@lotics/ui 20.0.1 → 20.0.2

package/LICENSE.md

@@ -0,0 +1,39 @@
+Copyright (c) 2026 Lotics Technology Company Limited. All rights reserved.
+
+This software is proprietary. It is published to the public npm registry for one
+purpose: building on the Lotics platform.
+
+In this license, **Lotics** means Lotics Technology Company Limited, and **the
+Lotics platform** means the hosted services Lotics operates at lotics.ai and its
+subdomains, together with applications, packages and integrations that run on or
+communicate with those services.
+
+## Permitted
+
+You may install this package and use it **solely in connection with the Lotics
+platform** — including bundling it, in whole or in part, into an application that
+runs on or integrates with the Lotics platform.
+
+## Not permitted
+
+Without prior written permission from Lotics you may not:
+
+1. use this software, or any portion of it, independently of the Lotics platform
+   — including in any application, product or service that neither runs on nor
+   integrates with the Lotics platform;
+2. copy, republish, redistribute or sublicense the source code, in whole or in
+   part, other than as the bundled dependency described above;
+3. create derivative works from the source code, or incorporate any portion of it
+   into another library, product or package;
+4. reverse engineer, decompile or disassemble any compiled artifact, except to the
+   extent that restriction is unenforceable under applicable law;
+5. use the source code, or any portion of it, to train or fine-tune a machine
+   learning model.
+
+## No warranty
+
+This software is provided "as is", without warranty of any kind, express or
+implied. In no event shall Lotics be liable for any claim, damages or other
+liability arising from the software or its use.
+
+For any other use, contact minh@lotics.ai.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/ui",
-  "version": "20.0.1",
+  "version": "20.0.2",
   "type": "module",
   "exports": {
     "./vite": {
@@ -248,7 +248,9 @@
     "examples",
     "AGENTS.md",
     "MIGRATION.md",
-    "docs"
+    "docs",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx"
   ],
   "publishConfig": {
     "access": "public"
@@ -258,7 +260,7 @@
     "url": "https://github.com/lotics/lotics.git",
     "directory": "packages/ui"
   },
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
     "@lotics/docx": "^0.1.0",
     "@lotics/xlsx": "^0.1.0",

package/src/agent_transform.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toSegments, anyRunning, lastRunningStep, type AgentUIPart, type AgentSegment, type AgentStep } from "./agent_transform";
-
-// RN-free logic test for the parts → timeline fold. The renderer (agent_run.tsx)
-// is verified visually in the gallery; the mapping — ai's 7-state tool machine to
-// the feed's 4 states, plus grouping — is unit-tested here. Fixtures are the ai-sdk
-// `dynamic-tool` part shape (contextually typed as `AgentUIPart`, so each concrete
-// `state` discriminates to the right member — no casts).
-
-function groups(parts: AgentUIPart[]): Extract<AgentSegment, { kind: "group" }>[] {
-  return toSegments(parts).filter((s): s is Extract<AgentSegment, { kind: "group" }> => s.kind === "group");
-}
-
-function onlyStep(parts: AgentUIPart[]): AgentStep {
-  const [group, ...rest] = groups(parts);
-  expect(rest).toHaveLength(0);
-  expect(group.steps).toHaveLength(1);
-  return group.steps[0];
-}
-
-describe("agent_transform — tool state mapping", () => {
-  it("input-streaming → running", () => {
-    expect(onlyStep([{ type: "dynamic-tool", toolName: "update_records", toolCallId: "t", state: "input-streaming", input: {} }]).status).toBe("running");
-  });
-
-  it("input-available → running", () => {
-    expect(onlyStep([{ type: "dynamic-tool", toolName: "update_records", toolCallId: "t", state: "input-available", input: {} }]).status).toBe("running");
-  });
-
-  it("approval-requested → awaiting (parked on a human decision)", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "approval-requested", input: { table: "Containers" }, approval: { id: "a1" } }]);
-    expect(step.status).toBe("awaiting");
-    // The input still rides along for the on-demand peek.
-    expect(step.input).toEqual({ table: "Containers" });
-  });
-
-  it("approval-responded → running (the decision is in, work resumes)", () => {
-    expect(onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "approval-responded", input: {}, approval: { id: "a1", approved: true } }]).status).toBe("running");
-  });
-
-  it("output-available → done, carrying the output", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "output-available", input: { q: 1 }, output: { rows: 3 } }]);
-    expect(step.status).toBe("done");
-    expect(step.output).toEqual({ rows: 3 });
-  });
-
-  it("output-error → error, carrying errorText", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "output-error", input: {}, errorText: "Unknown field" }]);
-    expect(step.status).toBe("error");
-    expect(step.errorText).toBe("Unknown field");
-  });
-
-  it("output-denied → error, with the denial reason as the error text", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "output-denied", input: {}, approval: { id: "a1", approved: false, reason: "Delete not permitted" } }]);
-    expect(step.status).toBe("error");
-    expect(step.errorText).toBe("Delete not permitted");
-  });
-
-  it("output-denied without a reason → error with no error text", () => {
-    const step = onlyStep([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "output-denied", input: {}, approval: { id: "a1", approved: false } }]);
-    expect(step.status).toBe("error");
-    expect(step.errorText).toBeUndefined();
-  });
-});
-
-describe("agent_transform — streaming signals", () => {
-  it("anyRunning is true while a call runs, false once every call has settled", () => {
-    const running = toSegments([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "input-available", input: {} }]);
-    expect(anyRunning(running)).toBe(true);
-
-    const settled = toSegments([{ type: "dynamic-tool", toolName: "query_records", toolCallId: "t", state: "output-available", input: {}, output: {} }]);
-    expect(anyRunning(settled)).toBe(false);
-  });
-
-  it("an awaiting call is NOT running — it's parked, so the feed never pulses it", () => {
-    const parked = toSegments([{ type: "dynamic-tool", toolName: "delete_records", toolCallId: "t", state: "approval-requested", input: {}, approval: { id: "a1" } }]);
-    expect(anyRunning(parked)).toBe(false);
-    expect(lastRunningStep(parked)).toBeUndefined();
-  });
-});
-
-describe("agent_transform — grouping", () => {
-  it("folds consecutive tool parts into ONE group, split by prose", () => {
-    const parts: AgentUIPart[] = [
-      { type: "text", text: "First" },
-      { type: "dynamic-tool", toolName: "query_records", toolCallId: "a", state: "output-available", input: {}, output: {} },
-      { type: "dynamic-tool", toolName: "query_records", toolCallId: "b", state: "output-available", input: {}, output: {} },
-      { type: "text", text: "Then" },
-      { type: "dynamic-tool", toolName: "delete_records", toolCallId: "c", state: "approval-requested", input: {}, approval: { id: "a1" } },
-    ];
-    expect(toSegments(parts).map((s) => s.kind)).toEqual(["text", "group", "text", "group"]);
-    const [first, second] = groups(parts);
-    expect(first.steps.map((s) => s.id)).toEqual(["a", "b"]);
-    expect(second.steps.map((s) => s.status)).toEqual(["awaiting"]);
-  });
-});

