@cube-dev/ui-kit 0.201.0 → 0.203.0

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

@@ -1,68 +1,9 @@
-/** @license MIT | @cube-dev/ui-kit v0.201.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.203.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { deriveCheckedSets, toggleCheckedKey } from "./checked-keys.js";
 import { c } from "react/compiler-runtime";
 import { useState } from "react";
 //#region src/components/content/Tree/use-checkbox-tree.ts
-/**
-* Returns whether a node should be checkable (i.e. clicking the
-* checkbox should affect it).
-*
-* Skips:
-* - explicitly disabled nodes (`isDisabled === true`)
-* - explicitly disabled checkboxes (`isCheckboxDisabled === true`)
-* - nodes that opted out via `isCheckable === false`
-*/
-function isNodeEligible(node) {
-	if (!node) return false;
-	if (node.isDisabled) return false;
-	if (node.isCheckboxDisabled) return false;
-	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) half.delete(node.key);
-	else if (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);
-		half.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 {
@@ -74,19 +15,7 @@ function normalizeControlledChecked(controlled) {
 		halfChecked: new Set(controlled.halfChecked ?? [])
 	};
 }
-/**
-* Derive `{ checked, halfChecked }` from the source-of-truth `checked` set
-* by walking the tree bottom-up:
-*
-* - A parent is considered fully checked iff every eligible descendant
-*   leaf is checked.
-* - A parent is half-checked iff at least one eligible descendant is
-*   checked or half-checked, but not all.
-*
-* Ineligible nodes (disabled / opt-out) are ignored when computing the
-* parent's state — they neither force a parent into the unchecked nor
-* half state.
-*/
+/** Resolve the rendered sets from the source-of-truth `checked` set. */
 function resolveCheckedSets({ isCheckable, sourceChecked, ownHalfChecked, treeData, index }) {
 	if (!isCheckable) return {
 		checkedSet: /* @__PURE__ */ new Set(),
@@ -96,12 +25,10 @@ function resolveCheckedSets({ isCheckable, sourceChecked, ownHalfChecked, treeDa
 		checkedSet: new Set(sourceChecked),
 		halfCheckedSet: new Set(ownHalfChecked)
 	};
-	const checked = new Set(sourceChecked);
-	const half = /* @__PURE__ */ new Set();
-	for (const root of treeData) deriveCheckedState(root, index, checked, half);
+	const { checked, halfChecked } = deriveCheckedSets(treeData, index, sourceChecked);
 	return {
 		checkedSet: checked,
-		halfCheckedSet: half
+		halfCheckedSet: halfChecked
 	};
 }
 /**
@@ -112,8 +39,9 @@ function resolveCheckedSets({ isCheckable, sourceChecked, ownHalfChecked, treeDa
 *   indeterminate keys themselves.
 * - When the consumer passes `checkedKeys` as `{ checked, halfChecked }`,
 *   we keep the wire shape on the way out — same as AntD.
-* - Toggling a node propagates *down* (skipping ineligible descendants)
-*   and recomputes ancestors *up* in a single pass.
+* - Toggling a node propagates *down* through its subtree, past locked
+*   nodes to the eligible ones below them, and ancestors are then
+*   recomputed *up* by the derive.
 */
 function useCheckboxTree(opts) {
 	const $ = c(14);
@@ -139,52 +67,18 @@ function useCheckboxTree(opts) {
 	if ($[2] !== checkedSet || $[3] !== index || $[4] !== isControlled || $[5] !== onCheck || $[6] !== setUncontrolledChecked || $[7] !== treeData || $[8] !== wantsObjectShape) {
 		t1 = (key) => {
 			const node = index.byKey.get(key);
-			if (!node || !isNodeEligible(node)) return;
-			const willCheck = !checkedSet.has(key);
-			const next = new Set(checkedSet);
-			const apply = (n, value) => {
-				if (!isNodeEligible(n)) return;
-				if (value) next.add(n.key);
-				else next.delete(n.key);
-				const childKeys = index.childrenOf.get(n.key) ?? [];
-				for (const ck of childKeys) {
-					const child = index.byKey.get(ck);
-					if (child) apply(child, value);
-				}
-			};
-			apply(node, willCheck);
-			let parentKey = index.parentOf.get(key);
-			while (parentKey) {
-				const parent = index.byKey.get(parentKey);
-				if (!parent) break;
-				const childKeys_0 = index.childrenOf.get(parentKey) ?? [];
-				let allEligibleChecked = true;
-				let anyEligible = false;
-				for (const ck_0 of childKeys_0) {
-					const child_0 = index.byKey.get(ck_0);
-					if (!child_0) continue;
-					if (!isNodeEligible(child_0)) continue;
-					anyEligible = true;
-					if (!next.has(ck_0)) {
-						allEligibleChecked = false;
-						break;
-					}
-				}
-				if (anyEligible && allEligibleChecked && isNodeEligible(parent)) next.add(parentKey);
-				else next.delete(parentKey);
-				parentKey = index.parentOf.get(parentKey);
-			}
-			if (!isControlled) setUncontrolledChecked(next);
+			const next = toggleCheckedKey(index, checkedSet, key);
+			if (!node || !next) return;
+			const { checked: finalChecked, halfChecked: finalHalf } = deriveCheckedSets(treeData, index, next);
+			if (!isControlled) setUncontrolledChecked(finalChecked);
 			if (onCheck) {
-				const finalChecked = new Set(next);
-				const finalHalf = /* @__PURE__ */ new Set();
-				for (const root of treeData) deriveCheckedState(root, index, finalChecked, finalHalf);
 				const checkedArr = Array.from(finalChecked);
 				const halfArr = Array.from(finalHalf);
+				const checkedNodes = checkedArr.map((k) => index.byKey.get(k)).filter(_temp);
 				const info = {
-					checked: willCheck,
+					checked: next.has(key),
 					node,
-					checkedNodes: checkedArr.map((k) => index.byKey.get(k)).filter(_temp),
+					checkedNodes,
 					halfCheckedKeys: halfArr
 				};
 				if (wantsObjectShape) onCheck({
@@ -218,8 +112,8 @@ function useCheckboxTree(opts) {
 	} else t2 = $[13];
 	return t2;
 }
-function _temp(n_0) {
-	return !!n_0;
+function _temp(n) {
+	return !!n;
 }
 //#endregion
 export { useCheckboxTree };

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

@@ -1 +1 @@
-{"version":3,"file":"use-checkbox-tree.js","names":["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","resolveCheckedSets","sourceChecked","ownHalfChecked","Pick","root","useCheckboxTree","opts","$","_c","isControlled","wantsObjectShape","t0","uncontrolledChecked","setUncontrolledChecked","t1","isCurrentlyChecked","willCheck","next","apply","n","value","ck","parentKey","parentOf","parent","childKeys_0","allEligibleChecked","ck_0","child_0","finalChecked","finalHalf","checkedArr","from","halfArr","checkedNodes","map","k","filter","_temp","halfCheckedKeys","t2","n_0","_c"],"sources":["../../../../src/components/content/Tree/use-checkbox-tree.ts"],"sourcesContent":["import { 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 * 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 */\nfunction resolveCheckedSets({\n  isCheckable,\n  sourceChecked,\n  ownHalfChecked,\n  treeData,\n  index,\n}: {\n  isCheckable: boolean;\n  sourceChecked: Set<string>;\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  ownHalfChecked: Set<string> | null;\n  treeData: CubeTreeNodeData[];\n  index: TreeIndex;\n}): Pick<CheckboxTree, 'checkedSet' | 'halfCheckedSet'> {\n  if (!isCheckable) {\n    return {\n      checkedSet: new Set<string>(),\n      halfCheckedSet: new Set<string>(),\n    };\n  }\n\n  if (ownHalfChecked) {\n    return {\n      checkedSet: new Set(sourceChecked),\n      halfCheckedSet: new Set(ownHalfChecked),\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\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  /** Normalize the controlled `checkedKeys` prop into `Set` instances. */\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  const { checkedSet, halfCheckedSet } = resolveCheckedSets({\n    isCheckable,\n    sourceChecked,\n    ownHalfChecked:\n      isControlled && wantsObjectShape ? controlled!.halfChecked : null,\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 derivation 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":["useState","useEvent","deriveCheckedSets","toggleCheckedKey","Key","TreeIndex","CubeTreeNodeData","TreeOnCheckInfo","UseCheckboxTreeOptions","treeData","index","isCheckable","defaultCheckedKeys","checkedKeys","checked","halfChecked","onCheck","info","CheckboxTree","checkedSet","Set","halfCheckedSet","toggle","key","normalizeControlledChecked","controlled","Array","isArray","resolveCheckedSets","sourceChecked","ownHalfChecked","Pick","useCheckboxTree","opts","$","_c","isControlled","wantsObjectShape","t0","uncontrolledChecked","setUncontrolledChecked","t1","node","byKey","get","next","finalChecked","finalHalf","checkedArr","from","halfArr","checkedNodes","map","k","filter","_temp","has","halfCheckedKeys","t2","n","_c"],"sources":["../../../../src/components/content/Tree/use-checkbox-tree.ts"],"sourcesContent":["import { useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { deriveCheckedSets, toggleCheckedKey } from './checked-keys';\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\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/** Resolve the rendered sets from the source-of-truth `checked` set. */\nfunction resolveCheckedSets({\n  isCheckable,\n  sourceChecked,\n  ownHalfChecked,\n  treeData,\n  index,\n}: {\n  isCheckable: boolean;\n  sourceChecked: Set<string>;\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  ownHalfChecked: Set<string> | null;\n  treeData: CubeTreeNodeData[];\n  index: TreeIndex;\n}): Pick<CheckboxTree, 'checkedSet' | 'halfCheckedSet'> {\n  if (!isCheckable) {\n    return {\n      checkedSet: new Set<string>(),\n      halfCheckedSet: new Set<string>(),\n    };\n  }\n\n  if (ownHalfChecked) {\n    return {\n      checkedSet: new Set(sourceChecked),\n      halfCheckedSet: new Set(ownHalfChecked),\n    };\n  }\n\n  const { checked, halfChecked } = deriveCheckedSets(\n    treeData,\n    index,\n    sourceChecked,\n  );\n\n  return { checkedSet: checked, halfCheckedSet: halfChecked };\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* through its subtree, past locked\n *   nodes to the eligible ones below them, and ancestors are then\n *   recomputed *up* by the derive.\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  /** Normalize the controlled `checkedKeys` prop into `Set` instances. */\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  const { checkedSet, halfCheckedSet } = resolveCheckedSets({\n    isCheckable,\n    sourceChecked,\n    ownHalfChecked:\n      isControlled && wantsObjectShape ? controlled!.halfChecked : null,\n    treeData,\n    index,\n  });\n\n  const toggle = useEvent((key: string) => {\n    const node = index.byKey.get(key);\n    const next = toggleCheckedKey(index, checkedSet, key);\n    if (!node || !next) return;\n\n    const { checked: finalChecked, halfChecked: finalHalf } = deriveCheckedSets(\n      treeData,\n      index,\n      next,\n    );\n\n    // Store the derived set, as a controlled consumer stores `onCheck`'s\n    // keys, so a parent a check completed still covers children that load\n    // later.\n    if (!isControlled) {\n      setUncontrolledChecked(finalChecked);\n    }\n\n    if (onCheck) {\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: next.has(key),\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.201.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.203.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";

package/dist/components/content/highlightText.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.201.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.203.0 | Cube Dev Team */
 import { Text as _Text } from "./Text.js";
 import { jsx } from "react/jsx-runtime";
 //#region src/components/content/highlightText.tsx

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.201.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.203.0 | Cube Dev Team */
 import { TooltipProvider } from "../overlays/Tooltip/TooltipProvider.js";
 import { c } from "react/compiler-runtime";
 import { useEffect, useRef, useState } from "react";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.201.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.203.0 | Cube Dev Team */
 import { extractStyles, mergeStyleLayers } from "../../../utils/styles.js";
 import { useCombinedRefs } from "../../../utils/react/useCombinedRefs.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";