@godxjp/ui 13.9.3 → 13.11.0

package/dist/app/app-provider.d.ts

@@ -0,0 +1,30 @@
+import { type AppDateFormat, type AppLocale, type AppTimeFormat, type AppTimezone } from "./types";
+import type { AppContextValue, AppProviderProp } from "../props/components/app.prop";
+export type { AppProviderProp, AppContextValue } from "../props/components/app.prop";
+export declare function AppProvider({ children, defaultLocale, fallbackLocale, defaultTimezone, systemTimezone, defaultTimeFormat, defaultDateFormat, timezoneOptions, storageKey, persist, onLocaleChange, onTimezoneChange, onTimeFormatChange, onDateFormatChange, }: AppProviderProp): import("react/jsx-runtime").JSX.Element;
+export declare function useAppContext(): AppContextValue;
+/** Returns null outside AppProvider — used by pickers for optional context. */
+export declare function useOptionalAppContext(): AppContextValue | null;
+/** Shorthand for `{ locale, setLocale }`. */
+export declare function useAppLocale(): {
+    locale: AppLocale;
+    fallbackLocale: AppLocale;
+    setLocale: (locale: AppLocale) => void;
+    dateFnsLocale: import("date-fns").Locale;
+    dayPickerLocale: Partial<import("react-day-picker").DayPickerLocale>;
+};
+/** Shorthand for `{ timezone, setTimezone }`. */
+export declare function useAppTimezone(): {
+    timezone: string;
+    setTimezone: (timezone: AppTimezone) => void;
+};
+/** Shorthand for `{ timeFormat, setTimeFormat }`. */
+export declare function useAppTimeFormat(): {
+    timeFormat: AppTimeFormat;
+    setTimeFormat: (timeFormat: AppTimeFormat) => void;
+};
+/** Shorthand for `{ dateFormat, setDateFormat }`. */
+export declare function useAppDateFormat(): {
+    dateFormat: AppDateFormat;
+    setDateFormat: (dateFormat: AppDateFormat) => void;
+};

package/dist/app/app-provider.js

