@aiao/utils 0.0.5 → 0.0.7

package/dist/@browser/broadcast-channel-pool.d.ts

@@ -1,18 +1,38 @@
 import { Observable } from 'rxjs';
-export type BroadcastTopic<T> = {
+export interface BroadcastTopic<T = any> {
     message$: Observable<T>;
     emit: (message: T) => void;
-};
+}
 /**
- * BroadcastChannel pool
- * 统一管理所有的 BroadcastChannel
+ * BroadcastChannel 池
+ * 统一管理所有的 BroadcastChannel，支持自动资源清理
  */
 declare class BroadcastChannelPool {
-    #private;
+    private cache;
+    /**
+     * 发送消息到指定频道
+     * @param event 频道名称
+     * @param data 消息数据
+     * @throws 如果频道不存在则抛出错误
+     */
     emit<T = any>(event: string, data: T): void;
-    on<T = any>(event: string): Observable<any>;
+    /**
+     * 订阅指定频道的消息
+     * @param event 频道名称
+     * @returns Observable 消息流
+     */
+    on<T = any>(event: string): Observable<T>;
+    /**
+     * 减少引用计数，当计数为 0 时关闭频道
+     */
+    private decrementRef;
 }
 export declare const pool: BroadcastChannelPool;
+/**
+ * 创建一个 BroadcastChannel 主题
+ * @param event 频道名称
+ * @returns BroadcastTopic 对象，包含消息流和发送方法
+ */
 export declare const createBroadcastTopic: <T = any>(event: string) => BroadcastTopic<T>;
 export {};
 //# sourceMappingURL=broadcast-channel-pool.d.ts.map

