@aiao/utils 0.0.1

package/@browser/IdleTimer.d.ts

@@ -0,0 +1,18 @@
+interface IdleTimerOptions {
+    /**
+     * 多少毫秒内没有时间就算是空闲
+     * @default 2000
+     */
+    timeout?: number;
+}
+/**
+ * 浏览器空闲检测
+ */
+export declare class IdleTimer {
+    #private;
+    private options?;
+    idle$: import('rxjs').Observable<boolean>;
+    constructor(options?: IdleTimerOptions | undefined);
+    start(): void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+export type BroadcastTopic<T> = {
+    message$: Observable<T>;
+    emit: (message: T) => void;
+};
+/**
+ * BroadcastChannel pool
+ * 统一管理所有的 BroadcastChannel
+ */
+declare class BroadcastChannelPool {
+    #private;
+    emit<T = any>(event: string, data: T): void;
+    on<T = any>(event: string): Observable<any>;
+}
+export declare const pool: BroadcastChannelPool;
+export declare const createBroadcastTopic: <T = any>(event: string) => BroadcastTopic<T>;
+export {};

package/@browser/index.d.ts

@@ -0,0 +1,4 @@
+export * from './broadcast-channel-pool';
+export * from './IdleTimer';
+export * from './leader-election';
+export * from './perform-chunk';

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

@@ -0,0 +1,7 @@
+export declare class LeaderElection {
+    #private;
+    private name;
+    get isLeader(): boolean;
+    constructor(name: string);
+    leadership(): import('rxjs').Observable<boolean>;
+}

package/@browser/perform-chunk.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 分片执行任务
+ * 只能在浏览器环境中执行
+ * 把一个大任务分片执行，每次执行一小部分任务，然后让出主线程，等待下一次执行
+ *
+ * @param array 要执行的数据组
+ * @param consumer 消费者函数
+ */
+export declare function performChunk<T>(array: T[], consumer: (data: T, index: number) => void): void;

package/README.md

@@ -0,0 +1 @@
+# utils

package/array/chunk.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 将数组分割成指定大小的数组块
+ * 当数组长度不能被分割大小整除时，最后一个块将包含剩余的元素
+ *
+ * @template T - 数组元素的类型
+ * @param array - 要分割的数组（只读，不能为null/undefined）
+ * @param size - 每个块的大小，必须是正整数
+ * @returns 分割后的数组块组成的新数组
+ * @example
+ * chunk(['a', 'b', 'c', 'd'], 2);
+ * // 返回 [['a', 'b'], ['c', 'd']]
+ * @example
+ * chunk(['a', 'b', 'c', 'd'], 3);
+ * // 返回 [['a', 'b', 'c'], ['d']]
+ * @example
+ * chunk([], 2); // 返回 []（空数组）
+ * @example
+ * chunk([1, 2, 3], 5); // 返回 [[1, 2, 3]]（块大小大于数组长度）
+ * @example
+ * chunk([1, 2, 3, 4], 1); // 返回 [[1], [2], [3], [4]]（块大小为1）
+ * @warning size必须是正整数，非正数值可能导致意外行为
+ * @note 函数不会修改原数组，而是返回一个包含新数组块的新数组
+ */
+export declare const chunk: <T>(array: readonly T[], size: number) => T[][];

package/array/difference.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 计算两个数组的差异，返回仅存在于第一个数组中且不在第二个数组中的元素
+ * 元素比较使用严格相等运算符 (===)，因此对象仅在引用相同时被视为相等
+ * 结果数组保留元素在原数组中的出现顺序
+ *
+ * @template T - 数组元素的类型
+ * @param array1 - 源数组，从中筛选差异元素
+ * @param array2 - 比较数组，用于判断元素是否应被排除
+ * @returns 新数组，包含所有仅存在于 array1 中的元素（保留原顺序）
+ * @example
+ * difference([0, 1, 2], [2, 3, 4]);
+ * // 返回 [0, 1]（基础类型比较）
+ * @example
+ * difference(['a', 'b', 'c'], ['b', 'd']);
+ * // 返回 ['a', 'c']（字符串比较）
+ * @example
+ * difference([1, 2, 2, 3], [2]);
+ * // 返回 [1, 3]（自动去重 array1 中被排除的重复元素）
+ * @example
+ * difference([], [1, 2]); // 返回 []（源数组为空）
+ * @example
+ * difference([1, 2], []); // 返回 [1, 2]（比较数组为空）
+ * @example
+ * difference([{ id: 1 }], [{ id: 1 }]);
+ * // 返回 [{ id: 1 }]（对象引用不同，视为不同元素）
+ * @note 使用 Array.prototype.includes 实现，因此比较使用严格相等 (===)
+ * @note 结果数组中不会包含 array1 中重复出现但也存在于 array2 中的元素
+ * @warning 不支持对象的深度比较，仅比较引用是否相同
+ */
+export declare const difference: <T>(array1: T[], array2: T[]) => T[];

package/array/flatten.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 将嵌套一层的数组扁平化为一维数组
+ * 仅处理数组中的直接嵌套数组元素，不进行深度扁平化
+ *
+ * @template T - 数组元素的基础类型
+ * @param array - 输入数组，包含基础类型元素和/或嵌套一层的数组
+ * @returns 扁平化后的新数组，所有元素均为基础类型T
+ * @example
+ * flatten([1, [2, 3], 4]);
+ * // 返回 [1, 2, 3, 4]
+ * @example
+ * flatten(['a', ['b', ['c']], 'd']);
+ * // 返回 ['a', 'b', ['c'], 'd'] (仅扁平化一层，保留深层嵌套数组)
+ * @example
+ * flatten([[], [1, 2], 3]); // 返回 [1, 2, 3] (处理空数组)
+ * @example
+ * flatten([1, 2, 3]); // 返回 [1, 2, 3] (无嵌套数组时返回原数组元素)
+ * @example
+ * flatten([]); // 返回 [] (空输入数组)
+ * @note 与flattenDeep的区别：此函数仅扁平化一层，而flattenDeep会递归扁平化所有层级
+ * @note 函数返回新数组，不会修改原输入数组
+ * @note 非数组元素会被直接包含在结果中
+ */
+export declare const flatten: <T>(array: (T | T[])[]) => T[];

package/array/flattenDeep.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 将任意深度的嵌套数组完全扁平化为一维数组
+ * 递归处理所有层级的嵌套数组，直至所有元素都为非数组类型
+ *
+ * @template T - 数组元素的基础类型
+ * @param array - 任意深度的嵌套数组，可包含基础类型元素和/或嵌套数组
+ * @returns 完全扁平化后的一维数组，所有元素均为基础类型T
+ * @example
+ * flattenDeep([1, [2, [3, [4]], 5]]);
+ * // 返回 [1, 2, 3, 4, 5] (多层嵌套数组)
+ * @example
+ * flattenDeep(['a', [['b']], [[[['c']]]]]);
+ * // 返回 ['a', 'b', 'c'] (极深嵌套数组)
+ * @example
+ * flattenDeep([]); // 返回 [] (空数组)
+ * @example
+ * flattenDeep([1, [2, [3]], null, undefined, [true]]);
+ * // 返回 [1, 2, 3, null, undefined, true] (包含多种类型元素)
+ * @example
+ * flattenDeep([[[[[1]]]]]); // 返回 [1] (单一元素的深层嵌套)
+ * @note 使用递归实现，对于层级极深的数组可能导致栈溢出
+ * @note 非数组元素（包括null和undefined）会被直接包含在结果中
+ * @note 仅处理Array类型的嵌套结构，不处理类数组对象（如arguments、NodeList等）
+ */
+export declare const flattenDeep: (array: any[]) => any[];

package/array/index.d.ts

@@ -0,0 +1,8 @@
+export * from './chunk';
+export * from './difference';
+export * from './flatten';
+export { flattenDeep } from './flattenDeep';
+export * from './index';
+export * from './intersection';
+export * from './needArray';
+export * from './sortBy';

package/array/intersection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 计算多个数组的交集，返回所有输入数组中都存在的元素
+ * 使用严格相等运算符 (===) 进行元素比较，结果数组保留第一个数组中的元素顺序
+ * 如果输入单个数组，则返回该数组的去重版本
+ *
+ * @param arrays - 任意数量的数组，至少需要一个数组参数
+ * @returns 包含所有输入数组共有元素的新数组（自动去重）
+ * @example
+ * intersection([1, 2, 3], [2, 3, 4], [2, 5]);
+ * // 返回 [2]（多数组交集）
+ * @example
+ * intersection(['a', 'b'], ['b', 'a'], ['b']);
+ * // 返回 ['b']（保留第一个数组的元素顺序）
+ * @example
+ * intersection([1, 2, 2, 3], [2, 2, 4]);
+ * // 返回 [2]（自动去重结果）
+ * @example
+ * intersection([1, 2]); // 返回 [1, 2]（单个数组去重）
+ * @example
+ * intersection([], [1, 2]); // 返回 []（任意数组为空则结果为空）
+ * @example
+ * intersection([{ id: 1 }], [{ id: 1 }]);
+ * // 返回 []（对象引用不同，视为不同元素）
+ * @note 元素比较使用严格相等 (===)，因此 1 和 '1' 被视为不同元素
+ * @note 结果数组会自动去重，即使原数组包含重复元素
+ * @note 至少需要传入一个数组参数，否则会抛出运行时错误
+ * @warning 对于大型数组，此实现可能存在性能问题（时间复杂度 O(n^2)）
+ */
+export declare const intersection: (...arrays: any[]) => any;

package/array/needArray.d.ts

@@ -0,0 +1,37 @@
+type ArrayType<T = any> = T extends Array<infer R> ? R : T;
+/**
+ * 将任意值标准化为数组格式，提供一致的数组处理接口
+ * 处理规则：
+ * - 若输入已是数组，则直接返回原数组（不创建新数组）
+ * - 若输入为null/undefined，则返回空数组
+ * - 其他任何类型的值均包装为单元素数组
+ *
+ * @template T - 输入值的类型，可以是任意类型（包括数组）
+ * @param value - 需要标准化为数组的值
+ * @returns 标准化后的数组
+ *  - 当T为数组类型时，返回T本身
+ *  - 当T为null/undefined时，返回空数组
+ *  - 其他情况返回包含value的单元素数组
+ * @example
+ * 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），会将其视为普通对象包装为单元素数组
+ */
+export declare const needArray: <T = any>(value: T) => ArrayType<T>[];
+export {};

package/array/sortBy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 创建一个按指定对象属性排序的比较函数，用于数组排序
+ * 按属性值的自然顺序进行升序排序，支持字符串、数字等基本类型比较
+ * 生成的比较函数兼容Array.sort()方法，会修改原数组
+ *
+ * @template T - 数组元素对象的类型
+ * @param key - 用于排序的对象属性名，必须是T的有效属性
+ * @returns 比较函数，返回值：
+ *   - 正数：a应排在b后面
+ *   - 负数：a应排在b前面
+ *   - 0：a和b位置不变
+ * @example
+ * const data = [
+ *   { name: 'Bob', age: 30 },
+ *   { name: 'Alice', age: 25 },
+ *   { name: 'Charlie', age: 35 }
+ * ];
+ * // 按age升序排序
+ * data.sort(sortBy('age')); // 结果: Alice(25), Bob(30), Charlie(35)
+ * @example
+ * // 按name字母顺序排序(区分大小写)
+ * data.sort(sortBy('name')); // 结果: Alice, Bob, Charlie
+ * @example
+ * // 数字字符串会按字典序而非数值排序
+ * const items = [{ id: '10' }, { id: '2' }, { id: '1' }];
+ * items.sort(sortBy('id')); // 结果: [{id: '1'}, {id: '10'}, {id: '2'}]
+ * @example
+ * // 处理包含null/undefined的属性值
+ * const mixed = [{ score: 90 }, { score: null }, { score: 85 }];
+ * mixed.sort(sortBy('score')); // null值排在最后
+ * @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;

package/async/index.d.ts

@@ -0,0 +1,2 @@
+export { nextTick } from './next-tick';
+export * from './sleep';

package/async/next-tick.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 将函数推迟到下一个微任务队列执行
+ * 使用Promise.resolve()实现，确保函数在当前同步代码执行完成后、DOM更新前执行
+ *
+ * @template T - 回调函数中this的类型
+ * @template R - 回调函数的返回值类型
+ * @example
+ * // 基础用法
+ * nextTick(() => {
+ *   console.log('在当前同步代码后执行');
+ * });
+ * @example
+ * // 带返回值和async/await
+ * async function example() {
+ *   await nextTick(() => '执行完成');
+ *   console.log('Promise已解析');
+ * }
+ * @example
+ * // 无回调函数（仅获取下一个微任务的Promise）
+ * async function delay() {
+ *   await nextTick();
+ *   console.log('下一个微任务');
+ * }
+ * @param fn - 要推迟执行的函数，可选
+ * @returns 解析为回调函数返回值的Promise，若回调抛出错误则Promise会被拒绝
+ * @note 基于微任务队列实现，执行时机早于setTimeout(fn, 0)等宏任务
+ */
+export declare const nextTick: <T = void, R = void>(fn: (this: T) => R) => Promise<R>;

package/async/sleep.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 等待时间
+ * @param ms 毫秒
+ */
+export declare const sleep: (ms: number) => Promise<unknown>;

package/binary/index.d.ts

@@ -0,0 +1 @@
+export { uint8ArrayToString } from './uint8ArrayToString';

package/binary/uint8ArrayToString.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 将Uint8Array转换为UTF-8字符串
+ * 使用TextDecoder API进行解码，确保正确处理多字节字符
+ *
+ * @example
+ * const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+ * uint8ArrayToString(bytes); // 返回 'Hello'
+ * @param u8 - 要转换的Uint8Array实例
+ * @returns 解码后的UTF-8字符串
+ * @note 使用默认的UTF-8编码，不支持其他字符编码
+ */
+export declare const uint8ArrayToString: (u8: Uint8Array) => string;

package/collection/index.d.ts

@@ -0,0 +1 @@
+export { traverseObjectKeys } from './traverseObjectKeys';

package/collection/traverseObjectKeys.d.ts

@@ -0,0 +1,3 @@
+type Callback = (key: string, value: any, object: any) => void;
+export declare const traverseObjectKeys: (objOrArray: Record<string, any> | any[], callback: Callback) => void;
+export {};

package/crypto/aesDecrypt.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AES 解密
+ * @param cipherText
+ * @param keyString
+ * @param ivString
+ * @returns
+ */
+export declare function aesDecrypt(cipherText: string, keyString: string, ivString: string): Promise<string>;

package/crypto/aesEncrypt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AES 加密
+ * @param plaintext
+ * @returns
+ */
+export declare function aesEncrypt(text: string): Promise<{
+    key: string;
+    iv: string;
+    cipherText: string;
+}>;

package/crypto/base64Decode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * base64 解码
+ * @param value 字符串
+ * @returns
+ */
+export declare const base64Decode: (value: string) => Uint8Array<ArrayBuffer>;

package/crypto/base64Encode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * base64 编码
+ * @param value
+ * @returns
+ */
+export declare const base64Encode: (value: Uint8Array | ArrayBuffer | string | number[]) => string;

package/crypto/decodeJWTPayload.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 解码 JWT token 的信息
+ * @param token
+ * @returns
+ */
+export declare const decodeJWTPayload: (token: string) => any;

package/crypto/index.d.ts

@@ -0,0 +1,8 @@
+export { aesDecrypt } from './aesDecrypt';
+export { aesEncrypt } from './aesEncrypt';
+export { base64Decode } from './base64Decode';
+export { base64Encode } from './base64Encode';
+export { decodeJWTPayload } from './decodeJWTPayload';
+export { rsaDecrypt } from './rsaDecrypt';
+export { rsaEncrypt } from './rsaEncrypt';
+export { rsaGenerateKey } from './rsaGenerateKey';

package/crypto/rsaDecrypt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RSA 解密
+ * @param  cipherText 密文
+ * @param privateKeyPem 私钥
+ * @returns
+ */
+export declare function rsaDecrypt(cipherText: string, privateKeyPem: string): Promise<string>;

package/crypto/rsaEncrypt.d.ts

@@ -0,0 +1,8 @@
+export declare function importRsaPublicKey(publicKeyPem: string): Promise<CryptoKey>;
+/**
+ * RAS 加密
+ * @param text
+ * @param publicKeyPem
+ * @returns
+ */
+export declare function rsaEncrypt(text: string, publicKeyPem: string): Promise<string>;

package/crypto/rsaGenerateKey.d.ts

@@ -0,0 +1,5 @@
+export declare function exportCryptoKey(key: CryptoKey, type?: Exclude<KeyFormat, 'jwk'>): Promise<string>;
+export declare function rsaGenerateKey(modulusLength?: number): Promise<{
+    publicKey: string;
+    privateKey: string;
+}>;

package/date/canBeDate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 判断是否可以转换成日期
+ * @param date 时间
+ */
+export declare const canBeDate: (date?: unknown) => boolean;

package/date/dateStringToDate.d.ts

@@ -0,0 +1,7 @@
+/**
+ *  UTC 时间转换
+ *  offset 分钟
+ *  date 2018-12-04
+ *  time 19:09:10
+ */
+export declare const dateStringToDate: (date: string, time: string, offset: number) => Date;

package/date/dateStringWithTimezone.d.ts

@@ -0,0 +1,11 @@
+/**
+ * UTC 时间转换
+ * @param date 2018-12-04
+ * @param time  19:09:10
+ * @param offset 本地时间 减去 格林威治标准时间 (GMT) 的分钟量 与 getTimezoneOffset 相反数
+ * @returns
+ *
+ * @example
+ *   dateStringWithTimezone('2018-12-04', '19:09:10', 480) => '2018-12-04T19:09:10+08:00'
+ */
+export declare const dateStringWithTimezone: (date: string, time: string, offset: number) => string;

package/date/formatCountdown.d.ts

@@ -0,0 +1,12 @@
+import { ParseTimeConfig } from './formatPassTime';
+import { ParseTime } from './parseTime';
+type FormatCountdownFunction = (input: ParseTime) => string;
+/**
+ * 倒计时
+ * @param startDate 开始时间
+ * @param endDate 结束时间
+ * @param config 配置
+ * @returns
+ */
+export declare const formatCountdown: (startDate: Date, endDate: Date, config?: ParseTimeConfig | FormatCountdownFunction) => string;
+export {};

package/date/formatPassTime.d.ts

@@ -0,0 +1,10 @@
+import { ParseTime } from './parseTime';
+export type ParseTimeConfig = {
+    [K in keyof ParseTime]: string;
+};
+export type FormatPassFunction = (input: {
+    key: keyof ParseTime;
+    value: number;
+}) => string;
+export declare const dateKeys: (keyof ParseTime)[];
+export declare const formatPassTime: (startDate: Date, endDate: Date, config?: ParseTimeConfig | FormatPassFunction) => string;

package/date/index.d.ts

@@ -0,0 +1,12 @@
+export { canBeDate } from './canBeDate';
+export { dateStringToDate } from './dateStringToDate';
+export { dateStringWithTimezone } from './dateStringWithTimezone';
+export { formatCountdown } from './formatCountdown';
+export { formatPassTime } from './formatPassTime';
+export { isISODateString } from './isISODateString';
+export { isMSTime } from './isMSTime';
+export { msTimeToMilliseconds } from './msTimeToMilliseconds';
+export type { MSTime } from './msTimeToMilliseconds';
+export { parseTime } from './parseTime';
+export { stringTime } from './stringTime';
+export { unixTimestamp } from './unixTimestamp';

package/date/isISODateString.d.ts

@@ -0,0 +1,6 @@
+/**
+ * string 是否是 ISO 日期字符串
+ * @param value
+ * @returns
+ */
+export declare const isISODateString: (value: unknown) => boolean;

package/date/isMSTime.d.ts

@@ -0,0 +1,7 @@
+import { MSTime } from './msTimeToMilliseconds';
+/**
+ * 判断是否是 ms 时间类型
+ * https://github.com/vercel/ms
+ * @param value
+ */
+export declare function isMSTime(value: string | number): value is MSTime;

package/date/msTimeToMilliseconds.d.ts

@@ -0,0 +1,12 @@
+import { default as ms } from 'ms';
+/**
+ * 毫秒
+ */
+export type Milliseconds = number;
+export type MSTime = ms.StringValue;
+/**]
+ * ms 时间转换为毫秒
+ * value   https://github.com/vercel/ms
+ * @example '2 days', '1d', '10h',
+ */
+export declare function msTimeToMilliseconds(value: MSTime): Milliseconds;

package/date/parseTime.d.ts

@@ -0,0 +1,9 @@
+export interface ParseTime {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+}
+export declare const parseTime: (startDate: Date, endDate: Date) => ParseTime;

package/date/stringTime.d.ts

@@ -0,0 +1,3 @@
+import { ParseTimeConfig } from './formatPassTime';
+import { ParseTime } from './parseTime';
+export declare const stringTime: (key: keyof ParseTime, value: number, config?: ParseTimeConfig) => string;

package/date/unixTimestamp.d.ts

@@ -0,0 +1,5 @@
+/**
+ * unix 时间戳
+ * @returns
+ */
+export declare const unixTimestamp: () => number;

package/function/debounce.d.ts

@@ -0,0 +1,2 @@
+import { AnyFunction } from '../types';
+export declare const debounce: <Func extends AnyFunction>(func: Func, waitMilliseconds?: number) => ((this: ThisParameterType<Func>, ...args: Parameters<Func>) => void);

package/function/emptyFunction.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 空函数
+ */
+export declare const emptyFunction: () => void;

package/function/index.d.ts

@@ -0,0 +1,4 @@
+export { debounce } from './debounce';
+export { emptyFunction, emptyFunction as noop } from './emptyFunction';
+export { once } from './once';
+export { throttle } from './throttle';

package/function/once.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 创建一个只执行一次的函数，后续调用将返回第一次执行的结果
+ * 适用于初始化函数、资源加载等只需要执行一次的场景
+ *
+ * @template F - 被包装的函数类型，必须是无参数函数
+ * @param func - 需要限制只执行一次的函数
+ * @returns 包装后的函数，与原函数类型相同
+ * @example
+ * // 基础用法
+ * const initialize = once(() => {
+ *   console.log('初始化');
+ *   return '完成';
+ * });
+ * initialize(); // 输出 '初始化' 并返回 '完成'
+ * initialize(); // 直接返回 '完成'，不执行函数体
+ * @example
+ * // 带返回值的场景
+ * const getConfig = once(() => {
+ *   return fetch('/config').then(res => res.json());
+ * });
+ * // 多次调用只会发起一次请求
+ * getConfig();
+ * getConfig();
+ * @note 该实现仅支持无参数函数，如需处理带参数的函数，请使用其他实现
+ * @note 第一次执行的结果会被缓存，后续调用返回相同结果
+ */
+export declare function once<F extends () => any>(func: F): F;

package/function/throttle.d.ts

@@ -0,0 +1,30 @@
+import { AnyFunction } from '../types';
+/**
+ * 创建一个节流函数，确保函数在指定时间间隔内最多执行一次
+ * 与防抖不同，节流会定期执行函数，而非等待最后一次调用后执行，适用于限制高频事件（如滚动、调整大小）的触发频率
+ *
+ * @template Func - 被节流的函数类型
+ * @param func - 需要节流的函数
+ * @param timeFrame - 时间间隔（毫秒），在此期间函数最多执行一次
+ * @returns 节流后的函数
+ * @example
+ * // 基础用法
+ * const handleScroll = throttle(() => {
+ *   console.log('滚动位置:', window.scrollY);
+ * }, 100);
+ * window.addEventListener('scroll', handleScroll);
+ * @example
+ * // 带参数和this上下文
+ * const logger = {
+ *   prefix: 'Log:',
+ *   log: throttle(function(message: string) {
+ *     console.log(this.prefix, message);
+ *   }, 200)
+ * };
+ * logger.log('Hello');
+ * logger.log('World'); // 200ms内只会执行一次
+ * @note 节流函数会忽略在时间间隔内的调用，不累积执行
+ * @note 首次调用会立即执行，之后按时间间隔限制
+ * @warning 确保timeFrame为正整数，否则可能导致意外行为
+ */
+export declare const throttle: <Func extends AnyFunction>(func: Func, timeFrame: number) => (this: ThisParameterType<Func>, ...args: Parameters<Func>) => void;