@d-matrix/utils 1.27.1 → 1.28.1

package/dist/algorithm/binary.d.ts

@@ -1,8 +1,8 @@
-/**
- * 二分查找target 在arr中的索引
- * @param arr
- * @param target
- * @param forward true 向前取值，false
- * @param backward true 向后取值，false
- */
-export declare const binarySearchIndex: <T>(arr: T[], target: T, forward?: boolean, backward?: boolean) => number;
+/**
+ * 二分查找target 在arr中的索引
+ * @param arr
+ * @param target
+ * @param forward true 向前取值，false
+ * @param backward true 向后取值，false
+ */
+export declare const binarySearchIndex: <T>(arr: T[], target: T, forward?: boolean, backward?: boolean) => number;

package/dist/algorithm/binary.js

@@ -1,38 +1,38 @@
-// 二分
-/**
- * 二分查找target 在arr中的索引
- * @param arr
- * @param target
- * @param forward true 向前取值，false
- * @param backward true 向后取值，false
- */
-export const binarySearchIndex = (arr, target, forward = false, backward = false) => {
-    let low = 0;
-    let high = arr.length - 1;
-    let result = -1; // 如果找不到，返回-1
-    while (low <= high) {
-        const mid = Math.floor((low + high) / 2);
-        if (arr[mid] === target) {
-            return mid; // 找到目标值，返回索引
-        }
-        else if (arr[mid] < target) {
-            low = mid + 1;
-        }
-        else {
-            high = mid - 1;
-        }
-        if (forward) {
-            // 向前取值
-            if (arr[mid] < target) {
-                result = mid;
-            }
-        }
-        else if (backward) {
-            // 向后取值
-            if (arr[mid] > target) {
-                result = mid;
-            }
-        }
-    }
-    return result;
-};
+// 二分
+/**
+ * 二分查找target 在arr中的索引
+ * @param arr
+ * @param target
+ * @param forward true 向前取值，false
+ * @param backward true 向后取值，false
+ */
+export const binarySearchIndex = (arr, target, forward = false, backward = false) => {
+    let low = 0;
+    let high = arr.length - 1;
+    let result = -1; // 如果找不到，返回-1
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        if (arr[mid] === target) {
+            return mid; // 找到目标值，返回索引
+        }
+        else if (arr[mid] < target) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+        if (forward) {
+            // 向前取值
+            if (arr[mid] < target) {
+                result = mid;
+            }
+        }
+        else if (backward) {
+            // 向后取值
+            if (arr[mid] > target) {
+                result = mid;
+            }
+        }
+    }
+    return result;
+};

package/dist/algorithm/index.d.ts

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

package/dist/algorithm/index.js

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

package/dist/algorithm/tree.d.ts

@@ -1,34 +1,34 @@
-/**
- * 计算指定层级的节点数量
- * @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;
-/**
- * 查找节点路径
- * @param tree
- * @param func 符合条件的节点函数,返回 boolean
- * @param childrenKey 子节点key
- * @returns 节点路径
- */
-export declare function findPath<T extends Record<string, any>>(tree: T[], func: (node: T) => boolean, childrenKey?: string): T[] | null;
-export declare function flatten<T extends Record<string, any>>(tree: T[], childrenKey?: string): Record<string, any>[];
+/**
+ * 计算指定层级的节点数量
+ * @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;
+/**
+ * 查找节点路径
+ * @param tree
+ * @param func 符合条件的节点函数,返回 boolean
+ * @param childrenKey 子节点key
+ * @returns 节点路径
+ */
+export declare function findPath<T extends Record<string, any>>(tree: T[], func: (node: T) => boolean, childrenKey?: string): T[] | null;
+export declare function flatten<T extends Record<string, any>>(tree: T[], childrenKey?: string): Record<string, any>[];

package/dist/algorithm/tree.js

