@d-matrix/utils 1.22.0 → 1.24.0

package/dist/algorithm/index.d.ts

@@ -0,0 +1 @@
+export * as tree from './tree';

package/dist/algorithm/index.js

@@ -0,0 +1 @@
+export * as tree from './tree';

package/dist/algorithm/tree.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 计算指定层级的节点数量
+ * @param root tree data 对象
+ * @param depth 需要计算节点数量的层级
+ * @param childrenKey 子节点key
+ * @returns 节点数量
+ */
+export declare const nodeCountAtDepth: <T extends Record<string, any>>(root: T, depth: number, childrenKey?: string) => number;
+/**
+ * 找到符合条件的节点
+ * @param tree tree data 数组
+ * @param predicate 对每个节点执行的函数, 如果返回true, 则返回该节点
+ * @param childrenKey 子节点key
+ * @returns 找到的节点
+ */
+export declare const findNode: <T extends Record<string, any>>(tree: T[], predicate: (node: T) => boolean, childrenKey?: string) => T | null;
+/**
+ * 根据子节点查找父节点
+ * @param tree
+ * @param child 子节点
+ * @param indentityKey 节点唯一id字段名称
+ * @param childrenKey 节点的子节点的字段名称
+ * @returns
+ */
+export declare const findParent: <T extends Record<string, any>>(tree: T | undefined, child: T | undefined, indentityKey?: string, childrenKey?: string) => T | null;

package/dist/algorithm/tree.js

@@ -0,0 +1,70 @@
+/**
+ * 计算指定层级的节点数量
+ * @param root tree data 对象
+ * @param depth 需要计算节点数量的层级
+ * @param childrenKey 子节点key
+ * @returns 节点数量
+ */
+export const nodeCountAtDepth = (root, depth, childrenKey = 'children') => {
+    const depths = { 0: 1 };
+    (function recurTree(node, level) {
+        var _a;
+        level++;
+        const children = (_a = node[childrenKey]) !== null && _a !== void 0 ? _a : [];
+        if (depths[level] === undefined) {
+            depths[level] = children.length;
+        }
+        else {
+            depths[level] += children.length;
+        }
+        if (level + 1 > depth)
+            return;
+        for (let i = 0; i < children.length; i++) {
+            recurTree(children[i], level);
+        }
+    })(root, 0);
+    return depths[depth];
+};
+/**
+ * 找到符合条件的节点
+ * @param tree tree data 数组
+ * @param predicate 对每个节点执行的函数, 如果返回true, 则返回该节点
+ * @param childrenKey 子节点key
+ * @returns 找到的节点
+ */
+export const findNode = (tree, predicate, childrenKey = 'children') => {
+    const list = [...tree];
+    for (const node of list) {
+        if (predicate(node))
+            return node;
+        Array.isArray(node[childrenKey]) && list.push(...node[childrenKey]);
+    }
+    return null;
+};
+/**
+ * 根据子节点查找父节点
+ * @param tree
+ * @param child 子节点
+ * @param indentityKey 节点唯一id字段名称
+ * @param childrenKey 节点的子节点的字段名称
+ * @returns
+ */
+export const findParent = (tree, child, indentityKey = 'id', childrenKey = 'children') => {
+    if (tree === undefined || child === undefined) {
+        return null;
+    }
+    const children = tree[childrenKey];
+    if (Array.isArray(children)) {
+        const count = children.length;
+        for (let i = 0; i < count; i++) {
+            if (children[i][indentityKey] === child[indentityKey]) {
+                return tree;
+            }
+            const parent = findParent(children[i], child, indentityKey, childrenKey);
+            if (parent !== null) {
+                return parent;
+            }
+        }
+    }
+    return null;
+};

package/dist/array.d.ts

@@ -1,3 +1,4 @@
 export declare function moveMutable<T>(array: T[], fromIndex: number, toIndex: number): void;
 export declare function moveImmutable<T>(array: T[], fromIndex: number, toIndex: number): T[];
 export declare function moveToStart<T>(array: T[], predicate: (item: T) => boolean): T[];
+export declare const moveMulti: <T extends unknown>(arr: T[], indexes: number[], start: number) => T[];

package/dist/array.js

@@ -19,3 +19,15 @@ export function moveToStart(array, predicate) {
     moveMutable(newArray, index, 0);
     return newArray;
 }
