@pine-ds/core 5.0.0-mercury.0 → 5.0.0

package/dist/collection/components/pds-datepicker/presets.js

@@ -0,0 +1,131 @@
+import { addDays, addMonths, isOutOfRange, parseIsoDate } from "./date-utils";
+const DEFAULT_LABELS = {
+    'today': 'Today',
+    'yesterday': 'Yesterday',
+    'last-7-days': 'Last 7 days',
+    'last-30-days': 'Last 30 days',
+    'last-90-days': 'Last 90 days',
+    'this-month': 'This month',
+    'last-month': 'Last month',
+    'this-quarter': 'This quarter',
+    'last-quarter': 'Last quarter',
+    'this-year': 'This year',
+    'last-year': 'Last year',
+    'year-to-date': 'Year to date',
+    'last-12-months': 'Last 12 months',
+};
+const utc = (year, month, day) => new Date(Date.UTC(year, month, day));
+/**
+ * The range a built-in preset covers on the given day, or `null` for an unknown key. "Last N days"
+ * is N days ending today; "this" and "last" periods are whole periods; "to date" ends today.
+ */
+export function builtInPresetRange(key, now) {
+    const year = now.getUTCFullYear();
+    const month = now.getUTCMonth();
+    const quarterStart = month - (month % 3);
+    switch (key) {
+        case 'today':
+            return [now, now];
+        case 'yesterday':
+            return [addDays(now, -1), addDays(now, -1)];
+        case 'last-7-days':
+            return [addDays(now, -6), now];
+        case 'last-30-days':
+            return [addDays(now, -29), now];
+        case 'last-90-days':
+            return [addDays(now, -89), now];
+        case 'this-month':
+            return [utc(year, month, 1), utc(year, month + 1, 0)];
+        case 'last-month':
+            return [utc(year, month - 1, 1), utc(year, month, 0)];
+        case 'this-quarter':
+            return [utc(year, quarterStart, 1), utc(year, quarterStart + 3, 0)];
+        case 'last-quarter':
+            return [utc(year, quarterStart - 3, 1), utc(year, quarterStart, 0)];
+        case 'this-year':
+            return [utc(year, 0, 1), utc(year, 11, 31)];
+        case 'last-year':
+            return [utc(year - 1, 0, 1), utc(year - 1, 11, 31)];
+        case 'year-to-date':
+            return [utc(year, 0, 1), now];
+        case 'last-12-months':
+            return [addMonths(now, -12), now];
+        default:
+            return null;
+    }
+}
+const isWholeNumber = (value) => typeof value === 'number' && Number.isInteger(value);
+/** A preset's offset range: whole days from today, a missing or `null` one being today. `null` if unusable. */
+export function offsetPresetRange(preset, now) {
+    const { startOffset, endOffset } = preset;
+    // Checked at runtime, as offsets often come from JSON, where a missing one is often written `null`.
+    if (startOffset == null && endOffset == null)
+        return null;
+    if (startOffset != null && !isWholeNumber(startOffset))
+        return null;
+    if (endOffset != null && !isWholeNumber(endOffset))
+        return null;
+    const start = addDays(now, startOffset !== null && startOffset !== void 0 ? startOffset : 0);
+    const end = addDays(now, endOffset !== null && endOffset !== void 0 ? endOffset : 0);
+    return start <= end ? [start, end] : null;
+}
+// The list is re-resolved on every read, so each warning is said once.
+const warned = new Set();
+function warnOnce(message) {
+    if (warned.has(message))
+        return;
+    warned.add(message);
+    console.warn(`PDS Datepicker: ${message}`);
+}
+/**
+ * Normalizes the `presets` prop: a comma-separated list of built-in keys, or an array of presets
+ * that may relabel a built-in or give their own range. Unusable entries are dropped with a warning.
+ */
+export function resolvePresets(presets, now) {
+    var _a;
+    const entries = typeof presets === 'string'
+        ? presets
+            .split(',')
+            .map((key) => key.trim())
+            .filter(Boolean)
+            .map((key) => ({ key }))
+        : Array.isArray(presets)
+            ? presets
+            : [];
+    const resolved = [];
+    for (const preset of entries) {
+        // Presets often come from parsed JSON, so check types at runtime: a non-string label would
+        // otherwise reach the render as an object, which Stencil can turn into nodes.
+        if (!preset || typeof preset.key !== 'string') {
+            warnOnce('a preset with no string key was left out.');
+            continue;
+        }
+        const start = typeof preset.start === 'string' ? parseIsoDate(preset.start) : null;
+        const end = typeof preset.end === 'string' ? parseIsoDate(preset.end) : null;
+        // Fixed days, then offsets, then the built-in range.
+        const fixed = start !== null && end !== null && start <= end ? [start, end] : null;
+        const range = (_a = fixed !== null && fixed !== void 0 ? fixed : offsetPresetRange(preset, now)) !== null && _a !== void 0 ? _a : builtInPresetRange(preset.key, now);
+        // A blank label would leave the button unnamed.
+        const label = typeof preset.label === 'string' && preset.label.trim() !== '' ? preset.label : DEFAULT_LABELS[preset.key];
+        if (range === null) {
+            warnOnce(`preset "${preset.key}" has no usable range and was left out. Give it whole-day startOffset/endOffset or YYYY-MM-DD start/end, start first.`);
+            continue;
+        }
+        if (label === undefined) {
+            warnOnce(`preset "${preset.key}" has no label and was left out.`);
+            continue;
+        }
+        resolved.push({ key: preset.key, label, start: range[0], end: range[1] });
+    }
+    return resolved;
+}
+/** The first preset covering exactly this range. */
+export function matchPreset(presets, start, end) {
+    if (!start || !end)
+        return undefined;
+    return presets.find((preset) => preset.start.getTime() === start.getTime() && preset.end.getTime() === end.getTime());
+}
+/** Whether a preset's whole range can be picked within `min` and `max`. */
+export function presetInRange(preset, min, max) {
+    return !isOutOfRange(preset.start, min, max) && !isOutOfRange(preset.end, min, max);
+}

