@godxjp/ui 13.9.3 → 13.11.0

package/dist/components/data-entry/toggle-group.d.ts

@@ -0,0 +1 @@
+export { ToggleGroup, ToggleGroupItem } from "../ui/toggle-group";

package/dist/components/data-entry/toggle-group.js

@@ -0,0 +1,5 @@
+import { ToggleGroup, ToggleGroupItem } from "../ui/toggle-group";
+export {
+  ToggleGroup,
+  ToggleGroupItem
+};

package/dist/components/data-entry/toggle.d.ts

@@ -0,0 +1,2 @@
+export { Toggle } from "../ui/toggle";
+export type { ToggleProps } from "../ui/toggle";

package/dist/components/data-entry/toggle.js

@@ -0,0 +1,4 @@
+import { Toggle } from "../ui/toggle";
+export {
+  Toggle
+};

package/dist/components/data-entry/transfer.d.ts

@@ -1,20 +1,3 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { t as TransferProp } from '../../data-entry.prop-BSUaseKh.js';
-export { s as TransferItemProp } from '../../data-entry.prop-BSUaseKh.js';
-import '@radix-ui/react-checkbox';
-import '@radix-ui/react-radio-group';
-import '@radix-ui/react-slider';
-import '@radix-ui/react-switch';
-import 'react-day-picker';
-import 'react';
-import '../../shared.prop-BvMSLFJ6.js';
-import '../../content.prop-DrV_zDy-.js';
-import '../../layout.prop-CXvl2rVR.js';
-import '../../interaction.prop-DD46aTro.js';
-import '../../data.prop-D0UEEczj.js';
-import '../../layout.prop-fCz-Vlie.js';
-import '../../navigation.prop-CXDaVNaR.js';
-
-declare function Transfer({ dataSource, targetKeys, onValueChange, titles, showSearch, oneWay, disabled, className, selectedKeys: selectedKeysProp, onSelectChange, }: TransferProp): react_jsx_runtime.JSX.Element;
-
-export { Transfer, TransferProp, TransferProp as TransferProps };
+import type { TransferProp } from "../../props/components/data-entry.prop";
+export type { TransferProp, TransferProp as TransferProps, TransferItemProp, } from "../../props/components/data-entry.prop";
+export declare function Transfer({ dataSource, targetKeys, onValueChange, titles, showSearch, oneWay, disabled, className, selectedKeys: selectedKeysProp, onSelectChange, }: TransferProp): import("react/jsx-runtime").JSX.Element;

package/dist/components/data-entry/transfer.js