@@ -0,0 +1,244 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { resolveDefaultDateFormat } from "./date-format-labels";
+import { getDateFnsLocale, getDayPickerLocale } from "./locales";
+import { syncAppRequestHeaders } from "./request-headers";
+import { syncI18nLocale } from "../i18n/translate";
+const RTL_LANGUAGE_SUBTAGS = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur", "ps", "sd", "yi", "dv", "ckb"]);
+function localeDirection(locale) {
+  return RTL_LANGUAGE_SUBTAGS.has(locale.split("-")[0]?.toLowerCase() ?? "") ? "rtl" : "ltr";
+}
+import {
+  disableLiveRelativeFormatting,
+  enableLiveRelativeFormatting,
+  syncDatetimeContext
+} from "../lib/datetime";
+import { DEFAULT_STORAGE_KEY, readStoredPreferences, writeStoredPreferences } from "./storage";
+import { resolveDefaultTimeFormat } from "./time-format-labels";
+import { resolveDefaultTimezone } from "./timezones";
+import {
+  APP_REQUEST_HEADER_DATE_FORMAT,
+  APP_REQUEST_HEADER_LOCALE,
+  APP_REQUEST_HEADER_TIME_FORMAT,
+  APP_REQUEST_HEADER_TIMEZONE
+} from "./types";
+const AppContext = React.createContext(null);
+function resolveInitialTimeFormat(stored, defaultTimeFormat, locale) {
+  if (stored) return stored;
+  if (defaultTimeFormat === "locale") return resolveDefaultTimeFormat(locale);
+  return defaultTimeFormat;
+}
+function resolveInitialDateFormat(stored, defaultDateFormat, locale) {
+  if (stored) return stored;
+  if (defaultDateFormat === "locale") return resolveDefaultDateFormat(locale);
+  return defaultDateFormat;
+}
+function buildRequestHeaders(locale, timezone, timeFormat, dateFormat) {
+  return {
+    [APP_REQUEST_HEADER_LOCALE]: locale,
+    [APP_REQUEST_HEADER_TIMEZONE]: timezone,
+    [APP_REQUEST_HEADER_TIME_FORMAT]: timeFormat,
+    [APP_REQUEST_HEADER_DATE_FORMAT]: dateFormat
+  };
+}
+function resolveHydrationSafeTimezone(defaultTimezone, systemTimezone) {
+  if (defaultTimezone === "browser") return systemTimezone ?? "UTC";
+  return resolveDefaultTimezone(defaultTimezone, systemTimezone);
+}
+function AppProvider({
+  children,
+  defaultLocale = "vi",
+  fallbackLocale = "en",
+  defaultTimezone = "browser",
+  systemTimezone,
+  defaultTimeFormat = "locale",
+  defaultDateFormat = "locale",
+  timezoneOptions,
+  storageKey = DEFAULT_STORAGE_KEY,
+  persist = true,
+  onLocaleChange,
+  onTimezoneChange,
+  onTimeFormatChange,
+  onDateFormatChange
+}) {
+  const initialLocale = defaultLocale;
+  const [locale, setLocaleState] = React.useState(initialLocale);
+  const [timezone, setTimezoneState] = React.useState(
+    resolveHydrationSafeTimezone(defaultTimezone, systemTimezone)
+  );
+  const [timeFormat, setTimeFormatState] = React.useState(
+    () => resolveInitialTimeFormat(void 0, defaultTimeFormat, initialLocale)
+  );
+  const [dateFormat, setDateFormatState] = React.useState(
+    () => resolveInitialDateFormat(void 0, defaultDateFormat, initialLocale)
+  );
+  const hasMountedRef = React.useRef(false);
+  const prefsRef = React.useRef({ locale, timezone, timeFormat, dateFormat });
+  React.useEffect(() => {
+    const stored = persist ? readStoredPreferences(storageKey) : {};
+    const nextLocale = stored.locale ?? defaultLocale;
+    const nextTimezone = stored.timezone ?? resolveDefaultTimezone(defaultTimezone, systemTimezone);
+    const nextTimeFormat = resolveInitialTimeFormat(
+      stored.timeFormat,
+      defaultTimeFormat,
+      nextLocale
+    );
+    const nextDateFormat = resolveInitialDateFormat(
+      stored.dateFormat,
+      defaultDateFormat,
+      nextLocale
+    );
+    prefsRef.current = {
+      locale: nextLocale,
+      timezone: nextTimezone,
+      timeFormat: nextTimeFormat,
+      dateFormat: nextDateFormat
+    };
+    setLocaleState(nextLocale);
+    setTimezoneState(nextTimezone);
+    setTimeFormatState(nextTimeFormat);
+    setDateFormatState(nextDateFormat);
+  }, [
+    defaultDateFormat,
+    defaultLocale,
+    defaultTimeFormat,
+    defaultTimezone,
+    persist,
+    storageKey,
+    systemTimezone
+  ]);
+  React.useEffect(() => {
+    prefsRef.current = { locale, timezone, timeFormat, dateFormat };
+  }, [locale, timezone, timeFormat, dateFormat]);
+  const setLocale = React.useCallback(
+    (next) => {
+      prefsRef.current = { ...prefsRef.current, locale: next };
+      setLocaleState(next);
+      onLocaleChange?.(next);
+      if (persist) writeStoredPreferences(storageKey, prefsRef.current);
+    },
+    [onLocaleChange, persist, storageKey]
+  );
+  const setTimezone = React.useCallback(
+    (next) => {
+      prefsRef.current = { ...prefsRef.current, timezone: next };
+      setTimezoneState(next);
+      onTimezoneChange?.(next);
+      if (persist) writeStoredPreferences(storageKey, prefsRef.current);
+    },
+    [onTimezoneChange, persist, storageKey]
+  );
+  const setTimeFormat = React.useCallback(
+    (next) => {
+      prefsRef.current = { ...prefsRef.current, timeFormat: next };
+      setTimeFormatState(next);
+      onTimeFormatChange?.(next);
+      if (persist) writeStoredPreferences(storageKey, prefsRef.current);
+    },
+    [onTimeFormatChange, persist, storageKey]
+  );
+  const setDateFormat = React.useCallback(
+    (next) => {
+      prefsRef.current = { ...prefsRef.current, dateFormat: next };
+      setDateFormatState(next);
+      onDateFormatChange?.(next);
+      if (persist) writeStoredPreferences(storageKey, prefsRef.current);
+    },
+    [onDateFormatChange, persist, storageKey]
+  );
+  const requestHeaders = React.useMemo(
+    () => buildRequestHeaders(locale, timezone, timeFormat, dateFormat),
+    [locale, timezone, timeFormat, dateFormat]
+  );
+  const dateFnsLocale = getDateFnsLocale(locale);
+  syncI18nLocale(locale, fallbackLocale);
+  syncDatetimeContext({
+    locale,
+    timezone,
+    timeFormat,
+    dateFormat,
+    dateFnsLocale
+  });
+  if (!hasMountedRef.current) {
+    disableLiveRelativeFormatting();
+  }
+  React.useEffect(() => {
+    syncAppRequestHeaders(requestHeaders);
+  }, [requestHeaders]);
+  React.useEffect(() => {
+    if (typeof document !== "undefined") {
+      document.documentElement.dir = localeDirection(locale);
+    }
+  }, [locale]);
+  React.useEffect(() => {
+    hasMountedRef.current = true;
+    enableLiveRelativeFormatting();
+  }, []);
+  const value = React.useMemo(
+    () => ({
+      locale,
+      fallbackLocale,
+      timezone,
+      timeFormat,
+      dateFormat,
+      dateFnsLocale,
+      dayPickerLocale: getDayPickerLocale(locale),
+      requestHeaders,
+      timezoneOptions,
+      setLocale,
+      setTimezone,
+      setTimeFormat,
+      setDateFormat
+    }),
+    [
+      locale,
+      fallbackLocale,
+      timezone,
+      timeFormat,
+      dateFormat,
+      dateFnsLocale,
+      requestHeaders,
+      timezoneOptions,
+      setLocale,
+      setTimezone,
+      setTimeFormat,
+      setDateFormat
+    ]
+  );
+  return /* @__PURE__ */ jsx(AppContext.Provider, { value, children });
+}
+function useAppContext() {
+  const ctx = React.useContext(AppContext);
+  if (!ctx) {
+    throw new Error("useAppContext must be used within <AppProvider>");
+  }
+  return ctx;
+}
+function useOptionalAppContext() {
+  return React.useContext(AppContext);
+}
+function useAppLocale() {
+  const { locale, fallbackLocale, setLocale, dateFnsLocale, dayPickerLocale } = useAppContext();
+  return { locale, fallbackLocale, setLocale, dateFnsLocale, dayPickerLocale };
+}
+function useAppTimezone() {
+  const { timezone, setTimezone } = useAppContext();
+  return { timezone, setTimezone };
+}
+function useAppTimeFormat() {
+  const { timeFormat, setTimeFormat } = useAppContext();
+  return { timeFormat, setTimeFormat };
+}
+function useAppDateFormat() {
+  const { dateFormat, setDateFormat } = useAppContext();
+  return { dateFormat, setDateFormat };
+}
+export {
+  AppProvider,
+  useAppContext,
+  useAppDateFormat,
+  useAppLocale,
+  useAppTimeFormat,
+  useAppTimezone,
+  useOptionalAppContext
+};

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