package/dist/collection/components/pds-datepicker/stories/pds-datepicker.stories.js

@@ -0,0 +1,206 @@
+import { html } from 'lit';
+import { ifDefined } from 'lit-html/directives/if-defined.js';
+
+export default {
+  args: {
+    autoApply: false,
+    clearable: false,
+    disabled: false,
+    errorMessage: null,
+    firstDayOfWeek: null,
+    format: 'YYYY-MM-DD',
+    fullWidth: false,
+    helperMessage: null,
+    hideLabel: false,
+    invalid: false,
+    locale: null,
+    max: null,
+    min: null,
+    minuteIncrement: 1,
+    monthDay: false,
+    name: null,
+    presets: null,
+    range: false,
+    placeholder: null,
+    placement: 'bottom-start',
+    readonly: false,
+    required: false,
+    showDropdowns: false,
+    timePicker: false,
+    value: null,
+  },
+  argTypes: {
+    placement: {
+      control: 'select',
+      options: ['bottom-start', 'bottom', 'bottom-end', 'top-start', 'top', 'top-end'],
+    },
+    presets: {
+      control: 'text',
+    },
+    pdsDatepickerChange: {
+      action: 'pdsDatepickerChange',
+    },
+  },
+  component: 'pds-datepicker',
+  parameters: {
+    actions: {
+      handles: ['pdsDatepickerChange'],
+    },
+  },
+  title: 'components/Datepicker',
+};
+
+const BaseTemplate = (args) => html`<pds-datepicker
+  ?auto-apply=${args.autoApply}
+  ?clearable=${args.clearable}
+  component-id="${args.componentId}"
+  ?disabled=${args.disabled}
+  error-message=${ifDefined(args.errorMessage ?? undefined)}
+  first-day-of-week=${ifDefined(args.firstDayOfWeek ?? undefined)}
+  format=${ifDefined(args.format ?? undefined)}
+  ?full-width=${args.fullWidth}
+  helper-message=${ifDefined(args.helperMessage ?? undefined)}
+  ?hide-label=${args.hideLabel}
+  ?invalid=${args.invalid}
+  label="${args.label}"
+  locale=${ifDefined(args.locale ?? undefined)}
+  max=${ifDefined(args.max ?? undefined)}
+  min=${ifDefined(args.min ?? undefined)}
+  minute-increment=${ifDefined(args.minuteIncrement ?? undefined)}
+  ?month-day=${args.monthDay}
+  name=${ifDefined(args.name ?? undefined)}
+  placeholder=${ifDefined(args.placeholder ?? undefined)}
+  placement=${ifDefined(args.placement ?? undefined)}
+  presets=${ifDefined(args.presets ?? undefined)}
+  ?range=${args.range}
+  ?readonly=${args.readonly}
+  ?required=${args.required}
+  ?show-dropdowns=${args.showDropdowns}
+  ?time-picker=${args.timePicker}
+  value=${ifDefined(args.value ?? undefined)}>
+</pds-datepicker>`;
+
+export const Default = BaseTemplate.bind({});
+Default.args = {
+  componentId: 'pds-datepicker-default-example',
+  label: 'Due date',
+};
+
+export const WithValue = BaseTemplate.bind({});
+WithValue.args = {
+  componentId: 'pds-datepicker-value-example',
+  label: 'Due date',
+  value: '2026-10-13',
+};
+
+export const MinAndMax = BaseTemplate.bind({});
+MinAndMax.args = {
+  componentId: 'pds-datepicker-min-max-example',
+  helperMessage: 'Pick a day between October 5 and November 20.',
+  label: 'Delivery date',
+  max: '2026-11-20',
+  min: '2026-10-05',
+  value: '2026-10-13',
+};
+
+export const Locale = BaseTemplate.bind({});
+Locale.args = {
+  componentId: 'pds-datepicker-locale-example',
+  label: "Date d'échéance",
+  locale: 'fr',
+  value: '2026-10-13',
+};
+
+export const Invalid = BaseTemplate.bind({});
+Invalid.args = {
+  componentId: 'pds-datepicker-invalid-example',
+  errorMessage: 'Choose a date after today.',
+  invalid: true,
+  label: 'Due date',
+  value: '2026-10-13',
+};
+
+export const Disabled = BaseTemplate.bind({});
+Disabled.args = {
+  componentId: 'pds-datepicker-disabled-example',
+  disabled: true,
+  label: 'Due date',
+  value: '2026-10-13',
+};
+
+export const Range = BaseTemplate.bind({});
+Range.args = {
+  componentId: 'pds-datepicker-range-mode-example',
+  label: 'Period',
+  range: true,
+};
+
+export const RangeWithPresets = BaseTemplate.bind({});
+RangeWithPresets.args = {
+  componentId: 'pds-datepicker-range-presets-example',
+  hideLabel: true,
+  label: 'Period',
+  presets: 'today,last-7-days,last-30-days,last-month,this-month,last-quarter,this-quarter,this-year,last-12-months,year-to-date',
+  range: true,
+};
+
+export const RangeWithTimes = BaseTemplate.bind({});
+RangeWithTimes.args = {
+  componentId: 'pds-datepicker-range-times-example',
+  label: 'Event',
+  minuteIncrement: 15,
+  range: true,
+  timePicker: true,
+  value: '2026-10-13T14:00/2026-10-14T22:00',
+};
+
+export const MonthAndYearDropdowns = BaseTemplate.bind({});
+MonthAndYearDropdowns.args = {
+  componentId: 'pds-datepicker-dropdowns-example',
+  label: 'Birthday',
+  max: '2026-10-13',
+  min: '1901-01-01',
+  showDropdowns: true,
+};
+
+export const MonthDay = BaseTemplate.bind({});
+MonthDay.args = {
+  componentId: 'pds-datepicker-month-day-example',
+  format: null,
+  label: 'Birthday',
+  monthDay: true,
+  value: '--11-07',
+};
+
+export const InitiallyEmptyWithClear = BaseTemplate.bind({});
+InitiallyEmptyWithClear.args = {
+  clearable: true,
+  componentId: 'pds-datepicker-clearable-example',
+  label: 'Created',
+  range: true,
+};
+
+export const Format = BaseTemplate.bind({});
+Format.args = {
+  componentId: 'pds-datepicker-format-example',
+  format: 'MM/DD/YYYY',
+  label: 'Due date',
+  value: '2026-10-13',
+};
+
+export const RangeAutoApply = BaseTemplate.bind({});
+RangeAutoApply.args = {
+  autoApply: true,
+  componentId: 'pds-datepicker-auto-apply-example',
+  label: 'Period',
+  presets: 'today,last-7-days,last-30-days',
+  range: true,
+};
+
+export const Clearable = BaseTemplate.bind({});
+Clearable.args = {
+  clearable: true,
+  componentId: 'pds-datepicker-clearable-single-example',
+  label: 'Due date',
+  value: '2026-10-13',
+};

