@lotics/ui 20.0.1 → 20.0.2

package/src/gantt/scale.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { axisRange, barGeometry, buildTicks, pxPerDay } from "./scale";
-import type { GanttTask } from "./types";
-
-const AXIS = new Date(2026, 0, 1); // Jan 1 2026
-const task = (id: string, s: [number, number], e?: [number, number]): GanttTask => ({
-  id,
-  label: id,
-  start: new Date(2026, s[0], s[1]),
-  end: e ? new Date(2026, e[0], e[1]) : null,
-});
-
-describe("gantt scale", () => {
-  it("zoom widths shrink as the scale widens", () => {
-    expect(pxPerDay("day")).toBeGreaterThan(pxPerDay("week"));
-    expect(pxPerDay("week")).toBeGreaterThan(pxPerDay("month"));
-  });
-
-  it("positions a bar by day offset and inclusive span", () => {
-    // Jan 3 → Jan 5 inclusive = 3 days, 2 days after the axis start.
-    const b = barGeometry(task("a", [0, 3], [0, 5]), AXIS, "day");
-    expect(b.left).toBe(2 * 40);
-    expect(b.width).toBe(3 * 40);
-  });
-
-  it("gives a single-day task one day of width (floored)", () => {
-    const b = barGeometry(task("m", [0, 10]), AXIS, "day");
-    expect(b.width).toBe(40);
-    const tiny = barGeometry(task("m", [0, 10]), AXIS, "month"); // 1 * 5px → floored to 8
-    expect(tiny.width).toBe(8);
-  });
-
-  it("derives a padded axis window from the tasks", () => {
-    const { start, end } = axisRange([task("a", [0, 5], [0, 8]), task("b", [0, 3], [0, 20])], new Date(2026, 0, 1), 3);
-    expect(start).toEqual(new Date(2026, 0, 0)); // Jan 3 - 3 = Dec 31 (= Jan 0)
-    expect(end).toEqual(new Date(2026, 0, 23)); // Jan 20 + 3
-  });
-
-  it("emits one day-tick per day and flags month starts", () => {
-    const ticks = buildTicks(new Date(2026, 0, 30), new Date(2026, 1, 2), "day");
-    expect(ticks.map((t) => t.label)).toEqual(["30", "31", "1", "2"]);
-    expect(ticks.find((t) => t.label === "1")?.monthStart).toBe(true);
-    expect(ticks.find((t) => t.label === "30")?.monthStart).toBe(false);
-    expect(ticks[0].left).toBe(0);
-    expect(ticks[1].left).toBe(40); // one day across at day scale
-  });
-});

package/src/inline_focus.test.ts