@@ -0,0 +1,8 @@
+import type { AppLocale } from "./types";
+import type { AppDateFormat } from "./date-formats";
+export declare const APP_DATE_FORMAT_OPTIONS: {
+    value: "iso" | "dmy" | "mdy";
+}[];
+export declare function getDateFormatLabel(dateFormat: AppDateFormat, locale: AppLocale, fallbackLocale?: AppLocale): string;
+/** Suggested default per locale — vi → dmy, ja → iso, en → mdy. */
+export declare function resolveDefaultDateFormat(locale: AppLocale): AppDateFormat;

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

@@ -0,0 +1,16 @@
+import { APP_DATE_FORMATS } from "./date-formats";
+import { translate } from "../i18n/translate";
+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 "iso";
+  return "dmy";
+}
+export {
+  APP_DATE_FORMAT_OPTIONS,
+  getDateFormatLabel,
+  resolveDefaultDateFormat
+};

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

@@ -0,0 +1,10 @@
+/** Date-only display preset — sent as `x-date-format` to backend. */
+import { type AppTimeFormat } from "./time-formats";
+export type AppDateFormat = "iso" | "dmy" | "mdy";
+export declare const APP_DATE_FORMATS: readonly ["iso", "dmy", "mdy"];
+export declare const APP_REQUEST_HEADER_DATE_FORMAT: "x-date-format";
+/** 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;
+export declare function isAppDateFormat(value: string | null | undefined): value is AppDateFormat;

package/dist/app/date-formats.js

@@ -0,0 +1,27 @@
+import { getTimePattern } from "./time-formats";
+const APP_DATE_FORMATS = ["iso", "dmy", "mdy"];
+const APP_REQUEST_HEADER_DATE_FORMAT = "x-date-format";
+function getDatePattern(dateFormat) {
+  switch (dateFormat) {
+    case "dmy":
+      return "dd/MM/yyyy";
+    case "mdy":
+      return "MM/dd/yyyy";
+    case "iso":
+    default:
+      return "yyyy-MM-dd";
+  }
+}
+function getDateTimePattern(timeFormat, dateFormat) {
+  return `${getDatePattern(dateFormat)} ${getTimePattern(timeFormat)}`;
+}
+function isAppDateFormat(value) {
+  return value === "iso" || value === "dmy" || value === "mdy";
+}
+export {
+  APP_DATE_FORMATS,
+  APP_REQUEST_HEADER_DATE_FORMAT,
+  getDatePattern,
+  getDateTimePattern,
+  isAppDateFormat
+};

package/dist/app/index.d.ts

@@ -1,136 +1,13 @@
-import { h as AppLocale, j as AppTimeFormat, g as AppDateFormat, k as AppTimezone, i as AppRequestHeaders } from '../types-mvzYGrma.js';
-export { A as APP_DATE_FORMATS, a as APP_LOCALES, b as APP_REQUEST_HEADER_DATE_FORMAT, c as APP_REQUEST_HEADER_LOCALE, d as APP_REQUEST_HEADER_TIMEZONE, e as APP_REQUEST_HEADER_TIME_FORMAT, f as APP_TIME_FORMATS, l as AppTimezoneDefault, m as getDatePattern, n as getDateTimePattern, o as getTimePattern, p as isAppDateFormat, q as isAppTimeFormat } from '../types-mvzYGrma.js';
-import * as react_day_picker from 'react-day-picker';
-import * as date_fns from 'date-fns';
-import { Locale } from 'date-fns';
-import { vi } from 'react-day-picker/locale';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { a as AppProviderProp, A as AppContextValue } from '../app.prop-CVY8V4ss.js';
-import { j as formatDate, a as FormatDateOptions } from '../format-date-ByyZoqI5.js';
-export { F as FormatDateKind, b as FormatDatetimeOptions, d as detectFormatDateKind, f as formatAppDate, c as formatAppDateLong, e as formatAppDateTime, g as formatAppRelative, h as formatAppTime, i as formatCalendarDate, k as formatTimeOfDay, m as isFormatDateValue } from '../format-date-ByyZoqI5.js';
-export { getDatetimeContext, isValidHhmm, normalizeHhmm, parseDateInput, syncDatetimeContext } from '../lib/datetime/index.js';
-export { usePickerLocales, useTranslation } from '../i18n/index.js';
-import '../shared.prop-BvMSLFJ6.js';
-import 'react';
-import '@date-fns/tz';
-
-type AppLocaleConfig = {
-    code: AppLocale;
-    dateFns: Locale;
-    dayPicker: typeof vi;
-};
-declare const APP_LOCALE_CONFIG: Record<AppLocale, AppLocaleConfig>;
-declare function isAppLocale(value: string | null | undefined): value is AppLocale;
-declare function getDateFnsLocale(locale: AppLocale): Locale;
-declare function getDayPickerLocale(locale: AppLocale): react_day_picker.DayPickerLocale;
-
-/** Curated preset — pass to `<AppProvider timezoneOptions={APP_TIMEZONE_PRESET} />`. */
-declare const APP_TIMEZONE_PRESET: readonly ["UTC", "Asia/Ho_Chi_Minh", "Asia/Bangkok", "Asia/Singapore", "Asia/Jakarta", "Asia/Manila", "Asia/Kuala_Lumpur", "Asia/Yangon", "Asia/Phnom_Penh", "Asia/Vientiane", "Asia/Brunei", "Asia/Tokyo", "Asia/Seoul", "Asia/Shanghai", "Asia/Hong_Kong", "Asia/Taipei", "Asia/Ulaanbaatar", "Asia/Kolkata", "Asia/Karachi", "Asia/Dhaka", "Asia/Colombo", "Asia/Dubai", "Asia/Riyadh", "Asia/Qatar", "Asia/Tehran", "Asia/Jerusalem", "Europe/London", "Europe/Paris", "Europe/Berlin", "Europe/Amsterdam", "Europe/Rome", "Europe/Madrid", "Europe/Moscow", "Europe/Istanbul", "America/New_York", "America/Chicago", "America/Denver", "America/Los_Angeles", "America/Toronto", "America/Vancouver", "America/Mexico_City", "America/Sao_Paulo", "America/Buenos_Aires", "Australia/Sydney", "Australia/Melbourne", "Australia/Perth", "Pacific/Auckland"];
-type AppTimezonePreset = (typeof APP_TIMEZONE_PRESET)[number];
-/**
- * Preferred IANA ids not returned by all runtimes (e.g. Node lists `Asia/Saigon` only).
- * Keys are app-facing ids; values are Intl-canonical ids for offset lookup.
- */
-declare const TIMEZONE_ALIASES: Record<string, string>;
-/** Map app id → Intl id for `DateTimeFormat` / validation. */
-declare function resolveTimezoneForIntl(timezone: string): string;
-/** Full IANA list from runtime — sorted lexicographically. */
-declare function getAllIanaTimezones(): readonly string[];
-declare function isValidIanaTimezone(value: string): boolean;
-/**
- * Options for TimezonePicker.
- * - `configured` omitted/empty → full IANA list
- * - `configured` set → only those ids (+ `current` if missing)
- */
-declare function resolveTimezonePickerOptions(configured?: readonly string[] | null, current?: string): readonly string[];
-declare function getBrowserTimezone(): string;
-/** City/region segment from IANA id — `Asia/Ho_Chi_Minh` → `Ho Chi Minh`. */
-declare function getTimezoneCityName(timezone: string): string;
-/** UTC/GMT offset via Intl — e.g. `GMT+7`, `UTC`. */
-declare function getTimezoneOffsetLabel(timezone: string, locale?: AppLocale): string;
-/** Intl fallback when no i18n override — `Ho Chi Minh (GMT+7)`. */
-declare function formatTimezoneDisplayLabel(timezone: string, locale?: AppLocale): string;
-declare function getTimezoneLabel(timezone: string, locale: AppLocale, fallbackLocale?: AppLocale): string;
-declare function resolveDefaultTimezone(defaultTimezone: "browser" | "system" | (string & {}), systemTimezone?: string): string;
-/** Vitest only — reset cached IANA list between cases. */
-declare function resetIanaTimezoneCacheForTests(): void;
-
-declare const APP_TIME_FORMAT_OPTIONS: {
-    value: "24h" | "12h";
-}[];
-declare function getTimeFormatLabel(timeFormat: AppTimeFormat, locale: AppLocale, fallbackLocale?: AppLocale): string;
-/** Suggested default per locale — vi/ja → 24h, en → 12h. */
-declare function resolveDefaultTimeFormat(locale: AppLocale): AppTimeFormat;
-
-declare const APP_DATE_FORMAT_OPTIONS: {
-    value: "iso" | "dmy" | "mdy";
-}[];
-declare function getDateFormatLabel(dateFormat: AppDateFormat, locale: AppLocale, fallbackLocale?: AppLocale): string;
-/** Suggested default per locale — vi → dmy, ja → iso, en → mdy. */
-declare function resolveDefaultDateFormat(locale: AppLocale): AppDateFormat;
-
-declare const DEFAULT_STORAGE_KEY = "godxjp.app";
-type StoredAppPreferences = {
-    locale?: AppLocale;
-    timezone?: AppTimezone;
-    timeFormat?: AppTimeFormat;
-    dateFormat?: AppDateFormat;
-};
-declare function readStoredPreferences(storageKey: string): StoredAppPreferences;
-declare function writeStoredPreferences(storageKey: string, preferences: StoredAppPreferences): void;
-
-/** Sync locale/timezone into module state for HTTP clients (via `getAppRequestHeaders`). */
-declare function syncAppRequestHeaders(headers: Partial<AppRequestHeaders>): void;
-/** Read current app preference headers — wire to API client `setAppHeaderProvider`. */
-declare function getAppRequestHeaders(): AppRequestHeaders;
-/** Reset to defaults — for tests only. */
-declare function resetAppRequestHeaders(): void;
-
-declare function AppProvider({ children, defaultLocale, fallbackLocale, defaultTimezone, systemTimezone, defaultTimeFormat, defaultDateFormat, timezoneOptions, storageKey, persist, onLocaleChange, onTimezoneChange, onTimeFormatChange, onDateFormatChange, }: AppProviderProp): react_jsx_runtime.JSX.Element;
-declare function useAppContext(): AppContextValue;
-/** Returns null outside AppProvider — used by pickers for optional context. */
-declare function useOptionalAppContext(): AppContextValue | null;
-/** Shorthand for `{ locale, setLocale }`. */
-declare function useAppLocale(): {
-    locale: AppLocale;
-    fallbackLocale: AppLocale;
-    setLocale: (locale: AppLocale) => void;
-    dateFnsLocale: date_fns.Locale;
-    dayPickerLocale: Partial<react_day_picker.DayPickerLocale>;
-};
-/** Shorthand for `{ timezone, setTimezone }`. */
-declare function useAppTimezone(): {
-    timezone: string;
-    setTimezone: (timezone: AppTimezone) => void;
-};
-/** Shorthand for `{ timeFormat, setTimeFormat }`. */
-declare function useAppTimeFormat(): {
-    timeFormat: AppTimeFormat;
-    setTimeFormat: (timeFormat: AppTimeFormat) => void;
-};
-/** Shorthand for `{ dateFormat, setDateFormat }`. */
-declare function useAppDateFormat(): {
-    dateFormat: AppDateFormat;
-    setDateFormat: (dateFormat: AppDateFormat) => void;
-};
-
-/** Date/time formatters bound to the current AppProvider preferences. */
-declare function useFormatting(): {
-    locale: AppLocale;
-    timezone: string;
-    timeFormat: AppTimeFormat;
-    dateFormat: AppDateFormat;
-    /** Primary formatter — auto-detect + AppProvider defaults. */
-    format: (value: Parameters<typeof formatDate>[0], options?: FormatDateOptions) => string;
-    formatDate: (value: Parameters<typeof formatDate>[0], options?: FormatDateOptions) => string;
-    formatCalendarDate: (value: Date | null | undefined, options?: FormatDateOptions) => string;
-    formatTime: (value: Parameters<typeof formatDate>[0], options?: FormatDateOptions) => string;
-    formatDateTime: (value: Parameters<typeof formatDate>[0], options?: FormatDateOptions) => string;
-    formatDateLong: (value: Parameters<typeof formatDate>[0], options?: FormatDateOptions) => string;
-    formatRelative: (value: Parameters<typeof formatDate>[0], options?: FormatDateOptions) => string;
-    formatTimeOfDay: (value: Parameters<typeof formatDate>[0], options?: FormatDateOptions) => string;
-};
-/** Alias for useFormatting — emphasises timezone-aware datetime helpers. */
-declare const useDateTime: typeof useFormatting;
-
-export { APP_DATE_FORMAT_OPTIONS, APP_LOCALE_CONFIG, APP_TIMEZONE_PRESET, APP_TIME_FORMAT_OPTIONS, AppDateFormat, AppLocale, type AppLocaleConfig, AppProvider, AppRequestHeaders, AppTimeFormat, AppTimezone, type AppTimezonePreset, DEFAULT_STORAGE_KEY, FormatDateOptions, type StoredAppPreferences, TIMEZONE_ALIASES, formatDate, formatTimezoneDisplayLabel, getAllIanaTimezones, getAppRequestHeaders, getBrowserTimezone, getDateFnsLocale, getDateFormatLabel, getDayPickerLocale, getTimeFormatLabel, getTimezoneCityName, getTimezoneLabel, getTimezoneOffsetLabel, isAppLocale, isValidIanaTimezone, readStoredPreferences, resetAppRequestHeaders, resetIanaTimezoneCacheForTests, resolveDefaultDateFormat, resolveDefaultTimeFormat, resolveDefaultTimezone, resolveTimezoneForIntl, resolveTimezonePickerOptions, syncAppRequestHeaders, useAppContext, useAppDateFormat, useAppLocale, useAppTimeFormat, useAppTimezone, useDateTime, useFormatting, useOptionalAppContext, writeStoredPreferences };
+export * from "./types";
+export * from "./locales";
+export * from "./timezones";
+export * from "./time-formats";
+export * from "./date-formats";
+export * from "./time-format-labels";
+export * from "./date-format-labels";
+export * from "./storage";
+export * from "./request-headers";
+export { AppProvider, useAppContext, useOptionalAppContext, useAppLocale, useAppTimezone, useAppTimeFormat, useAppDateFormat, } from "./app-provider";
+export { useFormatting, useDateTime } from "./use-formatting";
+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";
+export { useTranslation, usePickerLocales } from "../i18n/use-translation";

