@pylonsync/create-pylon 0.3.344 → 0.3.346

package/templates/inventory/lib/search.ts

@@ -0,0 +1,78 @@
+// Client-side search powering the ⌘K palette.
+//
+// A small team's CRM fits in the synced replica, so search runs locally against
+// data already in memory: results appear as you type, with no request per
+// keystroke. Swap in `db.useSearch` (Pylon's FTS) when a workspace outgrows
+// that — the component boundary doesn't change, only this file.
+
+export interface SearchItem {
+  id: string;
+  type: "deal" | "company" | "contact";
+  title: string;
+  /** Second line: the company for a contact, the domain for a company. */
+  subtitle?: string;
+  href: string;
+  /** Extra text matched but not displayed — an email, say. */
+  keywords?: string;
+}
+
+export interface Scored extends SearchItem {
+  score: number;
+}
+
+/**
+ * Rank items against a query. Prefix matches beat word-boundary matches, which
+ * beat substring matches; ties break on the shorter title, so "Acme" ranks
+ * above "Acme Corporation Holdings" for the query "acme".
+ */
+export function searchItems(
+  items: SearchItem[],
+  query: string,
+  limit = 8,
+): SearchItem[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return items.slice(0, limit);
+
+  const scored: Scored[] = [];
+  for (const item of items) {
+    const score = scoreItem(item, q);
+    if (score > 0) scored.push({ ...item, score });
+  }
+  scored.sort(
+    (a, b) => b.score - a.score || a.title.length - b.title.length ||
+      a.title.localeCompare(b.title),
+  );
+  return scored.slice(0, limit);
+}
+
+function scoreItem(item: SearchItem, q: string): number {
+  const title = item.title.toLowerCase();
+  if (title.startsWith(q)) return 100;
+  if (wordStart(title, q)) return 80;
+  if (title.includes(q)) return 60;
+
+  const haystack = `${item.subtitle ?? ""} ${item.keywords ?? ""}`.toLowerCase();
+  if (wordStart(haystack, q)) return 40;
+  if (haystack.includes(q)) return 20;
+  return 0;
+}
+
+function wordStart(haystack: string, needle: string): boolean {
+  let from = 0;
+  for (;;) {
+    const at = haystack.indexOf(needle, from);
+    if (at === -1) return false;
+    if (at === 0 || /[\s._@/-]/.test(haystack[at - 1])) return true;
+    from = at + 1;
+  }
+}
+
+/** Move through a list with arrow keys, wrapping at both ends. */
+export function moveSelection(
+  current: number,
+  delta: number,
+  length: number,
+): number {
+  if (length === 0) return 0;
+  return (current + delta + length) % length;
+}

package/templates/inventory/lib/seed.ts

