@accelint/design-toolkit 9.9.2 → 9.10.0

package/dist/hooks/use-tree/actions/cache.d.ts

@@ -71,12 +71,13 @@ declare class Cache<T> {
   toTree(deriveVisible?: boolean): TreeNode<T>[];
   /**
    * CACHE FUNCTIONS
-   * These manage cache operations. No cache operations should ever be done
-   * outside this file.
+   * These are the public functions to manage cache operations. No cache operations should ever be done
+   * outside this file since it risks corruption of the data.
    **/
   getNode(key: Key): TreeNode<T>;
   getAllKeys(): MapIterator<Key>;
   getAllNodes(): MapIterator<CacheTreeNode<T>>;
+  getParentForPosition(target: Key | null, position: 'before' | 'after'): Key | null;
   setNode(key: Key, node: TreeNode<T>): void;
   setAllNodes({
     parentKey,
@@ -88,7 +89,23 @@ declare class Cache<T> {
   insertNode(parentKey: Key | null, node: TreeNode<T>, idx: number): void;
   moveNodes(target: Key | null, nodes: Set<Key>, position: 'before' | 'after'): void;
   moveNode(parentKey: Key | null, key: Key, idx: number): void;
+  /**
+   * Cascade selection down through descendants
+   */
+  cascadeSelection(key: Key, selected: boolean): void;
+  /**
+   * Bubble up selection state through ancestors
+   */
+  bubbleUpSelection(key: Key): void;
+  /**
+   * Compute selection state for a node based on its children
+   */
+  private computeSelectionState;
+  /**
+   * Sync cascade state for parents after a move operation
+   */
+  syncParentsAfterMove(oldParents: Set<Key>, newParent: Key | null): void;
 }
 //#endregion
-export { Cache };
+export { Cache, CacheTreeNode };
 //# sourceMappingURL=cache.d.ts.map

package/dist/hooks/use-tree/actions/cache.js

@@ -41,6 +41,7 @@ var Cache = class {
 				isSelected: false,
 				isVisible: false,
 				isVisibleComputed: false,
+				isIndeterminate: false,
 				...rest,
 				parentKey,
 				...children ? { children: children.map((child) => child.key) } : {}
@@ -56,6 +57,7 @@ var Cache = class {
 		return cache;
 	}
 	get(key) {
+		if (key == null) throw new Error(`Key is ${key} (null/undefined) - this is invalid`);
 		const node = this.cache.lookup.get(key);
 		if (node === void 0) throw new Error(`Key of ${key} does not exist in tree`);
 		return node;
@@ -183,8 +185,8 @@ var Cache = class {
 	}
 	/**
 	* CACHE FUNCTIONS
-	* These manage cache operations. No cache operations should ever be done
-	* outside this file.
+	* These are the public functions to manage cache operations. No cache operations should ever be done
+	* outside this file since it risks corruption of the data.
 	**/
 	getNode(key) {
 		const node = this.get(key);
@@ -199,6 +201,10 @@ var Cache = class {
 	getAllNodes() {
 		return this.cache.lookup.values();
 	}
+	getParentForPosition(target, position) {
+		const { parentKey } = this.parentOrSibling(target, position);
+		return parentKey;
+	}
 	setNode(key, node) {
 		this.set(key, {
 			...node,
@@ -231,6 +237,7 @@ var Cache = class {
 			isSelected: false,
 			isVisible: false,
 			isVisibleComputed: false,
+			isIndeterminate: false,
 			...rest,
 			parentKey,
 			...children ? { children: children.map((child) => child.key) } : {}
@@ -248,6 +255,107 @@ var Cache = class {
 		node.parentKey ? this.removeFromParent(node.parentKey, key) : this.removeFromRoot(key);
 		parentKey ? this.addToParent(parentKey, key, idx) : this.addToRoot(key, idx);
 	}
+	/**
+	* Cascade selection down through descendants
+	*/
+	cascadeSelection(key, selected) {
+		try {
+			const node = this.get(key);
+			if (!node.isDisabled) this.set(key, {
+				...node,
+				isSelected: selected,
+				isIndeterminate: false
+			});
+			if (node.children) {
+				for (const childKey of node.children) if (childKey != null) this.cascadeSelection(childKey, selected);
+			}
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Bubble up selection state through ancestors
+	*/
+	bubbleUpSelection(key) {
+		try {
+			let current = this.get(key);
+			while (current.parentKey) {
+				const parent = this.get(current.parentKey);
+				const newState = this.computeSelectionState(parent);
+				if (parent.isSelected === newState.isSelected && parent.isIndeterminate === newState.isIndeterminate) break;
+				this.set(parent.key, {
+					...parent,
+					isSelected: newState.isSelected,
+					isIndeterminate: newState.isIndeterminate
+				});
+				current = parent;
+			}
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Compute selection state for a node based on its children
+	*/
+	computeSelectionState(node) {
+		if (!node.children || node.children.length === 0) return {
+			isSelected: node.isSelected ?? false,
+			isIndeterminate: false
+		};
+		const selectableChildren = node.children.filter((k) => {
+			try {
+				return !this.get(k).isDisabled;
+			} catch {
+				return false;
+			}
+		}).map((k) => this.get(k));
+		if (selectableChildren.length === 0) return {
+			isSelected: node.isSelected ?? false,
+			isIndeterminate: false
+		};
+		const selectedCount = selectableChildren.filter((c) => c.isSelected).length;
+		if (selectableChildren.filter((c) => c.isIndeterminate).length > 0) return {
+			isSelected: false,
+			isIndeterminate: true
+		};
+		if (selectedCount === selectableChildren.length) return {
+			isSelected: true,
+			isIndeterminate: false
+		};
+		if (selectedCount === 0) return {
+			isSelected: false,
+			isIndeterminate: false
+		};
+		return {
+			isSelected: false,
+			isIndeterminate: true
+		};
+	}
+	/**
+	* Sync cascade state for parents after a move operation
+	*/
+	syncParentsAfterMove(oldParents, newParent) {
+		for (const parentKey of oldParents) try {
+			const parent = this.get(parentKey);
+			const newState = this.computeSelectionState(parent);
+			this.set(parentKey, {
+				...parent,
+				isSelected: newState.isSelected,
+				isIndeterminate: newState.isIndeterminate
+			});
+			if (parent.parentKey) this.bubbleUpSelection(parentKey);
+		} catch {}
+		if (newParent) try {
+			const parent = this.get(newParent);
+			const newState = this.computeSelectionState(parent);
+			this.set(newParent, {
+				...parent,
+				isSelected: newState.isSelected,
+				isIndeterminate: newState.isIndeterminate
+			});
+			if (parent.parentKey) this.bubbleUpSelection(newParent);
+		} catch {}
+	}
 };
 
 //#endregion

package/dist/hooks/use-tree/actions/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","names":["index: number","parentKey: Key | null","key"],"sources":["../../../../src/hooks/use-tree/actions/cache.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { Key } from '@react-types/shared';\nimport type { TreeNode } from '../types';\n\ntype CacheTreeNode<T> = Omit<TreeNode<T>, 'children'> & {\n  children?: Key[];\n};\n\n/**\n * This is a cache created only for performance reasons and is considered\n * to be only a temporary mirror of the data. The data is *always* correct\n * cache should be updated according to the data, only. If the data and\n * the cache do not match, the cache is invalidated and rebuilt.\n *\n * This will initialize once on load with data, then\n * updated with each tree operation.\n */\nexport class Cache<T> {\n  protected cache: { lookup: Map<Key, CacheTreeNode<T>>; roots: Key[] } = {\n    lookup: new Map(),\n    roots: [],\n  };\n\n  constructor(nodes: TreeNode<T>[] = []) {\n    this.rebuild(nodes);\n  }\n\n  /**\n   * Recursively creates the cache object from tree data\n   */\n  rebuild(\n    nodes: TreeNode<T>[],\n    lookup: Map<Key, CacheTreeNode<T>> = new Map(),\n    parentKey: Key | null = null,\n  ) {\n    nodes.forEach((node) => {\n      const { children, ...rest } = node;\n\n      lookup.set(node.key, {\n        isDisabled: false,\n        isExpanded: false,\n        isSelected: false,\n        isVisible: false,\n        isVisibleComputed: false,\n        ...rest,\n        parentKey,\n        ...(children ? { children: children.map((child) => child.key) } : {}),\n      });\n\n      if (node.children) {\n        this.rebuild(node.children, lookup, node.key);\n      }\n    });\n\n    const cache = { lookup, roots: nodes.map((node) => node.key) };\n\n    if (!parentKey) {\n      this.cache = cache;\n    }\n\n    this.deriveVisibility();\n    return cache;\n  }\n\n  protected get(key: Key) {\n    const node = this.cache.lookup.get(key);\n\n    if (node === undefined) {\n      throw new Error(`Key of ${key} does not exist in tree`);\n    }\n\n    return node;\n  }\n\n  protected set(key: Key, node: CacheTreeNode<T>) {\n    this.cache.lookup.set(key, node);\n  }\n\n  protected delete(key: Key) {\n    this.cache.lookup.delete(key);\n  }\n\n  protected addToParent(parentKey: Key, childKey: Key, idx: number) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n    const index = Math.max(0, idx);\n\n    this.set(childKey, {\n      ...child,\n      parentKey,\n    });\n\n    const children = (parent.children ?? []).slice(0);\n\n    children.splice(index, 0, childKey);\n\n    this.set(parentKey, {\n      ...parent,\n      children,\n    });\n  }\n\n  protected addToRoot(key: Key, idx: number) {\n    const node = this.get(key);\n    const index = Math.max(0, idx);\n\n    this.set(key, {\n      ...node,\n      parentKey: null,\n    });\n\n    this.cache.roots.splice(index, 0, key);\n  }\n\n  protected removeFromParent(parentKey: Key, childKey: Key) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n\n    this.set(childKey, {\n      ...child,\n      parentKey: null,\n    });\n\n    this.cache.lookup.set(parentKey, {\n      ...parent,\n      children: parent.children?.filter((key) => key !== childKey),\n    });\n  }\n\n  protected removeFromRoot(key: Key) {\n    const node = this.get(key);\n    const idx = this.cache.roots.indexOf(key);\n\n    if (idx >= 0) {\n      this.set(key, {\n        ...node,\n        parentKey: null,\n      });\n\n      this.cache.roots.splice(idx, 1);\n    }\n  }\n\n  protected parentOrSibling(target: Key | null, position: 'before' | 'after') {\n    let index: number;\n    let parentKey: Key | null = null;\n\n    if (target === null) {\n      index = position === 'before' ? 0 : this.cache.roots.length;\n    } else {\n      const targetNode = this.get(target);\n\n      if (targetNode.parentKey) {\n        const parent = this.get(targetNode.parentKey);\n\n        parentKey = parent.key;\n        index = parent.children?.indexOf(target) ?? 0;\n      } else {\n        index = this.cache.roots.indexOf(target);\n      }\n    }\n\n    return { parentKey, index };\n  }\n\n  protected traverse(key: Key) {\n    const node = this.get(key);\n\n    this.cache.lookup.set(key, {\n      ...node,\n      isVisibleComputed: this.calculateVisibility(key),\n    });\n\n    node.children?.map((child) => this.traverse(child));\n  }\n\n  protected calculateVisibility(key: Key) {\n    let current = this.get(key);\n    const ancestry = [current];\n\n    while (current.parentKey) {\n      const parent = this.get(current.parentKey);\n      if (parent) {\n        ancestry.push(parent);\n      }\n      current = parent;\n    }\n\n    return ancestry.every((n) => n.isVisible);\n  }\n\n  protected deriveVisibility() {\n    return this.cache.roots.map((key) => this.traverse(key));\n  }\n  /**\n   * Recursively builds a TreeNode from a key\n   *\n   * @param key\n   */\n  protected buildNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    const children = (node.children ?? []).reduce(\n      (acc: TreeNode<T>[], child) => {\n        const childNode = this.cache.lookup.get(child);\n\n        if (childNode && childNode.parentKey === key) {\n          acc.push(this.buildNode(child));\n        }\n\n        return acc;\n      },\n      [],\n    );\n\n    return {\n      ...node,\n      children,\n    };\n  }\n\n  /**\n   * Builds a tree structure from cache\n   *\n   * TODO: optimization - rebuild only from change to root\n   * Rebuild only from the changed node up the tree to avoid\n   * rebuilding the entire tree\n   *\n   * @param deriveVisible boolean - if true, will recompute visibility for nodes based on ancestry\n   */\n  toTree(deriveVisible?: boolean): TreeNode<T>[] {\n    if (deriveVisible) {\n      this.deriveVisibility();\n    }\n    return this.cache.roots.map((key) => this.buildNode(key));\n  }\n\n  /**\n   * CACHE FUNCTIONS\n   * These manage cache operations. No cache operations should ever be done\n   * outside this file.\n   **/\n  getNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    return {\n      ...node,\n      children: node.children?.map((key) => this.buildNode(key)),\n    };\n  }\n\n  getAllKeys() {\n    return this.cache.lookup.keys();\n  }\n\n  getAllNodes() {\n    return this.cache.lookup.values();\n  }\n\n  setNode(key: Key, node: TreeNode<T>) {\n    this.set(key, {\n      ...node,\n      children: (node.children ?? []).map((child) => child.key),\n    });\n  }\n\n  setAllNodes({ parentKey, children, ...rest }: Partial<TreeNode<T>>) {\n    for (const node of this.cache.lookup.values()) {\n      this.set(node.key, {\n        ...node,\n        ...rest,\n      });\n    }\n  }\n\n  deleteNode(key: Key) {\n    const node = this.cache.lookup.get(key);\n\n    if (!node) {\n      return;\n    }\n\n    // remove children\n    node.children?.map((key) => this.deleteNode(key));\n\n    // remove node from previous parent or root\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // remove the actual node\n    this.delete(key);\n  }\n\n  addNodes(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n    position: 'before' | 'after',\n  ) {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    nodes.map((node, i) => this.insertNode(parentKey, node, idx + i));\n  }\n\n  insertNode(parentKey: Key | null, node: TreeNode<T>, idx: number) {\n    const { children, ...rest } = node;\n\n    this.set(node.key, {\n      isDisabled: false,\n      isExpanded: false,\n      isSelected: false,\n      isVisible: false,\n      isVisibleComputed: false,\n      ...rest,\n      parentKey,\n      ...(children ? { children: children.map((child) => child.key) } : {}),\n    });\n\n    node.children?.map((child, i) => this.insertNode(node.key, child, i));\n\n    parentKey === null\n      ? this.addToRoot(node.key, idx)\n      : this.addToParent(parentKey, node.key, idx);\n  }\n\n  moveNodes(target: Key | null, nodes: Set<Key>, position: 'before' | 'after') {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    Array.from(nodes).map((key, i) => this.moveNode(parentKey, key, idx + i));\n  }\n\n  moveNode(parentKey: Key | null, key: Key, idx: number) {\n    const node = this.get(key);\n\n    // remove from previous parent\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // add as child to new parent or root at position\n    parentKey\n      ? this.addToParent(parentKey, key, idx)\n      : this.addToRoot(key, idx);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"cache.js","names":["index: number","parentKey: Key | null","key"],"sources":["../../../../src/hooks/use-tree/actions/cache.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport type { Key } from '@react-types/shared';\nimport type { TreeNode } from '../types';\n\nexport type CacheTreeNode<T> = Omit<TreeNode<T>, 'children'> & {\n  children?: Key[];\n};\n\n/**\n * This is a cache created only for performance reasons and is considered\n * to be only a temporary mirror of the data. The data is *always* correct\n * cache should be updated according to the data, only. If the data and\n * the cache do not match, the cache is invalidated and rebuilt.\n *\n * This will initialize once on load with data, then\n * updated with each tree operation.\n */\nexport class Cache<T> {\n  protected cache: { lookup: Map<Key, CacheTreeNode<T>>; roots: Key[] } = {\n    lookup: new Map(),\n    roots: [],\n  };\n\n  constructor(nodes: TreeNode<T>[] = []) {\n    this.rebuild(nodes);\n  }\n\n  /**\n   * Recursively creates the cache object from tree data\n   */\n  rebuild(\n    nodes: TreeNode<T>[],\n    lookup: Map<Key, CacheTreeNode<T>> = new Map(),\n    parentKey: Key | null = null,\n  ) {\n    nodes.forEach((node) => {\n      const { children, ...rest } = node;\n\n      lookup.set(node.key, {\n        isDisabled: false,\n        isExpanded: false,\n        isSelected: false,\n        isVisible: false,\n        isVisibleComputed: false,\n        isIndeterminate: false,\n        ...rest,\n        parentKey,\n        ...(children ? { children: children.map((child) => child.key) } : {}),\n      });\n\n      if (node.children) {\n        this.rebuild(node.children, lookup, node.key);\n      }\n    });\n\n    const cache = { lookup, roots: nodes.map((node) => node.key) };\n\n    if (!parentKey) {\n      this.cache = cache;\n    }\n\n    this.deriveVisibility();\n    return cache;\n  }\n\n  protected get(key: Key) {\n    if (key == null) {\n      throw new Error(`Key is ${key} (null/undefined) - this is invalid`);\n    }\n\n    const node = this.cache.lookup.get(key);\n\n    if (node === undefined) {\n      throw new Error(`Key of ${key} does not exist in tree`);\n    }\n\n    return node;\n  }\n\n  protected set(key: Key, node: CacheTreeNode<T>) {\n    this.cache.lookup.set(key, node);\n  }\n\n  protected delete(key: Key) {\n    this.cache.lookup.delete(key);\n  }\n\n  protected addToParent(parentKey: Key, childKey: Key, idx: number) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n    const index = Math.max(0, idx);\n\n    this.set(childKey, {\n      ...child,\n      parentKey,\n    });\n\n    const children = (parent.children ?? []).slice(0);\n\n    children.splice(index, 0, childKey);\n\n    this.set(parentKey, {\n      ...parent,\n      children,\n    });\n  }\n\n  protected addToRoot(key: Key, idx: number) {\n    const node = this.get(key);\n    const index = Math.max(0, idx);\n\n    this.set(key, {\n      ...node,\n      parentKey: null,\n    });\n\n    this.cache.roots.splice(index, 0, key);\n  }\n\n  protected removeFromParent(parentKey: Key, childKey: Key) {\n    const parent = this.get(parentKey);\n    const child = this.get(childKey);\n\n    this.set(childKey, {\n      ...child,\n      parentKey: null,\n    });\n\n    this.cache.lookup.set(parentKey, {\n      ...parent,\n      children: parent.children?.filter((key) => key !== childKey),\n    });\n  }\n\n  protected removeFromRoot(key: Key) {\n    const node = this.get(key);\n    const idx = this.cache.roots.indexOf(key);\n\n    if (idx >= 0) {\n      this.set(key, {\n        ...node,\n        parentKey: null,\n      });\n\n      this.cache.roots.splice(idx, 1);\n    }\n  }\n\n  protected parentOrSibling(target: Key | null, position: 'before' | 'after') {\n    let index: number;\n    let parentKey: Key | null = null;\n\n    if (target === null) {\n      index = position === 'before' ? 0 : this.cache.roots.length;\n    } else {\n      const targetNode = this.get(target);\n\n      if (targetNode.parentKey) {\n        const parent = this.get(targetNode.parentKey);\n\n        parentKey = parent.key;\n        index = parent.children?.indexOf(target) ?? 0;\n      } else {\n        index = this.cache.roots.indexOf(target);\n      }\n    }\n\n    return { parentKey, index };\n  }\n\n  protected traverse(key: Key) {\n    const node = this.get(key);\n\n    this.cache.lookup.set(key, {\n      ...node,\n      isVisibleComputed: this.calculateVisibility(key),\n    });\n\n    node.children?.map((child) => this.traverse(child));\n  }\n\n  protected calculateVisibility(key: Key) {\n    let current = this.get(key);\n    const ancestry = [current];\n\n    while (current.parentKey) {\n      const parent = this.get(current.parentKey);\n      if (parent) {\n        ancestry.push(parent);\n      }\n      current = parent;\n    }\n\n    return ancestry.every((n) => n.isVisible);\n  }\n\n  protected deriveVisibility() {\n    return this.cache.roots.map((key) => this.traverse(key));\n  }\n  /**\n   * Recursively builds a TreeNode from a key\n   *\n   * @param key\n   */\n  protected buildNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    const children = (node.children ?? []).reduce(\n      (acc: TreeNode<T>[], child) => {\n        const childNode = this.cache.lookup.get(child);\n\n        if (childNode && childNode.parentKey === key) {\n          acc.push(this.buildNode(child));\n        }\n\n        return acc;\n      },\n      [],\n    );\n\n    return {\n      ...node,\n      children,\n    };\n  }\n\n  /**\n   * Builds a tree structure from cache\n   *\n   * TODO: optimization - rebuild only from change to root\n   * Rebuild only from the changed node up the tree to avoid\n   * rebuilding the entire tree\n   *\n   * @param deriveVisible boolean - if true, will recompute visibility for nodes based on ancestry\n   */\n  toTree(deriveVisible?: boolean): TreeNode<T>[] {\n    if (deriveVisible) {\n      this.deriveVisibility();\n    }\n    return this.cache.roots.map((key) => this.buildNode(key));\n  }\n\n  /**\n   * CACHE FUNCTIONS\n   * These are the public functions to manage cache operations. No cache operations should ever be done\n   * outside this file since it risks corruption of the data.\n   **/\n  getNode(key: Key): TreeNode<T> {\n    const node = this.get(key);\n\n    return {\n      ...node,\n      children: node.children?.map((key) => this.buildNode(key)),\n    };\n  }\n\n  getAllKeys() {\n    return this.cache.lookup.keys();\n  }\n\n  getAllNodes() {\n    return this.cache.lookup.values();\n  }\n\n  getParentForPosition(\n    target: Key | null,\n    position: 'before' | 'after',\n  ): Key | null {\n    const { parentKey } = this.parentOrSibling(target, position);\n    return parentKey;\n  }\n\n  setNode(key: Key, node: TreeNode<T>) {\n    this.set(key, {\n      ...node,\n      children: (node.children ?? []).map((child) => child.key),\n    });\n  }\n\n  setAllNodes({ parentKey, children, ...rest }: Partial<TreeNode<T>>) {\n    for (const node of this.cache.lookup.values()) {\n      this.set(node.key, {\n        ...node,\n        ...rest,\n      });\n    }\n  }\n\n  deleteNode(key: Key) {\n    const node = this.cache.lookup.get(key);\n\n    if (!node) {\n      return;\n    }\n\n    // remove children\n    node.children?.map((key) => this.deleteNode(key));\n\n    // remove node from previous parent or root\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // remove the actual node\n    this.delete(key);\n  }\n\n  addNodes(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n    position: 'before' | 'after',\n  ) {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    nodes.map((node, i) => this.insertNode(parentKey, node, idx + i));\n  }\n\n  insertNode(parentKey: Key | null, node: TreeNode<T>, idx: number) {\n    const { children, ...rest } = node;\n\n    this.set(node.key, {\n      isDisabled: false,\n      isExpanded: false,\n      isSelected: false,\n      isVisible: false,\n      isVisibleComputed: false,\n      isIndeterminate: false,\n      ...rest,\n      parentKey,\n      ...(children\n        ? {\n            children: children.map((child) => child.key),\n          }\n        : {}),\n    });\n\n    node.children?.map((child, i) => this.insertNode(node.key, child, i));\n\n    parentKey === null\n      ? this.addToRoot(node.key, idx)\n      : this.addToParent(parentKey, node.key, idx);\n  }\n\n  moveNodes(target: Key | null, nodes: Set<Key>, position: 'before' | 'after') {\n    const { parentKey, index } = this.parentOrSibling(target, position);\n    const idx = index + (position === 'before' ? 0 : 1);\n\n    Array.from(nodes).map((key, i) => this.moveNode(parentKey, key, idx + i));\n  }\n\n  moveNode(parentKey: Key | null, key: Key, idx: number) {\n    const node = this.get(key);\n\n    // remove from previous parent\n    node.parentKey\n      ? this.removeFromParent(node.parentKey, key)\n      : this.removeFromRoot(key);\n\n    // add as child to new parent or root at position\n    parentKey\n      ? this.addToParent(parentKey, key, idx)\n      : this.addToRoot(key, idx);\n  }\n\n  /**\n   * Cascade selection down through descendants\n   */\n  cascadeSelection(key: Key, selected: boolean): void {\n    try {\n      const node = this.get(key);\n\n      // Update this node (skip if disabled)\n      if (!node.isDisabled) {\n        this.set(key, {\n          ...node,\n          isSelected: selected,\n          isIndeterminate: false,\n        });\n      }\n\n      // Recurse to children\n      if (node.children) {\n        for (const childKey of node.children) {\n          if (childKey != null) {\n            this.cascadeSelection(childKey, selected);\n          }\n        }\n      }\n    } catch {\n      // Key doesn't exist, skip\n      return;\n    }\n  }\n\n  /**\n   * Bubble up selection state through ancestors\n   */\n  bubbleUpSelection(key: Key): void {\n    try {\n      let current = this.get(key);\n\n      while (current.parentKey) {\n        const parent = this.get(current.parentKey);\n        const newState = this.computeSelectionState(parent);\n\n        // Early termination: if parent state unchanged, ancestors won't change\n        if (\n          parent.isSelected === newState.isSelected &&\n          parent.isIndeterminate === newState.isIndeterminate\n        ) {\n          break;\n        }\n\n        this.set(parent.key, {\n          ...parent,\n          isSelected: newState.isSelected,\n          isIndeterminate: newState.isIndeterminate,\n        });\n\n        current = parent;\n      }\n    } catch {\n      // Key doesn't exist, skip\n      return;\n    }\n  }\n\n  /**\n   * Compute selection state for a node based on its children\n   */\n  private computeSelectionState(node: CacheTreeNode<T>): {\n    isSelected: boolean;\n    isIndeterminate: boolean;\n  } {\n    // Leaf nodes: use their own state\n    if (!node.children || node.children.length === 0) {\n      return {\n        isSelected: node.isSelected ?? false,\n        isIndeterminate: false,\n      };\n    }\n\n    // Get selectable children (exclude disabled)\n    const selectableChildren = node.children\n      .filter((k) => {\n        try {\n          const child = this.get(k);\n          return !child.isDisabled;\n        } catch {\n          return false;\n        }\n      })\n      .map((k) => this.get(k));\n\n    // If all children disabled, treat as leaf\n    if (selectableChildren.length === 0) {\n      return {\n        isSelected: node.isSelected ?? false,\n        isIndeterminate: false,\n      };\n    }\n\n    // Check if all/none/some selected\n    const selectedCount = selectableChildren.filter((c) => c.isSelected).length;\n    const indeterminateCount = selectableChildren.filter(\n      (c) => c.isIndeterminate,\n    ).length;\n\n    // If any child is indeterminate, parent is indeterminate\n    if (indeterminateCount > 0) {\n      return {\n        isSelected: false,\n        isIndeterminate: true,\n      };\n    }\n\n    // All children selected\n    if (selectedCount === selectableChildren.length) {\n      return {\n        isSelected: true,\n        isIndeterminate: false,\n      };\n    }\n\n    // No children selected\n    if (selectedCount === 0) {\n      return {\n        isSelected: false,\n        isIndeterminate: false,\n      };\n    }\n\n    // Some children selected (indeterminate)\n    return {\n      isSelected: false,\n      isIndeterminate: true,\n    };\n  }\n\n  /**\n   * Sync cascade state for parents after a move operation\n   */\n  syncParentsAfterMove(oldParents: Set<Key>, newParent: Key | null): void {\n    // Update old parents (lost children)\n    for (const parentKey of oldParents) {\n      try {\n        const parent = this.get(parentKey);\n        const newState = this.computeSelectionState(parent);\n\n        this.set(parentKey, {\n          ...parent,\n          isSelected: newState.isSelected,\n          isIndeterminate: newState.isIndeterminate,\n        });\n\n        // Bubble up to ancestors\n        if (parent.parentKey) {\n          this.bubbleUpSelection(parentKey);\n        }\n      } catch {\n        // Parent doesn't exist, skip\n      }\n    }\n\n    // Update new parent (gained children)\n    if (newParent) {\n      try {\n        const parent = this.get(newParent);\n        const newState = this.computeSelectionState(parent);\n\n        this.set(newParent, {\n          ...parent,\n          isSelected: newState.isSelected,\n          isIndeterminate: newState.isIndeterminate,\n        });\n\n        // Bubble up to ancestors\n        if (parent.parentKey) {\n          this.bubbleUpSelection(newParent);\n        }\n      } catch {\n        // Parent doesn't exist, skip\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/hooks/use-tree/actions/index.d.ts

@@ -48,7 +48,8 @@ import "client-only";
  * ```
  */
 declare function useTreeActions<T>({
-  nodes
+  nodes,
+  selectionCascade
 }: UseTreeActionsOptions<T>): TreeActions<T>;
 //#endregion
 export { useTreeActions };

package/dist/hooks/use-tree/actions/index.js

@@ -51,11 +51,41 @@ import { useUpdateEffect } from "@react-aria/utils";
 * ]);
 * ```
 */
-function useTreeActions({ nodes }) {
+function useTreeActions({ nodes, selectionCascade = false }) {
 	const cache = useRef(new Cache(nodes)).current;
 	useUpdateEffect(() => {
 		cache.rebuild(nodes);
 	}, [nodes]);
+	/** HELPERS **/
+	/**
+	* Collects parent keys for a set of nodes before a move operation
+	*/
+	function getParents(keys) {
+		const prevParents = /* @__PURE__ */ new Set();
+		for (const key of keys) {
+			const node = cache.getNode(key);
+			if (node.parentKey) prevParents.add(node.parentKey);
+		}
+		return prevParents;
+	}
+	/** CASCADE SELECTION **/
+	/**
+	* Selection change with cascade logic
+	*/
+	function onSelectionChangeCascade(keys) {
+		const previouslySelected = /* @__PURE__ */ new Set();
+		for (const k of cache.getAllKeys()) try {
+			if (cache.getNode(k).isSelected) previouslySelected.add(k);
+		} catch {}
+		const validKeys = [...keys].filter((k) => k != null);
+		const added = validKeys.filter((k) => !previouslySelected.has(k));
+		const removed = [...previouslySelected].filter((k) => !validKeys.includes(k));
+		for (const key of added) cache.cascadeSelection(key, true);
+		for (const key of removed) cache.cascadeSelection(key, false);
+		const affectedKeys = new Set([...added, ...removed]);
+		for (const key of affectedKeys) cache.bubbleUpSelection(key);
+		return cache.toTree();
+	}
 	/** GET NODE **/
 	function getNode(key) {
 		return cache.getNode(key);
@@ -75,15 +105,35 @@ function useTreeActions({ nodes }) {
 	}
 	/** MOVE NODES **/
 	function moveAfter(target, keys) {
+		if (!selectionCascade) {
+			cache.moveNodes(target, keys, "after");
+			return cache.toTree();
+		}
+		const prevParents = getParents(keys);
+		const newParent = cache.getParentForPosition(target, "after");
 		cache.moveNodes(target, keys, "after");
+		cache.syncParentsAfterMove(prevParents, newParent);
 		return cache.toTree();
 	}
 	function moveBefore(target, keys) {
+		if (!selectionCascade) {
+			cache.moveNodes(target, keys, "before");
+			return cache.toTree();
+		}
+		const prevParents = getParents(keys);
+		const newParent = cache.getParentForPosition(target, "before");
 		cache.moveNodes(target, keys, "before");
+		cache.syncParentsAfterMove(prevParents, newParent);
 		return cache.toTree();
 	}
 	function moveInto(target, keys) {
+		if (!selectionCascade) {
+			for (const key of keys) cache.moveNode(target, key, 0);
+			return cache.toTree();
+		}
+		const prevParents = getParents(keys);
 		for (const key of keys) cache.moveNode(target, key, 0);
+		cache.syncParentsAfterMove(prevParents, target);
 		return cache.toTree();
 	}
 	/** UPDATE NODES **/
@@ -99,22 +149,31 @@ function useTreeActions({ nodes }) {
 	}
 	/** SELECTION **/
 	function onSelectionChange(keys) {
-		unselectAll();
-		for (const key of keys) {
-			const node = cache.getNode(key);
-			cache.setNode(node.key, {
-				...node,
-				isSelected: true
-			});
+		if (!selectionCascade) {
+			unselectAll();
+			for (const key of keys) {
+				const node = cache.getNode(key);
+				cache.setNode(node.key, {
+					...node,
+					isSelected: true
+				});
+			}
+			return cache.toTree();
 		}
-		return cache.toTree();
+		return onSelectionChangeCascade(keys);
 	}
 	function selectAll() {
-		cache.setAllNodes({ isSelected: true });
+		cache.setAllNodes({
+			isSelected: true,
+			isIndeterminate: false
+		});
 		return cache.toTree();
 	}
 	function unselectAll() {
-		cache.setAllNodes({ isSelected: false });
+		cache.setAllNodes({
+			isSelected: false,
+			isIndeterminate: false
+		});
 		return cache.toTree();
 	}
 	/** EXPANSION **/

package/dist/hooks/use-tree/actions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["nodes"],"sources":["../../../../src/hooks/use-tree/actions/index.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n'use client';\n\nimport 'client-only';\nimport { useUpdateEffect } from '@react-aria/utils';\nimport { useRef } from 'react';\nimport { Cache } from './cache';\nimport type { Key } from '@react-types/shared';\nimport type {\n  TreeActions,\n  TreeData,\n  TreeNode,\n  TreeNodeBase,\n  UseTreeActionsOptions,\n} from '../types';\n\n/**\n * Stateless hook that transforms tree data according to actions\n * it takes in nodes and returns a new version of the tree.\n *\n * Note: each operation returns the whole tree. Future iterations\n * might want to return only the changed portion of the tree.\n *\n * @param options - {@link UseTreeActionsOptions}\n * @param options.nodes - Current tree nodes to operate on.\n * @returns {@link TreeActions} Object containing all tree manipulation functions.\n *\n * @example\n * ```tsx\n * const treeActions = useTreeActions({\n *   nodes: [\n *     {\n *       key: 'root',\n *       label: 'Root',\n *       children: [\n *         { key: 'child1', label: 'Child 1' },\n *         { key: 'child2', label: 'Child 2' }\n *       ]\n *     }\n *   ]\n * });\n *\n * // Use tree actions\n * const updatedTree = treeActions.insertAfter('child1', [\n *   { key: 'newChild', label: 'New Child' }\n * ]);\n * ```\n */\nexport function useTreeActions<T>({\n  nodes,\n}: UseTreeActionsOptions<T>): TreeActions<T> {\n  const cache = useRef(new Cache<T>(nodes)).current;\n\n  useUpdateEffect(() => {\n    cache.rebuild(nodes);\n  }, [nodes]);\n\n  /** GET NODE **/\n  function getNode(key: Key) {\n    return cache.getNode(key);\n  }\n\n  /** INSERT NODES **/\n  function insertAfter(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n  ): TreeNode<T>[] {\n    cache.addNodes(target, nodes, 'after');\n\n    return cache.toTree(true);\n  }\n\n  function insertBefore(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n  ): TreeNode<T>[] {\n    cache.addNodes(target, nodes, 'before');\n\n    return cache.toTree(true);\n  }\n\n  function insertInto(target: Key | null, nodes: TreeNode<T>[]): TreeNode<T>[] {\n    for (const node of nodes) {\n      cache.insertNode(target, node, 0);\n    }\n\n    return cache.toTree(true);\n  }\n\n  /** MOVE NODES **/\n  function moveAfter(target: Key | null, keys: Set<Key>): TreeNode<T>[] {\n    cache.moveNodes(target, keys, 'after');\n\n    return cache.toTree();\n  }\n\n  function moveBefore(target: Key | null, keys: Set<Key>): TreeNode<T>[] {\n    cache.moveNodes(target, keys, 'before');\n\n    return cache.toTree();\n  }\n\n  function moveInto(target: Key | null, keys: Set<Key>): TreeNode<T>[] {\n    for (const key of keys) {\n      cache.moveNode(target, key, 0);\n    }\n\n    return cache.toTree();\n  }\n\n  /** UPDATE NODES **/\n  function updateNode(\n    key: Key,\n    callback: (node: TreeNodeBase<T>) => TreeNodeBase<T>,\n  ): TreeNode<T>[] {\n    const node = cache.getNode(key);\n\n    cache.setNode(key, callback(node));\n\n    return cache.toTree(true);\n  }\n\n  /** REMOVE NODES **/\n  function remove(keys: Set<Key>): TreeNode<T>[] {\n    for (const key of keys.values()) {\n      cache.deleteNode(key);\n    }\n\n    return cache.toTree(true);\n  }\n\n  /** SELECTION **/\n  function onSelectionChange(keys: Set<Key>): TreeNode<T>[] {\n    unselectAll();\n\n    for (const key of keys) {\n      const node = cache.getNode(key);\n\n      cache.setNode(node.key, {\n        ...node,\n        isSelected: true,\n      });\n    }\n\n    return cache.toTree();\n  }\n\n  function selectAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isSelected: true });\n\n    return cache.toTree();\n  }\n\n  function unselectAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isSelected: false });\n\n    return cache.toTree();\n  }\n\n  /** EXPANSION **/\n  function onExpandedChange(keys: Set<Key>): TreeNode<T>[] {\n    collapseAll();\n\n    for (const key of keys) {\n      const node = cache.getNode(key);\n\n      cache.setNode(node.key, {\n        ...node,\n        isExpanded: true,\n      });\n    }\n\n    return cache.toTree();\n  }\n\n  function expandAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isExpanded: true });\n\n    return cache.toTree();\n  }\n\n  function collapseAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isExpanded: false });\n\n    return cache.toTree();\n  }\n\n  /** VISIBILITY **/\n  function onVisibilityChange(keys: Set<Key>): TreeData<T> {\n    hideAll();\n\n    for (const key of keys) {\n      const node = cache.getNode(key);\n      cache.setNode(node.key, {\n        ...node,\n        isVisible: true,\n      });\n    }\n    return cache.toTree(true);\n  }\n\n  function revealAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isVisible: true });\n\n    return cache.toTree(true);\n  }\n\n  function hideAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isVisible: false });\n\n    return cache.toTree(true);\n  }\n\n  return {\n    getNode,\n    insertAfter,\n    insertBefore,\n    insertInto,\n    moveAfter,\n    moveBefore,\n    moveInto,\n    remove,\n    updateNode,\n\n    // Expansion\n    collapseAll,\n    expandAll,\n    onExpandedChange,\n\n    // Selection\n    selectAll,\n    unselectAll,\n    onSelectionChange,\n\n    // Visibility\n    hideAll,\n    revealAll,\n    onVisibilityChange,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["nodes"],"sources":["../../../../src/hooks/use-tree/actions/index.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n'use client';\n\nimport 'client-only';\nimport { useUpdateEffect } from '@react-aria/utils';\nimport { useRef } from 'react';\nimport { Cache } from './cache';\nimport type { Key } from '@react-types/shared';\nimport type {\n  TreeActions,\n  TreeData,\n  TreeNode,\n  TreeNodeBase,\n  UseTreeActionsOptions,\n} from '../types';\n\n/**\n * Stateless hook that transforms tree data according to actions\n * it takes in nodes and returns a new version of the tree.\n *\n * Note: each operation returns the whole tree. Future iterations\n * might want to return only the changed portion of the tree.\n *\n * @param options - {@link UseTreeActionsOptions}\n * @param options.nodes - Current tree nodes to operate on.\n * @returns {@link TreeActions} Object containing all tree manipulation functions.\n *\n * @example\n * ```tsx\n * const treeActions = useTreeActions({\n *   nodes: [\n *     {\n *       key: 'root',\n *       label: 'Root',\n *       children: [\n *         { key: 'child1', label: 'Child 1' },\n *         { key: 'child2', label: 'Child 2' }\n *       ]\n *     }\n *   ]\n * });\n *\n * // Use tree actions\n * const updatedTree = treeActions.insertAfter('child1', [\n *   { key: 'newChild', label: 'New Child' }\n * ]);\n * ```\n */\nexport function useTreeActions<T>({\n  nodes,\n  selectionCascade = false,\n}: UseTreeActionsOptions<T>): TreeActions<T> {\n  const cache = useRef(new Cache<T>(nodes)).current;\n\n  useUpdateEffect(() => {\n    cache.rebuild(nodes);\n  }, [nodes]);\n\n  /** HELPERS **/\n\n  /**\n   * Collects parent keys for a set of nodes before a move operation\n   */\n  function getParents(keys: Set<Key>): Set<Key> {\n    const prevParents = new Set<Key>();\n    for (const key of keys) {\n      const node = cache.getNode(key);\n      if (node.parentKey) {\n        prevParents.add(node.parentKey);\n      }\n    }\n    return prevParents;\n  }\n\n  /** CASCADE SELECTION **/\n\n  /**\n   * Selection change with cascade logic\n   */\n  function onSelectionChangeCascade(keys: Set<Key>): TreeNode<T>[] {\n    // Detect changes\n    const previouslySelected = new Set<Key>();\n    for (const k of cache.getAllKeys()) {\n      try {\n        const node = cache.getNode(k);\n        if (node.isSelected) {\n          previouslySelected.add(k);\n        }\n      } catch {\n        // Skip invalid keys\n      }\n    }\n\n    const validKeys = [...keys].filter((k) => k != null);\n    const added = validKeys.filter((k) => !previouslySelected.has(k));\n    const removed = [...previouslySelected].filter(\n      (k) => !validKeys.includes(k),\n    );\n\n    // Cascade down\n    for (const key of added) {\n      cache.cascadeSelection(key, true);\n    }\n\n    for (const key of removed) {\n      cache.cascadeSelection(key, false);\n    }\n\n    // Bubble up\n    const affectedKeys = new Set([...added, ...removed]);\n    for (const key of affectedKeys) {\n      cache.bubbleUpSelection(key);\n    }\n\n    return cache.toTree();\n  }\n\n  /** GET NODE **/\n  function getNode(key: Key) {\n    return cache.getNode(key);\n  }\n\n  /** INSERT NODES **/\n  function insertAfter(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n  ): TreeNode<T>[] {\n    cache.addNodes(target, nodes, 'after');\n\n    return cache.toTree(true);\n  }\n\n  function insertBefore(\n    target: Key | null,\n    nodes: TreeNode<T>[],\n  ): TreeNode<T>[] {\n    cache.addNodes(target, nodes, 'before');\n\n    return cache.toTree(true);\n  }\n\n  function insertInto(target: Key | null, nodes: TreeNode<T>[]): TreeNode<T>[] {\n    for (const node of nodes) {\n      cache.insertNode(target, node, 0);\n    }\n\n    return cache.toTree(true);\n  }\n\n  /** MOVE NODES **/\n  function moveAfter(target: Key | null, keys: Set<Key>): TreeNode<T>[] {\n    if (!selectionCascade) {\n      cache.moveNodes(target, keys, 'after');\n      return cache.toTree();\n    }\n\n    // Collect old parents before move\n    const prevParents = getParents(keys);\n\n    // Get new parent before move\n    const newParent = cache.getParentForPosition(target, 'after');\n\n    // Perform move\n    cache.moveNodes(target, keys, 'after');\n\n    // Sync cascade state\n    cache.syncParentsAfterMove(prevParents, newParent);\n\n    return cache.toTree();\n  }\n\n  function moveBefore(target: Key | null, keys: Set<Key>): TreeNode<T>[] {\n    if (!selectionCascade) {\n      cache.moveNodes(target, keys, 'before');\n      return cache.toTree();\n    }\n\n    // Collect old parents before move\n    const prevParents = getParents(keys);\n\n    // Get new parent before move\n    const newParent = cache.getParentForPosition(target, 'before');\n\n    // Perform move\n    cache.moveNodes(target, keys, 'before');\n\n    // Sync cascade state\n    cache.syncParentsAfterMove(prevParents, newParent);\n\n    return cache.toTree();\n  }\n\n  function moveInto(target: Key | null, keys: Set<Key>): TreeNode<T>[] {\n    if (!selectionCascade) {\n      for (const key of keys) {\n        cache.moveNode(target, key, 0);\n      }\n      return cache.toTree();\n    }\n\n    // Collect old parents before move\n    const prevParents = getParents(keys);\n\n    // Perform move\n    for (const key of keys) {\n      cache.moveNode(target, key, 0);\n    }\n\n    // Sync cascade state (target IS the new parent for moveInto)\n    cache.syncParentsAfterMove(prevParents, target);\n\n    return cache.toTree();\n  }\n\n  /** UPDATE NODES **/\n  function updateNode(\n    key: Key,\n    callback: (node: TreeNodeBase<T>) => TreeNodeBase<T>,\n  ): TreeNode<T>[] {\n    const node = cache.getNode(key);\n\n    cache.setNode(key, callback(node));\n\n    return cache.toTree(true);\n  }\n\n  /** REMOVE NODES **/\n  function remove(keys: Set<Key>): TreeNode<T>[] {\n    for (const key of keys.values()) {\n      cache.deleteNode(key);\n    }\n\n    return cache.toTree(true);\n  }\n\n  /** SELECTION **/\n  function onSelectionChange(keys: Set<Key>): TreeNode<T>[] {\n    if (!selectionCascade) {\n      // Current behavior (no cascade)\n      unselectAll();\n\n      for (const key of keys) {\n        const node = cache.getNode(key);\n\n        cache.setNode(node.key, {\n          ...node,\n          isSelected: true,\n        });\n      }\n\n      return cache.toTree();\n    }\n\n    // Cascade behavior\n    return onSelectionChangeCascade(keys);\n  }\n\n  function selectAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isSelected: true, isIndeterminate: false });\n\n    return cache.toTree();\n  }\n\n  function unselectAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isSelected: false, isIndeterminate: false });\n\n    return cache.toTree();\n  }\n\n  /** EXPANSION **/\n  function onExpandedChange(keys: Set<Key>): TreeNode<T>[] {\n    collapseAll();\n\n    for (const key of keys) {\n      const node = cache.getNode(key);\n\n      cache.setNode(node.key, {\n        ...node,\n        isExpanded: true,\n      });\n    }\n\n    return cache.toTree();\n  }\n\n  function expandAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isExpanded: true });\n\n    return cache.toTree();\n  }\n\n  function collapseAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isExpanded: false });\n\n    return cache.toTree();\n  }\n\n  /** VISIBILITY **/\n  function onVisibilityChange(keys: Set<Key>): TreeData<T> {\n    hideAll();\n\n    for (const key of keys) {\n      const node = cache.getNode(key);\n      cache.setNode(node.key, {\n        ...node,\n        isVisible: true,\n      });\n    }\n    return cache.toTree(true);\n  }\n\n  function revealAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isVisible: true });\n\n    return cache.toTree(true);\n  }\n\n  function hideAll(): TreeNode<T>[] {\n    cache.setAllNodes({ isVisible: false });\n\n    return cache.toTree(true);\n  }\n\n  return {\n    getNode,\n    insertAfter,\n    insertBefore,\n    insertInto,\n    moveAfter,\n    moveBefore,\n    moveInto,\n    remove,\n    updateNode,\n\n    // Expansion\n    collapseAll,\n    expandAll,\n    onExpandedChange,\n\n    // Selection\n    selectAll,\n    unselectAll,\n    onSelectionChange,\n\n    // Visibility\n    hideAll,\n    revealAll,\n    onVisibilityChange,\n  };\n}\n"],"mappings":"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"}

package/dist/hooks/use-tree/state/index.d.ts

@@ -14,15 +14,34 @@ import { UseTreeState, UseTreeStateOptions } from "../types.js";
 import "client-only";
 
 //#region src/hooks/use-tree/state/index.d.ts
+
 /**
  * Stateful tree manager with drag-and-drop, selection, expansion, and visibility controls
  *
  * @param options - {@link UseTreeStateOptions}
  * @param options.items - Initial tree node items.
+ * @param options.selectionCascade - Enable cascade selection mode. When true, selecting a parent
+ *   automatically selects all descendants, and parent checkboxes show indeterminate state when
+ *   partially selected. Default: false.
  * @returns {@link UseTreeState} Tree state, actions, and drag-and-drop configuration.
+ *
+ * @example
+ * ```tsx
+ * // Basic tree without cascade
+ * const { nodes, actions } = useTreeState({
+ *   items: myTree,
+ * });
+ *
+ * // Tree with cascade selection (file system-like behavior)
+ * const { nodes, actions } = useTreeState({
+ *   items: fileSystemTree,
+ *   selectionCascade: true,
+ * });
+ * ```
  */
 declare function useTreeState<T>({
-  items
+  items,
+  selectionCascade
 }: UseTreeStateOptions<T>): UseTreeState<T>;
 //#endregion
 export { useTreeState };

package/dist/hooks/use-tree/state/index.js

@@ -24,11 +24,31 @@ import { useState } from "react";
 *
 * @param options - {@link UseTreeStateOptions}
 * @param options.items - Initial tree node items.
+* @param options.selectionCascade - Enable cascade selection mode. When true, selecting a parent
+*   automatically selects all descendants, and parent checkboxes show indeterminate state when
+*   partially selected. Default: false.
 * @returns {@link UseTreeState} Tree state, actions, and drag-and-drop configuration.
+*
+* @example
+* ```tsx
+* // Basic tree without cascade
+* const { nodes, actions } = useTreeState({
+*   items: myTree,
+* });
+*
+* // Tree with cascade selection (file system-like behavior)
+* const { nodes, actions } = useTreeState({
+*   items: fileSystemTree,
+*   selectionCascade: true,
+* });
+* ```
 */
-function useTreeState({ items }) {
+function useTreeState({ items, selectionCascade = false }) {
 	const [nodes, setNodes] = useState(items);
-	const actions = useTreeActions({ nodes });
+	const actions = useTreeActions({
+		nodes,
+		selectionCascade
+	});
 	const dragAndDropConfig = {
 		getItems: (keys) => [...keys].map((key) => {
 			const node = actions.getNode(key);

package/dist/hooks/use-tree/state/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["dragAndDropConfig: DragAndDropConfig","items"],"sources":["../../../../src/hooks/use-tree/state/index.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n'use client';\n\nimport 'client-only';\nimport { useState } from 'react';\nimport { useTreeActions } from '../actions';\nimport { processDroppedItems } from './utils';\nimport type {\n  DragItem,\n  DroppableCollectionInsertDropEvent,\n  DroppableCollectionRootDropEvent,\n  Key,\n  Selection,\n} from '@react-types/shared';\nimport type {\n  DragAndDropConfig,\n  UseTreeState,\n  UseTreeStateOptions,\n} from '../types';\n\n/**\n * Stateful tree manager with drag-and-drop, selection, expansion, and visibility controls\n *\n * @param options - {@link UseTreeStateOptions}\n * @param options.items - Initial tree node items.\n * @returns {@link UseTreeState} Tree state, actions, and drag-and-drop configuration.\n */\nexport function useTreeState<T>({\n  items,\n}: UseTreeStateOptions<T>): UseTreeState<T> {\n  const [nodes, setNodes] = useState(items);\n  const actions = useTreeActions<T>({ nodes });\n\n  const dragAndDropConfig: DragAndDropConfig = {\n    getItems: (keys: Set<Key>): DragItem[] =>\n      [...keys].map((key) => {\n        const node = actions.getNode(key);\n\n        return {\n          key: `${key}`,\n          'text/plain': JSON.stringify(node),\n        };\n      }),\n    onInsert: ({ items, target }: DroppableCollectionInsertDropEvent) => {\n      (async () => {\n        const processedItems = await processDroppedItems(\n          items,\n          dragAndDropConfig.acceptedDragTypes ?? [],\n        );\n\n        setNodes(\n          actions.remove(new Set(processedItems.map((item) => item.id))),\n        );\n\n        if (target.dropPosition === 'before') {\n          setNodes(actions.insertBefore(target.key, processedItems));\n        } else if (target.dropPosition === 'after') {\n          setNodes(actions.insertAfter(target.key, processedItems));\n        }\n      })();\n    },\n    onRootDrop: ({ items }: DroppableCollectionRootDropEvent) => {\n      (async () => {\n        const processedItems = await processDroppedItems(\n          items,\n          dragAndDropConfig.acceptedDragTypes ?? [],\n        );\n\n        setNodes(\n          actions.remove(new Set(processedItems.map((item) => item.key))),\n        );\n        setNodes(actions.insertAfter(null, processedItems));\n      })();\n    },\n    onMove: (e) => {\n      if (e.target.dropPosition === 'before') {\n        setNodes(actions.moveBefore(e.target.key, e.keys));\n      } else if (e.target.dropPosition === 'after') {\n        setNodes(actions.moveAfter(e.target.key, e.keys));\n      } else if (e.target.dropPosition === 'on') {\n        const targetNode = actions.getNode(e.target.key);\n        if (targetNode) {\n          setNodes(actions.moveInto(e.target.key, e.keys));\n        }\n      }\n    },\n  };\n\n  function collapseAll() {\n    setNodes(actions.collapseAll());\n  }\n\n  function expandAll() {\n    setNodes(actions.expandAll());\n  }\n\n  function onExpandedChange(keys: Set<Key>) {\n    setNodes(actions.onExpandedChange(keys));\n  }\n\n  function selectAll() {\n    setNodes(actions.selectAll());\n  }\n\n  function unselectAll() {\n    setNodes(actions.unselectAll());\n  }\n\n  function onSelectionChange(keys: Selection) {\n    if (keys === 'all') {\n      return selectAll();\n    }\n\n    setNodes(actions.onSelectionChange(keys));\n  }\n\n  function hideAll() {\n    setNodes(actions.hideAll());\n  }\n\n  function revealAll() {\n    setNodes(actions.revealAll());\n  }\n\n  function onVisibilityChange(keys: Set<Key>) {\n    setNodes(actions.onVisibilityChange(keys));\n  }\n\n  return {\n    nodes,\n    actions: {\n      // Expansion\n      collapseAll,\n      expandAll,\n      onExpandedChange,\n\n      // Selection\n      selectAll,\n      unselectAll,\n      onSelectionChange,\n\n      // Visibility\n      hideAll,\n      revealAll,\n      onVisibilityChange,\n    },\n    dragAndDropConfig,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,aAAgB,EAC9B,SAC0C;CAC1C,MAAM,CAAC,OAAO,YAAY,SAAS,MAAM;CACzC,MAAM,UAAU,eAAkB,EAAE,OAAO,CAAC;CAE5C,MAAMA,oBAAuC;EAC3C,WAAW,SACT,CAAC,GAAG,KAAK,CAAC,KAAK,QAAQ;GACrB,MAAM,OAAO,QAAQ,QAAQ,IAAI;AAEjC,UAAO;IACL,KAAK,GAAG;IACR,cAAc,KAAK,UAAU,KAAK;IACnC;IACD;EACJ,WAAW,EAAE,gBAAO,aAAiD;AACnE,IAAC,YAAY;IACX,MAAM,iBAAiB,MAAM,oBAC3BC,SACA,kBAAkB,qBAAqB,EAAE,CAC1C;AAED,aACE,QAAQ,OAAO,IAAI,IAAI,eAAe,KAAK,SAAS,KAAK,GAAG,CAAC,CAAC,CAC/D;AAED,QAAI,OAAO,iBAAiB,SAC1B,UAAS,QAAQ,aAAa,OAAO,KAAK,eAAe,CAAC;aACjD,OAAO,iBAAiB,QACjC,UAAS,QAAQ,YAAY,OAAO,KAAK,eAAe,CAAC;OAEzD;;EAEN,aAAa,EAAE,qBAA8C;AAC3D,IAAC,YAAY;IACX,MAAM,iBAAiB,MAAM,oBAC3BA,SACA,kBAAkB,qBAAqB,EAAE,CAC1C;AAED,aACE,QAAQ,OAAO,IAAI,IAAI,eAAe,KAAK,SAAS,KAAK,IAAI,CAAC,CAAC,CAChE;AACD,aAAS,QAAQ,YAAY,MAAM,eAAe,CAAC;OACjD;;EAEN,SAAS,MAAM;AACb,OAAI,EAAE,OAAO,iBAAiB,SAC5B,UAAS,QAAQ,WAAW,EAAE,OAAO,KAAK,EAAE,KAAK,CAAC;YACzC,EAAE,OAAO,iBAAiB,QACnC,UAAS,QAAQ,UAAU,EAAE,OAAO,KAAK,EAAE,KAAK,CAAC;YACxC,EAAE,OAAO,iBAAiB,MAEnC;QADmB,QAAQ,QAAQ,EAAE,OAAO,IAAI,CAE9C,UAAS,QAAQ,SAAS,EAAE,OAAO,KAAK,EAAE,KAAK,CAAC;;;EAIvD;CAED,SAAS,cAAc;AACrB,WAAS,QAAQ,aAAa,CAAC;;CAGjC,SAAS,YAAY;AACnB,WAAS,QAAQ,WAAW,CAAC;;CAG/B,SAAS,iBAAiB,MAAgB;AACxC,WAAS,QAAQ,iBAAiB,KAAK,CAAC;;CAG1C,SAAS,YAAY;AACnB,WAAS,QAAQ,WAAW,CAAC;;CAG/B,SAAS,cAAc;AACrB,WAAS,QAAQ,aAAa,CAAC;;CAGjC,SAAS,kBAAkB,MAAiB;AAC1C,MAAI,SAAS,MACX,QAAO,WAAW;AAGpB,WAAS,QAAQ,kBAAkB,KAAK,CAAC;;CAG3C,SAAS,UAAU;AACjB,WAAS,QAAQ,SAAS,CAAC;;CAG7B,SAAS,YAAY;AACnB,WAAS,QAAQ,WAAW,CAAC;;CAG/B,SAAS,mBAAmB,MAAgB;AAC1C,WAAS,QAAQ,mBAAmB,KAAK,CAAC;;AAG5C,QAAO;EACL;EACA,SAAS;GAEP;GACA;GACA;GAGA;GACA;GACA;GAGA;GACA;GACA;GACD;EACD;EACD"}
+{"version":3,"file":"index.js","names":["dragAndDropConfig: DragAndDropConfig","items"],"sources":["../../../../src/hooks/use-tree/state/index.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n'use client';\n\nimport 'client-only';\nimport { useState } from 'react';\nimport { useTreeActions } from '../actions';\nimport { processDroppedItems } from './utils';\nimport type {\n  DragItem,\n  DroppableCollectionInsertDropEvent,\n  DroppableCollectionRootDropEvent,\n  Key,\n  Selection,\n} from '@react-types/shared';\nimport type {\n  DragAndDropConfig,\n  UseTreeState,\n  UseTreeStateOptions,\n} from '../types';\n\n/**\n * Stateful tree manager with drag-and-drop, selection, expansion, and visibility controls\n *\n * @param options - {@link UseTreeStateOptions}\n * @param options.items - Initial tree node items.\n * @param options.selectionCascade - Enable cascade selection mode. When true, selecting a parent\n *   automatically selects all descendants, and parent checkboxes show indeterminate state when\n *   partially selected. Default: false.\n * @returns {@link UseTreeState} Tree state, actions, and drag-and-drop configuration.\n *\n * @example\n * ```tsx\n * // Basic tree without cascade\n * const { nodes, actions } = useTreeState({\n *   items: myTree,\n * });\n *\n * // Tree with cascade selection (file system-like behavior)\n * const { nodes, actions } = useTreeState({\n *   items: fileSystemTree,\n *   selectionCascade: true,\n * });\n * ```\n */\nexport function useTreeState<T>({\n  items,\n  selectionCascade = false,\n}: UseTreeStateOptions<T>): UseTreeState<T> {\n  const [nodes, setNodes] = useState(items);\n  const actions = useTreeActions<T>({ nodes, selectionCascade });\n\n  const dragAndDropConfig: DragAndDropConfig = {\n    getItems: (keys: Set<Key>): DragItem[] =>\n      [...keys].map((key) => {\n        const node = actions.getNode(key);\n\n        return {\n          key: `${key}`,\n          'text/plain': JSON.stringify(node),\n        };\n      }),\n    onInsert: ({ items, target }: DroppableCollectionInsertDropEvent) => {\n      (async () => {\n        const processedItems = await processDroppedItems(\n          items,\n          dragAndDropConfig.acceptedDragTypes ?? [],\n        );\n\n        setNodes(\n          actions.remove(new Set(processedItems.map((item) => item.id))),\n        );\n\n        if (target.dropPosition === 'before') {\n          setNodes(actions.insertBefore(target.key, processedItems));\n        } else if (target.dropPosition === 'after') {\n          setNodes(actions.insertAfter(target.key, processedItems));\n        }\n      })();\n    },\n    onRootDrop: ({ items }: DroppableCollectionRootDropEvent) => {\n      (async () => {\n        const processedItems = await processDroppedItems(\n          items,\n          dragAndDropConfig.acceptedDragTypes ?? [],\n        );\n\n        setNodes(\n          actions.remove(new Set(processedItems.map((item) => item.key))),\n        );\n        setNodes(actions.insertAfter(null, processedItems));\n      })();\n    },\n    onMove: (e) => {\n      if (e.target.dropPosition === 'before') {\n        setNodes(actions.moveBefore(e.target.key, e.keys));\n      } else if (e.target.dropPosition === 'after') {\n        setNodes(actions.moveAfter(e.target.key, e.keys));\n      } else if (e.target.dropPosition === 'on') {\n        const targetNode = actions.getNode(e.target.key);\n        if (targetNode) {\n          setNodes(actions.moveInto(e.target.key, e.keys));\n        }\n      }\n    },\n  };\n\n  function collapseAll() {\n    setNodes(actions.collapseAll());\n  }\n\n  function expandAll() {\n    setNodes(actions.expandAll());\n  }\n\n  function onExpandedChange(keys: Set<Key>) {\n    setNodes(actions.onExpandedChange(keys));\n  }\n\n  function selectAll() {\n    setNodes(actions.selectAll());\n  }\n\n  function unselectAll() {\n    setNodes(actions.unselectAll());\n  }\n\n  function onSelectionChange(keys: Selection) {\n    if (keys === 'all') {\n      return selectAll();\n    }\n\n    setNodes(actions.onSelectionChange(keys));\n  }\n\n  function hideAll() {\n    setNodes(actions.hideAll());\n  }\n\n  function revealAll() {\n    setNodes(actions.revealAll());\n  }\n\n  function onVisibilityChange(keys: Set<Key>) {\n    setNodes(actions.onVisibilityChange(keys));\n  }\n\n  return {\n    nodes,\n    actions: {\n      // Expansion\n      collapseAll,\n      expandAll,\n      onExpandedChange,\n\n      // Selection\n      selectAll,\n      unselectAll,\n      onSelectionChange,\n\n      // Visibility\n      hideAll,\n      revealAll,\n      onVisibilityChange,\n    },\n    dragAndDropConfig,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,aAAgB,EAC9B,OACA,mBAAmB,SACuB;CAC1C,MAAM,CAAC,OAAO,YAAY,SAAS,MAAM;CACzC,MAAM,UAAU,eAAkB;EAAE;EAAO;EAAkB,CAAC;CAE9D,MAAMA,oBAAuC;EAC3C,WAAW,SACT,CAAC,GAAG,KAAK,CAAC,KAAK,QAAQ;GACrB,MAAM,OAAO,QAAQ,QAAQ,IAAI;AAEjC,UAAO;IACL,KAAK,GAAG;IACR,cAAc,KAAK,UAAU,KAAK;IACnC;IACD;EACJ,WAAW,EAAE,gBAAO,aAAiD;AACnE,IAAC,YAAY;IACX,MAAM,iBAAiB,MAAM,oBAC3BC,SACA,kBAAkB,qBAAqB,EAAE,CAC1C;AAED,aACE,QAAQ,OAAO,IAAI,IAAI,eAAe,KAAK,SAAS,KAAK,GAAG,CAAC,CAAC,CAC/D;AAED,QAAI,OAAO,iBAAiB,SAC1B,UAAS,QAAQ,aAAa,OAAO,KAAK,eAAe,CAAC;aACjD,OAAO,iBAAiB,QACjC,UAAS,QAAQ,YAAY,OAAO,KAAK,eAAe,CAAC;OAEzD;;EAEN,aAAa,EAAE,qBAA8C;AAC3D,IAAC,YAAY;IACX,MAAM,iBAAiB,MAAM,oBAC3BA,SACA,kBAAkB,qBAAqB,EAAE,CAC1C;AAED,aACE,QAAQ,OAAO,IAAI,IAAI,eAAe,KAAK,SAAS,KAAK,IAAI,CAAC,CAAC,CAChE;AACD,aAAS,QAAQ,YAAY,MAAM,eAAe,CAAC;OACjD;;EAEN,SAAS,MAAM;AACb,OAAI,EAAE,OAAO,iBAAiB,SAC5B,UAAS,QAAQ,WAAW,EAAE,OAAO,KAAK,EAAE,KAAK,CAAC;YACzC,EAAE,OAAO,iBAAiB,QACnC,UAAS,QAAQ,UAAU,EAAE,OAAO,KAAK,EAAE,KAAK,CAAC;YACxC,EAAE,OAAO,iBAAiB,MAEnC;QADmB,QAAQ,QAAQ,EAAE,OAAO,IAAI,CAE9C,UAAS,QAAQ,SAAS,EAAE,OAAO,KAAK,EAAE,KAAK,CAAC;;;EAIvD;CAED,SAAS,cAAc;AACrB,WAAS,QAAQ,aAAa,CAAC;;CAGjC,SAAS,YAAY;AACnB,WAAS,QAAQ,WAAW,CAAC;;CAG/B,SAAS,iBAAiB,MAAgB;AACxC,WAAS,QAAQ,iBAAiB,KAAK,CAAC;;CAG1C,SAAS,YAAY;AACnB,WAAS,QAAQ,WAAW,CAAC;;CAG/B,SAAS,cAAc;AACrB,WAAS,QAAQ,aAAa,CAAC;;CAGjC,SAAS,kBAAkB,MAAiB;AAC1C,MAAI,SAAS,MACX,QAAO,WAAW;AAGpB,WAAS,QAAQ,kBAAkB,KAAK,CAAC;;CAG3C,SAAS,UAAU;AACjB,WAAS,QAAQ,SAAS,CAAC;;CAG7B,SAAS,YAAY;AACnB,WAAS,QAAQ,WAAW,CAAC;;CAG/B,SAAS,mBAAmB,MAAgB;AAC1C,WAAS,QAAQ,mBAAmB,KAAK,CAAC;;AAG5C,QAAO;EACL;EACA,SAAS;GAEP;GACA;GACA;GAGA;GACA;GACA;GAGA;GACA;GACA;GACD;EACD;EACD"}

package/dist/hooks/use-tree/types.d.ts

@@ -54,6 +54,13 @@ type DragAndDropConfig = {
 type UseTreeStateOptions<T> = {
   /** Initial root items in the tree. If omitted, will return an empty tree. */
   items: TreeNode<T>[];
+  /**
+   * Enable semantic cascade selection mode. When true, selecting a parent
+   * automatically selects all descendants, and parent state reflects children
+   * (selected/indeterminate/unselected). Only works with dynamic collections.
+   * @default false
+   */
+  selectionCascade?: boolean;
 };
 /** Return value from the useTreeState hook */
 type UseTreeState<T> = {
@@ -108,6 +115,8 @@ type TreeNodeBase<T> = {
   isVisible?: boolean;
   /** Computed actual visibility based on ancestors and self visibility **/
   isVisibleComputed?: boolean;
+  /** Computed indeterminate state for cascade selection (some but not all descendants selected) **/
+  isIndeterminate?: boolean;
 };
 type TreeNode<T> = TreeNodeBase<T> & {
   /** The key of the parent node. */
@@ -119,6 +128,11 @@ type TreeNode<T> = TreeNodeBase<T> & {
 type UseTreeActionsOptions<T> = {
   /** Current tree nodes to operate on */
   nodes: TreeNode<T>[];
+  /**
+   * Enable semantic cascade selection mode.
+   * @default false
+   */
+  selectionCascade?: boolean;
 };
 /**
  * Stateless collection of transform actions to simplify tree operations