@reliability-design/web 1.4.4 → 1.4.6

package/dist/components/rel-date-picker/date-parse.test.ts

@@ -0,0 +1,116 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  parseDateInput,
+  isDayFirstPattern,
+  isDayFirstLocale,
+} from "./date-parse";
+
+// Reference "today": 2026-07-21 (a Tuesday), noon to dodge TZ edges.
+const ref = new Date(2026, 6, 21, 12, 0, 0);
+const opts = { referenceDate: ref };
+
+const ymd = (d: Date | null) =>
+  d === null
+    ? null
+    : `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(
+        d.getDate()
+      ).padStart(2, "0")}`;
+
+test("shortcuts: t / today / t±N / tN", () => {
+  assert.equal(ymd(parseDateInput("t", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("T", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("today", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("t+1", opts)), "2026-07-22");
+  assert.equal(ymd(parseDateInput("t1", opts)), "2026-07-22");
+  assert.equal(ymd(parseDateInput("T + 7", opts)), "2026-07-28");
+  assert.equal(ymd(parseDateInput("t-1", opts)), "2026-07-20");
+  assert.equal(ymd(parseDateInput("t-30", opts)), "2026-06-21");
+  // month/year rollover
+  assert.equal(ymd(parseDateInput("t+11", opts)), "2026-08-01");
+});
+
+test("incomplete shortcut is not 'today'", () => {
+  assert.equal(parseDateInput("t+", opts), null);
+  assert.equal(parseDateInput("t-", opts), null);
+});
+
+test("ISO and year-first forms", () => {
+  assert.equal(ymd(parseDateInput("2026-07-21", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("2026/7/21", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("2026.07.21", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("20260721", opts)), "2026-07-21");
+});
+
+test("numeric M/D/Y vs D/M/Y via dayFirst", () => {
+  assert.equal(ymd(parseDateInput("7/21/2026", opts)), "2026-07-21");
+  assert.equal(
+    ymd(parseDateInput("21/7/2026", { ...opts, dayFirst: true })),
+    "2026-07-21"
+  );
+  // ambiguous "3/4": order decided by dayFirst
+  assert.equal(ymd(parseDateInput("3/4/2026", opts)), "2026-03-04");
+  assert.equal(
+    ymd(parseDateInput("3/4/2026", { ...opts, dayFirst: true })),
+    "2026-04-03"
+  );
+  // a part > 12 forces the order regardless of dayFirst
+  assert.equal(ymd(parseDateInput("21/7/2026", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("7/21/2026", { ...opts, dayFirst: true })), "2026-07-21");
+});
+
+test("two-digit years map to 20YY", () => {
+  assert.equal(ymd(parseDateInput("7/21/26", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("21/7/26", { ...opts, dayFirst: true })), "2026-07-21");
+});
+
+test("month names, long and short, any case", () => {
+  assert.equal(ymd(parseDateInput("21 Jul 2026", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("Jul 21 2026", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("July 21, 2026", opts)), "2026-07-21");
+  assert.equal(ymd(parseDateInput("21 december 2026", opts)), "2026-12-21");
+});
+
+test("partial input fills from the reference date", () => {
+  assert.equal(ymd(parseDateInput("5", opts)), "2026-07-05"); // day in ref month
+  assert.equal(ymd(parseDateInput("21/7", { ...opts, dayFirst: true })), "2026-07-21");
+  assert.equal(ymd(parseDateInput("12/25", opts)), "2026-12-25");
+  assert.equal(ymd(parseDateInput("25 Dec", opts)), "2026-12-25");
+  assert.equal(ymd(parseDateInput("Dec 25", opts)), "2026-12-25");
+});
+
+test("impossible dates rejected", () => {
+  assert.equal(parseDateInput("2026-02-30", opts), null);
+  assert.equal(parseDateInput("31/4/2026", { ...opts, dayFirst: true }), null);
+  assert.equal(parseDateInput("0", opts), null);
+  assert.equal(parseDateInput("32", opts), null);
+  assert.equal(parseDateInput("13/13/2026", opts), null);
+});
+
+test("garbage rejected", () => {
+  assert.equal(parseDateInput("", opts), null);
+  assert.equal(parseDateInput("asdf", opts), null);
+  assert.equal(parseDateInput("1/2/3/4", opts), null);
+  assert.equal(parseDateInput("Jul", opts), null);
+  assert.equal(parseDateInput("tomorrow+1", opts), null);
+});
+
+test("leap day handling", () => {
+  assert.equal(ymd(parseDateInput("2028-02-29", opts)), "2028-02-29");
+  assert.equal(parseDateInput("2026-02-29", opts), null);
+});
+
+test("isDayFirstPattern", () => {
+  assert.equal(isDayFirstPattern("DD/MM/YYYY"), true);
+  assert.equal(isDayFirstPattern("MM/DD/YYYY"), false);
+  assert.equal(isDayFirstPattern("YYYY-MM-DD"), false);
+  assert.equal(isDayFirstPattern("D MMM YYYY"), true);
+  assert.equal(isDayFirstPattern("[Due] MM/DD"), false);
+  assert.equal(isDayFirstPattern("YYYY"), null);
+});
+
+test("isDayFirstLocale", () => {
+  assert.equal(isDayFirstLocale("en-US"), false);
+  assert.equal(isDayFirstLocale("en-GB"), true);
+  assert.equal(isDayFirstLocale("de-DE"), true);
+});

package/dist/components/rel-date-picker/date-parse.ts

@@ -0,0 +1,178 @@
+/**
+ * Free-form date parsing for rel-date-picker's typed keyboard entry.
+ *
+ * Pure (Date + Intl only, no DOM, no Date.now — "today" comes in via
+ * `referenceDate`) so it is unit-testable in Node. The component owns range
+ * checks (minDate/maxDate); this module only turns text into a calendar day.
+ *
+ * Shortcuts (case/whitespace-insensitive):
+ *   "t", "today"        → referenceDate
+ *   "t+7", "t7", "t +7" → referenceDate + 7 days
+ *   "t-3"               → referenceDate − 3 days
+ *
+ * Date entry — parts split on `/ - . ,` or spaces, then classified:
+ *   "2026-07-21", "21/7/2026", "7/21/26", "21 Jul 2026", "July 21, 2026",
+ *   "21/7" (reference year), "21" (reference month), "20260721" (ISO digits).
+ * Two-digit years map to 20YY. When day/month order is ambiguous (both ≤ 12),
+ * `dayFirst` decides — derive it from the display format or locale via
+ * `isDayFirstPattern` / `isDayFirstLocale`.
+ */
+
+export interface ParseDateOptions {
+  /** "Today" and the fallback year/month for partial input. */
+  referenceDate: Date;
+  /** Ambiguous "a/b" order: true → day/month (EU), false → month/day (US). */
+  dayFirst?: boolean;
+  /** Locale for month-name matching (default "en-US"). */
+  locale?: string;
+}
+
+/** Day-before-month order of a display pattern, e.g. "DD/MM/YYYY" → true. */
+export function isDayFirstPattern(pattern: string): boolean | null {
+  // Strip bracketed literals so "[Due] DD/MM" doesn't match the literal's letters.
+  const bare = pattern.replace(/\[[^\]]*\]/g, "");
+  const d = bare.search(/D/);
+  const m = bare.search(/M/);
+  if (d === -1 || m === -1) return null;
+  return d < m;
+}
+
+/** Day-before-month order of a locale's default numeric date format. */
+export function isDayFirstLocale(locale: string): boolean {
+  try {
+    const parts = new Intl.DateTimeFormat(locale).formatToParts(
+      new Date(2020, 0, 15)
+    );
+    const d = parts.findIndex((p) => p.type === "day");
+    const m = parts.findIndex((p) => p.type === "month");
+    return d !== -1 && m !== -1 && d < m;
+  } catch {
+    return false;
+  }
+}
+
+/** 0-based month index for a month name in the locale (long/short), or null. */
+function matchMonthName(token: string, locale: string): number | null {
+  const cleaned = token.replace(/\.$/, "").toLowerCase();
+  if (!cleaned || /\d/.test(cleaned)) return null;
+  for (const style of ["long", "short"] as const) {
+    const fmt = new Intl.DateTimeFormat(locale, { month: style });
+    for (let m = 0; m < 12; m++) {
+      if (fmt.format(new Date(2020, m, 15)).toLowerCase() === cleaned) return m;
+    }
+  }
+  return null;
+}
+
+/** Reject impossible days (Feb 30 …) by round-tripping through Date. */
+function buildDate(year: number, monthIndex: number, day: number): Date | null {
+  if (monthIndex < 0 || monthIndex > 11 || day < 1 || day > 31) return null;
+  const date = new Date(year, monthIndex, day, 12, 0, 0);
+  if (date.getFullYear() !== year || date.getMonth() !== monthIndex || date.getDate() !== day) {
+    return null;
+  }
+  return date;
+}
+
+function normalizeYear(raw: string): number {
+  const n = parseInt(raw, 10);
+  return raw.length <= 2 ? 2000 + n : n;
+}
+
+export function parseDateInput(
+  text: string,
+  opts: ParseDateOptions
+): Date | null {
+  const input = text.trim();
+  if (!input) return null;
+  const locale = opts.locale ?? "en-US";
+  const ref = opts.referenceDate;
+
+  // ── Shortcuts: t / today / t±N ──
+  const shortcut = input.match(/^t(?:oday)?\s*(?:([+-])\s*)?(\d+)?$/i);
+  if (shortcut) {
+    const sign = shortcut[1] === "-" ? -1 : 1;
+    const offset = shortcut[2] ? sign * parseInt(shortcut[2], 10) : 0;
+    // "t-" / "t+" with no number is incomplete, not "today".
+    if (shortcut[1] && !shortcut[2]) return null;
+    return new Date(ref.getFullYear(), ref.getMonth(), ref.getDate() + offset, 12, 0, 0);
+  }
+
+  // ── Single run of digits: "21" (day), "0721"?, "20260721" (ISO) ──
+  if (/^\d+$/.test(input)) {
+    if (input.length <= 2) {
+      return buildDate(ref.getFullYear(), ref.getMonth(), parseInt(input, 10));
+    }
+    if (input.length === 8) {
+      return buildDate(
+        parseInt(input.slice(0, 4), 10),
+        parseInt(input.slice(4, 6), 10) - 1,
+        parseInt(input.slice(6), 10)
+      );
+    }
+    return null;
+  }
+
+  // ── Tokenized parts ──
+  const parts = input.split(/[\s/\-.,]+/).filter(Boolean);
+  if (parts.length < 2 || parts.length > 3) return null;
+
+  const dayFirst = opts.dayFirst ?? false;
+
+  // Classify each part: 4-digit year, month name, or plain number.
+  const yearIdx = parts.findIndex((p) => /^\d{4}$/.test(p));
+  const monthNameIdx = parts.findIndex((p) => matchMonthName(p, locale) !== null);
+
+  if (parts.length === 3) {
+    if (!parts.every((p, i) => i === monthNameIdx || /^\d{1,4}$/.test(p))) return null;
+    // ISO-style: 4-digit year leads → Y-M-D regardless of dayFirst.
+    if (yearIdx === 0 && monthNameIdx === -1) {
+      return buildDate(
+        parseInt(parts[0], 10),
+        parseInt(parts[1], 10) - 1,
+        parseInt(parts[2], 10)
+      );
+    }
+    // Year (2- or 4-digit) is last otherwise.
+    const yearRaw = parts[2];
+    if (!/^\d{1,4}$/.test(yearRaw) || monthNameIdx === 2) return null;
+    const year = normalizeYear(yearRaw);
+    let monthIndex: number;
+    let day: number;
+    if (monthNameIdx !== -1) {
+      monthIndex = matchMonthName(parts[monthNameIdx], locale)!;
+      const dayRaw = parts[monthNameIdx === 0 ? 1 : 0];
+      if (!/^\d{1,2}$/.test(dayRaw)) return null;
+      day = parseInt(dayRaw, 10);
+    } else {
+      if (!/^\d{1,2}$/.test(parts[0]) || !/^\d{1,2}$/.test(parts[1])) return null;
+      const a = parseInt(parts[0], 10);
+      const b = parseInt(parts[1], 10);
+      // A part that can't be a month forces the order; otherwise dayFirst decides.
+      if (a > 12 && b > 12) return null;
+      const useDayFirst = a > 12 ? true : b > 12 ? false : dayFirst;
+      day = useDayFirst ? a : b;
+      monthIndex = (useDayFirst ? b : a) - 1;
+    }
+    return buildDate(year, monthIndex, day);
+  }
+
+  // Two parts: day + month in the reference year ("21/7", "21 Jul", "Jul 21").
+  let monthIndex: number;
+  let day: number;
+  if (monthNameIdx !== -1) {
+    monthIndex = matchMonthName(parts[monthNameIdx], locale)!;
+    const dayRaw = parts[monthNameIdx === 0 ? 1 : 0];
+    if (!/^\d{1,2}$/.test(dayRaw)) return null;
+    day = parseInt(dayRaw, 10);
+  } else {
+    if (!/^\d{1,2}$/.test(parts[0]) || !/^\d{1,2}$/.test(parts[1])) return null;
+    const a = parseInt(parts[0], 10);
+    const b = parseInt(parts[1], 10);
+    if (a > 12 && b > 12) return null;
+    const useDayFirst = a > 12 ? true : b > 12 ? false : dayFirst;
+    day = useDayFirst ? a : b;
+    monthIndex = (useDayFirst ? b : a) - 1;
+  }
+  return buildDate(ref.getFullYear(), monthIndex, day);
+}