@godxjp/ui 6.0.0 → 6.0.1

package/dist/app/index.d.ts

@@ -0,0 +1,140 @@
+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-IobwLwaM.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-BNRJc9K0.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"];
+/** @deprecated Use `APP_TIMEZONE_PRESET` or `getAllIanaTimezones()`. */
+declare const APP_TIMEZONE_OPTIONS: 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;
+/** @deprecated Use `isValidIanaTimezone`. */
+declare function isKnownAppTimezone(value: string): value is AppTimezonePreset;
+/**
+ * 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_OPTIONS, 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, isKnownAppTimezone, isValidIanaTimezone, readStoredPreferences, resetAppRequestHeaders, resetIanaTimezoneCacheForTests, resolveDefaultDateFormat, resolveDefaultTimeFormat, resolveDefaultTimezone, resolveTimezoneForIntl, resolveTimezonePickerOptions, syncAppRequestHeaders, useAppContext, useAppDateFormat, useAppLocale, useAppTimeFormat, useAppTimezone, useDateTime, useFormatting, useOptionalAppContext, writeStoredPreferences };

package/dist/app/index.js

@@ -0,0 +1,38 @@
+import { useAppContext } from '../chunk-3F2AKYRD.js';
+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 } from '../chunk-3F2AKYRD.js';
+import { formatDate } from '../chunk-YFCQKO3B.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-YFCQKO3B.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 };

package/dist/app.prop-IobwLwaM.d.ts

@@ -0,0 +1,90 @@
+import { Locale } from 'date-fns';
+import { DayPickerProps } from 'react-day-picker';
+import { h as AppLocale, l as AppTimezoneDefault, k as AppTimezone, j as AppTimeFormat, g as AppDateFormat, i as AppRequestHeaders } from './types-mvzYGrma.js';
+import { C as ChildrenProp, a as ClassNameProp, D as DisabledProp, I as IdProp } from './shared.prop-BNRJc9K0.js';
+
+/** App shell prop types — @see docs/COMPONENTS.md#app */
+
+/** @see AppProvider */
+type AppProviderProp = {
+    children: ChildrenProp;
+    /** Initial locale when nothing in storage. Default: `vi`. */
+    defaultLocale?: AppLocale;
+    /** Fallback when a translation key is missing. Default: `en`. */
+    fallbackLocale?: AppLocale;
+    /** Initial timezone: IANA id, `browser`, or `system`. Default: `browser`. */
+    defaultTimezone?: AppTimezoneDefault;
+    /** Backend/system timezone when `defaultTimezone` is `system`. */
+    systemTimezone?: AppTimezone;
+    /** Initial clock format. `"locale"` derives from `defaultLocale`. Default: `"locale"`. */
+    defaultTimeFormat?: AppTimeFormat | "locale";
+    /** Initial date display format. `"locale"` derives from `defaultLocale`. Default: `"locale"`. */
+    defaultDateFormat?: AppDateFormat | "locale";
+    /**
+     * IANA ids shown in `TimezonePicker`.
+     * Omit for the full IANA list; set to restrict (e.g. `APP_TIMEZONE_PRESET`).
+     */
+    timezoneOptions?: readonly AppTimezone[];
+    /** localStorage key. Default: `godxjp.app`. */
+    storageKey?: string;
+    /** Persist user choices. Default: true. */
+    persist?: boolean;
+    onLocaleChange?: (locale: AppLocale) => void;
+    onTimezoneChange?: (timezone: AppTimezone) => void;
+    onTimeFormatChange?: (timeFormat: AppTimeFormat) => void;
+    onDateFormatChange?: (dateFormat: AppDateFormat) => void;
+};
+/** @see LocalePicker */
+type LocalePickerProp = {
+    className?: ClassNameProp;
+    disabled?: DisabledProp;
+    id?: IdProp;
+    /** Controlled value; default reads/writes AppProvider. */
+    value?: AppLocale;
+    onChange?: (locale: AppLocale) => void;
+};
+/** @see TimezonePicker */
+type TimezonePickerProp = {
+    className?: ClassNameProp;
+    disabled?: DisabledProp;
+    id?: IdProp;
+    value?: AppTimezone;
+    onChange?: (timezone: AppTimezone) => void;
+    /** Override AppProvider list; omit to use context or full IANA. */
+    options?: readonly AppTimezone[];
+};
+/** @see TimeFormatPicker */
+type TimeFormatPickerProp = {
+    className?: ClassNameProp;
+    disabled?: DisabledProp;
+    id?: IdProp;
+    value?: AppTimeFormat;
+    onChange?: (timeFormat: AppTimeFormat) => void;
+};
+/** @see DateFormatPicker */
+type DateFormatPickerProp = {
+    className?: ClassNameProp;
+    disabled?: DisabledProp;
+    id?: IdProp;
+    value?: AppDateFormat;
+    onChange?: (dateFormat: AppDateFormat) => void;
+};
+/** Value exposed by `useAppContext`. */
+type AppContextValue = {
+    locale: AppLocale;
+    fallbackLocale: AppLocale;
+    timezone: AppTimezone;
+    timeFormat: AppTimeFormat;
+    dateFormat: AppDateFormat;
+    dateFnsLocale: Locale;
+    dayPickerLocale: NonNullable<DayPickerProps["locale"]>;
+    requestHeaders: AppRequestHeaders;
+    /** Configured picker list; `undefined` → full IANA in TimezonePicker. */
+    timezoneOptions?: readonly AppTimezone[];
+    setLocale: (locale: AppLocale) => void;
+    setTimezone: (timezone: AppTimezone) => void;
+    setTimeFormat: (timeFormat: AppTimeFormat) => void;
+    setDateFormat: (dateFormat: AppDateFormat) => void;
+};
+
+export type { AppContextValue as A, DateFormatPickerProp as D, LocalePickerProp as L, TimeFormatPickerProp as T, AppProviderProp as a, TimezonePickerProp as b };

