@snack-uikit/tree 0.10.3 → 0.11.1-preview-c3fee040.0

package/dist/cjs/hooks/useTreeMultiSelection.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeMultiSelection = useTreeMultiSelection;
+const react_1 = require("react");
+const utils_1 = require("@snack-uikit/utils");
+const getNewSelectedIds = (selectedIds, added, removed) => {
+  const result = new Set(selectedIds);
+  added.forEach(id => {
+    result.add(id);
+  });
+  removed.forEach(id => {
+    result.delete(id);
+  });
+  return Array.from(result);
+};
+function useTreeMultiSelection(_ref) {
+  let {
+    onDataLoad,
+    onSelect: onSelectProp,
+    selected,
+    onChangeSelected
+  } = _ref;
+  const [selectedIds = [], setSelectedIds] = (0, utils_1.useValueControl)({
+    value: selected,
+    defaultValue: [],
+    onChange: onChangeSelected
+  });
+  const onSelect = (0, react_1.useCallback)((selectedKeys, node) => __awaiter(this, void 0, void 0, function* () {
+    const isSelected = selectedKeys.includes(node.id);
+    const clonedNode = structuredClone(node);
+    if (node.nested && !node.nested.length) {
+      const {
+        preloadedChildren
+      } = yield onDataLoad(node);
+      clonedNode.nested = preloadedChildren;
+    }
+    const {
+      added,
+      removed
+    } = onSelectProp({
+      selectedKeys,
+      node: clonedNode,
+      isSelected
+    });
+    const updatedSelectedIds = getNewSelectedIds(selectedIds, added, removed);
+    setSelectedIds(updatedSelectedIds);
+  }), [onDataLoad, onSelectProp, selectedIds, setSelectedIds]);
+  return {
+    selected: selectedIds,
+    onSelect
+  };
+}

package/dist/cjs/index.d.ts

@@ -1,3 +1,4 @@
 export * from './components';
-export type { OnNodeClick, TreeNodeId, TreeNodeProps } from './types';
+export type { OnNodeClick, TreeNodeId, TreeNodeProps, ExtendedTreeNodeProps } from './types';
 export { setNonce } from '@snack-uikit/list';
+export * from './helpers';

package/dist/cjs/index.js

@@ -30,4 +30,5 @@ Object.defineProperty(exports, "setNonce", {
   get: function () {
     return list_1.setNonce;
   }
-});
+});
+__exportStar(require("./helpers"), exports);

package/dist/cjs/types.d.ts

@@ -103,3 +103,20 @@ export type TreeBaseProps = TreeView | TreeMultiSelect | TreeSingleSelect;
 export type ExtendedTreeNodeProps = TreeNodeProps & {
     getTitle?(): void;
 };
+export type PreloadNodeHandler<TTreeNode extends TreeNodeProps> = (node: TreeNodeProps) => Promise<{
+    preloadedChildren: TTreeNode[];
+    updatedTree: TTreeNode[];
+}>;
+export type SearchableTreeDataLoadResult<TTreeNode extends TreeNodeProps, TRecordValue> = {
+    preloadedChildren: TTreeNode[];
+    updatedTree: TTreeNode[];
+    newTreeItemsRecord: Record<string, TRecordValue>;
+};
+export type SelectHandler = (props: {
+    selectedKeys: string[];
+    node: TreeNodeProps;
+    isSelected: boolean;
+}) => {
+    added: string[];
+    removed: string[];
+};

