@godxjp/ui 6.0.0 → 6.0.2

package/src/app/__tests__/app-provider.test.tsx

@@ -1,232 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import * as React from "react";
-import { AppProvider, useAppContext } from "../app-provider";
-import { getAppRequestHeaders, resetAppRequestHeaders } from "../request-headers";
-import { resetI18nLocale } from "../../i18n/translate";
-import { readStoredPreferences, writeStoredPreferences } from "../storage";
-
-const STORAGE_KEY = "godxjp.app.test";
-
-function wrapper(props: React.PropsWithChildren<{ persist?: boolean }>) {
-  return (
-    <AppProvider
-      storageKey={STORAGE_KEY}
-      persist={props.persist ?? false}
-      defaultLocale="vi"
-      fallbackLocale="en"
-      defaultTimezone="Asia/Tokyo"
-    >
-      {props.children}
-    </AppProvider>
-  );
-}
-
-describe("AppProvider", () => {
-  beforeEach(() => {
-    resetAppRequestHeaders();
-    resetI18nLocale();
-    localStorage.removeItem(STORAGE_KEY);
-  });
-
-  afterEach(() => {
-    localStorage.removeItem(STORAGE_KEY);
-  });
-
-  it("initializes locale and timezone and syncs request headers", () => {
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => wrapper({ children }),
-    });
-
-    expect(result.current.locale).toBe("vi");
-    expect(result.current.timezone).toBe("Asia/Tokyo");
-    expect(getAppRequestHeaders()).toEqual({
-      "x-locale": "vi",
-      "x-timezone": "Asia/Tokyo",
-      "x-time-format": "24h",
-      "x-date-format": "dmy",
-    });
-  });
-
-  it("updates headers when locale and timezone change", () => {
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => wrapper({ children }),
-    });
-
-    act(() => {
-      result.current.setLocale("ja");
-      result.current.setTimezone("Asia/Ho_Chi_Minh");
-      result.current.setTimeFormat("12h");
-      result.current.setDateFormat("iso");
-    });
-
-    expect(result.current.requestHeaders).toEqual({
-      "x-locale": "ja",
-      "x-timezone": "Asia/Ho_Chi_Minh",
-      "x-time-format": "12h",
-      "x-date-format": "iso",
-    });
-    expect(getAppRequestHeaders()["x-locale"]).toBe("ja");
-  });
-
-  it("persists preferences to localStorage", () => {
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => wrapper({ children, persist: true }),
-    });
-
-    act(() => {
-      result.current.setLocale("en");
-      result.current.setTimezone("UTC");
-      result.current.setTimeFormat("12h");
-      result.current.setDateFormat("mdy");
-    });
-
-    expect(readStoredPreferences(STORAGE_KEY)).toEqual({
-      locale: "en",
-      timezone: "UTC",
-      timeFormat: "12h",
-      dateFormat: "mdy",
-    });
-  });
-
-  it("restores persisted preferences on mount", () => {
-    writeStoredPreferences(STORAGE_KEY, {
-      locale: "ja",
-      timezone: "Asia/Singapore",
-      timeFormat: "12h",
-      dateFormat: "iso",
-    });
-
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => wrapper({ children, persist: true }),
-    });
-
-    expect(result.current.locale).toBe("ja");
-    expect(result.current.timezone).toBe("Asia/Singapore");
-    expect(result.current.timeFormat).toBe("12h");
-    expect(result.current.dateFormat).toBe("iso");
-  });
-
-  it("calls onLocaleChange and onTimezoneChange", () => {
-    const onLocaleChange = vi.fn();
-    const onTimezoneChange = vi.fn();
-
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider
-          storageKey={STORAGE_KEY}
-          persist={false}
-          onLocaleChange={onLocaleChange}
-          onTimezoneChange={onTimezoneChange}
-        >
-          {children}
-        </AppProvider>
-      ),
-    });
-
-    act(() => {
-      result.current.setLocale("en");
-      result.current.setTimezone("UTC");
-    });
-
-    expect(onLocaleChange).toHaveBeenCalledWith("en");
-    expect(onTimezoneChange).toHaveBeenCalledWith("UTC");
-  });
-
-  it("derives default time format from locale when defaultTimeFormat is locale", () => {
-    const { result: enResult } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider storageKey={STORAGE_KEY} persist={false} defaultLocale="en">
-          {children}
-        </AppProvider>
-      ),
-    });
-    expect(enResult.current.timeFormat).toBe("12h");
-
-    const { result: viResult } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider storageKey={STORAGE_KEY} persist={false} defaultLocale="vi">
-          {children}
-        </AppProvider>
-      ),
-    });
-    expect(viResult.current.timeFormat).toBe("24h");
-  });
-
-  it("derives default date format from locale when defaultDateFormat is locale", () => {
-    const { result: enResult } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider storageKey={STORAGE_KEY} persist={false} defaultLocale="en">
-          {children}
-        </AppProvider>
-      ),
-    });
-    expect(enResult.current.dateFormat).toBe("mdy");
-
-    const { result: viResult } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider storageKey={STORAGE_KEY} persist={false} defaultLocale="vi">
-          {children}
-        </AppProvider>
-      ),
-    });
-    expect(viResult.current.dateFormat).toBe("dmy");
-
-    const { result: jaResult } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider storageKey={STORAGE_KEY} persist={false} defaultLocale="ja">
-          {children}
-        </AppProvider>
-      ),
-    });
-    expect(jaResult.current.dateFormat).toBe("iso");
-  });
-
-  it("throws outside AppProvider", () => {
-    expect(() => renderHook(() => useAppContext())).toThrow(/AppProvider/);
-  });
-
-  it("exposes timezoneOptions on context when configured", () => {
-    const zones = ["Asia/Tokyo", "Asia/Ho_Chi_Minh"] as const;
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider storageKey={STORAGE_KEY} persist={false} timezoneOptions={zones}>
-          {children}
-        </AppProvider>
-      ),
-    });
-    expect(result.current.timezoneOptions).toEqual(zones);
-  });
-
-  it("timezoneOptions undefined means full IANA list in picker", () => {
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider storageKey={STORAGE_KEY} persist={false}>
-          {children}
-        </AppProvider>
-      ),
-    });
-    expect(result.current.timezoneOptions).toBeUndefined();
-  });
-
-  it("calls onDateFormatChange when date format updates", () => {
-    const onDateFormatChange = vi.fn();
-    const { result } = renderHook(() => useAppContext(), {
-      wrapper: ({ children }) => (
-        <AppProvider
-          storageKey={STORAGE_KEY}
-          persist={false}
-          onDateFormatChange={onDateFormatChange}
-        >
-          {children}
-        </AppProvider>
-      ),
-    });
-
-    act(() => {
-      result.current.setDateFormat("iso");
-    });
-
-    expect(onDateFormatChange).toHaveBeenCalledWith("iso");
-  });
-});