package/dist/collection/components/pds-datepicker/value.js

@@ -0,0 +1,296 @@
+import { MONTH_DAY_YEAR, dateFormatter, inMonthDayYear, parseIsoDate, parseMonthDay, toIsoDate } from "./date-utils";
+const DATE_TIME = /^(\d{4}-\d{2}-\d{2})(?:[T ](\d{2}):(\d{2}))?$/;
+/** Parses `YYYY-MM-DD`, `YYYY-MM-DDTHH:mm` or `YYYY-MM-DD HH:mm`. */
+export function parseDateTime(text) {
+    const match = DATE_TIME.exec((text !== null && text !== void 0 ? text : '').trim());
+    if (!match)
+        return null;
+    const date = parseIsoDate(match[1]);
+    if (!date)
+        return null;
+    if (match[2] === undefined)
+        return { date, time: null };
+    const hours = Number(match[2]);
+    const minutes = Number(match[3]);
+    return hours < 24 && minutes < 60 ? { date, time: `${match[2]}:${match[3]}` } : null;
+}
+export const DEFAULT_FORMAT = 'YYYY-MM-DD';
+/**
+ * A format's parts: `[text]` is literal text, and the tokens are `YYYY`, `MMMM` (month name),
+ * `MMM` (short month name), `MM`/`M` (month), `DD`/`D` (day), `HH`/`H` (24-hour), `hh`/`h`
+ * (12-hour), `mm` (minutes) and `A`/`a` (AM/PM). Longest tokens first, so `MM` isn't read as two
+ * `M`s. Anything else is copied as is.
+ */
+const FORMAT_PARTS = /\[([^\]]*)\]|YYYY|MMMM|MMM|MM|M|DD|D|HH|H|hh|h|mm|A|a/g;
+const HOUR_TOKEN = /HH|H|hh|h/;
+const TWELVE_HOUR_TOKEN = /hh|h/;
+const PERIOD_TOKEN = /A|a/;
+/** Without its `[literal]` parts, to test which tokens a format uses. */
+const tokensOnly = (format) => format.replace(/\[[^\]]*\]/g, '');
+/**
+ * The field's format: the date format, with a time added when the time picker is on and it has
+ * none, on the same clock as the time picker. A 12-hour format gets AM/PM if it has none, as
+ * `1:30` alone can't say which.
+ */
+export function fieldFormat(format, timePicker, hour12 = false) {
+    const date = (format === null || format === void 0 ? void 0 : format.trim()) || DEFAULT_FORMAT;
+    const tokens = tokensOnly(date);
+    if (TWELVE_HOUR_TOKEN.test(tokens) && !PERIOD_TOKEN.test(tokens))
+        return `${date} A`;
+    if (!timePicker || HOUR_TOKEN.test(tokens))
+        return date;
+    return `${date} ${hour12 ? 'h:mm A' : 'HH:mm'}`;
+}
+const pad = (n, width = 2) => String(n).padStart(width, '0');
+const wordsCache = new Map();
+/** Month names and AM/PM words in the locale, on the Gregorian calendar. */
+function localeWords(locale) {
+    let words = wordsCache.get(locale);
+    if (!words) {
+        const month = (style, withDay) => {
+            const format = new Intl.DateTimeFormat(locale, Object.assign(Object.assign({ month: style }, (withDay ? { day: 'numeric' } : {})), { timeZone: 'UTC', calendar: 'gregory' }));
+            return Array.from({ length: 12 }, (_, m) => {
+                const date = new Date(Date.UTC(2023, m, 1));
+                if (!withDay)
+                    return format.format(date);
+                const parts = format.formatToParts(date);
+                const index = parts.findIndex((part) => part.type === 'month');
+                if (index === -1)
+                    return format.format(date);
+                // CJK locales split a counter word, as Japanese `月`, into its own literal right after the
+                // month; a literal with no space is that word, not the separator before the day.
+                const suffix = parts[index + 1];
+                return (suffix === null || suffix === void 0 ? void 0 : suffix.type) === 'literal' && !/\s/.test(suffix.value) ? parts[index].value + suffix.value : parts[index].value;
+            });
+        };
+        const clock = clockFor(locale);
+        words = {
+            months: month('long', false),
+            shortMonths: month('short', false),
+            monthsWithDay: month('long', true),
+            shortMonthsWithDay: month('short', true),
+            am: clock.am,
+            pm: clock.pm,
+        };
+        wordsCache.set(locale, words);
+    }
+    return words;
+}
+/** Whether a format's tokens (see `tokensOnly`) have a day, so a month name should inflect for one. */
+const hasDayToken = (tokens) => /D/.test(tokens);
+/** Writes a date in a format of tokens (see `FORMAT_PARTS`), with month names and AM/PM in the locale. */
+export function formatWith(value, format, locale = 'en-US') {
+    var _a;
+    const words = localeWords(locale);
+    const withDay = hasDayToken(tokensOnly(format));
+    const [hours, minutes] = splitTime((_a = value.time) !== null && _a !== void 0 ? _a : '00:00');
+    const hour12 = hours % 12 || 12;
+    const month = value.date.getUTCMonth();
+    const period = hours < 12 ? words.am : words.pm;
+    const parts = {
+        YYYY: pad(value.date.getUTCFullYear(), 4),
+        MMMM: withDay ? words.monthsWithDay[month] : words.months[month],
+        MMM: withDay ? words.shortMonthsWithDay[month] : words.shortMonths[month],
+        MM: pad(month + 1),
+        M: String(month + 1),
+        DD: pad(value.date.getUTCDate()),
+        D: String(value.date.getUTCDate()),
+        HH: pad(hours),
+        H: String(hours),
+        hh: pad(hour12),
+        h: String(hour12),
+        mm: pad(minutes),
+        A: period,
+        a: period.toLowerCase(),
+    };
+    return format.replace(FORMAT_PARTS, (token, literal) => literal !== null && literal !== void 0 ? literal : parts[token]);
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Escapes a format's literal text for a pattern, letting its spaces match any run of spaces. */
+const literalPattern = (literal) => escapeRegExp(literal).replace(/\s+/g, '\\s*');
+const alternatives = (words) => `(${words.map(escapeRegExp).join('|')})`;
+/**
+ * Reads typed text in a format of tokens, as written by `formatWith`. Leading zeros are optional,
+ * spaces are loose, and month names and AM/PM are matched without regard to case, in the locale or
+ * in English. A format without `YYYY` reads into `year`, and without `year` it reads nothing.
+ * Returns `null` for anything that isn't a real date and time in that format.
+ */
+export function parseWith(text, format, locale = 'en-US', year) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const words = localeWords(locale);
+    const english = localeWords('en-US');
+    const withDay = hasDayToken(tokensOnly(format));
+    const months = withDay ? words.monthsWithDay : words.months;
+    const shortMonths = withDay ? words.shortMonthsWithDay : words.shortMonths;
+    const englishMonths = withDay ? english.monthsWithDay : english.months;
+    const englishShortMonths = withDay ? english.shortMonthsWithDay : english.shortMonths;
+    const periods = [words.am, words.pm, english.am, english.pm];
+    const patterns = {
+        YYYY: '(\\d{4})',
+        MMMM: alternatives([...months, ...englishMonths]),
+        MMM: alternatives([...shortMonths, ...englishShortMonths]),
+        MM: '(\\d{1,2})',
+        M: '(\\d{1,2})',
+        DD: '(\\d{1,2})',
+        D: '(\\d{1,2})',
+        HH: '(\\d{1,2})',
+        H: '(\\d{1,2})',
+        hh: '(\\d{1,2})',
+        h: '(\\d{1,2})',
+        mm: '(\\d{2})',
+        A: alternatives(periods),
+        a: alternatives(periods),
+    };
+    const tokens = [];
+    const build = () => {
+        tokens.length = 0;
+        let pattern = '';
+        let last = 0;
+        format.replace(FORMAT_PARTS, (token, literal, offset) => {
+            pattern += literalPattern(format.slice(last, offset));
+            if (literal !== undefined) {
+                pattern += literalPattern(literal);
+            }
+            else {
+                pattern += patterns[token];
+                tokens.push(token);
+            }
+            last = offset + token.length;
+            return token;
+        });
+        return new RegExp(`^\\s*${pattern}${literalPattern(format.slice(last))}\\s*$`, 'i');
+    };
+    // Two-digit minutes first, so a format with no separator, as `HHmm`, still reads `930` as 9:30;
+    // then one digit, as leading zeros are optional.
+    let match = build().exec(text !== null && text !== void 0 ? text : '');
+    if (!match) {
+        patterns.mm = '(\\d{1,2})';
+        match = build().exec(text !== null && text !== void 0 ? text : '');
+    }
+    if (!match)
+        return null;
+    const found = match;
+    const read = {};
+    tokens.forEach((token, i) => (read[token] = found[i + 1]));
+    const monthIndex = (name, long) => {
+        if (name === undefined)
+            return undefined;
+        const lists = long ? [months, englishMonths] : [shortMonths, englishShortMonths];
+        for (const list of lists) {
+            const index = list.findIndex((candidate) => candidate.toLowerCase() === name.toLowerCase());
+            if (index >= 0)
+                return index + 1;
+        }
+        return undefined;
+    };
+    const readYear = read.YYYY ? Number(read.YYYY) : year;
+    const month = (_b = (_a = monthIndex(read.MMMM, true)) !== null && _a !== void 0 ? _a : monthIndex(read.MMM, false)) !== null && _b !== void 0 ? _b : Number((_c = read.MM) !== null && _c !== void 0 ? _c : read.M);
+    const day = Number((_d = read.DD) !== null && _d !== void 0 ? _d : read.D);
+    if (readYear === undefined || !month || !day)
+        return null;
+    const date = parseIsoDate(`${pad(readYear, 4)}-${pad(month)}-${pad(day)}`);
+    if (!date)
+        return null;
+    const hourText = (_g = (_f = (_e = read.HH) !== null && _e !== void 0 ? _e : read.H) !== null && _f !== void 0 ? _f : read.hh) !== null && _g !== void 0 ? _g : read.h;
+    if (hourText === undefined)
+        return { date, time: null };
+    let hours = Number(hourText);
+    const minutes = Number((_h = read.mm) !== null && _h !== void 0 ? _h : 0);
+    const period = (_k = ((_j = read.A) !== null && _j !== void 0 ? _j : read.a)) === null || _k === void 0 ? void 0 : _k.toLowerCase();
+    if (read.hh !== undefined || read.h !== undefined) {
+        if (hours < 1 || hours > 12)
+            return null;
+        const pm = period === words.pm.toLowerCase() || period === english.pm.toLowerCase();
+        hours = (hours % 12) + (pm ? 12 : 0);
+    }
+    return hours < 24 && minutes < 60 ? { date, time: joinTime(hours, minutes) } : null;
+}
+/** Reads one typed date in the format, falling back to ISO, which is always accepted. */
+export function parseFieldText(text, format = DEFAULT_FORMAT, locale = 'en-US') {
+    var _a;
+    return (_a = parseWith(text, format, locale)) !== null && _a !== void 0 ? _a : parseDateTime(text);
+}
+/**
+ * The locale's way of writing a month and day, as a format of tokens: `MMMM D` in English, `D MMMM`
+ * in French, `M月D日` in Japanese, or with `numeric`, `M/D` and `D/M`.
+ */
+export function monthDayFormat(locale = 'en-US', month = 'long') {
+    const parts = dateFormatter(locale, { month, day: 'numeric' }).formatToParts(new Date(Date.UTC(MONTH_DAY_YEAR, 11, 31)));
+    return parts
+        .map((part) => {
+        // Some locales write even the long month in digits, as Japanese `12月31日`.
+        if (part.type === 'month')
+            return /^\d+$/.test(part.value) ? 'M' : 'MMMM';
+        if (part.type === 'day')
+            return 'D';
+        // Bracketed, spaces included, only when it has letters a token could be read from, as
+        // Spanish `D[ de ]MMMM`.
+        return /[A-Za-z]/.test(part.value) ? `[${part.value}]` : part.value;
+    })
+        .join('');
+}
+/**
+ * Reads a typed month and day, into month-day mode's year: in the format, then as the locale writes
+ * it with a month name or in numbers, with the English order too, then as `--MM-DD` or a full ISO
+ * date, whose year is dropped.
+ */
+export function parseMonthDayText(text, format, locale = 'en-US') {
+    const formats = [format, monthDayFormat(locale), monthDayFormat(locale, 'numeric'), 'MMMM D', 'D MMMM', 'MMM D', 'D MMM'];
+    for (const candidate of formats) {
+        const read = parseWith(text, candidate, locale, MONTH_DAY_YEAR);
+        if (read)
+            return { date: inMonthDayYear(read.date), time: null };
+    }
+    const date = parseMonthDay(text);
+    return date ? { date, time: null } : null;
+}
+/**
+ * Parses a typed range: two dates (with times, optionally) joined by a dash or `to` with spaces
+ * around it, as `2026-09-13 – 2026-10-13`, or by `/` when the format doesn't use slashes. The
+ * split is tried at each separator until both halves read as dates, so a format that itself has a
+ * spaced dash, as `D - M - YYYY`, still works.
+ */
+export function parseRangeText(text, format = DEFAULT_FORMAT, locale = 'en-US') {
+    const trimmed = (text !== null && text !== void 0 ? text : '').trim();
+    const separators = new RegExp(`${escapeRegExp(RANGE_SEPARATOR)}|\\s+(?:–|—|-|to)\\s+${format.includes('/') ? '' : '|\\s*/\\s*'}`, 'gi');
+    let found;
+    while ((found = separators.exec(trimmed)) !== null) {
+        const start = parseFieldText(trimmed.slice(0, found.index), format, locale);
+        const end = parseFieldText(trimmed.slice(found.index + found[0].length), format, locale);
+        if (start && end)
+            return compareDateTime(start, end) <= 0 ? [start, end] : null;
+    }
+    return null;
+}
+export function compareDateTime(a, b) {
+    var _a, _b;
+    const byDay = a.date.getTime() - b.date.getTime();
+    if (byDay !== 0)
+        return byDay;
+    return ((_a = a.time) !== null && _a !== void 0 ? _a : '00:00').localeCompare((_b = b.time) !== null && _b !== void 0 ? _b : '00:00');
+}
+/** The value form: `YYYY-MM-DD`, or `YYYY-MM-DDTHH:mm` with a time. */
+export function toValueString(value) {
+    return value.time ? `${toIsoDate(value.date)}T${value.time}` : toIsoDate(value.date);
+}
+/** The field form in a format, or by default `YYYY-MM-DD`, with ` HH:mm` when it has a time. */
+export function toFieldText(value, format, locale = 'en-US') {
+    return formatWith(value, format !== null && format !== void 0 ? format : fieldFormat(DEFAULT_FORMAT, !!value.time), locale);
+}
+export const RANGE_SEPARATOR = ' – ';
+/** Hour and minute numbers from `HH:mm`. */
+export function splitTime(time) {
+    const [hours, minutes] = time.split(':').map(Number);
+    return [hours || 0, minutes || 0];
+}
+export function joinTime(hours, minutes) {
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+}
+/** Whether the locale writes times on a 12-hour clock, and its AM and PM words. */
+export function clockFor(locale) {
+    var _a, _b;
+    const format = new Intl.DateTimeFormat(locale, { hour: 'numeric', timeZone: 'UTC' });
+    const hour12 = !!format.resolvedOptions().hour12;
+    const period = (hour) => { var _a; return (_a = format.formatToParts(new Date(Date.UTC(2023, 0, 1, hour))).find((part) => part.type === 'dayPeriod')) === null || _a === void 0 ? void 0 : _a.value; };
+    return { hour12, am: (_a = period(1)) !== null && _a !== void 0 ? _a : 'AM', pm: (_b = period(13)) !== null && _b !== void 0 ? _b : 'PM' };
+}