@@ -1,49 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect } from "vitest";
-import { ensureModalityListeners, getInteractionModality } from "./interaction_modality";
-import { FOCUS_OPEN_SUPPRESS_MS, shouldOpenOnFocus, shouldRestoreFocusOnClose } from "./inline_focus";
-
-describe("shouldRestoreFocusOnClose — no scroll jump on a pointer close", () => {
-  it("restores focus on a keyboard close (Enter/Escape) — preserves Tab order", () => {
-    expect(shouldRestoreFocusOnClose("keyboard")).toBe(true);
-  });
-
-  it("does NOT restore on a pointer close (click ✓/✕ or click away) — a bare focus() would scroll the page", () => {
-    expect(shouldRestoreFocusOnClose("pointer")).toBe(false);
-  });
-});
-
-describe("shouldOpenOnFocus — the inline keyboard-entry gate", () => {
-  it("keyboard focus opens the editor", () => {
-    expect(shouldOpenOnFocus("keyboard", null, 1_000)).toBe(true);
-  });
-
-  it("pointer focus never opens the editor — the click path stays press-driven", () => {
-    expect(shouldOpenOnFocus("pointer", null, 1_000)).toBe(false);
-    // …even outside any suppression window.
-    expect(shouldOpenOnFocus("pointer", 100, 100_000)).toBe(false);
-  });
-
-  it("a programmatic focus restore inside the suppression window does not re-open", () => {
-    const restoredAt = 5_000;
-    expect(shouldOpenOnFocus("keyboard", restoredAt, restoredAt)).toBe(false);
-    expect(shouldOpenOnFocus("keyboard", restoredAt, restoredAt + FOCUS_OPEN_SUPPRESS_MS - 1)).toBe(false);
-  });
-
-  it("suppression expires — a later Tab arrival opens again", () => {
-    const restoredAt = 5_000;
-    expect(shouldOpenOnFocus("keyboard", restoredAt, restoredAt + FOCUS_OPEN_SUPPRESS_MS)).toBe(true);
-  });
-});
-
-describe("interaction modality tracker", () => {
-  it("records keyboard on keydown and pointer on mousedown (Tab-vs-click focus)", () => {
-    ensureModalityListeners();
-    document.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab" }));
-    expect(getInteractionModality()).toBe("keyboard");
-    document.dispatchEvent(new MouseEvent("mousedown"));
-    expect(getInteractionModality()).toBe("pointer");
-    document.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
-    expect(getInteractionModality()).toBe("keyboard");
-  });
-});

package/src/matrix.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { matrixTotals, type MatrixAxisItem } from "./matrix_totals";
-
-const rows: MatrixAxisItem[] = [
-  { key: "msc", label: "MSC" },
-  { key: "one", label: "ONE" },
-];
-const cols: MatrixAxisItem[] = [
-  { key: "20", label: "20ft" },
-  { key: "40", label: "40ft" },
-];
-
-// MSC: 20→5, 40→3 ; ONE: 20→0, 40→7
-const grid: Record<string, Record<string, number>> = {
-  msc: { "20": 5, "40": 3 },
-  one: { "20": 0, "40": 7 },
-};
-const value = (r: string, c: string) => grid[r]?.[c] ?? 0;
-
-describe("matrixTotals", () => {
-  it("sums each row across its columns", () => {
-    const { rowTotals } = matrixTotals(rows, cols, value);
-    expect(rowTotals.get("msc")).toBe(8);
-    expect(rowTotals.get("one")).toBe(7);
-  });
-
-  it("sums each column across its rows", () => {
-    const { colTotals } = matrixTotals(rows, cols, value);
-    expect(colTotals.get("20")).toBe(5);
-    expect(colTotals.get("40")).toBe(10);
-  });
-
-  it("grand total equals the sum of every cell", () => {
-    expect(matrixTotals(rows, cols, value).grandTotal).toBe(15);
-  });
-
-  it("max is the largest single cell, for the heat scale", () => {
-    expect(matrixTotals(rows, cols, value).max).toBe(7);
-  });
-
-  it("is all-zero for an empty axis", () => {
-    const r = matrixTotals([], cols, value);
-    expect(r.grandTotal).toBe(0);
-    expect(r.max).toBe(0);
-    expect(r.colTotals.get("20")).toBeUndefined();
-  });
-
-  it("counts a fully-empty grid as zero without dividing by it", () => {
-    const zero = matrixTotals(rows, cols, () => 0);
-    expect(zero.grandTotal).toBe(0);
-    expect(zero.max).toBe(0);
-    expect(zero.rowTotals.get("msc")).toBe(0);
-  });
-});