package/src/app/__tests__/date-format-labels.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  APP_DATE_FORMAT_OPTIONS,
-  getDateFormatLabel,
-  resolveDefaultDateFormat,
-} from "../date-format-labels";
-
-describe("date-format-labels", () => {
-  describe("resolveDefaultDateFormat", () => {
-    it.each([
-      ["vi", "dmy"],
-      ["ja", "iso"],
-      ["en", "mdy"],
-    ] as const)("locale %s → %s", (locale, expected) => {
-      expect(resolveDefaultDateFormat(locale)).toBe(expected);
-    });
-  });
-
-  describe("getDateFormatLabel", () => {
-    it("returns Vietnamese label for dmy", () => {
-      expect(getDateFormatLabel("dmy", "vi", "en")).toMatch(/Ngày|Tháng|Năm/);
-    });
-
-    it("returns Japanese ISO label", () => {
-      expect(getDateFormatLabel("iso", "ja", "en")).toMatch(/YYYY-MM-DD/);
-    });
-
-    it("returns English label when locale is en", () => {
-      expect(getDateFormatLabel("mdy", "en", "vi")).toMatch(/Month|Day|Year/i);
-    });
-  });
-
-  it("exports option list for pickers", () => {
-    expect(APP_DATE_FORMAT_OPTIONS.map((o) => o.value)).toEqual(["iso", "dmy", "mdy"]);
-  });
-});