@@ -1,13 +1,193 @@
-export { Transfer } from '../../chunk-WY3VYUMX.js';
-import '../../chunk-LVLPNKJP.js';
-import '../../chunk-K24AQV4R.js';
-import '../../chunk-SMLKNECP.js';
-import '../../chunk-BE6GJGKJ.js';
-import '../../chunk-44YRPSZ7.js';
-import '../../chunk-XBFUROAY.js';
-import '../../chunk-J2DEWIYY.js';
-import '../../chunk-7PWBC4BY.js';
-import '../../chunk-B6S6LTWT.js';
-import '../../chunk-5732TWQF.js';
-import '../../chunk-LFW37FGG.js';
-import '../../chunk-U7N2A7A3.js';
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import { useTranslation } from "../../i18n/use-translation";
+import { cn } from "../../lib/utils";
+import { Button } from "../general/button";
+import { ScrollArea } from "../data-display/scroll-area";
+import { Checkbox } from "./checkbox";
+import { SearchInput } from "./search-input";
+import { reactNodeText } from "./tree-utils";
+function TransferPanel({
+  title,
+  items,
+  selectedKeys,
+  onSelectChange,
+  onSelectAll,
+  showSearch,
+  disabled,
+  searchPlaceholder,
+  emptyText,
+  direction
+}) {
+  const { t } = useTranslation();
+  const titleId = React.useId();
+  const [query, setQuery] = React.useState("");
+  const filtered = React.useMemo(() => {
+    const q = query.trim().toLowerCase();
+    if (!q) return items;
+    return items.filter((item) => {
+      const titleMatch = reactNodeText(item.title).toLowerCase().includes(q);
+      const descMatch = item.description ? reactNodeText(item.description).toLowerCase().includes(q) : false;
+      return titleMatch || descMatch;
+    });
+  }, [items, query]);
+  const enabledItems = filtered.filter((i) => !i.disabled);
+  const allChecked = enabledItems.length > 0 && enabledItems.every((i) => selectedKeys.includes(i.key));
+  const indeterminate = !allChecked && enabledItems.some((i) => selectedKeys.includes(i.key));
+  const toggleKey = (key, checked) => {
+    onSelectChange(checked ? [...selectedKeys, key] : selectedKeys.filter((k) => k !== key));
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "bg-background flex min-h-[14rem] flex-1 flex-col rounded-md border", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between border-b px-3 py-2 text-sm", children: [
+      /* @__PURE__ */ jsxs("label", { className: "flex cursor-pointer items-center gap-2 font-medium", children: [
+        /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            checked: allChecked ? true : indeterminate ? "indeterminate" : false,
+            disabled: Boolean(disabled) || enabledItems.length === 0,
+            onCheckedChange: (v) => onSelectAll(v === true),
+            "aria-label": direction === "left" ? t("dataEntry.transfer.selectAllSource") : t("dataEntry.transfer.selectAllTarget")
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { id: titleId, children: title })
+      ] }),
+      /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground text-xs", children: [
+        selectedKeys.length,
+        "/",
+        filtered.length
+      ] })
+    ] }),
+    showSearch && /* @__PURE__ */ jsx("div", { className: "border-b p-2", children: /* @__PURE__ */ jsx(
+      SearchInput,
+      {
+        onSearch: setQuery,
+        placeholder: searchPlaceholder,
+        ariaLabel: searchPlaceholder,
+        debounce: 0,
+        className: disabled ? "pointer-events-none opacity-50" : void 0
+      }
+    ) }),
+    /* @__PURE__ */ jsx(ScrollArea, { className: "flex-1", children: /* @__PURE__ */ jsx("ul", { className: "p-1", role: "group", "aria-labelledby": titleId, children: filtered.length === 0 ? /* @__PURE__ */ jsx("li", { className: "text-muted-foreground py-8 text-center text-sm", children: emptyText }) : filtered.map((item) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs(
+      "label",
+      {
+        className: cn(
+          "flex cursor-pointer items-start gap-2 rounded-sm px-2 py-2 text-sm",
+          "hover:bg-accent hover:text-accent-foreground",
+          item.disabled && "pointer-events-none opacity-50"
+        ),
+        children: [
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              checked: selectedKeys.includes(item.key),
+              disabled: Boolean(disabled) || Boolean(item.disabled),
+              onCheckedChange: (v) => toggleKey(item.key, v === true),
+              className: "mt-0.5"
+            }
+          ),
+          /* @__PURE__ */ jsxs("span", { className: "min-w-0 flex-1", children: [
+            /* @__PURE__ */ jsx("span", { className: "block truncate font-medium", children: item.title }),
+            item.description && /* @__PURE__ */ jsx("span", { className: "text-muted-foreground block truncate text-xs", children: item.description })
+          ] })
+        ]
+      }
+    ) }, item.key)) }) })
+  ] });
+}
+function Transfer({
+  dataSource,
+  targetKeys,
+  onValueChange,
+  titles,
+  showSearch,
+  oneWay,
+  disabled,
+  className,
+  selectedKeys: selectedKeysProp,
+  onSelectChange
+}) {
+  const { t } = useTranslation();
+  const [internalSelected, setInternalSelected] = React.useState([[], []]);
+  const selected = selectedKeysProp ?? internalSelected;
+  const sourceItems = dataSource.filter((item) => !targetKeys.includes(item.key));
+  const targetItems = dataSource.filter((item) => targetKeys.includes(item.key));
+  const setSelected = (side, keys) => {
+    const next = side === 0 ? [keys, selected[1]] : [selected[0], keys];
+    if (selectedKeysProp) onSelectChange?.(next[0], next[1]);
+    else setInternalSelected(next);
+  };
+  const move = (direction) => {
+    const fromSide = direction === "right" ? 0 : 1;
+    const keys = selected[fromSide];
+    if (!keys.length) return;
+    const nextTarget = direction === "right" ? [...targetKeys, ...keys.filter((k) => !targetKeys.includes(k))] : targetKeys.filter((k) => !keys.includes(k));
+    onValueChange?.(nextTarget, direction, keys);
+    const cleared = fromSide === 0 ? [[], selected[1]] : [selected[0], []];
+    if (selectedKeysProp) onSelectChange?.(cleared[0], cleared[1]);
+    else setInternalSelected(cleared);
+  };
+  const leftTitle = titles?.[0] ?? t("dataEntry.transfer.source");
+  const rightTitle = titles?.[1] ?? t("dataEntry.transfer.target");
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex flex-wrap items-stretch gap-3", className), children: [
+    /* @__PURE__ */ jsx(
+      TransferPanel,
+      {
+        direction: "left",
+        title: leftTitle,
+        items: sourceItems,
+        selectedKeys: selected[0],
+        onSelectChange: (keys) => setSelected(0, keys),
+        onSelectAll: (checked) => setSelected(0, checked ? sourceItems.filter((i) => !i.disabled).map((i) => i.key) : []),
+        showSearch,
+        disabled,
+        searchPlaceholder: t("dataEntry.transfer.searchPlaceholder"),
+        emptyText: t("dataEntry.transfer.empty")
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-col justify-center gap-2", children: [
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          size: "icon",
+          variant: "outline",
+          disabled: Boolean(disabled) || selected[0].length === 0,
+          "aria-label": t("dataEntry.transfer.moveRight"),
+          onClick: () => move("right"),
+          children: /* @__PURE__ */ jsx(ChevronRight, { className: "size-4", "aria-hidden": "true" })
+        }
+      ),
+      !oneWay && /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          size: "icon",
+          variant: "outline",
+          disabled: Boolean(disabled) || selected[1].length === 0,
+          "aria-label": t("dataEntry.transfer.moveLeft"),
+          onClick: () => move("left"),
+          children: /* @__PURE__ */ jsx(ChevronLeft, { className: "size-4", "aria-hidden": "true" })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      TransferPanel,
+      {
+        direction: "right",
+        title: rightTitle,
+        items: targetItems,
+        selectedKeys: selected[1],
+        onSelectChange: (keys) => setSelected(1, keys),
+        onSelectAll: (checked) => setSelected(1, checked ? targetItems.filter((i) => !i.disabled).map((i) => i.key) : []),
+        showSearch,
+        disabled,
+        searchPlaceholder: t("dataEntry.transfer.searchPlaceholder"),
+        emptyText: t("dataEntry.transfer.empty")
+      }
+    )
+  ] });
+}
+export {
+  Transfer
+};

