@cube-dev/ui-kit 0.0.0-canary-ad23b00 → 0.0.0-canary-c76c00e

package/dist/components/content/Result/Result.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { extractStyles } from "../../../utils/styles.js";
 import { mergeProps } from "../../../utils/react/mergeProps.js";
 import { wrapNodeIfPlain } from "../../../utils/react/wrapNodeIfPlain.js";

package/dist/components/content/Skeleton/Skeleton.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { Space } from "../../layout/Space.js";
 import { Grid } from "../../layout/Grid.js";
 import { Flow } from "../../layout/Flow.js";

package/dist/components/content/Tag/Tag.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { _Item } from "../Item/Item.js";
 import { CloseIcon } from "../../../icons/CloseIcon.js";
 import { tasty } from "@tenphi/tasty";

package/dist/components/content/Text.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { useSlotProps } from "../../utils/react/Slots.js";
 import { BASE_STYLES, COLOR_STYLES, TEXT_STYLES, filterBaseProps, tasty } from "@tenphi/tasty";

package/dist/components/content/TextItem/TextItem.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { extractStyles } from "../../../utils/styles.js";
 import { TEXT_PROP_MAP, _Text } from "../Text.js";
 import { highlightText } from "../highlightText.js";

package/dist/components/content/Title.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { useSlotProps } from "../../utils/react/Slots.js";
 import { TEXT_PROP_MAP } from "./Text.js";

package/dist/components/content/Tree/Tree.js

@@ -1,8 +1,10 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { extractStyles } from "../../../utils/styles.js";
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
+import { mergeRefs } from "../../../utils/react/useCombinedRefs.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { TreeElement } from "./styled.js";
+import { buildTreeIndex } from "./tree-index.js";
 import { TreeNode } from "./TreeNode.js";
 import { useCheckboxTree } from "./use-checkbox-tree.js";
 import { useLoadData } from "./use-load-data.js";
@@ -34,18 +36,6 @@ function renderItem(node) {
 		children: node.title
 	}, node.key);
 }