package/src/calendar/layout.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { layoutDayColumns, packEventLanes } from "./layout";
-import type { CalendarEvent } from "./types";
-
-const DAY = new Date(2026, 0, 15);
-const at = (h: number, m = 0) => new Date(2026, 0, 15, h, m);
-const ev = (id: string, sh: number, sm: number, eh: number, em: number): CalendarEvent => ({
-  id,
-  title: id,
-  start: at(sh, sm),
-  end: at(eh, em),
-});
-
-/** column/columns keyed by event id, for order-independent assertions. */
-function geom(events: CalendarEvent[]) {
-  return Object.fromEntries(
-    layoutDayColumns(DAY, events).map((c) => [c.event.id, { column: c.column, columns: c.columns }]),
-  );
-}
-
-describe("layoutDayColumns", () => {
-  it("returns nothing for an empty day", () => {
-    expect(layoutDayColumns(DAY, [])).toEqual([]);
-  });
-
-  it("stacks non-overlapping events in a single column", () => {
-    const g = geom([ev("a", 9, 0, 10, 0), ev("b", 11, 0, 12, 0)]);
-    expect(g.a).toEqual({ column: 0, columns: 1 });
-    expect(g.b).toEqual({ column: 0, columns: 1 });
-  });
-
-  it("splits two fully overlapping events into two columns", () => {
-    const g = geom([ev("a", 9, 0, 10, 0), ev("b", 9, 0, 10, 0)]);
-    expect(g.a.columns).toBe(2);
-    expect(g.b.columns).toBe(2);
-    expect(new Set([g.a.column, g.b.column])).toEqual(new Set([0, 1]));
-  });
-
-  it("gives three concurrent events three columns", () => {
-    const g = geom([ev("a", 9, 0, 12, 0), ev("b", 9, 0, 12, 0), ev("c", 9, 0, 12, 0)]);
-    expect(new Set([g.a.column, g.b.column, g.c.column])).toEqual(new Set([0, 1, 2]));
-    for (const k of ["a", "b", "c"]) expect(g[k].columns).toBe(3);
-  });
-
-  it("reuses a freed column within a transitive cluster (A→B→C chain)", () => {
-    // A 9-10, B 9:30-11 (overlaps A), C 10:30-12 (overlaps B, not A).
-    // One cluster via B; 2 columns; C reuses A's column once A ends.
-    const g = geom([ev("a", 9, 0, 10, 0), ev("b", 9, 30, 11, 0), ev("c", 10, 30, 12, 0)]);
-    expect(g.a.columns).toBe(2);
-    expect(g.a.column).toBe(0);
-    expect(g.b.column).toBe(1);
-    expect(g.c.column).toBe(0); // freed by A
-  });
-
-  it("treats time-separated events as independent clusters", () => {
-    const g = geom([ev("morn1", 9, 0, 10, 0), ev("morn2", 9, 0, 10, 0), ev("aft", 14, 0, 15, 0)]);
-    expect(g.morn1.columns).toBe(2);
-    expect(g.morn2.columns).toBe(2);
-    expect(g.aft).toEqual({ column: 0, columns: 1 }); // own cluster
-  });
-
-  it("positions and floors height; clamps to the day window", () => {
-    const [c] = layoutDayColumns(DAY, [ev("x", 9, 0, 9, 5)]);
-    expect(c.topMinutes).toBe(540); // 9:00
-    expect(c.heightMinutes).toBeGreaterThanOrEqual(20); // 5-min event floored
-    const spill = layoutDayColumns(DAY, [
-      { id: "y", title: "y", start: at(23, 0), end: new Date(2026, 0, 16, 2, 0) },
-    ])[0];
-    expect(spill.topMinutes).toBe(1380); // 23:00
-    expect(spill.topMinutes + spill.heightMinutes).toBeLessThanOrEqual(1440); // clamped
-  });
-});
-
-describe("packEventLanes", () => {
-  const WEEK = new Date(2026, 0, 12); // Mon
-  const allDay = (id: string, startDay: number, endDay: number): CalendarEvent => ({
-    id,
-    title: id,
-    start: new Date(2026, 0, 12 + startDay),
-    end: new Date(2026, 0, 12 + endDay),
-    allDay: true,
-  });
-
-  it("places non-overlapping spans in one lane", () => {
-    const { bars, lanes } = packEventLanes([allDay("a", 0, 1), allDay("b", 3, 4)], WEEK, 7);
-    expect(lanes).toBe(1);
-    expect(bars.find((b) => b.event.id === "a")).toMatchObject({ startCol: 0, span: 2, lane: 0 });
-    expect(bars.find((b) => b.event.id === "b")).toMatchObject({ startCol: 3, span: 2, lane: 0 });
-  });
-
-  it("stacks overlapping multi-day spans into separate lanes", () => {
-    const { lanes } = packEventLanes([allDay("a", 0, 3), allDay("b", 2, 5)], WEEK, 7);
-    expect(lanes).toBe(2);
-  });
-
-  it("clamps a span that starts before the window and filters out-of-range", () => {
-    const before: CalendarEvent = { id: "x", title: "x", start: new Date(2026, 0, 9), end: new Date(2026, 0, 13), allDay: true };
-    const after = allDay("y", 9, 10); // entirely after a 7-day window
-    const { bars } = packEventLanes([before, after], WEEK, 7);
-    expect(bars).toHaveLength(1);
-    expect(bars[0]).toMatchObject({ event: { id: "x" }, startCol: 0, span: 2 }); // clamped to days 0..1
-  });
-});

