zzz-pc-view 0.0.1

package/src/utils/reduce/sumByGroup.d.ts

@@ -0,0 +1,53 @@
+import { KeyMatch, KeyValType } from '../DeclareType';
+/**
+ * 定义一个函数 `verticalSumByGroup`，它接受一个包含以下属性的对象作为参数：
+ * - `list`: 原始数据数组，类型为 `T[]`。
+ * - `dataKeys`: 一个包含三个元素的数组，分别表示基础维度键、值维度键和值键，类型为 `[KeyMatch<T, KeyValType>, KeyMatch<T, KeyValType>, KeyMatch<T, number>]`。
+ * - `groupMap`: 一个记录对象，用于将值维度键映射到分组对象，类型为 `Record<KeyValType, U>`。
+ * - `groupKeys`: 一个包含两个元素的数组，分别表示分组键和小数位数键，类型为 `[KeyMatch<U, KeyValType>, KeyMatch<U, number | undefined | null>?]`。
+ * - `formatter`: 一个可选的格式化函数，用于在计算总和后对数据进行格式化，类型为 `(sumData: T, calcItems: T[]) => void`。
+ * - `enableFourRoundSix`: 一个可选的布尔值，用于指定是否启用四舍六入五成双规则，类型为 `boolean`，默认值为 `true`。
+ * 这个函数通常用于根据指定的分组键对数据进行分组，并计算每个分组的总和。
+ *
+ * @param option - 包含计算总和所需的所有参数的对象。
+ * @returns 一个包含原始数据和计算得到的总和的数组，类型为 `T[]`。
+ *
+ * @example
+    verticalSumByGroup({
+      list: [
+        { dataTime: '2000/01/01 00:00:00', factorId: '1001', value: 8 },
+        { dataTime: '2000/01/01 00:00:00', factorId: '1002', value: 1.9368984375 },
+        { dataTime: '2000/01/02 00:00:00', factorId: '1001', value: 4 },
+        { dataTime: '2000/01/02 00:00:00', factorId: '1002', value: 7.171923084374999 }
+      ],
+      dataKeys: [ 'dataTime', 'factorId', 'value' ],
+      groupMap: {
+        '1001': {
+          id: '1000',
+          digits: 2
+        },
+        '1002': {
+          id: '1000',
+          digits: 2
+        }
+      },
+      groupKeys: ['id', 'digits']
+    })
+ * // 输出
+    [
+      { dataTime: '2000/01/01 00:00:00', factorId: '1001', value: 8 },
+      { dataTime: '2000/01/01 00:00:00', factorId: '1002', value: 1.9368984375 },
+      { dataTime: '2000/01/01 00:00:00', factorId: '1000', value: 9.94 },
+      { dataTime: '2000/01/02 00:00:00', factorId: '1001', value: 4 },
+      { dataTime: '2000/01/02 00:00:00', factorId: '1002', value: 7.171923084374999 },
+      { dataTime: '2000/01/02 00:00:00', factorId: '1000', value: 11.17 },
+    ]
+ */
+export declare const verticalSumByGroup: <T, U>(option: {
+    list: T[];
+    dataKeys: [KeyMatch<T, KeyValType>, KeyMatch<T, KeyValType>, KeyMatch<T, number>];
+    groupMap: Record<KeyValType, U>;
+    groupKeys: [KeyMatch<U, KeyValType>, KeyMatch<U, number | undefined | null>?];
+    formatter?: (sumData: T, calcItems: T[]) => void;
+    enableFourRoundSix?: boolean;
+}) => T[];

package/src/utils/reduce/toGroup.d.ts