@@ -0,0 +1,102 @@
+// Demo data for a brand-new stock workspace.
+//
+// An empty product list shows nothing about levels, reorder flags, or the
+// ledger. The first sign-in seeds a realistic shelf — including one line out of
+// stock and one below its reorder point — so those states are visible rather
+// than theoretical.
+//
+// The movements are the interesting part: each product\'s level is the sum of
+// its history, so the seed writes a plausible sequence of receipts and sales
+// rather than a starting quantity.
+
+export interface SeedProduct {
+  key: string;
+  sku: string;
+  name: string;
+  category: string;
+  cost: number;
+  price: number;
+  reorderPoint: number;
+}
+
+export interface SeedMovement {
+  product: string;
+  delta: number;
+  reason: string;
+  note?: string;
+  /** Days ago. */
+  age: number;
+}
+
+export const SEED_PRODUCTS: SeedProduct[] = [
+  { key: "beans", sku: "CFE-001", name: "House Blend, 1kg", category: "Coffee", cost: 9.4, price: 18, reorderPoint: 12 },
+  { key: "decaf", sku: "CFE-002", name: "Decaf Single Origin, 1kg", category: "Coffee", cost: 11.2, price: 22, reorderPoint: 6 },
+  { key: "cups", sku: "PKG-010", name: "12oz Cups (sleeve of 50)", category: "Packaging", cost: 4.15, price: 0, reorderPoint: 20 },
+  { key: "lids", sku: "PKG-011", name: "12oz Lids (sleeve of 50)", category: "Packaging", cost: 2.8, price: 0, reorderPoint: 20 },
+  { key: "grinder", sku: "EQP-100", name: "Burr Grinder", category: "Equipment", cost: 148, price: 249, reorderPoint: 2 },
+  { key: "filters", sku: "PKG-020", name: "Paper Filters (box of 100)", category: "Packaging", cost: 3.5, price: 7, reorderPoint: 10 },
+];
+
+export const SEED_MOVEMENTS: SeedMovement[] = [
+  // Healthy stock.
+  { product: "beans", delta: 60, reason: "received", note: "PO-4471", age: 21 },
+  { product: "beans", delta: -8, reason: "sold", age: 14 },
+  { product: "beans", delta: -11, reason: "sold", age: 7 },
+  { product: "beans", delta: -6, reason: "sold", age: 2 },
+
+  // Below its reorder point of 6 — ends at 4.
+  { product: "decaf", delta: 24, reason: "received", note: "PO-4471", age: 21 },
+  { product: "decaf", delta: -9, reason: "sold", age: 12 },
+  { product: "decaf", delta: -8, reason: "sold", age: 5 },
+  { product: "decaf", delta: -3, reason: "sold", age: 1 },
+
+  { product: "cups", delta: 100, reason: "received", age: 30 },
+  { product: "cups", delta: -34, reason: "sold", age: 10 },
+
+  // Out of stock — ends at 0.
+  { product: "lids", delta: 40, reason: "received", age: 30 },
+  { product: "lids", delta: -38, reason: "sold", age: 9 },
+  { product: "lids", delta: -2, reason: "damaged", note: "Crushed in transit", age: 4 },
+
+  { product: "grinder", delta: 6, reason: "received", note: "PO-4502", age: 40 },
+  { product: "grinder", delta: -2, reason: "sold", age: 18 },
+  { product: "grinder", delta: 1, reason: "returned", note: "Customer changed mind", age: 6 },
+
+  { product: "filters", delta: 48, reason: "received", age: 25 },
+  { product: "filters", delta: -12, reason: "sold", age: 8 },
+  { product: "filters", delta: -2, reason: "count", note: "Cycle count adjustment", age: 3 },
+];
+
+export interface ShapedSeed {
+  products: Array<{ key: string; row: Record<string, unknown> }>;
+  movements: Array<{ product: string; row: Record<string, unknown> }>;
+}
+
+export function shapeSeed(now: number = Date.now()): ShapedSeed {
+  const daysAgo = (days: number) => new Date(now - days * 86_400_000).toISOString();
+
+  return {
+    products: SEED_PRODUCTS.map((p) => ({
+      key: p.key,
+      row: {
+        sku: p.sku,
+        name: p.name,
+        category: p.category,
+        unitCostCents: Math.round(p.cost * 100),
+        unitPriceCents: Math.round(p.price * 100),
+        reorderPoint: p.reorderPoint,
+        archived: false,
+        createdAt: daysAgo(60),
+      },
+    })),
+    movements: SEED_MOVEMENTS.map((m) => ({
+      product: m.product,
+      row: {
+        delta: m.delta,
+        reason: m.reason,
+        note: m.note ?? null,
+        createdAt: daysAgo(m.age),
+      },
+    })),
+  };
+}

package/templates/inventory/lib/stock.ts

