@snack-uikit/tree 0.11.0 → 0.11.1-preview-02fd9f01.0

package/README.md

@@ -112,8 +112,8 @@ function TreeAsyncLoadExample() {
 ### Props
 | name | type | default value | description |
 |------|------|---------------|-------------|
-| __@unscopables@986* | `{ [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; ... 29 more ...; readonly [Symbol.unscopables]?: boolean; }` | - | Is an object whose properties have the value 'true' when they will be absent when used in a 'with' statement. |
-| __@iterator@984* | `() => ArrayIterator<TreeNodeProps>` | - | Iterator |
+| __@unscopables@987* | `{ [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; ... 29 more ...; readonly [Symbol.unscopables]?: boolean; }` | - | Is an object whose properties have the value 'true' when they will be absent when used in a 'with' statement. |
+| __@iterator@985* | `() => ArrayIterator<TreeNodeProps>` | - | Iterator |
 | with* | `(index: number, value: TreeNodeProps) => TreeNodeProps[]` | - | Copies an array, then overwrites the value at the provided index with the given value. If the index is negative, then it replaces from the end of the array. @param index The index of the value to overwrite. If the index is negative, then it replaces from the end of the array. @param value The value to write into the copied array. @returns The copied array with the updated value. |
 | toSpliced* | `{ (start: number, deleteCount: number, ...items: TreeNodeProps[]): TreeNodeProps[]; (start: number, deleteCount?: number): TreeNodeProps[]; }` | - | Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array. Copies an array and removes elements while returning the remaining elements. @param start The zero-based location in the array from which to start removing elements. @param deleteCount The number of elements to remove. @param items Elements to insert into the copied array in place of the deleted elements. @returns The copied array. @param start The zero-based location in the array from which to start removing elements. @param deleteCount The number of elements to remove. @returns A copy of the original array with the remaining elements. |
 | toSorted* | `(compareFn?: (a: TreeNodeProps, b: TreeNodeProps) => number) => TreeNodeProps[]` | - | Returns a copy of an array with its elements sorted. @param compareFn Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order. ```ts [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22] ``` |
@@ -176,8 +176,8 @@ function TreeAsyncLoadExample() {
 ### Props
 | name | type | default value | description |
 |------|------|---------------|-------------|
-| __@unscopables@986* | `{ [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; ... 29 more ...; readonly [Symbol.unscopables]?: boolean; }` | - | Is an object whose properties have the value 'true' when they will be absent when used in a 'with' statement. |
-| __@iterator@984* | `() => ArrayIterator<ExtendedTreeNodeProps>` | - | Iterator |
+| __@unscopables@987* | `{ [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; ... 29 more ...; readonly [Symbol.unscopables]?: boolean; }` | - | Is an object whose properties have the value 'true' when they will be absent when used in a 'with' statement. |
+| __@iterator@985* | `() => ArrayIterator<ExtendedTreeNodeProps>` | - | Iterator |
 | with* | `(index: number, value: ExtendedTreeNodeProps) => ExtendedTreeNodeProps[]` | - | Copies an array, then overwrites the value at the provided index with the given value. If the index is negative, then it replaces from the end of the array. @param index The index of the value to overwrite. If the index is negative, then it replaces from the end of the array. @param value The value to write into the copied array. @returns The copied array with the updated value. |
 | toSpliced* | `{ (start: number, deleteCount: number, ...items: ExtendedTreeNodeProps[]): ExtendedTreeNodeProps[]; (start: number, deleteCount?: number): ExtendedTreeNodeProps[]; }` | - | Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array. Copies an array and removes elements while returning the remaining elements. @param start The zero-based location in the array from which to start removing elements. @param deleteCount The number of elements to remove. @param items Elements to insert into the copied array in place of the deleted elements. @returns The copied array. @param start The zero-based location in the array from which to start removing elements. @param deleteCount The number of elements to remove. @returns A copy of the original array with the remaining elements. |
 | toSorted* | `(compareFn?: (a: ExtendedTreeNodeProps, b: ExtendedTreeNodeProps) => number) => ExtendedTreeNodeProps[]` | - | Returns a copy of an array with its elements sorted. @param compareFn Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order. ```ts [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22] ``` |
@@ -217,6 +217,13 @@ function TreeAsyncLoadExample() {
 | length* | `number` | - | Gets or sets the length of the array. This is a number one higher than the highest index in the array. |
 | toString | `() => string` | function toString() { [native code] } | Returns a string representation of an array. |
 | toLocaleString | `{ (): string; (locales: string \| string[], options?: NumberFormatOptions & DateTimeFormatOptions): string; }` | function toLocaleString() { [native code] } | Returns a string representation of an array. The elements are converted to string using their toLocaleString methods. |
+## traverseWithTarget
+BFS с указанием целевого списка для каждого узла.
+Очередь хранит (node, depth, targetList). Callback добавляет узел в targetList
+и возвращает массив для детей (или undefined, чтобы не обходить детей).
+### Props
+| name | type | default value | description |
+|------|------|---------------|-------------|
 
 
 [//]: DOCUMENTATION_SECTION_END

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

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

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

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const vitest_1 = require("vitest");
+const collectEmptyNestedNodesInExpanded_1 = require("../collectEmptyNestedNodesInExpanded");
+const node = (id, nested) => Object.assign({
+  id,
+  title: id
+}, nested !== undefined && {
+  nested
+});
+(0, vitest_1.describe)('collectEmptyNestedNodesInExpanded', () => {
+  (0, vitest_1.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 = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, expandedIds);
+    (0, vitest_1.expect)(result).toHaveLength(1);
+    (0, vitest_1.expect)(result[0]).toMatchObject({
+      id: 'a',
+      nested: []
+    });
+  });
+  (0, vitest_1.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 = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, expandedIds);
+    (0, vitest_1.expect)(result).toHaveLength(1);
+    (0, vitest_1.expect)(result[0].id).toBe('b');
+  });
+  (0, vitest_1.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 = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, expandedIds);
+    (0, vitest_1.expect)(result).toHaveLength(1);
+    (0, vitest_1.expect)(result[0].id).toBe('b');
+  });
+  (0, vitest_1.it)('does not return nodes without nested property (leaf)', () => {
+    const tree = [node('leaf'), node('empty', [])];
+    const expandedIds = new Set(['leaf', 'empty']);
+    const result = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, expandedIds);
+    (0, vitest_1.expect)(result).toHaveLength(1);
+    (0, vitest_1.expect)(result[0].id).toBe('empty');
+  });
+  (0, vitest_1.it)('returns empty array for empty tree', () => {
+    const result = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)([], new Set(['any']));
+    (0, vitest_1.expect)(result).toEqual([]);
+  });
+  (0, vitest_1.it)('returns empty array when expandedIds is empty', () => {
+    const tree = [node('a', []), node('b', [])];
+    const result = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, new Set());
+    (0, vitest_1.expect)(result).toEqual([]);
+  });
+  (0, vitest_1.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 = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, expandedIds);
+    (0, vitest_1.expect)(result).toHaveLength(1);
+    (0, vitest_1.expect)(result[0]).toMatchObject({
+      id: 'child',
+      nested: []
+    });
+  });
+  (0, vitest_1.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 = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, expandedIds);
+    (0, vitest_1.expect)(result).toHaveLength(3);
+    (0, vitest_1.expect)(result.map(n => n.id).sort()).toEqual(['a', 'b1', 'b2']);
+  });
+  (0, vitest_1.it)('only includes node if both empty nested and expanded', () => {
+    const tree = [node('expanded', []), node('collapsed', [])];
+    const expandedIds = new Set(['expanded']);
+    const result = (0, collectEmptyNestedNodesInExpanded_1.collectEmptyNestedNodesInExpanded)(tree, expandedIds);
+    (0, vitest_1.expect)(result).toHaveLength(1);
+    (0, vitest_1.expect)(result[0].id).toBe('expanded');
+  });
+});

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

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

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

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const vitest_1 = require("vitest");
+const setChildrenOfTreeNode_1 = require("../setChildrenOfTreeNode");
+const node = (id, nested) => Object.assign({
+  id,
+  title: id
+}, nested !== undefined && {
+  nested: nested.map(n => Object.assign(Object.assign({}, n), {
+    title: n.id
+  }))
+});
+(0, vitest_1.describe)('setChildrenOfTreeNode', () => {
+  (0, vitest_1.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 = (0, setChildrenOfTreeNode_1.setChildrenOfTreeNode)(tree, 'b', children);
+    (0, vitest_1.expect)(result).toHaveLength(2);
+    (0, vitest_1.expect)(result[0]).toMatchObject({
+      id: 'a',
+      nested: [{
+        id: 'a1'
+      }]
+    });
+    (0, vitest_1.expect)(result[1]).toMatchObject({
+      id: 'b',
+      nested: [{
+        id: 'new1'
+      }, {
+        id: 'new2'
+      }]
+    });
+  });
+  (0, vitest_1.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 = (0, setChildrenOfTreeNode_1.setChildrenOfTreeNode)(tree, 'child', children);
+    const root = result[0];
+    (0, vitest_1.expect)(root.nested).toHaveLength(1);
+    (0, vitest_1.expect)(root.nested[0]).toMatchObject({
+      id: 'child',
+      nested: [{
+        id: 'replacement'
+      }]
+    });
+  });
+  (0, vitest_1.it)('returns cloned tree when node is not found', () => {
+    const tree = [node('a'), node('b')];
+    const result = (0, setChildrenOfTreeNode_1.setChildrenOfTreeNode)(tree, 'missing', [node('x')]);
+    (0, vitest_1.expect)(result).toHaveLength(2);
+    (0, vitest_1.expect)(result[0]).toMatchObject({
+      id: 'a'
+    });
+    (0, vitest_1.expect)(result[1]).toMatchObject({
+      id: 'b'
+    });
+    (0, vitest_1.expect)(result).not.toBe(tree);
+  });
+  (0, vitest_1.it)('returns empty array for empty tree', () => {
+    const result = (0, setChildrenOfTreeNode_1.setChildrenOfTreeNode)([], 'any', [node('x')]);
+    (0, vitest_1.expect)(result).toEqual([]);
+  });
+  (0, vitest_1.it)('sets children for target node that had no nested (leaf)', () => {
+    const tree = [node('leaf'), node('other')];
+    const children = [node('new1')];
+    const result = (0, setChildrenOfTreeNode_1.setChildrenOfTreeNode)(tree, 'leaf', children);
+    (0, vitest_1.expect)(result[0]).toMatchObject({
+      id: 'leaf',
+      nested: [{
+        id: 'new1'
+      }]
+    });
+    (0, vitest_1.expect)(result[1]).toMatchObject({
+      id: 'other'
+    });
+  });
+  (0, vitest_1.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 = (0, setChildrenOfTreeNode_1.setChildrenOfTreeNode)(tree, 'second', children);
+    (0, vitest_1.expect)(result.map(n => n.id)).toEqual(['first', 'second', 'third']);
+    (0, vitest_1.expect)(result[1].nested).toHaveLength(2);
+    (0, vitest_1.expect)(result[1].nested.map(n => n.id)).toEqual(['new1', 'new2']);
+  });
+});