@@ -1,124 +1,124 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-/**
- * 计算指定层级的节点数量
- * @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;
-};
-/**
- * 查找节点路径
- * @param tree
- * @param func 符合条件的节点函数,返回 boolean
- * @param childrenKey 子节点key
- * @returns 节点路径
- */
-export function findPath(tree, func, childrenKey = 'children') {
-    const path = [];
-    const list = [...tree];
-    const visitedSet = new Set();
-    while (list.length) {
-        const node = list[0];
-        if (visitedSet.has(node)) {
-            path.pop();
-            list.shift();
-        }
-        else {
-            visitedSet.add(node);
-            Array.isArray(node[childrenKey]) && list.unshift(...node[childrenKey]);
-            path.push(node);
-            if (func(node))
-                return path;
-        }
-    }
-    return null;
-}
-export function flatten(tree, childrenKey = 'children') {
-    const result = [];
-    function traverse(node) {
-        // 将当前节点添加到结果数组
-        const _a = node, _b = childrenKey, __ = _a[_b], nodePropsOmitChildren = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-        result.push(nodePropsOmitChildren);
-        const children = node[childrenKey];
-        // 如果节点有子节点，则递归处理每个子节点
-        if (children && Array.isArray(children) && children.length > 0) {
-            children.forEach((child) => traverse(child));
-        }
-    }
-    // 遍历树的每个根节点
-    tree.forEach((root) => traverse(root));
-    return result;
-}
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * 计算指定层级的节点数量
+ * @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;
+};
+/**
+ * 查找节点路径
+ * @param tree
+ * @param func 符合条件的节点函数,返回 boolean
+ * @param childrenKey 子节点key
+ * @returns 节点路径
+ */
+export function findPath(tree, func, childrenKey = 'children') {
+    const path = [];
+    const list = [...tree];
+    const visitedSet = new Set();
+    while (list.length) {
+        const node = list[0];
+        if (visitedSet.has(node)) {
+            path.pop();
+            list.shift();
+        }
+        else {
+            visitedSet.add(node);
+            Array.isArray(node[childrenKey]) && list.unshift(...node[childrenKey]);
+            path.push(node);
+            if (func(node))
+                return path;
+        }
+    }
+    return null;
+}
+export function flatten(tree, childrenKey = 'children') {
+    const result = [];
+    function traverse(node) {
+        // 将当前节点添加到结果数组
+        const _a = node, _b = childrenKey, __ = _a[_b], nodePropsOmitChildren = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        result.push(nodePropsOmitChildren);
+        const children = node[childrenKey];
+        // 如果节点有子节点，则递归处理每个子节点
+        if (children && Array.isArray(children) && children.length > 0) {
+            children.forEach((child) => traverse(child));
+        }
+    }
+    // 遍历树的每个根节点
+    tree.forEach((root) => traverse(root));
+    return result;
+}

package/dist/array.d.ts

@@ -1,5 +1,46 @@
-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[];
-export declare const getArrayOrUndefined: <T>(array?: T[] | null | undefined) => T[] | undefined;
+/**
+ * 在数组中移动元素的位置（修改原数组）
+ *
+ * @param array - 要操作的数组
+ * @param fromIndex - 要移动元素的起始索引，支持负数（-1表示最后一个元素）
+ * @param toIndex - 目标位置的索引，支持负数（-1表示最后一个位置）
+ * @returns 无返回值，直接修改原数组
+ */
+export declare function moveMutable<T>(array: T[], fromIndex: number, toIndex: number): void;
+/**
+ * 创建一个新数组，将指定位置的元素移动到新位置，不修改原数组
+ * @param array 原始数组
+ * @param fromIndex 要移动元素的当前位置索引
+ * @param toIndex 元素要移动到的目标位置索引
+ * @returns 返回一个新的数组，其中指定元素已移动到新位置
+ */
+export declare function moveImmutable<T>(array: T[], fromIndex: number, toIndex: number): T[];
+/**
+ * 将数组中第一个满足条件的元素移动到数组开头
+ * @param array - 要操作的数组
+ * @param predicate - 判断元素是否满足条件的函数
+ * @returns 新的数组，其中第一个满足条件的元素被移动到开头位置
+ */
+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[];
+/**
+ * 获取数组或undefined
+ *
+ * @param array - 可选的数组参数，可以是任意类型的数组、undefined或null
+ * @returns 如果传入的参数是有效的非空数组则返回该数组，否则返回undefined
+ */
+export declare const getArrayOrUndefined: <T>(array?: T[] | null | undefined) => T[] | undefined;
+/**
+ * 通用序号计算工具：从指定列表中提取「前缀+数字」格式的值，找到未被使用的最小正整数序号
+ * @param list 待检索的列表
+ * @param options 配置项（通用化核心）
+ * @param options.fieldName 要提取的字段名（比如 'groupName'）
+ * @param options.prefix 匹配的前缀（比如 '组合'）
+ * @param options.defaultNo 无可用序号时的默认值（默认1）
+ * @returns 未被使用的最小正整数序号
+ */
+export declare function calcUnusedMinSerialNumber(list: any[], options: {
+    fieldName: string;
+    prefix: string;
+    defaultNo?: number;
+}): number;

package/dist/array.js

