@lotics/ui 20.0.1 → 20.0.2

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

package/src/file_badge_fit.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  FILE_BADGE_BOX,
-  FILE_BADGE_DEFAULT_WIDTH,
-  fileBadgeHeight,
-  fileBadgeWidthForBox,
-} from "./file_badge_fit";
-
-describe("FileBadge geometry", () => {
-  it("scales the badge with the requested width instead of pinning the default", () => {
-    // The bug this covers: a caller's `size` was dropped and every badge rendered at
-    // the 26x32 default. A requested width must produce a proportionally smaller badge.
-    expect(fileBadgeHeight(FILE_BADGE_DEFAULT_WIDTH)).toBe(FILE_BADGE_BOX);
-    expect(fileBadgeHeight(20)).toBe(25);
-    expect(fileBadgeHeight(13)).toBe(16);
-    expect(fileBadgeHeight(52)).toBe(64);
-  });
-
-  it("fills the compact thumbnail slot exactly at the default width", () => {
-    // Why DEFAULT_WIDTH is 26: a default badge is exactly as tall as the 32px compact
-    // tile it sits in. A slot of 32 must therefore resolve to the default, unchanged.
-    expect(fileBadgeWidthForBox(FILE_BADGE_BOX)).toBe(FILE_BADGE_DEFAULT_WIDTH);
-  });
-
-  it("resolves a SMALLER slot to a smaller badge, not the default", () => {
-    // The reported bug: a sub-32 tile still rendered the 26x32 default — wider AND taller
-    // than its own tile. The requested slot now drives the badge.
-    expect(fileBadgeWidthForBox(30)).toBe(24);
-    expect(fileBadgeHeight(fileBadgeWidthForBox(30))).toBe(30);
-    expect(fileBadgeWidthForBox(24)).toBe(19);
-    expect(fileBadgeHeight(fileBadgeWidthForBox(24))).toBe(23);
-  });
-
-  it("never overflows its square slot, at any slot size", () => {
-    // The badge is taller than it is wide, so height is the binding dimension and the
-    // rounding in `fileBadgeHeight` can push a naive floor over the edge.
-    for (let box = 8; box <= 200; box++) {
-      const width = fileBadgeWidthForBox(box);
-      expect(width).toBeLessThanOrEqual(box);
-      expect(fileBadgeHeight(width)).toBeLessThanOrEqual(box);
-    }
-  });
-
-  it("grows monotonically with the slot", () => {
-    for (let box = 9; box <= 200; box++) {
-      expect(fileBadgeWidthForBox(box)).toBeGreaterThanOrEqual(fileBadgeWidthForBox(box - 1));
-    }
-  });
-});

