@godxjp/ui 31.31.8 → 32.0.1

package/dist/app/app-provider.js

@@ -3,7 +3,15 @@ import { jsx } from "react/jsx-runtime";
 import * as React from "react";
 import { I18nProvider } from "react-aria-components";
 import { resolveDefaultDateFormat } from "./date-format-labels.js";
-import { getDateFnsLocale, getDayPickerLocale } from "./locales.js";
+import {
+  getDateFnsLocale,
+  getDayPickerLocale,
+  getRegisteredLocales,
+  resolvePageLocale,
+  resolveRegisteredLocale
+} from "./locales.js";
+import { AppPresetContext } from "./preset.js";
+import { warnUnknownLocale } from "../i18n/locale-tags.js";
 import { syncAppRequestHeaders } from "./request-headers.js";
 import { syncI18nLocale } from "../i18n/translate.js";
 const RTL_LANGUAGE_SUBTAGS = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur", "ps", "sd", "yi", "dv", "ckb"]);
@@ -29,12 +37,18 @@ import {
 import { resolveDefaultTimeFormat } from "./time-format-labels.js";
 import { resolveDefaultTimezone, resolveHydrationSafeTimezone } from "./timezones.js";
 import {
-  APP_LOCALES,
   APP_REQUEST_HEADER_DATE_FORMAT,
   APP_REQUEST_HEADER_LOCALE,
   APP_REQUEST_HEADER_TIME_FORMAT,
   APP_REQUEST_HEADER_TIMEZONE
 } from "./types.js";
+function resolveProviderLocale(defaultLocale, presetLocale) {
+  const fromProp = resolveRegisteredLocale(defaultLocale);
+  if (fromProp) return fromProp;
+  const resolved = resolvePageLocale() ?? resolveRegisteredLocale(presetLocale) ?? "en";
+  if (defaultLocale) warnUnknownLocale(defaultLocale, resolved);
+  return resolved;
+}
 const AppContext = React.createContext(null);
 function resolveInitialTimeFormat(stored, defaultTimeFormat, locale) {
   if (stored) return stored;
@@ -56,9 +70,10 @@ function buildRequestHeaders(locale, timezone, timeFormat, dateFormat) {
 }
 function AppProvider({
   children,
-  defaultLocale = "vi",
+  preset,
+  defaultLocale: defaultLocaleProp,
   fallbackLocale = "en",
-  defaultTimezone = "browser",
+  defaultTimezone: defaultTimezoneProp,
   systemTimezone,
   defaultTimeFormat = "locale",
   defaultDateFormat = "locale",
@@ -81,6 +96,12 @@ function AppProvider({
   onFontSizeChange,
   onScalingChange
 }) {
+  const presetLocale = preset?.defaultLocale;
+  const defaultLocale = React.useMemo(
+    () => resolveProviderLocale(defaultLocaleProp, presetLocale),
+    [defaultLocaleProp, presetLocale]
+  );
+  const defaultTimezone = defaultTimezoneProp ?? preset?.timeZone ?? "browser";
   const initialLocale = defaultLocale;
   const [locale, setLocaleState] = React.useState(initialLocale);
   const [timezone, setTimezoneState] = React.useState(
@@ -133,18 +154,22 @@ function AppProvider({
     const raw = readStoredPreferences(storageKey);
     const stored = pickPersistedAxes(raw, persistedAxes);
     if (!raw.dateFormatChosen && stored.dateFormat !== void 0) {
-      const derivable = APP_LOCALES.some((l) => resolveDefaultDateFormat(l) === stored.dateFormat);
+      const derivable = getRegisteredLocales().some(
+        (l) => resolveDefaultDateFormat(l) === stored.dateFormat
+      );
       if (derivable) delete stored.dateFormat;
     }
     if (!raw.timeFormatChosen && stored.timeFormat !== void 0) {
-      const derivable = APP_LOCALES.some((l) => resolveDefaultTimeFormat(l) === stored.timeFormat);
+      const derivable = getRegisteredLocales().some(
+        (l) => resolveDefaultTimeFormat(l) === stored.timeFormat
+      );
       if (derivable) delete stored.timeFormat;
     }
     formatChosenRef.current = {
       dateFormat: stored.dateFormat !== void 0,
       timeFormat: stored.timeFormat !== void 0
     };
-    const nextLocale = stored.locale ?? defaultLocale;
+    const nextLocale = resolveRegisteredLocale(stored.locale) ?? defaultLocale;
     const nextTimezone = stored.timezone ?? resolveDefaultTimezone(defaultTimezone, systemTimezone);
     const nextTimeFormat = resolveInitialTimeFormat(
       stored.timeFormat,
@@ -221,7 +246,12 @@ function AppProvider({
     return () => query.removeEventListener("change", reapply);
   }, [theme]);
   const setLocale = React.useCallback(
-    (next) => {
+    (requested) => {
+      const next = resolveRegisteredLocale(requested);
+      if (!next) {
+        warnUnknownLocale(requested, prefsRef.current.locale);
+        return;
+      }
       prefsRef.current = { ...prefsRef.current, locale: next };
       setLocaleState(next);
       if (!formatChosenRef.current.dateFormat && defaultDateFormat === "locale") {
@@ -326,18 +356,23 @@ function AppProvider({
     dateFormat,
     dateFnsLocale
   });
+  syncAppRequestHeaders(requestHeaders);
   if (!hasMountedRef.current) {
     disableLiveRelativeFormatting();
   }
-  React.useEffect(() => {
-    syncAppRequestHeaders(requestHeaders);
-  }, [requestHeaders]);
   React.useEffect(() => {
     if (typeof document !== "undefined") {
       document.documentElement.dir = localeDirection(locale);
       document.documentElement.lang = locale;
     }
   }, [locale]);
+  const presetName = preset?.name;
+  React.useEffect(() => {
+    if (typeof document === "undefined" || !presetName) return;
+    const root = document.documentElement;
+    root.setAttribute("data-preset", presetName);
+    return () => root.removeAttribute("data-preset");
+  }, [presetName]);
   React.useEffect(() => {
     hasMountedRef.current = true;
     enableLiveRelativeFormatting();
@@ -395,7 +430,7 @@ function AppProvider({
       setScaling
     ]
   );
-  return /* @__PURE__ */ jsx(I18nProvider, { locale, children: /* @__PURE__ */ jsx(AppContext.Provider, { value, children }) });
+  return /* @__PURE__ */ jsx(I18nProvider, { locale, children: /* @__PURE__ */ jsx(AppPresetContext.Provider, { value: preset, children: /* @__PURE__ */ jsx(AppContext.Provider, { value, children }) }) });
 }
 function useAppContext() {
   const ctx = React.useContext(AppContext);

package/dist/app/date-format-labels.d.ts

@@ -5,7 +5,9 @@ export declare const APP_DATE_FORMAT_OPTIONS: {
 }[];
 export declare function getDateFormatLabel(dateFormat: AppDateFormat, locale: AppLocale, fallbackLocale?: AppLocale): string;
 /**
- * Suggested default per locale — vi → dmy, ja → ymd, en → mdy.
+ * Suggested default per locale: the order the locale writes a numeric date in, from `Intl`
+ * (v32, gh#1219) — vi → dmy, ja → ymd, en → mdy, de / pt-BR / en-GB → dmy, ko → ymd. The three
+ * built-ins answer what the old hard-coded table answered.
  *
  * `ja` used to be `iso` (`yyyy-MM-dd`). Nothing recorded a reason for it, and it is not the form a
  * Japanese business document is written in: those use `YYYY/MM/DD` (or `YYYY年MM月DD日`). The cost

package/dist/app/date-format-labels.js

@@ -1,13 +1,11 @@
-import { APP_DATE_FORMATS } from "./date-formats.js";
+import { APP_DATE_FORMATS, getLocaleDateOrder } from "./date-formats.js";
 import { translate } from "../i18n/translate.js";
 const APP_DATE_FORMAT_OPTIONS = APP_DATE_FORMATS.map((value) => ({ value }));
 function getDateFormatLabel(dateFormat, locale, fallbackLocale = "en") {
   return translate(locale, fallbackLocale, `dateFormat.${dateFormat}`);
 }
 function resolveDefaultDateFormat(locale) {
-  if (locale === "en") return "mdy";
-  if (locale === "ja") return "ymd";
-  return "dmy";
+  return getLocaleDateOrder(locale);
 }
 export {
   APP_DATE_FORMAT_OPTIONS,

package/dist/app/date-formats.d.ts

@@ -15,8 +15,27 @@ export type AppDateFormat = "iso" | "ymd" | "dmy" | "mdy";
  */
 export declare const APP_DATE_FORMATS: readonly ["iso", "ymd", "dmy", "mdy"];
 export declare const APP_REQUEST_HEADER_DATE_FORMAT: "x-date-format";
+/**
+ * A date-fns pattern equivalent to `Intl.DateTimeFormat(locale, options)` — Gregorian calendar,
+ * Latin digits (what date-fns prints). `null` when the engine cannot format `locale`.
+ */
+export declare function intlDatePattern(locale: string, options: Intl.DateTimeFormatOptions): string | null;
+/**
+ * The locale's own numeric date pattern, from `Intl` (v32, gh#1219): `de` → `dd.MM.yyyy`, `en-GB`
+ * → `dd/MM/yyyy`, `ja` → `yyyy/MM/dd`, `vi` → `dd/MM/yyyy`, `en` → `MM/dd/yyyy`.
+ */
+export declare function getLocaleDatePattern(locale: string): string;
+/** The ORDER the locale writes a numeric date in, from `Intl` — `ymd`, `dmy` or `mdy`. */
+export declare function getLocaleDateOrder(locale: string): Exclude<AppDateFormat, "iso">;
+/**
+ * date-fns pattern for date-only display IN A LOCALE (v32, gh#1219): the order the locale writes
+ * natively is printed with the locale's own separators from `Intl` — `dmy` under `de` is
+ * `dd.MM.yyyy`. Any other order prints the fixed {@link getDatePattern}. For `vi`, `en` and `ja`
+ * the native pattern equals the fixed one, so they print exactly what they always did.
+ */
+export declare function getLocaleAwareDatePattern(dateFormat: AppDateFormat, locale: string): string;
 /** date-fns pattern for date-only display. */
 export declare function getDatePattern(dateFormat: AppDateFormat): string;
-/** date-fns pattern for date + time (table cells). */
-export declare function getDateTimePattern(timeFormat: AppTimeFormat, dateFormat: AppDateFormat): string;
+/** date-fns pattern for date + time (table cells); with a `locale`, its native separators. */
+export declare function getDateTimePattern(timeFormat: AppTimeFormat, dateFormat: AppDateFormat, locale?: string): string;
 export declare function isAppDateFormat(value: string | null | undefined): value is AppDateFormat;

package/dist/app/date-formats.js

@@ -1,4 +1,5 @@
 import { getTimePattern } from "./time-formats.js";
+import { dateTimeFormat } from "../lib/intl-cache.js";
 const APP_DATE_FORMATS = [
   "iso",
   "ymd",
@@ -6,6 +7,49 @@ const APP_DATE_FORMATS = [
   "mdy"
 ];
 const APP_REQUEST_HEADER_DATE_FORMAT = "x-date-format";
+function partToken(part, options) {
+  switch (part.type) {
+    case "year":
+      return "yyyy";
+    case "month":
+      return options.month === "long" ? "MMMM" : options.month === "short" ? "MMM" : options.month === "2-digit" ? "MM" : "M";
+    case "day":
+      return options.day === "2-digit" ? "dd" : "d";
+    case "weekday":
+      return options.weekday === "long" ? "EEEE" : "EEE";
+    default:
+      return /[A-Za-z']/.test(part.value) ? `'${part.value.replaceAll("'", "''")}'` : part.value;
+  }
+}
+function intlParts(locale, options) {
+  const resolved = { ...options, calendar: "gregory", numberingSystem: "latn", timeZone: "UTC" };
+  try {
+    return dateTimeFormat(locale, resolved).formatToParts(new Date(Date.UTC(2026, 9, 8)));
+  } catch {
+    return null;
+  }
+}
+function intlDatePattern(locale, options) {
+  const parts = intlParts(locale, options);
+  return parts ? parts.map((part) => partToken(part, options)).join("") : null;
+}
+const NUMERIC_DATE = {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit"
+};
+function getLocaleDatePattern(locale) {
+  return intlDatePattern(locale, NUMERIC_DATE) ?? getDatePattern("iso");
+}
+function getLocaleDateOrder(locale) {
+  const first = intlParts(locale, NUMERIC_DATE)?.find((part) => part.type !== "literal")?.type;
+  if (first === "year") return "ymd";
+  if (first === "month") return "mdy";
+  return "dmy";
+}
+function getLocaleAwareDatePattern(dateFormat, locale) {
+  return dateFormat !== "iso" && dateFormat === getLocaleDateOrder(locale) ? getLocaleDatePattern(locale) : getDatePattern(dateFormat);
+}
 function getDatePattern(dateFormat) {
   switch (dateFormat) {
     case "ymd":
@@ -19,8 +63,9 @@ function getDatePattern(dateFormat) {
       return "yyyy-MM-dd";
   }
 }
-function getDateTimePattern(timeFormat, dateFormat) {
-  return `${getDatePattern(dateFormat)} ${getTimePattern(timeFormat)}`;
+function getDateTimePattern(timeFormat, dateFormat, locale) {
+  const date = locale ? getLocaleAwareDatePattern(dateFormat, locale) : getDatePattern(dateFormat);
+  return `${date} ${getTimePattern(timeFormat)}`;
 }
 function isAppDateFormat(value) {
   return APP_DATE_FORMATS.includes(value);
@@ -30,5 +75,9 @@ export {
   APP_REQUEST_HEADER_DATE_FORMAT,
   getDatePattern,
   getDateTimePattern,
+  getLocaleAwareDatePattern,
+  getLocaleDateOrder,
+  getLocaleDatePattern,
+  intlDatePattern,
   isAppDateFormat
 };

package/dist/app/index.d.ts

@@ -9,7 +9,9 @@ export * from "./storage.js";
 export * from "./theme-axes.js";
 export * from "./tenant-theme.js";
 export * from "./request-headers.js";
-export { AppProvider, useAppContext, useOptionalAppContext, useAppLocale, useAppTimezone, useAppTimeFormat, useAppDateFormat, } from "./app-provider.js";
+export { runWithAppSettings, type AppSettings } from "./settings-scope.js";
+export { AppPresetContext, useAppPreset, type AppPreset } from "./preset.js";
+export { type AppProviderProps, AppProvider, useAppContext, useOptionalAppContext, useAppLocale, useAppTimezone, useAppTimeFormat, useAppDateFormat, } from "./app-provider.js";
 export { useFormatting, useDateTime } from "./use-formatting.js";
 export { syncDatetimeContext, getDatetimeContext, formatDate, isFormatDateValue, detectFormatDateKind, formatAppDate, formatAppDateTime, formatAppTime, formatAppDateLong, formatAppRelative, formatCalendarDate, formatTimeOfDay, parseDateInput, normalizeHhmm, isValidHhmm, type FormatDateOptions, type FormatDateKind, type FormatDatetimeOptions, } from "../lib/datetime/index.js";
 export { useTranslation, usePickerLocales } from "../i18n/use-translation.js";

package/dist/app/index.js

@@ -9,6 +9,8 @@ export * from "./storage.js";
 export * from "./theme-axes.js";
 export * from "./tenant-theme.js";
 export * from "./request-headers.js";
+import { runWithAppSettings } from "./settings-scope.js";
+import { AppPresetContext, useAppPreset } from "./preset.js";
 import {
   AppProvider,
   useAppContext,
@@ -40,6 +42,7 @@ import { useTranslation, usePickerLocales } from "../i18n/use-translation.js";
 import { OverlayPortalProvider } from "../lib/overlay-portal.js";
 import { ThemeScope } from "../lib/overlay-portal.js";
 export {
+  AppPresetContext,
   AppProvider,
   OverlayPortalProvider,
   ThemeScope,
@@ -57,10 +60,12 @@ export {
   isValidHhmm,
   normalizeHhmm,
   parseDateInput,
+  runWithAppSettings,
   syncDatetimeContext,
   useAppContext,
   useAppDateFormat,
   useAppLocale,
+  useAppPreset,
   useAppTimeFormat,
   useAppTimezone,
   useDateTime,

package/dist/app/locales.d.ts

@@ -1,12 +1,67 @@
 import type { Locale } from "date-fns";
 import { vi as viDayPicker } from "react-day-picker/locale";
 import type { AppLocale } from "./types.js";
+export { getRegisteredLocales, resolveRegisteredLocale, resolveDefaultLocale, resolvePageLocale, } from "../i18n/locale-tags.js";
+/** A react-day-picker locale: a date-fns `Locale` plus optional `labels`. */
+export type DayPickerLocale = typeof viDayPicker;
 export type AppLocaleConfig = {
     code: AppLocale;
     dateFns: Locale;
-    dayPicker: typeof viDayPicker;
+    dayPicker: DayPickerLocale;
 };
-export declare const APP_LOCALE_CONFIG: Record<AppLocale, AppLocaleConfig>;
+/**
+ * What `registerLocale` takes. Only `code` is required: without `dateFns` the date adapter is built
+ * from `Intl` (month/weekday names, long date patterns, week start), and without `dayPicker` the
+ * calendar uses that same adapter.
+ */
+export type RegisterLocaleInput = {
+    /** Any BCP-47 tag — `de`, `pt-BR`, `en-GB`, `ar`. Canonicalised (`pt-br` → `pt-BR`). */
+    code: string;
+    /** This locale's strings. For a locale the library does not ship, its own namespaces too. */
+    messages?: Record<string, unknown>;
+    /** A date-fns locale (`import { de } from "date-fns/locale"`). */
+    dateFns?: Locale;
+    /** A react-day-picker locale (`import { de } from "react-day-picker/locale"`). */
+    dayPicker?: DayPickerLocale;
+};
+/**
+ * First day of the week for `code`, as date-fns counts it (0 = Sunday … 6 = Saturday).
+ *
+ * From `Intl.Locale#getWeekInfo` (or the older `.weekInfo` getter) where the engine has it; else
+ * the pack's own `weekStartsOn`; else the region's CLDR first day, Monday (ISO 8601) by default.
+ */
+export declare function getLocaleWeekStart(code: string, pack?: Pick<Locale, "options">): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Every registered locale's date adapters. `vi`, `en` and `ja` are pre-registered with the packs
+ * they always had; `registerLocale` adds the rest. Exported for compatibility — read it through
+ * `getDateFnsLocale` / `getDayPickerLocale`, which also handle an unregistered tag.
+ */
+export declare const APP_LOCALE_CONFIG: Record<string, AppLocaleConfig>;
+/** The three locales the library ships packs for. */
+export declare const BUILT_IN_LOCALES: readonly ["vi", "en", "ja"];
+/**
+ * REGISTER A LOCALE — any BCP-47 tag (v32, gh#1219).
+ *
+ * The locale set used to be a closed union of three, so a German or Brazilian app could not get
+ * German dates or a Monday/Sunday week from this package at all. Register once at startup, before
+ * the first render:
+ *
+ * ```ts
+ * import { de } from "date-fns/locale";
+ * import { de as deDayPicker } from "react-day-picker/locale";
+ * registerLocale({ code: "de", messages: deMessages, dateFns: de, dayPicker: deDayPicker });
+ * ```
+ *
+ * Registering an already-registered tag updates it (messages merge; adapters given replace).
+ * Returns the canonical tag.
+ */
+export declare function registerLocale(input: RegisterLocaleInput): AppLocale;
+/** Whether `value` is a REGISTERED locale tag (exactly, after canonicalisation). */
 export declare function isAppLocale(value: string | null | undefined): value is AppLocale;
+/**
+ * The registered locale that serves `tag` (`de-AT` → `de`), or — with one development warning —
+ * the default locale (`<html lang>` if registered, else `en`).
+ */
+export declare function normalizeAppLocale(tag: string | null | undefined): AppLocale;
 export declare function getDateFnsLocale(locale: AppLocale): Locale;
-export declare function getDayPickerLocale(locale: AppLocale): import("react-day-picker").DayPickerLocale;
+export declare function getDayPickerLocale(locale: AppLocale): DayPickerLocale;

package/dist/app/locales.js

@@ -5,23 +5,149 @@ import {
   ja as jaDayPicker,
   vi as viDayPicker
 } from "react-day-picker/locale";
-const APP_LOCALE_CONFIG = {
-  vi: { code: "vi", dateFns: vi, dayPicker: viDayPicker },
-  en: { code: "en", dateFns: enUS, dayPicker: enUSDayPicker },
-  ja: { code: "ja", dateFns: ja, dayPicker: jaDayPicker }
+import { registerLocaleMessages } from "../i18n/translate.js";
+import {
+  canonicalLocaleTag,
+  getRegisteredLocales,
+  isBuiltInLocale,
+  markLocaleRegistered,
+  resolveDefaultLocale,
+  resolveRegisteredLocale,
+  warnUnknownLocale
+} from "../i18n/locale-tags.js";
+import { dateTimeFormat } from "../lib/intl-cache.js";
+import { intlDatePattern } from "./date-formats.js";
+import {
+  getRegisteredLocales as getRegisteredLocales2,
+  resolveRegisteredLocale as resolveRegisteredLocale2,
+  resolveDefaultLocale as resolveDefaultLocale2,
+  resolvePageLocale
+} from "../i18n/locale-tags.js";
+const SUNDAY_FIRST = "AG AS BD BR BS BT BW BZ CA CN CO DM DO ET GT GU HK HN ID IL IN JM JP KE KH KR LA MH MM MO MT MX MZ NI NP PA PE PH PK PR PT PY SA SG SV TH TT TW UM US VE VI WS YE ZA ZW";
+const SATURDAY_FIRST = "AE AF BH DJ DZ EG IQ IR JO KW LY OM QA SD SY";
+function intlWeekInfo(code) {
+  try {
+    const locale = new Intl.Locale(code);
+    return locale.getWeekInfo?.() ?? locale.weekInfo;
+  } catch {
+    return void 0;
+  }
+}
+function getLocaleWeekStart(code, pack) {
+  const info = intlWeekInfo(code);
+  if (info) return info.firstDay % 7;
+  const fromPack = pack?.options?.weekStartsOn;
+  if (fromPack !== void 0) return fromPack;
+  let region = "";
+  try {
+    region = new Intl.Locale(code).maximize().region ?? "";
+  } catch {
+  }
+  if (region && SUNDAY_FIRST.split(" ").includes(region)) return 0;
+  if (region && SATURDAY_FIRST.split(" ").includes(region)) return 6;
+  return 1;
+}
+function withIntlWeekStart(code, pack) {
+  const weekStartsOn = getLocaleWeekStart(code, pack);
+  if (pack.options?.weekStartsOn === weekStartsOn) return pack;
+  return { ...pack, options: { ...pack.options, weekStartsOn } };
+}
+const INTL_WIDTH = {
+  narrow: "narrow",
+  short: "short",
+  abbreviated: "short",
+  wide: "long",
+  any: "long"
+};
+const LONG_DATE = {
+  full: { weekday: "long", year: "numeric", month: "long", day: "numeric" },
+  long: { year: "numeric", month: "long", day: "numeric" },
+  medium: { year: "numeric", month: "short", day: "numeric" },
+  short: { year: "numeric", month: "2-digit", day: "2-digit" },
+  any: { year: "numeric", month: "long", day: "numeric" }
 };
+function intlDateFnsLocale(code) {
+  const name = (options, date) => dateTimeFormat(code, { ...options, timeZone: "UTC" }).format(date);
+  const width = (options) => INTL_WIDTH[options?.width ?? "wide"];
+  const info = intlWeekInfo(code);
+  return {
+    ...enUS,
+    code,
+    localize: {
+      ...enUS.localize,
+      // 2017-01-01 was a Sunday, so day `n` of that week is weekday `n` in date-fns' numbering.
+      month: (n, options) => name({ month: width(options) }, new Date(Date.UTC(2017, n, 1))),
+      day: (n, options) => name({ weekday: width(options) }, new Date(Date.UTC(2017, 0, 1 + n)))
+    },
+    formatLong: {
+      ...enUS.formatLong,
+      date: ({ width: w = "full" } = {}) => intlDatePattern(code, LONG_DATE[w]) ?? enUS.formatLong.date({ width: w })
+    },
+    options: {
+      weekStartsOn: getLocaleWeekStart(code),
+      firstWeekContainsDate: info?.minimalDays === 4 ? 4 : 1
+    }
+  };
+}
+const APP_LOCALE_CONFIG = {};
+function storeConfig(code, dateFns, dayPicker) {
+  const config = {
+    code,
+    dateFns: withIntlWeekStart(code, dateFns),
+    dayPicker: withIntlWeekStart(code, dayPicker)
+  };
+  APP_LOCALE_CONFIG[code] = config;
+  return config;
+}
+storeConfig("vi", vi, viDayPicker);
+storeConfig("en", enUS, enUSDayPicker);
+storeConfig("ja", ja, jaDayPicker);
+const BUILT_IN_LOCALES = ["vi", "en", "ja"];
+function registerLocale(input) {
+  const code = canonicalLocaleTag(input.code);
+  const existing = APP_LOCALE_CONFIG[code];
+  const dateFns = input.dateFns ?? existing?.dateFns ?? intlDateFnsLocale(code);
+  const dayPicker = input.dayPicker ?? existing?.dayPicker ?? dateFns;
+  storeConfig(code, dateFns, dayPicker);
+  markLocaleRegistered(code);
+  registerLocaleMessages(code, input.messages ?? {}, !isBuiltInLocale(code));
+  return code;
+}
 function isAppLocale(value) {
-  return value === "vi" || value === "en" || value === "ja";
+  if (!value) return false;
+  try {
+    return getRegisteredLocales().includes(canonicalLocaleTag(value));
+  } catch {
+    return false;
+  }
+}
+function normalizeAppLocale(tag) {
+  const resolved = resolveRegisteredLocale(tag);
+  if (resolved) return resolved;
+  const fallback = resolveDefaultLocale();
+  if (tag) warnUnknownLocale(tag, fallback);
+  return fallback;
+}
+function configFor(locale) {
+  return APP_LOCALE_CONFIG[locale] ?? APP_LOCALE_CONFIG[normalizeAppLocale(locale)] ?? APP_LOCALE_CONFIG.en;
 }
 function getDateFnsLocale(locale) {
-  return APP_LOCALE_CONFIG[locale].dateFns;
+  return configFor(locale).dateFns;
 }
 function getDayPickerLocale(locale) {
-  return APP_LOCALE_CONFIG[locale].dayPicker;
+  return configFor(locale).dayPicker;
 }
 export {
   APP_LOCALE_CONFIG,
+  BUILT_IN_LOCALES,
   getDateFnsLocale,
   getDayPickerLocale,
-  isAppLocale
+  getLocaleWeekStart,
+  getRegisteredLocales2 as getRegisteredLocales,
+  isAppLocale,
+  normalizeAppLocale,
+  registerLocale,
+  resolveDefaultLocale2 as resolveDefaultLocale,
+  resolvePageLocale,
+  resolveRegisteredLocale2 as resolveRegisteredLocale
 };

package/dist/app/preset.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+/**
+ * An app PRESET (v32, gh#1220): the product-specific defaults a host opts into, so the library's
+ * own defaults can stay neutral. Core never imports a preset; a host passes one to
+ * `<AppProvider preset={…}>`, and the GoDX look ships as `godxPreset` from
+ * `@godxjp/ui/themes/godx` together with `@godxjp/ui/themes/godx.css`.
+ *
+ * Every field is optional and only fills what the host left unset: an explicit `AppProvider` prop
+ * always wins over the preset.
+ */
+export interface AppPreset {
+    /** Stable name, written to `<html data-preset>` so a preset stylesheet can scope itself. */
+    name: string;
+    /** BCP-47 tag used when the host gives no `defaultLocale` (and `<html lang>` has none registered). */
+    defaultLocale?: string;
+    /** IANA zone used when the host gives no `timeZone`. */
+    timeZone?: string;
+    /** The brand mark `AuthIdentity` (and other identity surfaces) render when given no `brand`. */
+    brandMark?: React.ReactNode;
+    /** Label for the email brand mark when the caller passes none. */
+    emailBrandLabel?: string;
+}
+export declare const AppPresetContext: React.Context<AppPreset | undefined>;
+/** The active preset, or `undefined` when the host chose none (the neutral default). */
+export declare function useAppPreset(): AppPreset | undefined;

package/dist/app/preset.js

@@ -0,0 +1,10 @@
+"use client";
+import * as React from "react";
+const AppPresetContext = React.createContext(void 0);
+function useAppPreset() {
+  return React.useContext(AppPresetContext);
+}
+export {
+  AppPresetContext,
+  useAppPreset
+};

package/dist/app/request-headers.d.ts

@@ -1,7 +1,7 @@
 import type { AppRequestHeaders } from "./types.js";
-/** Sync locale/timezone into module state for HTTP clients (via `getAppRequestHeaders`). */
+/** Sync locale/timezone into the CURRENT scope for HTTP clients (via `getAppRequestHeaders`). */
 export declare function syncAppRequestHeaders(headers: Partial<AppRequestHeaders>): void;
-/** Read current app preference headers — wire to API client `setAppHeaderProvider`. */
+/** Read the current scope's preference headers — wire to API client `setAppHeaderProvider`. */
 export declare function getAppRequestHeaders(): AppRequestHeaders;
-/** Reset to defaults — for tests only. */
+/** Reset the current scope's headers to defaults — for tests only. */
 export declare function resetAppRequestHeaders(): void;

package/dist/app/request-headers.js

@@ -4,21 +4,30 @@ import {
   APP_REQUEST_HEADER_TIME_FORMAT,
   APP_REQUEST_HEADER_TIMEZONE
 } from "./types.js";
-const DEFAULT_HEADERS = {
-  [APP_REQUEST_HEADER_LOCALE]: "vi",
-  [APP_REQUEST_HEADER_TIMEZONE]: "Asia/Ho_Chi_Minh",
-  [APP_REQUEST_HEADER_TIME_FORMAT]: "24h",
-  [APP_REQUEST_HEADER_DATE_FORMAT]: "dmy"
-};
-let currentHeaders = { ...DEFAULT_HEADERS };
+import { getAppSettingsState } from "./settings-scope.js";
+import { resolveDefaultDateFormat } from "./date-format-labels.js";
+import { resolveDefaultTimeFormat } from "./time-format-labels.js";
+import { getBrowserTimezone } from "./timezones.js";
+import { resolveDefaultLocale } from "../i18n/locale-tags.js";
+function defaultHeaders() {
+  const { i18n, datetime } = getAppSettingsState();
+  const locale = i18n?.locale ?? datetime?.locale ?? resolveDefaultLocale();
+  return {
+    [APP_REQUEST_HEADER_LOCALE]: locale,
+    [APP_REQUEST_HEADER_TIMEZONE]: datetime?.timezone ?? (typeof window === "undefined" ? "UTC" : getBrowserTimezone()),
+    [APP_REQUEST_HEADER_TIME_FORMAT]: datetime?.timeFormat ?? resolveDefaultTimeFormat(locale),
+    [APP_REQUEST_HEADER_DATE_FORMAT]: datetime?.dateFormat ?? resolveDefaultDateFormat(locale)
+  };
+}
 function syncAppRequestHeaders(headers) {
-  currentHeaders = { ...currentHeaders, ...headers };
+  const state = getAppSettingsState();
+  state.headers = { ...state.headers, ...headers };
 }
 function getAppRequestHeaders() {
-  return { ...currentHeaders };
+  return { ...defaultHeaders(), ...getAppSettingsState().headers };
 }
 function resetAppRequestHeaders() {
-  currentHeaders = { ...DEFAULT_HEADERS };
+  getAppSettingsState().headers = void 0;
 }
 export {
   getAppRequestHeaders,