package/src/pending_commits.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { pendingCommits, trackCommit } from "./pending_commits";
-
-/** A field write that lands in `stored` after `ms`, like a save round trip. */
-const commit = (stored: { value: string }, next: string, ms: number) =>
-  new Promise<void>((resolve) =>
-    setTimeout(() => {
-      stored.value = next;
-      resolve();
-    }, ms),
-  );
-
-/** Let the registry's own settle callback run before asserting on it. */
-const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
-
-describe("pendingCommits", () => {
-  it("is null with nothing in flight — a press keeps its synchronous path", () => {
-    expect(pendingCommits()).toBeNull();
-  });
-
-  it("holds until a commit still in flight has landed", async () => {
-    const stored = { value: "BKG CŨ: " };
-    void trackCommit(commit(stored, "BKG CŨ:  SGNA52926200", 20));
-    const gate = pendingCommits();
-    expect(gate).not.toBeNull();
-    await gate;
-    expect(stored.value).toBe("BKG CŨ:  SGNA52926200");
-  });
-
-  it("holds for EVERY commit in flight, not just the first", async () => {
-    const landed: string[] = [];
-    const land = (name: string, ms: number) =>
-      new Promise<void>((resolve) =>
-        setTimeout(() => {
-          landed.push(name);
-          resolve();
-        }, ms),
-      );
-    void trackCommit(land("slow", 30));
-    void trackCommit(land("fast", 5));
-    await pendingCommits();
-    expect([...landed].sort()).toEqual(["fast", "slow"]);
-  });
-
-  it("releases again once the commits have landed", async () => {
-    await trackCommit(Promise.resolve());
-    await tick();
-    expect(pendingCommits()).toBeNull();
-  });
-
-  it("is released by a FAILED commit too — a stuck gate would wedge every action", async () => {
-    const failed = trackCommit(Promise.reject(new Error("Save failed")));
-    // The caller owns the error: the inline editor keeps the edit and shows it.
-    await expect(failed).rejects.toThrow("Save failed");
-    await expect(pendingCommits() ?? Promise.resolve()).resolves.toBeUndefined();
-    await tick();
-    expect(pendingCommits()).toBeNull();
-  });
-
-  it("ignores a commit started AFTER the gate was taken — it holds the press for the edit that caused it, not later work", async () => {
-    const stored = { value: "before" };
-    void trackCommit(commit(stored, "first", 5));
-    const gate = pendingCommits();
-    void trackCommit(commit(stored, "later", 40));
-    await gate;
-    expect(stored.value).toBe("first");
-  });
-});

package/src/popover_layers.test.ts