+const removeSymbol = Symbol('Placeholder for removed element');
+export const moveMulti = (arr, indexes, start) => {
+    const cloned = arr.slice();
+    for (let i = 0; i < cloned.length; i++) {
+        if (indexes.includes(i)) {
+            cloned[i] = removeSymbol;
+        }
+    }
+    const els = arr.filter((__, i) => indexes.includes(i));
+    cloned.splice(start, 0, ...els);
+    return cloned.filter((v) => v !== removeSymbol);
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@d-matrix/utils",
   "sideEffects": false,
-  "version": "1.22.0",
+  "version": "1.24.0",
   "description": "A dozen of utils for Front-End Development",
   "main": "dist/index.js",
   "scripts": {

package/readme.md

@@ -354,9 +354,58 @@ type Output = WithRequired<Input, 'b'> // { a: number; b: string }
 
 ### algorithm
 
-- `moveMulti<T extends unknown>(arr: T[], indexes: number[], start: number): T[]`
+- `function nodeCountAtDepth(root: Record<string, any>, depth: number, childrenKey: string = 'children'): number;`
 
-移动多个元素到数组中指定的位置,用法,见[测试用例](tests/algorithm.cy.ts)
+计算指定层级的节点数量
+
+```ts
+const root = {
+  id: 1,
+  children: [
+    { id: 2, children: [{ id: 21 }, { id: 22 }, { id: 23 }] },
+    { id: 3, children: [{ id: 31 }, { id: 32 }, { id: 33 }] },
+  ],
+};
+expect(tree.nodeCountAtDepth(root, 0)).to.be.equal(1);
+expect(tree.nodeCountAtDepth(root, 1)).to.be.equal(2);
+expect(tree.nodeCountAtDepth(root, 2)).to.be.equal(6);
+```
+
+- `const findNode = <T extends Record<string, any>>(tree: T[], predicate: (node: T) => boolean, childrenKey = 'children'): T | null`
+
+找到符合条件的节点
+
+```ts
+const root = {
+  id: 1,
+  children: [
+    { id: 2, children: [{ id: 21 }, { id: 22 }, { id: 23 }] },
+    { id: 3, children: [{ id: 31 }, { id: 32 }, { id: 33 }] },
+  ],
+};
+const actual = tree.findNode([root], (node) => node.id === 3);
+expect(actual).to.be.deep.equal(root.children[1]);
+
+const actual2 = tree.findNode([root], (node) => node.id === 33);
+expect(actual2).to.be.deep.equal(root.children[1].children[2]);
+```
+
+- `tree.findNode(tree, child, indentityKey, childrenKey)`
+
+根据子节点查找父节点
+
+```ts
+const treeData = {
+  code: 1,
+  subs: [
+    { code: 2, subs: [{ code: 21 }, { code: 22 }, { code: 23 }] },
+    { code: 3, subs: [{ code: 31 }, { code: 32 }, { code: 33 }] },
+  ],
+};
+
+const actual = tree.findParent(treeData, treeData.subs[1].subs[2], 'code', 'subs');
+expect(actual).to.be.deep.equal(treeData.subs[1]);
+```
 
 ### file
 
@@ -545,6 +594,10 @@ const newList = array.moveToStart(list, (item) => item.id === 4);
 // [{ id: 4 }, { id: 1 }, { id: 2 }, { id: 3 }, { id: 5 }]
 ```
 
+- `moveMulti<T extends unknown>(arr: T[], indexes: number[], start: number): T[]`
+
+移动多个元素到数组中指定的位置,用法,见[测试用例](tests/algorithm.cy.ts)
+
 ## number
 
 - `randomInt(min: number, max: number): number`
@@ -572,13 +625,13 @@ deep merge Echarts配置，用法见[测试用例](./tests//echarts/echarts.cy.t
 运行全部组件测试
 
 ```bash
-npm run cy:run -- --component
+npm run cy:component:all
 ```
 
 运行单个组件测试
 
 ```bash
-npm run cy:run -- --component --spec tests/date.cy.ts
+npm run cy:component -- tests/date.cy.ts
 ```
 
 运行E2E测试

package/dist/algorithm.d.ts

@@ -1 +0,0 @@
-export declare const moveMulti: <T extends unknown>(arr: T[], indexes: number[], start: number) => T[];

package/dist/algorithm.js

@@ -1,12 +0,0 @@
-const removeSymbol = Symbol('Placeholder for removed element');
-export const moveMulti = (arr, indexes, start) => {
-    const cloned = arr.slice();
-    for (let i = 0; i < cloned.length; i++) {
-        if (indexes.includes(i)) {
-            cloned[i] = removeSymbol;
-        }
-    }
-    const els = arr.filter((__, i) => indexes.includes(i));
-    cloned.splice(start, 0, ...els);
-    return cloned.filter((v) => v !== removeSymbol);
-};