package/src/app/__tests__/date-formats.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  APP_DATE_FORMATS,
-  getDatePattern,
-  getDateTimePattern,
-  isAppDateFormat,
-} from "../date-formats";
-
-describe("date-formats", () => {
-  describe("getDatePattern", () => {
-    it.each([
-      ["iso", "yyyy-MM-dd"],
-      ["dmy", "dd/MM/yyyy"],
-      ["mdy", "MM/dd/yyyy"],
-    ] as const)("maps %s → %s", (format, pattern) => {
-      expect(getDatePattern(format)).toBe(pattern);
-    });
-  });
-
-  describe("getDateTimePattern", () => {
-    it("combines date pattern + 24h time", () => {
-      expect(getDateTimePattern("24h", "iso")).toBe("yyyy-MM-dd HH:mm");
-      expect(getDateTimePattern("24h", "dmy")).toBe("dd/MM/yyyy HH:mm");
-    });
-
-    it("combines date pattern + 12h time", () => {
-      expect(getDateTimePattern("12h", "mdy")).toBe("MM/dd/yyyy h:mm a");
-    });
-  });
-
-  describe("isAppDateFormat", () => {
-    it("accepts known presets", () => {
-      for (const format of APP_DATE_FORMATS) {
-        expect(isAppDateFormat(format)).toBe(true);
-      }
-    });
-
-    it("rejects unknown values", () => {
-      expect(isAppDateFormat("ymd")).toBe(false);
-      expect(isAppDateFormat(null)).toBe(false);
-      expect(isAppDateFormat("")).toBe(false);
-    });
-  });
-});

package/src/app/__tests__/timezones.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  APP_TIMEZONE_PRESET,
-  formatTimezoneDisplayLabel,
-  getAllIanaTimezones,
-  getTimezoneLabel,
-  getTimezoneOffsetLabel,
-  isValidIanaTimezone,
-  resolveTimezonePickerOptions,
-} from "../timezones";
-
-describe("timezones", () => {
-  it("exposes full IANA list by default", () => {
-    const all = getAllIanaTimezones();
-    expect(all.length).toBeGreaterThan(100);
-    expect(all).toContain("Asia/Ho_Chi_Minh");
-    expect(all).toContain("Asia/Tokyo");
-    expect(all).toContain("Europe/Paris");
-  });
-
-  it("preset covers cross-border hubs", () => {
-    expect(APP_TIMEZONE_PRESET).toContain("Asia/Ho_Chi_Minh");
-    expect(APP_TIMEZONE_PRESET).toContain("Australia/Sydney");
-    expect(APP_TIMEZONE_PRESET.length).toBeGreaterThanOrEqual(40);
-  });
-
-  it("resolveTimezonePickerOptions uses full list when unconfigured", () => {
-    const options = resolveTimezonePickerOptions(undefined, "Asia/Tokyo");
-    expect(options.length).toBeGreaterThan(100);
-    expect(options).toContain("Asia/Tokyo");
-  });
-
-  it("resolveTimezonePickerOptions respects AppProvider config", () => {
-    const configured = ["Asia/Tokyo", "Asia/Ho_Chi_Minh"] as const;
-    const options = resolveTimezonePickerOptions(configured, "Asia/Tokyo");
-    expect(options).toEqual(["Asia/Tokyo", "Asia/Ho_Chi_Minh"]);
-  });
-
-  it("prepends current timezone when missing from configured list", () => {
-    const options = resolveTimezonePickerOptions(["Asia/Tokyo"], "Europe/Paris");
-    expect(options[0]).toBe("Europe/Paris");
-    expect(options).toContain("Asia/Tokyo");
-  });
-
-  it("uses i18n label for curated zones", () => {
-    expect(getTimezoneLabel("Asia/Ho_Chi_Minh", "vi", "en")).toBe("Việt Nam (HCM)");
-    expect(getTimezoneLabel("Asia/Tokyo", "ja", "en")).toMatch(/日本|Tokyo/);
-  });
-
-  it("falls back to city + UTC offset for zones without i18n", () => {
-    const label = getTimezoneLabel("Europe/Paris", "en", "en");
-    expect(label).toMatch(/Paris/);
-    expect(label).toMatch(/GMT|UTC|[+-]\d/);
-  });
-
-  it("formats offset via Intl", () => {
-    expect(getTimezoneOffsetLabel("Asia/Ho_Chi_Minh", "en")).toMatch(/GMT|UTC|[+-]\d/);
-    expect(formatTimezoneDisplayLabel("Asia/Ho_Chi_Minh", "en")).toMatch(/Ho Chi Minh/);
-  });
-
-  it("validates IANA ids against full list", () => {
-    expect(isValidIanaTimezone("Asia/Jakarta")).toBe(true);
-    expect(isValidIanaTimezone("Not/A/Zone")).toBe(false);
-  });
-});

package/src/app/app-provider.tsx