@@ -1,113 +0,0 @@
-// @vitest-environment jsdom
-import { describe, expect, test, beforeEach } from "vitest";
-import {
-  hasModalLayerAbove,
-  isInLayerAbove,
-  snapshotOpenModalLayers,
-} from "./popover_layers";
-
-function addModal(): HTMLElement {
-  const modal = document.createElement("div");
-  modal.setAttribute("aria-modal", "true");
-  const inner = document.createElement("button");
-  modal.appendChild(inner);
-  document.body.appendChild(modal);
-  return modal;
-}
-
-function addPopover(level: number): HTMLElement {
-  const popover = document.createElement("div");
-  popover.setAttribute("data-popover", "true");
-  popover.setAttribute("data-popover-level", String(level));
-  const inner = document.createElement("button");
-  popover.appendChild(inner);
-  document.body.appendChild(popover);
-  return popover;
-}
-
-beforeEach(() => {
-  document.body.innerHTML = "";
-});
-
-describe("isInLayerAbove", () => {
-  test("plain page node is not above", () => {
-    const el = document.createElement("div");
-    document.body.appendChild(el);
-    expect(isInLayerAbove(el, 0, new Set())).toBe(false);
-  });
-
-  test("document itself (page scroll target) is not above", () => {
-    expect(isInLayerAbove(document, 0, new Set())).toBe(false);
-  });
-
-  test("text node resolves through its parent element", () => {
-    const modal = addModal();
-    const text = document.createTextNode("hello");
-    modal.appendChild(text);
-    expect(isInLayerAbove(text, 0, new Set())).toBe(true);
-  });
-
-  test("node inside a deeper nested popover is above", () => {
-    const nested = addPopover(1);
-    expect(isInLayerAbove(nested.firstChild as Node, 0, new Set())).toBe(true);
-  });
-
-  test("node inside a same-level popover is not above", () => {
-    const sibling = addPopover(0);
-    expect(isInLayerAbove(sibling.firstChild as Node, 0, new Set())).toBe(false);
-  });
-
-  test("node inside a modal opened AFTER the popover is above (file preview)", () => {
-    const snapshot = snapshotOpenModalLayers(document);
-    const preview = addModal();
-    expect(isInLayerAbove(preview.firstChild as Node, 0, snapshot)).toBe(true);
-  });
-
-  test("node inside the modal the popover LIVES IN is not above (drawer scroll dismisses)", () => {
-    const drawer = addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    expect(isInLayerAbove(drawer.firstChild as Node, 0, snapshot)).toBe(false);
-  });
-
-  test("stacked modals: only the one opened after the popover is above", () => {
-    const drawer = addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    const preview = addModal();
-    expect(isInLayerAbove(drawer.firstChild as Node, 0, snapshot)).toBe(false);
-    expect(isInLayerAbove(preview.firstChild as Node, 0, snapshot)).toBe(true);
-  });
-
-  test("null snapshot treats any modal ancestor as above", () => {
-    const modal = addModal();
-    expect(isInLayerAbove(modal.firstChild as Node, 0, null)).toBe(true);
-  });
-});
-
-describe("hasModalLayerAbove", () => {
-  test("false with no modals", () => {
-    expect(hasModalLayerAbove(document, new Set())).toBe(false);
-  });
-
-  test("false while only pre-existing modals are open (popover in a drawer)", () => {
-    addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    expect(hasModalLayerAbove(document, snapshot)).toBe(false);
-  });
-
-  test("true while a modal opened after the popover is open, false after it closes", () => {
-    addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    const preview = addModal();
-    expect(hasModalLayerAbove(document, snapshot)).toBe(true);
-    preview.remove();
-    expect(hasModalLayerAbove(document, snapshot)).toBe(false);
-  });
-
-  test("a reopened modal is a NEW element and counts as above", () => {
-    const snapshot = snapshotOpenModalLayers(document);
-    const first = addModal();
-    first.remove();
-    addModal();
-    expect(hasModalLayerAbove(document, snapshot)).toBe(true);
-  });
-});

