@assistant-ui/react-generative-ui 0.0.24 → 0.1.0

package/src/temporal.test.ts

@@ -1,337 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  classifyTemporal,
-  formatTemporalInstant,
-  formatTemporalUnixSeconds,
-  fromLocalDateTime,
-  fromOffsetDateTime,
-  mergeTemporalMinutes,
-  normalizeTemporalInputValue,
-  splitTemporalMinutes,
-  temporalOffsetLabel,
-  toLocalDateTime,
-  toPickerLocalDateTime,
-} from "./temporal";
-
-describe("temporal values", () => {
-  it("splits instants in their own offset or another offset", () => {
-    expect(splitTemporalMinutes("2025-12-15T17:00:00+02:00")).toEqual({
-      date: "2025-12-15",
-      time: "17:00",
-      droppedPrecision: false,
-    });
-    expect(splitTemporalMinutes("2025-12-14T23:30:00Z", "+02:00")).toEqual({
-      date: "2025-12-15",
-      time: "01:30",
-      droppedPrecision: false,
-    });
-    expect(temporalOffsetLabel("2025-12-15T17:00Z")).toBe("UTC");
-    expect(temporalOffsetLabel("2025-12-15T17:00+02:00")).toBe("UTC+02:00");
-  });
-
-  it("merges a wall minute using the original offset and precision", () => {
-    expect(
-      fromOffsetDateTime(
-        "2025-12-16T18:20",
-        "2025-12-15T17:00:30.123456+02:00",
-      ),
-    ).toBe("2025-12-16T18:20:30.123456+02:00");
-    expect(fromOffsetDateTime("2025-12-16T18:20", "2025-12-15T17:00:00Z")).toBe(
-      "2025-12-16T18:20:00Z",
-    );
-    expect(fromOffsetDateTime("2025-12-16T18:20")).toBe("2025-12-16T18:20");
-    expect(fromOffsetDateTime("", "2025-12-15T17:00Z")).toBe("");
-  });
-  it.each([
-    ["17:00", { time: "17:00", droppedPrecision: false }],
-    ["17:00:00", { time: "17:00", droppedPrecision: false }],
-    ["17:00:30", { time: "17:00", droppedPrecision: true }],
-    [
-      "2025-12-15T17:00",
-      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
-    ],
-    [
-      "2025-12-15T17:00:00.000",
-      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
-    ],
-    [
-      "2025-12-15T17:00:00.001",
-      { date: "2025-12-15", time: "17:00", droppedPrecision: true },
-    ],
-    [
-      "2025-12-15T17:00Z",
-      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
-    ],
-    [
-      "2025-12-15T17:00:30.001Z",
-      { date: "2025-12-15", time: "17:00", droppedPrecision: true },
-    ],
-    [
-      "2025-12-15T17:00:00.000Z",
-      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
-    ],
-    ["2025-12-15", undefined],
-    ["invalid", undefined],
-    ["", undefined],
-  ])("splits %s into minute precision wall-clock parts", (value, expected) => {
-    expect(splitTemporalMinutes(value as string)).toEqual(expected);
-  });
-
-  it.each([
-    ["2025-12-15", "17:00", "2025-12-15T17:00"],
-    ["2025-12-15", "17:00:30", "2025-12-15T17:00"],
-    ["", "17:00", ""],
-    ["2025-12-15", "", ""],
-    ["2025-02-29", "17:00", ""],
-    ["2025-12-15", "24:00", ""],
-  ])("merges %j and %j without assigning a zone", (date, time, expected) => {
-    expect(mergeTemporalMinutes(date!, time!)).toBe(expected);
-  });
-
-  it.each([
-    [1765818000, "Z", "2025-12-15T17:00:00Z"],
-    [1765810800, "+02:00", "2025-12-15T17:00:00+02:00"],
-    [0, "-00:00", "1970-01-01T00:00:00-00:00"],
-    [-1, "Z", "1969-12-31T23:59:59Z"],
-    [0, "+24:00", undefined],
-    [0.5, "Z", undefined],
-    [Infinity, "Z", undefined],
-    [NaN, "Z", undefined],
-    [Number.MAX_SAFE_INTEGER, "Z", undefined],
-  ])(
-    "formats unix seconds %s with offset %s safely",
-    (seconds, offset, expected) => {
-      expect(
-        formatTemporalUnixSeconds(seconds as number, offset as string),
-      ).toBe(expected);
-    },
-  );
-
-  it.each([
-    ["12:00:00", "12:00"],
-    ["12:00:00.000", "12:00"],
-    ["12:00:05.1200", "12:00:05.12"],
-    ["2025-12-15T12:00:00.000", "2025-12-15T12:00"],
-    ["2025-12-15T12:00:05.1200", "2025-12-15T12:00:05.12"],
-    ["12:00:05.123456", "12:00:05.123"],
-    ["12:00:05.000456", "12:00:05"],
-    ["2025-12-15T12:00:05.123456789", "2025-12-15T12:00:05.123"],
-    ["2025-12-15", "2025-12-15"],
-  ])("normalizes the browser input value %s", (value, expected) => {
-    expect(normalizeTemporalInputValue(value!)).toBe(expected);
-  });
-
-  it("completes normalization of a 100000 digit zero fraction", () => {
-    const zeros = "0".repeat(100_000);
-    for (const value of [zeros, `12:00:00.${zeros}`, `12:00:00.${zeros}1`]) {
-      expect(normalizeTemporalInputValue(value)).toBe(value);
-    }
-    expect(normalizeTemporalInputValue("12:00:00.000000000")).toBe("12:00");
-    expect(normalizeTemporalInputValue("12:00:00.100000000")).toBe(
-      "12:00:00.1",
-    );
-  });
-
-  it("uses a fixed viewer time zone with seasonal offsets", () => {
-    expect(Intl.DateTimeFormat().resolvedOptions().timeZone).toBe(
-      "America/New_York",
-    );
-    expect(new Date("2026-01-15T12:00Z").getTimezoneOffset()).toBe(300);
-    expect(new Date("2026-07-15T12:00Z").getTimezoneOffset()).toBe(240);
-  });
-
-  it.each(["0002", "0020", "0202"])(
-    "preserves minute edits in %s when the zone offset has seconds",
-    (year) => {
-      const local = `${year}-12-15T12:00`;
-      const value = fromLocalDateTime(local, "2025-12-15T17:00Z");
-      expect(value).toBe(`${year}-12-15T16:56:02Z`);
-      expect(toPickerLocalDateTime(value)).toBe(local);
-    },
-  );
-
-  it("preserves entered seconds with a minute precision anchor", () => {
-    const local = "2025-12-15T12:00:30";
-    const value = fromLocalDateTime(local, "2025-12-15T17:00Z");
-    expect(value).toBe("2025-12-15T17:00:30Z");
-    expect(toPickerLocalDateTime(value)).toBe(local);
-  });
-
-  it.each([
-    ["2026-07-15", "date"],
-    ["2024-02-29", "date"],
-    ["00:00", "time"],
-    ["23:59:59", "time"],
-    ["12:34:56.1", "time"],
-    ["12:34:56.1200", "time"],
-    ["2026-07-15T12:34", "floating"],
-    ["2026-07-15T12:34:56", "floating"],
-    ["2026-07-15T12:34:56.123456", "floating"],
-  ])("classifies and passes through %s as %s", (value, kind) => {
-    expect(classifyTemporal(value!)).toMatchObject({ kind, value });
-    expect(toLocalDateTime(value!)).toBe(value);
-    expect(fromLocalDateTime(value!, value!)).toBe(value);
-  });
-
-  describe.each([
-    { offset: "Z", local: "2026-07-15T08:34" },
-    { offset: "+08:00", local: "2026-07-15T00:34" },
-    { offset: "-05:30", local: "2026-07-15T14:04" },
-  ])("$offset instants", ({ offset, local }) => {
-    it.each([
-      { suffix: "", precision: "minutes" },
-      { suffix: ":56", precision: "seconds" },
-      { suffix: ":56.1", precision: 1 },
-      { suffix: ":56.12", precision: 2 },
-      { suffix: ":56.123", precision: 3 },
-      { suffix: ":56.123456789", precision: 9 },
-      { suffix: ":00.000009", precision: 6 },
-    ])(
-      "round trips local wall time at $precision precision",
-      ({ suffix, precision }) => {
-        const value = `2026-07-15T12:34${suffix}${offset}`;
-        const parsed = classifyTemporal(value);
-        expect(parsed).toMatchObject({
-          kind: "instant",
-          epochMs: Date.parse(value),
-          offset,
-          precision,
-        });
-        if (parsed.kind !== "instant") throw new Error("Expected an instant");
-        expect(formatTemporalInstant(parsed)).toBe(value);
-        const wallTime = toLocalDateTime(value, parsed.precision);
-        expect(wallTime).toBe(`${local}${suffix}`);
-        expect(fromLocalDateTime(wallTime, value)).toBe(value);
-      },
-    );
-  });
-
-  it("formats an instant in another offset and precision across calendar boundaries", () => {
-    const parsed = classifyTemporal("2026-01-01T00:15:30.120Z");
-    if (parsed.kind !== "instant") throw new Error("Expected an instant");
-    expect(formatTemporalInstant(parsed, "-05:30", "minutes")).toBe(
-      "2025-12-31T18:45-05:30",
-    );
-    expect(formatTemporalInstant(parsed, "+08:00", "seconds")).toBe(
-      "2026-01-01T08:15:30+08:00",
-    );
-    expect(formatTemporalInstant(parsed, "Z", 6)).toBe(
-      "2026-01-01T00:15:30.120000Z",
-    );
-  });
-
-  it("preserves offset spelling and uses the edited fractional digits", () => {
-    expect(
-      fromLocalDateTime(
-        "2026-07-16T10:20:30.123456789",
-        "2026-07-15T12:34:56.123456789-00:00",
-      ),
-    ).toBe("2026-07-16T14:20:30.123456789-00:00");
-  });
-
-  it.each([
-    ["2025-12-15T12:00:00.750", "2025-12-15T17:00:00.750Z", 3],
-    ["2025-12-15T12:00:00.75", "2025-12-15T17:00:00.750Z", 2],
-    ["2025-12-15T12:00:00", "2025-12-15T17:00:00.000Z", undefined],
-    ["2025-12-15T12:00:00.250", "2025-12-15T17:00:00.250Z", 3],
-    ["2025-12-15T12:00:00.750987", "2025-12-15T17:00:00.750987Z", 6],
-  ])(
-    "round trips a local fraction edit of %s",
-    (local, expected, precision) => {
-      const result = fromLocalDateTime(local!, "2025-12-15T17:00:00.250Z");
-      expect(result).toBe(expected);
-      expect(toLocalDateTime(result, precision)).toBe(local);
-    },
-  );
-
-  it.each([
-    [
-      "2026-07-16T08:34:56",
-      "2026-07-15T12:34:56.000456Z",
-      "2026-07-16T12:34:56.000456Z",
-    ],
-    [
-      "2026-07-16T08:34",
-      "2026-07-15T12:34:00.000456Z",
-      "2026-07-16T12:34:00.000456Z",
-    ],
-  ])(
-    "keeps a sub-millisecond tail the control cannot show after an edit to %s",
-    (local, anchor, expected) => {
-      expect(fromLocalDateTime(local, anchor)).toBe(expected);
-    },
-  );
-
-  it("uses zero for a native zero or omitted fraction", () => {
-    expect(
-      fromLocalDateTime("2025-12-15T12:00:00.000", "2025-12-15T17:00:00.250Z"),
-    ).toBe("2025-12-15T17:00:00.000Z");
-    expect(
-      fromLocalDateTime("2025-12-15T12:00:00", "2025-12-15T17:00:00.250123Z"),
-    ).toBe("2025-12-15T17:00:00.000000Z");
-  });
-
-  it.each([
-    ["2026-01-15T12:34", "2026-01-15T12:34:00-05:00"],
-    ["2026-07-15T12:34", "2026-07-15T12:34:00-04:00"],
-  ])("uses the viewer offset at %s for an empty value", (value, expected) => {
-    expect(fromLocalDateTime(value!, "")).toBe(expected);
-    expect(fromLocalDateTime(value!)).toBe(expected);
-  });
-
-  it.each([
-    {
-      value: "2026-03-08T02:30:45",
-      parts: [2026, 2, 8, 2, 30, 45] as const,
-      expected: "2026-03-08T07:30:45.000000Z",
-      local: "2026-03-08T03:30:45",
-    },
-    {
-      value: "2026-11-01T01:30:45",
-      parts: [2026, 10, 1, 1, 30, 45] as const,
-      expected: "2026-11-01T05:30:45.000000Z",
-      local: "2026-11-01T01:30:45",
-    },
-  ])(
-    "resolves DST wall time $value like the native constructor",
-    ({ value, parts, expected, local }) => {
-      const result = fromLocalDateTime(value, "2026-01-15T12:00:00.123456Z");
-      expect(result).toBe(expected);
-      const [year, month, day, hour, minute, second] = parts;
-      expect(Date.parse(result)).toBe(
-        new Date(year, month, day, hour, minute, second).getTime(),
-      );
-      expect(toLocalDateTime(result)).toBe(local);
-      expect(fromLocalDateTime(value, value)).toBe(value);
-    },
-  );
-
-  it("preserves an empty input when an instant is cleared", () => {
-    expect(fromLocalDateTime("", "2026-07-15T12:34:56+08:00")).toBe("");
-  });
-
-  it.each([
-    "",
-    "not a date",
-    "2026-02-29",
-    "2026-04-31",
-    "2026-13-01",
-    "2026-01-00",
-    "24:00",
-    "12:60",
-    "12:34:60",
-    "2026-07-15T24:00Z",
-    "2026-07-15T12:60Z",
-    "2026-07-15T12:34:60Z",
-    "2026-02-29T12:34Z",
-    "2026-07-15T12:34.1Z",
-    "2026-07-15T12:34+24:00",
-    "2026-07-15T12:34+08:60",
-    "2026-07-15T12:34+0800",
-    "2026-07-15 12:34Z",
-  ])("classifies %j as unparseable and passes it through", (value) => {
-    expect(classifyTemporal(value)).toEqual({ kind: "unparseable", value });
-    expect(toLocalDateTime(value)).toBe(value);
-    expect(fromLocalDateTime(value)).toBe(value);
-  });
-});