package/dist/cjs/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/cjs/helpers/collectEmptyNestedNodesInExpanded.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectEmptyNestedNodesInExpanded = collectEmptyNestedNodesInExpanded;
+const traverse_1 = require("./traverse");
+function collectEmptyNestedNodesInExpanded(nodes, expandedIds) {
+  const result = [];
+  (0, traverse_1.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/cjs/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/cjs/helpers/index.js

@@ -29,4 +29,6 @@ __exportStar(require("./getSearchedTreeItems"), exports);
 __exportStar(require("./getSearchedTreeNodeById"), exports);
 __exportStar(require("./lookupTreeForSelectedNodes"), exports);
 __exportStar(require("./sortTreeItemsByTitle"), exports);
-__exportStar(require("./traverse"), exports);
+__exportStar(require("./traverse"), exports);
+__exportStar(require("./setChildrenOfTreeNode"), exports);
+__exportStar(require("./collectEmptyNestedNodesInExpanded"), exports);

package/dist/cjs/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/cjs/helpers/setChildrenOfTreeNode.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setChildrenOfTreeNode = void 0;
+const traverse_1 = require("./traverse");
+const setChildrenOfTreeNode = (tree, nodeId, children) => {
+  const result = [];
+  (0, traverse_1.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;
+};
+exports.setChildrenOfTreeNode = setChildrenOfTreeNode;

package/dist/cjs/helpers/sortTreeItemsByTitle.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.sortTreeItemsByTitle = void 0;
 const extractTreeNodeTitle_1 = require("./extractTreeNodeTitle");
 const sortTreeItemsByTitle = items => items === null || items === void 0 ? void 0 : items.toSorted((itemA, itemB) => {
-  const valueA = (0, extractTreeNodeTitle_1.extractTreeNodeTitle)(itemA);
-  const valueB = (0, extractTreeNodeTitle_1.extractTreeNodeTitle)(itemB);
+  const valueA = (0, extractTreeNodeTitle_1.extractTreeNodeTitle)(itemA).toLowerCase();
+  const valueB = (0, extractTreeNodeTitle_1.extractTreeNodeTitle)(itemB).toLowerCase();
   return valueA.localeCompare(valueB);
 });
 exports.sortTreeItemsByTitle = sortTreeItemsByTitle;

package/dist/cjs/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/cjs/helpers/traverse.js

@@ -8,7 +8,7 @@ var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.traverse = void 0;
+exports.traverseWithTarget = exports.traverse = void 0;
 const queue_fifo_1 = __importDefault(require("queue-fifo"));
 const traverse = (nodes, callback) => {
   var _a;
@@ -37,4 +37,40 @@ const traverse = (nodes, callback) => {
     }
   }
 };
-exports.traverse = traverse;
+exports.traverse = traverse;
+/**
+ * BFS с указанием целевого списка для каждого узла.
+ * Очередь хранит (node, depth, targetList). Callback добавляет узел в targetList
+ * и возвращает массив для детей (или undefined, чтобы не обходить детей).
+ */
+const traverseWithTarget = (nodes, rootTargetList, callback) => {
+  var _a;
+  const queue = new queue_fifo_1.default();
+  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
+        });
+      }
+    }
+  }
+};
+exports.traverseWithTarget = traverseWithTarget;

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

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

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