@@ -0,0 +1,207 @@
+// Stock levels, valuation, and reorder state.
+//
+// THE CENTRAL DECISION: on-hand is never stored. It is the sum of an append-only
+// ledger of movements. A mutable `quantity` column is the classic inventory bug
+// — two people receive the same delivery, both read 10, both write 15, and you
+// have lost five units with nothing to audit. Appending "+5" twice gives 20 and
+// shows you exactly who did it.
+//
+// It also means every count can be explained. "Why do we have 3?" is answerable
+// from the same rows that produced the number.
+//
+// Money is INTEGER CENTS. Quantities are whole units — you cannot hold half a
+// physical thing, and allowing it hides unit-of-measure mistakes.
+//
+// Pure: no React, no `db`.
+
+export interface Product {
+  id: string;
+  sku: string;
+  name: string;
+  category?: string | null;
+  unitCostCents?: number | null;
+  unitPriceCents?: number | null;
+  /** Order more at or below this level. Null means never flag it. */
+  reorderPoint?: number | null;
+  archived?: boolean | null;
+  createdAt?: string | null;
+}
+
+export interface Movement {
+  id: string;
+  productId: string;
+  /** Signed: positive receives, negative issues. Never zero. */
+  delta: number;
+  reason: string;
+  note?: string | null;
+  createdAt?: string | null;
+  actorId?: string | null;
+}
+
+export interface Reason {
+  id: string;
+  label: string;
+  /** Which direction this reason is allowed to move stock. */
+  direction: "in" | "out" | "either";
+}
+
+export const REASONS: Reason[] = [
+  { id: "received", label: "Received", direction: "in" },
+  { id: "sold", label: "Sold", direction: "out" },
+  { id: "returned", label: "Customer return", direction: "in" },
+  { id: "damaged", label: "Damaged", direction: "out" },
+  { id: "count", label: "Stock count", direction: "either" },
+];
+
+export function reasonById(id: string): Reason | undefined {
+  return REASONS.find((r) => r.id === id);
+}
+
+export function isValidReason(id: string): boolean {
+  return REASONS.some((r) => r.id === id);
+}
+
+/**
+ * Does this reason permit this direction? A "Sold" that adds stock is a
+ * mis-click, and catching it here keeps the ledger meaningful — the whole point
+ * of storing a reason is being able to trust it later.
+ */
+export function reasonAllows(reasonId: string, delta: number): boolean {
+  const reason = reasonById(reasonId);
+  if (!reason || delta === 0) return false;
+  if (reason.direction === "either") return true;
+  return reason.direction === "in" ? delta > 0 : delta < 0;
+}
+
+/** On-hand for one product: the sum of its movements. */
+export function onHand(productId: string, movements: Movement[]): number {
+  let total = 0;
+  for (const movement of movements) {
+    if (movement.productId !== productId) continue;
+    const delta = Number(movement.delta);
+    if (Number.isFinite(delta)) total += Math.trunc(delta);
+  }
+  return total;
+}
+
+/**
+ * On-hand for every product in one pass.
+ *
+ * The per-product version is O(movements) each, so a list view calling it per
+ * row is O(products × movements) — fine at ten products, not at a thousand.
+ */
+export function onHandByProduct(movements: Movement[]): Map<string, number> {
+  const totals = new Map<string, number>();
+  for (const movement of movements) {
+    const delta = Number(movement.delta);
+    if (!Number.isFinite(delta)) continue;
+    totals.set(
+      movement.productId,
+      (totals.get(movement.productId) ?? 0) + Math.trunc(delta),
+    );
+  }
+  return totals;
+}
+
+export type StockState = "out" | "low" | "ok";
+
+/**
+ * Out of stock, at/below the reorder point, or fine.
+ *
+ * Zero is `out` even when there's no reorder point set — you can't sell what
+ * you don't have, and that's worth surfacing whether or not someone configured
+ * a threshold.
+ */
+export function stockState(quantity: number, reorderPoint?: number | null): StockState {
+  if (quantity <= 0) return "out";
+  const point = Number(reorderPoint);
+  if (Number.isFinite(point) && point > 0 && quantity <= point) return "low";
+  return "ok";
+}
+
+export interface Summary {
+  skuCount: number;
+  unitCount: number;
+  /** Stock at COST — what the shelves are worth to you, not to a customer. */
+  valuationCents: number;
+  lowCount: number;
+  outCount: number;
+}
+
+export function summarize(products: Product[], movements: Movement[]): Summary {
+  const byProduct = onHandByProduct(movements);
+  const summary: Summary = {
+    skuCount: 0,
+    unitCount: 0,
+    valuationCents: 0,
+    lowCount: 0,
+    outCount: 0,
+  };
+
+  for (const product of products) {
+    if (product.archived) continue;
+    summary.skuCount += 1;
+    const quantity = byProduct.get(product.id) ?? 0;
+    // Negative stock is a data error, not negative value — don't let it credit
+    // the valuation and hide itself.
+    summary.unitCount += Math.max(0, quantity);
+    summary.valuationCents +=
+      Math.max(0, quantity) * (Number(product.unitCostCents) || 0);
+
+    const state = stockState(quantity, product.reorderPoint);
+    if (state === "out") summary.outCount += 1;
+    else if (state === "low") summary.lowCount += 1;
+  }
+  return summary;
+}
+
+/** Products at or below their reorder point, most urgent first. */
+export function needsReorder(
+  products: Product[],
+  movements: Movement[],
+): Array<{ product: Product; quantity: number; state: StockState }> {
+  const byProduct = onHandByProduct(movements);
+  return products
+    .filter((product) => !product.archived)
+    .map((product) => {
+      const quantity = byProduct.get(product.id) ?? 0;
+      return { product, quantity, state: stockState(quantity, product.reorderPoint) };
+    })
+    .filter((row) => row.state !== "ok")
+    .sort((a, b) => a.quantity - b.quantity);
+}
+
+/** "$12.50" — exact, like every money figure in this app. */
+export function money(cents: number | null | undefined): string {
+  const value = Number(cents) || 0;
+  const sign = value < 0 ? "-" : "";
+  const abs = Math.abs(value);
+  const dollars = Math.floor(abs / 100).toLocaleString("en-US");
+  const rest = String(abs % 100).padStart(2, "0");
+  return `${sign}$${dollars}.${rest}`;
+}
+
+/** "+5" / "−3" — the sign is the point, so it's always shown. */
+export function signedQuantity(delta: number): string {
+  const value = Math.trunc(Number(delta) || 0);
+  return value > 0 ? `+${value}` : value < 0 ? `−${Math.abs(value)}` : "0";
+}
+
+/** Parse a typed amount into cents. Returns null on anything unreadable. */
+export function parseAmount(input: string): number | null {
+  const cleaned = input.replace(/[$,\s]/g, "");
+  if (!cleaned || !/^-?\d*\.?\d*$/.test(cleaned) || cleaned === "." || cleaned === "-") {
+    return null;
+  }
+  const value = Number(cleaned);
+  if (!Number.isFinite(value)) return null;
+  return Math.round(value * 100);
+}
+
+/** Parse a typed whole-unit count. Rejects fractions and nonsense. */
+export function parseCount(input: string): number | null {
+  const cleaned = input.replace(/[,\s]/g, "");
+  if (!cleaned || !/^-?\d+$/.test(cleaned)) return null;
+  const value = Number(cleaned);
+  return Number.isFinite(value) ? value : null;
+}