-/** Walk the treeData and build a flat `key -> node` index. */
-function buildNodesByKey(treeData) {
-	const map = /* @__PURE__ */ new Map();
-	const visit = (nodes) => {
-		for (const node of nodes) {
-			map.set(node.key, node);
-			if (node.children) visit(node.children);
-		}
-	};
-	visit(treeData);
-	return map;
-}
 /** Walk the treeData and collect all keys whose `isDisabled === true`. */
 function collectDisabledKeys(treeData, treeIsDisabled) {
 	const keys = [];
@@ -59,20 +49,6 @@ function collectDisabledKeys(treeData, treeIsDisabled) {
 	return keys;
 }
 /**
-* Map `key -> parentKey` (used for `autoExpandParent`).
-*/
-function buildParentOf(treeData) {
-	const parentOf = /* @__PURE__ */ new Map();
-	const visit = (nodes, parent) => {
-		for (const node of nodes) {
-			parentOf.set(node.key, parent);
-			if (node.children) visit(node.children, node.key);
-		}
-	};
-	visit(treeData, null);
-	return parentOf;
-}
-/**
 * Expand the supplied keys with all of their ancestors. Used when
 * `autoExpandParent` is `true` so that the consumer can pass deep keys
 * (e.g. search matches) without having to manually walk parents.
@@ -106,8 +82,14 @@ function TreeBase(props, ref) {
 	const { treeData, isCheckable = false, isSelectable, selectionMode: selectionModeProp, blockNode = false, isDisabled = false, defaultExpandedKeys, expandedKeys, autoExpandParent = false, defaultCheckedKeys, checkedKeys, defaultSelectedKeys, selectedKeys, height, loadData, onExpand, onCheck, onSelect, rowStyles, qa, ...otherProps } = props;
 	const baseStyles = extractStyles(otherProps, OUTER_STYLES);
 	const treeRef = useRef(null);
-	const nodesByKey = useMemo(() => buildNodesByKey(treeData), [treeData]);
-	const parentOf = useMemo(() => buildParentOf(treeData), [treeData]);
+	/**
+	* Single tree walk that produces `byKey`, `parentOf`, and `childrenOf`.
+	* Shared with `useCheckboxTree` so a `treeData` change triggers exactly
+	* one walk (instead of three) for these three maps.
+	*/
+	const treeIndex = useMemo(() => buildTreeIndex(treeData), [treeData]);
+	const nodesByKey = treeIndex.byKey;
+	const parentOf = treeIndex.parentOf;
 	const disabledKeys = useMemo(() => collectDisabledKeys(treeData, isDisabled), [treeData, isDisabled]);
 	const selectionMode = resolveSelectionMode(selectionModeProp, isSelectable);
 	/**
@@ -120,8 +102,20 @@ function TreeBase(props, ref) {
 		expandedKeys,
 		parentOf
 	]);
+	/**
+	* Mirror the same logic for the uncontrolled `defaultExpandedKeys`.
+	* `useTreeState` only reads it on mount, but we still need to expand
+	* ancestors so consumers passing a deep key (e.g. a search match) get
+	* the same behaviour as in the controlled mode.
+	*/
+	const effectiveDefaultExpandedKeys = useMemo(() => autoExpandParent ? expandWithParents(defaultExpandedKeys, parentOf) : defaultExpandedKeys, [
+		autoExpandParent,
+		defaultExpandedKeys,
+		parentOf
+	]);
 	const checkbox = useCheckboxTree({
 		treeData,
+		index: treeIndex,
 		isCheckable,
 		defaultCheckedKeys,
 		checkedKeys,
@@ -129,7 +123,8 @@ function TreeBase(props, ref) {
 	});
 	const loadDataController = useLoadData({
 		nodesByKey,
-		loadData
+		loadData,
+		initialExpandedKeys: effectiveExpandedKeys ?? effectiveDefaultExpandedKeys
 	});
 	/**
 	* Tracks the previously-expanded set so we can diff against the next set
@@ -138,8 +133,14 @@ function TreeBase(props, ref) {
 	* ref is the only source for the previous state — `effectiveExpandedKeys`
 	* is `undefined` and would otherwise produce an empty `previous` set,
 	* mis-identifying every toggle.
+	*
+	* Must mirror what `useTreeState` was initialized with (the *effective*
+	* sets, which include `autoExpandParent` ancestors). Using the raw
+	* `defaultExpandedKeys` here would make the first toggle in uncontrolled
+	* mode diff against an undersized previous set, reporting auto-expanded
+	* ancestors as newly expanded.
 	*/
-	const previousExpandedRef = useRef(new Set(expandedKeys ?? defaultExpandedKeys ?? []));
+	const previousExpandedRef = useRef(new Set(effectiveExpandedKeys ?? effectiveDefaultExpandedKeys ?? []));
 	/**
 	* Translate Stately's `Set<Key>` callbacks into the public AntD-flavoured
 	* `Key[]` shape and dispatch the per-key load.
@@ -215,7 +216,7 @@ function TreeBase(props, ref) {
 		defaultSelectedKeys,
 		onSelectionChange: onSelect && selectionMode !== "none" ? handleSelectionChange : void 0,
 		expandedKeys: effectiveExpandedKeys,
-		defaultExpandedKeys,
+		defaultExpandedKeys: effectiveDefaultExpandedKeys,
 		onExpandedChange: handleExpandedChange,
 		disabledKeys,
 		disabledBehavior: "all",
@@ -229,7 +230,7 @@ function TreeBase(props, ref) {
 		onSelect,
 		handleSelectionChange,
 		effectiveExpandedKeys,
-		defaultExpandedKeys,
+		effectiveDefaultExpandedKeys,
 		handleExpandedChange,
 		disabledKeys,
 		treeData,
@@ -275,9 +276,16 @@ function TreeBase(props, ref) {
 	}, [state.collection, state.expandedKeys]);
 	const heightStyle = useMemo(() => height != null ? { ["--tree-height"]: `${height}px` } : void 0, [height]);
 	const mods = useMemo(() => ({ "has-height": height != null }), [height]);
+	/**
+	* Merge the consumer's forwarded ref with our internal `treeRef`. Both
+	* must point at the same DOM node: `useTree` reads `treeRef.current` for
+	* keyboard navigation/focus management, and consumers expect the
+	* forwarded `ref` to receive the element too.
+	*/
+	const mergedRef = useMemo(() => mergeRefs(ref, treeRef), [ref]);
 	return /* @__PURE__ */ jsx(TreeElement, {
-		...mergeProps$1(gridProps, { ref: ref ?? treeRef }),
-		ref: ref ?? treeRef,
+		...mergeProps$1(gridProps, { ref: mergedRef }),
+		ref: mergedRef,
 		qa: qa ?? "Tree",
 		mods,
 		styles: baseStyles,

package/dist/components/content/Tree/Tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"Tree.js","names":["mergeProps"],"sources":["../../../../src/components/content/Tree/Tree.tsx"],"sourcesContent":["import { OUTER_STYLES } from '@tenphi/tasty';\nimport { forwardRef, useMemo, useRef } from 'react';\nimport { useTree } from 'react-aria';\nimport { Item, useTreeState } from 'react-stately';\n\nimport { useEvent } from '../../../_internal/hooks';\nimport { mergeProps } from '../../../utils/react';\nimport { extractStyles } from '../../../utils/styles';\n\nimport { TreeElement } from './styled';\nimport { TreeNode } from './TreeNode';\nimport { useCheckboxTree } from './use-checkbox-tree';\nimport { useLoadData } from './use-load-data';\n\nimport type { Key, Node, Selection } from '@react-types/shared';\nimport type { CSSProperties, ForwardedRef, ReactElement } from 'react';\nimport type {\n  CubeTreeNodeData,\n  CubeTreeProps,\n  TreeOnExpandInfo,\n  TreeOnSelectInfo,\n  TreeSelectionMode,\n} from './types';\n\n/**\n * Render an `<Item>` for React Stately's collection builder.\n *\n * The visible row content is rendered by `TreeNode` via a\n * `nodesByKey` lookup, so the `<Item>`'s body is only used by\n * Stately to build the collection (`textValue` for keyboard nav,\n * `childItems` for nested traversal).\n *\n * For nested traversal to work, the `children` of the `<Tree>` must\n * be passed as a *function* together with the top-level `items`\n * array — see the `<Tree>` `useCollection` call below. Stately\n * propagates that renderer into `childItems` so nested arrays of\n * raw `CubeTreeNodeData` are turned back into `<Item>` elements.\n */\nfunction renderItem(node: CubeTreeNodeData): ReactElement {\n  const textValue =\n    typeof node.title === 'string' ? node.title : String(node.key);\n  return (\n    <Item\n      key={node.key}\n      textValue={textValue}\n      childItems={node.children as CubeTreeNodeData[] | undefined}\n    >\n      {node.title as any}\n    </Item>\n  );\n}\n\n/** Walk the treeData and build a flat `key -> node` index. */\nfunction buildNodesByKey(\n  treeData: CubeTreeNodeData[],\n): Map<string, CubeTreeNodeData> {\n  const map = new Map<string, CubeTreeNodeData>();\n  const visit = (nodes: CubeTreeNodeData[]) => {\n    for (const node of nodes) {\n      map.set(node.key, node);\n      if (node.children) visit(node.children);\n    }\n  };\n  visit(treeData);\n  return map;\n}\n\n/** Walk the treeData and collect all keys whose `isDisabled === true`. */\nfunction collectDisabledKeys(\n  treeData: CubeTreeNodeData[],\n  treeIsDisabled: boolean,\n): string[] {\n  const keys: string[] = [];\n  const visit = (nodes: CubeTreeNodeData[]) => {\n    for (const node of nodes) {\n      if (treeIsDisabled || node.isDisabled) keys.push(node.key);\n      if (node.children) visit(node.children);\n    }\n  };\n  visit(treeData);\n  return keys;\n}\n\n/**\n * Map `key -> parentKey` (used for `autoExpandParent`).\n */\nfunction buildParentOf(\n  treeData: CubeTreeNodeData[],\n): Map<string, string | null> {\n  const parentOf = new Map<string, string | null>();\n  const visit = (nodes: CubeTreeNodeData[], parent: string | null) => {\n    for (const node of nodes) {\n      parentOf.set(node.key, parent);\n      if (node.children) visit(node.children, node.key);\n    }\n  };\n  visit(treeData, null);\n  return parentOf;\n}\n\n/**\n * Expand the supplied keys with all of their ancestors. Used when\n * `autoExpandParent` is `true` so that the consumer can pass deep keys\n * (e.g. search matches) without having to manually walk parents.\n */\nfunction expandWithParents(\n  keys: string[] | undefined,\n  parentOf: Map<string, string | null>,\n): string[] | undefined {\n  if (!keys || keys.length === 0) return keys;\n  const set = new Set<string>(keys);\n  for (const key of keys) {\n    let parent = parentOf.get(key);\n    while (parent) {\n      set.add(parent);\n      parent = parentOf.get(parent);\n    }\n  }\n  return Array.from(set);\n}\n\n/**\n * Coerce the public `selectionMode` / `isSelectable` pair into a single\n * `selectionMode` value for `useTreeState`.\n *\n * - `selectionMode` wins when both are passed.\n * - `isSelectable === false` is sugar for `selectionMode='none'`.\n * - `selectionMode` defaults to `'single'` (matches AntD's default).\n */\nfunction resolveSelectionMode(\n  selectionMode: TreeSelectionMode | undefined,\n  isSelectable: boolean | undefined,\n): TreeSelectionMode {\n  if (selectionMode != null) return selectionMode;\n  if (isSelectable === false) return 'none';\n  return 'single';\n}\n\nfunction TreeBase(props: CubeTreeProps, ref: ForwardedRef<HTMLDivElement>) {\n  const {\n    treeData,\n    isCheckable = false,\n    isSelectable,\n    selectionMode: selectionModeProp,\n    blockNode = false,\n    isDisabled = false,\n    defaultExpandedKeys,\n    expandedKeys,\n    autoExpandParent = false,\n    defaultCheckedKeys,\n    checkedKeys,\n    defaultSelectedKeys,\n    selectedKeys,\n    height,\n    loadData,\n    onExpand,\n    onCheck,\n    onSelect,\n    rowStyles,\n    qa,\n    ...otherProps\n  } = props;\n\n  const baseStyles = extractStyles(otherProps, OUTER_STYLES);\n\n  const treeRef = useRef<HTMLDivElement>(null);\n\n  const nodesByKey = useMemo(() => buildNodesByKey(treeData), [treeData]);\n  const parentOf = useMemo(() => buildParentOf(treeData), [treeData]);\n\n  const disabledKeys = useMemo(\n    () => collectDisabledKeys(treeData, isDisabled),\n    [treeData, isDisabled],\n  );\n\n  const selectionMode = resolveSelectionMode(selectionModeProp, isSelectable);\n\n  /**\n   * Apply `autoExpandParent` to the controlled `expandedKeys`. This is\n   * a one-shot thing — once the consumer responds to `onExpand` and\n   * sets `autoExpandParent` to `false`, we stop force-expanding parents.\n   */\n  const effectiveExpandedKeys = useMemo(\n    () =>\n      autoExpandParent\n        ? expandWithParents(expandedKeys, parentOf)\n        : expandedKeys,\n    [autoExpandParent, expandedKeys, parentOf],\n  );\n\n  const checkbox = useCheckboxTree({\n    treeData,\n    isCheckable,\n    defaultCheckedKeys,\n    checkedKeys,\n    onCheck,\n  });\n\n  const loadDataController = useLoadData({ nodesByKey, loadData });\n\n  /**\n   * Tracks the previously-expanded set so we can diff against the next set\n   * inside `handleExpandedChange`. In controlled mode the parent owns the\n   * truth (read from `effectiveExpandedKeys`); in uncontrolled mode this\n   * ref is the only source for the previous state — `effectiveExpandedKeys`\n   * is `undefined` and would otherwise produce an empty `previous` set,\n   * mis-identifying every toggle.\n   */\n  const previousExpandedRef = useRef<Set<Key>>(\n    new Set<Key>(expandedKeys ?? defaultExpandedKeys ?? []),\n  );\n\n  /**\n   * Translate Stately's `Set<Key>` callbacks into the public AntD-flavoured\n   * `Key[]` shape and dispatch the per-key load.\n   */\n  const handleExpandedChange = useEvent((nextSet: Set<Key>) => {\n    loadDataController.onExpandedChanged(nextSet);\n\n    const previous =\n      expandedKeys !== undefined\n        ? new Set<Key>(effectiveExpandedKeys ?? [])\n        : previousExpandedRef.current;\n    previousExpandedRef.current = new Set<Key>(nextSet);\n\n    if (!onExpand) return;\n    const nextArr: Key[] = Array.from(nextSet);\n\n    /**\n     * Find the single key that toggled relative to the previous set.\n     * Useful for `info.node` and `info.expanded` — matches AntD.\n     */\n    let toggledKey: Key | null = null;\n    let toggledExpanded = false;\n    for (const k of nextArr) {\n      if (!previous.has(k)) {\n        toggledKey = k;\n        toggledExpanded = true;\n        break;\n      }\n    }\n    if (toggledKey == null) {\n      for (const k of previous) {\n        if (!nextSet.has(k)) {\n          toggledKey = k;\n          toggledExpanded = false;\n          break;\n        }\n      }\n    }\n\n    const node =\n      toggledKey != null ? nodesByKey.get(String(toggledKey)) : undefined;\n    const info: TreeOnExpandInfo = {\n      expanded: toggledExpanded,\n      node: node ?? ({} as CubeTreeNodeData),\n    };\n    onExpand(nextArr, info);\n  });\n\n  const handleSelectionChange = useEvent((selection: Selection) => {\n    if (!onSelect) return;\n    const arr: Key[] =\n      selection === 'all'\n        ? Array.from(nodesByKey.keys())\n        : Array.from(selection);\n    /**\n     * Stately's `onSelectionChange` hands us the *next* selection only —\n     * we don't get a \"toggled key\" diff for free. For `single` mode we\n     * can infer it cheaply (it's the only entry); for `multiple` we\n     * report the most recent addition. Falls back to the first key.\n     */\n    let toggledKey: Key | null = null;\n    let toggledSelected = false;\n    if (selectionMode === 'single') {\n      toggledKey = arr[0] ?? null;\n      toggledSelected = arr.length > 0;\n    } else if (selection !== 'all') {\n      toggledKey = arr.length > 0 ? arr[arr.length - 1] : null;\n      toggledSelected = arr.length > 0;\n    } else {\n      toggledKey = arr[0] ?? null;\n      toggledSelected = true;\n    }\n\n    const node =\n      toggledKey != null ? nodesByKey.get(String(toggledKey)) : undefined;\n    const selectedNodes = arr\n      .map((k) => nodesByKey.get(String(k)))\n      .filter((n): n is CubeTreeNodeData => !!n);\n\n    const info: TreeOnSelectInfo = {\n      selected: toggledSelected,\n      node: node ?? ({} as CubeTreeNodeData),\n      selectedNodes,\n    };\n\n    onSelect(arr, info);\n  });\n\n  /**\n   * Stately propagates the `children` function through `childItems`,\n   * so a single render function recursively turns the entire\n   * `treeData` array into `<Item>` elements.\n   */\n  const renderCollectionItem = useEvent((item: CubeTreeNodeData) =>\n    renderItem(item),\n  );\n\n  const ariaProps = useMemo(\n    () => ({\n      selectionMode,\n      selectedKeys,\n      defaultSelectedKeys,\n      onSelectionChange:\n        onSelect && selectionMode !== 'none'\n          ? handleSelectionChange\n          : undefined,\n      expandedKeys: effectiveExpandedKeys,\n      defaultExpandedKeys,\n      onExpandedChange: handleExpandedChange,\n      disabledKeys,\n      disabledBehavior: 'all' as const,\n      items: treeData,\n      children: renderCollectionItem as any,\n      'aria-label': 'Tree',\n    }),\n    [\n      selectionMode,\n      selectedKeys,\n      defaultSelectedKeys,\n      onSelect,\n      handleSelectionChange,\n      effectiveExpandedKeys,\n      defaultExpandedKeys,\n      handleExpandedChange,\n      disabledKeys,\n      treeData,\n      renderCollectionItem,\n    ],\n  );\n\n  const baseState = useTreeState<CubeTreeNodeData>(ariaProps);\n\n  /**\n   * The legacy `TreeCollection` returned by `useTreeState` doesn't\n   * implement `getChildren`, but `@react-aria/tree`'s `useTree`\n   * (via `useGridListItem`) calls it unguarded for any nested row\n   * (`node.level > 0`). Patch it once so `useTree` works on top of\n   * the legacy state without forking.\n   */\n  const state = useMemo(() => {\n    const collection = baseState.collection;\n    if (typeof (collection as any).getChildren === 'function') {\n      return baseState;\n    }\n    const getChildren = (key: Key): Iterable<Node<CubeTreeNodeData>> => {\n      const result: Node<CubeTreeNodeData>[] = [];\n      const node = collection.getItem(key);\n      if (!node) return result;\n      for (const child of node.childNodes) {\n        result.push(child);\n      }\n      return result;\n    };\n    const patched = Object.assign(\n      Object.create(Object.getPrototypeOf(collection)),\n      collection,\n      { getChildren },\n    );\n    return { ...baseState, collection: patched };\n  }, [baseState]);\n\n  const { gridProps } = useTree(ariaProps, state, treeRef);\n\n  /**\n   * Iterate the collection in DOM order. The TreeCollection only walks\n   * into expanded subtrees, so `getKeys()` already gives us *only*\n   * visible rows — no manual filtering required.\n   */\n  const visibleNodes: Node<CubeTreeNodeData>[] = useMemo(() => {\n    const out: Node<CubeTreeNodeData>[] = [];\n    for (const key of state.collection.getKeys()) {\n      const node = state.collection.getItem(key);\n      if (node && node.type === 'item') out.push(node);\n    }\n    return out;\n  }, [state.collection, state.expandedKeys]);\n\n  const heightStyle = useMemo<CSSProperties | undefined>(\n    () =>\n      height != null\n        ? ({\n            ['--tree-height' as keyof CSSProperties]: `${height}px`,\n          } as CSSProperties)\n        : undefined,\n    [height],\n  );\n\n  const mods = useMemo(\n    () => ({\n      'has-height': height != null,\n    }),\n    [height],\n  );\n\n  const elementProps = mergeProps(gridProps, {\n    ref: ref ?? treeRef,\n  });\n\n  return (\n    <TreeElement\n      {...elementProps}\n      ref={ref ?? treeRef}\n      qa={qa ?? 'Tree'}\n      mods={mods}\n      styles={baseStyles}\n      style={heightStyle}\n    >\n      {visibleNodes.map((node) => {\n        const data = nodesByKey.get(String(node.key));\n        if (!data) return null;\n        const isExpanded = state.expandedKeys.has(node.key);\n        return (\n          <TreeNode\n            key={node.key}\n            node={node}\n            data={data}\n            state={state}\n            isCheckable={isCheckable}\n            isExpanded={isExpanded}\n            isChecked={checkbox.checkedSet.has(String(node.key))}\n            isIndeterminate={checkbox.halfCheckedSet.has(String(node.key))}\n            isLoading={loadDataController.loadingKeys.has(String(node.key))}\n            isBlockNode={blockNode}\n            rowStyles={rowStyles}\n            onToggleChecked={checkbox.toggle}\n          />\n        );\n      })}\n    </TreeElement>\n  );\n}\n\nconst _Tree = forwardRef(TreeBase);\n\n/**\n * Hierarchical data display with optional checkboxes, single/multi\n * selection, async lazy loading, and keyboard navigation.\n *\n * Built on `useTree` / `useTreeState` (React Aria + React Stately) and\n * styled with Tasty.\n *\n * @example\n * ```tsx\n * <Tree\n *   treeData={data}\n *   isCheckable\n *   selectionMode=\"none\"\n *   defaultExpandedKeys={['root']}\n *   onCheck={(keys) => console.log(keys)}\n * />\n * ```\n */\nexport const Tree = _Tree;\n"],"mappings":"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"}
+{"version":3,"file":"Tree.js","names":["mergeProps"],"sources":["../../../../src/components/content/Tree/Tree.tsx"],"sourcesContent":["import { OUTER_STYLES } from '@tenphi/tasty';\nimport { forwardRef, useMemo, useRef } from 'react';\nimport { useTree } from 'react-aria';\nimport { Item, useTreeState } from 'react-stately';\n\nimport { useEvent } from '../../../_internal/hooks';\nimport { mergeProps, mergeRefs } from '../../../utils/react';\nimport { extractStyles } from '../../../utils/styles';\n\nimport { TreeElement } from './styled';\nimport { buildTreeIndex } from './tree-index';\nimport { TreeNode } from './TreeNode';\nimport { useCheckboxTree } from './use-checkbox-tree';\nimport { useLoadData } from './use-load-data';\n\nimport type { Key, Node, Selection } from '@react-types/shared';\nimport type { CSSProperties, ForwardedRef, ReactElement } from 'react';\nimport type {\n  CubeTreeNodeData,\n  CubeTreeProps,\n  TreeOnExpandInfo,\n  TreeOnSelectInfo,\n  TreeSelectionMode,\n} from './types';\n\n/**\n * Render an `<Item>` for React Stately's collection builder.\n *\n * The visible row content is rendered by `TreeNode` via a\n * `nodesByKey` lookup, so the `<Item>`'s body is only used by\n * Stately to build the collection (`textValue` for keyboard nav,\n * `childItems` for nested traversal).\n *\n * For nested traversal to work, the `children` of the `<Tree>` must\n * be passed as a *function* together with the top-level `items`\n * array — see the `<Tree>` `useCollection` call below. Stately\n * propagates that renderer into `childItems` so nested arrays of\n * raw `CubeTreeNodeData` are turned back into `<Item>` elements.\n */\nfunction renderItem(node: CubeTreeNodeData): ReactElement {\n  const textValue =\n    typeof node.title === 'string' ? node.title : String(node.key);\n  return (\n    <Item\n      key={node.key}\n      textValue={textValue}\n      childItems={node.children as CubeTreeNodeData[] | undefined}\n    >\n      {node.title as any}\n    </Item>\n  );\n}\n\n/** Walk the treeData and collect all keys whose `isDisabled === true`. */\nfunction collectDisabledKeys(\n  treeData: CubeTreeNodeData[],\n  treeIsDisabled: boolean,\n): string[] {\n  const keys: string[] = [];\n  const visit = (nodes: CubeTreeNodeData[]) => {\n    for (const node of nodes) {\n      if (treeIsDisabled || node.isDisabled) keys.push(node.key);\n      if (node.children) visit(node.children);\n    }\n  };\n  visit(treeData);\n  return keys;\n}\n\n/**\n * Expand the supplied keys with all of their ancestors. Used when\n * `autoExpandParent` is `true` so that the consumer can pass deep keys\n * (e.g. search matches) without having to manually walk parents.\n */\nfunction expandWithParents(\n  keys: string[] | undefined,\n  parentOf: Map<string, string | null>,\n): string[] | undefined {\n  if (!keys || keys.length === 0) return keys;\n  const set = new Set<string>(keys);\n  for (const key of keys) {\n    let parent = parentOf.get(key);\n    while (parent) {\n      set.add(parent);\n      parent = parentOf.get(parent);\n    }\n  }\n  return Array.from(set);\n}\n\n/**\n * Coerce the public `selectionMode` / `isSelectable` pair into a single\n * `selectionMode` value for `useTreeState`.\n *\n * - `selectionMode` wins when both are passed.\n * - `isSelectable === false` is sugar for `selectionMode='none'`.\n * - `selectionMode` defaults to `'single'` (matches AntD's default).\n */\nfunction resolveSelectionMode(\n  selectionMode: TreeSelectionMode | undefined,\n  isSelectable: boolean | undefined,\n): TreeSelectionMode {\n  if (selectionMode != null) return selectionMode;\n  if (isSelectable === false) return 'none';\n  return 'single';\n}\n\nfunction TreeBase(props: CubeTreeProps, ref: ForwardedRef<HTMLDivElement>) {\n  const {\n    treeData,\n    isCheckable = false,\n    isSelectable,\n    selectionMode: selectionModeProp,\n    blockNode = false,\n    isDisabled = false,\n    defaultExpandedKeys,\n    expandedKeys,\n    autoExpandParent = false,\n    defaultCheckedKeys,\n    checkedKeys,\n    defaultSelectedKeys,\n    selectedKeys,\n    height,\n    loadData,\n    onExpand,\n    onCheck,\n    onSelect,\n    rowStyles,\n    qa,\n    ...otherProps\n  } = props;\n\n  const baseStyles = extractStyles(otherProps, OUTER_STYLES);\n\n  const treeRef = useRef<HTMLDivElement>(null);\n\n  /**\n   * Single tree walk that produces `byKey`, `parentOf`, and `childrenOf`.\n   * Shared with `useCheckboxTree` so a `treeData` change triggers exactly\n   * one walk (instead of three) for these three maps.\n   */\n  const treeIndex = useMemo(() => buildTreeIndex(treeData), [treeData]);\n  const nodesByKey = treeIndex.byKey;\n  const parentOf = treeIndex.parentOf;\n\n  const disabledKeys = useMemo(\n    () => collectDisabledKeys(treeData, isDisabled),\n    [treeData, isDisabled],\n  );\n\n  const selectionMode = resolveSelectionMode(selectionModeProp, isSelectable);\n\n  /**\n   * Apply `autoExpandParent` to the controlled `expandedKeys`. This is\n   * a one-shot thing — once the consumer responds to `onExpand` and\n   * sets `autoExpandParent` to `false`, we stop force-expanding parents.\n   */\n  const effectiveExpandedKeys = useMemo(\n    () =>\n      autoExpandParent\n        ? expandWithParents(expandedKeys, parentOf)\n        : expandedKeys,\n    [autoExpandParent, expandedKeys, parentOf],\n  );\n\n  /**\n   * Mirror the same logic for the uncontrolled `defaultExpandedKeys`.\n   * `useTreeState` only reads it on mount, but we still need to expand\n   * ancestors so consumers passing a deep key (e.g. a search match) get\n   * the same behaviour as in the controlled mode.\n   */\n  const effectiveDefaultExpandedKeys = useMemo(\n    () =>\n      autoExpandParent\n        ? expandWithParents(defaultExpandedKeys, parentOf)\n        : defaultExpandedKeys,\n    [autoExpandParent, defaultExpandedKeys, parentOf],\n  );\n\n  const checkbox = useCheckboxTree({\n    treeData,\n    index: treeIndex,\n    isCheckable,\n    defaultCheckedKeys,\n    checkedKeys,\n    onCheck,\n  });\n\n  const loadDataController = useLoadData({\n    nodesByKey,\n    loadData,\n    initialExpandedKeys: effectiveExpandedKeys ?? effectiveDefaultExpandedKeys,\n  });\n\n  /**\n   * Tracks the previously-expanded set so we can diff against the next set\n   * inside `handleExpandedChange`. In controlled mode the parent owns the\n   * truth (read from `effectiveExpandedKeys`); in uncontrolled mode this\n   * ref is the only source for the previous state — `effectiveExpandedKeys`\n   * is `undefined` and would otherwise produce an empty `previous` set,\n   * mis-identifying every toggle.\n   *\n   * Must mirror what `useTreeState` was initialized with (the *effective*\n   * sets, which include `autoExpandParent` ancestors). Using the raw\n   * `defaultExpandedKeys` here would make the first toggle in uncontrolled\n   * mode diff against an undersized previous set, reporting auto-expanded\n   * ancestors as newly expanded.\n   */\n  const previousExpandedRef = useRef<Set<Key>>(\n    new Set<Key>(effectiveExpandedKeys ?? effectiveDefaultExpandedKeys ?? []),\n  );\n\n  /**\n   * Translate Stately's `Set<Key>` callbacks into the public AntD-flavoured\n   * `Key[]` shape and dispatch the per-key load.\n   */\n  const handleExpandedChange = useEvent((nextSet: Set<Key>) => {\n    loadDataController.onExpandedChanged(nextSet);\n\n    const previous =\n      expandedKeys !== undefined\n        ? new Set<Key>(effectiveExpandedKeys ?? [])\n        : previousExpandedRef.current;\n    previousExpandedRef.current = new Set<Key>(nextSet);\n\n    if (!onExpand) return;\n    const nextArr: Key[] = Array.from(nextSet);\n\n    /**\n     * Find the single key that toggled relative to the previous set.\n     * Useful for `info.node` and `info.expanded` — matches AntD.\n     */\n    let toggledKey: Key | null = null;\n    let toggledExpanded = false;\n    for (const k of nextArr) {\n      if (!previous.has(k)) {\n        toggledKey = k;\n        toggledExpanded = true;\n        break;\n      }\n    }\n    if (toggledKey == null) {\n      for (const k of previous) {\n        if (!nextSet.has(k)) {\n          toggledKey = k;\n          toggledExpanded = false;\n          break;\n        }\n      }\n    }\n\n    const node =\n      toggledKey != null ? nodesByKey.get(String(toggledKey)) : undefined;\n    const info: TreeOnExpandInfo = {\n      expanded: toggledExpanded,\n      node: node ?? ({} as CubeTreeNodeData),\n    };\n    onExpand(nextArr, info);\n  });\n\n  const handleSelectionChange = useEvent((selection: Selection) => {\n    if (!onSelect) return;\n    const arr: Key[] =\n      selection === 'all'\n        ? Array.from(nodesByKey.keys())\n        : Array.from(selection);\n    /**\n     * Stately's `onSelectionChange` hands us the *next* selection only —\n     * we don't get a \"toggled key\" diff for free. For `single` mode we\n     * can infer it cheaply (it's the only entry); for `multiple` we\n     * report the most recent addition. Falls back to the first key.\n     */\n    let toggledKey: Key | null = null;\n    let toggledSelected = false;\n    if (selectionMode === 'single') {\n      toggledKey = arr[0] ?? null;\n      toggledSelected = arr.length > 0;\n    } else if (selection !== 'all') {\n      toggledKey = arr.length > 0 ? arr[arr.length - 1] : null;\n      toggledSelected = arr.length > 0;\n    } else {\n      toggledKey = arr[0] ?? null;\n      toggledSelected = true;\n    }\n\n    const node =\n      toggledKey != null ? nodesByKey.get(String(toggledKey)) : undefined;\n    const selectedNodes = arr\n      .map((k) => nodesByKey.get(String(k)))\n      .filter((n): n is CubeTreeNodeData => !!n);\n\n    const info: TreeOnSelectInfo = {\n      selected: toggledSelected,\n      node: node ?? ({} as CubeTreeNodeData),\n      selectedNodes,\n    };\n\n    onSelect(arr, info);\n  });\n\n  /**\n   * Stately propagates the `children` function through `childItems`,\n   * so a single render function recursively turns the entire\n   * `treeData` array into `<Item>` elements.\n   */\n  const renderCollectionItem = useEvent((item: CubeTreeNodeData) =>\n    renderItem(item),\n  );\n\n  const ariaProps = useMemo(\n    () => ({\n      selectionMode,\n      selectedKeys,\n      defaultSelectedKeys,\n      onSelectionChange:\n        onSelect && selectionMode !== 'none'\n          ? handleSelectionChange\n          : undefined,\n      expandedKeys: effectiveExpandedKeys,\n      defaultExpandedKeys: effectiveDefaultExpandedKeys,\n      onExpandedChange: handleExpandedChange,\n      disabledKeys,\n      disabledBehavior: 'all' as const,\n      items: treeData,\n      children: renderCollectionItem as any,\n      'aria-label': 'Tree',\n    }),\n    [\n      selectionMode,\n      selectedKeys,\n      defaultSelectedKeys,\n      onSelect,\n      handleSelectionChange,\n      effectiveExpandedKeys,\n      effectiveDefaultExpandedKeys,\n      handleExpandedChange,\n      disabledKeys,\n      treeData,\n      renderCollectionItem,\n    ],\n  );\n\n  const baseState = useTreeState<CubeTreeNodeData>(ariaProps);\n\n  /**\n   * The legacy `TreeCollection` returned by `useTreeState` doesn't\n   * implement `getChildren`, but `@react-aria/tree`'s `useTree`\n   * (via `useGridListItem`) calls it unguarded for any nested row\n   * (`node.level > 0`). Patch it once so `useTree` works on top of\n   * the legacy state without forking.\n   */\n  const state = useMemo(() => {\n    const collection = baseState.collection;\n    if (typeof (collection as any).getChildren === 'function') {\n      return baseState;\n    }\n    const getChildren = (key: Key): Iterable<Node<CubeTreeNodeData>> => {\n      const result: Node<CubeTreeNodeData>[] = [];\n      const node = collection.getItem(key);\n      if (!node) return result;\n      for (const child of node.childNodes) {\n        result.push(child);\n      }\n      return result;\n    };\n    const patched = Object.assign(\n      Object.create(Object.getPrototypeOf(collection)),\n      collection,\n      { getChildren },\n    );\n    return { ...baseState, collection: patched };\n  }, [baseState]);\n\n  const { gridProps } = useTree(ariaProps, state, treeRef);\n\n  /**\n   * Iterate the collection in DOM order. The TreeCollection only walks\n   * into expanded subtrees, so `getKeys()` already gives us *only*\n   * visible rows — no manual filtering required.\n   */\n  const visibleNodes: Node<CubeTreeNodeData>[] = useMemo(() => {\n    const out: Node<CubeTreeNodeData>[] = [];\n    for (const key of state.collection.getKeys()) {\n      const node = state.collection.getItem(key);\n      if (node && node.type === 'item') out.push(node);\n    }\n    return out;\n  }, [state.collection, state.expandedKeys]);\n\n  const heightStyle = useMemo<CSSProperties | undefined>(\n    () =>\n      height != null\n        ? ({\n            ['--tree-height' as keyof CSSProperties]: `${height}px`,\n          } as CSSProperties)\n        : undefined,\n    [height],\n  );\n\n  const mods = useMemo(\n    () => ({\n      'has-height': height != null,\n    }),\n    [height],\n  );\n\n  /**\n   * Merge the consumer's forwarded ref with our internal `treeRef`. Both\n   * must point at the same DOM node: `useTree` reads `treeRef.current` for\n   * keyboard navigation/focus management, and consumers expect the\n   * forwarded `ref` to receive the element too.\n   */\n  const mergedRef = useMemo(() => mergeRefs(ref, treeRef), [ref]);\n\n  const elementProps = mergeProps(gridProps, {\n    ref: mergedRef,\n  });\n\n  return (\n    <TreeElement\n      {...elementProps}\n      ref={mergedRef}\n      qa={qa ?? 'Tree'}\n      mods={mods}\n      styles={baseStyles}\n      style={heightStyle}\n    >\n      {visibleNodes.map((node) => {\n        const data = nodesByKey.get(String(node.key));\n        if (!data) return null;\n        const isExpanded = state.expandedKeys.has(node.key);\n        return (\n          <TreeNode\n            key={node.key}\n            node={node}\n            data={data}\n            state={state}\n            isCheckable={isCheckable}\n            isExpanded={isExpanded}\n            isChecked={checkbox.checkedSet.has(String(node.key))}\n            isIndeterminate={checkbox.halfCheckedSet.has(String(node.key))}\n            isLoading={loadDataController.loadingKeys.has(String(node.key))}\n            isBlockNode={blockNode}\n            rowStyles={rowStyles}\n            onToggleChecked={checkbox.toggle}\n          />\n        );\n      })}\n    </TreeElement>\n  );\n}\n\nconst _Tree = forwardRef(TreeBase);\n\n/**\n * Hierarchical data display with optional checkboxes, single/multi\n * selection, async lazy loading, and keyboard navigation.\n *\n * Built on `useTree` / `useTreeState` (React Aria + React Stately) and\n * styled with Tasty.\n *\n * @example\n * ```tsx\n * <Tree\n *   treeData={data}\n *   isCheckable\n *   selectionMode=\"none\"\n *   defaultExpandedKeys={['root']}\n *   onCheck={(keys) => console.log(keys)}\n * />\n * ```\n */\nexport const Tree = _Tree;\n"],"mappings":"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"}

package/dist/components/content/Tree/TreeNode.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { LoadingIcon } from "../../../icons/LoadingIcon.js";

package/dist/components/content/Tree/styled.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { _Item } from "../Item/Item.js";
 import { Action } from "../../actions/Action/Action.js";
 import { tasty } from "@tenphi/tasty";

package/dist/components/content/Tree/tree-index.js

@@ -0,0 +1,26 @@
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
+//#region src/components/content/Tree/tree-index.ts
+function buildTreeIndex(treeData) {
+	const byKey = /* @__PURE__ */ new Map();
+	const parentOf = /* @__PURE__ */ new Map();
+	const childrenOf = /* @__PURE__ */ new Map();
+	const visit = (nodes, parent) => {
+		for (const node of nodes) {
+			byKey.set(node.key, node);
+			parentOf.set(node.key, parent);
+			const childKeys = (node.children ?? []).map((c) => c.key);
+			childrenOf.set(node.key, childKeys);
+			if (node.children) visit(node.children, node.key);
+		}
+	};
+	visit(treeData, null);
+	return {
+		byKey,
+		parentOf,
+		childrenOf
+	};
+}
+
+//#endregion
+export { buildTreeIndex };
+//# sourceMappingURL=tree-index.js.map

package/dist/components/content/Tree/tree-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-index.js","names":[],"sources":["../../../../src/components/content/Tree/tree-index.ts"],"sourcesContent":["import type { CubeTreeNodeData } from './types';\n\n/**\n * Map of `key -> { node, parentKey, childKeys }` for fast cascading lookups.\n *\n * Built from the public `treeData` rather than from React Stately's\n * collection, because we need the consumer's original (controlled)\n * shape to derive parent/child relationships and to call back with the\n * actual `node` objects.\n *\n * Shared between `Tree.tsx` (for `nodesByKey` / `parentOf`) and\n * `useCheckboxTree` (cascading checked state) so a single tree walk\n * powers all three maps.\n */\nexport interface TreeIndex {\n  byKey: Map<string, CubeTreeNodeData>;\n  parentOf: Map<string, string | null>;\n  childrenOf: Map<string, string[]>;\n}\n\nexport function buildTreeIndex(treeData: CubeTreeNodeData[]): TreeIndex {\n  const byKey = new Map<string, CubeTreeNodeData>();\n  const parentOf = new Map<string, string | null>();\n  const childrenOf = new Map<string, string[]>();\n\n  const visit = (nodes: CubeTreeNodeData[], parent: string | null) => {\n    for (const node of nodes) {\n      byKey.set(node.key, node);\n      parentOf.set(node.key, parent);\n      const childKeys = (node.children ?? []).map((c) => c.key);\n      childrenOf.set(node.key, childKeys);\n      if (node.children) {\n        visit(node.children, node.key);\n      }\n    }\n  };\n\n  visit(treeData, null);\n\n  return { byKey, parentOf, childrenOf };\n}\n"],"mappings":";;AAoBA,SAAgB,eAAe,UAAyC;CACtE,MAAM,wBAAQ,IAAI,KAA+B;CACjD,MAAM,2BAAW,IAAI,KAA4B;CACjD,MAAM,6BAAa,IAAI,KAAuB;CAE9C,MAAM,SAAS,OAA2B,WAA0B;AAClE,OAAK,MAAM,QAAQ,OAAO;AACxB,SAAM,IAAI,KAAK,KAAK,KAAK;AACzB,YAAS,IAAI,KAAK,KAAK,OAAO;GAC9B,MAAM,aAAa,KAAK,YAAY,EAAE,EAAE,KAAK,MAAM,EAAE,IAAI;AACzD,cAAW,IAAI,KAAK,KAAK,UAAU;AACnC,OAAI,KAAK,SACP,OAAM,KAAK,UAAU,KAAK,IAAI;;;AAKpC,OAAM,UAAU,KAAK;AAErB,QAAO;EAAE;EAAO;EAAU;EAAY"}

package/dist/components/content/Tree/use-checkbox-tree.js

@@ -1,28 +1,8 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useMemo, useState } from "react";
 
 //#region src/components/content/Tree/use-checkbox-tree.ts
-function buildIndex(treeData) {
-	const byKey = /* @__PURE__ */ new Map();
-	const parentOf = /* @__PURE__ */ new Map();
-	const childrenOf = /* @__PURE__ */ new Map();
-	const visit = (nodes, parent) => {
-		for (const node of nodes) {
-			byKey.set(node.key, node);
-			parentOf.set(node.key, parent);
-			const childKeys = (node.children ?? []).map((c) => c.key);
-			childrenOf.set(node.key, childKeys);
-			if (node.children) visit(node.children, node.key);
-		}
-	};
-	visit(treeData, null);
-	return {
-		byKey,
-		parentOf,
-		childrenOf
-	};
-}
 /**
 * Returns whether a node should be checkable (i.e. clicking the
 * checkbox should affect it).
@@ -39,6 +19,46 @@ function isNodeEligible(node) {
 	if (node.isCheckable === false) return false;
 	return true;
 }
+/**
+* Recursively walk a subtree bottom-up, deriving which nodes are fully
+* checked vs half-checked.  Mutates `checked` and `half` in place.
+*/
+function deriveCheckedState(node, index, checked, half) {
+	const childKeys = index.childrenOf.get(node.key) ?? [];
+	if (childKeys.length === 0) {
+		const eligible = isNodeEligible(node);
+		const isChecked = checked.has(node.key);
+		return {
+			allChecked: !eligible || isChecked,
+			anyChecked: isChecked,
+			anyEligible: eligible
+		};
+	}
+	let allChecked = true;
+	let anyChecked = false;
+	let anyEligible = false;
+	for (const childKey of childKeys) {
+		const child = index.byKey.get(childKey);
+		if (!child) continue;
+		const r = deriveCheckedState(child, index, checked, half);
+		if (r.anyEligible) anyEligible = true;
+		if (!r.allChecked) allChecked = false;
+		if (r.anyChecked) anyChecked = true;
+	}
+	const eligible = isNodeEligible(node);
+	if (anyEligible && allChecked) {
+		checked.add(node.key);
+		half.delete(node.key);
+	} else if (anyChecked) {
+		checked.delete(node.key);
+		half.add(node.key);
+	} else checked.delete(node.key);
+	return {
+		allChecked: !eligible ? allChecked : checked.has(node.key) && allChecked,
+		anyChecked: anyChecked || checked.has(node.key),
+		anyEligible: anyEligible || eligible
+	};
+}
 function normalizeControlledChecked(controlled) {
 	if (controlled == null) return null;
 	if (Array.isArray(controlled)) return {
@@ -62,8 +82,7 @@ function normalizeControlledChecked(controlled) {
 *   and recomputes ancestors *up* in a single pass.
 */
 function useCheckboxTree(opts) {
-	const { treeData, isCheckable, defaultCheckedKeys, checkedKeys, onCheck } = opts;
-	const index = useMemo(() => buildIndex(treeData), [treeData]);
+	const { treeData, index, isCheckable, defaultCheckedKeys, checkedKeys, onCheck } = opts;
 	const controlled = normalizeControlledChecked(checkedKeys);
 	const isControlled = controlled != null;
 	const wantsObjectShape = checkedKeys != null && !Array.isArray(checkedKeys);
@@ -100,43 +119,7 @@ function useCheckboxTree(opts) {
 		};
 		const checked = new Set(sourceChecked);
 		const half = /* @__PURE__ */ new Set();
-		const visit = (node) => {
-			const childKeys = index.childrenOf.get(node.key) ?? [];
-			if (childKeys.length === 0) {
-				const eligible = isNodeEligible(node);
-				const isChecked = checked.has(node.key);
-				return {
-					allChecked: !eligible || isChecked,
-					anyChecked: isChecked,
-					anyEligible: eligible
-				};
-			}
-			let allChecked = true;
-			let anyChecked = false;
-			let anyEligible = false;
-			for (const childKey of childKeys) {
-				const child = index.byKey.get(childKey);
-				if (!child) continue;
-				const r = visit(child);
-				if (r.anyEligible) anyEligible = true;
-				if (!r.allChecked) allChecked = false;
-				if (r.anyChecked) anyChecked = true;
-			}
-			const eligible = isNodeEligible(node);
-			if (anyEligible && allChecked) {
-				checked.add(node.key);
-				half.delete(node.key);
-			} else if (anyChecked || half.has(node.key)) {
-				checked.delete(node.key);
-				half.add(node.key);
-			} else checked.delete(node.key);
-			return {
-				allChecked: !eligible ? allChecked : checked.has(node.key) && allChecked,
-				anyChecked: anyChecked || checked.has(node.key),
-				anyEligible: anyEligible || eligible
-			};
-		};
-		for (const root of treeData) visit(root);
+		for (const root of treeData) deriveCheckedState(root, index, checked, half);
 		return {
 			checkedSet: checked,
 			halfCheckedSet: half
@@ -199,43 +182,7 @@ function useCheckboxTree(opts) {
 			if (onCheck) {
 				const finalChecked = new Set(next);
 				const finalHalf = /* @__PURE__ */ new Set();
-				const recompute = (n) => {
-					const childKeys = index.childrenOf.get(n.key) ?? [];
-					if (childKeys.length === 0) {
-						const eligible = isNodeEligible(n);
-						const isChecked = finalChecked.has(n.key);
-						return {
-							allChecked: !eligible || isChecked,
-							anyChecked: isChecked,
-							anyEligible: eligible
-						};
-					}
-					let allChecked = true;
-					let anyChecked = false;
-					let anyEligible = false;
-					for (const ck of childKeys) {
-						const child = index.byKey.get(ck);
-						if (!child) continue;
-						const r = recompute(child);
-						if (r.anyEligible) anyEligible = true;
-						if (!r.allChecked) allChecked = false;
-						if (r.anyChecked) anyChecked = true;
-					}
-					const eligible = isNodeEligible(n);
-					if (anyEligible && allChecked) {
-						finalChecked.add(n.key);
-						finalHalf.delete(n.key);
-					} else if (anyChecked) {
-						finalChecked.delete(n.key);
-						finalHalf.add(n.key);
-					} else finalChecked.delete(n.key);
-					return {
-						allChecked: !eligible ? allChecked : finalChecked.has(n.key) && allChecked,
-						anyChecked: anyChecked || finalChecked.has(n.key),
-						anyEligible: anyEligible || eligible
-					};
-				};
-				for (const root of treeData) recompute(root);
+				for (const root of treeData) deriveCheckedState(root, index, finalChecked, finalHalf);
 				const checkedArr = Array.from(finalChecked);
 				const halfArr = Array.from(finalHalf);
 				const info = {

package/dist/components/content/Tree/use-checkbox-tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-checkbox-tree.js","names":[],"sources":["../../../../src/components/content/Tree/use-checkbox-tree.ts"],"sourcesContent":["import { useMemo, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { Key } from '@react-types/shared';\nimport type { CubeTreeNodeData, TreeOnCheckInfo } from './types';\n\nexport interface UseCheckboxTreeOptions {\n  treeData: CubeTreeNodeData[];\n  isCheckable: boolean;\n  defaultCheckedKeys?: string[];\n  /** Either an array (AntD's default) or `{ checked, halfChecked }`. */\n  checkedKeys?: string[] | { checked: string[]; halfChecked?: string[] };\n  onCheck?: (\n    checked: Key[] | { checked: Key[]; halfChecked: Key[] },\n    info: TreeOnCheckInfo,\n  ) => void;\n}\n\nexport interface CheckboxTree {\n  /** Set of keys that are fully checked. */\n  checkedSet: Set<string>;\n  /** Set of keys that are in the indeterminate (half-checked) state. */\n  halfCheckedSet: Set<string>;\n  /** Toggle a key, propagating to descendants and updating ancestors. */\n  toggle: (key: string) => void;\n}\n\n/**\n * Map of `key -> { node, parentKey, childKeys }` for fast cascading lookups.\n *\n * Built from the public `treeData` rather than from React Stately's\n * collection, because we need the consumer's original (controlled)\n * shape to derive parent/child relationships and to call back with the\n * actual `node` objects in `onCheck`'s `info`.\n */\ninterface NodeIndex {\n  byKey: Map<string, CubeTreeNodeData>;\n  parentOf: Map<string, string | null>;\n  childrenOf: Map<string, string[]>;\n}\n\nfunction buildIndex(treeData: CubeTreeNodeData[]): NodeIndex {\n  const byKey = new Map<string, CubeTreeNodeData>();\n  const parentOf = new Map<string, string | null>();\n  const childrenOf = new Map<string, string[]>();\n\n  const visit = (nodes: CubeTreeNodeData[], parent: string | null) => {\n    for (const node of nodes) {\n      byKey.set(node.key, node);\n      parentOf.set(node.key, parent);\n      const childKeys = (node.children ?? []).map((c) => c.key);\n      childrenOf.set(node.key, childKeys);\n      if (node.children) {\n        visit(node.children, node.key);\n      }\n    }\n  };\n\n  visit(treeData, null);\n\n  return { byKey, parentOf, childrenOf };\n}\n\n/**\n * Returns whether a node should be checkable (i.e. clicking the\n * checkbox should affect it).\n *\n * Skips:\n * - explicitly disabled nodes (`isDisabled === true`)\n * - explicitly disabled checkboxes (`isCheckboxDisabled === true`)\n * - nodes that opted out via `isCheckable === false`\n */\nfunction isNodeEligible(node: CubeTreeNodeData | undefined): boolean {\n  if (!node) return false;\n  if (node.isDisabled) return false;\n  if (node.isCheckboxDisabled) return false;\n  if (node.isCheckable === false) return false;\n  return true;\n}\n\nfunction normalizeControlledChecked(\n  controlled: UseCheckboxTreeOptions['checkedKeys'],\n): { checked: Set<string>; halfChecked: Set<string> } | null {\n  if (controlled == null) return null;\n  if (Array.isArray(controlled)) {\n    return {\n      checked: new Set(controlled),\n      halfChecked: new Set(),\n    };\n  }\n  return {\n    checked: new Set(controlled.checked ?? []),\n    halfChecked: new Set(controlled.halfChecked ?? []),\n  };\n}\n\n/**\n * Local hook implementing AntD-style cascading checkbox state.\n *\n * - `checked` and `halfChecked` are always derived together from a single\n *   `checked` set (the source of truth) so callers don't need to track\n *   indeterminate keys themselves.\n * - When the consumer passes `checkedKeys` as `{ checked, halfChecked }`,\n *   we keep the wire shape on the way out — same as AntD.\n * - Toggling a node propagates *down* (skipping ineligible descendants)\n *   and recomputes ancestors *up* in a single pass.\n */\nexport function useCheckboxTree(opts: UseCheckboxTreeOptions): CheckboxTree {\n  const { treeData, isCheckable, defaultCheckedKeys, checkedKeys, onCheck } =\n    opts;\n\n  const index = useMemo(() => buildIndex(treeData), [treeData]);\n\n  const controlled = normalizeControlledChecked(checkedKeys);\n  const isControlled = controlled != null;\n  const wantsObjectShape = checkedKeys != null && !Array.isArray(checkedKeys);\n\n  const [uncontrolledChecked, setUncontrolledChecked] = useState<Set<string>>(\n    () => new Set(defaultCheckedKeys ?? []),\n  );\n\n  const sourceChecked = isControlled\n    ? controlled!.checked\n    : uncontrolledChecked;\n\n  /**\n   * Derive `{ checked, halfChecked }` from the source-of-truth `checked` set\n   * by walking the tree bottom-up:\n   *\n   * - A parent is considered fully checked iff every eligible descendant\n   *   leaf is checked.\n   * - A parent is half-checked iff at least one eligible descendant is\n   *   checked or half-checked, but not all.\n   *\n   * Ineligible nodes (disabled / opt-out) are ignored when computing the\n   * parent's state — they neither force a parent into the unchecked nor\n   * half state.\n   */\n  const { checkedSet, halfCheckedSet } = useMemo(() => {\n    if (!isCheckable) {\n      return {\n        checkedSet: new Set<string>(),\n        halfCheckedSet: new Set<string>(),\n      };\n    }\n\n    /**\n     * If the consumer passed the object shape (`{ checked, halfChecked }`),\n     * they own the half-checked set and we use it as-is. With the array\n     * shape we still need to derive `halfChecked` ourselves — the consumer\n     * only provides `checked`, so parents should still light up\n     * indeterminate when only some descendants are checked.\n     */\n    if (isControlled && wantsObjectShape) {\n      return {\n        checkedSet: new Set(sourceChecked),\n        halfCheckedSet: new Set(controlled!.halfChecked),\n      };\n    }\n\n    const checked = new Set(sourceChecked);\n    const half = new Set<string>();\n\n    const visit = (\n      node: CubeTreeNodeData,\n    ): { allChecked: boolean; anyChecked: boolean; anyEligible: boolean } => {\n      const childKeys = index.childrenOf.get(node.key) ?? [];\n\n      if (childKeys.length === 0) {\n        const eligible = isNodeEligible(node);\n        const isChecked = checked.has(node.key);\n        return {\n          allChecked: !eligible || isChecked,\n          anyChecked: isChecked,\n          anyEligible: eligible,\n        };\n      }\n\n      let allChecked = true;\n      let anyChecked = false;\n      let anyEligible = false;\n\n      for (const childKey of childKeys) {\n        const child = index.byKey.get(childKey);\n        if (!child) continue;\n        const r = visit(child);\n        if (r.anyEligible) anyEligible = true;\n        if (!r.allChecked) allChecked = false;\n        if (r.anyChecked) anyChecked = true;\n      }\n\n      const eligible = isNodeEligible(node);\n\n      if (anyEligible && allChecked) {\n        checked.add(node.key);\n        half.delete(node.key);\n      } else if (anyChecked || half.has(node.key)) {\n        checked.delete(node.key);\n        half.add(node.key);\n      } else {\n        checked.delete(node.key);\n      }\n\n      return {\n        allChecked: !eligible\n          ? allChecked\n          : checked.has(node.key) && allChecked,\n        anyChecked: anyChecked || checked.has(node.key),\n        anyEligible: anyEligible || eligible,\n      };\n    };\n\n    for (const root of treeData) {\n      visit(root);\n    }\n\n    return { checkedSet: checked, halfCheckedSet: half };\n  }, [\n    isCheckable,\n    isControlled,\n    wantsObjectShape,\n    sourceChecked,\n    controlled,\n    treeData,\n    index,\n  ]);\n\n  const toggle = useEvent((key: string) => {\n    const node = index.byKey.get(key);\n    if (!node || !isNodeEligible(node)) return;\n\n    const isCurrentlyChecked = checkedSet.has(key);\n    const willCheck = !isCurrentlyChecked;\n\n    const next = new Set(sourceChecked);\n\n    const apply = (n: CubeTreeNodeData, value: boolean) => {\n      if (!isNodeEligible(n)) return;\n      if (value) next.add(n.key);\n      else next.delete(n.key);\n      const childKeys = index.childrenOf.get(n.key) ?? [];\n      for (const ck of childKeys) {\n        const child = index.byKey.get(ck);\n        if (child) apply(child, value);\n      }\n    };\n\n    apply(node, willCheck);\n\n    /**\n     * After the cascade, recompute ancestors so the public `checked` set\n     * doesn't carry parent keys that should be half-checked instead.\n     * Ancestors of `key` get visited bottom-up here.\n     */\n    let parentKey = index.parentOf.get(key);\n    while (parentKey) {\n      const parent = index.byKey.get(parentKey);\n      if (!parent) break;\n      const childKeys = index.childrenOf.get(parentKey) ?? [];\n      let allEligibleChecked = true;\n      let anyEligible = false;\n      for (const ck of childKeys) {\n        const child = index.byKey.get(ck);\n        if (!child) continue;\n        if (!isNodeEligible(child)) continue;\n        anyEligible = true;\n        if (!next.has(ck)) {\n          allEligibleChecked = false;\n          break;\n        }\n      }\n      if (anyEligible && allEligibleChecked && isNodeEligible(parent)) {\n        next.add(parentKey);\n      } else {\n        next.delete(parentKey);\n      }\n      parentKey = index.parentOf.get(parentKey);\n    }\n\n    if (!isControlled) {\n      setUncontrolledChecked(next);\n    }\n\n    if (onCheck) {\n      const finalChecked = new Set(next);\n      const finalHalf = new Set<string>();\n\n      const recompute = (\n        n: CubeTreeNodeData,\n      ): {\n        allChecked: boolean;\n        anyChecked: boolean;\n        anyEligible: boolean;\n      } => {\n        const childKeys = index.childrenOf.get(n.key) ?? [];\n        if (childKeys.length === 0) {\n          const eligible = isNodeEligible(n);\n          const isChecked = finalChecked.has(n.key);\n          return {\n            allChecked: !eligible || isChecked,\n            anyChecked: isChecked,\n            anyEligible: eligible,\n          };\n        }\n        let allChecked = true;\n        let anyChecked = false;\n        let anyEligible = false;\n        for (const ck of childKeys) {\n          const child = index.byKey.get(ck);\n          if (!child) continue;\n          const r = recompute(child);\n          if (r.anyEligible) anyEligible = true;\n          if (!r.allChecked) allChecked = false;\n          if (r.anyChecked) anyChecked = true;\n        }\n        const eligible = isNodeEligible(n);\n        if (anyEligible && allChecked) {\n          finalChecked.add(n.key);\n          finalHalf.delete(n.key);\n        } else if (anyChecked) {\n          finalChecked.delete(n.key);\n          finalHalf.add(n.key);\n        } else {\n          finalChecked.delete(n.key);\n        }\n        return {\n          allChecked: !eligible\n            ? allChecked\n            : finalChecked.has(n.key) && allChecked,\n          anyChecked: anyChecked || finalChecked.has(n.key),\n          anyEligible: anyEligible || eligible,\n        };\n      };\n\n      for (const root of treeData) recompute(root);\n\n      const checkedArr = Array.from(finalChecked);\n      const halfArr = Array.from(finalHalf);\n      const checkedNodes: CubeTreeNodeData[] = checkedArr\n        .map((k) => index.byKey.get(k))\n        .filter((n): n is CubeTreeNodeData => !!n);\n\n      const info: TreeOnCheckInfo = {\n        checked: willCheck,\n        node,\n        checkedNodes,\n        halfCheckedKeys: halfArr,\n      };\n\n      if (wantsObjectShape) {\n        onCheck({ checked: checkedArr, halfChecked: halfArr }, info);\n      } else {\n        onCheck(checkedArr, info);\n      }\n    }\n  });\n\n  return { checkedSet, halfCheckedSet, toggle };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-checkbox-tree.js","names":[],"sources":["../../../../src/components/content/Tree/use-checkbox-tree.ts"],"sourcesContent":["import { useMemo, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { Key } from '@react-types/shared';\nimport type { TreeIndex } from './tree-index';\nimport type { CubeTreeNodeData, TreeOnCheckInfo } from './types';\n\nexport interface UseCheckboxTreeOptions {\n  treeData: CubeTreeNodeData[];\n  /**\n   * Pre-built tree index, shared with `Tree.tsx` so that `treeData`\n   * is walked exactly once per change rather than once per consumer.\n   */\n  index: TreeIndex;\n  isCheckable: boolean;\n  defaultCheckedKeys?: string[];\n  /** Either an array (AntD's default) or `{ checked, halfChecked }`. */\n  checkedKeys?: string[] | { checked: string[]; halfChecked?: string[] };\n  onCheck?: (\n    checked: Key[] | { checked: Key[]; halfChecked: Key[] },\n    info: TreeOnCheckInfo,\n  ) => void;\n}\n\nexport interface CheckboxTree {\n  /** Set of keys that are fully checked. */\n  checkedSet: Set<string>;\n  /** Set of keys that are in the indeterminate (half-checked) state. */\n  halfCheckedSet: Set<string>;\n  /** Toggle a key, propagating to descendants and updating ancestors. */\n  toggle: (key: string) => void;\n}\n\n/**\n * Returns whether a node should be checkable (i.e. clicking the\n * checkbox should affect it).\n *\n * Skips:\n * - explicitly disabled nodes (`isDisabled === true`)\n * - explicitly disabled checkboxes (`isCheckboxDisabled === true`)\n * - nodes that opted out via `isCheckable === false`\n */\nfunction isNodeEligible(node: CubeTreeNodeData | undefined): boolean {\n  if (!node) return false;\n  if (node.isDisabled) return false;\n  if (node.isCheckboxDisabled) return false;\n  if (node.isCheckable === false) return false;\n  return true;\n}\n\n/**\n * Recursively walk a subtree bottom-up, deriving which nodes are fully\n * checked vs half-checked.  Mutates `checked` and `half` in place.\n */\nfunction deriveCheckedState(\n  node: CubeTreeNodeData,\n  index: TreeIndex,\n  checked: Set<string>,\n  half: Set<string>,\n): { allChecked: boolean; anyChecked: boolean; anyEligible: boolean } {\n  const childKeys = index.childrenOf.get(node.key) ?? [];\n\n  if (childKeys.length === 0) {\n    const eligible = isNodeEligible(node);\n    const isChecked = checked.has(node.key);\n    return {\n      allChecked: !eligible || isChecked,\n      anyChecked: isChecked,\n      anyEligible: eligible,\n    };\n  }\n\n  let allChecked = true;\n  let anyChecked = false;\n  let anyEligible = false;\n\n  for (const childKey of childKeys) {\n    const child = index.byKey.get(childKey);\n    if (!child) continue;\n    const r = deriveCheckedState(child, index, checked, half);\n    if (r.anyEligible) anyEligible = true;\n    if (!r.allChecked) allChecked = false;\n    if (r.anyChecked) anyChecked = true;\n  }\n\n  const eligible = isNodeEligible(node);\n\n  if (anyEligible && allChecked) {\n    checked.add(node.key);\n    half.delete(node.key);\n  } else if (anyChecked) {\n    checked.delete(node.key);\n    half.add(node.key);\n  } else {\n    checked.delete(node.key);\n  }\n\n  return {\n    allChecked: !eligible ? allChecked : checked.has(node.key) && allChecked,\n    anyChecked: anyChecked || checked.has(node.key),\n    anyEligible: anyEligible || eligible,\n  };\n}\n\nfunction normalizeControlledChecked(\n  controlled: UseCheckboxTreeOptions['checkedKeys'],\n): { checked: Set<string>; halfChecked: Set<string> } | null {\n  if (controlled == null) return null;\n  if (Array.isArray(controlled)) {\n    return {\n      checked: new Set(controlled),\n      halfChecked: new Set(),\n    };\n  }\n  return {\n    checked: new Set(controlled.checked ?? []),\n    halfChecked: new Set(controlled.halfChecked ?? []),\n  };\n}\n\n/**\n * Local hook implementing AntD-style cascading checkbox state.\n *\n * - `checked` and `halfChecked` are always derived together from a single\n *   `checked` set (the source of truth) so callers don't need to track\n *   indeterminate keys themselves.\n * - When the consumer passes `checkedKeys` as `{ checked, halfChecked }`,\n *   we keep the wire shape on the way out — same as AntD.\n * - Toggling a node propagates *down* (skipping ineligible descendants)\n *   and recomputes ancestors *up* in a single pass.\n */\nexport function useCheckboxTree(opts: UseCheckboxTreeOptions): CheckboxTree {\n  const {\n    treeData,\n    index,\n    isCheckable,\n    defaultCheckedKeys,\n    checkedKeys,\n    onCheck,\n  } = opts;\n\n  const controlled = normalizeControlledChecked(checkedKeys);\n  const isControlled = controlled != null;\n  const wantsObjectShape = checkedKeys != null && !Array.isArray(checkedKeys);\n\n  const [uncontrolledChecked, setUncontrolledChecked] = useState<Set<string>>(\n    () => new Set(defaultCheckedKeys ?? []),\n  );\n\n  const sourceChecked = isControlled\n    ? controlled!.checked\n    : uncontrolledChecked;\n\n  /**\n   * Derive `{ checked, halfChecked }` from the source-of-truth `checked` set\n   * by walking the tree bottom-up:\n   *\n   * - A parent is considered fully checked iff every eligible descendant\n   *   leaf is checked.\n   * - A parent is half-checked iff at least one eligible descendant is\n   *   checked or half-checked, but not all.\n   *\n   * Ineligible nodes (disabled / opt-out) are ignored when computing the\n   * parent's state — they neither force a parent into the unchecked nor\n   * half state.\n   */\n  const { checkedSet, halfCheckedSet } = useMemo(() => {\n    if (!isCheckable) {\n      return {\n        checkedSet: new Set<string>(),\n        halfCheckedSet: new Set<string>(),\n      };\n    }\n\n    /**\n     * If the consumer passed the object shape (`{ checked, halfChecked }`),\n     * they own the half-checked set and we use it as-is. With the array\n     * shape we still need to derive `halfChecked` ourselves — the consumer\n     * only provides `checked`, so parents should still light up\n     * indeterminate when only some descendants are checked.\n     */\n    if (isControlled && wantsObjectShape) {\n      return {\n        checkedSet: new Set(sourceChecked),\n        halfCheckedSet: new Set(controlled!.halfChecked),\n      };\n    }\n\n    const checked = new Set(sourceChecked);\n    const half = new Set<string>();\n\n    for (const root of treeData) {\n      deriveCheckedState(root, index, checked, half);\n    }\n\n    return { checkedSet: checked, halfCheckedSet: half };\n  }, [\n    isCheckable,\n    isControlled,\n    wantsObjectShape,\n    sourceChecked,\n    controlled,\n    treeData,\n    index,\n  ]);\n\n  const toggle = useEvent((key: string) => {\n    const node = index.byKey.get(key);\n    if (!node || !isNodeEligible(node)) return;\n\n    const isCurrentlyChecked = checkedSet.has(key);\n    const willCheck = !isCurrentlyChecked;\n\n    const next = new Set(sourceChecked);\n\n    const apply = (n: CubeTreeNodeData, value: boolean) => {\n      if (!isNodeEligible(n)) return;\n      if (value) next.add(n.key);\n      else next.delete(n.key);\n      const childKeys = index.childrenOf.get(n.key) ?? [];\n      for (const ck of childKeys) {\n        const child = index.byKey.get(ck);\n        if (child) apply(child, value);\n      }\n    };\n\n    apply(node, willCheck);\n\n    /**\n     * After the cascade, recompute ancestors so the public `checked` set\n     * doesn't carry parent keys that should be half-checked instead.\n     * Ancestors of `key` get visited bottom-up here.\n     */\n    let parentKey = index.parentOf.get(key);\n    while (parentKey) {\n      const parent = index.byKey.get(parentKey);\n      if (!parent) break;\n      const childKeys = index.childrenOf.get(parentKey) ?? [];\n      let allEligibleChecked = true;\n      let anyEligible = false;\n      for (const ck of childKeys) {\n        const child = index.byKey.get(ck);\n        if (!child) continue;\n        if (!isNodeEligible(child)) continue;\n        anyEligible = true;\n        if (!next.has(ck)) {\n          allEligibleChecked = false;\n          break;\n        }\n      }\n      if (anyEligible && allEligibleChecked && isNodeEligible(parent)) {\n        next.add(parentKey);\n      } else {\n        next.delete(parentKey);\n      }\n      parentKey = index.parentOf.get(parentKey);\n    }\n\n    if (!isControlled) {\n      setUncontrolledChecked(next);\n    }\n\n    if (onCheck) {\n      const finalChecked = new Set(next);\n      const finalHalf = new Set<string>();\n\n      for (const root of treeData) {\n        deriveCheckedState(root, index, finalChecked, finalHalf);\n      }\n\n      const checkedArr = Array.from(finalChecked);\n      const halfArr = Array.from(finalHalf);\n      const checkedNodes: CubeTreeNodeData[] = checkedArr\n        .map((k) => index.byKey.get(k))\n        .filter((n): n is CubeTreeNodeData => !!n);\n\n      const info: TreeOnCheckInfo = {\n        checked: willCheck,\n        node,\n        checkedNodes,\n        halfCheckedKeys: halfArr,\n      };\n\n      if (wantsObjectShape) {\n        onCheck({ checked: checkedArr, halfChecked: halfArr }, info);\n      } else {\n        onCheck(checkedArr, info);\n      }\n    }\n  });\n\n  return { checkedSet, halfCheckedSet, toggle };\n}\n"],"mappings":"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"}

package/dist/components/content/Tree/use-load-data.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { useCallback, useRef, useState } from "react";
 
 //#region src/components/content/Tree/use-load-data.ts
@@ -18,9 +18,9 @@ import { useCallback, useRef, useState } from "react";
 * `treeData` themselves (matching AntD's pattern).
 */
 function useLoadData(opts) {
-	const { nodesByKey, loadData } = opts;
+	const { nodesByKey, loadData, initialExpandedKeys } = opts;
 	const [loadingKeys, setLoadingKeys] = useState(() => /* @__PURE__ */ new Set());
-	const previousExpandedRef = useRef(/* @__PURE__ */ new Set());
+	const previousExpandedRef = useRef(new Set(initialExpandedKeys));
 	const inFlightRef = useRef(/* @__PURE__ */ new Set());
 	return {
 		loadingKeys,

package/dist/components/content/Tree/use-load-data.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-load-data.js","names":[],"sources":["../../../../src/components/content/Tree/use-load-data.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nimport type { Key } from '@react-types/shared';\nimport type { CubeTreeNodeData, TreeLoadDataNode } from './types';\n\nexport interface UseLoadDataOptions {\n  /**\n   * Map of `key -> node` built from the consumer's `treeData`. Used to\n   * find the node being expanded when `loadData` fires.\n   */\n  nodesByKey: Map<string, CubeTreeNodeData>;\n  loadData?: (node: TreeLoadDataNode) => Promise<void>;\n}\n\nexport interface LoadDataController {\n  /** Set of keys that are currently waiting on `loadData`. */\n  loadingKeys: Set<string>;\n  /**\n   * Called by `Tree.tsx` whenever the underlying React Stately state's\n   * `expandedKeys` change. We diff against the previous set, and for\n   * each newly-expanded key we trigger `loadData` if appropriate.\n   */\n  onExpandedChanged: (expandedKeys: Iterable<Key>) => void;\n}\n\n/**\n * Tracks which rows are currently fetching their children via `loadData`\n * and exposes a setter for the Tree to call after every expand change.\n *\n * `loadData` is fired exactly once per key per \"first expand\" event:\n *\n * - Skipped if there is no `loadData` callback.\n * - Skipped for leaf nodes (`isLeaf === true`).\n * - Skipped if the node already has `children` (already loaded).\n * - Skipped if a previous fetch for the same key is still in flight.\n *\n * The promise's resolution is awaited only to clear the `loading` mod;\n * the consumer is expected to commit the new children to the controlled\n * `treeData` themselves (matching AntD's pattern).\n */\nexport function useLoadData(opts: UseLoadDataOptions): LoadDataController {\n  const { nodesByKey, loadData } = opts;\n  const [loadingKeys, setLoadingKeys] = useState<Set<string>>(() => new Set());\n  const previousExpandedRef = useRef<Set<string>>(new Set());\n  const inFlightRef = useRef<Set<string>>(new Set());\n\n  const onExpandedChanged = useCallback(\n    (expandedKeys: Iterable<Key>) => {\n      const next = new Set<string>();\n      for (const k of expandedKeys) next.add(String(k));\n\n      const prev = previousExpandedRef.current;\n      const newlyExpanded: string[] = [];\n      for (const k of next) {\n        if (!prev.has(k)) newlyExpanded.push(k);\n      }\n      previousExpandedRef.current = next;\n\n      if (!loadData || newlyExpanded.length === 0) return;\n\n      let added = false;\n      const toLoad: string[] = [];\n      for (const key of newlyExpanded) {\n        const node = nodesByKey.get(key);\n        if (!node) continue;\n        if (node.isLeaf) continue;\n        if (node.children && node.children.length > 0) continue;\n        if (inFlightRef.current.has(key)) continue;\n        inFlightRef.current.add(key);\n        toLoad.push(key);\n        added = true;\n      }\n\n      if (!added) return;\n\n      setLoadingKeys((current) => {\n        const updated = new Set(current);\n        for (const k of toLoad) updated.add(k);\n        return updated;\n      });\n\n      for (const key of toLoad) {\n        Promise.resolve(loadData({ key }))\n          .catch(() => {\n            // Allow consumers to re-trigger after a rejected load by\n            // letting the next expand event re-enter this branch.\n          })\n          .finally(() => {\n            inFlightRef.current.delete(key);\n            setLoadingKeys((current) => {\n              if (!current.has(key)) return current;\n              const updated = new Set(current);\n              updated.delete(key);\n              return updated;\n            });\n          });\n      }\n    },\n    [loadData, nodesByKey],\n  );\n\n  return { loadingKeys, onExpandedChanged };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,YAAY,MAA8C;CACxE,MAAM,EAAE,YAAY,aAAa;CACjC,MAAM,CAAC,aAAa,kBAAkB,+BAA4B,IAAI,KAAK,CAAC;CAC5E,MAAM,sBAAsB,uBAAoB,IAAI,KAAK,CAAC;CAC1D,MAAM,cAAc,uBAAoB,IAAI,KAAK,CAAC;AAyDlD,QAAO;EAAE;EAAa,mBAvDI,aACvB,iBAAgC;GAC/B,MAAM,uBAAO,IAAI,KAAa;AAC9B,QAAK,MAAM,KAAK,aAAc,MAAK,IAAI,OAAO,EAAE,CAAC;GAEjD,MAAM,OAAO,oBAAoB;GACjC,MAAM,gBAA0B,EAAE;AAClC,QAAK,MAAM,KAAK,KACd,KAAI,CAAC,KAAK,IAAI,EAAE,CAAE,eAAc,KAAK,EAAE;AAEzC,uBAAoB,UAAU;AAE9B,OAAI,CAAC,YAAY,cAAc,WAAW,EAAG;GAE7C,IAAI,QAAQ;GACZ,MAAM,SAAmB,EAAE;AAC3B,QAAK,MAAM,OAAO,eAAe;IAC/B,MAAM,OAAO,WAAW,IAAI,IAAI;AAChC,QAAI,CAAC,KAAM;AACX,QAAI,KAAK,OAAQ;AACjB,QAAI,KAAK,YAAY,KAAK,SAAS,SAAS,EAAG;AAC/C,QAAI,YAAY,QAAQ,IAAI,IAAI,CAAE;AAClC,gBAAY,QAAQ,IAAI,IAAI;AAC5B,WAAO,KAAK,IAAI;AAChB,YAAQ;;AAGV,OAAI,CAAC,MAAO;AAEZ,mBAAgB,YAAY;IAC1B,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,SAAK,MAAM,KAAK,OAAQ,SAAQ,IAAI,EAAE;AACtC,WAAO;KACP;AAEF,QAAK,MAAM,OAAO,OAChB,SAAQ,QAAQ,SAAS,EAAE,KAAK,CAAC,CAAC,CAC/B,YAAY,GAGX,CACD,cAAc;AACb,gBAAY,QAAQ,OAAO,IAAI;AAC/B,oBAAgB,YAAY;AAC1B,SAAI,CAAC,QAAQ,IAAI,IAAI,CAAE,QAAO;KAC9B,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,aAAQ,OAAO,IAAI;AACnB,YAAO;MACP;KACF;KAGR,CAAC,UAAU,WAAW,CACvB;EAEwC"}
+{"version":3,"file":"use-load-data.js","names":[],"sources":["../../../../src/components/content/Tree/use-load-data.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nimport type { Key } from '@react-types/shared';\nimport type { CubeTreeNodeData, TreeLoadDataNode } from './types';\n\nexport interface UseLoadDataOptions {\n  /**\n   * Map of `key -> node` built from the consumer's `treeData`. Used to\n   * find the node being expanded when `loadData` fires.\n   */\n  nodesByKey: Map<string, CubeTreeNodeData>;\n  loadData?: (node: TreeLoadDataNode) => Promise<void>;\n  /**\n   * Keys that are expanded at mount time (controlled or default).\n   * Seeds `previousExpandedRef` so the first `onExpandedChanged` call\n   * doesn't misidentify them as user-triggered expansions.\n   */\n  initialExpandedKeys?: Iterable<string>;\n}\n\nexport interface LoadDataController {\n  /** Set of keys that are currently waiting on `loadData`. */\n  loadingKeys: Set<string>;\n  /**\n   * Called by `Tree.tsx` whenever the underlying React Stately state's\n   * `expandedKeys` change. We diff against the previous set, and for\n   * each newly-expanded key we trigger `loadData` if appropriate.\n   */\n  onExpandedChanged: (expandedKeys: Iterable<Key>) => void;\n}\n\n/**\n * Tracks which rows are currently fetching their children via `loadData`\n * and exposes a setter for the Tree to call after every expand change.\n *\n * `loadData` is fired exactly once per key per \"first expand\" event:\n *\n * - Skipped if there is no `loadData` callback.\n * - Skipped for leaf nodes (`isLeaf === true`).\n * - Skipped if the node already has `children` (already loaded).\n * - Skipped if a previous fetch for the same key is still in flight.\n *\n * The promise's resolution is awaited only to clear the `loading` mod;\n * the consumer is expected to commit the new children to the controlled\n * `treeData` themselves (matching AntD's pattern).\n */\nexport function useLoadData(opts: UseLoadDataOptions): LoadDataController {\n  const { nodesByKey, loadData, initialExpandedKeys } = opts;\n  const [loadingKeys, setLoadingKeys] = useState<Set<string>>(() => new Set());\n  const previousExpandedRef = useRef<Set<string>>(new Set(initialExpandedKeys));\n  const inFlightRef = useRef<Set<string>>(new Set());\n\n  const onExpandedChanged = useCallback(\n    (expandedKeys: Iterable<Key>) => {\n      const next = new Set<string>();\n      for (const k of expandedKeys) next.add(String(k));\n\n      const prev = previousExpandedRef.current;\n      const newlyExpanded: string[] = [];\n      for (const k of next) {\n        if (!prev.has(k)) newlyExpanded.push(k);\n      }\n      previousExpandedRef.current = next;\n\n      if (!loadData || newlyExpanded.length === 0) return;\n\n      let added = false;\n      const toLoad: string[] = [];\n      for (const key of newlyExpanded) {\n        const node = nodesByKey.get(key);\n        if (!node) continue;\n        if (node.isLeaf) continue;\n        if (node.children && node.children.length > 0) continue;\n        if (inFlightRef.current.has(key)) continue;\n        inFlightRef.current.add(key);\n        toLoad.push(key);\n        added = true;\n      }\n\n      if (!added) return;\n\n      setLoadingKeys((current) => {\n        const updated = new Set(current);\n        for (const k of toLoad) updated.add(k);\n        return updated;\n      });\n\n      for (const key of toLoad) {\n        Promise.resolve(loadData({ key }))\n          .catch(() => {\n            // Allow consumers to re-trigger after a rejected load by\n            // letting the next expand event re-enter this branch.\n          })\n          .finally(() => {\n            inFlightRef.current.delete(key);\n            setLoadingKeys((current) => {\n              if (!current.has(key)) return current;\n              const updated = new Set(current);\n              updated.delete(key);\n              return updated;\n            });\n          });\n      }\n    },\n    [loadData, nodesByKey],\n  );\n\n  return { loadingKeys, onExpandedChanged };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,YAAY,MAA8C;CACxE,MAAM,EAAE,YAAY,UAAU,wBAAwB;CACtD,MAAM,CAAC,aAAa,kBAAkB,+BAA4B,IAAI,KAAK,CAAC;CAC5E,MAAM,sBAAsB,OAAoB,IAAI,IAAI,oBAAoB,CAAC;CAC7E,MAAM,cAAc,uBAAoB,IAAI,KAAK,CAAC;AAyDlD,QAAO;EAAE;EAAa,mBAvDI,aACvB,iBAAgC;GAC/B,MAAM,uBAAO,IAAI,KAAa;AAC9B,QAAK,MAAM,KAAK,aAAc,MAAK,IAAI,OAAO,EAAE,CAAC;GAEjD,MAAM,OAAO,oBAAoB;GACjC,MAAM,gBAA0B,EAAE;AAClC,QAAK,MAAM,KAAK,KACd,KAAI,CAAC,KAAK,IAAI,EAAE,CAAE,eAAc,KAAK,EAAE;AAEzC,uBAAoB,UAAU;AAE9B,OAAI,CAAC,YAAY,cAAc,WAAW,EAAG;GAE7C,IAAI,QAAQ;GACZ,MAAM,SAAmB,EAAE;AAC3B,QAAK,MAAM,OAAO,eAAe;IAC/B,MAAM,OAAO,WAAW,IAAI,IAAI;AAChC,QAAI,CAAC,KAAM;AACX,QAAI,KAAK,OAAQ;AACjB,QAAI,KAAK,YAAY,KAAK,SAAS,SAAS,EAAG;AAC/C,QAAI,YAAY,QAAQ,IAAI,IAAI,CAAE;AAClC,gBAAY,QAAQ,IAAI,IAAI;AAC5B,WAAO,KAAK,IAAI;AAChB,YAAQ;;AAGV,OAAI,CAAC,MAAO;AAEZ,mBAAgB,YAAY;IAC1B,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,SAAK,MAAM,KAAK,OAAQ,SAAQ,IAAI,EAAE;AACtC,WAAO;KACP;AAEF,QAAK,MAAM,OAAO,OAChB,SAAQ,QAAQ,SAAS,EAAE,KAAK,CAAC,CAAC,CAC/B,YAAY,GAGX,CACD,cAAc;AACb,gBAAY,QAAQ,OAAO,IAAI;AAC/B,oBAAgB,YAAY;AAC1B,SAAI,CAAC,QAAQ,IAAI,IAAI,CAAE,QAAO;KAC9B,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,aAAQ,OAAO,IAAI;AACnB,YAAO;MACP;KACF;KAGR,CAAC,UAAU,WAAW,CACvB;EAEwC"}

package/dist/components/content/highlightText.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-ad23b00 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c76c00e | Cube Dev Team */
 import { _Text } from "./Text.js";
 import { jsx } from "react/jsx-runtime";