@alibarbar/common 1.0.0

package/dist/object.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 对象工具函数
+ */
+/**
+ * 深拷贝对象
+ * 支持 Date、Array、RegExp、Map、Set 等特殊类型
+ * @param obj - 输入对象
+ * @returns 深拷贝后的对象
+ */
+declare function deepClone<T>(obj: T): T;
+/**
+ * 对象合并
+ * @param target - 目标对象
+ * @param sources - 源对象数组
+ * @returns 合并后的对象
+ */
+declare function merge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * 深合并对象
+ * @param target - 目标对象
+ * @param sources - 源对象数组
+ * @returns 深合并后的对象
+ */
+declare function deepMerge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * 获取对象嵌套属性值
+ * @param obj - 对象
+ * @param path - 属性路径，如 'a.b.c' 或 ['a', 'b', 'c']
+ * @param defaultValue - 默认值
+ * @returns 属性值
+ */
+declare function get<T = unknown>(obj: Record<string, unknown>, path: string | string[], defaultValue?: T): T | undefined;
+/**
+ * 设置嵌套属性值
+ * @param obj - 对象
+ * @param path - 属性路径，如 'a.b.c' 或 ['a', 'b', 'c']
+ * @param value - 要设置的值
+ * @returns 设置后的新对象（不修改原对象）
+ */
+declare function set<T extends Record<string, unknown>>(obj: T, path: string | string[], value: unknown): T;
+/**
+ * 选择指定属性
+ * @param obj - 对象
+ * @param keys - 要选择的属性键数组
+ * @returns 包含指定属性的新对象
+ */
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * 排除指定属性
+ * @param obj - 对象
+ * @param keys - 要排除的属性键数组
+ * @returns 排除指定属性后的新对象
+ */
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * 获取所有键（支持深度）
+ * @param obj - 对象
+ * @param deep - 是否深度获取，默认为 false
+ * @returns 键数组
+ */
+declare function keys<T extends Record<string, unknown>>(obj: T, deep?: boolean): string[];
+/**
+ * 获取所有值（支持深度）
+ * @param obj - 对象
+ * @param deep - 是否深度获取，默认为 false
+ * @returns 值数组
+ */
+declare function values<T extends Record<string, unknown>>(obj: T, deep?: boolean): unknown[];
+/**
+ * 键映射
+ * @param obj - 对象
+ * @param fn - 键转换函数
+ * @returns 键映射后的新对象
+ */
+declare function mapKeys<T extends Record<string, unknown>>(obj: T, fn: (key: string, value: unknown) => string): Record<string, unknown>;
+/**
+ * 值映射
+ * @param obj - 对象
+ * @param fn - 值转换函数
+ * @returns 值映射后的新对象
+ */
+declare function mapValues<T extends Record<string, unknown>, R>(obj: T, fn: (value: unknown, key: string) => R): Record<string, R>;
+/**
+ * 键值反转
+ * @param obj - 对象
+ * @returns 键值反转后的新对象
+ */
+declare function invert<T extends Record<string, string | number>>(obj: T): Record<string, string>;
+/**
+ * 设置默认值
+ * @param obj - 对象
+ * @param defaults - 默认值对象
+ * @returns 合并默认值后的新对象
+ */
+declare function defaults<T extends Record<string, unknown>>(obj: Partial<T>, ...defaults: Partial<T>[]): T;
+/**
+ * 判断对象是否为空
+ * @param obj - 对象
+ * @returns 是否为空
+ */
+declare function isEmptyObject(obj: Record<string, unknown>): boolean;
+/**
+ * 深度比较两个对象
+ * @param obj1 - 第一个对象
+ * @param obj2 - 第二个对象
+ * @returns 是否相等
+ */
+declare function isEqual<T>(obj1: T, obj2: T): boolean;
+/**
+ * 对象转换
+ * @param obj - 对象
+ * @param iteratee - 转换函数
+ * @param accumulator - 累加器，默认为空对象
+ * @returns 转换后的对象
+ */
+declare function transform<T extends Record<string, unknown>, R extends Record<string, unknown>>(obj: T, iteratee: (result: R, value: unknown, key: string) => void, accumulator?: R): R;
+/**
+ * 条件选择属性
+ * @param obj - 对象
+ * @param predicate - 条件函数
+ * @returns 满足条件的属性组成的新对象
+ */
+declare function pickBy<T extends Record<string, unknown>>(obj: T, predicate: (value: unknown, key: string) => boolean): Partial<T>;
+/**
+ * 条件排除属性
+ * @param obj - 对象
+ * @param predicate - 条件函数
+ * @returns 不满足条件的属性组成的新对象
+ */
+declare function omitBy<T extends Record<string, unknown>>(obj: T, predicate: (value: unknown, key: string) => boolean): Partial<T>;
+
+export { deepClone, deepMerge, defaults, get, invert, isEmptyObject, isEqual, keys, mapKeys, mapValues, merge, omit, omitBy, pick, pickBy, set, transform, values };