package/dist/@browser/broadcast-channel-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"broadcast-channel-pool.d.ts","sourceRoot":"","sources":["../../src/@browser/broadcast-channel-pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,MAAM,CAAC;AAE9C,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACxB,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;CAC5B,CAAC;AASF;;;GAGG;AACH,cAAM,oBAAoB;;IAGxB,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IASpC,EAAE,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM;CAuB1B;AAED,eAAO,MAAM,IAAI,sBAA6B,CAAC;AAE/C,eAAO,MAAM,oBAAoB,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,MAAM,KAAG,cAAc,CAAC,CAAC,CAO7E,CAAC"}
+{"version":3,"file":"broadcast-channel-pool.d.ts","sourceRoot":"","sources":["../../src/@browser/broadcast-channel-pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAyB,MAAM,MAAM,CAAC;AAEzD,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,GAAG;IACrC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACxB,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;CAC5B;AAQD;;;GAGG;AACH,cAAM,oBAAoB;IACxB,OAAO,CAAC,KAAK,CAAiC;IAE9C;;;;;OAKG;IACH,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAQ3C;;;;OAIG;IACH,EAAE,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;IAmCzC;;OAEG;IACH,OAAO,CAAC,YAAY;CASrB;AAED,eAAO,MAAM,IAAI,sBAA6B,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,MAAM,KAAG,cAAc,CAAC,CAAC,CAQ7E,CAAC"}

package/dist/@browser/index.d.ts

@@ -1,5 +1,7 @@
 export * from './broadcast-channel-pool.js';
 export * from './IdleTimer.js';
 export * from './leader-election.js';
+export * from './opfs-detection.js';
 export * from './perform-chunk.js';
+export * from './requestIdleCallbackPolyfill.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/@browser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/@browser/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/@browser/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kCAAkC,CAAC"}

package/dist/@browser/leader-election.d.ts

@@ -1,8 +1,46 @@
+/**
+ * 基于 Web Locks API 的 Leader Election 实现
+ * 用于在多个浏览器 tab/window 之间选举唯一的 leader
+ *
+ * @example
+ * ```ts
+ * const leader = new LeaderElection('my-app');
+ *
+ * const unsubscribe = leader.elect(isLeader => {
+ *   if (isLeader) {
+ *     console.log('当前 tab 成为 leader');
+ *     // 执行只有 leader 才能做的事情，如：
+ *     // - 与服务器建立 WebSocket 连接
+ *     // - 执行定时同步任务
+ *   }
+ * });
+ *
+ * // 同步检查是否为 leader
+ * console.log(leader.isLeader);
+ *
+ * // 取消订阅
+ * unsubscribe();
+ *
+ * // 页面关闭时自动释放，也可手动调用
+ * leader.dispose();
+ * ```
+ */
 export declare class LeaderElection {
     #private;
-    private name;
+    private readonly name;
+    /** 当前是否为 leader */
     get isLeader(): boolean;
+    /**
+     * @param name - 锁名称，相同名称的实例竞争同一个 leader 位置
+     */
     constructor(name: string);
-    leadership(): import('rxjs').Observable<boolean>;
+    /**
+     * 参与 leader 选举
+     * @param callback - 成为 leader 时回调，参数为 `true`
+     * @returns 取消订阅函数
+     */
+    elect(callback: (isLeader: boolean) => void): () => boolean;
+    /** 释放 leader 身份并清理资源 */
+    dispose(): void;
 }
 //# sourceMappingURL=leader-election.d.ts.map

package/dist/@browser/leader-election.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"leader-election.d.ts","sourceRoot":"","sources":["../../src/@browser/leader-election.ts"],"names":[],"mappings":"AAEA,qBAAa,cAAc;;IAWb,OAAO,CAAC,IAAI;IAJxB,IAAI,QAAQ,YAEX;gBAEmB,IAAI,EAAE,MAAM;IAIhC,UAAU;CAUX"}
+{"version":3,"file":"leader-election.d.ts","sourceRoot":"","sources":["../../src/@browser/leader-election.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,cAAc;;IAeb,OAAO,CAAC,QAAQ,CAAC,IAAI;IARjC,mBAAmB;IACnB,IAAI,QAAQ,YAEX;IAED;;OAEG;gBAC0B,IAAI,EAAE,MAAM;IAIzC;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI;IAmB3C,wBAAwB;IACxB,OAAO;CASR"}

package/dist/@browser/opfs-detection.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 检测浏览器是否支持 OPFS (Origin Private File System)
+ * @returns {boolean} 是否支持 OPFS
+ */
+export declare const isOPFSSupported: () => boolean;
+/**
+ * 异步检测 OPFS 是否真正可用
+ * 有些浏览器可能有 API 但实际不可用
+ * @returns {Promise<boolean>} 是否可用
+ */
+export declare const checkOPFSAvailable: () => Promise<boolean>;
+//# sourceMappingURL=opfs-detection.d.ts.map

package/dist/@browser/opfs-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opfs-detection.d.ts","sourceRoot":"","sources":["../../src/@browser/opfs-detection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAO,OAAwE,CAAC;AAE5G;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,QAAa,OAAO,CAAC,OAAO,CAU1D,CAAC"}

package/dist/@browser/requestIdleCallbackPolyfill.d.ts

@@ -0,0 +1,2 @@
+export declare const requestIdleCallbackPolyfill: () => void;
+//# sourceMappingURL=requestIdleCallbackPolyfill.d.ts.map

package/dist/@browser/requestIdleCallbackPolyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestIdleCallbackPolyfill.d.ts","sourceRoot":"","sources":["../../src/@browser/requestIdleCallbackPolyfill.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,YAavC,CAAC"}

package/dist/array/difference.d.ts

@@ -23,9 +23,9 @@
  * @example
  * difference([{ id: 1 }], [{ id: 1 }]);
  * // 返回 [{ id: 1 }]（对象引用不同，视为不同元素）
- * @note 使用 Array.prototype.includes 实现，因此比较使用严格相等 (===)
- * @note 结果数组中不会包含 array1 中重复出现但也存在于 array2 中的元素
- * @warning 不支持对象的深度比较，仅比较引用是否相同
+ * **Note:** 使用 Array.prototype.includes 实现，因此比较使用严格相等 (===)
+ * **Note:** 结果数组中不会包含 array1 中重复出现但也存在于 array2 中的元素
+ * **Warning:** 不支持对象的深度比较，仅比较引用是否相同
  */
 export declare const difference: <T>(array1: T[], array2: T[]) => T[];
 //# sourceMappingURL=difference.d.ts.map

package/dist/array/flatten.d.ts

@@ -17,9 +17,9 @@
  * flatten([1, 2, 3]); // 返回 [1, 2, 3] (无嵌套数组时返回原数组元素)
  * @example
  * flatten([]); // 返回 [] (空输入数组)
- * @note 与flattenDeep的区别：此函数仅扁平化一层，而flattenDeep会递归扁平化所有层级
- * @note 函数返回新数组，不会修改原输入数组
- * @note 非数组元素会被直接包含在结果中
+ * **Note:** 与flattenDeep的区别：此函数仅扁平化一层，而flattenDeep会递归扁平化所有层级
+ * **Note:** 函数返回新数组，不会修改原输入数组
+ * **Note:** 非数组元素会被直接包含在结果中
  */
 export declare const flatten: <T>(array: (T | T[])[]) => T[];
 //# sourceMappingURL=flatten.d.ts.map

package/dist/array/flattenDeep.d.ts

@@ -18,9 +18,9 @@
  * // 返回 [1, 2, 3, null, undefined, true] (包含多种类型元素)
  * @example
  * flattenDeep([[[[[1]]]]]); // 返回 [1] (单一元素的深层嵌套)
- * @note 使用递归实现，对于层级极深的数组可能导致栈溢出
- * @note 非数组元素（包括null和undefined）会被直接包含在结果中
- * @note 仅处理Array类型的嵌套结构，不处理类数组对象（如arguments、NodeList等）
+ * **Note:** 使用递归实现，对于层级极深的数组可能导致栈溢出
+ * **Note:** 非数组元素（包括null和undefined）会被直接包含在结果中
+ * **Note:** 仅处理Array类型的嵌套结构，不处理类数组对象（如arguments、NodeList等）
  */
 export declare const flattenDeep: (array: any[]) => any[];
 //# sourceMappingURL=flattenDeep.d.ts.map

package/dist/array/intersection.d.ts

@@ -21,10 +21,10 @@
  * @example
  * intersection([{ id: 1 }], [{ id: 1 }]);
  * // 返回 []（对象引用不同，视为不同元素）
- * @note 元素比较使用严格相等 (===)，因此 1 和 '1' 被视为不同元素
- * @note 结果数组会自动去重，即使原数组包含重复元素
- * @note 至少需要传入一个数组参数，否则会抛出运行时错误
- * @warning 对于大型数组，此实现可能存在性能问题（时间复杂度 O(n^2)）
+ * **Note:** 元素比较使用严格相等 (===)，因此 1 和 '1' 被视为不同元素
+ * **Note:** 结果数组会自动去重，即使原数组包含重复元素
+ * **Note:** 至少需要传入一个数组参数，否则会抛出运行时错误
+ * **Warning:** 对于大型数组，此实现可能存在性能问题（时间复杂度 O(n^2)）
  */
 export declare const intersection: (...arrays: any[]) => any;
 //# sourceMappingURL=intersection.d.ts.map

package/dist/array/needArray.d.ts

@@ -13,25 +13,20 @@ type ArrayType<T = any> = T extends Array<infer R> ? R : T;
  *  - 当T为null/undefined时，返回空数组
  *  - 其他情况返回包含value的单元素数组
  * @example
+ * ```ts
  * needArray(5);          // 返回 [5]（基本类型包装）
- * @example
  * needArray([1, 2, 3]);  // 返回 [1, 2, 3]（数组直接返回）
- * @example
  * needArray(null);       // 返回 []（null处理）
- * @example
  * needArray(undefined);  // 返回 []（undefined处理）
- * @example
  * needArray('hello');    // 返回 ['hello']（字符串包装）
- * @example
  * needArray({ a: 1 });   // 返回 [{ a: 1 }]（对象包装）
- * @example
  * needArray(true);       // 返回 [true]（布尔值包装）
- * @example
  * needArray(new Date()); // 返回 [Date实例]（特殊对象包装）
+ * ```
  * @see ArrayType - 用于提取数组元素类型的工具类型，定义为：type ArrayType<T = any> = T extends Array<infer R> ? R : T
- * @note 使用isNil函数判断null/undefined，该函数来自'../types'模块
- * @note 对于数组输入，返回原数组引用而非副本，修改返回值会影响原数组
- * @note 不处理类数组对象（如arguments、NodeList），会将其视为普通对象包装为单元素数组
+ * **Note:** 使用isNil函数判断null/undefined，该函数来自'../types'模块
+ * **Note:** 对于数组输入，返回原数组引用而非副本，修改返回值会影响原数组
+ * **Note:** 不处理类数组对象（如arguments、NodeList），会将其视为普通对象包装为单元素数组
  */
 export declare const needArray: <T = any>(value: T) => ArrayType<T>[];
 export {};

package/dist/array/needArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"needArray.d.ts","sourceRoot":"","sources":["../../src/array/needArray.ts"],"names":[],"mappings":"AAEA,KAAK,SAAS,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,KAAG,SAAS,CAAC,CAAC,CAAC,EASzD,CAAC"}
+{"version":3,"file":"needArray.d.ts","sourceRoot":"","sources":["../../src/array/needArray.ts"],"names":[],"mappings":"AAEA,KAAK,SAAS,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,KAAG,SAAS,CAAC,CAAC,CAAC,EASzD,CAAC"}

