feat: add ICS export, search column picker, dark-mode PDF, and offline payment queue (#243, #244, #245, #246) (#278)

- ICS calendar export with RFC 5545 VEVENT entries and VALARM reminders
- Search result column customization with localStorage persistence
- Dark-mode-aware PDF receipts with Print/Screen mode toggle
- Offline payment queue using IndexedDB with auto-resubmit on reconnect

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: The-moving-man

src/__tests__/icsExport.test.ts

@@ -0,0 +1,92 @@
+import { generateICS, type ICSEvent } from "@/lib/icsExport";
+
+const FIXED_STAMP = new Date("2025-01-15T12:00:00Z");
+
+function makeEvent(overrides: Partial<ICSEvent> = {}): ICSEvent {
+  return {
+    uid: "test-uid-1@stellarsplit",
+    summary: "Payout to Alice",
+    description: "Invoice #42 payout",
+    date: new Date("2025-02-01T00:00:00Z"),
+    ...overrides,
+  };
+}
+
+describe("generateICS — single event", () => {
+  it("produces valid iCalendar structure", () => {
+    const ics = generateICS([makeEvent()], FIXED_STAMP);
+
+    expect(ics).toContain("BEGIN:VCALENDAR");
+    expect(ics).toContain("END:VCALENDAR");
+    expect(ics).toContain("VERSION:2.0");
+    expect(ics).toContain("PRODID:");
+    expect(ics).toContain("BEGIN:VEVENT");
+    expect(ics).toContain("END:VEVENT");
+    expect(ics).toContain("UID:test-uid-1@stellarsplit");
+    expect(ics).toContain("SUMMARY:Payout to Alice");
+  });
+});
+
+describe("generateICS — multiple events", () => {
+  it("includes correct number of VEVENT blocks", () => {
+    const events: ICSEvent[] = [
+      makeEvent({ uid: "uid-1" }),
+      makeEvent({ uid: "uid-2", summary: "Payout to Bob" }),
+      makeEvent({ uid: "uid-3", summary: "Payout to Carol" }),
+    ];
+    const ics = generateICS(events, FIXED_STAMP);
+
+    const veventCount = (ics.match(/BEGIN:VEVENT/g) || []).length;
+    expect(veventCount).toBe(3);
+
+    expect(ics).toContain("UID:uid-1");
+    expect(ics).toContain("UID:uid-2");
+    expect(ics).toContain("UID:uid-3");
+  });
+});
+
+describe("generateICS — VALARM reminder", () => {
+  it("includes a 1-day-before reminder in each event", () => {
+    const events = [makeEvent({ uid: "a" }), makeEvent({ uid: "b" })];
+    const ics = generateICS(events, FIXED_STAMP);
+
+    const alarmCount = (ics.match(/BEGIN:VALARM/g) || []).length;
+    expect(alarmCount).toBe(2);
+    expect(ics).toContain("TRIGGER:-P1D");
+    expect(ics).toContain("ACTION:DISPLAY");
+  });
+});
+
+describe("generateICS — zero events", () => {
+  it("returns valid iCalendar with no VEVENT", () => {
+    const ics = generateICS([], FIXED_STAMP);
+
+    expect(ics).toContain("BEGIN:VCALENDAR");
+    expect(ics).toContain("END:VCALENDAR");
+    expect(ics).toContain("VERSION:2.0");
+    expect(ics).toContain("CALSCALE:GREGORIAN");
+    expect(ics).not.toContain("BEGIN:VEVENT");
+  });
+});
+
+describe("generateICS — date formatting", () => {
+  it("formats dates as YYYYMMDD VALUE=DATE", () => {
+    const event = makeEvent({ date: new Date("2025-12-25T00:00:00Z") });
+    const ics = generateICS([event], FIXED_STAMP);
+
+    expect(ics).toContain("DTSTART;VALUE=DATE:20251225");
+  });
+
+  it("formats DTSTAMP correctly", () => {
+    const ics = generateICS([makeEvent()], FIXED_STAMP);
+
+    expect(ics).toContain("DTSTAMP:20250115T120000Z");
+  });
+
+  it("pads single-digit months and days", () => {
+    const event = makeEvent({ date: new Date("2025-03-05T00:00:00Z") });
+    const ics = generateICS([event], FIXED_STAMP);
+
+    expect(ics).toContain("DTSTART;VALUE=DATE:20250305");
+  });
+});

src/__tests__/invoicePDF.test.ts

@@ -0,0 +1,43 @@
+import { getPDFThemeClasses } from "@/lib/pdfTheme";
+
+describe("getPDFThemeClasses", () => {
+  it("print mode returns light classes when resolvedTheme is light", () => {
+    const classes = getPDFThemeClasses("print", "light");
+    expect(classes.container).toBe("bg-white text-black");
+    expect(classes.subtitle).toBe("text-gray-500");
+    expect(classes.borderRow).toBe("border-gray-200");
+    expect(classes.borderHeaderRow).toBe("border-gray-300");
+    expect(classes.recipientRow).toBe("border-gray-100");
+    expect(classes.watermark).toBe("text-gray-800");
+  });
+
+  it("print mode returns light classes when resolvedTheme is dark", () => {
+    const classes = getPDFThemeClasses("print", "dark");
+    expect(classes.container).toBe("bg-white text-black");
+    expect(classes.subtitle).toBe("text-gray-500");
+    expect(classes.borderRow).toBe("border-gray-200");
+    expect(classes.borderHeaderRow).toBe("border-gray-300");
+    expect(classes.recipientRow).toBe("border-gray-100");
+    expect(classes.watermark).toBe("text-gray-800");
+  });
+
+  it("screen mode + dark theme returns dark classes", () => {
+    const classes = getPDFThemeClasses("screen", "dark");
+    expect(classes.container).toBe("bg-gray-900 text-gray-100");
+    expect(classes.subtitle).toBe("text-gray-400");
+    expect(classes.borderRow).toBe("border-gray-700");
+    expect(classes.borderHeaderRow).toBe("border-gray-600");
+    expect(classes.recipientRow).toBe("border-gray-800");
+    expect(classes.watermark).toBe("text-gray-300");
+  });
+
+  it("screen mode + light theme returns light classes", () => {
+    const classes = getPDFThemeClasses("screen", "light");
+    expect(classes.container).toBe("bg-white text-black");
+    expect(classes.subtitle).toBe("text-gray-500");
+    expect(classes.borderRow).toBe("border-gray-200");
+    expect(classes.borderHeaderRow).toBe("border-gray-300");
+    expect(classes.recipientRow).toBe("border-gray-100");
+    expect(classes.watermark).toBe("text-gray-800");
+  });
+});

src/__tests__/offlineQueue.test.ts

@@ -0,0 +1,216 @@
+import type { QueuedPayment } from "@/lib/offlineQueue";
+
+let store: Record<string, QueuedPayment> = {};
+
+vi.mock("@/lib/offlineQueue", async () => {
+  const actual = await vi.importActual<typeof import("@/lib/offlineQueue")>(
+    "@/lib/offlineQueue"
+  );
+
+  const getQueuedPayments = vi.fn(async (): Promise<QueuedPayment[]> => {
+    return Object.values(store).sort((a, b) => a.timestamp - b.timestamp);
+  });
+
+  const updatePaymentStatus = vi.fn(
+    async (id: string, status: QueuedPayment["status"], error?: string) => {
+      if (store[id]) {
+        store[id] = { ...store[id], status };
+        if (error !== undefined) store[id].error = error;
+      }
+    }
+  );
+
+  const removePayment = vi.fn(async (id: string) => {
+    delete store[id];
+  });
+
+  async function processQueue(
+    submitFn: (payment: QueuedPayment) => Promise<void>
+  ): Promise<Array<{ id: string; success: boolean; error?: string }>> {
+    const payments = await getQueuedPayments();
+    const pending = payments.filter((p) => p.status === "pending");
+    const results: Array<{ id: string; success: boolean; error?: string }> = [];
+
+    for (const payment of pending) {
+      await updatePaymentStatus(payment.id, "submitting");
+      try {
+        await submitFn(payment);
+        await removePayment(payment.id);
+        results.push({ id: payment.id, success: true });
+      } catch (err) {
+        const errorMsg =
+          err instanceof Error ? err.message : "Unknown error";
+        await updatePaymentStatus(payment.id, "failed", errorMsg);
+        results.push({ id: payment.id, success: false, error: errorMsg });
+      }
+    }
+
+    return results;
+  }
+
+  return {
+    ...actual,
+    openDB: vi.fn(),
+    getQueuedPayments,
+    updatePaymentStatus,
+    removePayment,
+    processQueue,
+  };
+});
+
+const { isNetworkError, processQueue } = await import("@/lib/offlineQueue");
+
+function setStore(payments: QueuedPayment[]) {
+  store = {};
+  for (const p of payments) store[p.id] = { ...p };
+}
+
+beforeEach(() => {
+  store = {};
+});
+
+describe("isNetworkError", () => {
+  it("returns true for TypeError with 'Failed to fetch'", () => {
+    expect(isNetworkError(new TypeError("Failed to fetch"))).toBe(true);
+  });
+
+  it("returns true for TypeError with 'network' in message", () => {
+    expect(isNetworkError(new TypeError("A network error occurred"))).toBe(
+      true
+    );
+  });
+
+  it("returns true for error with name NetworkError", () => {
+    const err = new Error("something");
+    err.name = "NetworkError";
+    expect(isNetworkError(err)).toBe(true);
+  });
+
+  it("returns true for error with name AbortError", () => {
+    const err = new Error("aborted");
+    err.name = "AbortError";
+    expect(isNetworkError(err)).toBe(true);
+  });
+
+  it("returns false for contract rejection errors", () => {
+    expect(isNetworkError(new Error("invoice already funded"))).toBe(false);
+  });
+
+  it("returns false for generic errors", () => {
+    expect(isNetworkError(new Error("something went wrong"))).toBe(false);
+  });
+
+  it("returns false for non-error values", () => {
+    expect(isNetworkError("string error")).toBe(false);
+    expect(isNetworkError(null)).toBe(false);
+    expect(isNetworkError(undefined)).toBe(false);
+  });
+});
+
+describe("processQueue", () => {
+  it("processes payments in timestamp order", async () => {
+    const order: string[] = [];
+    setStore([
+      {
+        id: "p3",
+        invoiceId: "inv-3",
+        amount: 300n,
+        sender: "GABC",
+        timestamp: 3000,
+        status: "pending",
+      },
+      {
+        id: "p1",
+        invoiceId: "inv-1",
+        amount: 100n,
+        sender: "GABC",
+        timestamp: 1000,
+        status: "pending",
+      },
+      {
+        id: "p2",
+        invoiceId: "inv-2",
+        amount: 200n,
+        sender: "GABC",
+        timestamp: 2000,
+        status: "pending",
+      },
+    ]);
+
+    const submitFn = vi.fn(async (p: QueuedPayment) => {
+      order.push(p.id);
+    });
+
+    const results = await processQueue(submitFn);
+
+    expect(order).toEqual(["p1", "p2", "p3"]);
+    expect(results).toHaveLength(3);
+    expect(results.every((r) => r.success)).toBe(true);
+  });
+
+  it("removes successful payments and marks failed ones", async () => {
+    setStore([
+      {
+        id: "ok",
+        invoiceId: "inv-ok",
+        amount: 100n,
+        sender: "GABC",
+        timestamp: 1000,
+        status: "pending",
+      },
+      {
+        id: "fail",
+        invoiceId: "inv-fail",
+        amount: 200n,
+        sender: "GABC",
+        timestamp: 2000,
+        status: "pending",
+      },
+    ]);
+
+    const submitFn = vi.fn(async (p: QueuedPayment) => {
+      if (p.id === "fail") throw new Error("tx rejected");
+    });
+
+    const results = await processQueue(submitFn);
+
+    expect(results).toEqual([
+      { id: "ok", success: true },
+      { id: "fail", success: false, error: "tx rejected" },
+    ]);
+
+    expect(store["ok"]).toBeUndefined();
+    expect(store["fail"]).toBeDefined();
+    expect(store["fail"].status).toBe("failed");
+    expect(store["fail"].error).toBe("tx rejected");
+  });
+
+  it("skips non-pending payments", async () => {
+    setStore([
+      {
+        id: "pending-one",
+        invoiceId: "inv-1",
+        amount: 100n,
+        sender: "GABC",
+        timestamp: 1000,
+        status: "pending",
+      },
+      {
+        id: "already-failed",
+        invoiceId: "inv-2",
+        amount: 200n,
+        sender: "GABC",
+        timestamp: 2000,
+        status: "failed",
+      },
+    ]);
+
+    const submitFn = vi.fn(async () => {});
+
+    const results = await processQueue(submitFn);
+
+    expect(submitFn).toHaveBeenCalledTimes(1);
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe("pending-one");
+  });
+});