package/src/colors.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isColorName, asColorName } from "./colors";
-
-describe("isColorName", () => {
-  it("accepts palette family names", () => {
-    expect(isColorName("blue")).toBe(true);
-    expect(isColorName("emerald")).toBe(true);
-    expect(isColorName("zinc")).toBe(true);
-  });
-
-  it("rejects role keys and scalar colors (not selectable families)", () => {
-    expect(isColorName("border")).toBe(false);
-    expect(isColorName("border_shadow")).toBe(false);
-    expect(isColorName("background")).toBe(false);
-    expect(isColorName("shadow")).toBe(false);
-    expect(isColorName("black")).toBe(false);
-    expect(isColorName("white")).toBe(false);
-  });
-
-  it("rejects unknown tokens and non-strings", () => {
-    expect(isColorName("chartreuse")).toBe(false);
-    expect(isColorName("")).toBe(false);
-    expect(isColorName(undefined)).toBe(false);
-    expect(isColorName(null)).toBe(false);
-    expect(isColorName(42)).toBe(false);
-  });
-});
-
-describe("asColorName", () => {
-  it("passes a valid family through", () => {
-    expect(asColorName("purple")).toBe("purple");
-  });
-
-  it("degrades an unknown/absent token to the neutral default", () => {
-    // The graceful-degradation contract: a select option whose color token this
-    // build doesn't recognize, or none at all, renders neutral rather than break.
-    expect(asColorName("chartreuse")).toBe("zinc");
-    expect(asColorName(undefined)).toBe("zinc");
-    expect(asColorName(null)).toBe("zinc");
-  });
-
-  it("honors a custom fallback", () => {
-    expect(asColorName(undefined, "slate")).toBe("slate");
-  });
-});