package/dist/array/orderBy.d.ts

@@ -1,9 +1,23 @@
 /**
  * 根据指定的迭代器和排序方向对数组进行排序
- * @param collection 要排序的数组
- * @param iteratees 用于排序的迭代器数组
- * @param orders 排序方向数组，对应每个迭代器
- * @returns 排序后的新数组
+ * 支持多字段排序，按迭代器数组顺序依次比较，当字段相等时继续比较下一个字段
+ * @template T - 数组元素的类型
+ * @param collection - 要排序的数组
+ * @param iteratees - 用于排序的属性名数组，每个元素为对象属性路径字符串
+ * @param orders - 排序方向数组，对应每个迭代器的排序方向，默认为 'asc'
+ * @returns 排序后的新数组，不修改原数组
+ * @example
+ * orderBy([{ name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }], ['age'], ['desc']);
+ * // 返回 [{ name: 'Bob', age: 30 }, { name: 'Alice', age: 25 }]（按年龄降序）
+ * @example
+ * orderBy([{ name: 'Alice', age: 25 }, { name: 'Bob', age: 25 }], ['age', 'name'], ['asc', 'asc']);
+ * // 返回 [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 25 }]（先按年龄，再按姓名排序）
+ * @example
+ * orderBy([3, 1, 4, 1, 5], [], []);
+ * // 返回 [3, 1, 4, 1, 5]（无迭代器时返回原数组副本）
+ * **Note:** null 和 undefined 值会被视为最小值
+ * **Note:** 使用数组副本进行排序，不修改原数组
+ * **Note:** 当 iteratees 为空数组时，返回原数组的浅拷贝
  */
 export declare const orderBy: <T>(collection: T[], iteratees?: string[], orders?: ("asc" | "desc")[]) => T[];
 //# sourceMappingURL=orderBy.d.ts.map