@@ -0,0 +1,79 @@
+import { KeyMatch } from '../DeclareType';
+/**
+ * 根据 `U` 和 `K` 的类型，生成一个交集类型。
+ *
+ * @template U - 输入的对象类型。
+ * @template K - 键的类型，可以是单个键、键数组或键元组。
+ * @returns 生成的交集类型。
+ */
+type IntersectionOf<U, K> = K extends [keyof U, PropertyKey] ? {
+    [k in K[1]]: U[K[0]];
+} : K extends keyof U ? {
+    [k in K]: U[K];
+} : K extends [infer FirstKey, ...infer Intermediate] ? IntersectionOf<U, FirstKey> & IntersectionOf<U, Intermediate> : unknown;
+/**
+ * 垂直分组映射响应的类型定义。
+ *
+ * @template T - 输入的对象类型。
+ * @template P - 分组键的类型。
+ * @template U - 映射对象的类型。
+ * @template K - 映射数据键的类型。
+ * @returns 垂直分组映射响应的类型。
+ */
+type VerticalToGroupByMapResponse<T, P extends PropertyKey, U, K> = {
+    [k in P]: T[];
+} & IntersectionOf<U, K>;
+/**
+ * 根据指定的键将数组中的对象垂直分组，并映射到另一个对象。
+ *
+ * @template T - 输入的对象类型。
+ * @template P - 分组键的类型。
+ * @template U - 映射对象的类型。
+ * @template K - 映射数据键的类型。
+ * @param {T[]} list - 要分组的对象数组。
+ * @param {P} groupKey - 用于分组的键。
+ * @param {KeyMatch<T, PropertyKey>} dataGroupKey - 用于匹配分组键的对象键。
+ * @param {Record<PropertyKey, U>} map - 映射对象。
+ * @param {K} mapDataKeys - 映射数据键的数组。
+ * @returns {VerticalToGroupByMapResponse<T, P, U, K>[]} 分组和映射后的对象数组。
+ *
+ * @example
+    verticalByMap(
+      [
+        { factorId: '1001', value: 3},
+        { factorId: '1001', value: 8},
+        { factorId: '1002', value: 2.208140625},
+        { factorId: '1002', value: 2.941640625}
+      ],
+      'list',
+      'factorId',
+      {
+        '1001': {  id: '1001', 'name': 'SO₂', defaultUnit: 'μg/m³' },
+        '1002': {  id: '1002', 'name': 'NO', defaultUnit: 'μg/m³' },
+      },
+      ['id', 'name', ['defaultUnit', 'unit']] as const
+    )
+ * // 输出
+    [
+      {
+        id: '1001',
+        name: 'SO₂',
+        unit: 'μg/m³',
+        list: [
+          { factorId: '1001', value: 3},
+          { factorId: '1001', value: 8}
+        ]
+      },
+      {
+        id: '1002',
+        name: 'NO',
+        unit: 'μg/m³',
+        list: [
+          { factorId: '1002', value: 2.208140625},
+          { factorId: '1002', value: 2.941640625}
+        ]
+      }
+    ]
+ */
+export declare const verticalByMap: <T, P extends PropertyKey, U, K extends ([keyof U, PropertyKey] | keyof U)[]>(list: T[], groupKey: P, dataGroupKey: KeyMatch<T, PropertyKey>, map: Record<PropertyKey, U>, mapDataKeys: K) => VerticalToGroupByMapResponse<T, P, U, K>[];
+export {};

package/src/utils/reduce/tree.d.ts