package/src/date_filter_presets.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getPresetValue, PRESET_IDS, type PresetId } from "./date_filter_presets";
-
-// Wednesday, 10 June 2026, 14:30 — a fixed clock so every range is deterministic.
-const NOW = new Date(2026, 5, 10, 14, 30, 0, 0);
-
-function ymd(d: Date | null): string {
-  if (!d) return "null";
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-}
-
-describe("getPresetValue", () => {
-  it("today spans the start to end of the current day", () => {
-    const v = getPresetValue("today", NOW)!;
-    expect(ymd(v.start.date)).toBe("2026-06-10");
-    expect(ymd(v.end.date)).toBe("2026-06-10");
-    expect(v.start.date!.getHours()).toBe(0);
-    expect(v.start.date!.getMilliseconds()).toBe(0);
-    expect(v.end.date!.getHours()).toBe(23);
-    expect(v.end.date!.getMinutes()).toBe(59);
-    expect(v.end.date!.getMilliseconds()).toBe(999);
-  });
-
-  it("yesterday and tomorrow shift by one day", () => {
-    expect(ymd(getPresetValue("yesterday", NOW)!.start.date)).toBe("2026-06-09");
-    expect(ymd(getPresetValue("yesterday", NOW)!.end.date)).toBe("2026-06-09");
-    expect(ymd(getPresetValue("tomorrow", NOW)!.start.date)).toBe("2026-06-11");
-    expect(ymd(getPresetValue("tomorrow", NOW)!.end.date)).toBe("2026-06-11");
-  });
-
-  it("this_week runs Monday → Sunday around now", () => {
-    const v = getPresetValue("this_week", NOW)!;
-    expect(ymd(v.start.date)).toBe("2026-06-08"); // Monday
-    expect(v.start.date!.getDay()).toBe(1);
-    expect(ymd(v.end.date)).toBe("2026-06-14"); // Sunday
-    expect(v.end.date!.getDay()).toBe(0);
-  });
-
-  it("this_month covers the whole calendar month", () => {
-    const v = getPresetValue("this_month", NOW)!;
-    expect(ymd(v.start.date)).toBe("2026-06-01");
-    expect(ymd(v.end.date)).toBe("2026-06-30");
-  });
-
-  it("last_month covers the previous calendar month", () => {
-    const v = getPresetValue("last_month", NOW)!;
-    expect(ymd(v.start.date)).toBe("2026-05-01");
-    expect(ymd(v.end.date)).toBe("2026-05-31");
-  });
-
-  it("custom carries no range", () => {
-    expect(getPresetValue("custom", NOW)).toBeNull();
-  });
-
-  it("every preset id resolves (only custom is null)", () => {
-    for (const id of PRESET_IDS) {
-      const v = getPresetValue(id as PresetId, NOW);
-      if (id === "custom") expect(v).toBeNull();
-      else expect(v).not.toBeNull();
-    }
-  });
-});