package/dist/object.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var chunk27UDDVLZ_js = require('./chunk-27UDDVLZ.js');
+
+
+
+Object.defineProperty(exports, "deepClone", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.deepClone; }
+});
+Object.defineProperty(exports, "deepMerge", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.deepMerge; }
+});
+Object.defineProperty(exports, "defaults", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.defaults; }
+});
+Object.defineProperty(exports, "get", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.get; }
+});
+Object.defineProperty(exports, "invert", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.invert; }
+});
+Object.defineProperty(exports, "isEmptyObject", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.isEmptyObject; }
+});
+Object.defineProperty(exports, "isEqual", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.isEqual; }
+});
+Object.defineProperty(exports, "keys", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.keys; }
+});
+Object.defineProperty(exports, "mapKeys", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.mapKeys; }
+});
+Object.defineProperty(exports, "mapValues", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.mapValues; }
+});
+Object.defineProperty(exports, "merge", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.merge; }
+});
+Object.defineProperty(exports, "omit", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.omit; }
+});
+Object.defineProperty(exports, "omitBy", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.omitBy; }
+});
+Object.defineProperty(exports, "pick", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.pick; }
+});
+Object.defineProperty(exports, "pickBy", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.pickBy; }
+});
+Object.defineProperty(exports, "set", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.set; }
+});
+Object.defineProperty(exports, "transform", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.transform; }
+});
+Object.defineProperty(exports, "values", {
+  enumerable: true,
+  get: function () { return chunk27UDDVLZ_js.values; }
+});
+//# sourceMappingURL=object.js.map
+//# sourceMappingURL=object.js.map

package/dist/object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"object.js"}

package/dist/object.mjs

@@ -0,0 +1,3 @@
+export { deepClone, deepMerge, defaults, get, invert, isEmptyObject, isEqual, keys, mapKeys, mapValues, merge, omit, omitBy, pick, pickBy, set, transform, values } from './chunk-JBLX27WD.mjs';
+//# sourceMappingURL=object.mjs.map
+//# sourceMappingURL=object.mjs.map

package/dist/object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"object.mjs"}

package/dist/performance.d.mts

@@ -0,0 +1,85 @@
+/**
+ * 性能工具函数
+ */
+/**
+ * 防抖函数
+ * @param fn - 要防抖的函数
+ * @param delay - 延迟时间（毫秒）
+ * @returns 防抖后的函数
+ */
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * 节流函数
+ * @param fn - 要节流的函数
+ * @param delay - 延迟时间（毫秒）
+ * @returns 节流后的函数
+ */
+declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * 函数记忆化
+ * @param fn - 要记忆化的函数
+ * @param keyFn - 缓存键生成函数，可选
+ * @returns 记忆化后的函数
+ */
+declare function memoize<T extends (...args: unknown[]) => unknown>(fn: T, keyFn?: (...args: Parameters<T>) => string): T;
+/**
+ * 只执行一次的函数
+ * @param fn - 要执行的函数
+ * @returns 包装后的函数
+ */
+declare function once<T extends (...args: unknown[]) => unknown>(fn: T): T;
+/**
+ * 重试机制
+ * @param fn - 要重试的函数
+ * @param retryCount - 重试次数，默认为 3
+ * @param retryDelay - 重试延迟（毫秒），默认为 1000
+ * @returns Promise<T>
+ */
+declare function retry<T>(fn: () => Promise<T>, retryCount?: number, retryDelay?: number): Promise<T>;
+/**
+ * 超时控制
+ * @param fn - 要执行的函数
+ * @param timeout - 超时时间（毫秒）
+ * @returns Promise<T>
+ */
+declare function timeout<T>(fn: () => Promise<T>, timeout: number): Promise<T>;
+/**
+ * 批量处理
+ * @param items - 要处理的项数组
+ * @param fn - 处理函数
+ * @param batchSize - 每批大小，默认为 10
+ * @returns Promise<T[]>
+ */
+declare function batch<T, R>(items: T[], fn: (item: T) => Promise<R>, batchSize?: number): Promise<R[]>;
+/**
+ * 队列处理
+ */
+declare class Queue<T> {
+    private items;
+    private processing;
+    private processor?;
+    /**
+     * 添加项到队列
+     * @param item - 要添加的项
+     */
+    enqueue(item: T): void;
+    /**
+     * 设置处理函数并开始处理
+     * @param processor - 处理函数
+     */
+    start(processor: (item: T) => Promise<void>): Promise<void>;
+    /**
+     * 处理队列
+     */
+    private processItems;
+    /**
+     * 清空队列
+     */
+    clear(): void;
+    /**
+     * 获取队列长度
+     */
+    get length(): number;
+}
+
+export { Queue, batch, debounce, memoize, once, retry, throttle, timeout };