package/src/primitives_purity.test.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect } from "vitest";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-/**
- * Primitives purity test.
- *
- * `@lotics/ui` is the public, published, universal-rendering primitives
- * package. Every file in `src/` is a primitive. It must not import any
- * dependency that ties it to a specific Lotics runtime context: no chat
- * SDK, no analytics, no i18n, and no Lotics domain types (which live in
- * `@lotics/shared`). Lotics-coupled UI is in the workspace-private
- * `@lotics/ui-internal` package, which may import from here and from
- * `@lotics/shared` freely.
- *
- * Markdown (react-markdown/remark) is the one heavy third-party dependency
- * the kit carries on purpose — it's the single canonical renderer for chat,
- * apps, and `AgentRun`. It's generic, not a Lotics coupling; it stays
- * universal via the `markdown.web.tsx` (DOM) / `markdown.tsx` (native
- * plain-text) split and is tree-shaken out of any consumer that doesn't
- * import `./markdown`. So it's allowed — the guards below remain for the
- * genuine context couplings.
- *
- * The ONE allowed `ai` coupling: the `AgentRun` family renders the ai-sdk
- * `UIMessage.parts` shape directly — that IS its contract (both chat and app
- * agents emit it), so there is no bespoke transcript type to keep in sync.
- * `agent_transform.ts` (the single place that folds parts into the render
- * timeline) `import type`s from `ai` — erased at runtime, so no `ai` enters any
- * consumer's bundle. That file alone is exempt from the `ai`-package guard; every
- * other primitive stays ai-free, and the `@ai-sdk/*` runtime packages are never
- * allowed anywhere.
- *
- * The boundary is enforced by this test — without it primitives drift
- * back into the parent app's contexts over months.
- */
-
-const AI_PACKAGE_PATTERN = /from\s+["']ai["']/;
-const FORBIDDEN_PATTERNS = [
-  /from\s+["']posthog-js/,
-  /from\s+["']@lingui\//,
-  /from\s+["']@ai-sdk\//,
-  AI_PACKAGE_PATTERN,
-  /from\s+["']@lotics\/shared/,
-];
-
-// The sole file permitted to `import type` from the `ai` package (see above).
-const AI_PACKAGE_ALLOWED = new Set(["agent_transform.ts"]);
-
-const SRC_DIR = path.resolve(__dirname);
-
-function listTopLevelSourceFiles(): string[] {
-  const entries = fs.readdirSync(SRC_DIR, { withFileTypes: true });
-  return entries
-    .filter((e) => e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx")))
-    .filter((e) => !e.name.endsWith(".test.ts") && !e.name.endsWith(".test.tsx"))
-    .map((e) => path.join(SRC_DIR, e.name));
-}
-
-describe("packages/ui primitives — purity", () => {
-  it("no primitive imports posthog, lingui, ai-sdk, or @lotics/shared", () => {
-    const violations: string[] = [];
-    for (const file of listTopLevelSourceFiles()) {
-      const src = fs.readFileSync(file, "utf-8");
-      for (const pattern of FORBIDDEN_PATTERNS) {
-        if (pattern === AI_PACKAGE_PATTERN && AI_PACKAGE_ALLOWED.has(path.basename(file))) continue;
-        if (pattern.test(src)) {
-          violations.push(`${path.basename(file)} matches ${pattern}`);
-        }
-      }
-    }
-    expect(violations).toEqual([]);
-  });
-});

package/src/remark_gfm_safe.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import { remarkGfmSafe } from "./remark_gfm_safe";
-
-/** Parse markdown to an mdast tree and serialize it, so tests assert on the
- *  resulting document structure without depending on mdast node typings. */
-function parse(markdown: string): string {
-  return JSON.stringify(unified().use(remarkParse).use(remarkGfmSafe).parse(markdown));
-}
-
-describe("remarkGfmSafe", () => {
-  it("autolinks a bare URL in normal text (micromark tokenizer, no lookbehind)", () => {
-    expect(parse("see https://example.com now")).toContain('"url":"https://example.com"');
-  });
-
-  it("autolinks a bare email in normal text (the case the removed sweep also handled)", () => {
-    expect(parse("contact me at a@b.com please")).toContain('"url":"mailto:a@b.com"');
-  });
-
-  it("autolinks a bare www link", () => {
-    expect(parse("visit www.example.com today")).toContain('"url":"http://www.example.com"');
-  });
-
-  it("still parses GFM tables", () => {
-    expect(parse("| a | b |\n| --- | --- |\n| 1 | 2 |")).toContain('"type":"table"');
-  });
-
-  it("still parses strikethrough and task lists", () => {
-    expect(parse("~~gone~~")).toContain('"type":"delete"');
-    expect(parse("- [x] done")).toContain('"checked":true');
-  });
-});

package/src/share_or_download.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { shareOrDownloadFiles, prepareShareFiles, shareFiles } from "./share_or_download";
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  vi.unstubAllGlobals();
-});
-
-describe("shareOrDownloadFiles", () => {
-  it("is a no-op (download/0) when there are no usable files", async () => {
-    expect(await shareOrDownloadFiles([])).toEqual({ delivered: "download", count: 0 });
-    expect(await shareOrDownloadFiles([{ url: "", filename: "x.png" }])).toEqual({ delivered: "download", count: 0 });
-  });
-
-  it("hands the BYTES (not the URL) to the OS share sheet when files can be shared", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => new Response(new Blob(["img"], { type: "image/png" }))));
-    // navigator.share is a true external boundary — assert WHAT crosses it. Typing
-    // the mock's param makes mock.calls[0][0] the shared payload.
-    const share = vi.fn(async (_data: { files: File[]; title?: string }) => undefined);
-    vi.stubGlobal("navigator", { canShare: () => true, share });
-
-    const res = await shareOrDownloadFiles([{ url: "https://r2/presigned", filename: "a.png", mimeType: "image/png" }], { title: "Ảnh" });
-
-    expect(res).toEqual({ delivered: "share", count: 1 });
-    const shared = share.mock.calls[0][0];
-    expect(shared.files).toHaveLength(1);
-    expect(shared.files[0]).toBeInstanceOf(File); // bytes, not a link → no expiry problem
-    expect(shared.files[0].name).toBe("a.png");
-    expect(shared.title).toBe("Ảnh");
-  });
-
-  it("rides the given credentials on the blob fetch so an auth-gated proxy URL authorizes", async () => {
-    // Type the init param so mock.calls[0][1] is the RequestInit we assert on.
-    const fetchMock = vi.fn(async (_url: string, _init?: RequestInit) => new Response(new Blob(["img"], { type: "image/png" })));
-    vi.stubGlobal("fetch", fetchMock);
-    vi.stubGlobal("navigator", { canShare: () => true, share: vi.fn(async () => undefined) });
-
-    await shareOrDownloadFiles([{ url: "https://api.example/v1/files/k", filename: "a.png" }], { credentials: "include" });
-
-    expect(fetchMock.mock.calls[0][1]).toMatchObject({ credentials: "include" });
-  });
-
-  it("treats a cancelled share sheet (AbortError) as done — never falls back to downloading", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => new Response(new Blob(["img"], { type: "image/png" }))));
-    const share = vi.fn(async () => { throw new DOMException("cancelled", "AbortError"); });
-    vi.stubGlobal("navigator", { canShare: () => true, share });
-
-    expect(await shareOrDownloadFiles([{ url: "u", filename: "a.png" }])).toEqual({ delivered: "share", count: 0 });
-  });
-});
-
-describe("prepareShareFiles + shareFiles (iOS: fetch ahead of the gesture, share synchronously)", () => {
-  it("prepareShareFiles fetches the bytes into File[] with the given credentials", async () => {
-    const fetchMock = vi.fn(async (_url: string, _init?: RequestInit) => new Response(new Blob(["img"], { type: "image/png" })));
-    vi.stubGlobal("fetch", fetchMock);
-    vi.stubGlobal("navigator", { canShare: () => true, share: vi.fn() });
-
-    const files = await prepareShareFiles([{ url: "https://api/v1/files/k", filename: "a.png" }], { credentials: "include" });
-
-    expect(files).not.toBeNull();
-    expect(files?.[0]).toBeInstanceOf(File);
-    expect(files?.[0].name).toBe("a.png");
-    expect(fetchMock.mock.calls[0][1]).toMatchObject({ credentials: "include" });
-  });
-
-  it("prepareShareFiles returns null when Web Share (files) is unsupported", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => new Response(new Blob(["img"]))));
-    vi.stubGlobal("navigator", {}); // no canShare / share
-    expect(await prepareShareFiles([{ url: "u", filename: "a.png" }])).toBeNull();
-  });
-
-  it("prepareShareFiles THROWS on a fetch failure (caller logs it, not a silent download)", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => new Response(null, { status: 401 })));
-    vi.stubGlobal("navigator", { canShare: () => true, share: vi.fn() });
-    await expect(prepareShareFiles([{ url: "u", filename: "a.png" }])).rejects.toThrow(/401/);
-  });
-
-  it("shareFiles shares the SAME pre-fetched File (no re-fetch) and maps cancel/unsupported", async () => {
-    const share = vi.fn(async (_d: { files: File[] }) => undefined);
-    vi.stubGlobal("navigator", { canShare: () => true, share });
-    const file = new File(["x"], "a.png", { type: "image/png" });
-
-    expect(await shareFiles([file], { title: "T" })).toBe("shared");
-    expect(share.mock.calls[0][0].files[0]).toBe(file); // the exact pre-fetched File crosses the boundary
-
-    vi.stubGlobal("navigator", { share: vi.fn(async () => { throw new DOMException("x", "AbortError"); }) });
-    expect(await shareFiles([file])).toBe("cancelled");
-
-    vi.stubGlobal("navigator", {}); // no share
-    expect(await shareFiles([file])).toBe("unsupported");
-  });
-});