@@ -1,227 +0,0 @@
-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";
-import { 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,
-  type AppDateFormat,
-  type AppLocale,
-  type AppRequestHeaders,
-  type AppTimeFormat,
-  type AppTimezone,
-} from "./types";
-import type { AppContextValue, AppProviderProp } from "../props/components/app.prop";
-
-export type { AppProviderProp, AppContextValue } from "../props/components/app.prop";
-
-const AppContext = React.createContext<AppContextValue | null>(null);
-
-function resolveInitialTimeFormat(
-  stored: AppTimeFormat | undefined,
-  defaultTimeFormat: AppTimeFormat | "locale",
-  locale: AppLocale,
-): AppTimeFormat {
-  if (stored) return stored;
-  if (defaultTimeFormat === "locale") return resolveDefaultTimeFormat(locale);
-  return defaultTimeFormat;
-}
-
-function resolveInitialDateFormat(
-  stored: AppDateFormat | undefined,
-  defaultDateFormat: AppDateFormat | "locale",
-  locale: AppLocale,
-): AppDateFormat {
-  if (stored) return stored;
-  if (defaultDateFormat === "locale") return resolveDefaultDateFormat(locale);
-  return defaultDateFormat;
-}
-
-function buildRequestHeaders(
-  locale: AppLocale,
-  timezone: AppTimezone,
-  timeFormat: AppTimeFormat,
-  dateFormat: AppDateFormat,
-): AppRequestHeaders {
-  return {
-    [APP_REQUEST_HEADER_LOCALE]: locale,
-    [APP_REQUEST_HEADER_TIMEZONE]: timezone,
-    [APP_REQUEST_HEADER_TIME_FORMAT]: timeFormat,
-    [APP_REQUEST_HEADER_DATE_FORMAT]: dateFormat,
-  };
-}
-
-export 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,
-}: AppProviderProp) {
-  const stored = React.useMemo(
-    () => (persist ? readStoredPreferences(storageKey) : {}),
-    [persist, storageKey],
-  );
-
-  const initialLocale = stored.locale ?? defaultLocale;
-
-  const [locale, setLocaleState] = React.useState<AppLocale>(initialLocale);
-  const [timezone, setTimezoneState] = React.useState<AppTimezone>(
-    stored.timezone ?? resolveDefaultTimezone(defaultTimezone, systemTimezone),
-  );
-  const [timeFormat, setTimeFormatState] = React.useState<AppTimeFormat>(() =>
-    resolveInitialTimeFormat(stored.timeFormat, defaultTimeFormat, initialLocale),
-  );
-  const [dateFormat, setDateFormatState] = React.useState<AppDateFormat>(() =>
-    resolveInitialDateFormat(stored.dateFormat, defaultDateFormat, initialLocale),
-  );
-
-  const prefsRef = React.useRef({ locale, timezone, timeFormat, dateFormat });
-
-  React.useEffect(() => {
-    prefsRef.current = { locale, timezone, timeFormat, dateFormat };
-  }, [locale, timezone, timeFormat, dateFormat]);
-
-  const setLocale = React.useCallback(
-    (next: AppLocale) => {
-      prefsRef.current = { ...prefsRef.current, locale: next };
-      setLocaleState(next);
-      onLocaleChange?.(next);
-      if (persist) writeStoredPreferences(storageKey, prefsRef.current);
-    },
-    [onLocaleChange, persist, storageKey],
-  );
-
-  const setTimezone = React.useCallback(
-    (next: AppTimezone) => {
-      prefsRef.current = { ...prefsRef.current, timezone: next };
-      setTimezoneState(next);
-      onTimezoneChange?.(next);
-      if (persist) writeStoredPreferences(storageKey, prefsRef.current);
-    },
-    [onTimezoneChange, persist, storageKey],
-  );
-
-  const setTimeFormat = React.useCallback(
-    (next: AppTimeFormat) => {
-      prefsRef.current = { ...prefsRef.current, timeFormat: next };
-      setTimeFormatState(next);
-      onTimeFormatChange?.(next);
-      if (persist) writeStoredPreferences(storageKey, prefsRef.current);
-    },
-    [onTimeFormatChange, persist, storageKey],
-  );
-
-  const setDateFormat = React.useCallback(
-    (next: AppDateFormat) => {
-      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],
-  );
-
-  React.useEffect(() => {
-    syncAppRequestHeaders(requestHeaders);
-    syncI18nLocale(locale, fallbackLocale);
-    syncDatetimeContext({
-      locale,
-      timezone,
-      timeFormat,
-      dateFormat,
-      dateFnsLocale: getDateFnsLocale(locale),
-    });
-  }, [requestHeaders, locale, fallbackLocale, timezone, timeFormat, dateFormat]);
-
-  const value = React.useMemo<AppContextValue>(
-    () => ({
-      locale,
-      fallbackLocale,
-      timezone,
-      timeFormat,
-      dateFormat,
-      dateFnsLocale: getDateFnsLocale(locale),
-      dayPickerLocale: getDayPickerLocale(locale),
-      requestHeaders,
-      timezoneOptions,
-      setLocale,
-      setTimezone,
-      setTimeFormat,
-      setDateFormat,
-    }),
-    [
-      locale,
-      fallbackLocale,
-      timezone,
-      timeFormat,
-      dateFormat,
-      requestHeaders,
-      timezoneOptions,
-      setLocale,
-      setTimezone,
-      setTimeFormat,
-      setDateFormat,
-    ],
-  );
-
-  return <AppContext.Provider value={value}>{children}</AppContext.Provider>;
-}
-
-export function useAppContext(): AppContextValue {
-  const ctx = React.useContext(AppContext);
-  if (!ctx) {
-    throw new Error("useAppContext must be used within <AppProvider>");
-  }
-  return ctx;
-}
-
-/** Returns null outside AppProvider — used by pickers for optional context. */
-export function useOptionalAppContext(): AppContextValue | null {
-  return React.useContext(AppContext);
-}
-
-/** Shorthand for `{ locale, setLocale }`. */
-export function useAppLocale() {
-  const { locale, fallbackLocale, setLocale, dateFnsLocale, dayPickerLocale } = useAppContext();
-  return { locale, fallbackLocale, setLocale, dateFnsLocale, dayPickerLocale };
-}
-
-/** Shorthand for `{ timezone, setTimezone }`. */
-export function useAppTimezone() {
-  const { timezone, setTimezone } = useAppContext();
-  return { timezone, setTimezone };
-}
-
-/** Shorthand for `{ timeFormat, setTimeFormat }`. */
-export function useAppTimeFormat() {
-  const { timeFormat, setTimeFormat } = useAppContext();
-  return { timeFormat, setTimeFormat };
-}
-
-/** Shorthand for `{ dateFormat, setDateFormat }`. */
-export function useAppDateFormat() {
-  const { dateFormat, setDateFormat } = useAppContext();
-  return { dateFormat, setDateFormat };
-}