package/dist/performance.d.ts

@@ -0,0 +1,85 @@
+/**
+ * 性能工具函数
+ */
+/**
+ * 防抖函数
+ * @param fn - 要防抖的函数
+ * @param delay - 延迟时间（毫秒）
+ * @returns 防抖后的函数
+ */
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * 节流函数
+ * @param fn - 要节流的函数
+ * @param delay - 延迟时间（毫秒）
+ * @returns 节流后的函数
+ */
+declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * 函数记忆化
+ * @param fn - 要记忆化的函数
+ * @param keyFn - 缓存键生成函数，可选
+ * @returns 记忆化后的函数
+ */
+declare function memoize<T extends (...args: unknown[]) => unknown>(fn: T, keyFn?: (...args: Parameters<T>) => string): T;
+/**
+ * 只执行一次的函数
+ * @param fn - 要执行的函数
+ * @returns 包装后的函数
+ */
+declare function once<T extends (...args: unknown[]) => unknown>(fn: T): T;
+/**
+ * 重试机制
+ * @param fn - 要重试的函数
+ * @param retryCount - 重试次数，默认为 3
+ * @param retryDelay - 重试延迟（毫秒），默认为 1000
+ * @returns Promise<T>
+ */
+declare function retry<T>(fn: () => Promise<T>, retryCount?: number, retryDelay?: number): Promise<T>;
+/**
+ * 超时控制
+ * @param fn - 要执行的函数
+ * @param timeout - 超时时间（毫秒）
+ * @returns Promise<T>
+ */
+declare function timeout<T>(fn: () => Promise<T>, timeout: number): Promise<T>;
+/**
+ * 批量处理
+ * @param items - 要处理的项数组
+ * @param fn - 处理函数
+ * @param batchSize - 每批大小，默认为 10
+ * @returns Promise<T[]>
+ */
+declare function batch<T, R>(items: T[], fn: (item: T) => Promise<R>, batchSize?: number): Promise<R[]>;
+/**
+ * 队列处理
+ */
+declare class Queue<T> {
+    private items;
+    private processing;
+    private processor?;
+    /**
+     * 添加项到队列
+     * @param item - 要添加的项
+     */
+    enqueue(item: T): void;
+    /**
+     * 设置处理函数并开始处理
+     * @param processor - 处理函数
+     */
+    start(processor: (item: T) => Promise<void>): Promise<void>;
+    /**
+     * 处理队列
+     */
+    private processItems;
+    /**
+     * 清空队列
+     */
+    clear(): void;
+    /**
+     * 获取队列长度
+     */
+    get length(): number;
+}
+
+export { Queue, batch, debounce, memoize, once, retry, throttle, timeout };

package/dist/performance.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var chunkJQZBPAPO_js = require('./chunk-JQZBPAPO.js');
+
+
+
+Object.defineProperty(exports, "Queue", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.Queue; }
+});
+Object.defineProperty(exports, "batch", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.batch; }
+});
+Object.defineProperty(exports, "debounce", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.debounce; }
+});
+Object.defineProperty(exports, "memoize", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.memoize; }
+});
+Object.defineProperty(exports, "once", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.once; }
+});
+Object.defineProperty(exports, "retry", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.retry; }
+});
+Object.defineProperty(exports, "throttle", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.throttle; }
+});
+Object.defineProperty(exports, "timeout", {
+  enumerable: true,
+  get: function () { return chunkJQZBPAPO_js.timeout; }
+});
+//# sourceMappingURL=performance.js.map
+//# sourceMappingURL=performance.js.map

package/dist/performance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"performance.js"}

package/dist/performance.mjs

@@ -0,0 +1,3 @@
+export { Queue, batch, debounce, memoize, once, retry, throttle, timeout } from './chunk-LBHBNPNJ.mjs';
+//# sourceMappingURL=performance.mjs.map
+//# sourceMappingURL=performance.mjs.map

package/dist/performance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"performance.mjs"}

package/dist/storage.d.mts