package/src/file_intake.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { matchesAccept, filesFromTransfer, selectPasteSink, type FileTransferLike, type PasteSinkEntry } from "./file_intake";
-
-const file = (name: string, type: string) => new File([new Uint8Array([1])], name, { type });
-
-/** A clipboard/drag payload that surfaces its files only through `items` —
- *  what a pasted screenshot looks like on the engines that do that. */
-const itemsOnly = (files: File[]): FileTransferLike => ({
-  files: [],
-  items: files.map((f) => ({ kind: "file" as const, getAsFile: () => f })),
-});
-
-describe("matchesAccept", () => {
-  it("accepts everything when the list is absent or empty", () => {
-    expect(matchesAccept(file("a.pdf", "application/pdf"), undefined)).toBe(true);
-    expect(matchesAccept(file("a.pdf", "application/pdf"), "")).toBe(true);
-    expect(matchesAccept(file("a.pdf", "application/pdf"), " , ")).toBe(true);
-  });
-
-  it("matches an exact MIME, case-insensitively", () => {
-    expect(matchesAccept(file("a.pdf", "APPLICATION/PDF"), "application/pdf")).toBe(true);
-    expect(matchesAccept(file("a.png", "image/png"), "application/pdf")).toBe(false);
-  });
-
-  it("matches a wildcard type", () => {
-    expect(matchesAccept(file("a.png", "image/png"), "image/*")).toBe(true);
-    expect(matchesAccept(file("a.pdf", "application/pdf"), "image/*")).toBe(false);
-  });
-
-  it("matches an extension pattern by filename when the MIME is unknown", () => {
-    expect(matchesAccept(file("Report.CSV", ""), ".csv")).toBe(true);
-    expect(matchesAccept(file("report.csvx", ""), ".csv")).toBe(false);
-  });
-
-  it("accepts a file matching ANY pattern in the list", () => {
-    expect(matchesAccept(file("a.png", "image/png"), "application/pdf, image/*")).toBe(true);
-    expect(matchesAccept(file("a.zip", "application/zip"), "application/pdf, image/*")).toBe(false);
-  });
-});
-
-describe("filesFromTransfer", () => {
-  it("returns [] for a missing transfer", () => {
-    expect(filesFromTransfer(null)).toEqual([]);
-    expect(filesFromTransfer(undefined)).toEqual([]);
-    expect(filesFromTransfer({})).toEqual([]);
-  });
-
-  it("reads the direct file list", () => {
-    const a = file("a.pdf", "application/pdf");
-    expect(filesFromTransfer({ files: [a] })).toEqual([a]);
-  });
-
-  it("falls back to clipboard items when the file list is empty", () => {
-    const shot = file("image.png", "image/png");
-    expect(filesFromTransfer(itemsOnly([shot]))).toEqual([shot]);
-  });
-
-  it("never doubles a file present in BOTH files and items", () => {
-    const a = file("a.png", "image/png");
-    expect(filesFromTransfer({ files: [a], items: [{ kind: "file", getAsFile: () => a }] })).toEqual([a]);
-  });
-
-  it("skips non-file clipboard items and null getAsFile results", () => {
-    const a = file("a.png", "image/png");
-    const transfer: FileTransferLike = {
-      items: [
-        { kind: "string", getAsFile: () => null },
-        { kind: "file", getAsFile: () => null },
-        { kind: "file", getAsFile: () => a },
-      ],
-    };
-    expect(filesFromTransfer(transfer)).toEqual([a]);
-  });
-
-  it("filters by accept", () => {
-    const pdf = file("a.pdf", "application/pdf");
-    const zip = file("a.zip", "application/zip");
-    expect(filesFromTransfer({ files: [pdf, zip] }, { accept: "application/pdf" })).toEqual([pdf]);
-    expect(filesFromTransfer(itemsOnly([pdf, zip]), { accept: "application/pdf" })).toEqual([pdf]);
-  });
-
-  it("keeps every file by default and caps at one when multiple is false", () => {
-    const a = file("a.pdf", "application/pdf");
-    const b = file("b.pdf", "application/pdf");
-    expect(filesFromTransfer({ files: [a, b] })).toEqual([a, b]);
-    expect(filesFromTransfer({ files: [a, b] }, { multiple: false })).toEqual([a]);
-  });
-
-  it("caps AFTER filtering, so a rejected first file does not eat the slot", () => {
-    const zip = file("a.zip", "application/zip");
-    const pdf = file("b.pdf", "application/pdf");
-    expect(filesFromTransfer({ files: [zip, pdf] }, { accept: "application/pdf", multiple: false })).toEqual([pdf]);
-  });
-});
-
-describe("selectPasteSink", () => {
-  const entry = (sink: string, focused: boolean): PasteSinkEntry<string> => ({ sink, focused });
-
-  it("returns undefined for an empty stack", () => {
-    expect(selectPasteSink<string>([])).toBeUndefined();
-  });
-
-  it("falls back to the TOP of the stack when nothing is focused", () => {
-    expect(selectPasteSink([entry("a", false), entry("b", false), entry("c", false)])).toBe("c");
-  });
-
-  it("routes to a focused region over the (later-mounted) top of the stack", () => {
-    // b holds focus; c is on top but unfocused — b wins.
-    expect(selectPasteSink([entry("a", false), entry("b", true), entry("c", false)])).toBe("b");
-  });
-
-  it("picks the TOP-MOST focused region when several are focused", () => {
-    // Nested regions can both contain activeElement; the innermost/last wins.
-    expect(selectPasteSink([entry("a", true), entry("b", true), entry("c", false)])).toBe("b");
-  });
-
-  it("a single region-less sink still gets the paste (byte-for-byte old behavior)", () => {
-    expect(selectPasteSink([entry("only", false)])).toBe("only");
-  });
-
-  it("a focused region beats an unfocused one mounted after it", () => {
-    expect(selectPasteSink([entry("focused", true), entry("later", false)])).toBe("focused");
-  });
-});