package/src/date_picker_value.test.ts

@@ -1,204 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  parsePart,
-  partsToIso,
-  parseText,
-  resolveDateCommit,
-  timeText,
-  splitTime,
-  isoToDate,
-  parseTimeString,
-  withCalendarDate,
-  withTimeOfDay,
-  nowIso,
-} from "./date_picker_value";
-
-describe("parsePart", () => {
-  it("parses a plain date", () => {
-    expect(parsePart("2026-05-17")).toEqual({ y: 2026, mo: 5, d: 17, h: 0, mi: 0 });
-  });
-
-  it("parses a datetime with T or space separator", () => {
-    expect(parsePart("2026-05-17T14:30")).toEqual({ y: 2026, mo: 5, d: 17, h: 14, mi: 30 });
-    expect(parsePart("2026-05-17 14:30")).toEqual({ y: 2026, mo: 5, d: 17, h: 14, mi: 30 });
-  });
-
-  it("is lenient on missing leading zeros", () => {
-    expect(parsePart("2026-3-7")).toEqual({ y: 2026, mo: 3, d: 7, h: 0, mi: 0 });
-  });
-
-  it("trims surrounding whitespace", () => {
-    expect(parsePart("  2026-05-17  ")).toEqual({ y: 2026, mo: 5, d: 17, h: 0, mi: 0 });
-  });
-
-  it("rejects impossible calendar dates", () => {
-    expect(parsePart("2026-02-30")).toBeNull();
-    expect(parsePart("2026-13-01")).toBeNull();
-    expect(parsePart("2026-00-10")).toBeNull();
-  });
-
-  it("rejects out-of-range times", () => {
-    expect(parsePart("2026-05-17 24:00")).toBeNull();
-    expect(parsePart("2026-05-17 12:60")).toBeNull();
-  });
-
-  it("rejects malformed input", () => {
-    expect(parsePart("not-a-date")).toBeNull();
-    expect(parsePart("2026/05/17")).toBeNull();
-    expect(parsePart("")).toBeNull();
-  });
-});
-
-describe("partsToIso", () => {
-  it("formats a date without time", () => {
-    expect(partsToIso({ y: 2026, mo: 5, d: 7, h: 0, mi: 0 }, false)).toBe("2026-05-07");
-  });
-
-  it("formats a datetime with zero-padded time", () => {
-    expect(partsToIso({ y: 2026, mo: 5, d: 7, h: 9, mi: 5 }, true)).toBe("2026-05-07T09:05");
-  });
-});
-
-describe("parseText", () => {
-  it("returns empty string for blank input (clear)", () => {
-    expect(parseText("", false)).toBe("");
-    expect(parseText("   ", false)).toBe("");
-  });
-
-  it("parses a single date", () => {
-    expect(parseText("2026-3-7", false)).toBe("2026-03-07");
-  });
-
-  it("drops the time component for date-only formats", () => {
-    expect(parseText("2026-05-17 14:30", false)).toBe("2026-05-17");
-  });
-
-  it("keeps the time component for datetime formats", () => {
-    expect(parseText("2026-05-17 14:30", true)).toBe("2026-05-17T14:30");
-  });
-
-  it("returns null for an unparseable value", () => {
-    expect(parseText("2026-02-30", false)).toBeNull();
-    expect(parseText("garbage", false)).toBeNull();
-  });
-});
-
-describe("timeText", () => {
-  it("extracts HH:mm from a datetime value", () => {
-    expect(timeText("2026-05-17T09:05")).toBe("09:05");
-  });
-
-  it("treats a date-only value as midnight", () => {
-    expect(timeText("2026-05-17")).toBe("00:00");
-  });
-
-  it("returns empty for an unparseable value", () => {
-    expect(timeText("")).toBe("");
-  });
-});
-
-describe("splitTime", () => {
-  it("splits a canonical time string", () => {
-    expect(splitTime("14:30")).toEqual({ h: 14, mi: 30 });
-  });
-
-  it("returns midnight for empty input", () => {
-    expect(splitTime("")).toEqual({ h: 0, mi: 0 });
-  });
-});
-
-describe("isoToDate", () => {
-  it("builds a local Date from an ISO string", () => {
-    const date = isoToDate("2026-05-17T14:30");
-    expect(date?.getFullYear()).toBe(2026);
-    expect(date?.getMonth()).toBe(4);
-    expect(date?.getDate()).toBe(17);
-    expect(date?.getHours()).toBe(14);
-    expect(date?.getMinutes()).toBe(30);
-  });
-
-  it("returns null for an unparseable string", () => {
-    expect(isoToDate("")).toBeNull();
-    expect(isoToDate("2026-02-30")).toBeNull();
-  });
-});
-
-describe("withCalendarDate", () => {
-  const may20 = new Date(2026, 4, 20);
-
-  it("keeps the time carried by the previous value for datetime formats", () => {
-    expect(withCalendarDate(may20, "2026-01-01T14:30", true)).toBe("2026-05-20T14:30");
-  });
-
-  it("defaults to midnight when the previous value has no time", () => {
-    expect(withCalendarDate(may20, "", true)).toBe("2026-05-20T00:00");
-  });
-
-  it("drops the time component for date-only formats", () => {
-    expect(withCalendarDate(may20, "2026-01-01T14:30", false)).toBe("2026-05-20");
-  });
-});
-
-describe("withTimeOfDay", () => {
-  it("keeps the date and applies the new time", () => {
-    expect(withTimeOfDay("2026-05-20", "09:05")).toBe("2026-05-20T09:05");
-    expect(withTimeOfDay("2026-05-20T14:30", "08:00")).toBe("2026-05-20T08:00");
-  });
-});
-
-describe("nowIso", () => {
-  it("produces a canonical date or datetime string", () => {
-    expect(nowIso(false)).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-    expect(nowIso(true)).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/);
-  });
-});
-
-describe("parseTimeString", () => {
-  it("parses and zero-pads a valid time", () => {
-    expect(parseTimeString("9:05")).toBe("09:05");
-    expect(parseTimeString("14:30")).toBe("14:30");
-  });
-
-  it("rejects out-of-range or malformed times", () => {
-    expect(parseTimeString("24:00")).toBeNull();
-    expect(parseTimeString("12:60")).toBeNull();
-    expect(parseTimeString("1430")).toBeNull();
-    expect(parseTimeString("")).toBeNull();
-  });
-});
-
-describe("resolveDateCommit — the inline editor's commit contract", () => {
-  it("a typed complete date commits the value", () => {
-    expect(
-      resolveDateCommit({ draft: "2026-03-15", value: "2026-01-01", incomplete: false, clearable: false }),
-    ).toEqual({ kind: "save", value: "2026-03-15" });
-    // …including onto an empty field.
-    expect(
-      resolveDateCommit({ draft: "2026-03-15", value: null, incomplete: false, clearable: false }),
-    ).toEqual({ kind: "save", value: "2026-03-15" });
-  });
-
-  it("a partial entry never commits and never clears the stored value", () => {
-    expect(
-      resolveDateCommit({ draft: "2026-01-01", value: "2026-01-01", incomplete: true, clearable: true }),
-    ).toEqual({ kind: "invalid" });
-  });
-
-  it("an unchanged draft exits without a write (a touched-but-equal date is not a diff)", () => {
-    expect(
-      resolveDateCommit({ draft: "2026-01-01", value: "2026-01-01", incomplete: false, clearable: true }),
-    ).toEqual({ kind: "none" });
-    expect(resolveDateCommit({ draft: "", value: null, incomplete: false, clearable: true })).toEqual({
-      kind: "none",
-    });
-  });
-
-  it("an emptied entry clears only when the field is clearable", () => {
-    expect(
-      resolveDateCommit({ draft: "", value: "2026-01-01", incomplete: false, clearable: true }),
-    ).toEqual({ kind: "clear" });
-    expect(
-      resolveDateCommit({ draft: "", value: "2026-01-01", incomplete: false, clearable: false }),
-    ).toEqual({ kind: "none" });
-  });
-});

