@lotics/ui 20.0.1 → 20.1.0

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();
-  });
-});

package/src/date_segments.test.ts

@@ -1,335 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { resolveLocaleTag, en as enLocale, vi as viLocale } from "./locale";
-import {
-  getDateLayout,
-  getTimeLayout,
-  timeSegmentsConfig,
-  segmentsToTime,
-  fieldOrder,
-  to12h,
-  from12h,
-  typeDigit,
-  incrementSegment,
-  separatorAdvances,
-  setHourField,
-  withDayPeriod,
-  displayValue,
-  valueToSegments,
-  segmentsToValue,
-  isBufferEmpty,
-  placeholderFor,
-} from "./date_segments";
-
-const empty = { year: null, month: null, day: null, hour: null, minute: null };
-
-describe("getDateLayout / fieldOrder", () => {
-  it("derives m/d/y and 12h for en-US", () => {
-    expect(fieldOrder(getDateLayout("en-US", false))).toEqual(["month", "day", "year"]);
-    const dt = getDateLayout("en-US", true);
-    expect(fieldOrder(dt)).toEqual(["month", "day", "year", "hour", "minute", "dayPeriod"]);
-    expect(dt.hour12).toBe(true);
-  });
-
-  it("derives d/m/y, 24h, and time-first datetime for vi-VN", () => {
-    expect(fieldOrder(getDateLayout("vi-VN", false))).toEqual(["day", "month", "year"]);
-    const dt = getDateLayout("vi-VN", true);
-    // Vietnamese leads with the time ("HH:mm dd/MM/yyyy") — we follow the locale.
-    expect(fieldOrder(dt)).toEqual(["hour", "minute", "day", "month", "year"]);
-    expect(dt.hour12).toBe(false);
-  });
-
-  it("derives d/m/y for en-GB and y/m/d for ja-JP", () => {
-    expect(fieldOrder(getDateLayout("en-GB", false))).toEqual(["day", "month", "year"]);
-    expect(fieldOrder(getDateLayout("ja-JP", false))).toEqual(["year", "month", "day"]);
-  });
-
-  it("emits literal separators between fields", () => {
-    const literals = getDateLayout("en-US", false).segments.filter((s) => s.kind === "literal");
-    expect(literals.length).toBeGreaterThan(0);
-  });
-});
-
-describe("to12h / from12h", () => {
-  it("maps 24h to 12h", () => {
-    expect(to12h(0)).toEqual({ h12: 12, pm: false });
-    expect(to12h(12)).toEqual({ h12: 12, pm: true });
-    expect(to12h(13)).toEqual({ h12: 1, pm: true });
-    expect(to12h(23)).toEqual({ h12: 11, pm: true });
-  });
-
-  it("maps 12h back to 24h", () => {
-    expect(from12h(12, false)).toBe(0);
-    expect(from12h(12, true)).toBe(12);
-    expect(from12h(1, true)).toBe(13);
-    expect(from12h(11, false)).toBe(11);
-  });
-});
-
-describe("typeDigit", () => {
-  it("waits for a second digit when one could still fit", () => {
-    expect(typeDigit("month", "", "1", false)).toEqual({ text: "1", value: 1, complete: false });
-    expect(typeDigit("day", "", "3", false)).toEqual({ text: "3", value: 3, complete: false });
-    expect(typeDigit("minute", "", "5", false)).toEqual({ text: "5", value: 5, complete: false });
-  });
-
-  it("auto-advances when no second digit could keep it in range", () => {
-    expect(typeDigit("month", "", "2", false)).toEqual({ text: "2", value: 2, complete: true });
-    expect(typeDigit("day", "", "4", false)).toEqual({ text: "4", value: 4, complete: true });
-    expect(typeDigit("minute", "", "6", false)).toEqual({ text: "6", value: 6, complete: true });
-    expect(typeDigit("hour", "", "3", false)).toEqual({ text: "3", value: 3, complete: true });
-    expect(typeDigit("hour", "", "2", true)).toEqual({ text: "2", value: 2, complete: true });
-  });
-
-  it("completes on the second digit", () => {
-    expect(typeDigit("month", "1", "2", false)).toEqual({ text: "12", value: 12, complete: true });
-    expect(typeDigit("minute", "5", "9", false)).toEqual({ text: "59", value: 59, complete: true });
-  });
-
-  it("restarts when the accumulated value overflows", () => {
-    expect(typeDigit("month", "1", "5", false)).toEqual({ text: "5", value: 5, complete: true });
-    expect(typeDigit("hour", "2", "5", false)).toEqual({ text: "5", value: 5, complete: true });
-  });
-
-  it("accumulates up to four digits for the year", () => {
-    expect(typeDigit("year", "", "2", false)).toEqual({ text: "2", value: 2, complete: false });
-    expect(typeDigit("year", "202", "6", false)).toEqual({
-      text: "2026",
-      value: 2026,
-      complete: true,
-    });
-    expect(typeDigit("year", "2026", "7", false)).toEqual({
-      text: "0267",
-      value: 267,
-      complete: true,
-    });
-  });
-});
-
-describe("typed date entry — the inline keyboard path", () => {
-  // Simulate the segment engine's typing pipeline: each keystroke flows through
-  // typeDigit in the locale's own field order; the buffer then resolves through
-  // segmentsToValue. This is the outcome contract behind "type 15/03/2026 into
-  // an inline date editor and it commits".
-  it("a typed dd/MM/yyyy date composes the committed ISO value (vi-VN order)", () => {
-    expect(fieldOrder(getDateLayout("vi-VN", false))).toEqual(["day", "month", "year"]);
-    const day = typeDigit("day", typeDigit("day", "", "1", false).text, "5", false);
-    expect(day).toEqual({ text: "15", value: 15, complete: true });
-    const month = typeDigit("month", typeDigit("month", "", "0", false).text, "3", false);
-    expect(month).toEqual({ text: "03", value: 3, complete: true });
-    let yearText = "";
-    for (const digit of ["2", "0", "2", "6"]) yearText = typeDigit("year", yearText, digit, false).text;
-    const buffer = { year: Number(yearText), month: month.value, day: day.value, hour: null, minute: null };
-    expect(segmentsToValue(buffer, false)).toBe("2026-03-15");
-  });
-
-  it("a single-digit d/M/yyyy entry advances on the separator and still commits", () => {
-    // "1/1/2026": neither "1" can auto-advance (a second digit could still
-    // fit — "12", "11") — the typed "/" is the explicit advance.
-    const day = typeDigit("day", "", "1", false);
-    expect(day.complete).toBe(false);
-    expect(separatorAdvances("/", day.text !== "")).toBe(true);
-    const month = typeDigit("month", "", "1", false);
-    expect(month.complete).toBe(false);
-    expect(separatorAdvances("/", month.text !== "")).toBe(true);
-    const buffer = { year: 2026, month: month.value, day: day.value, hour: null, minute: null };
-    expect(segmentsToValue(buffer, false)).toBe("2026-01-01");
-  });
-
-  it("separators advance only off a segment that has content", () => {
-    for (const key of ["/", ".", "-", ",", ":", " "]) {
-      expect(separatorAdvances(key, true)).toBe(true);
-      expect(separatorAdvances(key, false)).toBe(false);
-    }
-    expect(separatorAdvances("a", true)).toBe(false);
-    expect(separatorAdvances("ArrowDown", true)).toBe(false);
-  });
-
-  it("an impossible typed date never composes a value", () => {
-    expect(segmentsToValue({ year: 2026, month: 2, day: 30, hour: null, minute: null }, false)).toBeNull();
-  });
-});
-
-describe("incrementSegment", () => {
-  it("wraps within range", () => {
-    expect(incrementSegment("month", 12, 1, false)).toBe(1);
-    expect(incrementSegment("month", 1, -1, false)).toBe(12);
-    expect(incrementSegment("minute", 59, 1, false)).toBe(0);
-    expect(incrementSegment("hour", 23, 1, false)).toBe(0);
-    expect(incrementSegment("hour", 12, 1, true)).toBe(1);
-  });
-
-  it("starts from an end when empty", () => {
-    expect(incrementSegment("day", null, 1, false)).toBe(1);
-    expect(incrementSegment("day", null, -1, false)).toBe(31);
-  });
-
-  it("clamps the year instead of wrapping", () => {
-    expect(incrementSegment("year", 2026, 1, false)).toBe(2027);
-    expect(incrementSegment("year", 9999, 1, false)).toBe(9999);
-    expect(incrementSegment("year", 1, -1, false)).toBe(1);
-  });
-});
-
-describe("setHourField / withDayPeriod", () => {
-  it("keeps AM/PM when typing the hour in 12h mode", () => {
-    expect(setHourField({ ...empty, hour: 14 }, 9, true)).toBe(21); // 9 PM
-    expect(setHourField({ ...empty, hour: 9 }, 11, true)).toBe(11); // 11 AM
-  });
-
-  it("returns the typed hour as-is in 24h mode", () => {
-    expect(setHourField({ ...empty, hour: null }, 18, false)).toBe(18);
-  });
-
-  it("toggles half-day while preserving the 12h value", () => {
-    expect(withDayPeriod({ ...empty, hour: 9 }, true)).toBe(21);
-    expect(withDayPeriod({ ...empty, hour: 21 }, false)).toBe(9);
-  });
-});
-
-describe("displayValue", () => {
-  const en = getDateLayout("en-US", true);
-  const vn = getDateLayout("vi-VN", true);
-
-  it("renders the 12h hour and AM/PM for en-US", () => {
-    const buffer = { year: 2026, month: 5, day: 17, hour: 14, minute: 30 };
-    expect(displayValue("hour", buffer, en)).toBe("02");
-    expect(displayValue("dayPeriod", buffer, en)).toBe(en.pmText);
-    expect(displayValue("minute", buffer, en)).toBe("30");
-  });
-
-  it("renders the 24h hour for vi-VN", () => {
-    const buffer = { year: 2026, month: 5, day: 17, hour: 14, minute: 30 };
-    expect(displayValue("hour", buffer, vn)).toBe("14");
-  });
-
-  it("returns null for unset fields", () => {
-    expect(displayValue("year", empty, en)).toBeNull();
-    expect(displayValue("hour", empty, en)).toBeNull();
-  });
-});
-
-describe("valueToSegments / segmentsToValue round-trip", () => {
-  it("round-trips a date", () => {
-    const buffer = valueToSegments("2026-05-17", false);
-    expect(buffer).toEqual({ year: 2026, month: 5, day: 17, hour: null, minute: null });
-    expect(segmentsToValue(buffer, false)).toBe("2026-05-17");
-  });
-
-  it("round-trips a datetime", () => {
-    const buffer = valueToSegments("2026-05-17T14:30", true);
-    expect(buffer).toEqual({ year: 2026, month: 5, day: 17, hour: 14, minute: 30 });
-    expect(segmentsToValue(buffer, true)).toBe("2026-05-17T14:30");
-  });
-
-  it("returns null for incomplete buffers", () => {
-    expect(segmentsToValue({ ...empty, year: 2026, month: 5 }, false)).toBeNull();
-    expect(segmentsToValue({ year: 2026, month: 5, day: 17, hour: 14, minute: null }, true)).toBeNull();
-  });
-
-  it("rejects impossible calendar dates", () => {
-    expect(segmentsToValue({ ...empty, year: 2026, month: 2, day: 30 }, false)).toBeNull();
-  });
-
-  it("yields an empty buffer for an unparseable value", () => {
-    expect(valueToSegments("", false)).toEqual(empty);
-    expect(isBufferEmpty(valueToSegments("garbage", false), false)).toBe(true);
-  });
-});
-
-describe("placeholderFor", () => {
-  it("gives per-type placeholders", () => {
-    expect(placeholderFor("year")).toBe("yyyy");
-    expect(placeholderFor("month")).toBe("mm");
-    expect(placeholderFor("dayPeriod")).toBe("--");
-  });
-});
-
-describe("locale-driven default segment order (LoticsLocaleProvider)", () => {
-  // The provider pack carries a BCP-47 tag; a wired date field defaults its
-  // segment order to that tag when no explicit `locale` prop is given. These
-  // assert the end-to-end contract — provider pack → rendered part ORDER —
-  // through the same resolveLocaleTag + getDateLayout the components compose.
-  // Before this, the field hardcoded "en-US", so a vi-wrapped app showed
-  // MM/DD/YYYY unless every call site threaded a `locale` prop.
-  it("a vi provider yields dd/MM/yyyy by default (no explicit locale)", () => {
-    const tag = resolveLocaleTag(viLocale);
-    expect(tag).toBe("vi-VN");
-    expect(fieldOrder(getDateLayout(tag, false))).toEqual(["day", "month", "year"]);
-  });
-
-  it("an en provider yields MM/dd/yyyy by default", () => {
-    const tag = resolveLocaleTag(enLocale);
-    expect(tag).toBe("en-US");
-    expect(fieldOrder(getDateLayout(tag, false))).toEqual(["month", "day", "year"]);
-  });
-
-  it("an explicit locale prop overrides the provider pack, both directions", () => {
-    // Under a vi provider, an author passing en-US still gets MM/dd/yyyy…
-    expect(fieldOrder(getDateLayout(resolveLocaleTag(viLocale, "en-US"), false))).toEqual([
-      "month",
-      "day",
-      "year",
-    ]);
-    // …and an en provider with an explicit vi-VN gets dd/MM/yyyy.
-    expect(fieldOrder(getDateLayout(resolveLocaleTag(enLocale, "vi-VN"), false))).toEqual([
-      "day",
-      "month",
-      "year",
-    ]);
-  });
-});
-
-describe("getTimeLayout", () => {
-  it("is hour/minute(+AM/PM) only, locale-driven", () => {
-    expect(fieldOrder(getTimeLayout("en-US"))).toEqual(["hour", "minute", "dayPeriod"]);
-    const vn = getTimeLayout("vi-VN");
-    expect(fieldOrder(vn)).toEqual(["hour", "minute"]);
-    expect(vn.hour12).toBe(false);
-  });
-});
-
-// -----------------------------------------------------------------------------
-// Time-only field. The point of the segmented time field is that 12/24-hour is
-// OUR locale's decision — a native `<input type="time">` takes it from the
-// browser's UI locale and ignores `lang`, so a Vietnamese screen on an en-US
-// browser rendered "01:45 PM" beside its own 24-hour text.
-// -----------------------------------------------------------------------------
-
-describe("timeSegmentsConfig", () => {
-  it("derives 24-hour display from the locale, not the runtime", () => {
-    expect(timeSegmentsConfig("vi-VN").layout.hour12).toBe(false);
-    expect(timeSegmentsConfig("de-DE").layout.hour12).toBe(false);
-  });
-
-  it("derives 12-hour display where the locale uses one", () => {
-    const layout = timeSegmentsConfig("en-US").layout;
-    expect(layout.hour12).toBe(true);
-    expect(layout.segments.some((s) => s.kind === "field" && s.type === "dayPeriod")).toBe(true);
-  });
-
-  it("keeps the value canonical 24-hour under a 12-hour locale", () => {
-    const cfg = timeSegmentsConfig("en-US");
-    expect(cfg.toValue(cfg.toBuffer("13:45"))).toBe("13:45");
-    expect(cfg.toValue(cfg.toBuffer("00:30"))).toBe("00:30");
-  });
-
-  it("round-trips every hour of the day", () => {
-    const cfg = timeSegmentsConfig("en-US");
-    for (let h = 0; h < 24; h++) {
-      const iso = `${String(h).padStart(2, "0")}:15`;
-      expect(cfg.toValue(cfg.toBuffer(iso))).toBe(iso);
-    }
-  });
-
-  it("reads an empty or unparseable time as empty", () => {
-    const cfg = timeSegmentsConfig("vi-VN");
-    for (const bad of ["", "banana", "25:00", "12:99"]) {
-      expect(cfg.isEmpty(cfg.toBuffer(bad))).toBe(true);
-    }
-  });
-
-  it("emits nothing while only half the time is typed", () => {
-    expect(segmentsToTime({ year: null, month: null, day: null, hour: 13, minute: null })).toBeNull();
-    expect(segmentsToTime({ year: null, month: null, day: null, hour: null, minute: 45 })).toBeNull();
-  });
-});