package/dist/esm/helpers/__tests__/collectEmptyNestedNodesInExpanded.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/helpers/__tests__/collectEmptyNestedNodesInExpanded.spec.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { collectEmptyNestedNodesInExpanded } from '../collectEmptyNestedNodesInExpanded';
+const node = (id, nested) => (Object.assign({ id, title: id }, (nested !== undefined && { nested })));
+describe('collectEmptyNestedNodesInExpanded', () => {
+    it('returns nodes with empty nested array that are in expandedIds', () => {
+        const tree = [node('a', []), node('b', [node('b1')])];
+        const expandedIds = new Set(['a']);
+        const result = collectEmptyNestedNodesInExpanded(tree, expandedIds);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({ id: 'a', nested: [] });
+    });
+    it('does not return nodes with empty nested if not in expandedIds', () => {
+        const tree = [node('a', []), node('b', [])];
+        const expandedIds = new Set(['b']);
+        const result = collectEmptyNestedNodesInExpanded(tree, expandedIds);
+        expect(result).toHaveLength(1);
+        expect(result[0].id).toBe('b');
+    });
+    it('does not return nodes that have non-empty nested', () => {
+        const tree = [node('a', [node('a1')]), node('b', [])];
+        const expandedIds = new Set(['a', 'b']);
+        const result = collectEmptyNestedNodesInExpanded(tree, expandedIds);
+        expect(result).toHaveLength(1);
+        expect(result[0].id).toBe('b');
+    });
+    it('does not return nodes without nested property (leaf)', () => {
+        const tree = [node('leaf'), node('empty', [])];
+        const expandedIds = new Set(['leaf', 'empty']);
+        const result = collectEmptyNestedNodesInExpanded(tree, expandedIds);
+        expect(result).toHaveLength(1);
+        expect(result[0].id).toBe('empty');
+    });
+    it('returns empty array for empty tree', () => {
+        const result = collectEmptyNestedNodesInExpanded([], new Set(['any']));
+        expect(result).toEqual([]);
+    });
+    it('returns empty array when expandedIds is empty', () => {
+        const tree = [node('a', []), node('b', [])];
+        const result = collectEmptyNestedNodesInExpanded(tree, new Set());
+        expect(result).toEqual([]);
+    });
+    it('collects from deeply nested nodes', () => {
+        const child = node('child', []);
+        const tree = [node('root', [node('mid', [child])])];
+        const expandedIds = new Set(['root', 'mid', 'child']);
+        const result = collectEmptyNestedNodesInExpanded(tree, expandedIds);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({ id: 'child', nested: [] });
+    });
+    it('returns all matching nodes from different levels', () => {
+        const tree = [node('a', []), node('b', [node('b1', []), node('b2', [])])];
+        const expandedIds = new Set(['a', 'b', 'b1', 'b2']);
+        const result = collectEmptyNestedNodesInExpanded(tree, expandedIds);
+        expect(result).toHaveLength(3);
+        expect(result.map(n => n.id).sort()).toEqual(['a', 'b1', 'b2']);
+    });
+    it('only includes node if both empty nested and expanded', () => {
+        const tree = [node('expanded', []), node('collapsed', [])];
+        const expandedIds = new Set(['expanded']);
+        const result = collectEmptyNestedNodesInExpanded(tree, expandedIds);
+        expect(result).toHaveLength(1);
+        expect(result[0].id).toBe('expanded');
+    });
+});