@@ -0,0 +1,570 @@
+import { KeyMatch, KeyValType } from '../DeclareType';
+/**
+ * 定义树节点的接口
+ * @template T 树节点中数据的类型
+ */
+interface TreeNode<T> {
+    id: KeyValType;
+    name: string;
+    parentId: KeyValType | undefined | null;
+    isLeaf: boolean;
+    children?: this[];
+    data: T;
+    [K: PropertyKey]: any;
+}
+/**
+ * 将一个扁平的列表转换为树形结构
+ * @template T 列表中元素的类型
+ * @param {Object} option - 转换选项
+ * @param {T[]} option.list - 要转换的列表
+ * @param {KeyMatch<T, KeyValType>} option.idKey - 用于获取元素唯一标识的键匹配函数
+ * @param {KeyMatch<T, string>} option.nameKey - 用于获取元素名称的键匹配函数
+ * @param {KeyMatch<T, KeyValType | null | undefined>} option.parentKey - 用于获取元素父节点唯一标识的键匹配函数
+ * @param {KeyMatch<T, boolean | undefined>} [option.leafKey] - 用于判断元素是否为叶子节点的键匹配函数，可选
+ * @param {KeyMatch<T, number>} [option.sortKey] - 用于排序元素的键匹配函数，可选
+ * @param {(treeNode: TreeNode<T>, data: T, parentTreeNode?: TreeNode<T>, parentData?: T) => void} [option.formatter] - 用于格式化树节点的函数，可选
+ * @returns {TreeNode<T>[]} 转换后的树形结构
+ *
+ * @example
+    crate({
+      list: [
+        {
+          id: '1-1-1',
+          name: '1-1-1',
+          parentId: '1-1',
+          sortNo: 3,
+          isLeaf: true,
+        },
+        {
+          id: '1-1-2',
+          name: '1-1-2',
+          parentId: '1-1',
+          sortNo: 2,
+          isLeaf: true,
+        },
+        {
+          id: '2',
+          name: '2',
+          sortNo: 2,
+          isLeaf: false,
+        },
+        {
+          id: '2-1',
+          name: '2-1',
+          parentId: '2',
+          sortNo: 2,
+          isLeaf: false,
+        },
+        {
+          id: '3',
+          name: '3',
+          sortNo: 3,
+          isLeaf: true,
+        },
+        {
+          id: '1',
+          name: '1',
+          sortNo: 1,
+          isLeaf: false,
+        },
+        {
+          id: '1-1',
+          name: '1-1',
+          parentId: '1',
+          sortNo: 1,
+          isLeaf: false,
+        },
+      ],
+      idKey: 'id',
+      nameKey: 'name',
+      parentKey: 'parentId',
+      sortKey: 'sortNo',
+      leafKey: 'isLeaf',
+      formatter: (node, data, parentNode) => {
+        node.path = `${parentNode?.path || ''}/${node.id}`
+      },
+    })
+
+    // 输出：
+    [
+      {
+        "id": "1",
+        "name": "1",
+        "data": {
+          "id": "1",
+          "name": "1",
+          "sortNo": 1,
+          "isLeaf": false
+        },
+        "isLeaf": false,
+        "children": [
+          {
+            "id": "1-1",
+            "name": "1-1",
+            "parentId": "1",
+            "data": {
+              "id": "1-1",
+              "name": "1-1",
+              "parentId": "1",
+              "sortNo": 1,
+              "isLeaf": false
+            },
+            "isLeaf": false,
+            "children": [
+              {
+                "id": "1-1-2",
+                "name": "1-1-2",
+                "parentId": "1-1",
+                "data": {
+                  "id": "1-1-2",
+                  "name": "1-1-2",
+                  "parentId": "1-1",
+                  "sortNo": 2,
+                  "isLeaf": true
+                },
+                "isLeaf": true,
+                "path": "/1/1-1/1-1-2"
+              },
+              {
+                "id": "1-1-1",
+                "name": "1-1-1",
+                "parentId": "1-1",
+                "data": {
+                  "id": "1-1-1",
+                  "name": "1-1-1",
+                  "parentId": "1-1",
+                  "sortNo": 3,
+                  "isLeaf": true
+                },
+                "isLeaf": true,
+                "path": "/1/1-1/1-1-1"
+              }
+            ],
+            "path": "/1/1-1"
+          }
+        ],
+        "path": "/1"
+      },
+      {
+        "id": "3",
+        "name": "3",
+        "data": {
+          "id": "3",
+          "name": "3",
+          "sortNo": 3,
+          "isLeaf": true
+        },
+        "isLeaf": true,
+        "path": "/3"
+      }
+    ]
+ */
+export declare const create: <T>(option: {
+    list: T[];
+    idKey: KeyMatch<T, KeyValType>;
+    nameKey: KeyMatch<T, string>;
+    parentKey: KeyMatch<T, KeyValType | null | undefined>;
+    leafKey?: KeyMatch<T, boolean | undefined>;
+    sortKey?: KeyMatch<T, number>;
+    formatter?: (treeNode: TreeNode<T>, data: T, parentTreeNode?: TreeNode<T>, parentData?: T) => void;
+}) => TreeNode<T>[];
+/**
+ * 根据指定的主键、父键和子键创建树形结构。
+ * @template T - 树节点的数据类型。
+ * @param {T[]} list - 包含树节点的数组。
+ * @param {KeyMatch<T, PropertyKey>} primaryKey - 用于获取节点唯一标识的键匹配函数。
+ * @param {KeyMatch<T, PropertyKey | undefined | null>} parentIdKey - 用于获取节点父节点唯一标识的键匹配函数。
+ * @param {KeyMatch<T, undefined | T[]>} childrenKey - 用于获取节点子节点的键匹配函数。
+ * @param {KeyMatch<T, undefined | number>} [sortKey] - 用于排序节点的键匹配函数。
+ * @returns {T[]} 返回创建的树形结构的根节点数组。
+ */
+export declare const createBySelf: <T>(list: T[], primaryKey: KeyMatch<T, PropertyKey>, parentIdKey: KeyMatch<T, undefined | null | PropertyKey>, childrenKey: KeyMatch<T, undefined | T[]>, sortKey?: KeyMatch<T, undefined | number>) => T[];
+/**
+ * 对树形结构的节点进行排序。
+ * @template T 树节点的数据类型。
+ * @param {T[]} nodes 要排序的节点列表。
+ * @param {KeyMatch<T, undefined | T[]>} childrenKey 用于获取节点子节点的键匹配函数。
+ * @param {KeyMatch<T, undefined | number>} sortKey 用于排序的键匹配函数。
+ * @returns {T[]} 返回排序后的节点列表。
+ *
+ * @example
+    const nodes = [
+      {
+        id: '1',
+        children: [
+          { id: '1-1', sortNo: 2 },
+          { id: '1-2', sortNo: 1 }
+        ]
+      },
+      {
+        id: '2',
+        children: [
+          { id: '2-1', sortNo: 3 },
+          { id: '2-2', sortNo: 4 }
+        ]
+      }
+    ]
+    sortTree(nodes, 'children', 'sortNo')
+ * // 输出
+    [
+      {
+        id: '1',
+        children: [
+          { id: '1-2', sortNo: 1 },
+          { id: '1-1', sortNo: 2 }
+        ]
+      },
+      {
+        id: '2',
+        children: [
+          { id: '2-1', sortNo: 3 },
+          { id: '2-2', sortNo: 4 }
+        ]
+      }
+    ]
+ */
+export declare const sortTree: <T>(nodes: T[], childrenKey: KeyMatch<T, undefined | T[]>, sortKey: KeyMatch<T, undefined | number>) => T[];
+/**
+ * 将嵌套的树形结构数据展平为一维数组。
+ * @template T 树节点的数据类型。
+ * @param {T[]} list 包含树节点的数组。
+ * @param {KeyMatch<T, T[] | undefined>} childrenKey 用于获取节点子节点的键匹配函数。
+ * @returns {T[]} 返回展平后的一维数组。
+ *
+ * @example
+    toFlat(
+      [
+        {
+          id: '1',
+          name: 'Node 1',
+          children: [
+            {
+              id: '1-1',
+              name: 'Node 1-1',
+              children: [
+                { id: '1-1-1', name: 'Node 1-1-1' },
+                { id: '1-1-2', name: 'Node 1-1-2' },
+              ],
+            },
+            {
+              id: '1-2',
+              name: 'Node 1-2',
+            },
+          ],
+        },
+        {
+          id: '2',
+          name: 'Node 2',
+          children: [
+            { id: '2-1', name: 'Node 2-1' },
+            { id: '2-2', name: 'Node 2-2' },
+          ],
+        },
+      ],
+      'children'
+    )
+
+    // 输出：
+    [
+      {
+        "id": "1",
+        "name": "Node 1",
+        "children": [
+          {
+            "id": "1-1",
+            "name": "Node 1-1",
+            "children": [
+              { "id": "1-1-1", "name": "Node 1-1-1" },
+              { "id": "1-1-2", "name": "Node 1-1-2" }
+            ]
+          },
+          { "id": "1-2", "name": "Node 1-2" }
+        ]
+      },
+      {
+        "id": "1-1",
+        "name": "Node 1-1",
+        "children": [
+          { "id": "1-1-1", "name": "Node 1-1-1" },
+          { "id": "1-1-2", "name": "Node 1-1-2" }
+        ]
+      },
+      { "id": "1-1-1", "name": "Node 1-1-1" },
+      { "id": "1-1-2", "name": "Node 1-1-2" },
+      { "id": "1-2", "name": "Node 1-2" },
+      {
+        "id": "2",
+        "name": "Node 2",
+        "children": [
+          { "id": "2-1", "name": "Node 2-1" },
+          { "id": "2-2", "name": "Node 2-2" }
+        ]
+      },
+      { "id": "2-1", "name": "Node 2-1" },
+      { "id": "2-2", "name": "Node 2-2" }
+    ]
+ */
+export declare const toFlat: <T>(list: T[], childrenKey: KeyMatch<T, T[] | undefined>) => T[];
+/**
+ * 在给定的列表中查找第一个叶子节点。
+ * @template T 树节点的数据类型。
+ * @param {T[]} list 要搜索的节点列表。
+ * @param {KeyMatch<T, T[] | undefined>} childrenKey 用于获取节点子节点的键匹配函数。
+ * @param {KeyMatch<T, boolean | undefined> | ((node: T) => boolean)} [leafNodeFilter] 用于判断节点是否为叶子节点的键匹配函数或自定义函数，可选。
+ * @returns {T | null} 返回找到的第一个叶子节点，如果没有找到则返回 null。
+ *
+ * @example
+    findLeafNode(
+      [
+        {
+          id: '1',
+          isLeaf: false,
+          children: [
+            {
+              id: '1-1',
+              isLeaf: false,
+              children: [
+                {
+                  id: '1-1-1',
+                  isLeaf: true
+                }
+              ]
+            }
+          ]
+        },
+        {
+          id: '2',
+          isLeaf: false,
+          children: [
+            {
+              id: '2-1',
+              isLeaf: true
+            }
+          ]
+        },
+        {
+          id: '3',
+          isLeaf: false
+        }
+      ],
+      'children'
+    )
+ * // 输出 { id: '1-1-1', isLeaf: true }
+
+ * @example
+    findLeafNode(
+      [
+        {
+          id: '1',
+          isLeaf: false,
+          children: [
+            {
+              id: '1-1',
+              isLeaf: false,
+              children: [
+                {
+                  id: '1-1-1',
+                  isLeaf: true
+                }
+              ]
+            }
+          ]
+        },
+        {
+          id: '2',
+          isLeaf: false,
+          children: [
+            {
+              id: '2-1',
+              isLeaf: true
+            }
+          ]
+        },
+        {
+          id: '3',
+          isLeaf: false
+        }
+      ],
+      'children',
+      'isLeaf'
+    )
+ * // 输出 { id: '1-1-1', isLeaf: true }
+
+ * @example
+    findLeafNode(
+      [
+        {
+          id: '1',
+          isLeaf: false,
+          children: [
+            {
+              id: '1-1',
+              isLeaf: false,
+              children: [
+                {
+                  id: '1-1-1',
+                  isLeaf: true
+                }
+              ]
+            }
+          ]
+        },
+        {
+          id: '2',
+          isLeaf: false,
+          children: [
+            {
+              id: '2-1',
+              isLeaf: true
+            }
+          ]
+        },
+        {
+          id: '3',
+          isLeaf: false
+        }
+      ],
+      'children',
+      (node) => node.id === '2-1'
+    )
+ * // 输出 { id: '2-1', isLeaf: true }
+ */
+export declare const findLeafNode: <T>(list: T[], childrenKey: KeyMatch<T, T[] | undefined>, leafNodeFilter?: KeyMatch<T, boolean | undefined> | ((node: T) => boolean)) => T | null;
+/**
+ * 在给定的列表中查找所有叶子节点。
+ * @template T 树节点的数据类型。
+ * @param {T[]} list 要搜索的节点列表。
+ * @param {KeyMatch<T, T[] | undefined>} childrenKey 用于获取节点子节点的键匹配函数。
+ * @param {KeyMatch<T, boolean | undefined> | ((node: T) => boolean)} [leafNodeFilter] 用于判断节点是否为叶子节点的键匹配函数或自定义函数，可选。
+ * @returns {T[]} 返回找到的所有叶子节点的数组。
+ *
+ * @example
+    findAllLeafNodes(
+      [
+        {
+          id: '1',
+          isLeaf: false,
+          children: [
+            {
+              id: '1-1',
+              isLeaf: false,
+              children: [
+                {
+                  id: '1-1-1',
+                  isLeaf: true
+                }
+              ]
+            }
+          ]
+        },
+        {
+          id: '2',
+          isLeaf: false,
+          children: [
+            {
+              id: '2-1',
+              isLeaf: true
+            }
+          ]
+        },
+        {
+          id: '3',
+          isLeaf: false
+        }
+      ],
+      'children'
+    )
+ * // 输出
+    [
+      { id: '1-1-1', isLeaf: true },
+      { id: '2-1', isLeaf: true },
+      { id: '3', isLeaf: false }
+    ]
+
+ * @example
+    findAllLeafNodes(
+      [
+        {
+          id: '1',
+          isLeaf: false,
+          children: [
+            {
+              id: '1-1',
+              isLeaf: false,
+              children: [
+                {
+                  id: '1-1-1',
+                  isLeaf: true
+                }
+              ]
+            }
+          ]
+        },
+        {
+          id: '2',
+          isLeaf: false,
+          children: [
+            {
+              id: '2-1',
+              isLeaf: true
+            }
+          ]
+        },
+        {
+          id: '3',
+          isLeaf: false
+        }
+      ],
+      'children',
+      'isLeaf'
+    )
+ * // 输出
+    [
+      { id: '1-1-1', isLeaf: true },
+      { id: '2-1', isLeaf: true }
+    ]
+
+ * @example
+    findAllLeafNodes(
+      [
+        {
+          id: '1',
+          isLeaf: false,
+          children: [
+            {
+              id: '1-1',
+              isLeaf: false,
+              children: [
+                {
+                  id: '1-1-1',
+                  isLeaf: true
+                }
+              ]
+            }
+          ]
+        },
+        {
+          id: '2',
+          isLeaf: false,
+          children: [
+            {
+              id: '2-1',
+              isLeaf: true
+            }
+          ]
+        },
+        {
+          id: '3',
+          isLeaf: false
+        }
+      ],
+      'children',
+      (node) => node.id === '1-1-1'
+    )
+ * // 输出
+    [
+      { id: '1-1-1', isLeaf: true }
+    ]
+ */
+export declare const findAllLeafNodes: <T>(list: T[], childrenKey: KeyMatch<T, T[] | undefined>, leafNodeFilter?: KeyMatch<T, boolean | undefined> | ((node: T) => boolean)) => T[];
+export {};