package/src/format_date.test.ts

@@ -1,138 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { formatDate, parseDate, toISODate } from "./format_date";
-
-describe("formatDate", () => {
-  test("formats an ISO date in the home market (dd/MM/yyyy)", () => {
-    expect(formatDate("2026-05-22", { locale: "vi-VN" })).toBe("22/05/2026");
-  });
-
-  test("formats a Date object, not just an ISO string", () => {
-    expect(formatDate(new Date(2026, 4, 22), { locale: "vi-VN" })).toBe("22/05/2026");
-  });
-
-  test("compact drops the year (dd/MM)", () => {
-    expect(formatDate("2026-05-22", { locale: "vi-VN", compact: true })).toBe("22/05");
-  });
-
-  test("time prepends the 24h time, then the locale date", () => {
-    expect(formatDate("2026-05-22T14:30", { locale: "vi-VN", time: true })).toBe("14:30 22/05/2026");
-  });
-
-  test("time + compact is time-first and drops the year", () => {
-    expect(formatDate("2026-05-22T09:05", { locale: "vi-VN", time: true, compact: true })).toBe("09:05 22/05");
-  });
-
-  test("time composes with a readable style — the orthogonal axis", () => {
-    expect(formatDate("2026-09-22T14:30", { format: "long", time: true, locale: "en-US" })).toBe("14:30 September 22, 2026");
-  });
-
-  test("medium — readable, abbreviated month", () => {
-    expect(formatDate("2026-05-22", { format: "medium", locale: "en-US" })).toBe("May 22, 2026");
-    // vi word output is ICU-dependent; assert the day + year are present (day-first locale).
-    expect(formatDate("2026-05-22", { format: "medium", locale: "vi-VN" })).toMatch(/22.*2026/);
-  });
-
-  test("long — readable, full month name", () => {
-    expect(formatDate("2026-09-22", { format: "long", locale: "en-US" })).toBe("September 22, 2026");
-    expect(formatDate("2026-09-22", { format: "long", locale: "vi-VN" })).toMatch(/22.*2026/);
-  });
-
-  test("dayMonth — day + abbreviated month, no year", () => {
-    expect(formatDate("2026-09-22", { format: "dayMonth", locale: "en-US" })).toBe("Sep 22");
-    expect(formatDate("2026-09-22", { format: "dayMonth", locale: "vi-VN" })).not.toMatch(/2026/);
-  });
-
-  test("monthYear — a period label, sentence-cased", () => {
-    expect(formatDate("2026-05-22", { format: "monthYear", locale: "en-US" })).toBe("May 2026");
-    // Leading character is upper-cased even where the locale lowercases the month name.
-    const vi = formatDate("2026-05-22", { format: "monthYear", locale: "vi-VN" });
-    expect(vi.charAt(0)).toBe(vi.charAt(0).toUpperCase());
-    expect(vi).toMatch(/2026/);
-  });
-
-  test("date-only ISO does not drift across local timezone (wall-clock parse)", () => {
-    // `new Date('2026-01-01')` is UTC midnight; in negative-offset zones it formats as Dec 31.
-    expect(formatDate("2026-01-01", { locale: "vi-VN" })).toBe("01/01/2026");
-  });
-
-  test("empty input returns the empty label", () => {
-    expect(formatDate(null)).toBe("");
-    expect(formatDate("")).toBe("");
-    expect(formatDate(undefined, { emptyLabel: "—" })).toBe("—");
-    expect(formatDate("not-a-date", { emptyLabel: "—" })).toBe("—");
-  });
-});
-
-describe("formatDate — reduced precision", () => {
-  test("month value renders MM/YYYY (numeric, locale order), no fabricated day", () => {
-    expect(formatDate("2026-05", { locale: "vi-VN" })).toBe("05/2026");
-    expect(formatDate("2026-05", { locale: "en-US" })).toBe("05/2026");
-  });
-
-  test("year value renders just the year", () => {
-    expect(formatDate("2026", { locale: "vi-VN" })).toBe("2026");
-    expect(formatDate("2026", { format: "medium", locale: "en-US" })).toBe("2026");
-    expect(formatDate("2026", { format: "monthYear", locale: "en-US" })).toBe("2026");
-  });
-
-  test("compact drops the year on a month value", () => {
-    expect(formatDate("2026-05", { locale: "vi-VN", compact: true })).toBe("05");
-  });
-
-  test("readable styles drop the day for a month value", () => {
-    expect(formatDate("2026-05", { format: "monthYear", locale: "en-US" })).toBe("May 2026");
-    expect(formatDate("2026-05", { format: "medium", locale: "en-US" })).toBe("May 2026");
-    expect(formatDate("2026-05", { format: "long", locale: "en-US" })).toBe("May 2026");
-    expect(formatDate("2026-05", { format: "dayMonth", locale: "en-US" })).toBe("May");
-  });
-
-  test("time is ignored for a reduced-precision value (a period has no clock)", () => {
-    expect(formatDate("2026-05", { locale: "vi-VN", time: true })).toBe("05/2026");
-  });
-});
-
-describe("parseDate", () => {
-  test("parses an ISO datetime to local wall-clock", () => {
-    const d = parseDate("2026-05-22T14:30");
-    expect(d).not.toBeNull();
-    expect(d?.getFullYear()).toBe(2026);
-    expect(d?.getMonth()).toBe(4);
-    expect(d?.getDate()).toBe(22);
-    expect(d?.getHours()).toBe(14);
-    expect(d?.getMinutes()).toBe(30);
-  });
-
-  test("passes a valid Date through and rejects an invalid one", () => {
-    const d = new Date(2026, 0, 1);
-    expect(parseDate(d)).toBe(d);
-    expect(parseDate(new Date("nonsense"))).toBeNull();
-    expect(parseDate(null)).toBeNull();
-    expect(parseDate("")).toBeNull();
-  });
-
-  test("parses a reduced-precision value to its period start", () => {
-    const month = parseDate("2026-05");
-    expect(month?.getFullYear()).toBe(2026);
-    expect(month?.getMonth()).toBe(4);
-    expect(month?.getDate()).toBe(1);
-    const year = parseDate("2026");
-    expect(year?.getFullYear()).toBe(2026);
-    expect(year?.getMonth()).toBe(0);
-    expect(year?.getDate()).toBe(1);
-  });
-});
-
-describe("toISODate", () => {
-  test("Date or ISO value → yyyy-MM-dd", () => {
-    expect(toISODate(new Date(2026, 4, 22))).toBe("2026-05-22");
-    expect(toISODate("2026-05-22T14:30")).toBe("2026-05-22");
-    expect(toISODate(null)).toBe("");
-  });
-
-  test("PRESERVES reduced precision verbatim — never fabricates a day", () => {
-    expect(toISODate("2026-05")).toBe("2026-05");
-    expect(toISODate("2026")).toBe("2026");
-    // Whitespace-trimmed but otherwise unchanged.
-    expect(toISODate("  2026-05  ")).toBe("2026-05");
-  });
-});