package/dist/components/data-entry/tree-select-strategy.d.ts

@@ -0,0 +1,5 @@
+/** Ant Design `showCheckedStrategy` equivalents for TreeSelect. */
+export declare const SHOW_CHILD: "SHOW_CHILD";
+export declare const SHOW_PARENT: "SHOW_PARENT";
+export declare const SHOW_ALL: "SHOW_ALL";
+export type ShowCheckedStrategy = typeof SHOW_CHILD | typeof SHOW_PARENT | typeof SHOW_ALL;

package/dist/components/data-entry/tree-select-strategy.js

@@ -0,0 +1,8 @@
+const SHOW_CHILD = "SHOW_CHILD";
+const SHOW_PARENT = "SHOW_PARENT";
+const SHOW_ALL = "SHOW_ALL";
+export {
+  SHOW_ALL,
+  SHOW_CHILD,
+  SHOW_PARENT
+};

package/dist/components/data-entry/tree-select.d.ts

@@ -1,29 +1,9 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { w as TreeSelectProp } from '../../data-entry.prop-BSUaseKh.js';
-import '@radix-ui/react-checkbox';
-import '@radix-ui/react-radio-group';
-import '@radix-ui/react-slider';
-import '@radix-ui/react-switch';
-import 'react-day-picker';
-import 'react';
-import '../../shared.prop-BvMSLFJ6.js';
-import '../../content.prop-DrV_zDy-.js';
-import '../../layout.prop-CXvl2rVR.js';
-import '../../interaction.prop-DD46aTro.js';
-import '../../data.prop-D0UEEczj.js';
-import '../../layout.prop-fCz-Vlie.js';
-import '../../navigation.prop-CXDaVNaR.js';
-
-/** Ant Design `showCheckedStrategy` equivalents for TreeSelect. */
-declare const SHOW_CHILD: "SHOW_CHILD";
-declare const SHOW_PARENT: "SHOW_PARENT";
-declare const SHOW_ALL: "SHOW_ALL";
-
-declare function TreeSelectRoot({ treeData: treeDataProp, value, defaultValue, onValueChange, multiple, treeCheckable, treeCheckStrictly, showSearch, showCheckedStrategy, treeDefaultExpandAll, placeholder, disabled, allowClear, className, id, fieldNames, }: TreeSelectProp): react_jsx_runtime.JSX.Element;
-declare const TreeSelect: typeof TreeSelectRoot & {
+import type { TreeSelectProp } from "../../props/components/data-entry.prop";
+export type { TreeSelectProp, TreeSelectProp as TreeSelectProps, } from "../../props/components/data-entry.prop";
+export { SHOW_CHILD, SHOW_PARENT, SHOW_ALL } from "./tree-select-strategy";
+declare function TreeSelectRoot({ treeData: treeDataProp, value, defaultValue, onValueChange, multiple, treeCheckable, treeCheckStrictly, showSearch, showCheckedStrategy, treeDefaultExpandAll, placeholder, disabled, allowClear, className, id, fieldNames, }: TreeSelectProp): import("react/jsx-runtime").JSX.Element;
+export declare const TreeSelect: typeof TreeSelectRoot & {
     SHOW_CHILD: "SHOW_CHILD";
     SHOW_PARENT: "SHOW_PARENT";
     SHOW_ALL: "SHOW_ALL";
 };
-
-export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeSelect, TreeSelectProp, TreeSelectProp as TreeSelectProps };