@@ -0,0 +1,232 @@
+"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
+});
+const react_1 = require("@testing-library/react");
+const react_2 = require("react");
+const vitest_1 = require("vitest");
+const useSearchableTree_1 = require("../useSearchableTree");
+vitest_1.vi.mock('@siberiacancode/reactuse', () => ({
+  useDebounceValue: value => value,
+  useDidUpdate: (effect, deps) => {
+    const isFirstRenderRef = (0, react_2.useRef)(true);
+    (0, react_2.useEffect)(() => {
+      if (isFirstRenderRef.current) {
+        isFirstRenderRef.current = false;
+        return;
+      }
+      effect();
+    }, [deps, effect]);
+  },
+  useRefState: initialValue => (0, react_2.useRef)(initialValue)
+}));
+const createLeaf = id => ({
+  id,
+  title: id
+});
+const createParent = (id, nested) => ({
+  id,
+  title: id,
+  nested
+});
+const mapNodeToRecordItem = node => ({
+  label: String(node.title)
+});
+(0, vitest_1.describe)('useSearchableTree', () => {
+  (0, vitest_1.it)('should initialize tree and treeItemsRecord from initTree', () => {
+    const initTree = [createLeaf('node-1'), createParent('node-2', [createLeaf('node-2-1')])];
+    const {
+      result
+    } = (0, react_1.renderHook)(() => (0, useSearchableTree_1.useSearchableTree)({
+      initTree,
+      onPreloadNode: vitest_1.vi.fn(),
+      onPreloadNodes: vitest_1.vi.fn(),
+      onSearch: vitest_1.vi.fn(),
+      mapNodeToRecordItem
+    }));
+    (0, vitest_1.expect)(result.current.tree.current).toEqual(initTree);
+    (0, vitest_1.expect)(result.current.treeItemsRecord.current).toEqual({
+      'node-1': {
+        label: 'node-1'
+      },
+      'node-2': {
+        label: 'node-2'
+      },
+      'node-2-1': {
+        label: 'node-2-1'
+      }
+    });
+  });
+  (0, vitest_1.it)('should update expandedNodes on onExpand call', () => {
+    const {
+      result
+    } = (0, react_1.renderHook)(() => (0, useSearchableTree_1.useSearchableTree)({
+      initTree: [createLeaf('root')],
+      onPreloadNode: vitest_1.vi.fn(),
+      onPreloadNodes: vitest_1.vi.fn(),
+      onSearch: vitest_1.vi.fn(),
+      mapNodeToRecordItem
+    }));
+    (0, react_1.act)(() => {
+      result.current.onExpand(['root', 'child']);
+    });
+    (0, vitest_1.expect)(result.current.expandedNodes.current).toEqual(['root', 'child']);
+  });
+  (0, vitest_1.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 = vitest_1.vi.fn().mockResolvedValue(preloadedChildren);
+    const {
+      result
+    } = (0, react_1.renderHook)(() => (0, useSearchableTree_1.useSearchableTree)({
+      initTree,
+      onPreloadNode,
+      onPreloadNodes: vitest_1.vi.fn(),
+      onSearch: vitest_1.vi.fn(),
+      mapNodeToRecordItem
+    }));
+    let loadResult;
+    yield (0, react_1.act)(() => __awaiter(void 0, void 0, void 0, function* () {
+      loadResult = yield result.current.onDataLoad(createParent('root', []));
+    }));
+    (0, vitest_1.expect)(onPreloadNode).toHaveBeenCalledWith(createParent('root', []));
+    (0, vitest_1.expect)(loadResult).toEqual({
+      preloadedChildren,
+      updatedTree: [createParent('root', preloadedChildren)],
+      newTreeItemsRecord: {
+        root: {
+          label: 'root'
+        },
+        'child-1': {
+          label: 'child-1'
+        },
+        'child-2': {
+          label: 'child-2'
+        }
+      }
+    });
+    (0, vitest_1.expect)(result.current.tree.current).toEqual([createParent('root', preloadedChildren)]);
+    (0, vitest_1.expect)(result.current.treeItemsRecord.current).toEqual({
+      root: {
+        label: 'root'
+      },
+      'child-1': {
+        label: 'child-1'
+      },
+      'child-2': {
+        label: 'child-2'
+      }
+    });
+  }));
+  (0, vitest_1.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 = vitest_1.vi.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+      return {
+        tree: searchedTree,
+        needPreloadNodes: ['expandable-root', 'external-root']
+      };
+    }));
+    const onPreloadNodes = vitest_1.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
+    } = (0, react_1.renderHook)(() => (0, useSearchableTree_1.useSearchableTree)({
+      initTree: [createParent('init-root', [])],
+      onPreloadNode: vitest_1.vi.fn(),
+      onPreloadNodes,
+      onSearch,
+      mapNodeToRecordItem
+    }));
+    (0, react_1.act)(() => {
+      result.current.onExpand(['expandable-root']);
+      result.current.search.onChange('query');
+    });
+    yield (0, react_1.waitFor)(() => {
+      (0, vitest_1.expect)(onSearch).toHaveBeenCalledWith({
+        search: 'query',
+        expandedNodes: ['expandable-root']
+      }, vitest_1.expect.any(AbortSignal));
+      (0, vitest_1.expect)(onPreloadNodes).toHaveBeenCalledWith(['expandable-root', 'external-root'], vitest_1.expect.any(AbortSignal));
+    });
+    (0, vitest_1.expect)(result.current.tree.current).toEqual([createParent('expandable-root', [createLeaf('expandable-child')]), createLeaf('leaf')]);
+    (0, vitest_1.expect)(result.current.treeItemsRecord.current).toEqual({
+      'expandable-root': {
+        label: 'expandable-root'
+      },
+      'expandable-child': {
+        label: 'expandable-child'
+      },
+      leaf: {
+        label: 'leaf'
+      }
+    });
+  }));
+  (0, vitest_1.it)('should update tree and record from search result without preloading', () => __awaiter(void 0, void 0, void 0, function* () {
+    const onSearch = vitest_1.vi.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+      return {
+        tree: [createParent('root-node', [createLeaf('child-node')])],
+        needPreloadNodes: []
+      };
+    }));
+    const {
+      result
+    } = (0, react_1.renderHook)(() => (0, useSearchableTree_1.useSearchableTree)({
+      initTree: [createLeaf('initial')],
+      onPreloadNode: vitest_1.vi.fn(),
+      onPreloadNodes: vitest_1.vi.fn(),
+      onSearch,
+      mapNodeToRecordItem
+    }));
+    (0, react_1.act)(() => {
+      result.current.search.onChange('query');
+    });
+    yield (0, react_1.waitFor)(() => {
+      (0, vitest_1.expect)(onSearch).toHaveBeenCalledWith({
+        search: 'query',
+        expandedNodes: []
+      }, vitest_1.expect.any(AbortSignal));
+      (0, vitest_1.expect)(result.current.tree.current).toEqual([createParent('root-node', [createLeaf('child-node')])]);
+    });
+    (0, vitest_1.expect)(result.current.expandedNodes.current).toEqual([]);
+    (0, vitest_1.expect)(result.current.treeItemsRecord.current).toEqual({
+      'root-node': {
+        label: 'root-node'
+      },
+      'child-node': {
+        label: 'child-node'
+      }
+    });
+  }));
+});

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

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