@astryxdesign/core 0.7.9-canary.2ea8f68 → 0.7.9-canary.4e7823a

package/dist/i18n/InternationalizationContext.d.ts

@@ -1,8 +1,14 @@
 import { getResolve } from './resolve.js';
 import type { Locale, MessagesByLocale, Overrides } from './types.js';
+import type { CalendarSystem } from '../utils/calendarSystem.js';
 export interface InternationalizationContextValue {
     locale: Locale;
     direction: 'ltr' | 'rtl';
+    /**
+     * The provider's resolved calendar system. A context without it means
+     * Gregorian dates.
+     */
+    calendar?: CalendarSystem;
     messages: MessagesByLocale;
     overrides?: Overrides;
     translate: ReturnType<typeof getResolve>;

package/dist/i18n/InternationalizationContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InternationalizationContext.d.ts","sourceRoot":"","sources":["../../src/i18n/InternationalizationContext.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAEjE,MAAM,WAAW,gCAAgC;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;IACzB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;CAC1C;AAED;;;GAGG;AACH,eAAO,MAAM,2BAA2B,2DAMpC,CAAC"}
+{"version":3,"file":"InternationalizationContext.d.ts","sourceRoot":"","sources":["../../src/i18n/InternationalizationContext.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AACjE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAE5D,MAAM,WAAW,gCAAgC;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;CAC1C;AAED;;;GAGG;AACH,eAAO,MAAM,2BAA2B,2DAMpC,CAAC"}

package/dist/i18n/InternationalizationProvider.d.ts

@@ -1,8 +1,8 @@
 /**
  * @file InternationalizationProvider.tsx
- * @input React, InternationalizationContext, i18n types
+ * @input React, InternationalizationContext, i18n types, calendar resolution
  * @output Exports InternationalizationProvider component and props type
- * @position Provider component for astryx i18n locale + messages
+ * @position Provider component for astryx i18n locale, messages, and calendar
  *
  * Wraps a subtree with a locale and (optional) additional message catalogs +
  * overrides. Astryx components inside the subtree resolve their strings via
@@ -15,6 +15,7 @@
  * - /packages/core/src/i18n/InternationalizationProvider.doc.mjs
  */
 import { type ReactNode } from 'react';
+import type { CalendarSystem } from '../utils/calendarSystem.js';
 import type { Locale, Overrides, ProviderMessagesByLocale } from './types.js';
 export interface InternationalizationProviderProps {
     /**
@@ -63,13 +64,30 @@ export interface InternationalizationProviderProps {
      * in sync (e.g. `dir={getLocaleDirection(locale)}` on both).
      */
     dir?: 'ltr' | 'rtl';
+    /**
+     * The calendar system of this subtree, such as `'persian'` or `'hebrew'`. The
+     * provider resolves it and exposes it on the context as `calendar`. Astryx
+     * date components show Gregorian dates. Values stay Gregorian ISO dates. When
+     * omitted, the calendar is Gregorian: a locale never selects it, neither by
+     * its default calendar nor by a `-u-ca-` keyword. Calendars other than
+     * `gregory`, `iso8601`, `buddhist`, `roc`, and `japanese` need `Temporal`.
+     * The context keeps the requested calendar; where `Temporal` is missing, a
+     * date component that resolves it shows Gregorian dates and warns once in
+     * development.
+     *
+     * @example
+     * ```
+     * <InternationalizationProvider locale="fa-IR" calendar="persian">
+     * ```
+     */
+    calendar?: CalendarSystem;
     children: ReactNode;
 }
 /**
  * Provides locale + additional messages + overrides to all astryx
  * components in the subtree.
  */
-export declare function InternationalizationProvider({ locale, messages, overrides, dir, children, }: InternationalizationProviderProps): import("react").JSX.Element;
+export declare function InternationalizationProvider({ locale, messages, overrides, dir, calendar: calendarProp, children, }: InternationalizationProviderProps): import("react").JSX.Element;
 export declare namespace InternationalizationProvider {
     var displayName: string;
 }

package/dist/i18n/InternationalizationProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InternationalizationProvider.d.ts","sourceRoot":"","sources":["../../src/i18n/InternationalizationProvider.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAU,KAAK,SAAS,EAAC,MAAM,OAAO,CAAC;AAG9C,OAAO,KAAK,EACV,MAAM,EAEN,SAAS,EACT,wBAAwB,EACzB,MAAM,SAAS,CAAC;AA0BjB,MAAM,WAAW,iCAAiC;IAChD;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IACpC;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACpB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,EAC3C,MAAM,EACN,QAAQ,EACR,SAAS,EACT,GAAG,EACH,QAAQ,GACT,EAAE,iCAAiC,+BAiBnC;yBAvBe,4BAA4B"}
+{"version":3,"file":"InternationalizationProvider.d.ts","sourceRoot":"","sources":["../../src/i18n/InternationalizationProvider.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAU,KAAK,SAAS,EAAC,MAAM,OAAO,CAAC;AAI9C,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EACV,MAAM,EAEN,SAAS,EACT,wBAAwB,EACzB,MAAM,SAAS,CAAC;AA4BjB,MAAM,WAAW,iCAAiC;IAChD;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IACpC;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACpB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,EAC3C,MAAM,EACN,QAAQ,EACR,SAAS,EACT,GAAG,EACH,QAAQ,EAAE,YAAY,EACtB,QAAQ,GACT,EAAE,iCAAiC,+BAyBnC;yBAhCe,4BAA4B"}

package/dist/i18n/InternationalizationProvider.js

@@ -4,9 +4,9 @@
 
 /**
  * @file InternationalizationProvider.tsx
- * @input React, InternationalizationContext, i18n types
+ * @input React, InternationalizationContext, i18n types, calendar resolution
  * @output Exports InternationalizationProvider component and props type
- * @position Provider component for astryx i18n locale + messages
+ * @position Provider component for astryx i18n locale, messages, and calendar
  *
  * Wraps a subtree with a locale and (optional) additional message catalogs +
  * overrides. Astryx components inside the subtree resolve their strings via
@@ -21,8 +21,10 @@
 import { useMemo } from 'react';
 import { InternationalizationContext } from "./InternationalizationContext.js";
 import { getLocaleDirection } from "./getLocaleDirection.js";
+import { resolveCalendarSystem } from "./useCalendarSystem.js";
 import { getResolve } from "./resolve.js";
 import { jsx as _jsx } from "react/jsx-runtime";
+const PROVIDER_NAME = 'InternationalizationProvider';
 function normalizeMessages(messages) {
   const hasRuntimeCatalog = Object.values(messages).some(catalog => Object.values(catalog).some(entry => typeof entry === 'string'));
   if (!hasRuntimeCatalog) {
@@ -41,19 +43,22 @@ export function InternationalizationProvider({
   messages,
   overrides,
   dir,
+  calendar: calendarProp,
   children
 }) {
   const direction = dir ?? getLocaleDirection(locale);
+  const calendar = useMemo(() => calendarProp != null ? resolveCalendarSystem(calendarProp, PROVIDER_NAME) : 'gregory', [calendarProp]);
   const value = useMemo(() => {
     const providedMessages = messages ?? {};
     return {
       locale,
       direction,
+      calendar,
       messages: normalizeMessages(providedMessages),
       overrides,
       translate: getResolve(locale, providedMessages, overrides)
     };
-  }, [locale, direction, messages, overrides]);
+  }, [locale, direction, calendar, messages, overrides]);
   return /*#__PURE__*/_jsx(InternationalizationContext, {
     value: value,
     children: children

package/dist/i18n/index.d.ts

@@ -13,6 +13,7 @@
  *   - useDirection                — hook returning the ambient text direction
  *   - getLocaleDirection          — server-safe locale → direction helper
  *   - Translator                  — interface for consumer-injected runtimes
+ *   - CalendarSystem              — the calendars date components can show
  *
  * `useTranslator` and `InternationalizationContext` are the public paths
  * that resolve any Astryx key, so they register the whole English catalog.
@@ -36,6 +37,7 @@ export { useLocale } from './useLocale.js';
 export { useCollator } from './useCollator.js';
 export { useDirection } from './useDirection.js';
 export { getLocaleDirection } from './getLocaleDirection.js';
+export type { CalendarSystem } from '../utils/calendarSystem.js';
 export type { Translator } from './translator.js';
 export type { Locale, Catalog, MessageEntry, RuntimeCatalog, MessagesByLocale, ProviderMessagesByLocale, Overrides, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAC,4BAA4B,EAAC,MAAM,gCAAgC,CAAC;AAC5E,YAAY,EAAC,iCAAiC,EAAC,MAAM,gCAAgC,CAAC;AACtF,OAAO,EAAC,2BAA2B,EAAC,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAC,gCAAgC,EAAC,MAAM,+BAA+B,CAAC;AACpF,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC9C,YAAY,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,YAAY,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAC7C,YAAY,EACV,MAAM,EACN,OAAO,EACP,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,GACV,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAC,4BAA4B,EAAC,MAAM,gCAAgC,CAAC;AAC5E,YAAY,EAAC,iCAAiC,EAAC,MAAM,gCAAgC,CAAC;AACtF,OAAO,EAAC,2BAA2B,EAAC,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAC,gCAAgC,EAAC,MAAM,+BAA+B,CAAC;AACpF,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC9C,YAAY,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,YAAY,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,YAAY,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAC7C,YAAY,EACV,MAAM,EACN,OAAO,EACP,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,GACV,MAAM,SAAS,CAAC"}

package/dist/i18n/index.js

@@ -15,6 +15,7 @@
  *   - useDirection                — hook returning the ambient text direction
  *   - getLocaleDirection          — server-safe locale → direction helper
  *   - Translator                  — interface for consumer-injected runtimes
+ *   - CalendarSystem              — the calendars date components can show
  *
  * `useTranslator` and `InternationalizationContext` are the public paths
  * that resolve any Astryx key, so they register the whole English catalog.

package/dist/i18n/useCalendarSystem.d.ts

@@ -0,0 +1,13 @@
+import { type CalendarSystem } from '../utils/calendarSystem.js';
+/**
+ * Normalizes a calendar identifier. An identifier outside `CalendarSystem`
+ * resolves to `gregory` and warns once in development.
+ */
+export declare function resolveCalendarSystem(id: string, source: string): CalendarSystem;
+/**
+ * The calendar a date component shows: its own `calendar`, else the
+ * provider's resolved calendar, else `gregory`. It resolves during render, so
+ * the server and the browser agree when both have `Temporal` or both lack it.
+ */
+export declare function useCalendarSystem(calendar: CalendarSystem | undefined, source: string): CalendarSystem;
+//# sourceMappingURL=useCalendarSystem.d.ts.map

package/dist/i18n/useCalendarSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCalendarSystem.d.ts","sourceRoot":"","sources":["../../src/i18n/useCalendarSystem.ts"],"names":[],"mappings":"AAeA,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,yBAAyB,CAAC;AAGjC;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,GACb,cAAc,CAUhB;AAyBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,MAAM,EAAE,MAAM,GACb,cAAc,CAOhB"}

package/dist/i18n/useCalendarSystem.js

@@ -0,0 +1,52 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file useCalendarSystem.ts
+ * @input InternationalizationContext, an optional component `calendar`
+ * @output The calendar system a date component shows, and the helper that
+ *   normalizes a calendar identifier
+ * @position Internal i18n hook; read by InternationalizationProvider and date
+ *   components. Not re-exported from the i18n barrel.
+ */
+import { use } from 'react';
+import { InternationalizationContext } from "./InternationalizationContext.js";
+import { isCalendarSystem, isCalendarSystemAvailable } from "../utils/calendarSystem.js";
+import { warnOnce } from "../utils/devWarning.js";
+
+/**
+ * Normalizes a calendar identifier. An identifier outside `CalendarSystem`
+ * resolves to `gregory` and warns once in development.
+ */
+export function resolveCalendarSystem(id, source) {
+  if (isCalendarSystem(id)) {
+    return id;
+  }
+  warnOnce(`calendar-unsupported:${id}`, source, `The calendar "${id}" is not supported; showing Gregorian dates.`);
+  return 'gregory';
+}
+
+/**
+ * A calendar this runtime can show, else `gregory`. Calendars outside the
+ * Gregorian-aligned set need a `Temporal` that supports them. The fallback
+ * warns once for each calendar, on the server and in the browser.
+ */
+function availableCalendarOrGregorian(calendar, source) {
+  if (isCalendarSystemAvailable(calendar)) {
+    return calendar;
+  }
+  warnOnce(`calendar-unavailable:${calendar}`, source, `The "${calendar}" calendar needs a Temporal that supports it, and this ` + 'runtime has none; showing Gregorian dates. Load a Temporal polyfill ' + "with every calendar, such as 'temporal-polyfill/full/global', on the " + 'server and in the browser.');
+  return 'gregory';
+}
+
+/**
+ * The calendar a date component shows: its own `calendar`, else the
+ * provider's resolved calendar, else `gregory`. It resolves during render, so
+ * the server and the browser agree when both have `Temporal` or both lack it.
+ */
+export function useCalendarSystem(calendar, source) {
+  const context = use(InternationalizationContext);
+  const requested = calendar != null ? resolveCalendarSystem(calendar, source) : context.calendar ?? 'gregory';
+  return availableCalendarOrGregorian(requested, source);
+}

package/dist/utils/calendarSystem.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @file calendarSystem.ts
+ * @input A calendar identifier and Gregorian PlainDates
+ * @output Calendar months located by their Gregorian days, month and year
+ *   steps, dates from calendar fields, availability of each calendar, and
+ *   calendar labels and digits
+ * @position Shared date utility; read by the i18n calendar resolution. Values
+ *   stay Gregorian PlainDates. Temporal owns the arithmetic of every calendar
+ *   whose months are not Gregorian.
+ */
+import type { Locale } from '../i18n/types.js';
+import type { PlainDate } from './dateTypes.js';
+/**
+ * A calendar system that date components can show: the calendars that
+ * ECMA-402 and Temporal require. Values stay Gregorian ISO dates in every
+ * calendar.
+ */
+export type CalendarSystem = 'gregory' | 'iso8601' | 'buddhist' | 'roc' | 'japanese' | 'persian' | 'indian' | 'hebrew' | 'chinese' | 'dangi' | 'coptic' | 'ethiopic' | 'ethioaa' | 'islamic-civil' | 'islamic-tbla' | 'islamic-umalqura';
+export declare const CALENDAR_SYSTEMS: ReadonlyArray<CalendarSystem>;
+/** Whether the calendar's months and days are the Gregorian ones. */
+export declare function isGregorianAligned(calendar: CalendarSystem): boolean;
+export declare function isCalendarSystem(value: string): value is CalendarSystem;
+/**
+ * Whether this runtime can show the calendar. Gregorian-aligned calendars
+ * always can. The others need a `Temporal` that knows the calendar: a
+ * polyfill build without non-ISO calendars throws for them.
+ */
+export declare function isCalendarSystemAvailable(calendar: CalendarSystem): boolean;
+/** A month of a calendar, located by its first and last Gregorian days. */
+export interface CalendarMonth {
+    readonly start: PlainDate;
+    readonly end: PlainDate;
+    readonly length: number;
+}
+/** The day of the calendar month that a Gregorian date falls on. */
+export declare function calendarDayOfMonth(calendar: CalendarSystem, pd: PlainDate): number;
+/** The calendar month that contains a Gregorian date. */
+export declare function calendarMonthOf(calendar: CalendarSystem, pd: PlainDate): CalendarMonth;
+/** The calendar month `n` months after `month`, or before it when negative. */
+export declare function calendarAddMonths(calendar: CalendarSystem, month: CalendarMonth, n: number): CalendarMonth;
+/**
+ * Moves a date by `n` calendar months. It keeps the day of the month and
+ * clamps it to the length of the target month.
+ */
+export declare function calendarShiftMonths(calendar: CalendarSystem, pd: PlainDate, n: number): PlainDate;
+/**
+ * Moves a date by `n` calendar years, to the same month of the target year.
+ * It clamps the day of the month. A leap month that the target year does not
+ * have becomes its common counterpart, because Temporal keeps the month code
+ * and constrains it.
+ */
+export declare function calendarShiftYears(calendar: CalendarSystem, pd: PlainDate, n: number): PlainDate;
+/** Whether a Gregorian date falls inside a calendar month. */
+export declare function isInCalendarMonth(pd: PlainDate, month: CalendarMonth): boolean;
+/**
+ * The stand-alone month and year label of a calendar month, such as
+ * "Aban 1405 AP". It formats a day in the middle of the month: in the
+ * Japanese calendar an era can start inside a month, and most days of that
+ * month then belong to the era of its middle day.
+ */
+export declare function formatCalendarMonthLabel(calendar: CalendarSystem, month: CalendarMonth, locale: Locale): string;
+/**
+ * Formats a Gregorian date in the calendar, such as "Friday, Aban 8, 1405 AP".
+ * The label always names the month and day that the grid shows. Intl and the
+ * runtime's Temporal can disagree on where a month of the Chinese or Dangi
+ * calendar starts; the label then takes its month and year from the middle of
+ * the Temporal month, its day from Temporal, and its weekday from the date.
+ */
+export declare function formatCalendarDate(calendar: CalendarSystem, pd: PlainDate, options: Intl.DateTimeFormatOptions, locale: Locale): string;
+/**
+ * The fields of a date written in a calendar. A field gives either `year` or
+ * `era` with `eraYear`, and either `monthCode` (such as `M05L` for a leap
+ * month) or `month`, the month's position in its year.
+ */
+export interface CalendarDateFields {
+    readonly year?: number;
+    readonly era?: string;
+    readonly eraYear?: number;
+    readonly monthCode?: string;
+    readonly month?: number;
+    readonly day: number;
+}
+/**
+ * The Gregorian date for fields written in a calendar that needs Temporal,
+ * or null when the calendar does not have that date. Temporal validates the
+ * fields and never adjusts them: 30 Esfand in a common Persian year is null.
+ */
+export declare function calendarDateFromFields(calendar: CalendarSystem, fields: CalendarDateFields): PlainDate | null;
+/** The number of months in the calendar year that contains a date. */
+export declare function calendarMonthsInYear(calendar: CalendarSystem, pd: PlainDate): number;
+//# sourceMappingURL=calendarSystem.d.ts.map

package/dist/utils/calendarSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendarSystem.d.ts","sourceRoot":"","sources":["../../src/utils/calendarSystem.ts"],"names":[],"mappings":"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"}

package/dist/utils/calendarSystem.js

@@ -0,0 +1,290 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file calendarSystem.ts
+ * @input A calendar identifier and Gregorian PlainDates
+ * @output Calendar months located by their Gregorian days, month and year
+ *   steps, dates from calendar fields, availability of each calendar, and
+ *   calendar labels and digits
+ * @position Shared date utility; read by the i18n calendar resolution. Values
+ *   stay Gregorian PlainDates. Temporal owns the arithmetic of every calendar
+ *   whose months are not Gregorian.
+ */
+
+import { dateTimeFormatFor, plainDateAddDays, plainDateAddMonths, plainDateFormat, plainDateFormatDayNumber, plainDateFormatStandaloneMonthYear, plainDateFormatToParts, plainDateIsInRange, getDaysInMonth } from "./plainDate.js";
+
+/**
+ * A calendar system that date components can show: the calendars that
+ * ECMA-402 and Temporal require. Values stay Gregorian ISO dates in every
+ * calendar.
+ */
+
+// A record, so the compiler checks that it lists every calendar exactly once.
+const KNOWN_CALENDARS = {
+  gregory: true,
+  iso8601: true,
+  buddhist: true,
+  roc: true,
+  japanese: true,
+  persian: true,
+  indian: true,
+  hebrew: true,
+  chinese: true,
+  dangi: true,
+  coptic: true,
+  ethiopic: true,
+  ethioaa: true,
+  'islamic-civil': true,
+  'islamic-tbla': true,
+  'islamic-umalqura': true
+};
+export const CALENDAR_SYSTEMS = Object.keys(KNOWN_CALENDARS);
+const GREGORIAN_ALIGNED = new Set(['gregory', 'iso8601', 'buddhist', 'roc', 'japanese']);
+
+/** Whether the calendar's months and days are the Gregorian ones. */
+export function isGregorianAligned(calendar) {
+  return GREGORIAN_ALIGNED.has(calendar);
+}
+export function isCalendarSystem(value) {
+  return Object.hasOwn(KNOWN_CALENDARS, value);
+}
+
+// The published types must not need the `esnext.temporal` library.
+// This module declares only the Temporal members it reads.
+
+function getTemporal() {
+  const temporal = globalThis.Temporal;
+  return typeof temporal?.PlainDate === 'function' ? temporal : undefined;
+}
+
+// The key is the Temporal object, so a polyfill that loads later gets its
+// own probe.
+const supportedCalendars = new WeakMap();
+
+/**
+ * Whether this runtime can show the calendar. Gregorian-aligned calendars
+ * always can. The others need a `Temporal` that knows the calendar: a
+ * polyfill build without non-ISO calendars throws for them.
+ */
+export function isCalendarSystemAvailable(calendar) {
+  if (isGregorianAligned(calendar)) {
+    return true;
+  }
+  const temporal = getTemporal();
+  if (temporal == null) {
+    return false;
+  }
+  let known = supportedCalendars.get(temporal);
+  if (known == null) {
+    known = new Map();
+    supportedCalendars.set(temporal, known);
+  }
+  let isSupported = known.get(calendar);
+  if (isSupported == null) {
+    try {
+      new temporal.PlainDate(2000, 1, 1, calendar);
+      isSupported = true;
+    } catch {
+      isSupported = false;
+    }
+    known.set(calendar, isSupported);
+  }
+  return isSupported;
+}
+function inCalendar(calendar, pd) {
+  const temporal = getTemporal();
+  if (temporal == null) {
+    throw new Error(`The "${calendar}" calendar needs Temporal.`);
+  }
+  return new temporal.PlainDate(pd.year, pd.month, pd.day, calendar);
+}
+function toGregorian(date) {
+  const iso = date.withCalendar('iso8601');
+  return {
+    year: iso.year,
+    month: iso.month,
+    day: iso.day
+  };
+}
+
+/** A month of a calendar, located by its first and last Gregorian days. */
+
+function makeMonth(start, length) {
+  return {
+    start,
+    end: plainDateAddDays(start, length - 1),
+    length
+  };
+}
+function gregorianMonth(year, month) {
+  return makeMonth({
+    year,
+    month,
+    day: 1
+  }, getDaysInMonth(year, month));
+}
+function temporalMonth(firstDay) {
+  return makeMonth(toGregorian(firstDay), firstDay.daysInMonth);
+}
+
+/** The day of the calendar month that a Gregorian date falls on. */
+export function calendarDayOfMonth(calendar, pd) {
+  return isGregorianAligned(calendar) ? pd.day : inCalendar(calendar, pd).day;
+}
+
+/** The calendar month that contains a Gregorian date. */
+export function calendarMonthOf(calendar, pd) {
+  if (isGregorianAligned(calendar)) {
+    return gregorianMonth(pd.year, pd.month);
+  }
+  return temporalMonth(inCalendar(calendar, pd).with({
+    day: 1
+  }));
+}
+
+/** The calendar month `n` months after `month`, or before it when negative. */
+export function calendarAddMonths(calendar, month, n) {
+  if (n === 0) {
+    return month;
+  }
+  if (isGregorianAligned(calendar)) {
+    const {
+      year,
+      month: monthOfYear
+    } = plainDateAddMonths(month.start, n);
+    return gregorianMonth(year, monthOfYear);
+  }
+  return temporalMonth(inCalendar(calendar, month.start).add({
+    months: n
+  }));
+}
+
+/**
+ * Moves a date by `n` calendar months. It keeps the day of the month and
+ * clamps it to the length of the target month.
+ */
+export function calendarShiftMonths(calendar, pd, n) {
+  if (isGregorianAligned(calendar)) {
+    return plainDateAddMonths(pd, n);
+  }
+  return toGregorian(inCalendar(calendar, pd).add({
+    months: n
+  }));
+}
+
+/**
+ * Moves a date by `n` calendar years, to the same month of the target year.
+ * It clamps the day of the month. A leap month that the target year does not
+ * have becomes its common counterpart, because Temporal keeps the month code
+ * and constrains it.
+ */
+export function calendarShiftYears(calendar, pd, n) {
+  if (isGregorianAligned(calendar)) {
+    return plainDateAddMonths(pd, n * 12);
+  }
+  return toGregorian(inCalendar(calendar, pd).add({
+    years: n
+  }));
+}
+
+/** Whether a Gregorian date falls inside a calendar month. */
+export function isInCalendarMonth(pd, month) {
+  return plainDateIsInRange(pd, [month.start, month.end]);
+}
+
+/**
+ * The stand-alone month and year label of a calendar month, such as
+ * "Aban 1405 AP". It formats a day in the middle of the month: in the
+ * Japanese calendar an era can start inside a month, and most days of that
+ * month then belong to the era of its middle day.
+ */
+export function formatCalendarMonthLabel(calendar, month, locale) {
+  return plainDateFormatStandaloneMonthYear(plainDateAddDays(month.start, Math.floor(month.length / 2)), locale, labelCalendar(calendar));
+}
+
+// Intl has no month names for `iso8601`. Labels use `gregory`, which has the
+// same months and days.
+function labelCalendar(calendar) {
+  return calendar === 'iso8601' ? 'gregory' : calendar;
+}
+function formatToParts(calendar, pd, options, locale) {
+  return plainDateFormatToParts(pd, {
+    ...options,
+    calendar
+  }, locale);
+}
+const MONTH_PART_TYPES = new Set(['era', 'year', 'relatedYear', 'yearName', 'month']);
+function monthPartsKey(parts) {
+  return parts.filter(part => MONTH_PART_TYPES.has(part.type)).map(part => part.value).join('|');
+}
+
+/**
+ * Formats a Gregorian date in the calendar, such as "Friday, Aban 8, 1405 AP".
+ * The label always names the month and day that the grid shows. Intl and the
+ * runtime's Temporal can disagree on where a month of the Chinese or Dangi
+ * calendar starts; the label then takes its month and year from the middle of
+ * the Temporal month, its day from Temporal, and its weekday from the date.
+ */
+export function formatCalendarDate(calendar, pd, options, locale) {
+  if (isGregorianAligned(calendar)) {
+    return plainDateFormat(pd, {
+      ...options,
+      calendar: labelCalendar(calendar)
+    }, locale);
+  }
+  const date = inCalendar(calendar, pd);
+  const parts = formatToParts(calendar, pd, options, locale);
+  const middle = plainDateAddDays(pd, Math.floor(date.daysInMonth / 2) - (date.day - 1));
+  const middleParts = formatToParts(calendar, middle, options, locale);
+  const intlDay = formatToParts(calendar, pd, {
+    day: 'numeric'
+  }, 'en-u-nu-latn').find(part => part.type === 'day')?.value;
+  if (Number(intlDay) === date.day && monthPartsKey(parts) === monthPartsKey(middleParts)) {
+    return parts.map(part => part.value).join('');
+  }
+  const {
+    numberingSystem
+  } = dateTimeFormatFor(locale, {
+    ...options,
+    calendar,
+    timeZone: 'UTC'
+  }).resolvedOptions();
+  const weekday = parts.find(part => part.type === 'weekday')?.value;
+  return middleParts.map(part => part.type === 'day' ? plainDateFormatDayNumber(date.day, locale, numberingSystem) : part.type === 'weekday' && weekday != null ? weekday : part.value).join('');
+}
+
+/**
+ * The fields of a date written in a calendar. A field gives either `year` or
+ * `era` with `eraYear`, and either `monthCode` (such as `M05L` for a leap
+ * month) or `month`, the month's position in its year.
+ */
+
+/**
+ * The Gregorian date for fields written in a calendar that needs Temporal,
+ * or null when the calendar does not have that date. Temporal validates the
+ * fields and never adjusts them: 30 Esfand in a common Persian year is null.
+ */
+export function calendarDateFromFields(calendar, fields) {
+  const temporal = getTemporal();
+  if (temporal == null) {
+    throw new Error(`The "${calendar}" calendar needs Temporal.`);
+  }
+  try {
+    return toGregorian(temporal.PlainDate.from({
+      ...fields,
+      calendar
+    }, {
+      overflow: 'reject'
+    }));
+  } catch (error) {
+    if (error instanceof RangeError || error instanceof TypeError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/** The number of months in the calendar year that contains a date. */
+export function calendarMonthsInYear(calendar, pd) {
+  return isGregorianAligned(calendar) ? 12 : inCalendar(calendar, pd).monthsInYear;
+}

package/dist/utils/plainDate.d.ts

@@ -80,7 +80,7 @@ export declare const DATE_FORMAT_MONTH_YEAR: Intl.DateTimeFormatOptions;
  * stand-alone forms (`component:Calendar` FR1). Internal: not re-exported from
  * `utils/index.ts`.
  */
-export declare function plainDateFormatStandaloneMonthYear(pd: PlainDate, locale: Locale): string;
+export declare function plainDateFormatStandaloneMonthYear(pd: PlainDate, locale: Locale, calendar?: Intl.DateTimeFormatOptions['calendar']): string;
 export declare const DATE_FORMAT_WEEKDAY_ONLY: Intl.DateTimeFormatOptions;
 /**
  * The platform's weekday names for a locale, Sunday first, in `Intl`'s
@@ -104,6 +104,11 @@ export declare const DATE_FORMAT_SHORT_WITH_YEAR: Intl.DateTimeFormatOptions;
  * serialization, or any Astryx component's calendar semantics.
  */
 export declare function plainDateFormat(pd: PlainDate, options: Intl.DateTimeFormatOptions, locale?: Locale): string;
+/**
+ * The parts of `plainDateFormat`'s output, from the same formatter and date.
+ * Internal: not re-exported from `utils/index.ts`.
+ */
+export declare function plainDateFormatToParts(pd: PlainDate, options: Intl.DateTimeFormatOptions, locale: Locale): Intl.DateTimeFormatPart[];
 /** @internal plainDateFormat's formatter cache; not part of the public API. */
 export declare function dateTimeFormatFor(locale: Locale, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
 /**
@@ -120,12 +125,13 @@ export declare function dateTimeFormatFor(locale: Locale, options: Intl.DateTime
 export declare function plainDateWeekFieldName(locale?: Locale): string;
 /**
  * A day of the month or a week number in the locale's own digits: `15` in
- * English, `۱۵` in Persian, `١٥` in Egyptian Arabic. Only the digits follow the
- * locale. The number stays the Gregorian day or ISO week that it names, so no
- * other calendar applies, and no grouping separator or unit word is added.
+ * English, `۱۵` in Persian, `١٥` in Egyptian Arabic. A `numberingSystem`
+ * replaces the locale's digits. Only the digits change. The number stays the
+ * value that it is given, so no calendar applies, and no grouping separator or
+ * unit word is added.
  * Internal: not re-exported from `utils/index.ts`.
  */
-export declare function plainDateFormatDayNumber(value: number, locale: Locale): string;
+export declare function plainDateFormatDayNumber(value: number, locale: Locale, numberingSystem?: string): string;
 /**
  * The date-only members of Timestamp's `format` vocabulary that a
  * calendar-date field (no time-of-day) can render. Both Timestamp and