@prolibu-suite/cobalt-core 0.1.2 → 0.2.0

package/dist/cjs/dates-D8D-aS5d.js

@@ -0,0 +1,432 @@
+'use strict';
+
+/**
+ * Cobalt date utilities — timezone-safe, date-only ("YYYY-MM-DD") helpers.
+ *
+ * Design rules (see the date-picker plan):
+ *   1. The value IS the string. `YYYY-MM-DD` is the source of truth. Compare
+ *      lexicographically — for ISO dates `"2026-06-03" < "2026-06-10"` holds.
+ *   2. Parse a string to a `Date` ONLY when unavoidable (Intl labels) and ALWAYS
+ *      via local parts: `new Date(y, m - 1, d)`. NEVER `new Date("2026-06-03")`
+ *      or `Date.parse(...)` — those parse as UTC midnight and shift the day in
+ *      negative-offset zones (e.g. es-CO / UTC-5).
+ *   3. Display formatting builds the string from the tuple — never via toISOString.
+ *
+ * Everything here is pure TS with zero dependencies so it can be consumed by
+ * `core` (Stencil web components), `form-core` and `form-vue` without creating a
+ * dependency cycle.
+ */
+const ISO_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const pad2 = (n) => String(n).padStart(2, '0');
+// ── Core round-trip ─────────────────────────────────────────────────────────
+/** Build a LOCAL Date from a tuple. The only sanctioned string→Date path. */
+function toLocalDate(ymd) {
+    return new Date(ymd.year, ymd.month - 1, ymd.day);
+}
+/** Extract local-part tuple from a Date. Never uses UTC getters. */
+function fromLocalDate(d) {
+    return { year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate() };
+}
+/**
+ * True when `value` is a syntactically well-formed AND real calendar date
+ * (rejects "2026-02-31", "2026-13-01", etc.) in strict "YYYY-MM-DD" form.
+ */
+function isValidYMD(value) {
+    if (typeof value !== 'string')
+        return false;
+    const m = ISO_RE.exec(value);
+    if (!m)
+        return false;
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    if (month < 1 || month > 12 || day < 1 || day > 31)
+        return false;
+    // Reconstruct and confirm nothing rolled over (e.g. Feb 31 → Mar 3).
+    const d = new Date(year, month - 1, day);
+    return d.getFullYear() === year && d.getMonth() === month - 1 && d.getDate() === day;
+}
+/** Parse strict "YYYY-MM-DD" → tuple, or null when invalid. */
+function parseISO(value) {
+    if (!isValidYMD(value))
+        return null;
+    const m = ISO_RE.exec(value);
+    return { year: Number(m[1]), month: Number(m[2]), day: Number(m[3]) };
+}
+/** Format a tuple → "YYYY-MM-DD". */
+function formatISO(ymd) {
+    return `${String(ymd.year).padStart(4, '0')}-${pad2(ymd.month)}-${pad2(ymd.day)}`;
+}
+/** Today's local date as "YYYY-MM-DD". Never uses toISOString (UTC). */
+function todayYMD() {
+    return formatISO(fromLocalDate(new Date()));
+}
+// ── Flexible manual-input parsing ───────────────────────────────────────────
+/**
+ * Parse free-form user text into a normalized "YYYY-MM-DD".
+ *
+ * Accepts separators `/ . -`, partial input (year omitted → `defaultYear`),
+ * 2-digit years, and a canonical ISO string. Validates by reconstruction so
+ * impossible dates like "31/02/2026" come back as `{ status: 'invalid' }`.
+ *
+ * Returns `{ status: 'empty' }` for blank input (the field should commit `null`).
+ */
+function parseFlexible(input, opts = {}) {
+    const order = opts.order ?? 'dmy';
+    const pivot = opts.twoDigitYearPivot ?? 69;
+    const invalid = { status: 'invalid', value: null };
+    const raw = (input ?? '').trim();
+    if (raw === '')
+        return { status: 'empty', value: null };
+    // Fast path: already canonical ISO.
+    if (ISO_RE.test(raw)) {
+        return isValidYMD(raw) ? { status: 'valid', value: raw } : invalid;
+    }
+    // Tokenize on separators + whitespace; drop filler words ("de", "of").
+    const tokens = raw
+        .split(/[/.\-\s]+/)
+        .filter(Boolean)
+        .filter((t) => !FILLER_WORDS.has(normalizeName(t)));
+    if (tokens.length < 2 || tokens.length > 3)
+        return invalid;
+    // Classify tokens into numerics (with position) and an optional month name.
+    const monthIdx = monthNameIndex(opts.locale);
+    const numerics = [];
+    let monthFromName = null;
+    tokens.forEach((t, pos) => {
+        if (/^\d+$/.test(t)) {
+            numerics.push({ val: Number(t), pos });
+        }
+        else {
+            const m = monthIdx[normalizeName(t)];
+            if (m && monthFromName === null)
+                monthFromName = m;
+            else
+                monthFromName = -1; // unknown/duplicate name → force invalid
+        }
+    });
+    if (monthFromName === -1)
+        return invalid;
+    let day;
+    let month;
+    let year;
+    if (monthFromName !== null) {
+        // Month came from a name; the numerics are day and/or year.
+        month = monthFromName;
+        if (numerics.length === 2) {
+            const [a, b] = numerics; // already in original order
+            // Prefer an explicit 4-digit / >31 value as the year.
+            if (a.val > 31 || tokenLen(tokens, a.pos) === 4) {
+                year = a.val;
+                day = b.val;
+            }
+            else if (b.val > 31 || tokenLen(tokens, b.pos) === 4) {
+                year = b.val;
+                day = a.val;
+            }
+            else {
+                // Ambiguous → use order (ymd: year first, else year last).
+                year = order === 'ymd' ? a.val : b.val;
+                day = order === 'ymd' ? b.val : a.val;
+            }
+        }
+        else if (numerics.length === 1) {
+            day = numerics[0].val;
+            year = opts.defaultYear ?? new Date().getFullYear();
+        }
+        else {
+            return invalid;
+        }
+    }
+    else {
+        // All numeric.
+        const nums = numerics.map((n) => n.val);
+        if (nums.length === 2) {
+            const [a, b] = nums;
+            // With the year omitted, year-first locales (ymd) fall back to the ISO
+            // month-day order — only day-first locales (dmy) read it as day/month.
+            if (order === 'mdy' || order === 'ymd') {
+                month = a;
+                day = b;
+            }
+            else {
+                day = a;
+                month = b;
+            }
+            year = opts.defaultYear ?? new Date().getFullYear();
+        }
+        else {
+            const [a, b, c] = nums;
+            if (order === 'ymd') {
+                year = a;
+                month = b;
+                day = c;
+            }
+            else if (order === 'mdy') {
+                month = a;
+                day = b;
+                year = c;
+            }
+            else {
+                day = a;
+                month = b;
+                year = c;
+            }
+        }
+    }
+    year = normalizeYear(year, pivot);
+    const candidate = formatISO({ year, month, day });
+    return isValidYMD(candidate) ? { status: 'valid', value: candidate } : invalid;
+}
+function tokenLen(tokens, pos) {
+    return tokens[pos]?.length ?? 0;
+}
+function normalizeYear(year, pivot) {
+    if (year >= 100)
+        return year;
+    // 2-digit (or 1-digit) year.
+    return year <= pivot ? 2000 + year : 1900 + year;
+}
+const FILLER_WORDS = new Set(['de', 'del', 'of', 'the']);
+/** Lowercase, strip accents and a trailing period. */
+function normalizeName(s) {
+    return s
+        .normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/\.$/, '')
+        .trim();
+}
+// Hardcoded Spanish + English month names (normalized) as a stable fallback,
+// regardless of the runtime Intl data.
+const BASE_MONTHS = {
+    // Spanish
+    enero: 1, febrero: 2, marzo: 3, abril: 4, mayo: 5, junio: 6, julio: 7,
+    agosto: 8, septiembre: 9, setiembre: 9, octubre: 10, noviembre: 11, diciembre: 12,
+    ene: 1, feb: 2, mar: 3, abr: 4, may: 5, jun: 6, jul: 7, ago: 8,
+    sep: 9, set: 9, oct: 10, nov: 11, dic: 12,
+    // English
+    january: 1, february: 2, march: 3, april: 4, june: 6, july: 7,
+    august: 8, september: 9, october: 10, november: 11, december: 12,
+    jan: 1, apr: 4, aug: 8, dec: 12,
+    // Portuguese (accents already stripped by normalizeName: "março" → "marco")
+    janeiro: 1, fevereiro: 2, marco: 3, maio: 5, junho: 6, julho: 7,
+    setembro: 9, outubro: 10, novembro: 11, dezembro: 12,
+    fev: 2, mai: 5, out: 10, dez: 12,
+};
+const monthIndexCache = new Map();
+/** Build a normalized month-name → 1..12 lookup for a locale (memoized). */
+function monthNameIndex(locale) {
+    const key = locale || '_base';
+    const cached = monthIndexCache.get(key);
+    if (cached)
+        return cached;
+    const map = { ...BASE_MONTHS };
+    if (locale) {
+        for (let m = 0; m < 12; m++) {
+            const d = new Date(2020, m, 1);
+            for (const style of ['short', 'long']) {
+                const name = normalizeName(new Intl.DateTimeFormat(locale, { month: style }).format(d));
+                if (name) {
+                    map[name] = m + 1;
+                    // Also index the 3-letter prefix (covers locale-specific abbreviations).
+                    if (name.length >= 3)
+                        map[name.slice(0, 3)] = m + 1;
+                }
+            }
+        }
+    }
+    monthIndexCache.set(key, map);
+    return map;
+}
+// ── Display formatting ──────────────────────────────────────────────────────
+/**
+ * Format "YYYY-MM-DD" for display using a token pattern. Supported tokens:
+ * `yyyy`, `yy`, `MMMM` (full month name), `MMM` (short month name), `MM`, `M`,
+ * `dd`, `d`. Month names are localized via `Intl` (trailing "." stripped).
+ * Default pattern `dd/MM/yyyy`. Returns '' when value is null/empty/invalid.
+ *
+ * Uses a single regex pass (not chained .replace) so an inserted month name
+ * like "dic"/"ene" is never re-scanned by the `d`/`M` token replacers.
+ */
+function formatDisplay(value, displayFormat = 'dd/MM/yyyy', locale = 'en-US') {
+    if (!value)
+        return '';
+    const ymd = parseISO(value);
+    if (!ymd)
+        return '';
+    const d = toLocalDate(ymd);
+    return displayFormat.replace(/yyyy|yy|MMMM|MMM|MM|M|dd|d/g, (tok) => {
+        switch (tok) {
+            case 'yyyy':
+                return String(ymd.year).padStart(4, '0');
+            case 'yy':
+                return String(ymd.year).slice(-2);
+            case 'MMMM':
+                return new Intl.DateTimeFormat(locale, { month: 'long' }).format(d);
+            case 'MMM':
+                return stripTrailingDot(new Intl.DateTimeFormat(locale, { month: 'short' }).format(d));
+            case 'MM':
+                return pad2(ymd.month);
+            case 'M':
+                return String(ymd.month);
+            case 'dd':
+                return pad2(ymd.day);
+            case 'd':
+                return String(ymd.day);
+            default:
+                return tok;
+        }
+    });
+}
+function stripTrailingDot(s) {
+    return s.replace(/\.$/, '');
+}
+// ── Comparison & arithmetic ─────────────────────────────────────────────────
+/** Lexicographic compare of two "YYYY-MM-DD" strings → -1 | 0 | 1. */
+function compareYMD(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+/** Add (or subtract) calendar days, returning "YYYY-MM-DD".
+ *  An unparseable input is returned unchanged (pass-through, NOT null —
+ *  callers chaining arithmetic keep their original value instead of crashing;
+ *  validate with `parseISO` first if you need to reject bad input). */
+function addDays(value, n) {
+    const ymd = parseISO(value);
+    if (!ymd)
+        return value;
+    const d = toLocalDate(ymd);
+    d.setDate(d.getDate() + n);
+    return formatISO(fromLocalDate(d));
+}
+/**
+ * Add (or subtract) months. Clamps the day to the target month's length so
+ * "2026-01-31" + 1 month → "2026-02-28" (not a March rollover).
+ * Unparseable input passes through unchanged (same contract as `addDays`).
+ */
+function addMonths(value, n) {
+    const ymd = parseISO(value);
+    if (!ymd)
+        return value;
+    const targetMonthIndex = ymd.month - 1 + n;
+    const targetYear = ymd.year + Math.floor(targetMonthIndex / 12);
+    const targetMonth = ((targetMonthIndex % 12) + 12) % 12; // 0-11
+    const lastDay = new Date(targetYear, targetMonth + 1, 0).getDate();
+    const day = Math.min(ymd.day, lastDay);
+    return formatISO({ year: targetYear, month: targetMonth + 1, day });
+}
+/** First day of the month for a given date. */
+function startOfMonth(value) {
+    const ymd = parseISO(value);
+    if (!ymd)
+        return value;
+    return formatISO({ year: ymd.year, month: ymd.month, day: 1 });
+}
+/** Whether `value` lies within [min, max] (inclusive). */
+function isWithinRange(value, min, max) {
+    if (min && compareYMD(value, min) < 0)
+        return false;
+    if (max && compareYMD(value, max) > 0)
+        return false;
+    return true;
+}
+/** Weekday for a date, 0=Sunday .. 6=Saturday (local, tz-safe). */
+function dayOfWeek(value) {
+    const ymd = parseISO(value);
+    if (!ymd)
+        return -1;
+    return toLocalDate(ymd).getDay();
+}
+/**
+ * Whether a date should be non-selectable given range/explicit/weekday rules.
+ * Invalid input counts as disabled.
+ */
+function isDisabled(value, opts = {}) {
+    if (!isValidYMD(value))
+        return true;
+    if (!isWithinRange(value, opts.min, opts.max))
+        return true;
+    if (opts.disabledDates && opts.disabledDates.includes(value))
+        return true;
+    if (opts.disabledDaysOfWeek && opts.disabledDaysOfWeek.includes(dayOfWeek(value)))
+        return true;
+    return false;
+}
+// ── Calendar grid ───────────────────────────────────────────────────────────
+/**
+ * Build a month grid of {value, inMonth} cells. Includes leading/trailing days
+ * from adjacent months so the calendar can render the `outside-month` state.
+ *
+ * @param year  full year
+ * @param month 1-12
+ * @param firstDayOfWeek 0=Sunday .. 6=Saturday. Default 1 (Monday).
+ * @param weeks number of week rows. Default 6 (stable height).
+ */
+function getMonthMatrix(year, month, firstDayOfWeek = 1, weeks = 6) {
+    const first = new Date(year, month - 1, 1);
+    const lead = (first.getDay() - firstDayOfWeek + 7) % 7;
+    const start = new Date(year, month - 1, 1 - lead);
+    const rows = [];
+    for (let w = 0; w < weeks; w++) {
+        const row = [];
+        for (let d = 0; d < 7; d++) {
+            const cur = new Date(start.getFullYear(), start.getMonth(), start.getDate() + (w * 7 + d));
+            row.push({
+                value: formatISO(fromLocalDate(cur)),
+                inMonth: cur.getMonth() === month - 1,
+            });
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+// ── Locale-aware labels (Intl, fed by local-parts Dates) ────────────────────
+/**
+ * Weekday short labels starting at `firstDayOfWeek`, in `locale`.
+ * e.g. es-CO Monday-first → ["lun.","mar.",...] (caller may trim/uppercase).
+ */
+function getWeekdayLabels(locale, firstDayOfWeek = 1, weekday = 'short') {
+    const fmt = new Intl.DateTimeFormat(locale, { weekday });
+    const labels = [];
+    // 2024-01-01 is a Monday; anchor from it then offset to firstDayOfWeek.
+    for (let i = 0; i < 7; i++) {
+        const offset = (i + (firstDayOfWeek - 1) + 7) % 7;
+        const d = new Date(2024, 0, 1 + offset); // local-parts Date
+        labels.push(fmt.format(d));
+    }
+    return labels;
+}
+/** Localized "month year" header label, e.g. "junio de 2026". */
+function getMonthLabel(year, month, locale, monthStyle = 'long') {
+    return new Intl.DateTimeFormat(locale, { month: monthStyle, year: 'numeric' }).format(new Date(year, month - 1, 1));
+}
+/** Localized full label for a single date, for screen-reader announcements. */
+function getFullDateLabel(value, locale) {
+    const ymd = parseISO(value);
+    if (!ymd)
+        return '';
+    return new Intl.DateTimeFormat(locale, {
+        weekday: 'long',
+        day: 'numeric',
+        month: 'long',
+        year: 'numeric',
+    }).format(toLocalDate(ymd));
+}
+
+exports.addDays = addDays;
+exports.addMonths = addMonths;
+exports.compareYMD = compareYMD;
+exports.formatDisplay = formatDisplay;
+exports.getFullDateLabel = getFullDateLabel;
+exports.getMonthLabel = getMonthLabel;
+exports.getMonthMatrix = getMonthMatrix;
+exports.getWeekdayLabels = getWeekdayLabels;
+exports.isDisabled = isDisabled;
+exports.isValidYMD = isValidYMD;
+exports.parseFlexible = parseFlexible;
+exports.parseISO = parseISO;
+exports.startOfMonth = startOfMonth;
+exports.toLocalDate = toLocalDate;
+exports.todayYMD = todayYMD;