package/dist/array/orderBy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderBy.d.ts","sourceRoot":"","sources":["../../src/array/orderBy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE,YAAW,MAAM,EAAO,EAAE,SAAQ,CAAC,KAAK,GAAG,MAAM,CAAC,EAAO,KAAG,CAAC,EAuCxG,CAAC"}
+{"version":3,"file":"orderBy.d.ts","sourceRoot":"","sources":["../../src/array/orderBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE,YAAW,MAAM,EAAO,EAAE,SAAQ,CAAC,KAAK,GAAG,MAAM,CAAC,EAAO,KAAG,CAAC,EAuCxG,CAAC"}

package/dist/array/sortBy.d.ts

@@ -28,10 +28,10 @@
  * // 处理包含null/undefined的属性值
  * const mixed = [{ score: 90 }, { score: null }, { score: 85 }];
  * mixed.sort(sortBy('score')); // null值排在最后
- * @note 字符串比较区分大小写，'Z'会排在'a'前面
- * @note 不支持对象类型的属性值比较，复杂类型需先转换为基本类型
- * @note 排序是原地(in-place)进行的，会修改原始数组
- * @note 当属性不存在于对象中时，该对象会被视为值为undefined
+ * **Note:** 字符串比较区分大小写，'Z'会排在'a'前面
+ * **Note:** 不支持对象类型的属性值比较，复杂类型需先转换为基本类型
+ * **Note:** 排序是原地(in-place)进行的，会修改原始数组
+ * **Note:** 当属性不存在于对象中时，该对象会被视为值为undefined
  */
-export declare const sortBy: (key: string) => (a: Record<string, any>, b: Record<string, any>) => 0 | 1 | -1;
+export declare const sortBy: (key: string) => (a: Record<string, any>, b: Record<string, any>) => 1 | 0 | -1;
 //# sourceMappingURL=sortBy.d.ts.map

package/dist/array/unionBy.d.ts

@@ -1,2 +1,22 @@
+/**
+ * 根据指定的键函数对数组进行去重，返回唯一元素的新数组
+ * 使用键函数提取每个元素的唯一标识符，保留第一次出现的元素
+ * @template T - 数组元素的类型
+ * @param array - 要去重的数组
+ * @param getKey - 键函数，用于从元素中提取唯一标识符
+ * @returns 去重后的新数组，保留元素在原数组中的出现顺序
+ * @example
+ * unionBy([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 1, name: 'Alice2' }], item => item.id);
+ * // 返回 [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]（按id去重）
+ * @example
+ * unionBy(['apple', 'banana', 'Apple'], item => item.toLowerCase());
+ * // 返回 ['apple', 'banana']（按小写字母去重）
+ * @example
+ * unionBy([1, 2, 3, 2, 1], item => item);
+ * // 返回 [1, 2, 3]（基本类型去重）
+ * **Note:** 键函数的返回值必须是字符串或数字类型
+ * **Note:** 保留第一次出现的元素，后续重复元素被过滤掉
+ * **Note:** 返回新数组，不修改原数组
+ */
 export declare const unionBy: <T = any>(array: T[], getKey: (item: T) => string | number) => T[];
 //# sourceMappingURL=unionBy.d.ts.map

package/dist/array/unionBy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unionBy.d.ts","sourceRoot":"","sources":["../../src/array/unionBy.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,QACS,CAAC"}
+{"version":3,"file":"unionBy.d.ts","sourceRoot":"","sources":["../../src/array/unionBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,QACS,CAAC"}

package/dist/async/{AsyncTaskExecutor.d.ts → AsyncQueueExecutor.d.ts}

@@ -2,31 +2,36 @@
  * 执行器状态接口
  */
 interface ExecutorStatus {
+    /**
+     * 当前运行中的任务数
+     */
     running: number;
+    /**
+     * 队列中等待的任务数
+     */
     queued: number;
+    /**
+     * 最大并发数
+     */
     maxConcurrent: number;
 }
 /**
  * 异步任务执行器
  * 支持并发控制和动态任务调度
  */
-export declare class AsyncTaskExecutor {
+export declare class AsyncQueueExecutor {
     private maxConcurrent;
     private running;
     private queue;
+    private queue_map;
     constructor(maxConcurrent?: number);
     /**
      * 添加任务到执行器
      * @param task - 返回 Promise 的异步任务函数
+     * @param id - 任务唯一标识符（可选），用于去重相同任务
      * @returns 返回任务执行结果的 Promise
      */
-    addTask<T>(task: () => Promise<T>): Promise<T>;
-    /**
-     * 批量添加多个任务
-     * @param tasks - 任务数组
-     * @returns 返回所有任务结果的 Promise 数组
-     */
-    addTasks<T>(tasks: (() => Promise<T>)[]): Promise<T[]>;
+    addTask<T>(task: () => Promise<T>, id?: string | number): Promise<T>;
     /**
      * 获取当前状态
      * @returns 包含运行中任务数、队列长度和最大并发数
@@ -57,7 +62,7 @@ export declare class AsyncTaskExecutor {
     /**
      * 执行队列中的下一个任务
      */
-    private _runNext;
+    private _run_next;
 }
 export {};
-//# sourceMappingURL=AsyncTaskExecutor.d.ts.map
+//# sourceMappingURL=AsyncQueueExecutor.d.ts.map

package/dist/async/AsyncQueueExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncQueueExecutor.d.ts","sourceRoot":"","sources":["../../src/async/AsyncQueueExecutor.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,UAAU,cAAc;IACtB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,SAAS,CAAiD;gBAEtD,aAAa,GAAE,MAAU;IAIrC;;;;;OAKG;IACH,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAiBpE;;;OAGG;IACH,SAAS,IAAI,cAAc;IAQ3B;;;OAGG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQtC;;OAEG;IACH,UAAU,IAAI,IAAI;IAQlB;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAa3B;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,OAAO,CAAC,SAAS;CAoBlB"}

package/dist/async/index.d.ts

@@ -1,4 +1,4 @@
-export * from './AsyncTaskExecutor.js';
+export * from './AsyncQueueExecutor.js';
 export * from './nextMacroTask.js';
 export * from './nextMicroTask.js';
 export * from './sleep.js';

package/dist/async/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC"}

package/dist/async/nextMacroTask.d.ts

@@ -1,6 +1,15 @@
 /**
- * 下一个宏任务执行
- * @param fn
+ * 在下一个宏任务中执行函数
+ * 使用 setTimeout(fn, 0) 将函数推迟到当前执行栈清空后执行
+ * @param fn - 要延迟执行的函数
+ * @example
+ * console.log('1');
+ * nextMacroTask(() => console.log('3'));
+ * console.log('2');
+ * // 输出顺序: 1, 2, 3
+ * **Note:** 宏任务包括 setTimeout、setInterval、I/O 操作等
+ * **Note:** 常用于避免阻塞当前执行栈，或确保 DOM 更新后再执行代码
+ * **Note:** 与 nextMicroTask 的区别：宏任务在微任务之后执行
  */
 export declare const nextMacroTask: (fn: () => any) => NodeJS.Timeout;
 //# sourceMappingURL=nextMacroTask.d.ts.map

package/dist/async/nextMacroTask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nextMacroTask.d.ts","sourceRoot":"","sources":["../../src/async/nextMacroTask.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,IAAI,MAAM,GAAG,mBAA8B,CAAC"}
+{"version":3,"file":"nextMacroTask.d.ts","sourceRoot":"","sources":["../../src/async/nextMacroTask.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,GAAI,IAAI,MAAM,GAAG,mBAA8B,CAAC"}

package/dist/async/nextMicroTask.d.ts

@@ -23,7 +23,7 @@
  * }
  * @param fn - 要推迟执行的函数，可选
  * @returns 解析为回调函数返回值的Promise，若回调抛出错误则Promise会被拒绝
- * @note 基于微任务队列实现，执行时机早于setTimeout(fn, 0)等宏任务
+ * **Note:** 基于微任务队列实现，执行时机早于setTimeout(fn, 0)等宏任务
  */
 export declare const nextMicroTask: <T = void, R = void>(fn?: (this: T) => R) => Promise<R | void>;
 //# sourceMappingURL=nextMicroTask.d.ts.map

package/dist/binary/uint8ArrayToString.d.ts

@@ -7,7 +7,7 @@
  * uint8ArrayToString(bytes); // 返回 'Hello'
  * @param u8 - 要转换的Uint8Array实例
  * @returns 解码后的UTF-8字符串
- * @note 使用默认的UTF-8编码，不支持其他字符编码
+ * **Note:** 使用默认的UTF-8编码，不支持其他字符编码
  */
 export declare const uint8ArrayToString: (u8: Uint8Array) => string;
 //# sourceMappingURL=uint8ArrayToString.d.ts.map

package/dist/collection/traverseObjectKeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traverseObjectKeys.d.ts","sourceRoot":"","sources":["../../src/collection/traverseObjectKeys.ts"],"names":[],"mappings":"AAMA,KAAK,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;AAkB/D,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,EAAE,UAAU,QAAQ,KAAG,IAMhG,CAAC"}
+{"version":3,"file":"traverseObjectKeys.d.ts","sourceRoot":"","sources":["../../src/collection/traverseObjectKeys.ts"],"names":[],"mappings":"AAyBA,KAAK,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;AAkB/D,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,EAAE,UAAU,QAAQ,KAAG,IAMhG,CAAC"}

package/dist/crypto/aesDecrypt.d.ts

@@ -1,9 +1,16 @@
 /**
- * AES 解密
- * @param cipherText
- * @param keyString
- * @param ivString
- * @returns
+ * 使用 AES-GCM 算法解密数据
+ * @param cipherText - Base64 编码的密文字符串
+ * @param keyString - Base64 编码的 AES 密钥字符串
+ * @param ivString - Base64 编码的初始化向量字符串
+ * @returns 解密后的明文字符串
+ * @throws {Error} 当解密失败时抛出错误
+ * @example
+ * const plaintext = await aesDecrypt('encryptedData', 'keyInBase64', 'ivInBase64');
+ * console.log(plaintext); // 输出解密后的明文
+ * **Note:** 使用 Web Crypto API 进行 AES-GCM 解密
+ * **Note:** 密钥长度为 256 位
+ * **Note:** 所有输入参数都应为有效的 Base64 字符串
  */
 export declare function aesDecrypt(cipherText: string, keyString: string, ivString: string): Promise<string>;
 //# sourceMappingURL=aesDecrypt.d.ts.map

package/dist/crypto/aesDecrypt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aesDecrypt.d.ts","sourceRoot":"","sources":["../../src/crypto/aesDecrypt.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,mBAsBvF"}
+{"version":3,"file":"aesDecrypt.d.ts","sourceRoot":"","sources":["../../src/crypto/aesDecrypt.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,mBAsBvF"}

package/dist/crypto/aesEncrypt.d.ts

@@ -1,7 +1,7 @@
 /**
  * AES 加密
- * @param plaintext
- * @returns
+ * @param text 明文
+ * @returns 加密结果
  */
 export declare function aesEncrypt(text: string): Promise<{
     key: string;

package/dist/crypto/rsaGenerateKey.d.ts

@@ -1,4 +1,26 @@
+/**
+ * 导出加密密钥为指定格式
+ * @param key - 要导出的 CryptoKey 对象
+ * @param type - 导出格式，默认为 'pkcs8'
+ * @returns Base64 编码的密钥字符串
+ */
 export declare function exportCryptoKey(key: CryptoKey, type?: Exclude<KeyFormat, 'jwk'>): Promise<string>;
+/**
+ * 生成 RSA 密钥对
+ * @param modulusLength - 模数长度，默认 1024，可选值：1024、2048、4096
+ * @returns 包含公钥和私钥 PEM 格式字符串的对象
+ * @property {string} publicKey - PEM 格式的 RSA 公钥
+ * @property {string} privateKey - PEM 格式的 RSA 私钥
+ * @throws {Error} 当密钥生成失败时抛出错误
+ * @example
+ * const keyPair = await rsaGenerateKey(2048);
+ * console.log(keyPair.publicKey);  // PEM 格式的公钥
+ * console.log(keyPair.privateKey); // PEM 格式的私钥
+ * **Note:** 使用 Web Crypto API 生成 RSA-OAEP 密钥对
+ * **Note:** 使用 SHA-512 哈希算法
+ * **Note:** 公钥指数固定为 65537 (0x010001)
+ * **Note:** 生成的密钥可用于加密和解密操作
+ */
 export declare function rsaGenerateKey(modulusLength?: number): Promise<{
     publicKey: string;
     privateKey: string;

package/dist/crypto/rsaGenerateKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsaGenerateKey.d.ts","sourceRoot":"","sources":["../../src/crypto/rsaGenerateKey.ts"],"names":[],"mappings":"AAKA,wBAAsB,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,GAAE,OAAO,CAAC,SAAS,EAAE,KAAK,CAAW,mBAG9F;AAED,wBAAsB,cAAc,CAAC,aAAa,SAAO;;;GAkBxD"}
+{"version":3,"file":"rsaGenerateKey.d.ts","sourceRoot":"","sources":["../../src/crypto/rsaGenerateKey.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,GAAE,OAAO,CAAC,SAAS,EAAE,KAAK,CAAW,mBAG9F;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAAC,aAAa,SAAO;;;GAkBxD"}

package/dist/date/parseTime.d.ts

@@ -1,10 +1,33 @@
+/**
+ * 解析两个日期之间的时间差，返回分解后的时间单位
+ */
 export interface ParseTime {
+    /** 年数 */
     year: number;
+    /** 月数 */
     month: number;
+    /** 天数 */
     day: number;
+    /** 小时数 */
     hour: number;
+    /** 分钟数 */
     minute: number;
+    /** 秒数 */
     second: number;
 }
+/**
+ * 计算两个日期之间的时间差，并分解为年、月、日、时、分、秒
+ * @param startDate - 开始日期
+ * @param endDate - 结束日期
+ * @returns 包含时间差分解结果的对象
+ * @example
+ * const start = new Date('2023-01-01T00:00:00');
+ * const end = new Date('2024-02-02T12:30:45');
+ * const result = parseTime(start, end);
+ * // 返回: { year: 1, month: 13, day: 397, hour: 12, minute: 30, second: 45 }
+ * **Note:** 月份和年份的计算是近似值（30天=1月，12月=1年）
+ * **Note:** 所有时间单位都是向下取整的整数
+ * **Note:** 返回的月份和年份可能超过常规范围（如13个月表示1年1个月）
+ */
 export declare const parseTime: (startDate: Date, endDate: Date) => ParseTime;
 //# sourceMappingURL=parseTime.d.ts.map

package/dist/date/parseTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseTime.d.ts","sourceRoot":"","sources":["../../src/date/parseTime.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AACD,eAAO,MAAM,SAAS,GAAI,WAAW,IAAI,EAAE,SAAS,IAAI,KAAG,SAS1D,CAAC"}
+{"version":3,"file":"parseTime.d.ts","sourceRoot":"","sources":["../../src/date/parseTime.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS;IACT,IAAI,EAAE,MAAM,CAAC;IACb,SAAS;IACT,KAAK,EAAE,MAAM,CAAC;IACd,SAAS;IACT,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU;IACV,IAAI,EAAE,MAAM,CAAC;IACb,UAAU;IACV,MAAM,EAAE,MAAM,CAAC;IACf,SAAS;IACT,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,GAAI,WAAW,IAAI,EAAE,SAAS,IAAI,KAAG,SAS1D,CAAC"}

package/dist/date/stringTime.d.ts

@@ -1,4 +1,16 @@
 import { ParseTimeConfig } from './formatPassTime.js';
 import { ParseTime } from './parseTime.js';
+/**
+ * 将时间数值格式化为带单位的字符串
+ * @param key - 时间单位键名，对应 ParseTime 接口的属性
+ * @param value - 时间数值
+ * @param config - 可选的配置对象，用于自定义单位名称
+ * @returns 格式化后的时间字符串，如 "5 天" 或 "3 hours"
+ * @example
+ * stringTime('day', 5); // 返回 "5 day"
+ * stringTime('hour', 3, { hour: '小时' }); // 返回 "3 小时"
+ * **Note:** 如果提供 config，会使用配置中的单位名称，否则使用英文键名
+ * **Note:** 此函数主要用于 formatPassTime 等函数的内部实现
+ */
 export declare const stringTime: (key: keyof ParseTime, value: number, config?: ParseTimeConfig) => string;
 //# sourceMappingURL=stringTime.d.ts.map

package/dist/date/stringTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stringTime.d.ts","sourceRoot":"","sources":["../../src/date/stringTime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,SAAS,EAAE,OAAO,MAAM,EAAE,SAAS,eAAe,WACJ,CAAC"}
+{"version":3,"file":"stringTime.d.ts","sourceRoot":"","sources":["../../src/date/stringTime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,SAAS,EAAE,OAAO,MAAM,EAAE,SAAS,eAAe,WACJ,CAAC"}

package/dist/function/once.d.ts

@@ -21,8 +21,8 @@
  * // 多次调用只会发起一次请求
  * getConfig();
  * getConfig();
- * @note 该实现仅支持无参数函数，如需处理带参数的函数，请使用其他实现
- * @note 第一次执行的结果会被缓存，后续调用返回相同结果
+ * **Note:** 该实现仅支持无参数函数，如需处理带参数的函数，请使用其他实现
+ * **Note:** 第一次执行的结果会被缓存，后续调用返回相同结果
  */
 export declare function once<F extends () => any>(func: F): F;
 //# sourceMappingURL=once.d.ts.map

package/dist/function/throttle.d.ts

@@ -23,9 +23,9 @@ import { AnyFunction } from '../types/index.js';
  * };
  * logger.log('Hello');
  * logger.log('World'); // 200ms内只会执行一次
- * @note 节流函数会忽略在时间间隔内的调用，不累积执行
- * @note 首次调用会立即执行，之后按时间间隔限制
- * @warning 确保timeFrame为正整数，否则可能导致意外行为
+ * **Note:** 节流函数会忽略在时间间隔内的调用，不累积执行
+ * **Note:** 首次调用会立即执行，之后按时间间隔限制
+ * **Warning:** 确保timeFrame为正整数，否则可能导致意外行为
  */
 export declare const throttle: <Func extends AnyFunction>(func: Func, timeFrame: number) => (this: ThisParameterType<Func>, ...args: Parameters<Func>) => void;
 //# sourceMappingURL=throttle.d.ts.map