package/dist/esm/helpers/__tests__/setChildrenOfTreeNode.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/helpers/__tests__/setChildrenOfTreeNode.spec.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { setChildrenOfTreeNode } from '../setChildrenOfTreeNode';
+const node = (id, nested) => (Object.assign({ id, title: id }, (nested !== undefined && { nested: nested.map(n => (Object.assign(Object.assign({}, n), { title: n.id }))) })));
+describe('setChildrenOfTreeNode', () => {
+    it('replaces nested for root-level node', () => {
+        const tree = [node('a', [{ id: 'a1', title: 'a1' }]), node('b', [{ id: 'b1', title: 'b1' }])];
+        const children = [node('new1'), node('new2')];
+        const result = setChildrenOfTreeNode(tree, 'b', children);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({ id: 'a', nested: [{ id: 'a1' }] });
+        expect(result[1]).toMatchObject({ id: 'b', nested: [{ id: 'new1' }, { id: 'new2' }] });
+    });
+    it('replaces nested for deeply nested node', () => {
+        const childWithNested = node('child');
+        childWithNested.nested = [{ id: 'grand', title: 'grand' }];
+        const tree = [node('root', [childWithNested])];
+        const children = [node('replacement')];
+        const result = setChildrenOfTreeNode(tree, 'child', children);
+        const root = result[0];
+        expect(root.nested).toHaveLength(1);
+        expect(root.nested[0]).toMatchObject({ id: 'child', nested: [{ id: 'replacement' }] });
+    });
+    it('returns cloned tree when node is not found', () => {
+        const tree = [node('a'), node('b')];
+        const result = setChildrenOfTreeNode(tree, 'missing', [node('x')]);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({ id: 'a' });
+        expect(result[1]).toMatchObject({ id: 'b' });
+        expect(result).not.toBe(tree);
+    });
+    it('returns empty array for empty tree', () => {
+        const result = setChildrenOfTreeNode([], 'any', [node('x')]);
+        expect(result).toEqual([]);
+    });
+    it('sets children for target node that had no nested (leaf)', () => {
+        const tree = [node('leaf'), node('other')];
+        const children = [node('new1')];
+        const result = setChildrenOfTreeNode(tree, 'leaf', children);
+        expect(result[0]).toMatchObject({ id: 'leaf', nested: [{ id: 'new1' }] });
+        expect(result[1]).toMatchObject({ id: 'other' });
+    });
+    it('preserves order of root nodes when target is second', () => {
+        const tree = [node('first'), node('second', [{ id: 's1', title: 's1' }]), node('third')];
+        const children = [node('new1'), node('new2')];
+        const result = setChildrenOfTreeNode(tree, 'second', children);
+        expect(result.map(n => n.id)).toEqual(['first', 'second', 'third']);
+        expect(result[1].nested).toHaveLength(2);
+        expect(result[1].nested.map(n => n.id)).toEqual(['new1', 'new2']);
+    });
+});

package/dist/esm/helpers/collectEmptyNestedNodesInExpanded.d.ts

@@ -0,0 +1,2 @@
+import { TreeNodeProps } from '../types';
+export declare function collectEmptyNestedNodesInExpanded<TTreeNode extends TreeNodeProps>(nodes: TTreeNode[], expandedIds: Set<string>): TTreeNode[];

package/dist/esm/helpers/collectEmptyNestedNodesInExpanded.js

@@ -0,0 +1,11 @@
+import { traverse } from './traverse';
+export function collectEmptyNestedNodesInExpanded(nodes, expandedIds) {
+    const result = [];
+    traverse(nodes, node => {
+        const hasEmptyNested = Array.isArray(node.nested) && node.nested.length === 0;
+        if (hasEmptyNested && expandedIds.has(node.id)) {
+            result.push(node);
+        }
+    });
+    return result;
+}

package/dist/esm/helpers/index.d.ts

@@ -6,3 +6,5 @@ export * from './getSearchedTreeNodeById';
 export * from './lookupTreeForSelectedNodes';
 export * from './sortTreeItemsByTitle';
 export * from './traverse';
+export * from './setChildrenOfTreeNode';
+export * from './collectEmptyNestedNodesInExpanded';

package/dist/esm/helpers/index.js

@@ -6,3 +6,5 @@ export * from './getSearchedTreeNodeById';
 export * from './lookupTreeForSelectedNodes';
 export * from './sortTreeItemsByTitle';
 export * from './traverse';
+export * from './setChildrenOfTreeNode';
+export * from './collectEmptyNestedNodesInExpanded';

package/dist/esm/helpers/setChildrenOfTreeNode.d.ts

@@ -0,0 +1,2 @@
+import { TreeNodeProps } from '../types';
+export declare const setChildrenOfTreeNode: <TTreeNode extends TreeNodeProps>(tree: TTreeNode[], nodeId: string, children: TTreeNode[]) => TTreeNode[];

package/dist/esm/helpers/setChildrenOfTreeNode.js

