feat: implement remaining TODO.md feature ideas + fix mobile headers

Implements the six previously-unscoped feature ideas plus a mobile
layout fix reported via screenshot:

- Mobile: Recipes/Collections/Pantry/Meal Plan/Shopping Lists headers
  now stack and wrap instead of clipping buttons on narrow viewports.
- Recipe diff/compare view: word/list diff against any past version,
  next to Restore in version history.
- Shared meal plans & shopping lists: new shoppingListMembers/
  mealPlanMembers tables (viewer/editor roles, mirrors
  collectionMembers), share dialogs, membership-checked routes.
- PDF cookbook export: /print/collection/[id] renders a whole
  collection with page breaks, using the existing print-CSS pattern
  instead of adding a PDF rendering dependency.
- Grocery delivery handoff: shopping lists can copy-as-text (works
  today) or send to Instacart once INSTACART_API_KEY is configured
  (stub adapter — real API needs a partner agreement).
- Personalized "For You" feed tab: ranks public recipes by tag/
  dietary overlap with the user's favorited/highly-rated history.
- PWA: added manifest.json + icons on top of the existing service
  worker so the app is installable; cook-mode pages were already
  cached for offline use.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Arnaud
2026-07-02 12:13:00 +02:00
parent d2faf98ac1
commit e5d1080fb9
56 changed files with 6096 additions and 74 deletions
@@ -0,0 +1,56 @@
import { describe, it, expect } from "vitest";
import { buildPreferenceMap, scoreCandidate, rankForYou } from "../for-you-ranking";
describe("buildPreferenceMap", () => {
it("counts tags and true dietary-tag keys across liked recipes", () => {
const map = buildPreferenceMap([
{ tags: ["spicy", "quick"], dietaryTags: { vegan: true, glutenFree: false } },
{ tags: ["spicy"], dietaryTags: null },
]);
expect(map.get("spicy")).toBe(2);
expect(map.get("quick")).toBe(1);
expect(map.get("vegan")).toBe(1);
expect(map.get("glutenFree")).toBeUndefined();
});
it("returns an empty map for no liked recipes", () => {
expect(buildPreferenceMap([]).size).toBe(0);
});
});
describe("scoreCandidate", () => {
it("sums preference weights for overlapping tags", () => {
const prefs = new Map([["spicy", 3], ["vegan", 1]]);
const score = scoreCandidate({ tags: ["spicy"], dietaryTags: { vegan: true } }, prefs);
expect(score).toBe(4);
});
it("scores 0 when nothing overlaps", () => {
const prefs = new Map([["spicy", 3]]);
expect(scoreCandidate({ tags: ["sweet"], dietaryTags: null }, prefs)).toBe(0);
});
});
describe("rankForYou", () => {
const base = { dietaryTags: null };
it("sorts by score descending", () => {
const prefs = new Map([["spicy", 5]]);
const candidates = [
{ id: "a", tags: ["sweet"], createdAt: new Date("2024-01-01"), ...base },
{ id: "b", tags: ["spicy"], createdAt: new Date("2024-01-01"), ...base },
];
const ranked = rankForYou(candidates, prefs);
expect(ranked.map((r) => r.id)).toEqual(["b", "a"]);
});
it("breaks ties by recency", () => {
const prefs = new Map<string, number>();
const candidates = [
{ id: "old", tags: [], createdAt: new Date("2024-01-01"), ...base },
{ id: "new", tags: [], createdAt: new Date("2024-06-01"), ...base },
];
const ranked = rankForYou(candidates, prefs);
expect(ranked.map((r) => r.id)).toEqual(["new", "old"]);
});
});
@@ -0,0 +1,29 @@
import { describe, it, expect } from "vitest";
import { buildGroceryExportPayload, groceryExportToText } from "../grocery-export";
describe("buildGroceryExportPayload", () => {
it("maps unchecked items and drops checked ones", () => {
const payload = buildGroceryExportPayload({
name: "Weekly groceries",
items: [
{ rawName: "Milk", quantity: "1", unit: "L", checked: false },
{ rawName: "Eggs", quantity: "12", unit: null, checked: true },
],
});
expect(payload.listName).toBe("Weekly groceries");
expect(payload.items).toEqual([{ name: "Milk", quantity: "1", unit: "L" }]);
});
});
describe("groceryExportToText", () => {
it("renders a plain-text list with quantities", () => {
const text = groceryExportToText({
listName: "Weekly groceries",
items: [
{ name: "Milk", quantity: "1", unit: "L" },
{ name: "Bananas", quantity: null, unit: null },
],
});
expect(text).toBe("Weekly groceries\n\n1 L Milk\nBananas");
});
});
@@ -0,0 +1,59 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
const { mockPlanFindFirst, mockMemberFindFirst } = vi.hoisted(() => ({
mockPlanFindFirst: vi.fn(),
mockMemberFindFirst: vi.fn(),
}));
vi.mock("@epicure/db", () => ({
db: {
query: {
mealPlans: { findFirst: mockPlanFindFirst },
mealPlanMembers: { findFirst: mockMemberFindFirst },
},
},
mealPlans: { id: "id", userId: "user_id" },
mealPlanMembers: { mealPlanId: "meal_plan_id", userId: "user_id" },
eq: vi.fn((a, b) => ({ a, b, op: "eq" })),
and: vi.fn((...args) => ({ args, op: "and" })),
}));
const { getMealPlanAccessById, canWriteMealPlan } = await import("../meal-plan-access");
beforeEach(() => {
vi.clearAllMocks();
});
describe("getMealPlanAccessById", () => {
it("returns null when the plan doesn't exist", async () => {
mockPlanFindFirst.mockResolvedValue(undefined);
expect(await getMealPlanAccessById("plan-1", "user-1")).toBeNull();
});
it("grants owner role to the plan's userId", async () => {
mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-1" });
const access = await getMealPlanAccessById("plan-1", "user-1");
expect(access?.role).toBe("owner");
});
it("grants the member's assigned role", async () => {
mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-owner" });
mockMemberFindFirst.mockResolvedValue({ role: "viewer" });
const access = await getMealPlanAccessById("plan-1", "user-2");
expect(access?.role).toBe("viewer");
});
it("returns null when the user is neither owner nor a member", async () => {
mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-owner" });
mockMemberFindFirst.mockResolvedValue(undefined);
expect(await getMealPlanAccessById("plan-1", "user-2")).toBeNull();
});
});
describe("canWriteMealPlan", () => {
it("allows owner and editor, denies viewer", () => {
expect(canWriteMealPlan("owner")).toBe(true);
expect(canWriteMealPlan("editor")).toBe(true);
expect(canWriteMealPlan("viewer")).toBe(false);
});
});
@@ -0,0 +1,59 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
const { mockListFindFirst, mockMemberFindFirst } = vi.hoisted(() => ({
mockListFindFirst: vi.fn(),
mockMemberFindFirst: vi.fn(),
}));
vi.mock("@epicure/db", () => ({
db: {
query: {
shoppingLists: { findFirst: mockListFindFirst },
shoppingListMembers: { findFirst: mockMemberFindFirst },
},
},
shoppingLists: { id: "id", userId: "user_id" },
shoppingListMembers: { listId: "list_id", userId: "user_id" },
eq: vi.fn((a, b) => ({ a, b, op: "eq" })),
and: vi.fn((...args) => ({ args, op: "and" })),
}));
const { getShoppingListAccess, canWriteShoppingList } = await import("../shopping-list-access");
beforeEach(() => {
vi.clearAllMocks();
});
describe("getShoppingListAccess", () => {
it("returns null when the list doesn't exist", async () => {
mockListFindFirst.mockResolvedValue(undefined);
expect(await getShoppingListAccess("list-1", "user-1")).toBeNull();
});
it("grants owner role to the list's userId", async () => {
mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-1" });
const access = await getShoppingListAccess("list-1", "user-1");
expect(access?.role).toBe("owner");
});
it("grants the member's assigned role", async () => {
mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-owner" });
mockMemberFindFirst.mockResolvedValue({ role: "editor" });
const access = await getShoppingListAccess("list-1", "user-2");
expect(access?.role).toBe("editor");
});
it("returns null when the user is neither owner nor a member", async () => {
mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-owner" });
mockMemberFindFirst.mockResolvedValue(undefined);
expect(await getShoppingListAccess("list-1", "user-2")).toBeNull();
});
});
describe("canWriteShoppingList", () => {
it("allows owner and editor, denies viewer", () => {
expect(canWriteShoppingList("owner")).toBe(true);
expect(canWriteShoppingList("editor")).toBe(true);
expect(canWriteShoppingList("viewer")).toBe(false);
});
});