@godxjp/ui 6.0.0 → 6.0.2

package/dist/chunk-3F2AKYRD.js

@@ -0,0 +1,416 @@
+import { APP_TIME_FORMATS, isAppDateFormat, isAppTimeFormat, isAppLocale, translate, syncI18nLocale, syncDatetimeContext, getDateFnsLocale, getDayPickerLocale, APP_REQUEST_HEADER_DATE_FORMAT, APP_REQUEST_HEADER_TIME_FORMAT, resolveDefaultDateFormat } from './chunk-YFCQKO3B.js';
+import * as React from 'react';
+import { useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/app/types.ts
+var APP_LOCALES = ["vi", "en", "ja"];
+var APP_REQUEST_HEADER_LOCALE = "x-locale";
+var APP_REQUEST_HEADER_TIMEZONE = "x-timezone";
+
+// src/app/request-headers.ts
+var 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"
+};
+var currentHeaders = { ...DEFAULT_HEADERS };
+function syncAppRequestHeaders(headers) {
+  currentHeaders = { ...currentHeaders, ...headers };
+}
+function getAppRequestHeaders() {
+  return { ...currentHeaders };
+}
+function resetAppRequestHeaders() {
+  currentHeaders = { ...DEFAULT_HEADERS };
+}
+
+// src/app/storage.ts
+var DEFAULT_STORAGE_KEY = "godxjp.app";
+function readStoredPreferences(storageKey) {
+  if (typeof window === "undefined") return {};
+  try {
+    const raw = window.localStorage.getItem(storageKey);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    return {
+      locale: isAppLocale(parsed.locale) ? parsed.locale : void 0,
+      timezone: typeof parsed.timezone === "string" ? parsed.timezone : void 0,
+      timeFormat: isAppTimeFormat(parsed.timeFormat) ? parsed.timeFormat : void 0,
+      dateFormat: isAppDateFormat(parsed.dateFormat) ? parsed.dateFormat : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function writeStoredPreferences(storageKey, preferences) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(storageKey, JSON.stringify(preferences));
+  } catch {
+  }
+}
+
+// src/app/time-format-labels.ts
+var APP_TIME_FORMAT_OPTIONS = APP_TIME_FORMATS.map((value) => ({ value }));
+function getTimeFormatLabel(timeFormat, locale, fallbackLocale = "en") {
+  return translate(locale, fallbackLocale, `timeFormat.${timeFormat}`);
+}
+function resolveDefaultTimeFormat(locale) {
+  return locale === "en" ? "12h" : "24h";
+}
+
+// src/app/timezones.ts
+var APP_TIMEZONE_PRESET = [
+  "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"
+];
+var APP_TIMEZONE_OPTIONS = APP_TIMEZONE_PRESET;
+var TIMEZONE_ALIASES = {
+  "Asia/Ho_Chi_Minh": "Asia/Saigon"
+};
+var PREFERRED_TIMEZONE_IDS = Object.keys(TIMEZONE_ALIASES);
+function resolveTimezoneForIntl(timezone) {
+  return TIMEZONE_ALIASES[timezone] ?? timezone;
+}
+var FALLBACK_IANA_TIMEZONES = [...APP_TIMEZONE_PRESET];
+var cachedAllTimezones = null;
+var cachedTimezoneSet = null;
+function enrichTimezoneList(base) {
+  const set = new Set(base);
+  for (const preferred of PREFERRED_TIMEZONE_IDS) {
+    if (!set.has(preferred)) {
+      const canonical = TIMEZONE_ALIASES[preferred];
+      if (!canonical || set.has(canonical)) set.add(preferred);
+    }
+  }
+  return [...set].sort();
+}
+function getAllIanaTimezones() {
+  if (cachedAllTimezones) return cachedAllTimezones;
+  try {
+    const intl = Intl;
+    if (typeof intl.supportedValuesOf === "function") {
+      cachedAllTimezones = enrichTimezoneList(intl.supportedValuesOf("timeZone").slice().sort());
+      return cachedAllTimezones;
+    }
+  } catch {
+  }
+  cachedAllTimezones = FALLBACK_IANA_TIMEZONES;
+  return cachedAllTimezones;
+}
+function getIanaTimezoneSet() {
+  cachedTimezoneSet ??= new Set(getAllIanaTimezones());
+  return cachedTimezoneSet;
+}
+function isValidIanaTimezone(value) {
+  const set = getIanaTimezoneSet();
+  if (set.has(value)) return true;
+  const canonical = TIMEZONE_ALIASES[value];
+  return canonical ? set.has(canonical) : false;
+}
+function isKnownAppTimezone(value) {
+  return APP_TIMEZONE_PRESET.includes(value);
+}
+function resolveTimezonePickerOptions(configured, current) {
+  const base = configured && configured.length > 0 ? [...configured] : [...getAllIanaTimezones()];
+  if (current && !base.includes(current)) {
+    return [current, ...base];
+  }
+  return base;
+}
+function getBrowserTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return "UTC";
+  }
+}
+function getTimezoneCityName(timezone) {
+  const segment = timezone.split("/").pop();
+  if (!segment) return timezone;
+  return segment.replace(/_/g, " ");
+}
+function getTimezoneOffsetLabel(timezone, locale = "en") {
+  if (timezone === "UTC") return "UTC";
+  try {
+    const parts = new Intl.DateTimeFormat(locale, {
+      timeZone: resolveTimezoneForIntl(timezone),
+      timeZoneName: "shortOffset"
+    }).formatToParts(/* @__PURE__ */ new Date());
+    return parts.find((part) => part.type === "timeZoneName")?.value ?? "";
+  } catch {
+    return "";
+  }
+}
+function formatTimezoneDisplayLabel(timezone, locale = "en") {
+  const city = getTimezoneCityName(timezone);
+  const offset = getTimezoneOffsetLabel(timezone, locale);
+  return offset ? `${city} (${offset})` : city;
+}
+function getTimezoneLabel(timezone, locale, fallbackLocale = "en") {
+  const key = `timezone.${timezone}`;
+  const translated = translate(locale, fallbackLocale, key);
+  if (translated !== key) return translated;
+  const offset = getTimezoneOffsetLabel(timezone, locale);
+  const city = getTimezoneCityName(timezone);
+  return offset ? `${city} (${offset})` : city;
+}
+function resolveDefaultTimezone(defaultTimezone, systemTimezone) {
+  if (defaultTimezone === "browser") return getBrowserTimezone();
+  if (defaultTimezone === "system") return systemTimezone ?? "UTC";
+  return defaultTimezone;
+}
+function resetIanaTimezoneCacheForTests() {
+  cachedAllTimezones = null;
+  cachedTimezoneSet = null;
+}
+var 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 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 stored = React.useMemo(
+    () => persist ? readStoredPreferences(storageKey) : {},
+    [persist, storageKey]
+  );
+  const initialLocale = stored.locale ?? defaultLocale;
+  const [locale, setLocaleState] = React.useState(initialLocale);
+  const [timezone, setTimezoneState] = React.useState(
+    stored.timezone ?? resolveDefaultTimezone(defaultTimezone, systemTimezone)
+  );
+  const [timeFormat, setTimeFormatState] = React.useState(
+    () => resolveInitialTimeFormat(stored.timeFormat, defaultTimeFormat, initialLocale)
+  );
+  const [dateFormat, setDateFormatState] = React.useState(
+    () => 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) => {
+      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]
+  );
+  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(
+    () => ({
+      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 /* @__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 };
+}
+var DEFAULT_LOCALE = "vi";
+var DEFAULT_FALLBACK = "en";
+function useTranslation() {
+  const ctx = useOptionalAppContext();
+  const locale = ctx?.locale ?? DEFAULT_LOCALE;
+  const fallbackLocale = ctx?.fallbackLocale ?? DEFAULT_FALLBACK;
+  return useMemo(
+    () => ({
+      locale,
+      fallbackLocale,
+      t: (key, params) => translate(locale, fallbackLocale, key, params)
+    }),
+    [locale, fallbackLocale]
+  );
+}
+function usePickerLocales(dayPickerOverride) {
+  const ctx = useOptionalAppContext();
+  const locale = ctx?.locale ?? DEFAULT_LOCALE;
+  return useMemo(
+    () => ({
+      locale,
+      timezone: ctx?.timezone ?? "Asia/Ho_Chi_Minh",
+      timeFormat: ctx?.timeFormat ?? "24h",
+      dateFormat: ctx?.dateFormat ?? "dmy",
+      dateFnsLocale: ctx?.dateFnsLocale ?? getDateFnsLocale(locale),
+      dayPickerLocale: dayPickerOverride ?? ctx?.dayPickerLocale ?? getDayPickerLocale(locale)
+    }),
+    [
+      ctx?.dateFnsLocale,
+      ctx?.dayPickerLocale,
+      ctx?.timeFormat,
+      ctx?.dateFormat,
+      ctx?.timezone,
+      dayPickerOverride,
+      locale
+    ]
+  );
+}
+
+export { APP_LOCALES, APP_REQUEST_HEADER_LOCALE, APP_REQUEST_HEADER_TIMEZONE, APP_TIMEZONE_OPTIONS, APP_TIMEZONE_PRESET, APP_TIME_FORMAT_OPTIONS, AppProvider, DEFAULT_STORAGE_KEY, TIMEZONE_ALIASES, formatTimezoneDisplayLabel, getAllIanaTimezones, getAppRequestHeaders, getBrowserTimezone, getTimeFormatLabel, getTimezoneCityName, getTimezoneLabel, getTimezoneOffsetLabel, isKnownAppTimezone, isValidIanaTimezone, readStoredPreferences, resetAppRequestHeaders, resetIanaTimezoneCacheForTests, resolveDefaultTimeFormat, resolveDefaultTimezone, resolveTimezoneForIntl, resolveTimezonePickerOptions, syncAppRequestHeaders, useAppContext, useAppDateFormat, useAppLocale, useAppTimeFormat, useAppTimezone, useOptionalAppContext, usePickerLocales, useTranslation, writeStoredPreferences };

package/dist/chunk-3KPEZ5CF.js

@@ -0,0 +1,37 @@
+import { cn } from './chunk-U7N2A7A3.js';
+import * as React from 'react';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var ScrollArea = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+  ScrollAreaPrimitive.Root,
+  {
+    ref,
+    className: cn("relative overflow-hidden", className),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx(ScrollAreaPrimitive.Viewport, { className: "size-full rounded-[inherit]", children }),
+      /* @__PURE__ */ jsx(ScrollBar, {}),
+      /* @__PURE__ */ jsx(ScrollAreaPrimitive.Corner, {})
+    ]
+  }
+));
+ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName;
+var ScrollBar = React.forwardRef(({ className, orientation = "vertical", ...props }, ref) => /* @__PURE__ */ jsx(
+  ScrollAreaPrimitive.ScrollAreaScrollbar,
+  {
+    ref,
+    orientation,
+    className: cn(
+      "flex touch-none transition-colors select-none",
+      orientation === "vertical" && "h-full w-2.5 border-l border-l-transparent p-px",
+      orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent p-px",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx(ScrollAreaPrimitive.ScrollAreaThumb, { className: "bg-border relative flex-1 rounded-full" })
+  }
+));
+ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName;
+
+export { ScrollArea, ScrollBar };

package/dist/chunk-3UGU5TYP.js

@@ -0,0 +1,89 @@
+import { ChoiceField, choiceGroupClassName } from './chunk-CQBADMFG.js';
+import { cn } from './chunk-U7N2A7A3.js';
+import * as React from 'react';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import { Circle } from 'lucide-react';
+import { jsx } from 'react/jsx-runtime';
+
+var RadioGroupRoot = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  RadioGroupPrimitive.Root,
+  {
+    ref,
+    "data-slot": "radio-group",
+    className: cn("ui-choice-group", className),
+    ...props
+  }
+));
+RadioGroupRoot.displayName = RadioGroupPrimitive.Root.displayName;
+var RadioItem = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  RadioGroupPrimitive.Item,
+  {
+    ref,
+    "data-slot": "radio-group-item",
+    className: cn(
+      "ui-radio focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 shrink-0 shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx(
+      RadioGroupPrimitive.Indicator,
+      {
+        "data-slot": "radio-group-indicator",
+        className: "ui-choice-indicator",
+        children: /* @__PURE__ */ jsx(Circle, { className: "ui-radio-icon", "aria-hidden": "true" })
+      }
+    )
+  }
+));
+RadioItem.displayName = RadioGroupPrimitive.Item.displayName;
+function RadioGroupOptions({
+  value,
+  defaultValue,
+  onValueChange,
+  options,
+  orientation = "vertical",
+  disabled,
+  name,
+  className,
+  children
+}) {
+  const reactId = React.useId();
+  if (options && options.length > 0) {
+    return /* @__PURE__ */ jsx(
+      RadioGroupRoot,
+      {
+        value,
+        defaultValue,
+        onValueChange,
+        disabled,
+        name,
+        "data-orientation": orientation,
+        className: choiceGroupClassName(orientation, className),
+        children: options.map((opt, index) => {
+          const id = `${reactId}-${opt.value}-${index}`;
+          return /* @__PURE__ */ jsx(ChoiceField, { id, label: opt.label, description: opt.description, children: /* @__PURE__ */ jsx(RadioItem, { id, value: opt.value, disabled: opt.disabled }) }, opt.value);
+        })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    RadioGroupRoot,
+    {
+      value,
+      defaultValue,
+      onValueChange,
+      disabled,
+      name,
+      "data-orientation": orientation,
+      className: choiceGroupClassName(orientation, className),
+      children
+    }
+  );
+}
+var Radio = Object.assign(RadioItem, {
+  Root: RadioGroupRoot,
+  Group: RadioGroupOptions,
+  Item: RadioItem
+});
+
+export { Radio, RadioGroupOptions, RadioGroupRoot, RadioItem };