@@ -0,0 +1,176 @@
+import { RSAKeyPair } from './crypto.mjs';
+
+/**
+ * 存储工具函数
+ */
+
+/**
+ * 存储配置选项
+ */
+interface StorageOptions {
+    /** RSA公钥（用于加密） */
+    publicKey?: CryptoKey;
+    /** RSA私钥（用于解密） */
+    privateKey?: CryptoKey;
+    /** 是否启用加密，默认为 true */
+    encrypt?: boolean;
+}
+/**
+ * 设置全局RSA密钥对
+ * @param keyPair - RSA密钥对
+ */
+declare function setStorageKeyPair(keyPair: RSAKeyPair): void;
+/**
+ * 获取全局密钥对
+ * @returns 全局密钥对或null
+ */
+declare function getStorageKeyPair(): RSAKeyPair | null;
+/**
+ * localStorage封装（支持过期时间和RSA加密）
+ */
+declare const localStorage: {
+    /**
+     * 设置值
+     * @param key - 键
+     * @param value - 值
+     * @param options - 选项（过期时间、密钥等）
+     * @returns Promise<void>
+     */
+    set<T>(key: string, value: T, options?: {
+        expiry?: number;
+        publicKey?: CryptoKey;
+    }): Promise<void>;
+    /**
+     * 获取值
+     * @param key - 键
+     * @param options - 选项（默认值、私钥等）
+     * @returns Promise<T | undefined> 值或默认值
+     */
+    get<T>(key: string, options?: {
+        defaultValue?: T;
+        privateKey?: CryptoKey;
+    }): Promise<T | undefined>;
+    /**
+     * 移除值
+     * @param key - 键
+     */
+    remove(key: string): void;
+    /**
+     * 清空所有值
+     */
+    clear(): void;
+    /**
+     * 获取所有键
+     * @returns 键数组
+     */
+    keys(): string[];
+};
+/**
+ * sessionStorage封装（支持RSA加密）
+ */
+declare const sessionStorage: {
+    /**
+     * 设置值
+     * @param key - 键
+     * @param value - 值
+     * @param options - 选项（公钥等）
+     * @returns Promise<void>
+     */
+    set<T>(key: string, value: T, options?: {
+        publicKey?: CryptoKey;
+    }): Promise<void>;
+    /**
+     * 获取值
+     * @param key - 键
+     * @param options - 选项（默认值、私钥等）
+     * @returns Promise<T | undefined> 值或默认值
+     */
+    get<T>(key: string, options?: {
+        defaultValue?: T;
+        privateKey?: CryptoKey;
+    }): Promise<T | undefined>;
+    /**
+     * 移除值
+     * @param key - 键
+     */
+    remove(key: string): void;
+    /**
+     * 清空所有值
+     */
+    clear(): void;
+};
+/**
+ * Cookie操作封装
+ */
+declare const cookie: {
+    /**
+     * 设置Cookie
+     * @param key - 键
+     * @param value - 值
+     * @param options - Cookie选项
+     */
+    set(key: string, value: string, options?: {
+        expires?: number | Date;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        sameSite?: "strict" | "lax" | "none";
+    }): void;
+    /**
+     * 获取Cookie
+     * @param key - 键
+     * @returns Cookie值
+     */
+    get(key: string): string | undefined;
+    /**
+     * 移除Cookie
+     * @param key - 键
+     * @param options - Cookie选项
+     */
+    remove(key: string, options?: {
+        path?: string;
+        domain?: string;
+    }): void;
+    /**
+     * 获取所有Cookie
+     * @returns Cookie对象
+     */
+    getAll(): Record<string, string>;
+};
+/**
+ * 统一存储接口（自动选择存储方式，支持RSA加密）
+ */
+declare const storage: {
+    /**
+     * 设置值（优先使用localStorage，失败则使用sessionStorage）
+     * @param key - 键
+     * @param value - 值
+     * @param options - 选项（过期时间、公钥等）
+     * @returns Promise<void>
+     */
+    set<T>(key: string, value: T, options?: {
+        expiry?: number;
+        publicKey?: CryptoKey;
+    }): Promise<void>;
+    /**
+     * 获取值
+     * @param key - 键
+     * @param options - 选项（默认值、私钥等）
+     * @returns Promise<T | undefined> 值或默认值
+     */
+    get<T>(key: string, options?: {
+        defaultValue?: T;
+        privateKey?: CryptoKey;
+    }): Promise<T | undefined>;
+    /**
+     * 移除值
+     * @param key - 键
+     */
+    remove(key: string): void;
+    /**
+     * 清空所有值
+     */
+    clear(): void;
+};
+
+export { type StorageOptions, cookie, getStorageKeyPair, localStorage, sessionStorage, setStorageKeyPair, storage };