@@ -0,0 +1,20 @@
+import { traverseWithTarget } from './traverse';
+export const setChildrenOfTreeNode = (tree, nodeId, children) => {
+    const result = [];
+    traverseWithTarget(tree, result, (source, _depth, targetList) => {
+        var _a;
+        const isTarget = source.id === nodeId;
+        const hasNested = Array.isArray(source.nested);
+        let newNested;
+        if (isTarget) {
+            newNested = children;
+        }
+        else if (hasNested) {
+            newNested = [];
+        }
+        const newNode = (newNested !== undefined ? Object.assign(Object.assign({}, source), { nested: newNested }) : Object.assign({}, source));
+        targetList.push(newNode);
+        return !isTarget && hasNested && ((_a = source.nested) === null || _a === void 0 ? void 0 : _a.length) ? newNested : undefined;
+    });
+    return result;
+};

package/dist/esm/helpers/sortTreeItemsByTitle.js

@@ -1,6 +1,6 @@
 import { extractTreeNodeTitle } from './extractTreeNodeTitle';
 export const sortTreeItemsByTitle = (items) => items === null || items === void 0 ? void 0 : items.toSorted((itemA, itemB) => {
-    const valueA = extractTreeNodeTitle(itemA);
-    const valueB = extractTreeNodeTitle(itemB);
+    const valueA = extractTreeNodeTitle(itemA).toLowerCase();
+    const valueB = extractTreeNodeTitle(itemB).toLowerCase();
     return valueA.localeCompare(valueB);
 });

package/dist/esm/helpers/traverse.d.ts

@@ -1,2 +1,8 @@
-import { TreeNodeProps } from '../';
+import { TreeNodeProps } from '../types';
 export declare const traverse: <T extends TreeNodeProps>(nodes: T[], callback: (node: T, depth: number) => void) => void;
+/**
+ * BFS с указанием целевого списка для каждого узла.
+ * Очередь хранит (node, depth, targetList). Callback добавляет узел в targetList
+ * и возвращает массив для детей (или undefined, чтобы не обходить детей).
+ */
+export declare const traverseWithTarget: <T extends TreeNodeProps>(nodes: T[], rootTargetList: T[], callback: (node: T, depth: number, targetList: T[]) => T[] | undefined) => void;

package/dist/esm/helpers/traverse.js

@@ -17,3 +17,27 @@ export const traverse = (nodes, callback) => {
         }
     }
 };
+/**
+ * BFS с указанием целевого списка для каждого узла.
+ * Очередь хранит (node, depth, targetList). Callback добавляет узел в targetList
+ * и возвращает массив для детей (или undefined, чтобы не обходить детей).
+ */
+export const traverseWithTarget = (nodes, rootTargetList, callback) => {
+    var _a;
+    const queue = new Queue();
+    for (const node of nodes) {
+        queue.enqueue({ node, depth: 0, targetList: rootTargetList });
+    }
+    while (!queue.isEmpty()) {
+        const item = queue.dequeue();
+        if (!item)
+            continue;
+        const { node, depth, targetList } = item;
+        const childTargetList = callback(node, depth, targetList);
+        if (childTargetList !== undefined && ((_a = node.nested) === null || _a === void 0 ? void 0 : _a.length)) {
+            for (const child of node.nested) {
+                queue.enqueue({ node: child, depth: depth + 1, targetList: childTargetList });
+            }
+        }
+    }
+};

package/dist/esm/hooks/__tests__/useSearchableTree.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/hooks/__tests__/useSearchableTree.spec.js