package/templates/inventory/lib/utils.ts

@@ -0,0 +1,10 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+// `cn` — the shadcn class merger. clsx resolves conditional/array class
+// inputs; tailwind-merge then dedupes conflicting Tailwind utilities so
+// the last one wins (e.g. `cn("px-2", "px-4")` → "px-4"). Every shadcn
+// component routes its className through this.
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/templates/inventory/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "__APP_NAME_KEBAB__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "pylon dev",
+    "deploy": "pylon deploy",
+    "check": "tsc --noEmit",
+    "test": "pylon test"
+  },
+  "dependencies": {
+    "@pylonsync/react": "^__PYLON_VERSION__",
+    "@pylonsync/sdk": "^__PYLON_VERSION__",
+    "@pylonsync/functions": "^__PYLON_VERSION__",
+    "@pylonsync/client": "^__PYLON_VERSION__",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwindcss": "^4.3.0",
+    "@tailwindcss/cli": "^4.3.0",
+    "tw-animate-css": "^1.2.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^2.5.0",
+    "lucide-react": "^0.460.0",
+    "@radix-ui/react-dialog": "^1.1.4",
+    "@radix-ui/react-slot": "^1.1.0"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.10.0",
+    "@pylonsync/cli": "^__PYLON_VERSION__",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "typescript": "^5.6.0"
+  }
+}

package/templates/inventory/tests/components.test.tsx