package/src/temporal.ts

@@ -1,263 +0,0 @@
-export type TemporalPrecision = "minutes" | "seconds" | number;
-
-export type TemporalInstant = {
-  kind: "instant";
-  epochMs: number;
-  offset: string;
-  precision: TemporalPrecision;
-  subMillisecondDigits?: string;
-};
-
-export type TemporalValue =
-  | { kind: "date" | "unparseable"; value: string }
-  | {
-      kind: "time" | "floating";
-      value: string;
-      precision: TemporalPrecision;
-    }
-  | TemporalInstant;
-
-const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-const TIME_PATTERN =
-  /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d{1,9}))?)?$/;
-const DATETIME_PATTERN =
-  /^(\d{4}-\d{2}-\d{2})T([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d+))?)?(Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)?$/;
-const INPUT_PATTERN =
-  /^((?:\d{4}-\d{2}-\d{2}T)?(?:[01]\d|2[0-3]):[0-5]\d)(?::([0-5]\d)(?:\.(\d{1,9}))?)?$/;
-
-export const normalizeTemporalInputValue = (value: string): string => {
-  const match = INPUT_PATTERN.exec(value);
-  if (!match || match[2] === undefined) return value;
-  const digits = match[3]?.slice(0, 3) ?? "";
-  let end = digits.length;
-  while (end > 0 && digits[end - 1] === "0") end--;
-  const fraction = digits.slice(0, end);
-  if (match[2] === "00" && !fraction) return match[1]!;
-  return `${match[1]}:${match[2]}${fraction ? `.${fraction}` : ""}`;
-};
-
-const isCalendarDate = (value: string): boolean => {
-  const date = new Date(`${value}T00:00:00Z`);
-  return (
-    Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value
-  );
-};
-
-export const classifyTemporal = (value: string): TemporalValue => {
-  if (DATE_PATTERN.test(value) && isCalendarDate(value)) {
-    return { kind: "date", value };
-  }
-  const time = TIME_PATTERN.exec(value);
-  if (time) {
-    return {
-      kind: "time",
-      value,
-      precision:
-        time[4]?.length ?? (time[3] === undefined ? "minutes" : "seconds"),
-    };
-  }
-  const datetime = DATETIME_PATTERN.exec(value);
-  if (!datetime || !isCalendarDate(datetime[1]!)) {
-    return { kind: "unparseable", value };
-  }
-  const precision =
-    datetime[5]?.length ?? (datetime[4] === undefined ? "minutes" : "seconds");
-  const offset = datetime[6];
-  if (offset === undefined) return { kind: "floating", value, precision };
-  return {
-    kind: "instant",
-    epochMs: Date.parse(value),
-    offset,
-    precision,
-    ...(datetime[5] && datetime[5].length > 3
-      ? { subMillisecondDigits: datetime[5].slice(3) }
-      : {}),
-  };
-};
-
-export const getTemporalInputStep = (
-  ...values: (string | undefined)[]
-): "any" | 1 | undefined => {
-  let step: 1 | undefined;
-  for (const value of values) {
-    const temporal = classifyTemporal(value ?? "");
-    const precision =
-      "precision" in temporal
-        ? temporal.precision
-        : INPUT_PATTERN.exec(value ?? "")?.[3]?.length;
-    if (typeof precision === "number") return "any";
-    if (precision === "seconds") step = 1;
-  }
-  return step;
-};
-
-export const splitTemporalMinutes = (
-  value: string,
-  offset?: string,
-): { date?: string; time: string; droppedPrecision: boolean } | undefined => {
-  const temporal = classifyTemporal(value);
-  if (temporal.kind === "date" || temporal.kind === "unparseable")
-    return undefined;
-  const wallTime =
-    temporal.kind === "instant"
-      ? formatTemporalInstant(temporal, offset).slice(
-          0,
-          -(offset ?? temporal.offset).length,
-        )
-      : temporal.value;
-  const end = temporal.kind === "time" ? 5 : 16;
-  return {
-    ...(temporal.kind === "time" ? {} : { date: wallTime.slice(0, 10) }),
-    time: wallTime.slice(end - 5, end),
-    droppedPrecision: /[1-9]/.test(wallTime.slice(end)),
-  };
-};
-
-export const mergeTemporalMinutes = (date: string, time: string): string => {
-  if (
-    classifyTemporal(date).kind !== "date" ||
-    classifyTemporal(time).kind !== "time"
-  )
-    return "";
-  return `${date}T${time.slice(0, 5)}`;
-};
-
-const pad = (value: number, digits = 2): string =>
-  String(value).padStart(digits, "0");
-
-const offsetMinutes = (offset: string): number =>
-  offset === "Z"
-    ? 0
-    : (offset.startsWith("-") ? -1 : 1) *
-      (Number(offset.slice(1, 3)) * 60 + Number(offset.slice(4, 6)));
-
-export const formatTemporalInstant = (
-  instant: TemporalInstant,
-  offset = instant.offset,
-  precision = instant.precision,
-): string => {
-  const date = new Date(instant.epochMs + offsetMinutes(offset) * 60_000);
-  const iso = date.toISOString();
-  const wallTime =
-    precision === "minutes"
-      ? iso.slice(0, 16)
-      : precision === "seconds"
-        ? iso.slice(0, 19)
-        : `${iso.slice(0, 19)}.${(pad(date.getUTCMilliseconds(), 3) + (instant.subMillisecondDigits ?? "")).padEnd(precision, "0").slice(0, precision)}`;
-  return `${wallTime}${offset}`;
-};
-
-export const formatTemporalUnixSeconds = (
-  seconds: number,
-  offset = "Z",
-): string | undefined => {
-  if (!Number.isInteger(seconds)) return undefined;
-  try {
-    const value = formatTemporalInstant({
-      kind: "instant",
-      epochMs: seconds * 1000,
-      offset,
-      precision: "seconds",
-    });
-    return classifyTemporal(value).kind === "instant" ? value : undefined;
-  } catch {
-    return undefined;
-  }
-};
-
-export const temporalOffsetLabel = (value: string): string | undefined => {
-  const temporal = classifyTemporal(value);
-  if (temporal.kind !== "instant") return undefined;
-  return temporal.offset === "Z" ? "UTC" : `UTC${temporal.offset}`;
-};
-
-export const fromOffsetDateTime = (
-  value: string,
-  previousValue?: string,
-): string => {
-  if (value === "") return "";
-  if (classifyTemporal(value).kind !== "floating") return value;
-  const previous = classifyTemporal(previousValue ?? "");
-  if (previous.kind !== "instant") return value;
-  const epochMs = Date.parse(`${value}${previous.offset}`);
-  const minuteRemainder =
-    previous.precision === "minutes"
-      ? 0
-      : ((previous.epochMs % 60_000) + 60_000) % 60_000;
-  return formatTemporalInstant({
-    ...previous,
-    epochMs: epochMs + minuteRemainder,
-  });
-};
-
-export const toLocalDateTime = (
-  value: string,
-  precision?: TemporalPrecision,
-): string => {
-  const temporal = classifyTemporal(value);
-  if (temporal.kind !== "instant") return value;
-  const date = new Date(temporal.epochMs);
-  const wallTime = `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
-  return (precision ?? temporal.precision) === "minutes"
-    ? wallTime
-    : `${wallTime}:${pad(date.getSeconds())}${typeof precision === "number" ? formatTemporalInstant(temporal, "Z", precision).slice(19, -1) : ""}`;
-};
-
-export const toPickerLocalDateTime = (value: string): string => {
-  const temporal = classifyTemporal(value);
-  if (temporal.kind !== "instant") return normalizeTemporalInputValue(value);
-  const local = toLocalDateTime(
-    value,
-    typeof temporal.precision === "number" ? 3 : temporal.precision,
-  );
-  return typeof temporal.precision !== "number" || local.endsWith(".000")
-    ? normalizeTemporalInputValue(local)
-    : local;
-};
-
-export const fromLocalDateTime = (
-  value: string,
-  previousValue?: string,
-): string => {
-  const temporal = classifyTemporal(value);
-  const previous = classifyTemporal(previousValue ?? "");
-  if (temporal.kind !== "floating" || previous.kind === "floating") {
-    return value;
-  }
-  const date = new Date(
-    value.replace(
-      /\.(\d{1,2})$/,
-      (_, digits: string) => `.${digits.padEnd(3, "0")}`,
-    ),
-  );
-  const minutes = -date.getTimezoneOffset();
-  const offset = `${minutes < 0 ? "-" : "+"}${pad(Math.floor(Math.abs(minutes) / 60))}:${pad(Math.abs(minutes) % 60)}`;
-  if (previous.kind !== "instant") {
-    return formatTemporalInstant({
-      kind: "instant",
-      epochMs: date.getTime(),
-      offset,
-      precision: "seconds",
-    });
-  }
-  return formatTemporalInstant({
-    ...previous,
-    epochMs: date.getTime(),
-    ...(previous.precision === "minutes" &&
-    (temporal.precision === "seconds" || date.getUTCSeconds() !== 0)
-      ? { precision: "seconds" }
-      : {}),
-    ...(date.getMilliseconds() ===
-    new Date(previous.epochMs).getUTCMilliseconds()
-      ? {}
-      : typeof temporal.precision === "number"
-        ? {
-            precision: Math.max(
-              temporal.precision,
-              typeof previous.precision === "number" ? previous.precision : 0,
-            ),
-            subMillisecondDigits: value.slice(value.indexOf(".") + 4),
-          }
-        : { subMillisecondDigits: "" }),
-  });
-};