@reliability-design/web 1.4.6 → 1.4.8

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

@@ -1,116 +0,0 @@
-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

@@ -1,178 +0,0 @@
-/**
- * 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);
-}

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

@@ -1 +0,0 @@
-export * from "./rel-date-picker";