@@ -0,0 +1,155 @@
+import { afterEach, describe, expect, test } from "bun:test";
+// This project uses the classic JSX transform, so .tsx tests import React.
+import React from "react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { StockLevel } from "../components/stock-level";
+import { MovementDialog } from "../components/movement-dialog";
+
+afterEach(cleanup);
+
+// Tier 2: components. No mocking needed — they take data as props and report
+// changes through callbacks, because the container owns `db`.
+
+const products = [
+  { id: "p1", sku: "CFE-001", name: "House Blend" },
+  { id: "p2", sku: "PKG-011", name: "Lids" },
+];
+
+describe("StockLevel", () => {
+  test("marks an empty shelf", () => {
+    render(<StockLevel quantity={0} reorderPoint={5} />);
+    expect(screen.getByText("out")).toBeDefined();
+  });
+
+  test("marks a level at the reorder point", () => {
+    render(<StockLevel quantity={5} reorderPoint={5} />);
+    expect(screen.getByText("low")).toBeDefined();
+  });
+
+  test("a healthy level is just the number", () => {
+    const { container } = render(<StockLevel quantity={41} reorderPoint={5} />);
+    expect(container.textContent).toBe("41");
+  });
+});
+
+describe("MovementDialog", () => {
+  const level = (id: string) => (id === "p1" ? 12 : 0);
+
+  test("a sale is recorded as a negative delta from a positive input", () => {
+    // Asking someone to type "-3" is how you get a "+3" sale.
+    const recorded: unknown[] = [];
+    render(
+      <MovementDialog
+        open
+        products={products}
+        currentLevel={level}
+        onOpenChange={() => {}}
+        onRecord={(id, delta, reason) => recorded.push([id, delta, reason])}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Product"), { target: { value: "p1" } });
+    fireEvent.change(screen.getByLabelText("Reason"), { target: { value: "sold" } });
+    fireEvent.change(screen.getByLabelText("Quantity"), { target: { value: "3" } });
+    fireEvent.click(screen.getByRole("button", { name: /^record$/i }));
+    expect(recorded).toEqual([["p1", -3, "sold"]]);
+  });
+
+  test("a receipt is positive", () => {
+    const recorded: unknown[] = [];
+    render(
+      <MovementDialog
+        open
+        products={products}
+        currentLevel={level}
+        onOpenChange={() => {}}
+        onRecord={(id, delta) => recorded.push(delta)}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Product"), { target: { value: "p1" } });
+    fireEvent.change(screen.getByLabelText("Quantity"), { target: { value: "10" } });
+    fireEvent.click(screen.getByRole("button", { name: /^record$/i }));
+    expect(recorded).toEqual([10]);
+  });
+
+  test("a stock count sets the level, so it sends the difference", () => {
+    // Counting a shelf produces "there are 9", not "adjust by -3".
+    const recorded: unknown[] = [];
+    render(
+      <MovementDialog
+        open
+        products={products}
+        currentLevel={level}
+        onOpenChange={() => {}}
+        onRecord={(id, delta) => recorded.push(delta)}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Product"), { target: { value: "p1" } });
+    fireEvent.change(screen.getByLabelText("Reason"), { target: { value: "count" } });
+    fireEvent.change(screen.getByLabelText("Counted"), { target: { value: "9" } });
+    fireEvent.click(screen.getByRole("button", { name: /^record$/i }));
+    expect(recorded).toEqual([-3]);
+  });
+
+  test("refuses to take stock below zero", () => {
+    const recorded: unknown[] = [];
+    render(
+      <MovementDialog
+        open
+        products={products}
+        currentLevel={level}
+        onOpenChange={() => {}}
+        onRecord={(id, delta) => recorded.push(delta)}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Product"), { target: { value: "p2" } });
+    fireEvent.change(screen.getByLabelText("Reason"), { target: { value: "sold" } });
+    fireEvent.change(screen.getByLabelText("Quantity"), { target: { value: "1" } });
+    fireEvent.click(screen.getByRole("button", { name: /^record$/i }));
+    expect(recorded).toEqual([]);
+    expect(screen.getByText(/below zero/i)).toBeDefined();
+  });
+
+  test("shows what the level will become", () => {
+    render(
+      <MovementDialog
+        open
+        products={products}
+        currentLevel={level}
+        onOpenChange={() => {}}
+        onRecord={() => {}}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Product"), { target: { value: "p1" } });
+    fireEvent.change(screen.getByLabelText("Quantity"), { target: { value: "5" } });
+    expect(screen.getByText(/On hand 12 → 17/)).toBeDefined();
+  });
+
+  test("nothing is recorded without a product", () => {
+    const recorded: unknown[] = [];
+    render(
+      <MovementDialog
+        open
+        products={products}
+        currentLevel={level}
+        onOpenChange={() => {}}
+        onRecord={() => recorded.push(1)}
+      />,
+    );
+    fireEvent.change(screen.getByLabelText("Quantity"), { target: { value: "5" } });
+    fireEvent.click(screen.getByRole("button", { name: /^record$/i }));
+    expect(recorded).toEqual([]);
+  });
+
+  test("renders nothing when closed", () => {
+    const { container } = render(
+      <MovementDialog
+        open={false}
+        products={products}
+        currentLevel={level}
+        onOpenChange={() => {}}
+        onRecord={() => {}}
+      />,
+    );
+    expect(container.firstChild).toBeNull();
+  });
+});

package/templates/inventory/tests/search.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import { moveSelection, searchItems, type SearchItem } from "../lib/search";
+
+const items: SearchItem[] = [
+  { id: "1", type: "company", title: "Acme Inc", subtitle: "acme.com", href: "/c" },
+  {
+    id: "2",
+    type: "company",
+    title: "Acme Corporation Holdings",
+    subtitle: "acmeholdings.com",
+    href: "/c",
+  },
+  {
+    id: "3",
+    type: "contact",
+    title: "Dana Whitfield",
+    subtitle: "Northwind Logistics",
+    href: "/p",
+    keywords: "dana@northwind.co VP Operations",
+  },
+  { id: "4", type: "deal", title: "Fleet dispatch rollout", href: "/d" },
+];
+
+const titles = (q: string) => searchItems(items, q).map((i) => i.title);
+
+describe("searchItems", () => {
+  test("an empty query lists everything", () => {
+    expect(searchItems(items, "").length).toBe(items.length);
+    expect(searchItems(items, "   ").length).toBe(items.length);
+  });
+
+  test("prefix beats substring", () => {
+    expect(titles("acme")[0]).toBe("Acme Inc");
+  });
+
+  test("the shorter title wins a tie", () => {
+    // Both start with "Acme"; the more specific record should come first.
+    expect(titles("acme")).toEqual(["Acme Inc", "Acme Corporation Holdings"]);
+  });
+
+  test("matches a word inside the title", () => {
+    expect(titles("dispatch")).toContain("Fleet dispatch rollout");
+  });
+
+  test("matches the subtitle and hidden keywords", () => {
+    expect(titles("northwind")).toContain("Dana Whitfield");
+    expect(titles("dana@northwind.co")).toContain("Dana Whitfield");
+    expect(titles("VP")).toContain("Dana Whitfield");
+  });
+
+  test("is case-insensitive", () => {
+    expect(titles("ACME").length).toBe(2);
+  });
+
+  test("no match is empty, not everything", () => {
+    expect(titles("zzzz")).toEqual([]);
+  });
+
+  test("respects the limit", () => {
+    expect(searchItems(items, "", 2)).toHaveLength(2);
+  });
+
+  test("a word-boundary hit beats a mid-word one", () => {
+    const rows: SearchItem[] = [
+      { id: "a", type: "deal", title: "Broadcasting", href: "/" },
+      { id: "b", type: "deal", title: "New cast list", href: "/" },
+    ];
+    expect(searchItems(rows, "cast").map((r) => r.title)[0]).toBe("New cast list");
+  });
+});
+
+describe("moveSelection", () => {
+  test("wraps at both ends", () => {
+    expect(moveSelection(0, -1, 3)).toBe(2);
+    expect(moveSelection(2, 1, 3)).toBe(0);
+    expect(moveSelection(0, 1, 3)).toBe(1);
+  });
+
+  test("an empty list stays at zero rather than going negative", () => {
+    expect(moveSelection(0, 1, 0)).toBe(0);
+    expect(moveSelection(0, -1, 0)).toBe(0);
+  });
+});

package/templates/inventory/tests/setup.ts

@@ -0,0 +1,5 @@
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+
+// Make document/window available so @testing-library/react can render. Loaded
+// via bunfig.toml's [test] preload, before any test file runs.
+GlobalRegistrator.register();