package/src/table.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { computeTableFit, type TableFitColumn } from "./table_fit";
-
-// The canonical register's columns (tpl_item_list): a fixed identity column,
-// a flexible name column, then fixed data columns — plus a 24px leading
-// checkbox gutter and a 132px trailing actions gutter.
-const REGISTER: TableFitColumn[] = [
-  { key: "ma", width: 112 },
-  { key: "khach" }, // flex
-  { key: "trangThai", width: 112 },
-  { key: "viec", width: 82 },
-  { key: "phi", width: 116 },
-  { key: "ngayNhan", width: 72 },
-];
-
-function visible(fit: ReturnType<typeof computeTableFit>): string[] {
-  return REGISTER.filter((c) => fit.visibleKeys.has(c.key)).map((c) => c.key);
-}
-
-describe("computeTableFit", () => {
-  it("keeps every column when the container fits them all", () => {
-    const fit = computeTableFit(REGISTER, 24, 132, 1040);
-    expect(fit.stacked).toBe(false);
-    expect(visible(fit)).toEqual(["ma", "khach", "trangThai", "viec", "phi", "ngayNhan"]);
-  });
-
-  it("drops columns right-to-left by default, one at a time, until the rest fit", () => {
-    // 700px: the full set (908px) and the set minus "ngayNhan" (822px) overflow;
-    // minus "phi" too (692px) fits.
-    const fit = computeTableFit(REGISTER, 24, 132, 700);
-    expect(fit.stacked).toBe(false);
-    expect(visible(fit)).toEqual(["ma", "khach", "trangThai", "viec"]);
-  });
-
-  it("keeps a high-priority column alive while lower-priority ones drop", () => {
-    const withPriority = REGISTER.map((c) => (c.key === "phi" ? { ...c, priority: 1 } : c));
-    const fit = computeTableFit(withPriority, 24, 132, 700);
-    expect(fit.stacked).toBe(false);
-    // "phi" (priority 1) outlives "trangThai"/"viec"/"ngayNhan" (default = index).
-    expect(fit.visibleKeys.has("phi")).toBe(true);
-    expect(fit.visibleKeys.has("trangThai")).toBe(false);
-    expect(fit.visibleKeys.has("viec")).toBe(false);
-    expect(fit.visibleKeys.has("ngayNhan")).toBe(false);
-  });
-
-  it("never drops the first column", () => {
-    // Wide enough for exactly the identity + flex pair, no more.
-    const fit = computeTableFit(REGISTER, 0, 0, 320);
-    expect(fit.stacked).toBe(false);
-    expect(fit.visibleKeys.has("ma")).toBe(true);
-  });
-
-  it("never drops the first column even when it carries the worst priority", () => {
-    const hostile = REGISTER.map((c) => (c.key === "ma" ? { ...c, priority: 99 } : c));
-    const fit = computeTableFit(hostile, 24, 132, 700);
-    expect(fit.stacked).toBe(false);
-    expect(fit.visibleKeys.has("ma")).toBe(true);
-  });
-
-  it("stacks when even the minimum column set overflows (the phone case)", () => {
-    // A 390px phone minus the page padding: the canonical register's identity +
-    // customer + gutters still need ~470px.
-    const fit = computeTableFit(REGISTER, 24, 132, 334);
-    expect(fit.stacked).toBe(true);
-    // Stacked mode shows every column — vertical space is free.
-    expect(visible(fit)).toEqual(["ma", "khach", "trangThai", "viec", "phi", "ngayNhan"]);
-  });
-
-  it("counts the leading/trailing gutters and gaps in the fit math", () => {
-    // Two fixed columns: 40 padding + 100 + 100 + 1 gap (14) = 254 exactly.
-    const two: TableFitColumn[] = [
-      { key: "a", width: 100 },
-      { key: "b", width: 100 },
-    ];
-    expect(computeTableFit(two, 0, 0, 254).stacked).toBe(false);
-    expect(computeTableFit(two, 0, 0, 253).stacked).toBe(true);
-    // Adding a 24px leading gutter adds the gutter and one more gap.
-    expect(computeTableFit(two, 24, 0, 292).stacked).toBe(false);
-    expect(computeTableFit(two, 24, 0, 291).stacked).toBe(true);
-  });
-
-  it("a single-column table fits until the gutters overflow, then stacks", () => {
-    const one: TableFitColumn[] = [{ key: "a" }];
-    // 40 padding + 120 flex minimum = 160.
-    expect(computeTableFit(one, 0, 0, 200).stacked).toBe(false);
-    const tiny = computeTableFit(one, 0, 0, 100);
-    expect(tiny.stacked).toBe(true);
-    expect(tiny.visibleKeys.has("a")).toBe(true);
-  });
-});