package/src/date_range_selection.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { nextRangeSelection, type DateRangeSelection } from "./date_range_selection";
-
-const d = (day: number): Date => new Date(2026, 6, day);
-const ymd = (x: Date | null): string =>
-  x ? `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, "0")}-${String(x.getDate()).padStart(2, "0")}` : "null";
-const EMPTY: DateRangeSelection = { start: null, end: null };
-
-describe("nextRangeSelection", () => {
-  it("opens a range on the first click", () => {
-    const next = nextRangeSelection(EMPTY, d(14));
-    expect(ymd(next.start)).toBe("2026-07-14");
-    expect(next.end).toBeNull();
-  });
-
-  it("closes the open range on the second click", () => {
-    const next = nextRangeSelection({ start: d(14), end: null }, d(20));
-    expect(ymd(next.start)).toBe("2026-07-14");
-    expect(ymd(next.end)).toBe("2026-07-20");
-  });
-
-  it("orders the bounds when the later day is clicked first", () => {
-    const next = nextRangeSelection({ start: d(20), end: null }, d(14));
-    expect(ymd(next.start)).toBe("2026-07-14");
-    expect(ymd(next.end)).toBe("2026-07-20");
-  });
-
-  // The whole point of dropping the single/range mode: a range must be
-  // reachable from EVERY starting value, including one that is already a
-  // single day. Under the mode, a single-day value silently disabled range
-  // selection entirely — two clicks just moved the one day around.
-  it("reaches a range from a single-day value", () => {
-    const singleDay: DateRangeSelection = { start: d(31), end: d(31) };
-    const opened = nextRangeSelection(singleDay, d(1));
-    const closed = nextRangeSelection(opened, d(20));
-    expect(ymd(closed.start)).toBe("2026-07-01");
-    expect(ymd(closed.end)).toBe("2026-07-20");
-  });
-
-  it("reaches a range from a closed multi-day range", () => {
-    const opened = nextRangeSelection({ start: d(1), end: d(5) }, d(10));
-    expect(ymd(opened.start)).toBe("2026-07-10");
-    expect(opened.end).toBeNull();
-    expect(ymd(nextRangeSelection(opened, d(12)).end)).toBe("2026-07-12");
-  });
-
-  // Selecting one day is clicking it twice — the replacement for the mode.
-  it("selects a single day when the same day is clicked twice", () => {
-    const next = nextRangeSelection(nextRangeSelection(EMPTY, d(14)), d(14));
-    expect(ymd(next.start)).toBe("2026-07-14");
-    expect(ymd(next.end)).toBe("2026-07-14");
-  });
-
-  it("never mutates the selection it is given", () => {
-    const current: DateRangeSelection = { start: d(14), end: null };
-    nextRangeSelection(current, d(20));
-    expect(ymd(current.start)).toBe("2026-07-14");
-    expect(current.end).toBeNull();
-  });
-});