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

package/src/helpers/getSearchedTreeItems.ts

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

package/src/helpers/getSearchedTreeNodeById.ts

@@ -0,0 +1,46 @@
+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 const getSearchedTreeNodeById = <I extends string | string[], T extends ExtendedTreeNodeProps>({
+  tree,
+  searchOptions: { id, includeNested = true },
+}: SearchByIdParams<I, T>): ReturnSearch<I, T> => {
+  const isArrayIds = Array.isArray(id);
+
+  if (!id || (isArrayIds && id.length === 0)) {
+    return (isArrayIds ? [] : null) as ReturnSearch<I, T>;
+  }
+
+  const foundItems: T[] = [];
+
+  const searchNodes = (nodes: T[]): void => {
+    for (const node of nodes) {
+      const matchCondition = isArrayIds ? id.includes(node.id) : node.id === id;
+
+      if (matchCondition) {
+        foundItems.push(includeNested ? node : { ...node, nested: undefined });
+
+        if (!isArrayIds) {
+          return;
+        }
+      }
+
+      if (node.nested) {
+        searchNodes(node.nested as T[]);
+      }
+    }
+  };
+
+  searchNodes(tree);
+
+  return (isArrayIds ? foundItems : foundItems[0] || null) as ReturnSearch<I, T>;
+};

package/src/helpers/index.ts

@@ -0,0 +1,8 @@
+export * from './checkNestedNodesSelection';
+export * from './collectIds';
+export * from './findAllExpandedChildNodeIds';
+export * from './getSearchedTreeItems';
+export * from './getSearchedTreeNodeById';
+export * from './lookupTreeForSelectedNodes';
+export * from './sortTreeItemsByTitle';
+export * from './traverse';

package/src/{helpers.ts → helpers/lookupTreeForSelectedNodes.ts}

@@ -1,53 +1,6 @@
-import { ParentNode, TreeNodeId, TreeNodeProps } from './types';
-
-function findAllChildNodeIds(nodes: TreeNodeProps[]): TreeNodeId[] {
-  const stack = [...nodes];
-  const ids: TreeNodeId[] = [];
-
-  let node: TreeNodeProps | undefined;
-
-  while ((node = stack.pop())) {
-    if (!node.disabled) {
-      ids.push(node.id);
-
-      if (node.nested?.length) {
-        stack.push(...node.nested);
-      }
-    }
-  }
-
-  return ids;
-}
-
-export function checkNestedNodesSelection(nodes: TreeNodeProps[], selectedKeys: TreeNodeId[]) {
-  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,
-  };
-}
-
-export function findAllExpandedChildNodeIds(nodes: TreeNodeProps[], expandedNodes: TreeNodeId[]) {
-  const stack = [...nodes];
-  const ids: TreeNodeId[] = [];
-
-  let node: TreeNodeProps | undefined;
-
-  while ((node = stack.shift())) {
-    ids.push(node.id);
-
-    if (node.nested?.length && expandedNodes.includes(node.id)) {
-      stack.unshift(...node.nested);
-    }
-  }
-
-  return ids;
-}
+import { ParentNode, TreeNodeId, TreeNodeProps } from '../types';
+import { checkNestedNodesSelection } from './checkNestedNodesSelection';
+import { findAllChildNodeIds } from './findAllChildNodeIds';
 
 export function lookupTreeForSelectedNodes({
   node,

package/src/helpers/sortTreeItemsByTitle.ts

@@ -0,0 +1,10 @@
+import { ExtendedTreeNodeProps } from '../types';
+import { extractTreeNodeTitle } from './extractTreeNodeTitle';
+
+export const sortTreeItemsByTitle = (items: ExtendedTreeNodeProps[]) =>
+  items?.toSorted((itemA, itemB) => {
+    const valueA = extractTreeNodeTitle(itemA);
+    const valueB = extractTreeNodeTitle(itemB);
+
+    return valueA.localeCompare(valueB);
+  });

package/src/helpers/traverse.ts

@@ -0,0 +1,27 @@
+import Queue from 'queue-fifo';
+
+import { TreeNodeProps } from '../';
+
+type NodeWithDepth<T extends TreeNodeProps> = { node: T; depth: number };
+
+export const traverse = <T extends TreeNodeProps>(nodes: T[], callback: (node: T, depth: number) => void) => {
+  const queue = new Queue<NodeWithDepth<T>>();
+
+  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 node.nested ?? []) {
+      queue.enqueue({ node: child as T, depth: depth + 1 });
+    }
+  }
+};

package/src/types.ts

@@ -114,3 +114,7 @@ export type TreeMultiSelect = Omit<TreeCommonProps, 'selected'> & {
 };
 
 export type TreeBaseProps = TreeView | TreeMultiSelect | TreeSingleSelect;
+
+export type ExtendedTreeNodeProps = TreeNodeProps & {
+  getTitle?(): void;
+};

package/dist/cjs/helpers.d.ts

@@ -1,11 +0,0 @@
-import { ParentNode, TreeNodeId, TreeNodeProps } from './types';
-export declare function checkNestedNodesSelection(nodes: TreeNodeProps[], selectedKeys: TreeNodeId[]): {
-    someSelected: boolean;
-    allSelected: boolean;
-};
-export declare function findAllExpandedChildNodeIds(nodes: TreeNodeProps[], expandedNodes: TreeNodeId[]): string[];
-export declare function lookupTreeForSelectedNodes({ node, selectedNodes, parentNode, }: {
-    node: Pick<TreeNodeProps, 'id' | 'nested' | 'disabled'>;
-    selectedNodes: TreeNodeId[];
-    parentNode?: ParentNode;
-}): string[];

package/dist/esm/helpers.d.ts

@@ -1,11 +0,0 @@
-import { ParentNode, TreeNodeId, TreeNodeProps } from './types';
-export declare function checkNestedNodesSelection(nodes: TreeNodeProps[], selectedKeys: TreeNodeId[]): {
-    someSelected: boolean;
-    allSelected: boolean;
-};
-export declare function findAllExpandedChildNodeIds(nodes: TreeNodeProps[], expandedNodes: TreeNodeId[]): string[];
-export declare function lookupTreeForSelectedNodes({ node, selectedNodes, parentNode, }: {
-    node: Pick<TreeNodeProps, 'id' | 'nested' | 'disabled'>;
-    selectedNodes: TreeNodeId[];
-    parentNode?: ParentNode;
-}): string[];