diff --git a/app/src/App.css b/app/src/App.css
index 58bd3514..6f949ac5 100644
--- a/app/src/App.css
+++ b/app/src/App.css
@@ -479,3 +479,68 @@ tr.drag-deselecting td {
color: rgba(0, 0, 0, 0.87) !important;
}
+
+/* Inventory "PDF" export: the printable table is hidden on screen and becomes the only
+ visible content when printing, so a user can use the browser dialog to Save as PDF. */
+.inventory-print {
+ display: none;
+}
+
+@media print {
+ body * {
+ visibility: hidden;
+ }
+
+ .inventory-print,
+ .inventory-print * {
+ visibility: visible;
+ }
+
+ .inventory-print {
+ display: block;
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+ color: #000;
+ }
+
+ .inventory-print h1 {
+ font-size: 18pt;
+ margin: 0 0 0.25em;
+ }
+
+ .inventory-print h2 {
+ font-size: 13pt;
+ margin: 1.25em 0 0.5em;
+ }
+
+ .inventory-print-meta {
+ font-size: 9pt;
+ color: #444;
+ margin: 0 0 0.75em;
+ }
+
+ .inventory-print table {
+ width: 100%;
+ border-collapse: collapse;
+ font-size: 10pt;
+ }
+
+ .inventory-print th,
+ .inventory-print td {
+ border: 1px solid #999;
+ padding: 4px 6px;
+ text-align: left;
+ vertical-align: top;
+ }
+
+ /* Repeat the header row at the top of each printed page. */
+ .inventory-print thead {
+ display: table-header-group;
+ }
+
+ .inventory-print tr {
+ page-break-inside: avoid;
+ }
+}
diff --git a/app/src/components/calculators/RationCalculator.js b/app/src/components/calculators/RationCalculator.js
index 6c35b4d1..448ce2cf 100644
--- a/app/src/components/calculators/RationCalculator.js
+++ b/app/src/components/calculators/RationCalculator.js
@@ -4,6 +4,8 @@ import Grid from "semantic-ui-react/dist/commonjs/collections/Grid";
import {Form, Header, Table} from "../Theme";
import {InfoPopup, roundDigits, useLocalStorage} from "../Common";
import {formatDuration} from "./WaterCalculator";
+// Field-role detection lives in inventory/summarize.js (single source of truth); re-exported here for back-compat.
+export {findCaloriesKey, findCountKey} from "../inventory/summarize";
// Pure calculation functions for the Ration (food storage) estimate.
//
@@ -46,27 +48,6 @@ export function daysOfFood(total, dailyDemand) {
return total / dailyDemand;
}
-// The calories field is detected by its dedicated `calories` type (falling back to a field literally keyed
-// "calories" for inventories created before the type existed).
-export function findCaloriesKey(fields) {
- const byType = (fields || []).find(f => f.type === 'calories');
- if (byType) {
- return byType.key;
- }
- const legacy = (fields || []).find(f => f.key === 'calories' && f.type === 'number');
- return legacy ? legacy.key : null;
-}
-
-// The count multiplier: prefer a number field keyed "count", else the first number field, else none (treat as 1).
-export function findCountKey(fields) {
- const count = (fields || []).find(f => f.type === 'number' && f.key === 'count');
- if (count) {
- return count.key;
- }
- const firstNumber = (fields || []).find(f => f.type === 'number');
- return firstNumber ? firstNumber.key : null;
-}
-
// Per-person daily calorie needs, by activity level. Adult figures are representative working-age values
// (ages 19-60) from the Dietary Guidelines for Americans 2020-2025, Appendix 2, Table A2-2 ("Estimated Calorie
// Needs per Day, by Age, Sex, and Physical Activity Level"), corroborated by the Merck Manuals table. The single
diff --git a/app/src/components/inventory/InventoryExportPanel.js b/app/src/components/inventory/InventoryExportPanel.js
new file mode 100644
index 00000000..601a40ee
--- /dev/null
+++ b/app/src/components/inventory/InventoryExportPanel.js
@@ -0,0 +1,60 @@
+import React from "react";
+import {Select} from "semantic-ui-react";
+import {Button, Header, Icon, Segment} from "../Theme";
+import {downloadCSV, inventoryExportFilename, toCSV} from "./inventoryExport";
+import {groupFieldsOf, summableFieldsOf} from "./summarize";
+
+const fieldOptions = (fs) => fs.map(f => ({key: f.key, value: f.key, text: f.label}));
+
+/**
+ * The "Export" tab: explains each export format and provides the action to produce it. CSV is the raw items table,
+ * generated entirely in the browser. "PDF" opens the print dialog over the hidden printable view (see
+ * InventoryPrint), which includes a summary table grouped by the field chosen here.
+ */
+export function InventoryExportPanel({name, fields, items, groupKey, sumKey, onGroupKey, onSumKey}) {
+ const count = (items || []).length;
+ const groupFields = groupFieldsOf(fields);
+ const summableFields = summableFieldsOf(fields);
+
+ const exportCSV = () =>
+ downloadCSV(inventoryExportFilename(name, 'csv'), toCSV(fields, items));
+
+ return <>
+
+
+
+ A comma-separated spreadsheet of all {count} item{count === 1 ? '' : 's'} and every field, openable
+ in Excel, Numbers, or Google Sheets. Generated entirely on this device.
+
+
+ Download CSV
+
+
+
+
+
+
+ A printable table of the whole inventory, followed by a summary grouped by the field you choose.
+ This opens your browser's print dialog — choose "Save as PDF" as the destination to get a PDF file,
+ or print it on paper.
+
+ {groupFields.length > 0 &&
+
+
+ Summary group:{' '}
+ onGroupKey(data.value)}/>
+
+ {summableFields.length > 0 &&
+
+ Sum:{' '}
+ onSumKey(data.value || undefined)}/>
+ }
+
}
+ window.print()} disabled={count === 0}>
+ Print / Save as PDF
+
+
+ >;
+}
diff --git a/app/src/components/inventory/InventoryPrint.js b/app/src/components/inventory/InventoryPrint.js
new file mode 100644
index 00000000..40e61419
--- /dev/null
+++ b/app/src/components/inventory/InventoryPrint.js
@@ -0,0 +1,57 @@
+import React from "react";
+import {formatValue} from "./InventoryTable";
+import {findCaloriesKey, findCountKey, summarizeInventory} from "./summarize";
+
+/**
+ * Printable rendering of a full inventory (every field, every item) plus a summary table grouped by `groupKey`,
+ * used for the "PDF" export via the browser's print dialog. It is hidden on screen
+ * (`.inventory-print { display: none }` in App.css) and becomes the only visible content when printing — so the
+ * user can "Save as PDF" without the app chrome.
+ */
+export function InventoryPrint({name, fields, items, groupKey, sumKey}) {
+ const cols = [...(fields || [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+ const list = items || [];
+ const printed = new Date().toLocaleString();
+
+ const caloriesKey = findCaloriesKey(fields);
+ const countKey = findCountKey(fields);
+ const summaryRows = summarizeInventory(list, {fields, groupKey, sumKey, countKey, caloriesKey});
+ const groupLabel = cols.find(f => f.key === groupKey)?.label || 'Group';
+
+ return
+
{name}
+
{list.length} item{list.length === 1 ? '' : 's'} · printed {printed}
+
+
+ {cols.map(f => {f.label || f.key} )}
+
+
+ {list.map(item =>
+ {cols.map(f => {formatValue(item, f)} )}
+ )}
+
+
+
+ {summaryRows.length > 0 && <>
+
Summary by {groupLabel}
+
+
+
+ {groupLabel}
+ Items
+ {sumKey && Total }
+ {caloriesKey && Calories }
+
+
+
+ {summaryRows.map(row =>
+ {row.name}
+ {row.count}
+ {sumKey && {row.total} }
+ {caloriesKey && {row.calories > 0 ? `${row.calories.toLocaleString()} kcal` : '—'} }
+ )}
+
+
+ >}
+
;
+}
diff --git a/app/src/components/inventory/InventoryPrint.test.js b/app/src/components/inventory/InventoryPrint.test.js
new file mode 100644
index 00000000..89edd97f
--- /dev/null
+++ b/app/src/components/inventory/InventoryPrint.test.js
@@ -0,0 +1,64 @@
+import React from "react";
+import {render} from "@testing-library/react";
+import {InventoryPrint} from "./InventoryPrint";
+
+const FIELDS = [
+ {key: 'name', label: 'Name', type: 'text', order: 0},
+ {key: 'category', label: 'Category', type: 'select', order: 1},
+ {key: 'item_size', label: 'Size', type: 'quantity', unit: 'lb', order: 2},
+ {key: 'count', label: 'Count', type: 'number', order: 3},
+ {key: 'calories', label: 'kcal', type: 'calories', order: 4},
+];
+
+const ITEMS = [
+ {id: 1, name: 'White Rice', category: 'grains', item_size: '30', item_size_unit: 'lb', count: '3', calories: '100'},
+ {id: 2, name: 'Oats', category: 'grains', item_size: '10', item_size_unit: 'lb', count: '2', calories: '50'},
+ {id: 3, name: 'Beans', category: 'legumes', item_size: '25', item_size_unit: 'lb', count: '1'},
+];
+
+describe('InventoryPrint', () => {
+ const tables = (container) => [...container.querySelectorAll('table')];
+
+ test('renders the full items table and a summary grouped by the chosen field', () => {
+ const {container} = render(
+ );
+
+ expect(container.querySelector('h1').textContent).toBe('Food Storage');
+ expect(container.querySelector('.inventory-print-meta').textContent).toMatch(/3 items/);
+
+ // Two tables: items, then summary.
+ const [itemsTable, summaryTable] = tables(container);
+ expect(itemsTable.querySelectorAll('tbody tr').length).toBe(3);
+
+ // Summary section header + grouped rows.
+ expect(container.querySelector('h2').textContent).toBe('Summary by Category');
+ const summaryRows = [...summaryTable.querySelectorAll('tbody tr')]
+ .map(tr => [...tr.querySelectorAll('td')].map(td => td.textContent));
+ // grains: 2 items, 110 lb, 400 kcal; legumes: 1 item, 25 lb, no calories.
+ expect(summaryRows).toEqual([
+ ['grains', '2', '110 lb', '400 kcal'],
+ ['legumes', '1', '25 lb', '—'],
+ ]);
+ });
+
+ test('summing a number field shows a plain column total', () => {
+ const {container} = render(
+ );
+ const summaryRows = [...tables(container)[1].querySelectorAll('tbody tr')]
+ .map(tr => [...tr.querySelectorAll('td')].map(td => td.textContent));
+ // grains: 2 items, count 3+2=5; legumes: 1 item, count 1.
+ expect(summaryRows).toEqual([
+ ['grains', '2', '5', '400 kcal'],
+ ['legumes', '1', '1', '—'],
+ ]);
+ });
+
+ test('omits the summary when there is no group key', () => {
+ const {container} = render(
+ );
+ expect(container.querySelector('h2')).toBeNull();
+ expect(tables(container).length).toBe(1);
+ });
+});
diff --git a/app/src/components/inventory/InventoryRoute.js b/app/src/components/inventory/InventoryRoute.js
index bd57cf22..9e8bd96f 100644
--- a/app/src/components/inventory/InventoryRoute.js
+++ b/app/src/components/inventory/InventoryRoute.js
@@ -1,11 +1,14 @@
-import React, {useState} from "react";
+import React, {useMemo, useState} from "react";
import {Dropdown, Input, Select} from "semantic-ui-react";
import {Button, Confirm, Header, Icon, Loader, Menu, Modal, Segment} from "../Theme";
import {PageContainer, useTitle} from "../Common";
import {collectLocations, useCatalog, useInventories} from "../../hooks/customHooks";
-import {InventoryTable} from "./InventoryTable";
+import {filterItems, InventoryTable} from "./InventoryTable";
import {InventoryItemsMobile} from "./InventoryItemsMobile";
import {InventorySummary} from "./InventorySummary";
+import {InventoryExportPanel} from "./InventoryExportPanel";
+import {InventoryPrint} from "./InventoryPrint";
+import {defaultGroupKey, defaultSumKey} from "./summarize";
import {FieldSchemaEditor} from "./FieldSchemaEditor";
import {CatalogEditor} from "./CatalogEditor";
import {Media} from "../../contexts/contexts";
@@ -62,6 +65,12 @@ export function InventoryRoute() {
const [renaming, setRenaming] = useState(false);
const [renameValue, setRenameValue] = useState('');
const [confirmDelete, setConfirmDelete] = useState(false);
+ // Grouping for the PDF export's summary table (chosen in the Export tab, rendered by the always-mounted print
+ // view). null until seeded from the current inventory's schema.
+ const [exportGroupKey, setExportGroupKey] = useState(null);
+ const [exportSumKey, setExportSumKey] = useState(null);
+ // Free-text filter applied to the active inventory's items across every column.
+ const [search, setSearch] = useState('');
// Default to the first inventory once loaded.
React.useEffect(() => {
@@ -71,8 +80,21 @@ export function InventoryRoute() {
}, [inventories, slug]);
const current = inventories?.find(i => i.slug === slug);
- const fields = current ? current.fields : [];
- const items = current ? current.items : [];
+ const fields = useMemo(() => (current ? current.fields : []), [current]);
+ const items = useMemo(() => (current ? current.items : []), [current]);
+
+ // Re-seed the export grouping when the selected inventory (or its schema) changes.
+ React.useEffect(() => {
+ setExportGroupKey(defaultGroupKey(fields));
+ setExportSumKey(defaultSumKey(fields));
+ }, [fields]);
+ // Clear the search when switching inventories.
+ React.useEffect(() => setSearch(''), [slug]);
+
+ // The search narrows the whole inventory view (Items display, Summary, Export); edits/adds in InventoryTable
+ // still operate on the full `items`, so filtering never drops data.
+ const filteredItems = useMemo(() => filterItems(items, fields, search), [items, fields, search]);
+
// Location suggestions are pooled across every inventory.
const locations = collectLocations(inventories);
@@ -133,27 +155,41 @@ export function InventoryRoute() {
>}
+ {current &&
+ setSearch(data.value)}/>}
{current ? <>
setTab('items')}/>
setTab('summary')}/>
+ setTab('export')}/>
- {tab === 'items'
- ? <>
- {/* Portrait mobile: condensed, read-only. Rotate to landscape (tablet+) for the full editor. */}
-
-
-
-
- persistInventory(slug, {items: newItems})}/>
-
- >
- : }
+ {tab === 'items' && <>
+ {/* Portrait mobile: condensed, read-only. Rotate to landscape (tablet+) for the full editor. */}
+
+
+
+
+ {/* The table gets the FULL items (so edits/adds don't drop filtered-out rows) plus the search,
+ which it applies to its displayed rows only. */}
+ persistInventory(slug, {items: newItems})}/>
+
+ >}
+ {tab === 'summary' && }
+ {tab === 'export' &&
+ }
+
+ {/* Always mounted (hidden on screen) so the browser print dialog has the full table + summary to render. */}
+
setEditFieldsOpen(false)}
diff --git a/app/src/components/inventory/InventorySummary.js b/app/src/components/inventory/InventorySummary.js
index 227ca00a..9cc32c43 100644
--- a/app/src/components/inventory/InventorySummary.js
+++ b/app/src/components/inventory/InventorySummary.js
@@ -1,22 +1,26 @@
import React, {useMemo, useState} from "react";
import {Select, TableBody, TableCell, TableHeader, TableHeaderCell, TableRow} from "semantic-ui-react";
import {Header, Segment, Table} from "../Theme";
-import {formatTotals, sumQuantities} from "./units";
-import {findCaloriesKey, findCountKey, RationEstimatePanel} from "../calculators/RationCalculator";
+import {RationEstimatePanel} from "../calculators/RationCalculator";
+import {
+ defaultGroupKey, defaultSumKey, findCaloriesKey, findCountKey, groupFieldsOf, sortSummaryRows,
+ summableFieldsOf, summarizeInventory,
+} from "./summarize";
import {ThemeContext} from "../../contexts/contexts";
-// Aggregate the inventory client-side: group items by a chosen text/select field and sum a chosen quantity field.
-// When the inventory has a `calories` field, a ration estimate is shown below the summary table.
+// Aggregate the inventory client-side: group items by a chosen text/select field and sum a chosen quantity, number,
+// or calories field. When the inventory has a `calories` field, a ration estimate is shown below the summary table.
+// The grouping math lives in summarize.js (shared with the PDF export).
export function InventorySummary({fields, items}) {
- const groupFields = fields.filter(f => ['text', 'select', 'location'].includes(f.type));
- const quantityFields = fields.filter(f => f.type === 'quantity');
+ const groupFields = groupFieldsOf(fields);
+ const summableFields = summableFieldsOf(fields);
const caloriesKey = findCaloriesKey(fields);
const countKey = findCountKey(fields);
const {t} = React.useContext(ThemeContext);
// Default to grouping by Category (easier to see grains/dairy/etc.), falling back to the first group field.
- const [groupKey, setGroupKey] = useState((groupFields.find(f => f.key === 'category') || groupFields[0])?.key);
- const [quantityKey, setQuantityKey] = useState(quantityFields[0]?.key);
+ const [groupKey, setGroupKey] = useState(defaultGroupKey(fields));
+ const [sumKey, setSumKey] = useState(defaultSumKey(fields));
const [sort, setSort] = useState({key: 'name', dir: 'asc'});
const toggleSort = (key) => setSort(prev =>
@@ -25,53 +29,9 @@ export function InventorySummary({fields, items}) {
: {key, dir: key === 'name' ? 'asc' : 'desc'});
const rows = useMemo(() => {
- if (!groupKey) {
- return [];
- }
- // A blank/zero count means a single unit (matches the ration estimate's convention).
- const unitsOf = (item) => {
- const c = countKey ? Number(item[countKey]) : 1;
- return c > 0 ? c : 1;
- };
- const groups = {};
- (items || []).forEach(item => {
- const key = item[groupKey] || '(none)';
- if (!groups[key]) {
- groups[key] = {entries: [], count: 0, calories: 0};
- }
- const group = groups[key];
- group.count += 1;
- const units = unitsOf(item);
- if (quantityKey) {
- // Total size = per-container size × count (the count field), so the summary matches reality.
- const size = Number(item[quantityKey]);
- group.entries.push({
- value: (size > 0 ? size : 0) * units,
- unit: item[`${quantityKey}_unit`],
- });
- }
- if (caloriesKey) {
- const cal = Number(item[caloriesKey]);
- if (cal > 0) {
- group.calories += cal * units;
- }
- }
- });
- const mapped = Object.entries(groups).map(([name, g]) => {
- const summed = sumQuantities(g.entries);
- // "Total" is a multi-unit string; keep a numeric proxy (sum of magnitudes + unitless) for sorting.
- const totalSort = (summed.totals || []).reduce((s, x) => s + x.magnitude, 0) + (summed.unitlessCount || 0);
- return {name, count: g.count, total: formatTotals(summed), totalSort, calories: g.calories};
- });
- const compare = (a, b) => {
- const r = sort.key === 'name' ? a.name.localeCompare(b.name)
- : sort.key === 'count' ? a.count - b.count
- : sort.key === 'total' ? a.totalSort - b.totalSort
- : a.calories - b.calories;
- return sort.dir === 'desc' ? -r : r;
- };
- return mapped.sort(compare);
- }, [items, groupKey, quantityKey, countKey, caloriesKey, sort]);
+ const summarized = summarizeInventory(items, {fields, groupKey, sumKey, countKey, caloriesKey});
+ return sortSummaryRows(summarized, sort);
+ }, [items, fields, groupKey, sumKey, countKey, caloriesKey, sort]);
const sortDir = (key) => sort.key === key ? (sort.dir === 'asc' ? 'ascending' : 'descending') : undefined;
@@ -89,11 +49,11 @@ export function InventorySummary({fields, items}) {
setGroupKey(data.value)}/>
- {quantityFields.length > 0 &&
+ {summableFields.length > 0 &&
Sum:{' '}
- setQuantityKey(data.value)}/>
+ setSumKey(data.value || undefined)}/>
}
@@ -105,8 +65,8 @@ export function InventorySummary({fields, items}) {
toggleSort('count')}
style={{cursor: 'pointer'}}>Items
- {quantityKey && toggleSort('total')}
- style={{cursor: 'pointer'}}>Total }
+ {sumKey && toggleSort('total')}
+ style={{cursor: 'pointer'}}>Total }
{caloriesKey && toggleSort('calories')}
style={{cursor: 'pointer'}}>Calories }
@@ -115,7 +75,7 @@ export function InventorySummary({fields, items}) {
{rows.map(row =>
{row.name}
{row.count}
- {quantityKey && {row.total} }
+ {sumKey && {row.total} }
{caloriesKey &&
{row.calories > 0 ? `${row.calories.toLocaleString()} kcal` : '—'} }
)}
diff --git a/app/src/components/inventory/InventoryTable.js b/app/src/components/inventory/InventoryTable.js
index f5cd983c..d75ae9c0 100644
--- a/app/src/components/inventory/InventoryTable.js
+++ b/app/src/components/inventory/InventoryTable.js
@@ -48,7 +48,7 @@ function compareByField(a, b, field) {
* inventory (the page holds every inventory and saves the changed one). A persistent "new item" row sits at the
* bottom: Tab moves between fields and Enter submits the item then refocuses the first field.
*/
-export function InventoryTable({slug, fields, items, locations, catalog, onChange}) {
+export function InventoryTable({slug, fields, items, locations, catalog, search, onChange}) {
const [draft, setDraft] = useState(() => emptyItem(fields));
const [edits, setEdits] = useState({}); // itemId -> edited copy
const [selected, setSelected] = useState(new Set());
@@ -120,6 +120,9 @@ export function InventoryTable({slug, fields, items, locations, catalog, onChang
return sort.dir === 'desc' ? sorted.reverse() : sorted;
}, [items, fields, sort]);
+ // The search filters which rows are shown; mutations below still operate on the full `items` prop.
+ const visibleItems = useMemo(() => filterItems(displayItems, fields, search), [displayItems, fields, search]);
+
const focusFirst = () => {
const node = firstInputRef.current;
if (node && node.focus) {
@@ -213,7 +216,7 @@ export function InventoryTable({slug, fields, items, locations, catalog, onChang
- {displayItems.map(item => {
+ {visibleItems.map(item => {
const editing = edits[item.id];
const expired = isExpired(item);
return
@@ -239,6 +242,12 @@ export function InventoryTable({slug, fields, items, locations, catalog, onChang
)}
;
})}
+ {search && visibleItems.length === 0 && (items || []).length > 0 &&
+
+
+ No items match "{search}".
+
+ }
{/* The persistent new-item entry row. */}
@@ -289,3 +298,21 @@ export function isItemExpired(item, fields) {
return !isNaN(t) && t < start.getTime();
});
}
+
+/**
+ * Filter items by a free-text search across every column's displayed value (using the same formatting as the
+ * table, so quantities match as "30 lb", dates as "2030-01-01", etc.). Case-insensitive; whitespace-separated
+ * terms are AND-ed. A blank search returns all items. Shared by the Items table, Summary, and export views.
+ */
+export function filterItems(items, fields, search) {
+ const query = (search || '').trim().toLowerCase();
+ if (!query) {
+ return items || [];
+ }
+ const terms = query.split(/\s+/);
+ const cols = [...(fields || [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+ return (items || []).filter(item => {
+ const haystack = cols.map(f => formatValue(item, f)).join(' ').toLowerCase();
+ return terms.every(term => haystack.includes(term));
+ });
+}
diff --git a/app/src/components/inventory/InventoryTable.test.js b/app/src/components/inventory/InventoryTable.test.js
index e611d275..d49b26fe 100644
--- a/app/src/components/inventory/InventoryTable.test.js
+++ b/app/src/components/inventory/InventoryTable.test.js
@@ -1,6 +1,6 @@
import React from "react";
import {fireEvent, render, screen} from "@testing-library/react";
-import {InventoryTable} from "./InventoryTable";
+import {filterItems, InventoryTable} from "./InventoryTable";
const FIELDS = [
{key: 'name', label: 'Name', type: 'text', order: 0},
@@ -141,3 +141,91 @@ describe('InventoryTable expired highlighting', () => {
expect(container.querySelectorAll('i.warning.sign.icon').length).toBe(1);
});
});
+
+describe('filterItems', () => {
+ const FIELDS = [
+ {key: 'name', label: 'Name', type: 'text', order: 0},
+ {key: 'category', label: 'Category', type: 'select', order: 1},
+ {key: 'item_size', label: 'Size', type: 'quantity', unit: 'lb', order: 2},
+ {key: 'count', label: 'Count', type: 'number', order: 3},
+ {key: 'expiration_date', label: 'Expires', type: 'date', order: 4},
+ ];
+ const ITEMS = [
+ {id: 1, name: 'White Rice', category: 'grains', item_size: '30', item_size_unit: 'lb', count: '3',
+ expiration_date: '2030-01-01'},
+ {id: 2, name: 'Pinto Beans', category: 'legumes', item_size: '25', item_size_unit: 'lb', count: '2',
+ expiration_date: '2033-01-01'},
+ {id: 3, name: 'Canned Chicken', category: 'meats', item_size: '12.5', item_size_unit: 'oz', count: '12',
+ expiration_date: '2030-06-01'},
+ ];
+ const names = (rows) => rows.map(r => r.name);
+
+ test('blank or whitespace search returns all items', () => {
+ expect(filterItems(ITEMS, FIELDS, '')).toHaveLength(3);
+ expect(filterItems(ITEMS, FIELDS, ' ')).toHaveLength(3);
+ });
+
+ test('matches a text column, case-insensitively', () => {
+ expect(names(filterItems(ITEMS, FIELDS, 'rice'))).toEqual(['White Rice']);
+ expect(names(filterItems(ITEMS, FIELDS, 'RICE'))).toEqual(['White Rice']);
+ });
+
+ test('matches a select column (category)', () => {
+ expect(names(filterItems(ITEMS, FIELDS, 'legumes'))).toEqual(['Pinto Beans']);
+ });
+
+ test('matches a date column', () => {
+ expect(names(filterItems(ITEMS, FIELDS, '2030'))).toEqual(['White Rice', 'Canned Chicken']);
+ });
+
+ test('matches a quantity column by its formatted value', () => {
+ expect(names(filterItems(ITEMS, FIELDS, '25 lb'))).toEqual(['Pinto Beans']);
+ });
+
+ test('whitespace-separated terms are AND-ed', () => {
+ expect(names(filterItems(ITEMS, FIELDS, 'canned chicken'))).toEqual(['Canned Chicken']);
+ expect(filterItems(ITEMS, FIELDS, 'rice beans')).toEqual([]);
+ });
+
+ test('a non-matching search returns nothing', () => {
+ expect(filterItems(ITEMS, FIELDS, 'xyzzy')).toEqual([]);
+ });
+});
+
+describe('InventoryTable search', () => {
+ const FIELDS = [
+ {key: 'name', label: 'Name', type: 'text', order: 0},
+ {key: 'count', label: 'Count', type: 'number', order: 1},
+ ];
+ const items = [
+ {id: 1, name: 'White Rice', count: '3'},
+ {id: 2, name: 'Pinto Beans', count: '2'},
+ ];
+
+ test('only matching rows are rendered, and the entry row remains', () => {
+ render();
+ expect(screen.getByText('White Rice')).toBeTruthy();
+ expect(screen.queryByText('Pinto Beans')).toBeNull();
+ // The persistent draft entry row is still present.
+ expect(screen.getAllByLabelText('Name').length).toBeGreaterThan(0);
+ });
+
+ test('adding from the entry row while filtered preserves the hidden items', () => {
+ const onChange = jest.fn();
+ render();
+ const draftName = screen.getAllByLabelText('Name').slice(-1)[0];
+ fireEvent.change(draftName, {target: {value: 'Oats'}});
+ fireEvent.keyDown(draftName, {key: 'Enter'});
+ // onChange gets the FULL inventory (both originals + new), not just the filtered view.
+ const newItems = onChange.mock.calls[0][0];
+ expect(newItems.map(i => i.name)).toEqual(['White Rice', 'Pinto Beans', 'Oats']);
+ });
+
+ test('a non-matching search shows a no-match message', () => {
+ render();
+ expect(screen.getByText(/no items match/i)).toBeTruthy();
+ });
+});
diff --git a/app/src/components/inventory/inventoryExport.js b/app/src/components/inventory/inventoryExport.js
new file mode 100644
index 00000000..ba3c804d
--- /dev/null
+++ b/app/src/components/inventory/inventoryExport.js
@@ -0,0 +1,48 @@
+import {formatValue} from "./InventoryTable";
+
+// Fields in display (column) order.
+function orderedFields(fields) {
+ return [...(fields || [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
+
+// Quote a single CSV cell per RFC 4180: wrap in double-quotes (escaping internal quotes by doubling) when the value
+// contains a comma, quote, or newline.
+function escapeCell(value) {
+ const s = value == null ? '' : String(value);
+ return /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+/**
+ * Build an RFC-4180 CSV string for an inventory: a header row of field labels followed by one row per item, using
+ * the same value formatting as the on-screen table (quantity fields render as ` `).
+ */
+export function toCSV(fields, items) {
+ const cols = orderedFields(fields);
+ const header = cols.map(f => escapeCell(f.label || f.key));
+ const rows = (items || []).map(item => cols.map(f => escapeCell(formatValue(item, f))));
+ return [header, ...rows].map(row => row.join(',')).join('\r\n');
+}
+
+// Filesystem-safe export filename derived from the inventory name (e.g. "Food Storage" -> "food-storage.csv").
+export function inventoryExportFilename(name, ext) {
+ const base = (name || 'inventory').trim().toLowerCase()
+ .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'inventory';
+ return `${base}.${ext}`;
+}
+
+// Trigger a browser download of `csv` as `filename`. A UTF-8 BOM is prepended so spreadsheet apps (notably Excel)
+// detect the encoding and render non-ASCII characters correctly.
+export function downloadCSV(filename, csv) {
+ const BOM = String.fromCharCode(0xFEFF);
+ const blob = new Blob([BOM + csv], {type: 'text/csv;charset=utf-8'});
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = filename;
+ // The anchor must be attached to the document for click() to trigger a download in some browsers, and the
+ // object URL must stay alive until the browser has started fetching it — so revoke on the next tick.
+ document.body.appendChild(a);
+ a.click();
+ document.body.removeChild(a);
+ setTimeout(() => URL.revokeObjectURL(url), 0);
+}
diff --git a/app/src/components/inventory/inventoryExport.test.js b/app/src/components/inventory/inventoryExport.test.js
new file mode 100644
index 00000000..09d94164
--- /dev/null
+++ b/app/src/components/inventory/inventoryExport.test.js
@@ -0,0 +1,61 @@
+import {inventoryExportFilename, toCSV} from "./inventoryExport";
+
+const FIELDS = [
+ {key: 'name', label: 'Name', type: 'text', order: 0},
+ {key: 'item_size', label: 'Size', type: 'quantity', unit: 'lb', order: 1},
+ {key: 'count', label: 'Count', type: 'number', order: 2},
+];
+
+describe('toCSV', () => {
+ test('emits a header row of labels then one row per item, in field order', () => {
+ const items = [
+ {id: 1, name: 'White Rice', item_size: '30', item_size_unit: 'lb', count: '3'},
+ {id: 2, name: 'Honey', item_size: '12', item_size_unit: 'lb', count: '1'},
+ ];
+ expect(toCSV(FIELDS, items)).toBe(
+ 'Name,Size,Count\r\n' +
+ 'White Rice,30 lb,3\r\n' +
+ 'Honey,12 lb,1'
+ );
+ });
+
+ test('orders columns by field order, not array order', () => {
+ const unordered = [
+ {key: 'count', label: 'Count', type: 'number', order: 2},
+ {key: 'name', label: 'Name', type: 'text', order: 0},
+ ];
+ const csv = toCSV(unordered, [{id: 1, name: 'Salt', count: '5'}]);
+ expect(csv.split('\r\n')[0]).toBe('Name,Count');
+ expect(csv.split('\r\n')[1]).toBe('Salt,5');
+ });
+
+ test('quotes values containing commas, quotes, or newlines (RFC 4180)', () => {
+ const fields = [{key: 'name', label: 'Name', type: 'text', order: 0}];
+ expect(toCSV(fields, [{id: 1, name: 'Beans, dried'}]).split('\r\n')[1])
+ .toBe('"Beans, dried"');
+ expect(toCSV(fields, [{id: 1, name: 'Bob\'s "Best"'}]).split('\r\n')[1])
+ .toBe('"Bob\'s ""Best"""');
+ expect(toCSV(fields, [{id: 1, name: 'line1\nline2'}]).split('\r\n').slice(1).join('\r\n'))
+ .toBe('"line1\nline2"');
+ });
+
+ test('blank/missing values render as empty cells', () => {
+ expect(toCSV(FIELDS, [{id: 1, name: 'Salt'}])).toBe('Name,Size,Count\r\nSalt,,');
+ });
+
+ test('no items yields just the header row', () => {
+ expect(toCSV(FIELDS, [])).toBe('Name,Size,Count');
+ });
+});
+
+describe('inventoryExportFilename', () => {
+ test('slugifies the inventory name with the given extension', () => {
+ expect(inventoryExportFilename('Food Storage', 'csv')).toBe('food-storage.csv');
+ expect(inventoryExportFilename(' My Tools!! ', 'csv')).toBe('my-tools.csv');
+ });
+
+ test('falls back to "inventory" for an empty name', () => {
+ expect(inventoryExportFilename('', 'csv')).toBe('inventory.csv');
+ expect(inventoryExportFilename(null, 'csv')).toBe('inventory.csv');
+ });
+});
diff --git a/app/src/components/inventory/summarize.js b/app/src/components/inventory/summarize.js
new file mode 100644
index 00000000..63844ab9
--- /dev/null
+++ b/app/src/components/inventory/summarize.js
@@ -0,0 +1,144 @@
+import {formatTotals, sumQuantities} from "./units";
+
+// Field-role detection and client-side aggregation for an inventory. This is the single source of truth shared by
+// the Summary tab, the PDF export, and the ration calculator — the backend stores raw items and does no aggregation.
+
+// Fields the summary can group by (categorical), in schema order.
+export function groupFieldsOf(fields) {
+ return (fields || []).filter(f => ['text', 'select', 'location'].includes(f.type));
+}
+
+// Fields the summary can sum, in schema order: quantity (unit-aware), plus number and calories (plain totals).
+export function summableFieldsOf(fields) {
+ return (fields || []).filter(f => ['quantity', 'number', 'calories'].includes(f.type));
+}
+
+// Default grouping: prefer Category (so grains/dairy/etc. are visible), else the first group field.
+export function defaultGroupKey(fields) {
+ const groups = groupFieldsOf(fields);
+ return (groups.find(f => f.key === 'category') || groups[0])?.key;
+}
+
+// Default field to sum: the first quantity field, else the first number, else the first calories field.
+export function defaultSumKey(fields) {
+ const summable = summableFieldsOf(fields);
+ for (const type of ['quantity', 'number', 'calories']) {
+ const f = summable.find(s => s.type === type);
+ if (f) {
+ return f.key;
+ }
+ }
+ return undefined;
+}
+
+// The calories field is detected by its dedicated `calories` type (falling back to a field literally keyed
+// "calories" for inventories created before the type existed).
+export function findCaloriesKey(fields) {
+ const byType = (fields || []).find(f => f.type === 'calories');
+ if (byType) {
+ return byType.key;
+ }
+ const legacy = (fields || []).find(f => f.key === 'calories' && f.type === 'number');
+ return legacy ? legacy.key : null;
+}
+
+// The count multiplier: prefer a number field keyed "count", else the first number field, else none (treat as 1).
+export function findCountKey(fields) {
+ const count = (fields || []).find(f => f.type === 'number' && f.key === 'count');
+ if (count) {
+ return count.key;
+ }
+ const firstNumber = (fields || []).find(f => f.type === 'number');
+ return firstNumber ? firstNumber.key : null;
+}
+
+// Parse an item's field value into a finite number, or null when blank/non-numeric.
+function numericValue(item, key) {
+ const raw = item[key];
+ if (raw === '' || raw == null) {
+ return null;
+ }
+ const n = Number(raw);
+ return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * Group items by `groupKey` and aggregate each group, returning rows sorted by group name.
+ *
+ * The "Total" depends on the summed field's type (looked up in `fields`):
+ * - `quantity` → count-aware, unit-compacted (Σ per-container size × count), e.g. "110 lb".
+ * - `number`/`calories`→ a plain column total of the raw values (Σ value, NOT × count), e.g. "280".
+ * The dedicated `calories` total in each row stays count-aware (Σ per-unit calories × count), independent of the
+ * chosen sum field.
+ *
+ * Each row: {name, count, total, totalSort, calories}. Returns [] when there is no group field. A blank/zero
+ * count is treated as a single unit (matches the ration estimate's convention).
+ */
+export function summarizeInventory(items, {fields, groupKey, sumKey, countKey, caloriesKey}) {
+ if (!groupKey) {
+ return [];
+ }
+ const sumType = (fields || []).find(f => f.key === sumKey)?.type;
+ const isQuantitySum = sumType === 'quantity';
+ const unitsOf = (item) => {
+ const c = countKey ? Number(item[countKey]) : 1;
+ return c > 0 ? c : 1;
+ };
+ const groups = {};
+ (items || []).forEach(item => {
+ const key = item[groupKey] || '(none)';
+ if (!groups[key]) {
+ groups[key] = {entries: [], plainTotal: 0, hasPlain: false, count: 0, calories: 0};
+ }
+ const group = groups[key];
+ group.count += 1;
+ const units = unitsOf(item);
+ if (sumKey && isQuantitySum) {
+ const size = Number(item[sumKey]);
+ group.entries.push({
+ value: (size > 0 ? size : 0) * units,
+ unit: item[`${sumKey}_unit`],
+ });
+ } else if (sumKey) {
+ // number / calories: a plain sum of the column's raw values.
+ const n = numericValue(item, sumKey);
+ if (n !== null) {
+ group.plainTotal += n;
+ group.hasPlain = true;
+ }
+ }
+ if (caloriesKey) {
+ const cal = Number(item[caloriesKey]);
+ if (cal > 0) {
+ group.calories += cal * units;
+ }
+ }
+ });
+ return Object.entries(groups).map(([name, g]) => {
+ let total, totalSort;
+ if (sumKey && isQuantitySum) {
+ const summed = sumQuantities(g.entries);
+ total = formatTotals(summed);
+ totalSort = (summed.totals || []).reduce((s, x) => s + x.magnitude, 0) + (summed.unitlessCount || 0);
+ } else if (sumKey) {
+ total = g.hasPlain ? g.plainTotal.toLocaleString() : '—';
+ totalSort = g.plainTotal;
+ } else {
+ total = '—';
+ totalSort = 0;
+ }
+ return {name, count: g.count, total, totalSort, calories: g.calories};
+ }).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// Return a copy of summary rows sorted by the given column (`name`|`count`|`total`|`calories`) and direction.
+export function sortSummaryRows(rows, sort) {
+ const compare = (a, b) => {
+ const r = sort.key === 'name' ? a.name.localeCompare(b.name)
+ : sort.key === 'count' ? a.count - b.count
+ : sort.key === 'total' ? a.totalSort - b.totalSort
+ : a.calories - b.calories;
+ return sort.dir === 'desc' ? -r : r;
+ };
+ return [...rows].sort(compare);
+}
diff --git a/app/src/components/inventory/summarize.test.js b/app/src/components/inventory/summarize.test.js
new file mode 100644
index 00000000..9445879c
--- /dev/null
+++ b/app/src/components/inventory/summarize.test.js
@@ -0,0 +1,142 @@
+import {
+ defaultGroupKey, defaultSumKey, findCaloriesKey, findCountKey, groupFieldsOf, sortSummaryRows,
+ summableFieldsOf, summarizeInventory,
+} from "./summarize";
+
+const FIELDS = [
+ {key: 'name', label: 'Name', type: 'text', order: 0},
+ {key: 'category', label: 'Category', type: 'select', order: 1},
+ {key: 'item_size', label: 'Size', type: 'quantity', unit: 'lb', order: 2},
+ {key: 'count', label: 'Count', type: 'number', order: 3},
+ {key: 'calories', label: 'kcal', type: 'calories', order: 4},
+];
+
+const ITEMS = [
+ {id: 1, name: 'White Rice', category: 'grains', item_size: '30', item_size_unit: 'lb', count: '3', calories: '100'},
+ {id: 2, name: 'Oats', category: 'grains', item_size: '10', item_size_unit: 'lb', count: '2', calories: '50'},
+ {id: 3, name: 'Beans', category: 'legumes', item_size: '25', item_size_unit: 'lb', count: '1', calories: '0'},
+];
+
+describe('field-role helpers', () => {
+ test('groupFieldsOf picks categorical (text/select/location) fields', () => {
+ expect(groupFieldsOf(FIELDS).map(f => f.key)).toEqual(['name', 'category']);
+ });
+
+ test('summableFieldsOf includes quantity, number, and calories fields', () => {
+ expect(summableFieldsOf(FIELDS).map(f => f.key)).toEqual(['item_size', 'count', 'calories']);
+ });
+
+ test('defaults: group by Category, sum the first quantity field', () => {
+ expect(defaultGroupKey(FIELDS)).toBe('category');
+ expect(defaultSumKey(FIELDS)).toBe('item_size');
+ });
+
+ test('defaultGroupKey falls back to the first group field when no Category', () => {
+ const noCat = [{key: 'fuel_type', label: 'Fuel', type: 'select', order: 0}];
+ expect(defaultGroupKey(noCat)).toBe('fuel_type');
+ });
+
+ test('defaultSumKey falls back to a number field when there is no quantity field', () => {
+ const noQty = [{key: 'qty', label: 'Qty', type: 'number', order: 0}];
+ expect(defaultSumKey(noQty)).toBe('qty');
+ });
+
+ test('findCaloriesKey / findCountKey detect by type/key', () => {
+ expect(findCaloriesKey(FIELDS)).toBe('calories');
+ expect(findCountKey(FIELDS)).toBe('count');
+ });
+});
+
+describe('summarizeInventory', () => {
+ test('quantity sum is count-aware and unit-compacted, with grouped calories', () => {
+ const rows = summarizeInventory(ITEMS, {
+ fields: FIELDS, groupKey: 'category', sumKey: 'item_size', countKey: 'count', caloriesKey: 'calories',
+ });
+ expect(rows.map(r => r.name)).toEqual(['grains', 'legumes']);
+
+ const grains = rows.find(r => r.name === 'grains');
+ expect(grains.count).toBe(2);
+ expect(grains.total).toBe('110 lb'); // 30×3 + 10×2
+ expect(grains.calories).toBe(400); // 100×3 + 50×2
+
+ const legumes = rows.find(r => r.name === 'legumes');
+ expect(legumes.total).toBe('25 lb'); // 25×1
+ expect(legumes.calories).toBe(0);
+ });
+
+ test('number sum is a plain column total (NOT multiplied by count)', () => {
+ const rows = summarizeInventory(ITEMS, {
+ fields: FIELDS, groupKey: 'category', sumKey: 'count', countKey: 'count',
+ });
+ expect(rows.find(r => r.name === 'grains').total).toBe('5'); // 3 + 2
+ expect(rows.find(r => r.name === 'legumes').total).toBe('1');
+ });
+
+ test('calories sum is a plain column total of the per-unit values', () => {
+ const rows = summarizeInventory(ITEMS, {
+ fields: FIELDS, groupKey: 'category', sumKey: 'calories', countKey: 'count',
+ });
+ expect(rows.find(r => r.name === 'grains').total).toBe('150'); // 100 + 50, not ×count
+ expect(rows.find(r => r.name === 'legumes').total).toBe('0');
+ });
+
+ test('a large plain total is formatted with grouping separators', () => {
+ const fields = [{key: 'g', type: 'select'}, {key: 'count', type: 'number'}];
+ const items = [{id: 1, g: 'x', count: '1500'}, {id: 2, g: 'x', count: '2500'}];
+ const rows = summarizeInventory(items, {fields, groupKey: 'g', sumKey: 'count'});
+ expect(rows[0].total).toBe((4000).toLocaleString());
+ });
+
+ test('a plain total with no numeric values shows —', () => {
+ const fields = [{key: 'g', type: 'select'}, {key: 'count', type: 'number'}];
+ const items = [{id: 1, g: 'x'}, {id: 2, g: 'x', count: ''}];
+ const rows = summarizeInventory(items, {fields, groupKey: 'g', sumKey: 'count'});
+ expect(rows[0].total).toBe('—');
+ });
+
+ test('blank/zero count counts as a single unit for quantity sums', () => {
+ const fields = [{key: 'g', type: 'select'}, {key: 'item_size', type: 'quantity', unit: 'lb'},
+ {key: 'count', type: 'number'}];
+ const items = [{id: 1, g: 'grains', item_size: '5', item_size_unit: 'lb', count: ''}];
+ const rows = summarizeInventory(items, {fields, groupKey: 'g', sumKey: 'item_size', countKey: 'count'});
+ expect(rows[0].total).toBe('5 lb');
+ });
+
+ test('missing group values bucket under "(none)"', () => {
+ const fields = [{key: 'name', type: 'text'}, {key: 'category', type: 'select'},
+ {key: 'item_size', type: 'quantity', unit: 'lb'}];
+ const items = [{id: 1, name: 'x', item_size: '5', item_size_unit: 'lb'}];
+ const rows = summarizeInventory(items, {fields, groupKey: 'category', sumKey: 'item_size'});
+ expect(rows[0].name).toBe('(none)');
+ });
+
+ test('returns [] when there is no group key', () => {
+ expect(summarizeInventory(ITEMS, {fields: FIELDS, groupKey: undefined})).toEqual([]);
+ });
+
+ test('no sum key yields a — total', () => {
+ const rows = summarizeInventory(ITEMS, {fields: FIELDS, groupKey: 'category'});
+ expect(rows.every(r => r.total === '—')).toBe(true);
+ });
+});
+
+describe('sortSummaryRows', () => {
+ const rows = [
+ {name: 'grains', count: 2, totalSort: 110, calories: 400},
+ {name: 'legumes', count: 1, totalSort: 25, calories: 0},
+ ];
+
+ test('sorts by count descending', () => {
+ expect(sortSummaryRows(rows, {key: 'count', dir: 'desc'}).map(r => r.name)).toEqual(['grains', 'legumes']);
+ });
+
+ test('sorts by total ascending', () => {
+ expect(sortSummaryRows(rows, {key: 'total', dir: 'asc'}).map(r => r.name)).toEqual(['legumes', 'grains']);
+ });
+
+ test('does not mutate the input array', () => {
+ const copy = [...rows];
+ sortSummaryRows(rows, {key: 'calories', dir: 'desc'});
+ expect(rows).toEqual(copy);
+ });
+});