package/src/format_date_negative_zone.test.ts

@@ -1,26 +0,0 @@
-// Pin a NEGATIVE-offset zone (UTC-5) before importing the formatter. The old
-// fall-through `new Date("2026-05")` parses as UTC midnight, which in a
-// negative-offset zone lands on the PREVIOUS month ("2026-04-30T19:00"), drifting
-// a month-precision value back a month. The naive part-based construction must
-// keep "2026-05" on May regardless of the runtime zone.
-process.env.TZ = "America/New_York";
-
-import { describe, expect, test } from "vitest";
-import { formatDate, toISODate } from "./format_date";
-
-describe("formatDate — reduced precision in a negative-offset zone", () => {
-  test("a month value does not drift to the previous month", () => {
-    expect(formatDate("2026-05", { locale: "en-US" })).toBe("05/2026");
-    // January is the adversarial case — a backward drift would land in Dec 2025.
-    expect(formatDate("2026-01", { locale: "en-US" })).toBe("01/2026");
-  });
-
-  test("a year value stays on its year", () => {
-    expect(formatDate("2026", { locale: "en-US" })).toBe("2026");
-  });
-
-  test("toISODate preserves the partial (no drift, no fabricated day)", () => {
-    expect(toISODate("2026-01")).toBe("2026-01");
-    expect(toISODate("2026")).toBe("2026");
-  });
-});