package/dist/app/index.js

@@ -1,38 +1,65 @@
-import { useAppContext } from '../chunk-B6S6LTWT.js';
-export { APP_LOCALES, APP_REQUEST_HEADER_LOCALE, APP_REQUEST_HEADER_TIMEZONE, APP_TIMEZONE_PRESET, APP_TIME_FORMAT_OPTIONS, AppProvider, DEFAULT_STORAGE_KEY, TIMEZONE_ALIASES, formatTimezoneDisplayLabel, getAllIanaTimezones, getAppRequestHeaders, getBrowserTimezone, getTimeFormatLabel, getTimezoneCityName, getTimezoneLabel, getTimezoneOffsetLabel, isValidIanaTimezone, readStoredPreferences, resetAppRequestHeaders, resetIanaTimezoneCacheForTests, resolveDefaultTimeFormat, resolveDefaultTimezone, resolveTimezoneForIntl, resolveTimezonePickerOptions, syncAppRequestHeaders, useAppContext, useAppDateFormat, useAppLocale, useAppTimeFormat, useAppTimezone, useOptionalAppContext, usePickerLocales, useTranslation, writeStoredPreferences } from '../chunk-B6S6LTWT.js';
-import { formatDate } from '../chunk-5732TWQF.js';
-export { APP_DATE_FORMATS, APP_DATE_FORMAT_OPTIONS, APP_LOCALE_CONFIG, APP_REQUEST_HEADER_DATE_FORMAT, APP_REQUEST_HEADER_TIME_FORMAT, APP_TIME_FORMATS, detectFormatDateKind, formatAppDate, formatAppDateLong, formatAppDateTime, formatAppRelative, formatAppTime, formatCalendarDate, formatDate, formatTimeOfDay, getDateFnsLocale, getDateFormatLabel, getDatePattern, getDateTimePattern, getDatetimeContext, getDayPickerLocale, getTimePattern, isAppDateFormat, isAppLocale, isAppTimeFormat, isFormatDateValue, isValidHhmm, normalizeHhmm, parseDateInput, resolveDefaultDateFormat, syncDatetimeContext } from '../chunk-5732TWQF.js';
-import { useMemo } from 'react';
-
-function useFormatting() {
-  const { locale, timezone, timeFormat, dateFormat, dateFnsLocale } = useAppContext();
-  const defaults = useMemo(
-    () => ({ locale: dateFnsLocale, timezone, timeFormat, dateFormat }),
-    [dateFnsLocale, timezone, timeFormat, dateFormat]
-  );
-  const bind = useMemo(
-    () => (value, options) => formatDate(value, { ...defaults, ...options }),
-    [defaults]
-  );
-  return useMemo(
-    () => ({
-      locale,
-      timezone,
-      timeFormat,
-      dateFormat,
-      /** Primary formatter — auto-detect + AppProvider defaults. */
-      format: bind,
-      formatDate: bind,
-      formatCalendarDate: (value, options) => formatDate(value, { ...defaults, ...options, kind: "calendar" }),
-      formatTime: (value, options) => formatDate(value, { ...defaults, ...options, kind: "time" }),
-      formatDateTime: (value, options) => formatDate(value, { ...defaults, ...options, kind: "datetime" }),
-      formatDateLong: (value, options) => formatDate(value, { ...defaults, ...options, kind: "long" }),
-      formatRelative: (value, options) => formatDate(value, { ...defaults, ...options, kind: "relative" }),
-      formatTimeOfDay: (value, options) => formatDate(value, { ...defaults, ...options, kind: "time" })
-    }),
-    [locale, timezone, timeFormat, dateFormat, defaults, bind]
-  );
-}
-var useDateTime = useFormatting;
-
-export { useDateTime, useFormatting };
+export * from "./types";
+export * from "./locales";
+export * from "./timezones";
+export * from "./time-formats";
+export * from "./date-formats";
+export * from "./time-format-labels";
+export * from "./date-format-labels";
+export * from "./storage";
+export * from "./request-headers";
+import {
+  AppProvider,
+  useAppContext,
+  useOptionalAppContext,
+  useAppLocale,
+  useAppTimezone,
+  useAppTimeFormat,
+  useAppDateFormat
+} from "./app-provider";
+import { useFormatting, useDateTime } from "./use-formatting";
+import {
+  syncDatetimeContext,
+  getDatetimeContext,
+  formatDate,
+  isFormatDateValue,
+  detectFormatDateKind,
+  formatAppDate,
+  formatAppDateTime,
+  formatAppTime,
+  formatAppDateLong,
+  formatAppRelative,
+  formatCalendarDate,
+  formatTimeOfDay,
+  parseDateInput,
+  normalizeHhmm,
+  isValidHhmm
+} from "../lib/datetime";
+import { useTranslation, usePickerLocales } from "../i18n/use-translation";
+export {
+  AppProvider,
+  detectFormatDateKind,
+  formatAppDate,
+  formatAppDateLong,
+  formatAppDateTime,
+  formatAppRelative,
+  formatAppTime,
+  formatCalendarDate,
+  formatDate,
+  formatTimeOfDay,
+  getDatetimeContext,
+  isFormatDateValue,
+  isValidHhmm,
+  normalizeHhmm,
+  parseDateInput,
+  syncDatetimeContext,
+  useAppContext,
+  useAppDateFormat,
+  useAppLocale,
+  useAppTimeFormat,
+  useAppTimezone,
+  useDateTime,
+  useFormatting,
+  useOptionalAppContext,
+  usePickerLocales,
+  useTranslation
+};

