@fusion.dev/helix-core 0.159.0 → 0.160.0

package/dist/utils/calendar/calendar.js

@@ -50,7 +50,7 @@ export const calendarLocale = (locale, calendar = '') => {
     let tag = tagged.get(key);
     if (tag === undefined) {
         const own = new Intl.DateTimeFormat(locale || undefined).resolvedOptions();
-        const wanted = DRAWN.includes(calendar)
+        const wanted = DRAWN.includes(calendar) || MONTH_CALENDARS.includes(calendar)
             ? calendar
             : DRAWN.includes(own.calendar)
                 ? ''
@@ -69,39 +69,64 @@ export const addMonths = (date, months) => {
     return utcDate(target.getUTCFullYear(), target.getUTCMonth(), Math.min(date.getUTCDate(), last));
 };
 export const MONTH_CALENDARS = [
+    'chinese',
     'coptic',
+    'dangi',
+    'ethioaa',
     'ethiopic',
     'hebrew',
     'indian',
+    'islamic',
     'islamic-civil',
+    'islamic-rgsa',
+    'islamic-tbla',
     'islamic-umalqura',
     'persian',
 ];
+const gregorianDays = (year, month) => utcDate(year, month, 0).getUTCDate();
 const GREGORIAN = {
     add: (date, months) => addMonths(date, months),
+    addYears: (date, years) => addMonths(date, years * 12),
     day: (date) => date.getUTCDate(),
+    days: gregorianDays,
+    from: (year, month, day) => {
+        const kept = Math.min(12, Math.max(1, month));
+        return utcDate(year, kept - 1, Math.min(Math.max(1, day), gregorianDays(year, kept)));
+    },
     key: (date) => monthOf(date),
+    months: () => 12,
+    parts: (date) => ({
+        day: date.getUTCDate(),
+        month: date.getUTCMonth() + 1,
+        year: date.getUTCFullYear(),
+    }),
     same: (left, right) => sameMonth(left, right),
     start: (date) => utcDate(date.getUTCFullYear(), date.getUTCMonth(), 1),
 };
 const intlMonths = (calendar) => {
-    const format = new Intl.DateTimeFormat(`en-u-ca-${calendar}-nu-latn`, {
-        day: 'numeric',
-        timeZone: 'UTC',
-    });
-    const days = new Map();
-    const day = (date) => {
-        const at = date.getTime();
-        let found = days.get(at);
+    const tag = `en-u-ca-${calendar}-nu-latn`;
+    const format = new Intl.DateTimeFormat(tag, { day: 'numeric', timeZone: 'UTC', year: 'numeric' });
+    const named = new Intl.DateTimeFormat(tag, { month: 'long', timeZone: 'UTC' });
+    const read = new Map();
+    const at = (date) => {
+        const time = date.getTime();
+        let found = read.get(time);
         if (found === undefined) {
-            found = Number(format.formatToParts(date).find((part) => part.type === 'day')?.value);
-            if (days.size > 4000) {
-                days.clear();
+            const parts = format.formatToParts(date);
+            const part = (type) => Number(parts.find((one) => one.type === type)?.value);
+            const year = part('relatedYear');
+            found = [Number.isNaN(year) ? part('year') : year, part('day')];
+            if (!(found[1] >= 1)) {
+                found[1] = at(addDays(date, -1))[1] + 1;
+            }
+            if (read.size > 4000) {
+                read.clear();
             }
-            days.set(at, found);
+            read.set(time, found);
         }
         return found;
     };
+    const day = (date) => at(date)[1];
     const start = (date) => addDays(date, 1 - day(date));
     const length = (first) => {
         for (const count of [29, 30, 31, 28, 32]) {
@@ -116,16 +141,78 @@ const intlMonths = (calendar) => {
         }
         return 30;
     };
+    const anchor = start(utcDate(2000, 0, 1));
+    const anchorYear = at(anchor)[0];
+    const span = 36_525 / (at(utcDate(2100, 0, 1))[0] - anchorYear);
+    const years = new Map();
+    const firsts = (year) => {
+        let found = years.get(year);
+        if (found !== undefined) {
+            return found;
+        }
+        let probe = addDays(anchor, Math.round((year - anchorYear + 0.5) * span));
+        for (let step = 0; step < 60 && at(probe)[0] !== year; step += 1) {
+            probe = addDays(probe, (year - at(probe)[0]) * 20);
+        }
+        let first = start(probe);
+        while (at(addDays(first, -1))[0] === year) {
+            const earlier = start(addDays(first, -1));
+            if (earlier.getTime() >= first.getTime()) {
+                break;
+            }
+            first = earlier;
+        }
+        found = [];
+        while (at(first)[0] === year && found.length < 14) {
+            found.push(first);
+            first = addDays(first, length(first));
+        }
+        if (years.size > 400) {
+            years.clear();
+        }
+        years.set(year, found);
+        return found;
+    };
+    const months = (year) => Math.max(1, firsts(year).length);
+    const firstOf = (year, month) => firsts(year)[Math.min(months(year), Math.max(1, month)) - 1] ?? anchor;
+    const days = (year, month) => length(firstOf(year, month));
+    const from = (year, month, wanted) => {
+        const first = firstOf(year, month);
+        return addDays(first, Math.min(Math.max(1, wanted), length(first)) - 1);
+    };
+    const parts = (date) => {
+        const [year, dayOf] = at(date);
+        const all = firsts(year);
+        let month = all.length;
+        while (month > 1 && all[month - 1].getTime() > date.getTime()) {
+            month -= 1;
+        }
+        return { day: dayOf, month, year };
+    };
     return {
-        add: (date, months) => {
+        add: (date, count) => {
             let first = start(date);
-            for (let step = 0; step < Math.abs(months); step += 1) {
-                first = months > 0 ? addDays(first, length(first)) : start(addDays(first, -1));
+            for (let step = 0; step < Math.abs(count); step += 1) {
+                first = count > 0 ? addDays(first, length(first)) : start(addDays(first, -1));
             }
             return addDays(first, Math.min(day(date), length(first)) - 1);
         },
+        addYears: (date, count) => {
+            const { day: dayOf, month, year } = parts(date);
+            const name = named.format(firstOf(year, month));
+            const names = firsts(year + count).map((first) => named.format(first));
+            let index = names.indexOf(name);
+            if (index < 0) {
+                index = names.findLastIndex((one) => one.startsWith(name) || name.startsWith(one));
+            }
+            return from(year + count, index < 0 ? month : index + 1, dayOf);
+        },
         day,
+        days,
+        from,
         key: (date) => fromDate(start(date)),
+        months,
+        parts,
         same: (left, right) => start(left).getTime() === start(right).getTime(),
         start,
     };
@@ -181,27 +268,29 @@ export const periodMove = (key, at, along) => {
             return null;
     }
 };
-export const monthOut = (first, min, max) => {
-    const month = monthOf(first);
-    return (min !== '' && month < min.slice(0, 7)) || (max !== '' && month > max.slice(0, 7));
-};
-export const yearOut = (year, min, max) => (min !== '' && year < Number(min.slice(0, 4))) || (max !== '' && year > Number(max.slice(0, 4)));
-export const periodCells = ({ max, min, page, shown, today, view }) => {
+export const monthOut = (first, min, max, system = GREGORIAN) => (min !== '' && fromDate(addDays(system.add(first, 1), -1)) < min) ||
+    (max !== '' && fromDate(first) > max);
+export const yearOut = (year, min, max, system = GREGORIAN) => (min !== '' && fromDate(addDays(system.from(year + 1, 1, 1), -1)) < min) ||
+    (max !== '' && fromDate(system.from(year, 1, 1)) > max);
+export const periodCells = ({ max, min, page, shown, system = GREGORIAN, today, view, }) => {
     const years = view === 'year';
-    const start = years ? yearPageOf(page) : page;
-    return Array.from({ length: 12 }, (_, index) => {
-        const at = years ? start + index : index;
-        const first = utcDate(years ? at : start, years ? 0 : index, 1);
+    const now = asDate(today);
+    const held = system.parts(shown).year;
+    const count = years ? YEARS_SHOWN : system.months(page);
+    const startYear = years ? yearPageOf(page) : page;
+    return Array.from({ length: count }, (_, index) => {
+        const at = years ? startYear + index : index;
+        const first = years ? system.from(at, 1, 1) : system.from(page, index + 1, 1);
         return {
             at,
-            chosen: years ? at === shown.getUTCFullYear() : monthOf(first) === monthOf(shown),
-            current: years ? String(at) === today.slice(0, 4) : monthOf(first) === today.slice(0, 7),
+            chosen: years ? at === held : system.same(first, shown),
+            current: now !== null && (years ? system.parts(now).year === at : system.same(first, now)),
             first,
-            out: years ? yearOut(at, min, max) : monthOut(first, min, max),
+            out: years ? yearOut(at, min, max, system) : monthOut(first, min, max, system),
         };
     });
 };
-export const periodKey = (view, stop, year, key, along) => {
+export const periodKey = (view, stop, year, key, along, months = () => 12) => {
     const index = view === 'year' ? stop - yearPageOf(stop) : stop;
     const delta = periodMove(key, index, along);
     if (delta === null) {
@@ -210,6 +299,19 @@ export const periodKey = (view, stop, year, key, along) => {
     if (view === 'year') {
         return { focus: stop + delta, pageYear: stop + delta };
     }
-    const months = year * 12 + stop + delta;
-    return { focus: ((months % 12) + 12) % 12, pageYear: Math.floor(months / 12) };
+    if (key === 'PageUp' || key === 'PageDown') {
+        const to = year + Math.sign(delta);
+        return { focus: Math.min(stop, months(to) - 1), pageYear: to };
+    }
+    let at = stop + delta;
+    let on = year;
+    while (at < 0) {
+        on -= 1;
+        at += months(on);
+    }
+    while (at >= months(on)) {
+        at -= months(on);
+        on += 1;
+    }
+    return { focus: at, pageYear: on };
 };

package/dist/utils/date-segments/date-segments.d.ts

@@ -1,9 +1,11 @@
+import type { MonthSystem } from '../calendar/calendar.js';
 /** One part of a date or a time a reader sets on its own. */
 export type SegmentKind = 'day' | 'dayPeriod' | 'hour' | 'minute' | 'month' | 'second' | 'year';
 /** What a segmented field holds: a date, or a time of day. */
 export type SegmentedKind = 'date' | 'time';
 /**
- * The parts set so far, each a number: the month 1 to 12, the hour 0 to 23
+ * The parts set so far, each a number: the month 1 to 12, or to 13 in a
+ * calendar whose year can have 13, the hour 0 to 23
  * whatever clock it is shown on, and the half of the day 0 for before noon and
  * 1 for after. A part not yet set is absent.
  */
@@ -37,7 +39,7 @@ export declare const isTwelveHourLayout: (layout: readonly SegmentSlot[]) => boo
  * The lowest and highest a segment can be, as it is shown: the hour on a twelve
  * hour clock is 1 to 12, and a day goes as high as its month allows.
  */
-export declare const segmentRange: (kind: SegmentKind, segments: Segments, twelve: boolean) => {
+export declare const segmentRange: (kind: SegmentKind, segments: Segments, twelve: boolean, system?: MonthSystem) => {
     max: number;
     min: number;
 };
@@ -45,16 +47,16 @@ export declare const segmentRange: (kind: SegmentKind, segments: Segments, twelv
 export declare const shownValue: (kind: SegmentKind, segments: Segments, twelve: boolean) => number | undefined;
 /**
  * Sets a segment from the number shown for it, which on a twelve hour clock
- * is put back together with the half of the day, and keeps the day inside its
- * month.
+ * is put back together with the half of the day, and keeps the month inside
+ * its year and the day inside its month.
  */
-export declare const setSegment: (segments: Segments, kind: SegmentKind, shown: number | undefined, twelve: boolean) => Segments;
+export declare const setSegment: (segments: Segments, kind: SegmentKind, shown: number | undefined, twelve: boolean, system?: MonthSystem) => Segments;
 /**
  * A segment moved by a key's step, wrapping at its ends as a dial does, and
  * starting from where a reader would look for it when it is empty: the lowest
  * going up, the highest going down, and this year for a year.
  */
-export declare const stepSegment: (segments: Segments, kind: SegmentKind, by: number, twelve: boolean, thisYear?: number) => Segments;
+export declare const stepSegment: (segments: Segments, kind: SegmentKind, by: number, twelve: boolean, thisYear?: number, system?: MonthSystem) => Segments;
 /**
  * A digit typed into a segment, given what was typed into it already.
  *
@@ -64,7 +66,7 @@ export declare const stepSegment: (segments: Segments, kind: SegmentKind, by: nu
  * on, which is React Aria's typing: `3` in a month is March and moves to the
  * day, `1` waits for a second digit.
  */
-export declare const typeDigit: (segments: Segments, kind: SegmentKind, typed: string, digit: string, twelve: boolean) => {
+export declare const typeDigit: (segments: Segments, kind: SegmentKind, typed: string, digit: string, twelve: boolean, system?: MonthSystem) => {
     advance: boolean;
     segments: Segments;
     typed: string;
@@ -77,6 +79,8 @@ export interface SegmentKeyState {
     locale: string;
     /** The field's parts. */
     segments: Segments;
+    /** The calendar a date's parts are counted in, Gregorian where none is given. */
+    system?: MonthSystem | undefined;
     /** Whether the field is on a twelve hour clock. */
     twelve: boolean;
     /** The digits typed into the segment so far. */
@@ -92,13 +96,16 @@ export interface SegmentKeyState {
  * the half whose word starts with it. `advance` says the segment is full and
  * focus moves on.
  */
-export declare const segmentKey: (key: string, { kind, locale, segments, twelve, typed }: SegmentKeyState) => {
+export declare const segmentKey: (key: string, { kind, locale, segments, system, twelve, typed }: SegmentKeyState) => {
     advance: boolean;
     segments: Segments;
     typed: string;
 } | null;
-/** The segments a value names, or none where it names nothing whole. */
-export declare const segmentsOf: (kind: SegmentedKind, value: string) => Segments;
+/**
+ * The segments a value names, or none where it names nothing whole: a date's
+ * year, month, and day as `system` counts them, Gregorian where none is given.
+ */
+export declare const segmentsOf: (kind: SegmentedKind, value: string, system?: MonthSystem) => Segments;
 /**
  * The value the segments add up to, or the empty string while any segment the
  * layout shows is unset.
@@ -106,9 +113,9 @@ export declare const segmentsOf: (kind: SegmentedKind, value: string) => Segment
  * A date that does not exist, the thirtieth of February, cannot be reached,
  * the day being kept inside its month as it is set.
  */
-export declare const segmentsValue: (kind: SegmentedKind, segments: Segments, layout: readonly SegmentSlot[]) => string;
+export declare const segmentsValue: (kind: SegmentedKind, segments: Segments, layout: readonly SegmentSlot[], system?: MonthSystem) => string;
 /** Whether a reader has set some segments and not all of them. */
-export declare const isPartial: (kind: SegmentedKind, segments: Segments, layout: readonly SegmentSlot[]) => boolean;
+export declare const isPartial: (kind: SegmentedKind, segments: Segments, layout: readonly SegmentSlot[], system?: MonthSystem) => boolean;
 /**
  * What a segment shows: its number, padded the way the locale pads it, the
  * locale's own word for the half of the day, or dashes while it is unset.
@@ -117,8 +124,33 @@ export declare const segmentText: (kind: SegmentKind, segments: Segments, twelve
 /**
  * What a screen reader hears for a segment's value: what it shows, and for a
  * month its name as well, "8 – August", which is React Aria's reading. A
- * month heard as a number alone leaves a reader counting.
+ * month heard as a number alone leaves a reader counting. In a calendar with
+ * months of its own, the name is that calendar's month in the year the
+ * segments hold, or in this year: "7 – Mehr".
  */
-export declare const segmentValueText: (kind: SegmentKind, segments: Segments, twelve: boolean, locale: string) => string;
+export declare const segmentValueText: (kind: SegmentKind, segments: Segments, twelve: boolean, locale: string, system?: MonthSystem) => string;
 /** What a locale calls a segment, such as "month" or "AM/PM", from `Intl`. */
 export declare const segmentName: (kind: SegmentKind, locale: string) => string;
+/**
+ * The date a reader wrote in the order and the digits of `locale`, as
+ * `YYYY-MM-DD`, or empty where it is no date.
+ *
+ * `8/4/2026` in `en-US` and `4.8.2026` in `de-DE` are August 4, 2026, and a
+ * month written as a word, `Aug 4, 2026` or `4. August 2026`, is read by its
+ * name in the Gregorian calendar. A first number of four digits is a year,
+ * as ISO writes it. A year of two digits is the nearest year within eighty
+ * years back and twenty forward. `Intl` formats and does not parse, so this
+ * reads the numbers back in the order `segmentLayout` finds the locale
+ * writing them. Under `system`, the numbers are that calendar's year, month,
+ * and day.
+ */
+export declare const readWrittenDate: (text: string, locale: string, system?: MonthSystem) => string;
+/**
+ * The time a reader wrote, as `HH:mm`, or `HH:mm:ss` with `seconds`, or empty
+ * where it is no time.
+ *
+ * Reads `2:30 PM`, `2.30pm`, `14h30`, and `3 pm` alike, with the half of the
+ * day in the locale's own words or as `am` and `pm`, and digits in the
+ * locale's own script.
+ */
+export declare const readWrittenTime: (text: string, locale: string, seconds?: boolean) => string;