@@ -0,0 +1,165 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useEffect, useRef } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { useSearchableTree } from '../useSearchableTree';
+vi.mock('@siberiacancode/reactuse', () => ({
+    useDebounceValue: (value) => value,
+    useDidUpdate: (effect, deps) => {
+        const isFirstRenderRef = useRef(true);
+        useEffect(() => {
+            if (isFirstRenderRef.current) {
+                isFirstRenderRef.current = false;
+                return;
+            }
+            effect();
+        }, [deps, effect]);
+    },
+    useRefState: (initialValue) => useRef(initialValue),
+}));
+const createLeaf = (id) => ({
+    id,
+    title: id,
+});
+const createParent = (id, nested) => ({
+    id,
+    title: id,
+    nested,
+});
+const mapNodeToRecordItem = (node) => ({
+    label: String(node.title),
+});
+describe('useSearchableTree', () => {
+    it('should initialize tree and treeItemsRecord from initTree', () => {
+        const initTree = [createLeaf('node-1'), createParent('node-2', [createLeaf('node-2-1')])];
+        const { result } = renderHook(() => useSearchableTree({
+            initTree,
+            onPreloadNode: vi.fn(),
+            onPreloadNodes: vi.fn(),
+            onSearch: vi.fn(),
+            mapNodeToRecordItem,
+        }));
+        expect(result.current.tree.current).toEqual(initTree);
+        expect(result.current.treeItemsRecord.current).toEqual({
+            'node-1': { label: 'node-1' },
+            'node-2': { label: 'node-2' },
+            'node-2-1': { label: 'node-2-1' },
+        });
+    });
+    it('should update expandedNodes on onExpand call', () => {
+        const { result } = renderHook(() => useSearchableTree({
+            initTree: [createLeaf('root')],
+            onPreloadNode: vi.fn(),
+            onPreloadNodes: vi.fn(),
+            onSearch: vi.fn(),
+            mapNodeToRecordItem,
+        }));
+        act(() => {
+            result.current.onExpand(['root', 'child']);
+        });
+        expect(result.current.expandedNodes.current).toEqual(['root', 'child']);
+    });
+    it('should preload node children and update tree and record on onDataLoad', () => __awaiter(void 0, void 0, void 0, function* () {
+        const initTree = [createParent('root', [])];
+        const preloadedChildren = [createLeaf('child-1'), createLeaf('child-2')];
+        const onPreloadNode = vi.fn().mockResolvedValue(preloadedChildren);
+        const { result } = renderHook(() => useSearchableTree({
+            initTree,
+            onPreloadNode,
+            onPreloadNodes: vi.fn(),
+            onSearch: vi.fn(),
+            mapNodeToRecordItem,
+        }));
+        let loadResult;
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            loadResult = yield result.current.onDataLoad(createParent('root', []));
+        }));
+        expect(onPreloadNode).toHaveBeenCalledWith(createParent('root', []));
+        expect(loadResult).toEqual({
+            preloadedChildren,
+            updatedTree: [createParent('root', preloadedChildren)],
+            newTreeItemsRecord: {
+                root: { label: 'root' },
+                'child-1': { label: 'child-1' },
+                'child-2': { label: 'child-2' },
+            },
+        });
+        expect(result.current.tree.current).toEqual([createParent('root', preloadedChildren)]);
+        expect(result.current.treeItemsRecord.current).toEqual({
+            root: { label: 'root' },
+            'child-1': { label: 'child-1' },
+            'child-2': { label: 'child-2' },
+        });
+    }));
+    it('should run search and preload required nodes', () => __awaiter(void 0, void 0, void 0, function* () {
+        const searchedTree = [createParent('expandable-root', []), createLeaf('leaf')];
+        const onSearch = vi.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                tree: searchedTree,
+                needPreloadNodes: ['expandable-root', 'external-root'],
+            });
+        }));
+        const onPreloadNodes = vi.fn((nodeIds) => __awaiter(void 0, void 0, void 0, function* () {
+            return (Object.assign({ 'expandable-root': [createLeaf('expandable-child')], 'external-root': [createLeaf('external-child')] }, Object.fromEntries(nodeIds.filter(id => id !== 'expandable-root' && id !== 'external-root').map(id => [id, []]))));
+        }));
+        const { result } = renderHook(() => useSearchableTree({
+            initTree: [createParent('init-root', [])],
+            onPreloadNode: vi.fn(),
+            onPreloadNodes,
+            onSearch,
+            mapNodeToRecordItem,
+        }));
+        act(() => {
+            result.current.onExpand(['expandable-root']);
+            result.current.search.onChange('query');
+        });
+        yield waitFor(() => {
+            expect(onSearch).toHaveBeenCalledWith({ search: 'query' }, expect.any(AbortSignal));
+            expect(onPreloadNodes).toHaveBeenCalledWith(['expandable-root', 'external-root'], expect.any(AbortSignal));
+        });
+        expect(result.current.tree.current).toEqual([
+            createParent('expandable-root', [createLeaf('expandable-child')]),
+            createLeaf('leaf'),
+        ]);
+        expect(result.current.treeItemsRecord.current).toEqual({
+            'expandable-root': { label: 'expandable-root' },
+            'expandable-child': { label: 'expandable-child' },
+            leaf: { label: 'leaf' },
+        });
+    }));
+    it('should update tree and record from search result without preloading', () => __awaiter(void 0, void 0, void 0, function* () {
+        const onSearch = vi.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                tree: [createParent('root-node', [createLeaf('child-node')])],
+                needPreloadNodes: [],
+            });
+        }));
+        const { result } = renderHook(() => useSearchableTree({
+            initTree: [createLeaf('initial')],
+            onPreloadNode: vi.fn(),
+            onPreloadNodes: vi.fn(),
+            onSearch,
+            mapNodeToRecordItem,
+        }));
+        act(() => {
+            result.current.search.onChange('query');
+        });
+        yield waitFor(() => {
+            expect(onSearch).toHaveBeenCalledWith({ search: 'query' }, expect.any(AbortSignal));
+            expect(result.current.tree.current).toEqual([createParent('root-node', [createLeaf('child-node')])]);
+        });
+        expect(result.current.expandedNodes.current).toEqual([]);
+        expect(result.current.treeItemsRecord.current).toEqual({
+            'root-node': { label: 'root-node' },
+            'child-node': { label: 'child-node' },
+        });
+    }));
+});