package/src/app/date-format-labels.ts

@@ -1,21 +0,0 @@
-import { APP_DATE_FORMATS } from "./date-formats";
-import type { AppLocale } from "./types";
-import type { AppDateFormat } from "./date-formats";
-import { translate } from "../i18n/translate";
-
-export const APP_DATE_FORMAT_OPTIONS = APP_DATE_FORMATS.map((value) => ({ value }));
-
-export function getDateFormatLabel(
-  dateFormat: AppDateFormat,
-  locale: AppLocale,
-  fallbackLocale: AppLocale = "en",
-): string {
-  return translate(locale, fallbackLocale, `dateFormat.${dateFormat}`);
-}
-
-/** Suggested default per locale — vi → dmy, ja → iso, en → mdy. */
-export function resolveDefaultDateFormat(locale: AppLocale): AppDateFormat {
-  if (locale === "en") return "mdy";
-  if (locale === "ja") return "iso";
-  return "dmy";
-}

package/src/app/date-formats.ts

@@ -1,30 +0,0 @@
-/** Date-only display preset — sent as `x-date-format` to backend. */
-import { getTimePattern, type AppTimeFormat } from "./time-formats";
-
-export type AppDateFormat = "iso" | "dmy" | "mdy";
-
-export const APP_DATE_FORMATS = ["iso", "dmy", "mdy"] as const satisfies readonly AppDateFormat[];
-
-export const APP_REQUEST_HEADER_DATE_FORMAT = "x-date-format" as const;
-
-/** date-fns pattern for date-only display. */
-export function getDatePattern(dateFormat: AppDateFormat): string {
-  switch (dateFormat) {
-    case "dmy":
-      return "dd/MM/yyyy";
-    case "mdy":
-      return "MM/dd/yyyy";
-    case "iso":
-    default:
-      return "yyyy-MM-dd";
-  }
-}
-
-/** date-fns pattern for date + time (table cells). */
-export function getDateTimePattern(timeFormat: AppTimeFormat, dateFormat: AppDateFormat): string {
-  return `${getDatePattern(dateFormat)} ${getTimePattern(timeFormat)}`;
-}
-
-export function isAppDateFormat(value: string | null | undefined): value is AppDateFormat {
-  return value === "iso" || value === "dmy" || value === "mdy";
-}

package/src/app/index.ts

@@ -1,40 +0,0 @@
-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";