576 lines
20 KiB
JavaScript
576 lines
20 KiB
JavaScript
import { INGREDIENTS, CATEGORY_LABELS, PRODUCTS, ingredientHasProducts } from '../data/catalog.js?v=8';
|
|
import { PANTRY_STORAGE_KEY, PANTRY_STORAGE_KEY_V2, SHOPPING_STORAGE_KEY } from '../storageKeys.js';
|
|
|
|
export const KITCHEN_LIST_ID = 'kitchen';
|
|
export const MISC_LIST_ID = 'misc';
|
|
|
|
function newId(prefix) {
|
|
if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
|
|
return crypto.randomUUID();
|
|
}
|
|
return `${prefix}${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
|
|
}
|
|
|
|
/** @typedef {{ id: string, ingredientId: string, productId?: string, name: string, amount: number, unit: string, category: string, checked: boolean, sourceNote?: string }} KitchenShoppingItem */
|
|
/** @typedef {{ id: string, text: string, note?: string, checked: boolean }} FreeformShoppingItem */
|
|
/** @typedef {{ id: string, name: string, type: 'kitchen'|'freeform', items: (KitchenShoppingItem|FreeformShoppingItem)[] }} ShoppingListDef */
|
|
|
|
/**
|
|
* @typedef {{
|
|
* lists: ShoppingListDef[],
|
|
* activeListId: string
|
|
* }} ShoppingState
|
|
*/
|
|
|
|
function defaultShoppingState() {
|
|
return {
|
|
lists: [
|
|
{ id: KITCHEN_LIST_ID, name: 'Kuchnia', type: 'kitchen', items: [] },
|
|
{ id: MISC_LIST_ID, name: 'Inne zakupy', type: 'freeform', items: [] },
|
|
],
|
|
activeListId: KITCHEN_LIST_ID,
|
|
};
|
|
}
|
|
|
|
/** @param {unknown} x */
|
|
function normalizeKitchenItem(x) {
|
|
if (!x || typeof x !== 'object') return null;
|
|
const o = /** @type {Record<string, unknown>} */ (x);
|
|
if (!o.ingredientId || !Number.isFinite(Number(o.amount))) return null;
|
|
const id = String(o.id && String(o.id).length ? o.id : newId('s'));
|
|
const ingId = String(o.ingredientId);
|
|
const item = {
|
|
id,
|
|
ingredientId: ingId,
|
|
name: String(o.name || INGREDIENTS[ingId]?.name || ingId),
|
|
amount: Math.round(Number(o.amount) * 100) / 100,
|
|
unit: String(o.unit || ''),
|
|
category: String(o.category || INGREDIENTS[ingId]?.category || 'inne'),
|
|
checked: Boolean(o.checked),
|
|
sourceNote: o.sourceNote ? String(o.sourceNote) : undefined,
|
|
};
|
|
if (o.productId && typeof o.productId === 'string' && PRODUCTS[o.productId]) {
|
|
item.productId = o.productId;
|
|
}
|
|
return item;
|
|
}
|
|
|
|
/** @param {unknown} x */
|
|
function normalizeFreeformItem(x) {
|
|
if (!x || typeof x !== 'object') return null;
|
|
const o = /** @type {Record<string, unknown>} */ (x);
|
|
if (!o.text || !String(o.text).trim()) return null;
|
|
return {
|
|
id: String(o.id && String(o.id).length ? o.id : newId('f')),
|
|
text: String(o.text).trim(),
|
|
note: o.note ? String(o.note) : undefined,
|
|
checked: Boolean(o.checked),
|
|
};
|
|
}
|
|
|
|
/** @returns {ShoppingState} */
|
|
function normalizeShoppingState(raw) {
|
|
const base = defaultShoppingState();
|
|
if (!raw || typeof raw !== 'object') return base;
|
|
const p = /** @type {Record<string, unknown>} */ (raw);
|
|
|
|
if (Array.isArray(p)) {
|
|
const items = p.map(normalizeKitchenItem).filter(Boolean);
|
|
const kitchen = base.lists.find((l) => l.id === KITCHEN_LIST_ID);
|
|
if (kitchen && kitchen.type === 'kitchen') {
|
|
kitchen.items = /** @type {KitchenShoppingItem[]} */ (items);
|
|
}
|
|
return base;
|
|
}
|
|
|
|
if (!Array.isArray(p.lists)) return base;
|
|
|
|
/** @type {ShoppingListDef[]} */
|
|
const lists = [];
|
|
for (const L of p.lists) {
|
|
if (!L || typeof L !== 'object') continue;
|
|
const row = /** @type {Record<string, unknown>} */ (L);
|
|
const id = String(row.id || '');
|
|
const name = String(row.name || 'Lista');
|
|
let type = row.type === 'freeform' ? 'freeform' : 'kitchen';
|
|
if (id === KITCHEN_LIST_ID) type = 'kitchen';
|
|
if (id === MISC_LIST_ID) type = 'freeform';
|
|
if (!id) continue;
|
|
if (type === 'kitchen') {
|
|
const items = Array.isArray(row.items)
|
|
? row.items.map(normalizeKitchenItem).filter(Boolean)
|
|
: [];
|
|
lists.push({ id, name, type: 'kitchen', items: /** @type {KitchenShoppingItem[]} */ (items) });
|
|
} else {
|
|
const items = Array.isArray(row.items)
|
|
? row.items.map(normalizeFreeformItem).filter(Boolean)
|
|
: [];
|
|
lists.push({ id, name, type: 'freeform', items: /** @type {FreeformShoppingItem[]} */ (items) });
|
|
}
|
|
}
|
|
|
|
if (lists.length === 0) return base;
|
|
|
|
const hasKitchen = lists.some((l) => l.id === KITCHEN_LIST_ID);
|
|
if (!hasKitchen) {
|
|
lists.unshift(/** @type {ShoppingListDef} */ (base.lists[0]));
|
|
}
|
|
const hasMisc = lists.some((l) => l.id === MISC_LIST_ID);
|
|
if (!hasMisc) {
|
|
lists.push(/** @type {ShoppingListDef} */ (base.lists[1]));
|
|
}
|
|
|
|
let activeListId = String(p.activeListId || KITCHEN_LIST_ID);
|
|
if (!lists.some((l) => l.id === activeListId)) activeListId = lists[0].id;
|
|
|
|
return { lists, activeListId };
|
|
}
|
|
|
|
export function loadShoppingState() {
|
|
try {
|
|
const raw = localStorage.getItem(SHOPPING_STORAGE_KEY);
|
|
if (!raw) return defaultShoppingState();
|
|
const parsed = JSON.parse(raw);
|
|
return normalizeShoppingState(parsed);
|
|
} catch {
|
|
return defaultShoppingState();
|
|
}
|
|
}
|
|
|
|
export function saveShoppingState(state) {
|
|
try {
|
|
localStorage.setItem(SHOPPING_STORAGE_KEY, JSON.stringify(state));
|
|
} catch { /* ignore */ }
|
|
}
|
|
|
|
export function getListSummaries() {
|
|
const { lists, activeListId } = loadShoppingState();
|
|
return {
|
|
lists: lists.map((l) => ({
|
|
id: l.id,
|
|
name: l.name,
|
|
type: l.type,
|
|
openCount: l.items.filter((i) => !i.checked).length,
|
|
})),
|
|
activeListId,
|
|
};
|
|
}
|
|
|
|
export function setActiveListId(listId) {
|
|
const s = loadShoppingState();
|
|
if (!s.lists.some((l) => l.id === listId)) return s;
|
|
s.activeListId = listId;
|
|
saveShoppingState(s);
|
|
return s;
|
|
}
|
|
|
|
export function getListById(listId) {
|
|
return loadShoppingState().lists.find((l) => l.id === listId) ?? null;
|
|
}
|
|
|
|
export function getActiveList() {
|
|
const s = loadShoppingState();
|
|
return s.lists.find((l) => l.id === s.activeListId) ?? s.lists[0];
|
|
}
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @returns {string} new list id
|
|
*/
|
|
export function addFreeformList(name) {
|
|
const s = loadShoppingState();
|
|
const id = newId('list');
|
|
s.lists.push({
|
|
id,
|
|
name: name.trim() || 'Nowa lista',
|
|
type: 'freeform',
|
|
items: [],
|
|
});
|
|
s.activeListId = id;
|
|
saveShoppingState(s);
|
|
return id;
|
|
}
|
|
|
|
/**
|
|
* @param {string} listId
|
|
* @returns {boolean}
|
|
*/
|
|
export function deleteList(listId) {
|
|
if (listId === KITCHEN_LIST_ID) return false;
|
|
const s = loadShoppingState();
|
|
const idx = s.lists.findIndex((l) => l.id === listId);
|
|
if (idx < 0) return false;
|
|
s.lists.splice(idx, 1);
|
|
if (s.activeListId === listId) {
|
|
s.activeListId = s.lists[0]?.id || KITCHEN_LIST_ID;
|
|
}
|
|
saveShoppingState(s);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Dodaje linie tylko do listy kuchennej (składniki z katalogu).
|
|
* @param {{ ingredientId: string, amount: number, unit: string, name?: string, category?: string, sourceNote?: string }[]} lines
|
|
* @param {string} [listId]
|
|
*/
|
|
export function addOrMergeShoppingLines(lines, listId = KITCHEN_LIST_ID) {
|
|
const s = loadShoppingState();
|
|
const list = s.lists.find((l) => l.id === listId && l.type === 'kitchen');
|
|
if (!list || list.type !== 'kitchen') return s;
|
|
|
|
const items = /** @type {KitchenShoppingItem[]} */ (list.items);
|
|
const open = items.filter((x) => !x.checked);
|
|
const closed = items.filter((x) => x.checked);
|
|
|
|
for (const L of lines) {
|
|
const def = INGREDIENTS[L.ingredientId];
|
|
const name = L.name || def?.name || L.ingredientId;
|
|
const category = L.category || def?.category || 'inne';
|
|
const productId = L.productId && PRODUCTS[L.productId] ? L.productId : undefined;
|
|
const productName = productId ? PRODUCTS[productId].name : null;
|
|
const displayName = productName || name;
|
|
const idx = open.findIndex(
|
|
(x) => x.ingredientId === L.ingredientId && x.unit === L.unit && (x.productId || '') === (productId || ''),
|
|
);
|
|
if (idx >= 0) {
|
|
open[idx].amount = Math.round((open[idx].amount + L.amount) * 100) / 100;
|
|
if (L.sourceNote && !open[idx].sourceNote) open[idx].sourceNote = L.sourceNote;
|
|
} else {
|
|
const item = {
|
|
id: newId('s'),
|
|
ingredientId: L.ingredientId,
|
|
name: displayName,
|
|
amount: Math.round(L.amount * 100) / 100,
|
|
unit: L.unit,
|
|
category,
|
|
checked: false,
|
|
sourceNote: L.sourceNote,
|
|
};
|
|
if (productId) item.productId = productId;
|
|
open.push(item);
|
|
}
|
|
}
|
|
|
|
list.items = [...open, ...closed];
|
|
saveShoppingState(s);
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* Na listę kuchenną ze spiżarni (amount w pantryUnit: g, ml lub szt.).
|
|
* @param {string} [sourceNote] — nadpisuje domyślne „Ze spiżarni”
|
|
*/
|
|
export function addIngredientToKitchenList(ingredientId, amount = 1, sourceNote) {
|
|
const def = INGREDIENTS[ingredientId];
|
|
if (!def) return;
|
|
const unit = displayUnit(def.pantryUnit);
|
|
addOrMergeShoppingLines([{
|
|
ingredientId,
|
|
amount,
|
|
unit,
|
|
name: def.name,
|
|
category: def.category,
|
|
sourceNote: sourceNote ?? 'Ze spiżarni',
|
|
}], KITCHEN_LIST_ID);
|
|
}
|
|
|
|
/**
|
|
* @param {string} listId
|
|
* @param {string} text
|
|
* @param {string} [note]
|
|
*/
|
|
export function addFreeformLine(listId, text, note) {
|
|
const t = text.trim();
|
|
if (!t) return;
|
|
const s = loadShoppingState();
|
|
const list = s.lists.find((l) => l.id === listId && l.type === 'freeform');
|
|
if (!list) return;
|
|
const items = /** @type {FreeformShoppingItem[]} */ (list.items);
|
|
items.push({
|
|
id: newId('f'),
|
|
text: t,
|
|
note: note?.trim() || undefined,
|
|
checked: false,
|
|
});
|
|
saveShoppingState(s);
|
|
}
|
|
|
|
export function toggleItemInList(listId, itemId) {
|
|
const s = loadShoppingState();
|
|
const list = s.lists.find((l) => l.id === listId);
|
|
if (!list) return s;
|
|
const it = list.items.find((i) => i.id === itemId);
|
|
if (it) it.checked = !it.checked;
|
|
saveShoppingState(s);
|
|
return s;
|
|
}
|
|
|
|
export function updateKitchenItemAmount(listId, itemId, newAmount) {
|
|
const s = loadShoppingState();
|
|
const list = s.lists.find((l) => l.id === listId && l.type === 'kitchen');
|
|
if (!list) return s;
|
|
const it = /** @type {KitchenShoppingItem[]} */ (list.items).find((i) => i.id === itemId);
|
|
if (!it) return s;
|
|
it.amount = Math.max(0, Math.round(newAmount * 100) / 100);
|
|
if (it.amount <= 0) {
|
|
list.items = list.items.filter((i) => i.id !== itemId);
|
|
}
|
|
saveShoppingState(s);
|
|
return s;
|
|
}
|
|
|
|
export function removeItemFromList(listId, itemId) {
|
|
const s = loadShoppingState();
|
|
const list = s.lists.find((l) => l.id === listId);
|
|
if (!list) return s;
|
|
list.items = list.items.filter((i) => i.id !== itemId);
|
|
saveShoppingState(s);
|
|
return s;
|
|
}
|
|
|
|
export function clearCheckedInList(listId) {
|
|
const s = loadShoppingState();
|
|
const list = s.lists.find((l) => l.id === listId);
|
|
if (!list) return s;
|
|
list.items = list.items.filter((i) => !i.checked);
|
|
saveShoppingState(s);
|
|
return s;
|
|
}
|
|
|
|
export function computeShortfalls(needLines, pantry = loadPantry()) {
|
|
const short = [];
|
|
for (const L of needLines) {
|
|
const def = INGREDIENTS[L.ingredientId];
|
|
if (!def) continue;
|
|
const u = normalizeUnitForPantry(L.unit, def.pantryUnit);
|
|
if (u === null) {
|
|
short.push({ ...L, pantryQty: 0, shortfall: L.amount, unitMismatch: true });
|
|
continue;
|
|
}
|
|
const have = getPantryTotal(L.ingredientId, pantry);
|
|
const miss = Math.max(0, Math.round((L.amount - have) * 100) / 100);
|
|
if (miss > 0) {
|
|
short.push({
|
|
...L,
|
|
unit: displayUnit(def.pantryUnit),
|
|
pantryQty: have,
|
|
shortfall: miss,
|
|
unitMismatch: false,
|
|
});
|
|
}
|
|
}
|
|
return short;
|
|
}
|
|
|
|
function displayUnit(pantryUnit) {
|
|
if (pantryUnit === 'szt') return 'szt.';
|
|
return pantryUnit;
|
|
}
|
|
|
|
function normalizeUnitForPantry(recipeUnit, pantryUnit) {
|
|
const r = String(recipeUnit).trim().toLowerCase().replace(/\.$/, '');
|
|
if (pantryUnit === 'g' && (r === 'g' || r === 'gram')) return 'g';
|
|
if (pantryUnit === 'ml' && (r === 'ml' || r === 'mililitr')) return 'ml';
|
|
if (pantryUnit === 'szt' && (r === 'szt' || r === 'sztuka' || r === 'kromki' || r === 'kromka')) return 'szt';
|
|
return null;
|
|
}
|
|
|
|
export function categoryLabel(cat) {
|
|
return CATEGORY_LABELS[cat] || CATEGORY_LABELS.inne;
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════════
|
|
* Pantry v2 — hybrydowy format.
|
|
*
|
|
* Wartość dla składnika może być:
|
|
* number — składnik bez produktów (generyczny)
|
|
* { _total, items: [{productId, qty}] } — składnik z produktami
|
|
*
|
|
* Brak pojęcia "generic" — jeśli składnik ma produkty, każda ilość
|
|
* musi być przypisana do konkretnego produktu.
|
|
* ══════════════════════════════════════════════════════════════════════ */
|
|
|
|
/** @typedef {{ productId: string, qty: number }} PantryProductItem */
|
|
/** @typedef {{ _total: number, items: PantryProductItem[] }} PantryProductEntry */
|
|
/** @typedef {Record<string, number | PantryProductEntry>} PantryV2 */
|
|
|
|
function recalcTotal(entry) {
|
|
entry._total = Math.round(entry.items.reduce((s, i) => s + i.qty, 0) * 1000) / 1000;
|
|
return entry;
|
|
}
|
|
|
|
function normalizePantryEntry(ingredientId, val) {
|
|
if (val && typeof val === 'object' && !Array.isArray(val)) {
|
|
const items = Array.isArray(val.items)
|
|
? val.items
|
|
.filter(i => i && typeof i.productId === 'string' && PRODUCTS[i.productId] && Number.isFinite(Number(i.qty)) && Number(i.qty) > 0)
|
|
.map(i => ({ productId: i.productId, qty: Math.round(Number(i.qty) * 1000) / 1000 }))
|
|
: [];
|
|
// Migrate generic stock → first product
|
|
const generic = Math.max(0, Number(val.generic) || 0);
|
|
if (generic > 0 && ingredientHasProducts(ingredientId)) {
|
|
const products = getProductsForIngredient(ingredientId);
|
|
if (products.length > 0) {
|
|
const firstPid = products[0].id;
|
|
const existing = items.find(i => i.productId === firstPid);
|
|
if (existing) existing.qty = Math.round((existing.qty + generic) * 1000) / 1000;
|
|
else items.push({ productId: firstPid, qty: Math.round(generic * 1000) / 1000 });
|
|
}
|
|
}
|
|
return recalcTotal({ items, _total: 0 });
|
|
}
|
|
const n = Number(val);
|
|
if (!Number.isFinite(n) || n < 0) return null;
|
|
if (ingredientHasProducts(ingredientId)) {
|
|
// Migrate number → first product
|
|
if (n > 0) {
|
|
const products = getProductsForIngredient(ingredientId);
|
|
if (products.length > 0) {
|
|
return recalcTotal({ items: [{ productId: products[0].id, qty: n }], _total: 0 });
|
|
}
|
|
}
|
|
return recalcTotal({ items: [], _total: 0 });
|
|
}
|
|
return n;
|
|
}
|
|
|
|
function migrateV1toV2() {
|
|
try {
|
|
const raw = localStorage.getItem(PANTRY_STORAGE_KEY);
|
|
if (!raw) return {};
|
|
const p = JSON.parse(raw);
|
|
if (typeof p !== 'object' || p === null) return {};
|
|
const out = {};
|
|
for (const [k, v] of Object.entries(p)) {
|
|
const norm = normalizePantryEntry(k, v);
|
|
if (norm !== null) out[k] = norm;
|
|
}
|
|
return out;
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
/** @returns {PantryV2} */
|
|
export function loadPantry() {
|
|
try {
|
|
const rawV2 = localStorage.getItem(PANTRY_STORAGE_KEY_V2);
|
|
if (rawV2) {
|
|
const p = JSON.parse(rawV2);
|
|
if (typeof p !== 'object' || p === null) return {};
|
|
const out = {};
|
|
for (const [k, v] of Object.entries(p)) {
|
|
const norm = normalizePantryEntry(k, v);
|
|
if (norm !== null) out[k] = norm;
|
|
}
|
|
return out;
|
|
}
|
|
const migrated = migrateV1toV2();
|
|
if (Object.keys(migrated).length > 0) {
|
|
savePantry(migrated);
|
|
}
|
|
return migrated;
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
/** @param {PantryV2} pantry */
|
|
export function savePantry(pantry) {
|
|
try {
|
|
localStorage.setItem(PANTRY_STORAGE_KEY_V2, JSON.stringify(pantry));
|
|
} catch { /* ignore */ }
|
|
}
|
|
|
|
/** Łączna ilość składnika (generyczna + produkty). */
|
|
export function getPantryTotal(ingredientId, pantry) {
|
|
const val = pantry[ingredientId];
|
|
if (val == null) return 0;
|
|
if (typeof val === 'number') return val;
|
|
return val._total || 0;
|
|
}
|
|
|
|
/** Lista produktów w spiżarni dla danego składnika. */
|
|
export function getPantryProducts(ingredientId, pantry) {
|
|
const val = pantry[ingredientId];
|
|
if (!val || typeof val === 'number') return [];
|
|
return val.items || [];
|
|
}
|
|
|
|
/** @deprecated No generic stock for ingredients with products. Returns 0 for those. */
|
|
export function getPantryGeneric(ingredientId, pantry) {
|
|
const val = pantry[ingredientId];
|
|
if (typeof val === 'number') return val;
|
|
return 0;
|
|
}
|
|
|
|
/** Ustaw ilość składnika BEZ produktów. Dla składników z produktami użyj setPantryProductQty. */
|
|
export function setPantryQty(ingredientId, qty) {
|
|
const pantry = loadPantry();
|
|
if (qty <= 0 || !Number.isFinite(qty)) delete pantry[ingredientId];
|
|
else pantry[ingredientId] = Math.round(qty * 1000) / 1000;
|
|
savePantry(pantry);
|
|
return pantry;
|
|
}
|
|
|
|
/** Ustaw ilość konkretnego produktu w spiżarni. */
|
|
export function setPantryProductQty(ingredientId, productId, qty) {
|
|
const pantry = loadPantry();
|
|
let val = pantry[ingredientId];
|
|
if (!val || typeof val === 'number') {
|
|
val = { items: [], _total: 0 };
|
|
pantry[ingredientId] = val;
|
|
}
|
|
const idx = val.items.findIndex(i => i.productId === productId);
|
|
const q = Math.max(0, Math.round(qty * 1000) / 1000);
|
|
if (q > 0) {
|
|
if (idx >= 0) val.items[idx].qty = q;
|
|
else val.items.push({ productId, qty: q });
|
|
} else {
|
|
if (idx >= 0) val.items.splice(idx, 1);
|
|
}
|
|
recalcTotal(val);
|
|
if (val._total <= 0) delete pantry[ingredientId];
|
|
savePantry(pantry);
|
|
return pantry;
|
|
}
|
|
|
|
/** Kupione ze listy kuchennej → spiżarnia (zawsze ta lista, niezależnie od aktywnej zakładki). */
|
|
export function applyCheckedKitchenListToPantry() {
|
|
const s = loadShoppingState();
|
|
const kitchen = s.lists.find((l) => l.id === KITCHEN_LIST_ID && l.type === 'kitchen');
|
|
if (!kitchen) return { pantry: loadPantry(), state: s };
|
|
|
|
const pantry = loadPantry();
|
|
const items = /** @type {KitchenShoppingItem[]} */ (kitchen.items);
|
|
|
|
for (const it of items) {
|
|
if (!it.checked) continue;
|
|
const def = INGREDIENTS[it.ingredientId];
|
|
if (!def) continue;
|
|
if (normalizeUnitForPantry(it.unit, def.pantryUnit) === null) continue;
|
|
|
|
if (it.productId && PRODUCTS[it.productId]) {
|
|
// Add to specific product
|
|
let val = pantry[it.ingredientId];
|
|
if (!val || typeof val === 'number') {
|
|
val = { items: [], _total: 0 };
|
|
pantry[it.ingredientId] = val;
|
|
}
|
|
const idx = val.items.findIndex(i => i.productId === it.productId);
|
|
if (idx >= 0) val.items[idx].qty = Math.round((val.items[idx].qty + it.amount) * 1000) / 1000;
|
|
else val.items.push({ productId: it.productId, qty: Math.round(it.amount * 1000) / 1000 });
|
|
recalcTotal(val);
|
|
} else {
|
|
// Generic ingredient (no products)
|
|
const cur = typeof pantry[it.ingredientId] === 'number' ? pantry[it.ingredientId] : 0;
|
|
pantry[it.ingredientId] = Math.round((cur + it.amount) * 1000) / 1000;
|
|
}
|
|
}
|
|
|
|
kitchen.items = items.filter((i) => !i.checked);
|
|
savePantry(pantry);
|
|
saveShoppingState(s);
|
|
return { pantry, state: s };
|
|
}
|