package/dist/checkbox-NkFkqsQ8.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { c as CheckboxGroupProp } from './data-entry.prop-BEGA1lTq.js';
+
+declare function CheckboxGroup({ value: controlledValue, defaultValue, onChange, options, orientation, disabled, name, className, children, }: CheckboxGroupProp): react_jsx_runtime.JSX.Element;
+
+/** Checkbox — dùng standalone hoặc `Checkbox.Group` với `options` (Ant Design style). */
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>> & {
+    Group: typeof CheckboxGroup;
+};
+
+export { Checkbox as C, CheckboxGroup as a };

package/dist/chunk-2XW7J3EI.js

@@ -0,0 +1,226 @@
+import { normalizeTreeOptions, collectAllExpandableKeys, filterVisibleTree, flattenVisibleTree, findNodeByValue, reactNodeText, getDescendantValues } from './chunk-SMLKNECP.js';
+import { Checkbox } from './chunk-E76QIYSY.js';
+import { Command, CommandInput } from './chunk-V6UWJKZF.js';
+import { Popover, PopoverTrigger, PopoverContent } from './chunk-DY5C44UP.js';
+import { ScrollArea } from './chunk-3KPEZ5CF.js';
+import { Button } from './chunk-HJEBRCXL.js';
+import { useTranslation } from './chunk-3F2AKYRD.js';
+import { cn } from './chunk-U7N2A7A3.js';
+import * as React from 'react';
+import { X, ChevronsUpDown, ChevronDown, ChevronRight } from 'lucide-react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/components/data-entry/tree-select-strategy.ts
+var SHOW_CHILD = "SHOW_CHILD";
+var SHOW_PARENT = "SHOW_PARENT";
+var SHOW_ALL = "SHOW_ALL";
+function toArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function displayValues(values, options, showCheckedStrategy, treeCheckStrictly) {
+  if (treeCheckStrictly || showCheckedStrategy === SHOW_ALL) return values;
+  if (showCheckedStrategy === SHOW_PARENT) {
+    const filtered = values.filter((v) => {
+      const node = findNodeByValue(options, v);
+      if (!node?.children?.length) return true;
+      const desc = getDescendantValues(node).slice(1);
+      return !desc.every((d) => values.includes(d));
+    });
+    return filtered.length ? filtered : values;
+  }
+  return values.filter((v) => {
+    const node = findNodeByValue(options, v);
+    return !node?.children?.length;
+  });
+}
+function TreeSelectRoot({
+  treeData: treeDataProp,
+  value,
+  defaultValue,
+  onChange,
+  multiple,
+  treeCheckable,
+  treeCheckStrictly,
+  showSearch,
+  showCheckedStrategy = SHOW_CHILD,
+  treeDefaultExpandAll,
+  placeholder,
+  disabled,
+  allowClear = true,
+  className,
+  id,
+  fieldNames
+}) {
+  const { t } = useTranslation();
+  const options = React.useMemo(
+    () => normalizeTreeOptions(treeDataProp, fieldNames),
+    [treeDataProp, fieldNames]
+  );
+  const checkable = treeCheckable ?? multiple;
+  const [open, setOpen] = React.useState(false);
+  const [search, setSearch] = React.useState("");
+  const [expandedKeys, setExpandedKeys] = React.useState(
+    () => new Set(treeDefaultExpandAll ? collectAllExpandableKeys(options) : [])
+  );
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React.useState(() => toArray(defaultValue));
+  const selected = isControlled ? toArray(value) : internal;
+  const resolvedPlaceholder = placeholder ?? t("dataEntry.treeSelect.placeholder");
+  const visible = React.useMemo(() => {
+    if (showSearch && search.trim()) return filterVisibleTree(options, search);
+    return flattenVisibleTree(options, expandedKeys);
+  }, [options, expandedKeys, search, showSearch]);
+  const commit = (next) => {
+    if (!isControlled) setInternal(next);
+    onChange?.(checkable || multiple ? next : next[0] ?? void 0);
+  };
+  const toggleExpand = (key) => {
+    setExpandedKeys((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  };
+  const toggleSelect = (node) => {
+    if (node.disabled) return;
+    const key = node.value;
+    if (!checkable && !multiple) {
+      commit([key]);
+      setOpen(false);
+      return;
+    }
+    const isOn = selected.includes(key);
+    let next;
+    if (treeCheckStrictly) {
+      next = isOn ? selected.filter((v) => v !== key) : [...selected, key];
+    } else {
+      const related = getDescendantValues(node);
+      next = isOn ? selected.filter((v) => !related.includes(v)) : [.../* @__PURE__ */ new Set([...selected, ...related])];
+    }
+    commit(next);
+  };
+  const displayKeys = displayValues(selected, options, showCheckedStrategy, treeCheckStrictly);
+  const displayLabel = displayKeys.map((v) => {
+    const label = findNodeByValue(options, v)?.label;
+    return label ? reactNodeText(label) : v;
+  }).join(", ");
+  const clearValue = (e) => {
+    e.stopPropagation();
+    commit([]);
+  };
+  return /* @__PURE__ */ jsxs(Popover, { open, onOpenChange: setOpen, children: [
+    /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+      Button,
+      {
+        id,
+        type: "button",
+        variant: "outline",
+        role: "combobox",
+        "aria-expanded": open,
+        disabled,
+        className: cn(
+          "w-full justify-between font-normal",
+          !displayKeys.length && "text-muted-foreground",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "truncate", children: displayKeys.length ? displayLabel : resolvedPlaceholder }),
+          /* @__PURE__ */ jsxs("span", { className: "ml-2 flex shrink-0 items-center gap-1", children: [
+            allowClear && displayKeys.length > 0 && !disabled && /* @__PURE__ */ jsx(
+              X,
+              {
+                className: "size-4 opacity-50 hover:opacity-100",
+                "aria-hidden": "true",
+                onClick: clearValue
+              }
+            ),
+            /* @__PURE__ */ jsx(ChevronsUpDown, { className: "size-4 opacity-50", "aria-hidden": "true" })
+          ] })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(PopoverContent, { className: "w-[var(--radix-popover-trigger-width)] p-0", align: "start", children: [
+      showSearch && /* @__PURE__ */ jsx("div", { className: "border-b p-2", children: /* @__PURE__ */ jsx(Command, { shouldFilter: false, children: /* @__PURE__ */ jsx(
+        CommandInput,
+        {
+          placeholder: t("dataEntry.treeSelect.searchPlaceholder"),
+          value: search,
+          onValueChange: setSearch
+        }
+      ) }) }),
+      /* @__PURE__ */ jsx(ScrollArea, { className: "max-h-[min(300px,50vh)]", children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          role: "tree",
+          "aria-multiselectable": Boolean(checkable) || Boolean(multiple),
+          className: "p-1",
+          children: visible.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground py-6 text-center text-sm", children: t("dataEntry.treeSelect.empty") }) : visible.map(({ node, depth, hasChildren }) => {
+            const expanded = expandedKeys.has(node.value);
+            const isSelected = selected.includes(node.value);
+            return /* @__PURE__ */ jsxs(
+              "div",
+              {
+                role: "treeitem",
+                "aria-expanded": hasChildren ? expanded : void 0,
+                "aria-selected": isSelected,
+                className: cn(
+                  "flex items-center rounded-sm py-1.5 pr-2 text-sm outline-none",
+                  "hover:bg-accent hover:text-accent-foreground",
+                  isSelected && "bg-accent/60",
+                  node.disabled && "pointer-events-none opacity-50"
+                ),
+                style: { paddingLeft: `${depth * 1.25 + 0.5}rem` },
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      tabIndex: -1,
+                      "aria-label": expanded ? t("dataEntry.treeSelect.collapse") : t("dataEntry.treeSelect.expand"),
+                      className: cn(
+                        "mr-1 flex size-5 shrink-0 items-center justify-center rounded-sm",
+                        !hasChildren && "invisible"
+                      ),
+                      onClick: () => toggleExpand(node.value),
+                      children: expanded ? /* @__PURE__ */ jsx(ChevronDown, { className: "size-4", "aria-hidden": "true" }) : /* @__PURE__ */ jsx(ChevronRight, { className: "size-4", "aria-hidden": "true" })
+                    }
+                  ),
+                  checkable ? /* @__PURE__ */ jsxs("label", { className: "flex flex-1 cursor-pointer items-center gap-2", children: [
+                    /* @__PURE__ */ jsx(
+                      Checkbox,
+                      {
+                        checked: isSelected,
+                        disabled: Boolean(node.disabled) || Boolean(node.disableCheckbox),
+                        onCheckedChange: () => toggleSelect(node)
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("span", { className: "truncate", children: node.label })
+                  ] }) : /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      className: "flex-1 truncate text-left",
+                      disabled: node.disabled,
+                      onClick: () => toggleSelect(node),
+                      children: node.label
+                    }
+                  )
+                ]
+              },
+              node.value
+            );
+          })
+        }
+      ) })
+    ] })
+  ] });
+}
+var TreeSelect = Object.assign(TreeSelectRoot, {
+  SHOW_CHILD,
+  SHOW_PARENT,
+  SHOW_ALL
+});
+
+export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeSelect };