@snack-uikit/tree 0.9.37 → 0.10.1-preview-0aba136f.0

package/dist/cjs/{helpers.js → helpers/lookupTreeForSelectedNodes.js}

@@ -3,47 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.checkNestedNodesSelection = checkNestedNodesSelection;
-exports.findAllExpandedChildNodeIds = findAllExpandedChildNodeIds;
 exports.lookupTreeForSelectedNodes = lookupTreeForSelectedNodes;
-function findAllChildNodeIds(nodes) {
-  var _a;
-  const stack = [...nodes];
-  const ids = [];
-  let node;
-  while (node = stack.pop()) {
-    if (!node.disabled) {
-      ids.push(node.id);
-      if ((_a = node.nested) === null || _a === void 0 ? void 0 : _a.length) {
-        stack.push(...node.nested);
-      }
-    }
-  }
-  return ids;
-}
-function checkNestedNodesSelection(nodes, selectedKeys) {
-  const allIds = findAllChildNodeIds(nodes);
-  const selected = allIds.filter(id => selectedKeys.includes(id));
-  const someSelected = selected.length > 0;
-  const allSelected = someSelected && allIds.length === selected.length;
-  return {
-    someSelected: !allSelected && someSelected,
-    allSelected
-  };
-}
-function findAllExpandedChildNodeIds(nodes, expandedNodes) {
-  var _a;
-  const stack = [...nodes];
-  const ids = [];
-  let node;
-  while (node = stack.shift()) {
-    ids.push(node.id);
-    if (((_a = node.nested) === null || _a === void 0 ? void 0 : _a.length) && expandedNodes.includes(node.id)) {
-      stack.unshift(...node.nested);
-    }
-  }
-  return ids;
-}
+const checkNestedNodesSelection_1 = require("./checkNestedNodesSelection");
+const findAllChildNodeIds_1 = require("./findAllChildNodeIds");
 function lookupTreeForSelectedNodes(_ref) {
   let {
     node,
@@ -54,12 +16,12 @@ function lookupTreeForSelectedNodes(_ref) {
   const {
     nested
   } = node;
-  const childSelection = (nested === null || nested === void 0 ? void 0 : nested.length) ? checkNestedNodesSelection(nested, selectedNodes) : undefined;
+  const childSelection = (nested === null || nested === void 0 ? void 0 : nested.length) ? (0, checkNestedNodesSelection_1.checkNestedNodesSelection)(nested, selectedNodes) : undefined;
   const isSelected = childSelection ? childSelection.someSelected || childSelection.allSelected : selectedNodes.includes(node.id);
   let updatedSelectedNodes = [];
   const allIdsFromNode = [node.id];
   if (nested === null || nested === void 0 ? void 0 : nested.length) {
-    allIdsFromNode.push(...findAllChildNodeIds(nested));
+    allIdsFromNode.push(...(0, findAllChildNodeIds_1.findAllChildNodeIds)(nested));
   }
   if (isSelected) {
     updatedSelectedNodes = selectedNodes.filter(id => !allIdsFromNode.includes(id));
@@ -70,7 +32,7 @@ function lookupTreeForSelectedNodes(_ref) {
     let parent = parentNode;
     while (parent) {
       if ((_a = parent.nested) === null || _a === void 0 ? void 0 : _a.length) {
-        const parentNestedSelection = checkNestedNodesSelection(parent.nested, updatedSelectedNodes);
+        const parentNestedSelection = (0, checkNestedNodesSelection_1.checkNestedNodesSelection)(parent.nested, updatedSelectedNodes);
         const parentId = parent.id;
         if (isSelected) {
           if (!parentNestedSelection.allSelected) {

package/dist/cjs/helpers/sortTreeItemsByTitle.d.ts

@@ -0,0 +1,2 @@
+import { ExtendedTreeNodeProps } from '../types';
+export declare const sortTreeItemsByTitle: (items: ExtendedTreeNodeProps[]) => ExtendedTreeNodeProps[];

package/dist/cjs/helpers/sortTreeItemsByTitle.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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);
+  return valueA.localeCompare(valueB);
+});
+exports.sortTreeItemsByTitle = sortTreeItemsByTitle;

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

@@ -0,0 +1,2 @@
+import { TreeNodeProps } from '../';
+export declare const traverse: <T extends TreeNodeProps>(nodes: T[], callback: (node: T, depth: number) => void) => void;

package/dist/cjs/helpers/traverse.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traverse = void 0;
+const queue_fifo_1 = __importDefault(require("queue-fifo"));
+const traverse = (nodes, callback) => {
+  var _a;
+  const queue = new queue_fifo_1.default();
+  for (const node of nodes) {
+    queue.enqueue({
+      node,
+      depth: 0
+    });
+  }
+  while (!queue.isEmpty()) {
+    const nodeWithDepth = queue.dequeue();
+    if (!nodeWithDepth) {
+      continue;
+    }
+    const {
+      node,
+      depth
+    } = nodeWithDepth;
+    callback(node, depth);
+    for (const child of (_a = node.nested) !== null && _a !== void 0 ? _a : []) {
+      queue.enqueue({
+        node: child,
+        depth: depth + 1
+      });
+    }
+  }
+};
+exports.traverse = traverse;

package/dist/cjs/types.d.ts

@@ -100,3 +100,6 @@ export type TreeMultiSelect = Omit<TreeCommonProps, 'selected'> & {
     onSelect?(selectedKeys: TreeNodeId[], node: TreeNodeProps): void;
 };
 export type TreeBaseProps = TreeView | TreeMultiSelect | TreeSingleSelect;
+export type ExtendedTreeNodeProps = TreeNodeProps & {
+    getTitle?(): void;
+};

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

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

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

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { collectIds } from '../collectIds';
+import { tree } from './constants';
+describe('collect tree ids', () => {
+    it('find all ids', () => {
+        const expected = [
+            'customer 1',
+            'customer 2',
+            'same_hierarchy customer',
+            'department 1.1',
+            'department 1.2',
+            'department 2.1',
+            'same_hierarchy department',
+            'project 1.1.1',
+            'project 1.1.2',
+            'same_hierarchy project',
+        ];
+        expect(collectIds(tree)).toEqual(expected);
+    });
+});

package/dist/esm/helpers/__tests__/constants.d.ts

@@ -0,0 +1,2 @@
+import { TreeNodeProps } from '../../types';
+export declare const tree: TreeNodeProps[];

package/dist/esm/helpers/__tests__/constants.js

@@ -0,0 +1,52 @@
+export const tree = [
+    {
+        id: 'customer 1',
+        title: 'customer 1',
+        nested: [
+            {
+                id: 'department 1.1',
+                title: 'department 1.1',
+                nested: [
+                    {
+                        id: 'project 1.1.1',
+                        title: 'project 1.1.1',
+                    },
+                    {
+                        id: 'project 1.1.2',
+                        title: 'project 1.1.2',
+                    },
+                ],
+            },
+            {
+                id: 'department 1.2',
+                title: 'department 1.2',
+            },
+        ],
+    },
+    {
+        id: 'customer 2',
+        title: 'customer 2',
+        nested: [
+            {
+                id: 'department 2.1',
+                title: 'department 2.1',
+            },
+        ],
+    },
+    {
+        id: 'same_hierarchy customer',
+        title: 'same_hierarchy customer',
+        nested: [
+            {
+                id: 'same_hierarchy department',
+                title: 'same_hierarchy department',
+                nested: [
+                    {
+                        id: 'same_hierarchy project',
+                        title: 'same_hierarchy project',
+                    },
+                ],
+            },
+        ],
+    },
+];

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

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

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

@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest';
+import { getSearchedTreeItems } from '../getSearchedTreeItems';
+import { tree } from './constants';
+describe('search tree items', () => {
+    it('find items if 1 project is matched', () => {
+        const expected = [
+            {
+                id: 'customer 1',
+                title: 'customer 1',
+                nested: [
+                    {
+                        id: 'department 1.1',
+                        title: 'department 1.1',
+                        nested: [
+                            {
+                                id: 'project 1.1.1',
+                                title: 'project 1.1.1',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'project 1.1.1' } })).toEqual(expected);
+    });
+    it('find items if 2 projects are matched', () => {
+        const expected = [
+            {
+                id: 'customer 1',
+                title: 'customer 1',
+                nested: [
+                    {
+                        id: 'department 1.1',
+                        title: 'department 1.1',
+                        nested: [
+                            {
+                                id: 'project 1.1.1',
+                                title: 'project 1.1.1',
+                            },
+                            {
+                                id: 'project 1.1.2',
+                                title: 'project 1.1.2',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'project 1.1' } })).toEqual(expected);
+    });
+    it('find items if 1 department is matched', () => {
+        const expected = [
+            {
+                id: 'customer 1',
+                title: 'customer 1',
+                nested: [
+                    {
+                        id: 'department 1.1',
+                        title: 'department 1.1',
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'department 1.1' } })).toEqual(expected);
+    });
+    it('find items if 2 departments are matched', () => {
+        const expected = [
+            {
+                id: 'customer 1',
+                title: 'customer 1',
+                nested: [
+                    {
+                        id: 'department 1.1',
+                        title: 'department 1.1',
+                    },
+                    {
+                        id: 'department 1.2',
+                        title: 'department 1.2',
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'department 1.' } })).toEqual(expected);
+    });
+    it('find items if 1 customer is matched', () => {
+        const expected = [
+            {
+                id: 'customer 1',
+                title: 'customer 1',
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'customer 1' } })).toEqual(expected);
+    });
+    it('find items if not one items are matched', () => {
+        const expected = [];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'test' } })).toEqual(expected);
+    });
+    it('find items if empty query', () => {
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: '' } })).toEqual(tree);
+    });
+    it('find items if empty searchOptions', () => {
+        expect(getSearchedTreeItems({ tree })).toEqual(tree);
+    });
+    it('find matches in the same hierarchy', () => {
+        const expected = [
+            {
+                id: 'same_hierarchy customer',
+                title: 'same_hierarchy customer',
+                nested: [
+                    {
+                        id: 'same_hierarchy department',
+                        title: 'same_hierarchy department',
+                        nested: [
+                            {
+                                id: 'same_hierarchy project',
+                                title: 'same_hierarchy project',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'same_hierarchy' } })).toEqual(expected);
+    });
+    it('find all items from customer 2', () => {
+        const expected = [
+            {
+                id: 'customer 2',
+                title: 'customer 2',
+                nested: [
+                    {
+                        id: 'department 2.1',
+                        title: 'department 2.1',
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'customer 2', includeChildrenMatchedParent: true } })).toEqual(expected);
+    });
+    it('find all items from department 1.1', () => {
+        const expected = [
+            {
+                id: 'customer 1',
+                title: 'customer 1',
+                nested: [
+                    {
+                        id: 'department 1.1',
+                        title: 'department 1.1',
+                        nested: [
+                            {
+                                id: 'project 1.1.1',
+                                title: 'project 1.1.1',
+                            },
+                            {
+                                id: 'project 1.1.2',
+                                title: 'project 1.1.2',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeItems({ tree, searchOptions: { query: 'department 1.1', includeChildrenMatchedParent: true } })).toEqual(expected);
+    });
+});

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

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

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

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { getSearchedTreeNodeById } from '../getSearchedTreeNodeById';
+import { tree } from './constants';
+describe('get tree items by id', () => {
+    it('should return the item with nested when it exists', () => {
+        const expected = {
+            id: 'customer 1',
+            title: 'customer 1',
+            nested: [
+                {
+                    id: 'department 1.1',
+                    title: 'department 1.1',
+                    nested: [
+                        {
+                            id: 'project 1.1.1',
+                            title: 'project 1.1.1',
+                        },
+                        {
+                            id: 'project 1.1.2',
+                            title: 'project 1.1.2',
+                        },
+                    ],
+                },
+                {
+                    id: 'department 1.2',
+                    title: 'department 1.2',
+                },
+            ],
+        };
+        expect(getSearchedTreeNodeById({ tree, searchOptions: { id: 'customer 1' } })).toEqual(expected);
+    });
+    it('should return the item without nested when it exists', () => {
+        const expected = {
+            id: 'customer 1',
+            title: 'customer 1',
+        };
+        expect(getSearchedTreeNodeById({ tree, searchOptions: { id: 'customer 1', includeNested: false } })).toEqual(expected);
+    });
+    it('should return null or undefined when the item does not exist', () => {
+        const expected = null;
+        expect(getSearchedTreeNodeById({ tree, searchOptions: { id: 'customer none' } })).toEqual(expected);
+    });
+});
+describe('get tree items by ids', () => {
+    it('should return the item when only 1 item exists with nested', () => {
+        const expected = [
+            {
+                id: 'department 1.1',
+                title: 'department 1.1',
+                nested: [
+                    {
+                        id: 'project 1.1.1',
+                        title: 'project 1.1.1',
+                    },
+                    {
+                        id: 'project 1.1.2',
+                        title: 'project 1.1.2',
+                    },
+                ],
+            },
+        ];
+        expect(getSearchedTreeNodeById({
+            tree,
+            searchOptions: { id: ['department 1.1'] },
+        })).toEqual(expected);
+    });
+    it('should return the item when only 1 item exists without nested', () => {
+        const expected = [
+            {
+                id: 'department 1.1',
+                title: 'department 1.1',
+            },
+        ];
+        expect(getSearchedTreeNodeById({
+            tree,
+            searchOptions: { id: ['department 1.1'], includeNested: false },
+        })).toEqual(expected);
+    });
+    it('should return both items when 2 items exist', () => {
+        const expected = [
+            {
+                id: 'department 1.1',
+                title: 'department 1.1',
+                nested: [
+                    {
+                        id: 'project 1.1.1',
+                        title: 'project 1.1.1',
+                    },
+                    {
+                        id: 'project 1.1.2',
+                        title: 'project 1.1.2',
+                    },
+                ],
+            },
+            {
+                id: 'department 1.2',
+                title: 'department 1.2',
+            },
+        ];
+        expect(getSearchedTreeNodeById({
+            tree,
+            searchOptions: { id: ['department 1.1', 'department 1.2'] },
+        })).toEqual(expected);
+    });
+    it('should return an empty array or null when no items exist', () => {
+        const expected = [];
+        expect(getSearchedTreeNodeById({
+            tree,
+            searchOptions: { id: ['department 1.1test', 'department 1.2test'] },
+        })).toEqual(expected);
+    });
+});

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

@@ -0,0 +1,5 @@
+import { TreeNodeId, TreeNodeProps } from '../types';
+export declare function checkNestedNodesSelection(nodes: TreeNodeProps[], selectedKeys: TreeNodeId[]): {
+    someSelected: boolean;
+    allSelected: boolean;
+};

package/dist/esm/helpers/checkNestedNodesSelection.js

@@ -0,0 +1,11 @@
+import { findAllChildNodeIds } from './findAllChildNodeIds';
+export function checkNestedNodesSelection(nodes, selectedKeys) {
+    const allIds = findAllChildNodeIds(nodes);
+    const selected = allIds.filter(id => selectedKeys.includes(id));
+    const someSelected = selected.length > 0;
+    const allSelected = someSelected && allIds.length === selected.length;
+    return {
+        someSelected: !allSelected && someSelected,
+        allSelected,
+    };
+}

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

@@ -0,0 +1,2 @@
+import { TreeNodeProps } from '../types';
+export declare const collectIds: (treeNodes: TreeNodeProps[]) => string[];

package/dist/esm/helpers/collectIds.js

@@ -0,0 +1,6 @@
+import { traverse } from './traverse';
+export const collectIds = (treeNodes) => {
+    const ids = [];
+    traverse(treeNodes, node => ids.push(node.id));
+    return ids;
+};

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

@@ -0,0 +1,2 @@
+import { ExtendedTreeNodeProps } from '../types';
+export declare const extractTreeNodeTitle: ({ title, getTitle }: ExtendedTreeNodeProps) => string;

package/dist/esm/helpers/extractTreeNodeTitle.js

@@ -0,0 +1 @@
+export const extractTreeNodeTitle = ({ title, getTitle }) => { var _a; return typeof title === 'string' ? title : ((_a = getTitle === null || getTitle === void 0 ? void 0 : getTitle()) !== null && _a !== void 0 ? _a : ''); };

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

@@ -0,0 +1,2 @@
+import { TreeNodeId, TreeNodeProps } from '../types';
+export declare function findAllChildNodeIds(nodes: TreeNodeProps[]): TreeNodeId[];

package/dist/esm/helpers/findAllChildNodeIds.js

@@ -0,0 +1,15 @@
+export function findAllChildNodeIds(nodes) {
+    var _a;
+    const stack = [...nodes];
+    const ids = [];
+    let node;
+    while ((node = stack.pop())) {
+        if (!node.disabled) {
+            ids.push(node.id);
+            if ((_a = node.nested) === null || _a === void 0 ? void 0 : _a.length) {
+                stack.push(...node.nested);
+            }
+        }
+    }
+    return ids;
+}

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

@@ -0,0 +1,2 @@
+import { TreeNodeId, TreeNodeProps } from '../types';
+export declare function findAllExpandedChildNodeIds(nodes: TreeNodeProps[], expandedNodes: TreeNodeId[]): string[];

package/dist/esm/helpers/findAllExpandedChildNodeIds.js

@@ -0,0 +1,13 @@
+export function findAllExpandedChildNodeIds(nodes, expandedNodes) {
+    var _a;
+    const stack = [...nodes];
+    const ids = [];
+    let node;
+    while ((node = stack.shift())) {
+        ids.push(node.id);
+        if (((_a = node.nested) === null || _a === void 0 ? void 0 : _a.length) && expandedNodes.includes(node.id)) {
+            stack.unshift(...node.nested);
+        }
+    }
+    return ids;
+}

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

@@ -0,0 +1,10 @@
+import { ExtendedTreeNodeProps } from '../types';
+type SearchParams = {
+    tree: ExtendedTreeNodeProps[];
+    searchOptions?: Partial<{
+        query: string;
+        includeChildrenMatchedParent: boolean;
+    }>;
+};
+export declare const getSearchedTreeItems: ({ tree, searchOptions }: SearchParams) => ExtendedTreeNodeProps[];
+export {};

package/dist/esm/helpers/getSearchedTreeItems.js

@@ -0,0 +1,31 @@
+import { extractTreeNodeTitle } from './extractTreeNodeTitle';
+const isMatchedTreeItem = (search) => {
+    const searchLower = search.toLocaleLowerCase();
+    return (treeItem) => {
+        const currentValue = extractTreeNodeTitle(treeItem);
+        return currentValue.toLocaleLowerCase().includes(searchLower);
+    };
+};
+export const getSearchedTreeItems = ({ tree, searchOptions }) => {
+    if (!(searchOptions === null || searchOptions === void 0 ? void 0 : searchOptions.query))
+        return tree;
+    const { query = '', includeChildrenMatchedParent } = searchOptions;
+    const matchFunc = isMatchedTreeItem(query);
+    const searchItems = (treeItems) => treeItems.reduce((acc, item) => {
+        const hasMatchingTitle = matchFunc(item);
+        const needDeepSearch = !(hasMatchingTitle && includeChildrenMatchedParent);
+        const matchedChildren = item.nested && (needDeepSearch ? searchItems(item.nested) : item.nested);
+        if (hasMatchingTitle || (matchedChildren === null || matchedChildren === void 0 ? void 0 : matchedChildren.length)) {
+            const newItem = Object.assign({}, item);
+            if (matchedChildren === null || matchedChildren === void 0 ? void 0 : matchedChildren.length) {
+                newItem.nested = matchedChildren;
+            }
+            else {
+                delete newItem.nested;
+            }
+            acc.push(newItem);
+        }
+        return acc;
+    }, []);
+    return searchItems(tree);
+};

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

@@ -0,0 +1,11 @@
+import { ExtendedTreeNodeProps } from '../types';
+type ReturnSearch<I, T> = I extends string ? T | null : T[];
+type SearchByIdParams<I, T> = {
+    tree: T[];
+    searchOptions: {
+        id: I;
+        includeNested?: boolean;
+    };
+};
+export declare const getSearchedTreeNodeById: <I extends string | string[], T extends ExtendedTreeNodeProps>({ tree, searchOptions: { id, includeNested }, }: SearchByIdParams<I, T>) => ReturnSearch<I, T>;
+export {};

package/dist/esm/helpers/getSearchedTreeNodeById.js

@@ -0,0 +1,23 @@
+export const getSearchedTreeNodeById = ({ tree, searchOptions: { id, includeNested = true }, }) => {
+    const isArrayIds = Array.isArray(id);
+    if (!id || (isArrayIds && id.length === 0)) {
+        return (isArrayIds ? [] : null);
+    }
+    const foundItems = [];
+    const searchNodes = (nodes) => {
+        for (const node of nodes) {
+            const matchCondition = isArrayIds ? id.includes(node.id) : node.id === id;
+            if (matchCondition) {
+                foundItems.push(includeNested ? node : Object.assign(Object.assign({}, node), { nested: undefined }));
+                if (!isArrayIds) {
+                    return;
+                }
+            }
+            if (node.nested) {
+                searchNodes(node.nested);
+            }
+        }
+    };
+    searchNodes(tree);
+    return (isArrayIds ? foundItems : foundItems[0] || null);
+};