package/dist/esm/hooks/__tests__/useTreeMultiSelection.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/hooks/__tests__/useTreeMultiSelection.spec.js

@@ -0,0 +1,130 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { act, renderHook } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import { useTreeMultiSelection } from '../useTreeMultiSelection';
+const createLeaf = (id) => ({
+    id,
+    title: id,
+});
+const createParent = (id, nested) => ({
+    id,
+    title: id,
+    nested,
+});
+describe('useTreeMultiSelection', () => {
+    it('should keep selected state uncontrolled by default', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { result } = renderHook(() => useTreeMultiSelection({
+            onDataLoad: vi.fn(() => __awaiter(void 0, void 0, void 0, function* () { return ({ preloadedChildren: [], updatedTree: [] }); })),
+            onSelect: () => ({ added: ['a'], removed: [] }),
+        }));
+        expect(result.current.selected).toEqual([]);
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield result.current.onSelect(['a'], createLeaf('a'));
+        }));
+        expect(result.current.selected).toEqual(['a']);
+    }));
+    it('should call onChangeSelected when selection updates', () => __awaiter(void 0, void 0, void 0, function* () {
+        const onChangeSelected = vi.fn();
+        const { result } = renderHook(() => useTreeMultiSelection({
+            onDataLoad: vi.fn(() => __awaiter(void 0, void 0, void 0, function* () { return ({ preloadedChildren: [], updatedTree: [] }); })),
+            onSelect: () => ({ added: ['a'], removed: [] }),
+            onChangeSelected,
+        }));
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield result.current.onSelect(['a'], createLeaf('a'));
+        }));
+        expect(onChangeSelected).toHaveBeenCalledWith(['a']);
+    }));
+    it('should treat selected prop as controlled', () => __awaiter(void 0, void 0, void 0, function* () {
+        const onChangeSelected = vi.fn();
+        const { result, rerender } = renderHook(({ selected }) => useTreeMultiSelection({
+            onDataLoad: vi.fn(() => __awaiter(void 0, void 0, void 0, function* () { return ({ preloadedChildren: [], updatedTree: [] }); })),
+            onSelect: () => ({ added: ['b'], removed: [] }),
+            selected,
+            onChangeSelected,
+        }), { initialProps: { selected: ['a'] } });
+        expect(result.current.selected).toEqual(['a']);
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield result.current.onSelect(['a', 'b'], createLeaf('b'));
+        }));
+        // controlled value does not change until parent updates it
+        expect(result.current.selected).toEqual(['a']);
+        expect(onChangeSelected).toHaveBeenCalledWith(['a', 'b']);
+        rerender({ selected: ['a', 'b'] });
+        expect(result.current.selected).toEqual(['a', 'b']);
+    }));
+    it('should preload children when selecting empty parent node and pass cloned node to onSelect', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = createParent('parent', []);
+        const preloadedChildren = [createLeaf('child-1'), createLeaf('child-2')];
+        const onDataLoad = vi.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                preloadedChildren,
+                updatedTree: [createParent('parent', preloadedChildren)],
+            });
+        }));
+        const onSelect = vi.fn(() => ({ added: ['parent', 'child-1', 'child-2'], removed: [] }));
+        const { result } = renderHook(() => useTreeMultiSelection({
+            onDataLoad,
+            onSelect,
+        }));
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield result.current.onSelect(['parent'], node);
+        }));
+        expect(onDataLoad).toHaveBeenCalledWith(node);
+        expect(onSelect).toHaveBeenCalledWith({
+            selectedKeys: ['parent'],
+            node: createParent('parent', preloadedChildren),
+            isSelected: true,
+        });
+        expect(result.current.selected.sort()).toEqual(['child-1', 'child-2', 'parent']);
+    }));
+    it('should not preload when parent node already has children', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = createParent('parent', [createLeaf('child')]);
+        const onDataLoad = vi.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                preloadedChildren: [],
+                updatedTree: [],
+            });
+        }));
+        const onSelect = vi.fn(() => ({ added: ['parent'], removed: [] }));
+        const { result } = renderHook(() => useTreeMultiSelection({
+            onDataLoad,
+            onSelect,
+        }));
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield result.current.onSelect(['parent'], node);
+        }));
+        expect(onDataLoad).not.toHaveBeenCalled();
+        expect(onSelect).toHaveBeenCalledWith({
+            selectedKeys: ['parent'],
+            node,
+            isSelected: true,
+        });
+    }));
+    it('should add and remove ids from selection without duplicates', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { result } = renderHook(() => useTreeMultiSelection({
+            onDataLoad: vi.fn(() => __awaiter(void 0, void 0, void 0, function* () { return ({ preloadedChildren: [], updatedTree: [] }); })),
+            onSelect: () => ({ added: ['a', 'a', 'b'], removed: [] }),
+        }));
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield result.current.onSelect(['a'], createLeaf('a'));
+        }));
+        expect(result.current.selected.sort()).toEqual(['a', 'b']);
+        const { result: result2 } = renderHook(() => useTreeMultiSelection({
+            onDataLoad: vi.fn(() => __awaiter(void 0, void 0, void 0, function* () { return ({ preloadedChildren: [], updatedTree: [] }); })),
+            onSelect: () => ({ added: [], removed: ['a'] }),
+            selected: ['a', 'b'],
+        }));
+        yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield result2.current.onSelect(['b'], createLeaf('a'));
+        }));
+    }));
+});

package/dist/esm/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useSearchableTree';
+export * from './useTreeMultiSelection';

package/dist/esm/hooks/index.js

@@ -0,0 +1,2 @@
+export * from './useSearchableTree';
+export * from './useTreeMultiSelection';