a2bei4-utils 1.0.3 → 1.0.5

package/dist/a2bei4.utils.umd.js

@@ -803,133 +803,222 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
         return new Date(v1 + Math.floor(Math.random() * (v2 - v1 + 1)));
     }
 
+    //#region   持续时间相关
+
+    /**
+     * 时间持续对象（完整版本，包含年月日时分秒毫秒）
+     * @typedef {Object} DurationObject
+     * @property {number} years - 年数
+     * @property {number} months - 月数（0-11）
+     * @property {number} days - 天数（0-29，取决于 monthDays）
+     * @property {number} hours - 小时数（0-23）
+     * @property {number} minutes - 分钟数（0-59）
+     * @property {number} seconds - 秒数（0-59）
+     * @property {number} milliseconds - 毫秒数（0-999）
+     */
+
     /**
-     * 计算两个时间之间的剩余/已过时长（天-时-分-秒），返回带补零的展示对象。
+     * 时间持续对象（最大单位为天）
+     * @typedef {Object} DurationMaxDayObject
+     * @property {number} days - 天数
+     * @property {number} hours - 小时数（0-23）
+     * @property {number} minutes - 分钟数（0-59）
+     * @property {number} seconds - 秒数（0-59）
+     * @property {number} milliseconds - 毫秒数（0-999）
+     */
+
+    /**
+     * 时间持续对象（最大单位为小时）
+     * @typedef {Object} DurationMaxHourObject
+     * @property {number} hours - 小时数
+     * @property {number} minutes - 分钟数（0-59）
+     * @property {number} seconds - 秒数（0-59）
+     * @property {number} milliseconds - 毫秒数（0-999）
+     */
+
+    /**
+     * 将毫秒转换为时间持续对象。
      *
-     * @param {string|number|Date} originalTime - 原始时间（可转 Date 的任意值）
-     * @param {Date} [currentTime=new Date()] - 基准时间，默认当前
-     * @returns {{days:number,hours:string,minutes:string,seconds:string}}
+     * @param {number} milliseconds - 毫秒数（非负整数）
+     * @param {Object} [options] - 选项对象。
+     * @param {number} [options.yearDays=365] - 一年的天数。
+     * @param {number} [options.monthDays=30] - 一月的天数。
+     * @returns {DurationObject} 时间持续对象
+     * @throws {TypeError} 当 milliseconds 不是有效数字
+     * @throws {RangeError} 当 milliseconds 为负数
+     * @throws {RangeError} 当 yearDays 或 monthDays 不是正整数
+     *
+     * @example
+     * // 基本用法
+     * millisecond2Duration(42070000500);
+     * // 返回: { years: 1, months: 4, days: 1, hours: 22, minutes: 6, seconds: 40, milliseconds: 500 }
      */