package/dist/components/data-entry/tree-select.js

@@ -1,13 +1,299 @@
-export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeSelect } from '../../chunk-EG3RDM6F.js';
-import '../../chunk-SMLKNECP.js';
-import '../../chunk-2RGPEFAW.js';
-import '../../chunk-BE6GJGKJ.js';
-import '../../chunk-44YRPSZ7.js';
-import '../../chunk-XBFUROAY.js';
-import '../../chunk-DY5C44UP.js';
-import '../../chunk-J2DEWIYY.js';
-import '../../chunk-B4K4BXEF.js';
-import '../../chunk-7PWBC4BY.js';
-import '../../chunk-B6S6LTWT.js';
-import '../../chunk-5732TWQF.js';
-import '../../chunk-U7N2A7A3.js';
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { ChevronDown, ChevronRight, ChevronsUpDown, X } from "lucide-react";
+import { useTranslation } from "../../i18n/use-translation";
+import { cn } from "../../lib/utils";
+import { controlOpenRingClass } from "../../lib/control-styles";
+import { Button } from "../general/button";
+import { Popover, PopoverContent, PopoverTrigger } from "../data-display/popover";
+import { ScrollArea } from "../data-display/scroll-area";
+import { Checkbox } from "./checkbox";
+import { Command, CommandInput } from "./command";
+import {
+  collectAllExpandableKeys,
+  filterVisibleTree,
+  findNodeByValue,
+  flattenVisibleTree,
+  getDescendantValues,
+  normalizeTreeOptions,
+  reactNodeText
+} from "./tree-utils";
+import { SHOW_CHILD, SHOW_PARENT, SHOW_ALL } from "./tree-select-strategy";
+import { SHOW_CHILD as SHOW_CHILD2, SHOW_PARENT as SHOW_PARENT2, SHOW_ALL as SHOW_ALL2 } from "./tree-select-strategy";
+function toArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function displayValues(values, options, showCheckedStrategy, treeCheckStrictly) {
+  if (treeCheckStrictly || showCheckedStrategy === SHOW_ALL2) return values;
+  if (showCheckedStrategy === SHOW_PARENT2) {
+    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,
+  onValueChange,
+  multiple,
+  treeCheckable,
+  treeCheckStrictly,
+  showSearch,
+  showCheckedStrategy = SHOW_CHILD2,
+  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 [activeKey, setActiveKey] = React.useState(null);
+  const treeItemRefs = React.useRef(/* @__PURE__ */ new Map());
+  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);
+    onValueChange?.(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([]);
+  };
+  const rovingKey = (activeKey && visible.some(({ node }) => node.value === activeKey) ? activeKey : null) ?? visible[0]?.node.value ?? null;
+  React.useEffect(() => {
+    if (!open || !activeKey) return;
+    treeItemRefs.current.get(activeKey)?.focus();
+  }, [activeKey, open, visible]);
+  const focusByOffset = (currentValue, delta) => {
+    const index = visible.findIndex(({ node }) => node.value === currentValue);
+    if (index === -1) return;
+    const next = visible[index + delta];
+    if (next) setActiveKey(next.node.value);
+  };
+  const onTreeItemKeyDown = (event, node, hasChildren, expanded) => {
+    switch (event.key) {
+      case "ArrowDown": {
+        event.preventDefault();
+        focusByOffset(node.value, 1);
+        break;
+      }
+      case "ArrowUp": {
+        event.preventDefault();
+        focusByOffset(node.value, -1);
+        break;
+      }
+      case "ArrowRight": {
+        event.preventDefault();
+        if (hasChildren && !expanded) {
+          toggleExpand(node.value);
+        } else if (hasChildren && expanded) {
+          focusByOffset(node.value, 1);
+        }
+        break;
+      }
+      case "ArrowLeft": {
+        event.preventDefault();
+        if (hasChildren && expanded) {
+          toggleExpand(node.value);
+        }
+        break;
+      }
+      case "Enter":
+      case " ": {
+        event.preventDefault();
+        toggleSelect(node);
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  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",
+          controlOpenRingClass,
+          !displayKeys.length && "text-muted-foreground",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "truncate", children: displayKeys.length ? displayLabel : resolvedPlaceholder }),
+          /* @__PURE__ */ jsxs("span", { className: "ms-2 flex shrink-0 items-center gap-1", children: [
+            allowClear && displayKeys.length > 0 && !disabled && /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                "aria-label": t("dataEntry.treeSelect.clear"),
+                className: "flex size-4 items-center justify-center rounded-sm opacity-50 hover:opacity-100 focus-visible:opacity-100",
+                onClick: clearValue,
+                children: /* @__PURE__ */ jsx(X, { className: "size-4", "aria-hidden": "true" })
+              }
+            ),
+            /* @__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",
+              {
+                ref: (el) => {
+                  treeItemRefs.current.set(node.value, el);
+                },
+                role: "treeitem",
+                tabIndex: node.disabled ? -1 : rovingKey === node.value ? 0 : -1,
+                "aria-expanded": hasChildren ? expanded : void 0,
+                "aria-selected": isSelected,
+                onFocus: () => setActiveKey(node.value),
+                onKeyDown: (event) => onTreeItemKeyDown(event, node, hasChildren, expanded),
+                className: cn(
+                  "flex items-center rounded-sm py-1.5 pe-2 text-sm outline-none",
+                  "hover:bg-accent hover:text-accent-foreground",
+                  "focus-visible:ring-ring focus-visible:ring-2 focus-visible:ring-offset-1",
+                  isSelected && "bg-accent/60",
+                  node.disabled && "pointer-events-none opacity-50"
+                ),
+                style: { paddingInlineStart: `${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(
+                        "me-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,
+                        tabIndex: -1,
+                        disabled: Boolean(node.disabled) || Boolean(node.disableCheckbox),
+                        onCheckedChange: () => toggleSelect(node)
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("span", { className: "truncate", children: node.label })
+                  ] }) : /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      tabIndex: -1,
+                      className: "flex-1 truncate text-start",
+                      disabled: node.disabled,
+                      onClick: () => toggleSelect(node),
+                      children: node.label
+                    }
+                  )
+                ]
+              },
+              node.value
+            );
+          })
+        }
+      ) })
+    ] })
+  ] });
+}
+const TreeSelect = Object.assign(TreeSelectRoot, {
+  SHOW_CHILD: SHOW_CHILD2,
+  SHOW_PARENT: SHOW_PARENT2,
+  SHOW_ALL: SHOW_ALL2
+});
+export {
+  SHOW_ALL,
+  SHOW_CHILD,
+  SHOW_PARENT,
+  TreeSelect
+};

package/dist/components/data-entry/tree-utils.d.ts

@@ -0,0 +1,48 @@
+import type * as React from "react";
+/** Normalized tree node — Ant Design `treeData` / Cascader `options`. */
+export type TreeOption = {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    /** When false with `loadData`, shows expand affordance */
+    isLeaf?: boolean;
+    children?: TreeOption[];
+};
+export type TreeFieldNames = {
+    label?: string;
+    value?: string;
+    children?: string;
+};
+export type NormalizedTreeOption = TreeOption & {
+    children?: NormalizedTreeOption[];
+};
+type RawTreeNode = Record<string, unknown>;
+export declare function reactNodeText(value: React.ReactNode): string;
+export declare function normalizeTreeOptions(nodes: RawTreeNode[] | undefined, fieldNames?: TreeFieldNames): NormalizedTreeOption[];
+export declare function getNodeByPath(options: NormalizedTreeOption[], path: string[]): NormalizedTreeOption[];
+export declare function getOptionsAtPath(options: NormalizedTreeOption[], path: string[]): NormalizedTreeOption[];
+export declare function formatPathLabels(chain: NormalizedTreeOption[], separator?: string): string;
+export type TreePath = {
+    path: string[];
+    labels: string[];
+};
+export declare function collectLeafPaths(options: NormalizedTreeOption[], prefix?: string[], root?: NormalizedTreeOption[]): TreePath[];
+export declare function collectAllPaths(options: NormalizedTreeOption[], prefix?: string[], root?: NormalizedTreeOption[]): TreePath[];
+export declare function pathKey(path: string[]): string;
+export declare function pathsEqual(a: string[], b: string[]): boolean;
+export declare function filterTreeOptions(options: NormalizedTreeOption[], query: string, filter?: (query: string, path: NormalizedTreeOption[]) => boolean): TreePath[];
+export declare function getDescendantValues(node: NormalizedTreeOption): string[];
+export declare function flattenVisibleTree(options: NormalizedTreeOption[], expandedKeys: Set<string>, depth?: number): {
+    node: NormalizedTreeOption;
+    depth: number;
+    hasChildren: boolean;
+}[];
+export declare function filterVisibleTree(options: NormalizedTreeOption[], query: string): {
+    node: NormalizedTreeOption;
+    depth: number;
+    hasChildren: boolean;
+}[];
+export declare function collectAllExpandableKeys(options: NormalizedTreeOption[]): string[];
+export declare function findNodeByValue(options: NormalizedTreeOption[], value: string): NormalizedTreeOption | undefined;
+export {};