package/src/task_metrics.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { TASK_ROW_BAND, TASK_ROW_GAP, TASK_TITLE_LINE, taskGutter, taskTitleSlack } from "./task_metrics";
-
-describe("task row geometry", () => {
-  it("puts the control's centre and the title's first text line on the SAME y, at every density", () => {
-    for (const band of Object.values(TASK_ROW_BAND)) {
-      // The control centres in the band; the title's first line centres at its slack + half a
-      // line. A density whose band breaks this equality sags the control off its own title.
-      expect(taskTitleSlack(band) + TASK_TITLE_LINE / 2).toBe(band / 2);
-    }
-  });
-
-  it("pins the first line on any band the family builds, not only the density table's", () => {
-    // A sub-field's line is the TALLER of the row band and the control it holds (a 40px inline
-    // editor does not fit a `dense` 32 row), so the law has to hold on bands the density table
-    // never names.
-    for (let band = TASK_TITLE_LINE; band <= 64; band += 2) {
-      expect(taskTitleSlack(band) + TASK_TITLE_LINE / 2).toBe(band / 2);
-    }
-  });
-
-  it("lands every density on whole pixels", () => {
-    for (const band of Object.values(TASK_ROW_BAND)) {
-      expect(Number.isInteger(taskTitleSlack(band))).toBe(true);
-    }
-  });
-
-  it("never pulls a title above its row when the band is shorter than a line of text", () => {
-    expect(taskTitleSlack(TASK_TITLE_LINE - 8)).toBe(0);
-  });
-});
-
-describe("task row gutters", () => {
-  it("gives a pinned control its own width plus the gap that separates it from the content", () => {
-    // ONE rule for BOTH edges: the leading ring's column and the trailing ⋯'s column are the same
-    // arithmetic, which is what lets a row reserve them as plain padding and leave a content box
-    // every line — title, caption, sub-row, detail, nested list — can span exactly.
-    for (const width of [20, 24, 28, 40]) {
-      expect(taskGutter(width)).toBe(width + TASK_ROW_GAP);
-    }
-  });
-
-  it("charges NOTHING for a gutter a list declines", () => {
-    // A list whose rows carry no ⋯ passes `actionWidth={0}` and its content must run to the
-    // container's edge. Leaving the gap behind would bill it 12px for a column it never uses.
-    expect(taskGutter(0)).toBe(0);
-  });
-});