-    function calcTimeDifference(originalTime, currentTime = new Date()) {
-        // 计算时间差（毫秒）
-        const diffMs = currentTime - new Date(originalTime);
-
-        // 转换为天、小时、分钟、秒
-        const diffSeconds = Math.floor(diffMs / 1000);
-        const days = Math.floor(diffSeconds / (3600 * 24));
-        const hours = Math.floor((diffSeconds % (3600 * 24)) / 3600);
-        const minutes = Math.floor((diffSeconds % 3600) / 60);
+    function millisecond2Duration(milliseconds, options = { yearDays: 365, monthDays: 30 }) {
+        // 参数验证
+        if (typeof milliseconds !== "number" || isNaN(milliseconds)) {
+            throw new TypeError("milliseconds must be a valid number");
+        }
+        if (milliseconds < 0) {
+            throw new RangeError("milliseconds must be a non-negative number");
+        }
+
+        // 默认选项
+        const { yearDays = 365, monthDays = 30 } = options;
+
+        // 选项验证
+        if (!Number.isInteger(yearDays) || yearDays <= 0) {
+            throw new RangeError("yearDays must be a positive integer");
+        }
+        if (!Number.isInteger(monthDays) || monthDays <= 0) {
+            throw new RangeError("monthDays must be a positive integer");
+        }
+
+        const totalMilliseconds = Math.floor(milliseconds);
+        const ms = totalMilliseconds % 1000;
+        const diffSeconds = Math.floor(totalMilliseconds / 1000);
+
         const seconds = diffSeconds % 60;
+        const minutes = Math.floor(diffSeconds / 60) % 60;
+        const hours = Math.floor(diffSeconds / 3600) % 24;
 
-        const padZero = (num) => String(num).padStart(2, "0");
+        // 计算年、月、日
+        const totalDays = Math.floor(diffSeconds / 3600 / 24);
+        const years = Math.floor(totalDays / yearDays);
+        const remainingDays = totalDays % yearDays;
+        const months = Math.floor(remainingDays / monthDays);
+        const days = remainingDays % monthDays;
 
-        return {
-            days,
-            hours: padZero(hours),
-            minutes: padZero(minutes),
-            seconds: padZero(seconds)
-        };
+        return { years, months, days, hours, minutes, seconds, milliseconds: ms };
     }
 
     /**
-     * 将总秒数格式化成人类可读的时间段文本。
-     * 固定进制：1 年=365 天，1 月=30 天。
-     *
-     * @param {number} totalSeconds - 非负总秒数
-     * @param {object} [options] - 格式化选项
-     * @param {Partial<{year:string,month:string,day:string,hour:string,minute:string,second:string}>} [options.labels] - 各单位的自定义文本
-     * @param {('year'|'month'|'day'|'hour'|'minute'|'second')} [options.maxUnit] - 最大输出单位
-     * @param {('year'|'month'|'day'|'hour'|'minute'|'second')} [options.minUnit] - 最小输出单位
-     * @param {boolean} [options.showZero] - 是否强制显示 0 秒
-     * @returns {string} 拼接后的时长文本，如“1天 02小时 30分钟”
-     * @throws {TypeError} 当 totalSeconds 为非数字或负数时抛出
+     * 将毫秒转换为时间持续对象（最大单位为天）。
+     * @param {number} milliseconds - 毫秒数（非负整数）
+     * @returns {DurationMaxDayObject} 包含天、小时、分钟、秒、毫秒的时间持续对象
+     * @throws {TypeError} 当 milliseconds 不是有效数字时抛出
+     * @throws {RangeError} 当 milliseconds 为负数时抛出
+     * @example
+     * // 返回 { days: 486, hours: 22, minutes: 6, seconds: 40, milliseconds: 500 }
+     * millisecond2DurationMaxDay(42070000500);
      */
-    function formatDuration(totalSeconds, options = {}) {
-        if (typeof totalSeconds !== "number" || totalSeconds < 0 || !isFinite(totalSeconds)) {
-            throw new TypeError("totalSeconds 必须是非负数字");
+    function millisecond2DurationMaxDay(milliseconds) {
+        if (typeof milliseconds !== "number" || isNaN(milliseconds)) {
+            throw new TypeError("milliseconds must be a valid number");
+        }
+        if (milliseconds < 0) {
+            throw new RangeError("milliseconds must be a non-negative number");
         }
 
-        // 1. 默认中文单位
-        const DEFAULT_LABELS = {
-            year: "年",
-            month: "月",
-            day: "天",
-            hour: "小时",
-            minute: "分钟",
-            second: "秒"
-        };
+        const totalMilliseconds = Math.floor(milliseconds);
+        const ms = totalMilliseconds % 1000;
+        const diffSeconds = Math.floor(totalMilliseconds / 1000);
 
-        // 2. 固定进制表（秒）
-        const UNIT_TABLE = [
-            { key: "year", seconds: 365 * 24 * 3600 },
-            { key: "month", seconds: 30 * 24 * 3600 },
-            { key: "day", seconds: 24 * 3600 },
-            { key: "hour", seconds: 3600 },
-            { key: "minute", seconds: 60 },
-            { key: "second", seconds: 1 }
-        ];
-
-        // 3. 合并用户自定义文本
-        const labels = Object.assign({}, DEFAULT_LABELS, options.labels);
-
-        // 4. 根据 maxUnit / minUnit 截取
-        let start = 0,
-            end = UNIT_TABLE.length;
-        if (options.maxUnit) {
-            const idx = UNIT_TABLE.findIndex((u) => u.key === options.maxUnit);
-            if (idx !== -1) start = idx;
-        }
-        if (options.minUnit) {
-            const idx = UNIT_TABLE.findIndex((u) => u.key === options.minUnit);
-            if (idx !== -1) end = idx + 1;
-        }
-        const units = UNIT_TABLE.slice(start, end);
-        if (!units.length) units.push(UNIT_TABLE[UNIT_TABLE.length - 1]); // 保底秒
-
-        // 5. 逐级计算
-        let rest = Math.floor(totalSeconds);
-        const parts = [];
-
-        for (const { key, seconds } of units) {
-            const val = Math.floor(rest / seconds);
-            rest %= seconds;
-
-            const shouldShow = val > 0 || (options.showZero && key === "second");
-            if (shouldShow || (parts.length === 0 && rest === 0)) {
-                parts.push(`${val}${labels[key]}`);
-            }
-        }
+        const seconds = diffSeconds % 60;
+        const minutes = Math.floor(diffSeconds / 60) % 60;
+        const hours = Math.floor(diffSeconds / 3600) % 24;
+        const days = Math.floor(diffSeconds / 3600 / 24);
+
+        return { days, hours, minutes, seconds, milliseconds: ms };
+    }
 
-        // 6. 兜底
-        if (parts.length === 0) {
-            parts.push(`0${labels[units[units.length - 1].key]}`);
+    /**
+     * 将毫秒转换为时间持续对象（最大单位为小时）。
+     * @param {number} milliseconds - 毫秒数（非负整数）
+     * @returns {DurationMaxHourObject} 包含小时、分钟、秒、毫秒的时间持续对象
+     * @throws {TypeError} 当 milliseconds 不是有效数字时抛出
+     * @throws {RangeError} 当 milliseconds 为负数时抛出
+     * @example
+     * // 返回 { hours: 11686, minutes: 6, seconds: 40, milliseconds: 500 }
+     * millisecond2DurationMaxHour(42070000500);
+     */
+    function millisecond2DurationMaxHour(milliseconds) {
+        if (typeof milliseconds !== "number" || isNaN(milliseconds)) {
+            throw new TypeError("milliseconds must be a valid number");
         }
+        if (milliseconds < 0) {
+            throw new RangeError("milliseconds must be a non-negative number");
+        }
+
+        const totalMilliseconds = Math.floor(milliseconds);
+        const ms = totalMilliseconds % 1000;
+        const diffSeconds = Math.floor(totalMilliseconds / 1000);
 
-        return parts.join("");
+        const seconds = diffSeconds % 60;
+        const minutes = Math.floor(diffSeconds / 60) % 60;
+        const hours = Math.floor(diffSeconds / 3600);
+
+        return { hours, minutes, seconds, milliseconds: ms };
     }
 
     /**
-     * 快捷调用 {@link formatDuration}，最大单位到“天”。
+     * 将秒转换为时间持续对象。
      *
-     * @param {number} totalSeconds
-     * @param {Omit<Parameters<typeof formatDuration>[1],'maxUnit'>} [options]
-     * @returns {string}
+     * @param {number} seconds - 秒数（非负整数）
+     * @param {Object} [options] - 选项对象。
+     * @param {number} [options.yearDays=365] - 一年的天数。
+     * @param {number} [options.monthDays=30] - 一月的天数。
+     * @returns {DurationObject} 时间持续对象
+     * @throws {TypeError} 当 seconds 不是有效数字
+     * @throws {RangeError} 当 seconds 为负数
+     * @throws {RangeError} 当 yearDays 或 monthDays 不是正整数
+     *
+     * @example
+     * // 基本用法
+     * second2Duration(42070000.5);
+     * // 返回: { years: 1, months: 4, days: 1, hours: 22, minutes: 6, seconds: 40, milliseconds: 500 }
      */
-    function formatDurationMaxDay(totalSeconds, options = {}) {
-        return formatDuration(totalSeconds, { ...options, maxUnit: "day" });
+    function second2Duration(seconds, options = { yearDays: 365, monthDays: 30 }) {
+        if (typeof seconds !== "number" || isNaN(seconds)) {
+            throw new TypeError("seconds must be a valid number");
+        }
+        if (seconds < 0) {
+            throw new RangeError("seconds must be a non-negative number");
+        }
+        return millisecond2Duration(seconds * 1000, options);
     }
 
     /**
-     * 快捷调用 {@link formatDuration}，最大单位到“小时”。
-     *
-     * @param {number} totalSeconds
-     * @param {Omit<Parameters<typeof formatDuration>[1],'maxUnit'>} [options]
-     * @returns {string}
+     * 将秒转换为时间持续对象（最大单位为天）。
+     * @param {number} seconds - 秒数（非负整数）
+     * @returns {DurationMaxDayObject} 包含天、小时、分钟、秒、毫秒的时间持续对象
+     * @throws {TypeError} 当 seconds 不是有效数字时抛出
+     * @throws {RangeError} 当 seconds 为负数时抛出
+     * @example
+     * // 返回 { days: 486, hours: 22, minutes: 6, seconds: 40, milliseconds: 500 }
+     * second2DurationMaxDay(42070000.5);
+     */
+    function second2DurationMaxDay(seconds) {
+        if (typeof seconds !== "number" || isNaN(seconds)) {
+            throw new TypeError("seconds must be a valid number");
+        }
+        if (seconds < 0) {
+            throw new RangeError("seconds must be a non-negative number");
+        }
+        return millisecond2DurationMaxDay(seconds * 1000);
+    }
+
+    /**
+     * 将秒转换为时间持续对象（最大单位为小时）。
+     * @param {number} seconds - 秒数（非负整数）
+     * @returns {DurationMaxHourObject} 包含小时、分钟、秒、毫秒的时间持续对象
+     * @throws {TypeError} 当 seconds 不是有效数字时抛出
+     * @throws {RangeError} 当 seconds 为负数时抛出
+     * @example
+     * // 返回 { hours: 11686, minutes: 6, seconds: 40, milliseconds: 500 }
+     * second2DurationMaxHour(42070000.5);
      */
-    function formatDurationMaxHour(totalSeconds, options = {}) {
-        return formatDuration(totalSeconds, { ...options, maxUnit: "hour" });
+    function second2DurationMaxHour(seconds) {
+        if (typeof seconds !== "number" || isNaN(seconds)) {
+            throw new TypeError("seconds must be a valid number");
+        }
+        if (seconds < 0) {
+            throw new RangeError("seconds must be a non-negative number");
+        }
+        return millisecond2DurationMaxHour(seconds * 1000);
     }
 
+    //#endregion
+
     /**
      * 根据小时数返回对应的时间段名称。
      *
@@ -1384,6 +1473,204 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
         }
     }
 
+    /**
+     * 处理数据库菜单项，生成 UI 菜单树和路由配置。
+     *
+     * @param {Array<Object>} menuItems - 原始菜单项数组，树形结构
+     * @param {Object} [options] - 配置选项
+     * @param {string} [options.idKey='id'] - 数据源 ID 键名
+     * @param {string} [options.codeKey='code'] - 数据源编码键名, 用于拼接路由名称和路由路径
+     * @param {string} [options.labelKey='text'] - 数据源标签键名
+     * @param {string} [options.childrenKey='children'] - 数据源子节点键名
+     * @param {string} [options.extendKey='extend'] - 数据源扩展对象键名
+     * @param {string} [options.menuIdKey='key'] - 输出菜单 ID 键名
+     * @param {string} [options.menuLabelKey='label'] - 输出菜单标签键名
+     * @param {string} [options.menuChildrenKey='children'] - 输出菜单子节点键名
+     * @param {string} [options.menuExtendKey='extend'] - 输出菜单扩展对象键名
+     * @param {string} [options.routeNameKey='name'] - 路由名称键名
+     * @param {string} [options.routePathKey='path'] - 路由路径键名
+     * @param {string} [options.routeMetaKey='meta'] - 路由元数据键名
+     * @param {Function} [options.handleNodeItem] - 节点处理钩子，参数：(nodeSimple) => void
+     * @param {Function} [options.handleMenuItem] - 菜单项处理钩子，参数：(uiMenuItem, nodeSimple) => void
+     * @param {Function} [options.handleRouteItem] - 路由项处理钩子，参数：(routeItem, nodeSimple) => void
+     *
+     * @returns {Object} 处理结果
+     * @returns {Array<Object>} returns.uiMenuItems - UI 菜单树形结构数组
+     * @returns {Array<Object>} returns.routeItems - 扁平化路由配置数组
+     * @returns {Map<string, Object>} returns.nodeMap - 节点 ID 到节点数据的映射表
+     *
+     * @example
+     * const menuItems = [
+     *   { id: '1', code: 'system', text: '系统管理', children: [
+     *     { id: '1-1', code: 'user', text: '用户管理' }
+     *   ]}
+     * ];
+     *
+     * const result = handleDbMenuItems(menuItems, {
+     *   handleRouteItem: (route, node) => {
+     *     route.component = () => import(`./views/${node.code}.vue`);
+     *   }
+     * });
+     *
+     * // result.uiMenuItems: [{ key: '1', label: '系统管理', children: [...] }]
+     * // result.routeItems: [{ name: 'system.user', path: '/system/user', meta: { id: '1-1' } }]
+     * // result.nodeMap: Map { '1' => {...}, '1-1' => {...} }
+     */
+    function handleDbMenuItems(menuItems, options = {}) {
+        // 1. 统一配置项，简化调用
+        const {
+            // 数据源键名
+            idKey = "id",
+            codeKey = "code",
+            labelKey = "text",
+            childrenKey = "children",
+            extendKey = "extend",
+
+            // 输出目标键名
+            menuIdKey = "key",
+            menuLabelKey = "label",
+            menuChildrenKey = "children",
+            menuExtendKey = "extend",
+
+            routeNameKey = "name",
+            routePathKey = "path",
+            routeMetaKey = "meta",
+
+            // 钩子函数
+            handleNodeItem,
+            handleMenuItem,
+            handleRouteItem
+        } = options;
+
+        const uiMenuItems = [];
+        const routeItems = [];
+        const nodeMap = new Map(); // id -> node (纯净的节点数据)
+        const nodePathMap = new Map(); // id -> [{ code, id }] (仅存储路径计算所需的轻量数据)
+
+        /* ---------- 1. 建立索引：扁平化节点 & 构建路径索引 ---------- */
+        // 使用栈进行深度优先遍历，记录路径
+        const stack = [];
+        if (Array.isArray(menuItems)) {
+            menuItems.forEach((n) => stack.push({ node: n, parentPath: [] }));
+        }
+
+        while (stack.length) {
+            const { node, parentPath } = stack.pop();
+            const idValue = node[idKey];
+
+            // 构建当前节点的路径片段
+            const currentPathSegment = { [idKey]: idValue };
+            const fullPath = [...parentPath, currentPathSegment];
+
+            // 存储路径信息用于后续路由生成
+            nodePathMap.set(idValue, fullPath);
+
+            // 创建轻量级的节点对象存入 nodeMap
+            // 注意：这里先创建基础结构，路由信息在第二步补充
+            const nodeSimple = {
+                ...node,
+                [extendKey]: {}, // 初始化扩展对象
+                [childrenKey]: null // 去除原始 children，避免引用污染
+            };
+            nodeMap.set(idValue, nodeSimple);
+
+            // 处理子节点
+            const childrenNodes = node[childrenKey];
+            if (Array.isArray(childrenNodes)) {
+                // 逆序压栈，保持原序
+                for (let i = childrenNodes.length - 1; i >= 0; i--) {
+                    stack.push({ node: childrenNodes[i], parentPath: fullPath });
+                }
+            }
+        }
+
+        /* ---------- 2. 构建树形结构 & 生成路由 ---------- */
+        const buildStack = [];
+        if (Array.isArray(menuItems)) {
+            for (let i = menuItems.length - 1; i >= 0; i--) {
+                buildStack.push({ node: menuItems[i], parentUi: undefined });
+            }
+        }
+
+        while (buildStack.length) {
+            const { node, parentUi } = buildStack.pop();
+            const idValue = node[idKey];
+
+            // 从 Map 中取出之前创建好的节点对象
+            const nodeSimple = nodeMap.get(idValue);
+
+            // 2.1 构建 UI 菜单项
+            const uiMenuItem = {
+                [menuIdKey]: idValue,
+                [menuLabelKey]: node[labelKey],
+                [menuExtendKey]: {} // UI 菜单专用扩展
+            };
+
+            // 处理子节点
+            const childrenNodes = node[childrenKey];
+            const hasChildren = Array.isArray(childrenNodes) && childrenNodes.length > 0;
+
+            if (hasChildren) {
+                // 有子节点 -> 继续压栈，传递当前 uiMenuItem 作为父级
+                for (let i = childrenNodes.length - 1; i >= 0; i--) {
+                    buildStack.push({ node: childrenNodes[i], parentUi: uiMenuItem });
+                }
+            } else {
+                // 2.2 无子节点 -> 生成路由配置
+
+                // 提取 code 和 id 数组
+                const codePaths = [],
+                    keyPaths = [];
+                nodePathMap.get(idValue).forEach((item) => {
+                    const idValue = item[idKey];
+                    const nodeSimple = nodeMap.get(idValue);
+                    keyPaths.push(idValue);
+                    codePaths.push(nodeSimple[codeKey]);
+                });
+
+                const routeName = codePaths.join(".");
+                const routePath = "/" + codePaths.join("/");
+
+                const routeItem = {
+                    [routeNameKey]: routeName,
+                    [routePathKey]: routePath,
+                    [routeMetaKey]: { [idKey]: idValue }
+                };
+
+                // 执行路由钩子
+                if (typeof handleRouteItem === "function") {
+                    handleRouteItem(routeItem, nodeSimple);
+                }
+                routeItems.push(routeItem);
+
+                // 补充扩展信息
+                uiMenuItem[menuExtendKey].routeName = routeName;
+                uiMenuItem[menuExtendKey].keyPaths = keyPaths;
+
+                nodeSimple[extendKey].routeName = routeName;
+                nodeSimple[extendKey].keyPaths = keyPaths;
+            }
+
+            // 2.3 挂载到父级 UI 或根数组
+            if (parentUi) {
+                // 逻辑赋值，确保 children 数组存在
+                (parentUi[menuChildrenKey] || (parentUi[menuChildrenKey] = [])).push(uiMenuItem);
+            } else {
+                if (typeof handleMenuItem === "function") {
+                    handleMenuItem(uiMenuItem, nodeSimple);
+                }
+                uiMenuItems.push(uiMenuItem);
+            }
+
+            // 执行节点钩子
+            if (typeof handleNodeItem === "function") {
+                handleNodeItem(nodeSimple);
+            }
+        }
+
+        return { uiMenuItems, routeItems, nodeMap };
+    }
+
     /**
      * 基于 `setTimeout` 的“间隔循环”定时器。
      * 每次任务执行完成后才计算下一次间隔，避免任务堆积。
@@ -1504,24 +1791,23 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
     }
 
     /**
-     * 在嵌套树中按 `id` 递归查找节点，并返回其指定属性值。
+     * 在嵌套树中按 `id` 递归查找节点
      *
      * @template T extends Record<PropertyKey, any>
      * @param {string | number} id - 要查找的 id
      * @param {T[]} arr - 嵌套树森林
-     * @param {string} [resultKey='name'] - 需要返回的字段
      * @param {string} [idKey='id'] - 主键字段
      * @param {string} [childrenKey='children'] - 子节点字段
-     * @returns {any} 找到的值；未找到返回 `undefined`
+     * @returns {any} 找到的节点；未找到返回 `undefined`
      */
-    const findObjAttrValueById = function findObjAttrValueByIdFn(id, arr, resultKey = "name", idKey = "id", childrenKey = "children") {
+    const findTreeNodeById = function findTreeNodeByIdFn(id, arr, idKey = "id", childrenKey = "children") {
         if (Array.isArray(arr) && arr.length > 0) {
             for (let i = 0; i < arr.length; i++) {
                 const item = arr[i];
                 if (item[idKey]?.toString() === id?.toString()) {
-                    return item[resultKey];
+                    return item;
                 } else if (Array.isArray(item[childrenKey]) && item[childrenKey].length > 0) {
-                    const result = findObjAttrValueByIdFn(id, item[childrenKey], resultKey, idKey, childrenKey);
+                    const result = findTreeNodeByIdFn(id, item[childrenKey], idKey, childrenKey);
                     if (result) {
                         return result;
                     }
@@ -1530,6 +1816,21 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
         }
     };
 
+    /**
+     * 在嵌套树中按 `id` 递归查找节点，并返回其指定属性值。
+     *
+     * @template T extends Record<PropertyKey, any>
+     * @param {string | number} id - 要查找的 id
+     * @param {T[]} arr - 嵌套树森林
+     * @param {string} [resultKey='name'] - 需要返回的字段
+     * @param {string} [idKey='id'] - 主键字段
+     * @param {string} [childrenKey='children'] - 子节点字段
+     * @returns {any} 找到的值；未找到返回 `undefined`
+     */
+    function findObjAttrValueById(id, arr, resultKey = "name", idKey = "id", childrenKey = "children") {
+        return findTreeNodeById(id, arr, idKey, childrenKey)?.[resultKey];
+    }
+
     /**
      * 从服务端返回的已选 id 数组里，提取出
      * 1. 叶子节点
@@ -2016,7 +2317,6 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
     exports.MyId = MyId;
     exports.WebSocketManager = WebSocketManager;
     exports.assignExisting = assignExisting;
-    exports.calcTimeDifference = calcTimeDifference;
     exports.debounce = debounce;
     exports.deepCloneByJSON = deepCloneByJSON;
     exports.downloadByBlob = downloadByBlob;
@@ -2027,10 +2327,8 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
     exports.extractFullyCheckedKeys = extractFullyCheckedKeys;
     exports.fetchOrDownloadByUrl = fetchOrDownloadByUrl;
     exports.findObjAttrValueById = findObjAttrValueById;
+    exports.findTreeNodeById = findTreeNodeById;
     exports.flatCompleteTree2NestedTree = flatCompleteTree2NestedTree;
-    exports.formatDuration = formatDuration;
-    exports.formatDurationMaxDay = formatDurationMaxDay;
-    exports.formatDurationMaxHour = formatDurationMaxHour;
     exports.formatTimeForLocale = formatTimeForLocale;
     exports.getAllSearchParams = getAllSearchParams;
     exports.getDataType = getDataType;
@@ -2039,12 +2337,16 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
     exports.getSearchParam = getSearchParam;
     exports.getTimePeriodName = getTimePeriodName;
     exports.getViewportSize = getViewportSize;
+    exports.handleDbMenuItems = handleDbMenuItems;
     exports.isBlob = isBlob;
     exports.isDate = isDate;
     exports.isFunction = isFunction;
     exports.isNonEmptyString = isNonEmptyString;
     exports.isPlainObject = isPlainObject;
     exports.isPromise = isPromise;
+    exports.millisecond2Duration = millisecond2Duration;
+    exports.millisecond2DurationMaxDay = millisecond2DurationMaxDay;
+    exports.millisecond2DurationMaxHour = millisecond2DurationMaxHour;
     exports.moveItem = moveItem;
     exports.nestedTree2IdMap = nestedTree2IdMap;
     exports.pcmToWavBlob = pcmToWavBlob;
@@ -2054,6 +2356,9 @@ registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProces
     exports.randomHanOrEn = randomHanOrEn;
     exports.randomIntInRange = randomIntInRange;
     exports.readBlobAsText = readBlobAsText;
+    exports.second2Duration = second2Duration;
+    exports.second2DurationMaxDay = second2DurationMaxDay;
+    exports.second2DurationMaxHour = second2DurationMaxHour;
     exports.shuffle = shuffle;
     exports.throttle = throttle;
     exports.toDate = toDate;