package/dist/app/locales.d.ts

@@ -0,0 +1,12 @@
+import type { Locale } from "date-fns";
+import { vi as viDayPicker } from "react-day-picker/locale";
+import type { AppLocale } from "./types";
+export type AppLocaleConfig = {
+    code: AppLocale;
+    dateFns: Locale;
+    dayPicker: typeof viDayPicker;
+};
+export declare const APP_LOCALE_CONFIG: Record<AppLocale, AppLocaleConfig>;
+export declare function isAppLocale(value: string | null | undefined): value is AppLocale;
+export declare function getDateFnsLocale(locale: AppLocale): Locale;
+export declare function getDayPickerLocale(locale: AppLocale): import("react-day-picker").DayPickerLocale;

package/dist/app/locales.js

@@ -0,0 +1,26 @@
+import { enUS, ja, vi } from "date-fns/locale";
+import {
+  enUS as enUSDayPicker,
+  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 }
+};
+function isAppLocale(value) {
+  return value === "vi" || value === "en" || value === "ja";
+}
+function getDateFnsLocale(locale) {
+  return APP_LOCALE_CONFIG[locale].dateFns;
+}
+function getDayPickerLocale(locale) {
+  return APP_LOCALE_CONFIG[locale].dayPicker;
+}
+export {
+  APP_LOCALE_CONFIG,
+  getDateFnsLocale,
+  getDayPickerLocale,
+  isAppLocale
+};

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

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