@cube-dev/ui-kit 0.182.0 → 0.183.0

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 { 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) {\n    // No eligible descendants — this node behaves like a leaf for\n    // checking purposes: its own checked state stands as-is.\n    half.delete(node.key);\n  } else if (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    half.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  /**\n   * Normalize the controlled `checkedKeys` prop into stable `Set` instances.\n   * Memoized on the `checkedKeys` reference so unrelated re-renders don't\n   * invalidate the derivation memo below — `normalizeControlledChecked`\n   * allocates fresh `Set`s each call, which would otherwise force\n   * `deriveCheckedState` to re-walk the entire tree on every render in\n   * controlled mode.\n   */\n  const controlled = useMemo(\n    () => normalizeControlledChecked(checkedKeys),\n    [checkedKeys],\n  );\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    /**\n     * Seed from the derived `checkedSet`, not `sourceChecked`. The\n     * source-of-truth set may only contain leaf keys (e.g. when\n     * `defaultCheckedKeys` is leaf-only, or a consumer in controlled-array\n     * mode passes only leaves). The ancestor walk below decides whether\n     * each ancestor is fully checked by inspecting its direct children\n     * via `next.has(ck)` — those children may themselves be inner nodes\n     * whose \"fully checked\" status only exists in the derived set. Seeding\n     * from `sourceChecked` causes a sibling subtree's parent key to be\n     * missing from `next`, which would incorrectly drop the grandparent\n     * from the stored state (the next render's `useMemo` self-corrects,\n     * but the intermediate stored value violates the cascade invariant).\n     */\n    const next = new Set(checkedSet);\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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"}
+{"version":3,"file":"use-checkbox-tree.js","names":["useMemo","useState","useEvent","Key","TreeIndex","CubeTreeNodeData","TreeOnCheckInfo","UseCheckboxTreeOptions","treeData","index","isCheckable","defaultCheckedKeys","checkedKeys","checked","halfChecked","onCheck","info","CheckboxTree","checkedSet","Set","halfCheckedSet","toggle","key","isNodeEligible","node","isDisabled","isCheckboxDisabled","deriveCheckedState","half","allChecked","anyChecked","anyEligible","childKeys","childrenOf","get","length","eligible","isChecked","has","childKey","child","byKey","r","delete","add","normalizeControlledChecked","controlled","Array","isArray","useCheckboxTree","opts","$","_c","t0","isControlled","wantsObjectShape","t1","uncontrolledChecked","setUncontrolledChecked","sourceChecked","t2","bb0","t3","Symbol","for","t4","t5","root","isCurrentlyChecked","willCheck","next","apply","n","value","ck","parentKey","parentOf","parent","childKeys_0","allEligibleChecked","ck_0","child_0","finalChecked","finalHalf","root_0","checkedArr","from","halfArr","checkedNodes","map","k","filter","_temp","halfCheckedKeys","n_0"],"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) {\n    // No eligible descendants — this node behaves like a leaf for\n    // checking purposes: its own checked state stands as-is.\n    half.delete(node.key);\n  } else if (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    half.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  /**\n   * Normalize the controlled `checkedKeys` prop into stable `Set` instances.\n   * Memoized on the `checkedKeys` reference so unrelated re-renders don't\n   * invalidate the derivation memo below — `normalizeControlledChecked`\n   * allocates fresh `Set`s each call, which would otherwise force\n   * `deriveCheckedState` to re-walk the entire tree on every render in\n   * controlled mode.\n   */\n  const controlled = useMemo(\n    () => normalizeControlledChecked(checkedKeys),\n    [checkedKeys],\n  );\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    /**\n     * Seed from the derived `checkedSet`, not `sourceChecked`. The\n     * source-of-truth set may only contain leaf keys (e.g. when\n     * `defaultCheckedKeys` is leaf-only, or a consumer in controlled-array\n     * mode passes only leaves). The ancestor walk below decides whether\n     * each ancestor is fully checked by inspecting its direct children\n     * via `next.has(ck)` — those children may themselves be inner nodes\n     * whose \"fully checked\" status only exists in the derived set. Seeding\n     * from `sourceChecked` causes a sibling subtree's parent key to be\n     * missing from `next`, which would incorrectly drop the grandparent\n     * from the stored state (the next render's `useMemo` self-corrects,\n     * but the intermediate stored value violates the cascade invariant).\n     */\n    const next = new Set(checkedSet);\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,6 +1,7 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { isDevEnvOrTest } from "../../../utils/is-dev-env.js";
+import { c } from "react-compiler-runtime";
 import { useRef, useState } from "react";
 
 //#region src/components/content/Tree/use-load-data.ts
@@ -20,18 +21,30 @@ import { useRef, useState } from "react";
 * `treeData` themselves (matching AntD's pattern).
 */
 function useLoadData(opts) {
+	const $ = c(9);
 	const { nodesByKey, loadData, initialExpandedKeys } = opts;
-	const [loadingKeys, setLoadingKeys] = useState(() => /* @__PURE__ */ new Set());
-	const previousExpandedRef = useRef(new Set(initialExpandedKeys));
-	const inFlightRef = useRef(/* @__PURE__ */ new Set());
-	return {
-		loadingKeys,
-		onExpandedChanged: useEvent((expandedKeys) => {
+	const [loadingKeys, setLoadingKeys] = useState(_temp);
+	let t0;
+	if ($[0] !== initialExpandedKeys) {
+		t0 = new Set(initialExpandedKeys);
+		$[0] = initialExpandedKeys;
+		$[1] = t0;
+	} else t0 = $[1];
+	const previousExpandedRef = useRef(t0);
+	let t1;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = /* @__PURE__ */ new Set();
+		$[2] = t1;
+	} else t1 = $[2];
+	const inFlightRef = useRef(t1);
+	let t2;
+	if ($[3] !== loadData || $[4] !== nodesByKey) {
+		t2 = (expandedKeys) => {
 			const next = /* @__PURE__ */ new Set();
 			for (const k of expandedKeys) next.add(String(k));
 			const prev = previousExpandedRef.current;
 			const newlyExpanded = [];
-			for (const k of next) if (!prev.has(k)) newlyExpanded.push(k);
+			for (const k_0 of next) if (!prev.has(k_0)) newlyExpanded.push(k_0);
 			previousExpandedRef.current = next;
 			if (!loadData || newlyExpanded.length === 0) return;
 			const toLoad = [];
@@ -47,28 +60,46 @@ function useLoadData(opts) {
 			if (toLoad.length === 0) return;
 			setLoadingKeys((current) => {
 				const updated = new Set(current);
-				for (const k of toLoad) updated.add(k);
+				for (const k_1 of toLoad) updated.add(k_1);
 				return updated;
 			});
-			for (const key of toLoad) {
-				const loadNode = nodesByKey.get(key);
+			for (const key_0 of toLoad) {
+				const loadNode = nodesByKey.get(key_0);
 				Promise.resolve(loadData({
-					key,
+					key: key_0,
 					children: loadNode?.children
 				})).catch((err) => {
-					if (isDevEnvOrTest()) console.error(`[Tree] loadData failed for key "${key}":`, err);
+					if (isDevEnvOrTest()) console.error(`[Tree] loadData failed for key "${key_0}":`, err);
 				}).finally(() => {
-					inFlightRef.current.delete(key);
-					setLoadingKeys((current) => {
-						if (!current.has(key)) return current;
-						const updated = new Set(current);
-						updated.delete(key);
-						return updated;
+					inFlightRef.current.delete(key_0);
+					setLoadingKeys((current_0) => {
+						if (!current_0.has(key_0)) return current_0;
+						const updated_0 = new Set(current_0);
+						updated_0.delete(key_0);
+						return updated_0;
 					});
 				});
 			}
-		})
-	};
+		};
+		$[3] = loadData;
+		$[4] = nodesByKey;
+		$[5] = t2;
+	} else t2 = $[5];
+	const onExpandedChanged = useEvent(t2);
+	let t3;
+	if ($[6] !== loadingKeys || $[7] !== onExpandedChanged) {
+		t3 = {
+			loadingKeys,
+			onExpandedChanged
+		};
+		$[6] = loadingKeys;
+		$[7] = onExpandedChanged;
+		$[8] = t3;
+	} else t3 = $[8];
+	return t3;
+}
+function _temp() {
+	return /* @__PURE__ */ new Set();
 }
 
 //#endregion

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 { useRef, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\nimport { isDevEnvOrTest } from '../../../utils/is-dev-env';\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 = useEvent((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    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    }\n\n    if (toLoad.length === 0) 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      const loadNode = nodesByKey.get(key);\n      Promise.resolve(loadData({ key, children: loadNode?.children }))\n        .catch((err) => {\n          if (isDevEnvOrTest()) {\n            console.error(`[Tree] loadData failed for key \"${key}\":`, err);\n          }\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\n  return { loadingKeys, onExpandedChanged };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAiDA,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;AAsDlD,QAAO;EAAE;EAAa,mBApDI,UAAU,iBAAgC;GAClE,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,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;;AAGlB,OAAI,OAAO,WAAW,EAAG;AAEzB,mBAAgB,YAAY;IAC1B,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,SAAK,MAAM,KAAK,OAAQ,SAAQ,IAAI,EAAE;AACtC,WAAO;KACP;AAEF,QAAK,MAAM,OAAO,QAAQ;IACxB,MAAM,WAAW,WAAW,IAAI,IAAI;AACpC,YAAQ,QAAQ,SAAS;KAAE;KAAK,UAAU,UAAU;KAAU,CAAC,CAAC,CAC7D,OAAO,QAAQ;AACd,SAAI,gBAAgB,CAClB,SAAQ,MAAM,mCAAmC,IAAI,KAAK,IAAI;MAEhE,CACD,cAAc;AACb,iBAAY,QAAQ,OAAO,IAAI;AAC/B,qBAAgB,YAAY;AAC1B,UAAI,CAAC,QAAQ,IAAI,IAAI,CAAE,QAAO;MAC9B,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,cAAQ,OAAO,IAAI;AACnB,aAAO;OACP;MACF;;IAEN;EAEuC"}
+{"version":3,"file":"use-load-data.js","names":["useRef","useState","useEvent","isDevEnvOrTest","Key","CubeTreeNodeData","TreeLoadDataNode","UseLoadDataOptions","nodesByKey","Map","loadData","node","Promise","initialExpandedKeys","Iterable","LoadDataController","loadingKeys","Set","onExpandedChanged","expandedKeys","useLoadData","opts","$","_c","setLoadingKeys","_temp","t0","previousExpandedRef","t1","Symbol","for","inFlightRef","t2","next","k","add","String","prev","current","newlyExpanded","k_0","has","push","length","toLoad","key","get","isLeaf","children","updated","k_1","key_0","loadNode","resolve","catch","err","console","error","finally","delete","current_0","updated_0","t3"],"sources":["../../../../src/components/content/Tree/use-load-data.ts"],"sourcesContent":["import { useRef, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\nimport { isDevEnvOrTest } from '../../../utils/is-dev-env';\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 = useEvent((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    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    }\n\n    if (toLoad.length === 0) 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      const loadNode = nodesByKey.get(key);\n      Promise.resolve(loadData({ key, children: loadNode?.children }))\n        .catch((err) => {\n          if (isDevEnvOrTest()) {\n            console.error(`[Tree] loadData failed for key \"${key}\":`, err);\n          }\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\n  return { loadingKeys, onExpandedChanged };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAiDA,SAAOoB,YAAAC,MAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CACL,MAAA,EAAAf,YAAAE,UAAAG,wBAAsDQ;CACtD,MAAA,CAAAL,aAAAQ,kBAAsCvB,SAAsBwB,MAAgB;CAAC,IAAAC;AAAA,KAAAJ,EAAA,OAAAT,qBAAA;AAC7Ba,OAAA,IAAIT,IAAIJ,oBAAoB;AAAAS,IAAA,KAAAT;AAAAS,IAAA,KAAAI;OAAAA,MAAAJ,EAAA;CAA5E,MAAAK,sBAA4B3B,OAAoB0B,GAA6B;CAAC,IAAAE;AAAA,KAAAN,EAAA,OAAAO,OAAAC,IAAA,4BAAA,EAAA;AACtCF,uBAAA,IAAIX,KAAK;AAAAK,IAAA,KAAAM;OAAAA,MAAAN,EAAA;CAAjD,MAAAS,cAAoB/B,OAAoB4B,GAAU;CAAC,IAAAI;AAAA,KAAAV,EAAA,OAAAZ,YAAAY,EAAA,OAAAd,YAAA;AAEhBwB,QAAAb,iBAAA;GACjC,MAAAc,uBAAa,IAAIhB,KAAa;AAC9B,QAAK,MAAAiB,KAAWf,aAAcc,MAAIE,IAAKC,OAAOF,EAAE,CAAC;GAEjD,MAAAG,OAAaV,oBAAmBW;GAChC,MAAAC,gBAAgC,EAAE;AAClC,QAAK,MAAAC,OAAWP,KACd,KAAI,CAACI,KAAII,IAAKP,IAAE,CAAEK,eAAaG,KAAMR,IAAE;AAEzCP,uBAAmBW,UAAWL;AAE9B,OAAI,CAACvB,YAAY6B,cAAaI,WAAY,EAAC;GAE3C,MAAAC,SAAyB,EAAE;AAC3B,QAAK,MAAAC,OAAaN,eAAa;IAC7B,MAAA5B,OAAaH,WAAUsC,IAAKD,IAAI;AAChC,QAAI,CAAClC,KAAM;AACX,QAAIA,KAAIoC,OAAS;AACjB,QAAIpC,KAAIqC,YAAarC,KAAIqC,SAASL,SAAU,EAAG;AAC/C,QAAIZ,YAAWO,QAAQG,IAAKI,IAAI,CAAE;AAClCd,gBAAWO,QAAQH,IAAKU,IAAI;AAC5BD,WAAMF,KAAMG,IAAI;;AAGlB,OAAID,OAAMD,WAAY,EAAC;AAEvBnB,mBAAec,YAAA;IACb,MAAAW,UAAgB,IAAIhC,IAAIqB,QAAQ;AAChC,SAAK,MAAAY,OAAWN,OAAQK,SAAOd,IAAKD,IAAE;AAAC,WAChCe;KACP;AAEF,QAAK,MAAAE,SAAaP,QAAM;IACtB,MAAAQ,WAAiB5C,WAAUsC,IAAKD,MAAI;AACpCjC,YAAOyC,QAAS3C,SAAS;KAAAmC,KAAEA;KAAGG,UAAYI,UAAQJ;KAAY,CAAC,CAAC,CAAAM,OACvDC,QAAA;AACL,SAAIpD,gBAAgB,CAClBqD,SAAOC,MAAO,mCAAmCZ,MAAG,KAAMU,IAAI;MAEhE,CAAAG,cACO;AACP3B,iBAAWO,QAAQqB,OAAQd,MAAI;AAC/BrB,qBAAeoC,cAAA;AACb,UAAI,CAACtB,UAAOG,IAAKI,MAAI,CAAA,QAASP;MAC9B,MAAAuB,YAAgB,IAAI5C,IAAIqB,UAAQ;AAChCW,gBAAOU,OAAQd,MAAI;AAAA,aACZI;OACP;MACF;;;AAEP3B,IAAA,KAAAZ;AAAAY,IAAA,KAAAd;AAAAc,IAAA,KAAAU;OAAAA,MAAAV,EAAA;CAlDD,MAAAJ,oBAA0BhB,SAAS8B,GAkDjC;CAAC,IAAA8B;AAAA,KAAAxC,EAAA,OAAAN,eAAAM,EAAA,OAAAJ,mBAAA;AAEI4C,OAAA;GAAA9C;GAAAE;GAAkC;AAAAI,IAAA,KAAAN;AAAAM,IAAA,KAAAJ;AAAAI,IAAA,KAAAwC;OAAAA,MAAAxC,EAAA;AAAA,QAAlCwC;;AA1DF,SAAArC,QAAA;AAAA,wBAE6D,IAAIR,KAAK"}

package/dist/components/content/highlightText.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"highlightText.js","names":["Text"],"sources":["../../../src/components/content/highlightText.tsx"],"sourcesContent":["import { Styles } from '@tenphi/tasty';\nimport { ReactNode } from 'react';\n\nimport { Text } from './Text';\n\n/**\n * Highlights occurrences of a search string within text.\n * Returns an array of ReactNodes with highlighted portions wrapped in Text.Highlight.\n */\nexport function highlightText(\n  text: string,\n  highlight: string,\n  caseSensitive: boolean,\n  highlightStyles?: Styles,\n): ReactNode[] {\n  if (!highlight) {\n    return [text];\n  }\n\n  const flags = caseSensitive ? 'g' : 'gi';\n  const escapedHighlight = highlight.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  const regex = new RegExp(`(${escapedHighlight})`, flags);\n  const parts = text.split(regex);\n\n  return parts.map((part, index) => {\n    const isMatch = caseSensitive\n      ? part === highlight\n      : part.toLowerCase() === highlight.toLowerCase();\n\n    if (isMatch) {\n      return (\n        <Text.Highlight key={index} styles={highlightStyles}>\n          {part}\n        </Text.Highlight>\n      );\n    }\n    return part;\n  });\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,cACd,MACA,WACA,eACA,iBACa;AACb,KAAI,CAAC,UACH,QAAO,CAAC,KAAK;CAGf,MAAM,QAAQ,gBAAgB,MAAM;CACpC,MAAM,mBAAmB,UAAU,QAAQ,uBAAuB,OAAO;CACzE,MAAM,QAAQ,IAAI,OAAO,IAAI,iBAAiB,IAAI,MAAM;AAGxD,QAFc,KAAK,MAAM,MAAM,CAElB,KAAK,MAAM,UAAU;AAKhC,MAJgB,gBACZ,SAAS,YACT,KAAK,aAAa,KAAK,UAAU,aAAa,CAGhD,QACE,oBAACA,MAAK;GAAsB,QAAQ;aACjC;KADkB,MAEJ;AAGrB,SAAO;GACP"}
+{"version":3,"file":"highlightText.js","names":["Styles","ReactNode","Text","highlightText","text","highlight","caseSensitive","highlightStyles","flags","escapedHighlight","replace","regex","RegExp","parts","split","map","part","index","isMatch","toLowerCase"],"sources":["../../../src/components/content/highlightText.tsx"],"sourcesContent":["import { Styles } from '@tenphi/tasty';\nimport { ReactNode } from 'react';\n\nimport { Text } from './Text';\n\n/**\n * Highlights occurrences of a search string within text.\n * Returns an array of ReactNodes with highlighted portions wrapped in Text.Highlight.\n */\nexport function highlightText(\n  text: string,\n  highlight: string,\n  caseSensitive: boolean,\n  highlightStyles?: Styles,\n): ReactNode[] {\n  if (!highlight) {\n    return [text];\n  }\n\n  const flags = caseSensitive ? 'g' : 'gi';\n  const escapedHighlight = highlight.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  const regex = new RegExp(`(${escapedHighlight})`, flags);\n  const parts = text.split(regex);\n\n  return parts.map((part, index) => {\n    const isMatch = caseSensitive\n      ? part === highlight\n      : part.toLowerCase() === highlight.toLowerCase();\n\n    if (isMatch) {\n      return (\n        <Text.Highlight key={index} styles={highlightStyles}>\n          {part}\n        </Text.Highlight>\n      );\n    }\n    return part;\n  });\n}\n"],"mappings":";;;;;;;;;AASA,SAAgBG,cACdC,MACAC,WACAC,eACAC,iBACa;AACb,KAAI,CAACF,UACH,QAAO,CAACD,KAAK;CAGf,MAAMI,QAAQF,gBAAgB,MAAM;CACpC,MAAMG,mBAAmBJ,UAAUK,QAAQ,uBAAuB,OAAO;CACzE,MAAMC,QAAQ,IAAIC,OAAO,IAAIH,iBAAgB,IAAKD,MAAM;AAGxD,QAFcJ,KAAKU,MAAMH,MAAM,CAElBI,KAAKC,MAAMC,UAAU;AAKhC,MAJgBX,gBACZU,SAASX,YACTW,KAAKG,aAAa,KAAKd,UAAUc,aAAa,CAGhD,QACE,oBAAC,MAAK;GAAsB,QAAQZ;aACjCS;KADkBC,MAEJ;AAGrB,SAAOD;GACP"}

package/dist/components/content/use-auto-tooltip.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { TooltipProvider } from "../overlays/Tooltip/TooltipProvider.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";

package/dist/components/content/use-auto-tooltip.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-auto-tooltip.js","names":[],"sources":["../../../src/components/content/use-auto-tooltip.tsx"],"sourcesContent":["import {\n  HTMLAttributes,\n  ReactNode,\n  RefObject,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { OverlayProps } from 'react-aria';\n\nimport {\n  CubeTooltipProviderProps,\n  TooltipProvider,\n} from '../overlays/Tooltip/TooltipProvider';\n\nimport type { Props } from '../../props';\n\nexport type AutoTooltipValue =\n  | string\n  | boolean\n  | (Omit<CubeTooltipProviderProps, 'children'> & { auto?: boolean });\n\nexport interface UseAutoTooltipOptions {\n  tooltip: AutoTooltipValue | undefined;\n  children: ReactNode;\n  labelProps?: Props;\n  isDynamicLabel?: boolean;\n}\n\nexport function useAutoTooltip({\n  tooltip,\n  children,\n  labelProps,\n  isDynamicLabel = false,\n}: UseAutoTooltipOptions) {\n  // Determine if auto tooltip is enabled\n  // Auto tooltip only works when children is a string (overflow detection needs text)\n  const isAutoTooltipEnabled = useMemo(() => {\n    if (typeof children !== 'string') return false;\n\n    // Boolean true enables auto overflow detection\n    if (tooltip === true) return true;\n    if (typeof tooltip === 'object') {\n      // If title is provided and auto is explicitly true, enable auto overflow detection\n      if (tooltip.title) {\n        return tooltip.auto === true;\n      }\n\n      // If no title is provided, default to auto=true unless explicitly disabled\n      const autoValue = tooltip.auto !== undefined ? tooltip.auto : true;\n      return !!autoValue;\n    }\n    return false;\n  }, [tooltip, children]);\n\n  // Track label overflow for auto tooltip (only when enabled)\n  const externalLabelRef = (labelProps as any)?.ref;\n  const [isLabelOverflowed, setIsLabelOverflowed] = useState(false);\n  const elementRef = useRef<HTMLElement | null>(null);\n  const resizeObserverRef = useRef<ResizeObserver | null>(null);\n\n  const measurePendingRef = useRef(false);\n\n  const checkLabelOverflow = useCallback(() => {\n    const label = elementRef.current;\n\n    if (!label) return;\n\n    setIsLabelOverflowed(label.scrollWidth > label.clientWidth);\n  }, []);\n\n  /**\n   * Measure once the current task has finished, not inside it.\n   *\n   * A microtask runs after React's whole commit — every mutation, layout effect\n   * and ref attachment — and before paint. Every label on the page therefore\n   * reads after all of them have written, so the reads collapse into one style\n   * and layout flush instead of forcing one each, mid-commit. Reading straight\n   * from the callback ref is what cost 122ms of `get scrollWidth` in one Cloud\n   * profile, more than the entire style engine.\n   *\n   * A microtask rather than the observer's first delivery: observer callbacks\n   * are part of the rendering steps, so a runner that is not producing frames —\n   * a background tab, or a headless browser running many stories at once — can\n   * delay them past the point something asks whether the tooltip is active.\n   * Microtasks do not depend on a frame.\n   */\n  const scheduleLabelOverflowCheck = useCallback(() => {\n    if (measurePendingRef.current) return;\n\n    measurePendingRef.current = true;\n\n    queueMicrotask(() => {\n      measurePendingRef.current = false;\n      checkLabelOverflow();\n    });\n  }, [checkLabelOverflow]);\n\n  useEffect(() => {\n    if (isAutoTooltipEnabled) {\n      checkLabelOverflow();\n\n      return;\n    }\n\n    // Clearing here rather than in the callback ref, which cannot be trusted\n    // to do it. Flipping `isAutoTooltipEnabled` changes the ref's identity, so\n    // React detaches with the PREVIOUS callback — the one that still believes\n    // auto tooltips are on, and therefore keeps the last verdict — and only\n    // attaches the new one if the label still exists. When `children` stops\n    // being a string the label unmounts, so the new callback never runs and a\n    // stale `true` would keep an auto tooltip mounted over content that is no\n    // longer text. That is the default `Button` path, where `tooltip` is `true`.\n    setIsLabelOverflowed(false);\n  }, [isAutoTooltipEnabled, checkLabelOverflow]);\n\n  // Attach ResizeObserver via callback ref to handle DOM node changes\n  const handleLabelElementRef = useCallback(\n    (element: HTMLElement | null) => {\n      // Call external callback ref to notify external refs\n      if (externalLabelRef) {\n        if (typeof externalLabelRef === 'function') {\n          externalLabelRef(element);\n        } else {\n          (externalLabelRef as any).current = element;\n        }\n      }\n\n      // Disconnect previous observer\n      if (resizeObserverRef.current) {\n        try {\n          resizeObserverRef.current.disconnect();\n        } catch {\n          // do nothing\n        }\n        resizeObserverRef.current = null;\n      }\n\n      elementRef.current = element;\n\n      if (!isAutoTooltipEnabled) {\n        setIsLabelOverflowed(false);\n\n        return;\n      }\n\n      // No node to measure. Leave the previous verdict alone rather than\n      // clearing it: turning the verdict on mounts `TooltipProvider`, which\n      // remounts the label underneath it, so React detaches the old node and\n      // attaches a new one within that commit. Clearing here would unmount the\n      // provider, remount the label, measure it, mount the provider again — a\n      // loop that never settles.\n      if (!element) return;\n\n      // Do NOT measure synchronously here — see `scheduleLabelOverflowCheck`.\n      // This covers the node the ref just handed us, including the fresh one\n      // React creates when `TooltipProvider` mounts and remounts the label.\n      scheduleLabelOverflowCheck();\n\n      // The observer covers every later size change.\n      const obs = new ResizeObserver(() => {\n        checkLabelOverflow();\n      });\n\n      resizeObserverRef.current = obs;\n\n      obs.observe(element);\n    },\n    [\n      externalLabelRef,\n      isAutoTooltipEnabled,\n      checkLabelOverflow,\n      scheduleLabelOverflowCheck,\n    ],\n  );\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      if (resizeObserverRef.current) {\n        try {\n          resizeObserverRef.current.disconnect();\n        } catch {\n          // do nothing\n        }\n        resizeObserverRef.current = null;\n      }\n      elementRef.current = null;\n    };\n  }, []);\n\n  const finalLabelProps = useMemo(() => {\n    const props = {\n      ...(labelProps || {}),\n    };\n\n    delete props.ref;\n\n    return props;\n  }, [labelProps]);\n\n  /**\n   * The `TooltipProvider` props this tooltip resolves to, or `null` when no\n   * tooltip is rendered at all. Resolved once so that both the rendering below\n   * and `isTooltipActive` speak about the same tooltip.\n   */\n  const resolvedTooltip = useMemo<Omit<\n    CubeTooltipProviderProps,\n    'children'\n  > | null>(() => {\n    if (!tooltip) return null;\n\n    // String tooltip - simple case\n    if (typeof tooltip === 'string') {\n      return { title: tooltip };\n    }\n\n    const hasAutoContent =\n      !!(children || labelProps) && (isLabelOverflowed || isDynamicLabel);\n\n    // Boolean tooltip - auto tooltip on overflow\n    if (tooltip === true) {\n      if (!hasAutoContent) return null;\n\n      return {\n        title: children,\n        isDisabled: !isLabelOverflowed && isDynamicLabel,\n      };\n    }\n\n    // Object tooltip - advanced configuration\n    const { auto, ...tooltipProps } = tooltip;\n\n    // If title is provided and auto is not explicitly true, always show the tooltip\n    if (tooltipProps.title && auto !== true) {\n      return tooltipProps;\n    }\n\n    // If title is provided with auto=true, OR no title but auto behavior enabled\n    if (!hasAutoContent) return null;\n\n    return {\n      title: tooltipProps.title ?? children,\n      isDisabled:\n        !isLabelOverflowed &&\n        isDynamicLabel &&\n        tooltipProps.isDisabled !== true,\n      ...tooltipProps,\n    };\n  }, [tooltip, children, labelProps, isLabelOverflowed, isDynamicLabel]);\n\n  /** Whether a tooltip is rendered and able to open. */\n  const isTooltipActive =\n    !!resolvedTooltip && resolvedTooltip.isDisabled !== true;\n\n  const renderWithTooltip = (\n    renderElement: (\n      tooltipTriggerProps?: HTMLAttributes<HTMLElement>,\n      tooltipRef?: RefObject<HTMLElement>,\n    ) => ReactNode,\n    defaultTooltipPlacement: OverlayProps['placement'],\n  ) => {\n    if (!resolvedTooltip) return renderElement();\n\n    return (\n      <TooltipProvider placement={defaultTooltipPlacement} {...resolvedTooltip}>\n        {(triggerProps, ref) => renderElement(triggerProps, ref)}\n      </TooltipProvider>\n    );\n  };\n\n  return {\n    labelRef: handleLabelElementRef,\n    labelProps: finalLabelProps,\n    isLabelOverflowed,\n    isAutoTooltipEnabled,\n    hasTooltip: !!tooltip,\n    isTooltipActive,\n    renderWithTooltip,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-auto-tooltip.js","names":["HTMLAttributes","ReactNode","RefObject","useCallback","useEffect","useMemo","useRef","useState","OverlayProps","CubeTooltipProviderProps","TooltipProvider","Props","AutoTooltipValue","Omit","auto","UseAutoTooltipOptions","tooltip","children","labelProps","isDynamicLabel","useAutoTooltip","isAutoTooltipEnabled","title","autoValue","undefined","externalLabelRef","ref","isLabelOverflowed","setIsLabelOverflowed","elementRef","HTMLElement","resizeObserverRef","ResizeObserver","measurePendingRef","checkLabelOverflow","label","current","scrollWidth","clientWidth","scheduleLabelOverflowCheck","queueMicrotask","handleLabelElementRef","element","disconnect","obs","observe","finalLabelProps","props","resolvedTooltip","hasAutoContent","isDisabled","tooltipProps","isTooltipActive","renderWithTooltip","renderElement","tooltipTriggerProps","tooltipRef","defaultTooltipPlacement","triggerProps","labelRef","hasTooltip"],"sources":["../../../src/components/content/use-auto-tooltip.tsx"],"sourcesContent":["import {\n  HTMLAttributes,\n  ReactNode,\n  RefObject,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { OverlayProps } from 'react-aria';\n\nimport {\n  CubeTooltipProviderProps,\n  TooltipProvider,\n} from '../overlays/Tooltip/TooltipProvider';\n\nimport type { Props } from '../../props';\n\nexport type AutoTooltipValue =\n  | string\n  | boolean\n  | (Omit<CubeTooltipProviderProps, 'children'> & { auto?: boolean });\n\nexport interface UseAutoTooltipOptions {\n  tooltip: AutoTooltipValue | undefined;\n  children: ReactNode;\n  labelProps?: Props;\n  isDynamicLabel?: boolean;\n}\n\nexport function useAutoTooltip({\n  tooltip,\n  children,\n  labelProps,\n  isDynamicLabel = false,\n}: UseAutoTooltipOptions) {\n  // Determine if auto tooltip is enabled\n  // Auto tooltip only works when children is a string (overflow detection needs text)\n  const isAutoTooltipEnabled = useMemo(() => {\n    if (typeof children !== 'string') return false;\n\n    // Boolean true enables auto overflow detection\n    if (tooltip === true) return true;\n    if (typeof tooltip === 'object') {\n      // If title is provided and auto is explicitly true, enable auto overflow detection\n      if (tooltip.title) {\n        return tooltip.auto === true;\n      }\n\n      // If no title is provided, default to auto=true unless explicitly disabled\n      const autoValue = tooltip.auto !== undefined ? tooltip.auto : true;\n      return !!autoValue;\n    }\n    return false;\n  }, [tooltip, children]);\n\n  // Track label overflow for auto tooltip (only when enabled)\n  const externalLabelRef = (labelProps as any)?.ref;\n  const [isLabelOverflowed, setIsLabelOverflowed] = useState(false);\n  const elementRef = useRef<HTMLElement | null>(null);\n  const resizeObserverRef = useRef<ResizeObserver | null>(null);\n\n  const measurePendingRef = useRef(false);\n\n  const checkLabelOverflow = useCallback(() => {\n    const label = elementRef.current;\n\n    if (!label) return;\n\n    setIsLabelOverflowed(label.scrollWidth > label.clientWidth);\n  }, []);\n\n  /**\n   * Measure once the current task has finished, not inside it.\n   *\n   * A microtask runs after React's whole commit — every mutation, layout effect\n   * and ref attachment — and before paint. Every label on the page therefore\n   * reads after all of them have written, so the reads collapse into one style\n   * and layout flush instead of forcing one each, mid-commit. Reading straight\n   * from the callback ref is what cost 122ms of `get scrollWidth` in one Cloud\n   * profile, more than the entire style engine.\n   *\n   * A microtask rather than the observer's first delivery: observer callbacks\n   * are part of the rendering steps, so a runner that is not producing frames —\n   * a background tab, or a headless browser running many stories at once — can\n   * delay them past the point something asks whether the tooltip is active.\n   * Microtasks do not depend on a frame.\n   */\n  const scheduleLabelOverflowCheck = useCallback(() => {\n    if (measurePendingRef.current) return;\n\n    measurePendingRef.current = true;\n\n    queueMicrotask(() => {\n      measurePendingRef.current = false;\n      checkLabelOverflow();\n    });\n  }, [checkLabelOverflow]);\n\n  useEffect(() => {\n    if (isAutoTooltipEnabled) {\n      checkLabelOverflow();\n\n      return;\n    }\n\n    // Clearing here rather than in the callback ref, which cannot be trusted\n    // to do it. Flipping `isAutoTooltipEnabled` changes the ref's identity, so\n    // React detaches with the PREVIOUS callback — the one that still believes\n    // auto tooltips are on, and therefore keeps the last verdict — and only\n    // attaches the new one if the label still exists. When `children` stops\n    // being a string the label unmounts, so the new callback never runs and a\n    // stale `true` would keep an auto tooltip mounted over content that is no\n    // longer text. That is the default `Button` path, where `tooltip` is `true`.\n    setIsLabelOverflowed(false);\n  }, [isAutoTooltipEnabled, checkLabelOverflow]);\n\n  // Attach ResizeObserver via callback ref to handle DOM node changes\n  const handleLabelElementRef = useCallback(\n    (element: HTMLElement | null) => {\n      // Call external callback ref to notify external refs\n      if (externalLabelRef) {\n        if (typeof externalLabelRef === 'function') {\n          externalLabelRef(element);\n        } else {\n          (externalLabelRef as any).current = element;\n        }\n      }\n\n      // Disconnect previous observer\n      if (resizeObserverRef.current) {\n        try {\n          resizeObserverRef.current.disconnect();\n        } catch {\n          // do nothing\n        }\n        resizeObserverRef.current = null;\n      }\n\n      elementRef.current = element;\n\n      if (!isAutoTooltipEnabled) {\n        setIsLabelOverflowed(false);\n\n        return;\n      }\n\n      // No node to measure. Leave the previous verdict alone rather than\n      // clearing it: turning the verdict on mounts `TooltipProvider`, which\n      // remounts the label underneath it, so React detaches the old node and\n      // attaches a new one within that commit. Clearing here would unmount the\n      // provider, remount the label, measure it, mount the provider again — a\n      // loop that never settles.\n      if (!element) return;\n\n      // Do NOT measure synchronously here — see `scheduleLabelOverflowCheck`.\n      // This covers the node the ref just handed us, including the fresh one\n      // React creates when `TooltipProvider` mounts and remounts the label.\n      scheduleLabelOverflowCheck();\n\n      // The observer covers every later size change.\n      const obs = new ResizeObserver(() => {\n        checkLabelOverflow();\n      });\n\n      resizeObserverRef.current = obs;\n\n      obs.observe(element);\n    },\n    [\n      externalLabelRef,\n      isAutoTooltipEnabled,\n      checkLabelOverflow,\n      scheduleLabelOverflowCheck,\n    ],\n  );\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      if (resizeObserverRef.current) {\n        try {\n          resizeObserverRef.current.disconnect();\n        } catch {\n          // do nothing\n        }\n        resizeObserverRef.current = null;\n      }\n      elementRef.current = null;\n    };\n  }, []);\n\n  const finalLabelProps = useMemo(() => {\n    const props = {\n      ...(labelProps || {}),\n    };\n\n    delete props.ref;\n\n    return props;\n  }, [labelProps]);\n\n  /**\n   * The `TooltipProvider` props this tooltip resolves to, or `null` when no\n   * tooltip is rendered at all. Resolved once so that both the rendering below\n   * and `isTooltipActive` speak about the same tooltip.\n   */\n  const resolvedTooltip = useMemo<Omit<\n    CubeTooltipProviderProps,\n    'children'\n  > | null>(() => {\n    if (!tooltip) return null;\n\n    // String tooltip - simple case\n    if (typeof tooltip === 'string') {\n      return { title: tooltip };\n    }\n\n    const hasAutoContent =\n      !!(children || labelProps) && (isLabelOverflowed || isDynamicLabel);\n\n    // Boolean tooltip - auto tooltip on overflow\n    if (tooltip === true) {\n      if (!hasAutoContent) return null;\n\n      return {\n        title: children,\n        isDisabled: !isLabelOverflowed && isDynamicLabel,\n      };\n    }\n\n    // Object tooltip - advanced configuration\n    const { auto, ...tooltipProps } = tooltip;\n\n    // If title is provided and auto is not explicitly true, always show the tooltip\n    if (tooltipProps.title && auto !== true) {\n      return tooltipProps;\n    }\n\n    // If title is provided with auto=true, OR no title but auto behavior enabled\n    if (!hasAutoContent) return null;\n\n    return {\n      title: tooltipProps.title ?? children,\n      isDisabled:\n        !isLabelOverflowed &&\n        isDynamicLabel &&\n        tooltipProps.isDisabled !== true,\n      ...tooltipProps,\n    };\n  }, [tooltip, children, labelProps, isLabelOverflowed, isDynamicLabel]);\n\n  /** Whether a tooltip is rendered and able to open. */\n  const isTooltipActive =\n    !!resolvedTooltip && resolvedTooltip.isDisabled !== true;\n\n  const renderWithTooltip = (\n    renderElement: (\n      tooltipTriggerProps?: HTMLAttributes<HTMLElement>,\n      tooltipRef?: RefObject<HTMLElement>,\n    ) => ReactNode,\n    defaultTooltipPlacement: OverlayProps['placement'],\n  ) => {\n    if (!resolvedTooltip) return renderElement();\n\n    return (\n      <TooltipProvider placement={defaultTooltipPlacement} {...resolvedTooltip}>\n        {(triggerProps, ref) => renderElement(triggerProps, ref)}\n      </TooltipProvider>\n    );\n  };\n\n  return {\n    labelRef: handleLabelElementRef,\n    labelProps: finalLabelProps,\n    isLabelOverflowed,\n    isAutoTooltipEnabled,\n    hasTooltip: !!tooltip,\n    isTooltipActive,\n    renderWithTooltip,\n  };\n}\n"],"mappings":"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"}

package/dist/components/data/DataTable/DataTable.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { extractStyles } from "../../../utils/styles.js";
 import { useCombinedRefs } from "../../../utils/react/useCombinedRefs.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";
@@ -116,8 +116,8 @@ function DataTable(props, ref) {
 	const orderedColumns = columnOrderState.columns;
 	const resolvedTreeColumnKey = useMemo(() => {
 		if (!treeModel) return void 0;
-		const visibleColumns = orderedColumns.filter((column) => !column.isHidden);
-		return visibleColumns.some((column) => column.key === treeColumnKey) ? treeColumnKey : visibleColumns[0]?.key;
+		const visibleColumns = orderedColumns.filter((column_0) => !column_0.isHidden);
+		return visibleColumns.some((column_1) => column_1.key === treeColumnKey) ? treeColumnKey : visibleColumns[0]?.key;
 	}, [
 		treeModel,
 		orderedColumns,
@@ -139,18 +139,18 @@ function DataTable(props, ref) {
 		numeric: true,
 		sensitivity: "base"
 	});
-	const treeSortMode = treeModel ? sortMode ?? (orderedColumns.some((column) => column.isSortable) ? "client" : "off") : resolvedSortMode;
+	const treeSortMode = treeModel ? sortMode ?? (orderedColumns.some((column_2) => column_2.isSortable) ? "client" : "off") : resolvedSortMode;
 	const processedTreeRoots = useMemo(() => {
 		const roots = treeModel?.roots ?? [];
 		if (treeSortMode !== "client" || !sorts.length) return roots;
 		const active = sorts.map((sort) => ({
 			sort,
-			column: orderedColumns.find((column) => column.key === sort.columnKey)
+			column: orderedColumns.find((column_3) => column_3.key === sort.columnKey)
 		})).filter((entry) => entry.column != null);
 		return sortTableTree(roots, (a, b) => {
-			for (const { sort, column } of active) {
-				const result = compareByColumn(column, collator, a.row, a.sourceIndex, b.row, b.sourceIndex);
-				if (result !== 0) return result * (sort.direction === "asc" ? 1 : -1);
+			for (const { sort: sort_0, column: column_4 } of active) {
+				const result = compareByColumn(column_4, collator, a.row, a.sourceIndex, b.row, b.sourceIndex);
+				if (result !== 0) return result * (sort_0.direction === "asc" ? 1 : -1);
 			}
 			return a.siblingIndex - b.siblingIndex;
 		});
@@ -173,10 +173,10 @@ function DataTable(props, ref) {
 		totalPages: isServerPaginated ? totalPages : void 0
 	});
 	const setPage = useEvent((next) => setPageState(clampPage(next, pageInfo.totalPages)));
-	const setPageSize = useEvent((next) => {
-		setPageSizeState(next);
+	const setPageSize = useEvent((next_0) => {
+		setPageSizeState(next_0);
 		setPageState(1);
-		if (pageSizeProp === void 0) storage.write({ pageSize: next });
+		if (pageSizeProp === void 0) storage.write({ pageSize: next_0 });
 	});
 	const flatVisibleRows = paginationMode === "client" ? sortedRows.slice((pageInfo.page - 1) * pageSize, pageInfo.page * pageSize) : sortedRows;
 	const treeState = useTableTreeState({
@@ -189,16 +189,16 @@ function DataTable(props, ref) {
 		allNodesByKey: treeModel?.byKey ?? /* @__PURE__ */ new Map(),
 		expandedKeys,
 		defaultExpandedKeys,
-		getTextValue: (node) => {
-			const column = orderedColumns.find((entry) => entry.key === resolvedTreeColumnKey);
-			return column ? getColumnText(column, node.row, node.sourceIndex) ?? String(node.key) : String(node.key);
+		getTextValue: (node_0) => {
+			const column_5 = orderedColumns.find((entry_0) => entry_0.key === resolvedTreeColumnKey);
+			return column_5 ? getColumnText(column_5, node_0.row, node_0.sourceIndex) ?? String(node_0.key) : String(node_0.key);
 		},
 		onExpand,
 		ariaLabel
 	});
 	const visibleTreeEntries = treeModel ? treeState.visibleEntries : [];
-	const visibleRows = treeModel ? visibleTreeEntries.map((entry) => entry.row) : flatVisibleRows;
-	const visibleRowKeys = treeModel ? visibleTreeEntries.map((entry) => entry.key) : void 0;
+	const visibleRows = treeModel ? visibleTreeEntries.map((entry_1) => entry_1.row) : flatVisibleRows;
+	const visibleRowKeys = treeModel ? visibleTreeEntries.map((entry_2) => entry_2.key) : void 0;
 	const [ownColumnWidths, setOwnColumnWidths] = useState(() => (columnWidthsProp === void 0 && storage.has("columnWidths") ? storage.initial.columnWidths ?? defaultColumnWidths : defaultColumnWidths) ?? EMPTY_WIDTHS);
 	const [draftColumnWidths, setDraftColumnWidths] = useState(null);
 	const draftRef = useRef(null);
@@ -217,13 +217,13 @@ function DataTable(props, ref) {
 		};
 		setDraftColumnWidths(draftRef.current);
 	});
-	const handleColumnResizeEnd = useEvent((key) => {
-		const next = draftRef.current ?? baseColumnWidths;
+	const handleColumnResizeEnd = useEvent((key_0) => {
+		const next_1 = draftRef.current ?? baseColumnWidths;
 		if (columnWidthsProp === void 0) {
-			setOwnColumnWidths(next);
-			storage.write({ columnWidths: next });
+			setOwnColumnWidths(next_1);
+			storage.write({ columnWidths: next_1 });
 		}
-		onColumnResize?.(key, next[key], next);
+		onColumnResize?.(key_0, next_1[key_0], next_1);
 		draftRef.current = null;
 		setDraftColumnWidths(null);
 	});
@@ -249,8 +249,8 @@ function DataTable(props, ref) {
 	]);
 	const selectionRowKeys = useMemo(() => [
 		...(pinnedTopRows ?? []).map((row, index) => selectionRowKey("pinnedTop", resolvedGetRowKey(row, index))),
-		...visibleRows.map((row, index) => visibleRowKeys?.[index] ?? resolvedGetRowKey(row, index)),
-		...(pinnedBottomRows ?? []).map((row, index) => selectionRowKey("pinnedBottom", resolvedGetRowKey(row, index)))
+		...visibleRows.map((row_0, index_0) => visibleRowKeys?.[index_0] ?? resolvedGetRowKey(row_0, index_0)),
+		...(pinnedBottomRows ?? []).map((row_1, index_1) => selectionRowKey("pinnedBottom", resolvedGetRowKey(row_1, index_1)))
 	], [
 		pinnedTopRows,
 		visibleRows,
@@ -258,15 +258,15 @@ function DataTable(props, ref) {
 		pinnedBottomRows,
 		resolvedGetRowKey
 	]);
-	const resolveCellSelectable = useEvent((row, rowKey, columnKey) => {
+	const resolveCellSelectable = useEvent((row_2, rowKey_0, columnKey) => {
 		if (!isCellSelectable) return true;
-		const index = selectionRowKeys.indexOf(rowKey);
+		const index_2 = selectionRowKeys.indexOf(rowKey_0);
 		const topCount = pinnedTopRows?.length ?? 0;
 		return isCellSelectable({
-			row,
-			rowKey,
+			row: row_2,
+			rowKey: rowKey_0,
 			columnKey,
-			section: index < topCount ? "pinnedTop" : index < topCount + visibleRows.length ? "body" : "pinnedBottom"
+			section: index_2 < topCount ? "pinnedTop" : index_2 < topCount + visibleRows.length ? "body" : "pinnedBottom"
 		});
 	});
 	const cellSelection = useCellSelection({
@@ -293,7 +293,7 @@ function DataTable(props, ref) {
 	const canReorderColumns = isColumnReorderable && !hasColumnGroups;
 	const headRowRef = useRef(null);
 	const draggableColumnKeys = useMemo(() => getDraggableColumnKeys(layout.columns, canReorderColumns), [layout.columns, canReorderColumns]);
-	const columnCollection = useMemo(() => new RowCollection(layout.columns.filter((column) => isColumnDraggable(column, canReorderColumns)), (column) => column.key, /* @__PURE__ */ new Set(), (column) => typeof column.title === "string" ? column.title : column.key), [layout.columns, canReorderColumns]);
+	const columnCollection = useMemo(() => new RowCollection(layout.columns.filter((column_6) => isColumnDraggable(column_6, canReorderColumns)), (column_7) => column_7.key, /* @__PURE__ */ new Set(), (column_8) => typeof column_8.title === "string" ? column_8.title : column_8.key), [layout.columns, canReorderColumns]);
 	/**
 	* `'single'`, not `'none'`.
 	*
@@ -307,8 +307,8 @@ function DataTable(props, ref) {
 		disabledBehavior: "all"
 	});
 	const columnSelectionManager = useMemo(() => new SelectionManager(columnCollection, columnSelectionState), [columnCollection, columnSelectionState]);
-	const handleColumnFocus = useEvent((columnKey) => {
-		columnSelectionManager.setFocusedKey(columnKey);
+	const handleColumnFocus = useEvent((columnKey_0) => {
+		columnSelectionManager.setFocusedKey(columnKey_0);
 	});
 	const isColumnDragEnabled = canReorderColumns && draggableColumnKeys.length > 1;
 	const treeRowNumberOffset = treeModel ? paginationMode === "client" ? flattenTableTree(processedTreeRoots.slice(0, (pageInfo.page - 1) * pageSize), treeState.expandedKeys).length : 0 : null;