@@ -1,37 +1,123 @@
-export function moveMutable(array, fromIndex, toIndex) {
-    const startIndex = fromIndex < 0 ? array.length + fromIndex : fromIndex;
-    if (startIndex >= 0 && startIndex < array.length) {
-        const endIndex = toIndex < 0 ? array.length + toIndex : toIndex;
-        const [item] = array.splice(fromIndex, 1);
-        array.splice(endIndex, 0, item);
-    }
-}
-export function moveImmutable(array, fromIndex, toIndex) {
-    const newArray = [...array];
-    moveMutable(newArray, fromIndex, toIndex);
-    return newArray;
-}
-export function moveToStart(array, predicate) {
-    const index = array.findIndex(predicate);
-    if (index < 0)
-        return array;
-    const newArray = [...array];
-    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);
-};
-export const getArrayOrUndefined = (array) => {
-    if (Array.isArray(array) && array.length > 0)
-        return array;
-};
+/**
+ * 在数组中移动元素的位置（修改原数组）
+ *
+ * @param array - 要操作的数组
+ * @param fromIndex - 要移动元素的起始索引，支持负数（-1表示最后一个元素）
+ * @param toIndex - 目标位置的索引，支持负数（-1表示最后一个位置）
+ * @returns 无返回值，直接修改原数组
+ */
+export function moveMutable(array, fromIndex, toIndex) {
+    // 计算实际的起始索引，支持负数索引
+    const startIndex = fromIndex < 0 ? array.length + fromIndex : fromIndex;
+    // 检查起始索引是否有效
+    if (startIndex >= 0 && startIndex < array.length) {
+        // 计算实际的目标索引，支持负数索引
+        const endIndex = toIndex < 0 ? array.length + toIndex : toIndex;
+        // 执行元素移动：先删除元素，再在新位置插入
+        const [item] = array.splice(fromIndex, 1);
+        array.splice(endIndex, 0, item);
+    }
+}
+/**
+ * 创建一个新数组，将指定位置的元素移动到新位置，不修改原数组
+ * @param array 原始数组
+ * @param fromIndex 要移动元素的当前位置索引
+ * @param toIndex 元素要移动到的目标位置索引
+ * @returns 返回一个新的数组，其中指定元素已移动到新位置
+ */
+export function moveImmutable(array, fromIndex, toIndex) {
+    // 创建原数组的浅拷贝
+    const newArray = [...array];
+    // 在新数组上执行移动操作
+    moveMutable(newArray, fromIndex, toIndex);
+    return newArray;
+}
+/**
+ * 将数组中第一个满足条件的元素移动到数组开头
+ * @param array - 要操作的数组
+ * @param predicate - 判断元素是否满足条件的函数
+ * @returns 新的数组，其中第一个满足条件的元素被移动到开头位置
+ */
+export function moveToStart(array, predicate) {
+    // 查找第一个满足条件的元素索引
+    const index = array.findIndex(predicate);
+    if (index < 0)
+        return array;
+    // 创建新数组并移动元素到开头
+    const newArray = [...array];
+    moveMutable(newArray, index, 0);
+    return newArray;
+}
+/**
+ * 将数组中指定索引的元素移动到指定位置
+ * @param arr 原始数组
+ * @param indexes 需要移动的元素索引数组
+ * @param start 目标插入位置的起始索引
+ * @returns 移动元素后的新数组
+ */
+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);
+};
+/**
+ * 获取数组或undefined
+ *
+ * @param array - 可选的数组参数，可以是任意类型的数组、undefined或null
+ * @returns 如果传入的参数是有效的非空数组则返回该数组，否则返回undefined
+ */
+export const getArrayOrUndefined = (array) => {
+    // 检查参数是否为数组且长度大于0，如果是则返回原数组，否则返回undefined
+    if (Array.isArray(array) && array.length > 0)
+        return array;
+    return undefined;
+};
+/**
+ * 通用序号计算工具：从指定列表中提取「前缀+数字」格式的值，找到未被使用的最小正整数序号
+ * @param list 待检索的列表
+ * @param options 配置项（通用化核心）
+ * @param options.fieldName 要提取的字段名（比如 'groupName'）
+ * @param options.prefix 匹配的前缀（比如 '组合'）
+ * @param options.defaultNo 无可用序号时的默认值（默认1）
+ * @returns 未被使用的最小正整数序号
+ */
+export function calcUnusedMinSerialNumber(list, options) {
+    const { fieldName, prefix, defaultNo = 1 } = options;
+    if (!(list === null || list === void 0 ? void 0 : list.length))
+        return defaultNo;
+    // 获取所有匹配前缀的项目并提取序号
+    const serialNumbers = list
+        .map((item) => item[fieldName])
+        .filter((value) => typeof value === 'string' && value.startsWith(prefix))
+        .map((value) => {
+        const numPart = value.substring(prefix.length);
+        // 如果前缀后没有数字，则认为是序号1（或者根据业务需求处理）
+        if (numPart === '')
+            return 1;
+        const num = parseInt(numPart, 10);
+        return isNaN(num) ? 0 : num;
+    })
+        .filter((num) => num > 0)
+        .sort((a, b) => a - b);
+    // 如果没有匹配项，返回默认值
+    if (serialNumbers.length === 0)
+        return defaultNo;
+    // 找到第一个缺失的正整数
+    for (let i = 0; i < serialNumbers.length; i++) {
+        if (serialNumbers[i] !== i + 1) {
+            return i + 1;
+        }
+    }
+    // 如果序列完整，返回下一个数字
+    return serialNumbers.length + 1;
+}

package/dist/clipboard.d.ts

@@ -1,12 +1,12 @@
-/**
- * 复制图片到剪贴板
- * @param element
- * @returns
- */
-export declare function writeImage(element: HTMLImageElement | null | string): Promise<unknown>;
-/**
- * 复制文本到剪贴板
- * @param text
- * @returns
- */
-export declare function writeText(text: string): Promise<void>;
+/**
+ * 复制图片到剪贴板
+ * @param element
+ * @returns
+ */
+export declare function writeImage(element: HTMLImageElement | null | string): Promise<unknown>;
+/**
+ * 复制文本到剪贴板
+ * @param text
+ * @returns
+ */
+export declare function writeText(text: string): Promise<void>;