@reliability-design/web 1.4.5 → 1.4.6

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