twcpt 0.0.2

package/dist/utils/helper/number.d.ts

@@ -0,0 +1,250 @@
+/**
+ * 数字处理工具函数
+ */
+/**
+ * 生成指定范围的随机整数
+ * @param min 最小值（包含）
+ * @param max 最大值（包含）
+ * @returns 随机整数
+ * @example
+ * random(1, 10) // 1-10之间的随机整数
+ */
+export declare function random(min: number, max: number): number;
+/**
+ * 生成指定范围的随机浮点数
+ * @param min 最小值（包含）
+ * @param max 最大值（不包含）
+ * @param decimals 小数位数，默认 2
+ * @returns 随机浮点数
+ * @example
+ * randomFloat(1, 10, 2) // 1.00-10.00之间的随机数
+ */
+export declare function randomFloat(min: number, max: number, decimals?: number): number;
+/**
+ * 生成数字序列
+ * @param start 起始值
+ * @param end 结束值（包含）
+ * @param step 步长，默认 1
+ * @returns 数字数组
+ * @example
+ * range(1, 5) // [1, 2, 3, 4, 5]
+ * range(0, 10, 2) // [0, 2, 4, 6, 8, 10]
+ */
+export declare function range(start: number, end: number, step?: number): number[];
+/**
+ * 限制数字在指定范围内
+ * @param value 数值
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 限制后的数值
+ * @example
+ * clamp(15, 0, 10) // 10
+ * clamp(-5, 0, 10) // 0
+ * clamp(5, 0, 10) // 5
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * 精确加法（解决 JavaScript 精度问题）
+ * @param num1 加数1
+ * @param num2 加数2
+ * @returns 和
+ * @example
+ * add(0.1, 0.2) // 0.3 (而不是 0.30000000000000004)
+ */
+export declare function add(num1: number, num2: number): number;
+/**
+ * 精确减法
+ * @param num1 被减数
+ * @param num2 减数
+ * @returns 差
+ * @example
+ * subtract(0.3, 0.1) // 0.2
+ */
+export declare function subtract(num1: number, num2: number): number;
+/**
+ * 精确乘法
+ * @param num1 乘数1
+ * @param num2 乘数2
+ * @returns 积
+ * @example
+ * multiply(0.1, 0.2) // 0.02
+ */
+export declare function multiply(num1: number, num2: number): number;
+/**
+ * 精确除法
+ * @param num1 被除数
+ * @param num2 除数
+ * @returns 商
+ * @example
+ * divide(0.3, 0.1) // 3
+ */
+export declare function divide(num1: number, num2: number): number;
+/**
+ * 精确舍入
+ * @param value 数值
+ * @param decimals 保留小数位数
+ * @returns 舍入后的数值
+ * @example
+ * round(1.2345, 2) // 1.23
+ */
+export declare function round(value: number, decimals?: number): number;
+/**
+ * 向上舍入
+ * @param value 数值
+ * @param decimals 保留小数位数
+ * @returns 舍入后的数值
+ * @example
+ * ceil(1.2345, 2) // 1.24
+ */
+export declare function ceil(value: number, decimals?: number): number;
+/**
+ * 向下舍入
+ * @param value 数值
+ * @param decimals 保留小数位数
+ * @returns 舍入后的数值
+ * @example
+ * floor(1.2345, 2) // 1.23
+ */
+export declare function floor(value: number, decimals?: number): number;
+/**
+ * 修复 toFixed 的问题（银行家舍入法）
+ * @param value 数值
+ * @param decimals 保留小数位数
+ * @returns 格式化后的字符串
+ * @example
+ * toFixed(1.2345, 2) // '1.23'
+ */
+export declare function toFixed(value: number, decimals?: number): string;
+/**
+ * 计算百分比
+ * @param value 当前值
+ * @param total 总值
+ * @param decimals 小数位数，默认 2
+ * @returns 百分比数值（0-100）
+ * @example
+ * percentage(25, 100) // 25
+ * percentage(1, 3, 2) // 33.33
+ */
+export declare function percentage(value: number, total: number, decimals?: number): number;
+/**
+ * 百分比转小数
+ * @param percent 百分比（0-100）
+ * @returns 小数（0-1）
+ * @example
+ * percentToDecimal(25) // 0.25
+ */
+export declare function percentToDecimal(percent: number): number;
+/**
+ * 小数转百分比
+ * @param decimal 小数（0-1）
+ * @returns 百分比（0-100）
+ * @example
+ * decimalToPercent(0.25) // 25
+ */
+export declare function decimalToPercent(decimal: number): number;
+/**
+ * 数字补零
+ * @param num 数字
+ * @param length 总长度
+ * @returns 补零后的字符串
+ * @example
+ * padZero(5, 3) // '005'
+ */
+export declare function padZero(num: number, length?: number): string;
+/**
+ * 数字转中文
+ * @param num 数字（0-99999）
+ * @returns 中文数字
+ * @example
+ * toChineseNumber(12345) // '一万二千三百四十五'
+ */
+export declare function toChineseNumber(num: number): string;
+/**
+ * 数字转大写金额
+ * @param num 金额
+ * @returns 大写金额
+ * @example
+ * toChineseMoney(123.45) // '壹佰贰拾叁元肆角伍分'
+ */
+export declare function toChineseMoney(num: number): string;
+/**
+ * 判断是否为偶数
+ * @param num 数字
+ * @returns 是否为偶数
+ * @example
+ * isEven(4) // true
+ */
+export declare function isEven(num: number): boolean;
+/**
+ * 判断是否为奇数
+ * @param num 数字
+ * @returns 是否为奇数
+ * @example
+ * isOdd(3) // true
+ */
+export declare function isOdd(num: number): boolean;
+/**
+ * 判断是否为质数
+ * @param num 数字
+ * @returns 是否为质数
+ * @example
+ * isPrime(7) // true
+ */
+export declare function isPrime(num: number): boolean;
+/**
+ * 判断是否在范围内
+ * @param value 数值
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 是否在范围内
+ * @example
+ * inRange(5, 0, 10) // true
+ */
+export declare function inRange(value: number, min: number, max: number): boolean;
+/**
+ * 求绝对值
+ * @param num 数字
+ * @returns 绝对值
+ */
+export declare function abs(num: number): number;
+/**
+ * 求平方根
+ * @param num 数字
+ * @returns 平方根
+ */
+export declare function sqrt(num: number): number;
+/**
+ * 求幂
+ * @param base 底数
+ * @param exponent 指数
+ * @returns 幂
+ * @example
+ * pow(2, 3) // 8
+ */
+export declare function pow(base: number, exponent: number): number;
+/**
+ * 求阶乘
+ * @param num 数字
+ * @returns 阶乘
+ * @example
+ * factorial(5) // 120
+ */
+export declare function factorial(num: number): number;
+/**
+ * 求最大公约数
+ * @param a 数字a
+ * @param b 数字b
+ * @returns 最大公约数
+ * @example
+ * gcd(12, 8) // 4
+ */
+export declare function gcd(a: number, b: number): number;
+/**
+ * 求最小公倍数
+ * @param a 数字a
+ * @param b 数字b
+ * @returns 最小公倍数
+ * @example
+ * lcm(12, 8) // 24
+ */
+export declare function lcm(a: number, b: number): number;

package/dist/utils/helper/object.d.ts

@@ -0,0 +1,240 @@
+/**
+ * 对象处理工具函数
+ */
+/**
+ * 深拷贝对象
+ * @param obj 要拷贝的对象
+ * @returns 深拷贝后的对象
+ * @example
+ * const obj = { a: 1, b: { c: 2 } };
+ * const copied = deepClone(obj);
+ * copied.b.c = 3; // 不影响原对象
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * 浅拷贝对象
+ * @param obj 要拷贝的对象
+ * @returns 浅拷贝后的对象
+ * @example
+ * const obj = { a: 1, b: { c: 2 } };
+ * const copied = shallowClone(obj);
+ */
+export declare function shallowClone<T>(obj: T): T;
+/**
+ * 深度合并对象
+ * @param target 目标对象
+ * @param sources 源对象数组
+ * @returns 合并后的对象
+ * @example
+ * deepMerge({ a: 1, b: { c: 2 } }, { b: { d: 3 }, e: 4 })
+ * // { a: 1, b: { c: 2, d: 3 }, e: 4 }
+ */
+export declare function deepMerge<T extends Record<string, any>>(...sources: Partial<T>[]): T;
+/**
+ * 浅合并对象
+ * @param target 目标对象
+ * @param sources 源对象数组
+ * @returns 合并后的对象
+ * @example
+ * shallowMerge({ a: 1 }, { b: 2 }, { c: 3 })
+ * // { a: 1, b: 2, c: 3 }
+ */
+export declare function shallowMerge<T extends Record<string, any>>(...sources: Partial<T>[]): T;
+/**
+ * 选取对象的指定属性
+ * @param obj 源对象
+ * @param keys 要选取的属性名数组
+ * @returns 只包含指定属性的新对象
+ * @example
+ * pick({ a: 1, b: 2, c: 3 }, ['a', 'c'])
+ * // { a: 1, c: 3 }
+ */
+export declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * 排除对象的指定属性
+ * @param obj 源对象
+ * @param keys 要排除的属性名数组
+ * @returns 排除指定属性后的新对象
+ * @example
+ * omit({ a: 1, b: 2, c: 3 }, ['b'])
+ * // { a: 1, c: 3 }
+ */
+export declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * 获取对象深层属性
+ * @param obj 对象
+ * @param path 属性路径，如 'user.info.name'
+ * @param defaultValue 默认值
+ * @returns 属性值或默认值
+ * @example
+ * get({ user: { info: { name: 'Tom' } } }, 'user.info.name')
+ * // 'Tom'
+ * get({ user: {} }, 'user.info.name', 'Unknown')
+ * // 'Unknown'
+ */
+export declare function get<T = any>(obj: any, path: string, defaultValue?: T): T;
+/**
+ * 设置对象深层属性
+ * @param obj 对象
+ * @param path 属性路径，如 'user.info.name'
+ * @param value 要设置的值
+ * @example
+ * const obj = {};
+ * set(obj, 'user.info.name', 'Tom');
+ * // obj 变为 { user: { info: { name: 'Tom' } } }
+ */
+export declare function set(obj: any, path: string, value: any): void;
+/**
+ * 判断对象是否有指定属性（支持深层路径）
+ * @param obj 对象
+ * @param path 属性路径，如 'user.info.name'
+ * @returns 是否存在该属性
+ * @example
+ * has({ user: { info: { name: 'Tom' } } }, 'user.info.name')
+ * // true
+ * has({ user: {} }, 'user.info.name')
+ * // false
+ */
+export declare function has(obj: any, path: string): boolean;
+/**
+ * 判断对象是否为空
+ * @param obj 对象
+ * @returns 是否为空
+ * @example
+ * isEmpty({}) // true
+ * isEmpty({ a: 1 }) // false
+ * isEmpty(null) // true
+ * isEmpty([]) // true
+ */
+export declare function isEmpty(obj: any): boolean;
+/**
+ * 判断是否为普通对象
+ * @param obj 任意值
+ * @returns 是否为普通对象
+ * @example
+ * isPlainObject({}) // true
+ * isPlainObject(new Date()) // false
+ * isPlainObject([]) // false
+ */
+export declare function isPlainObject(obj: any): obj is Record<string, any>;
+/**
+ * 判断两个对象是否相等（深度比较）
+ * @param obj1 对象1
+ * @param obj2 对象2
+ * @returns 是否相等
+ * @example
+ * isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })
+ * // true
+ */
+export declare function isEqual(obj1: any, obj2: any): boolean;
+/**
+ * 对象键名转驼峰
+ * @param obj 对象
+ * @returns 键名转为驼峰的新对象
+ * @example
+ * keysToCamelCase({ user_name: 'Tom', user_age: 20 })
+ * // { userName: 'Tom', userAge: 20 }
+ */
+export declare function keysToCamelCase<T extends Record<string, any>>(obj: T): any;
+/**
+ * 对象键名转下划线
+ * @param obj 对象
+ * @returns 键名转为下划线的新对象
+ * @example
+ * keysToUnderlineCase({ userName: 'Tom', userAge: 20 })
+ * // { user_name: 'Tom', user_age: 20 }
+ */
+export declare function keysToUnderlineCase<T extends Record<string, any>>(obj: T): any;
+/**
+ * 对象转 URL 查询字符串
+ * @param obj 对象
+ * @returns URL 查询字符串
+ * @example
+ * toQueryString({ name: 'Tom', age: 20 })
+ * // 'name=Tom&age=20'
+ */
+export declare function toQueryString(obj: Record<string, any>): string;
+/**
+ * URL 查询字符串转对象
+ * @param queryString URL 查询字符串
+ * @returns 对象
+ * @example
+ * fromQueryString('name=Tom&age=20')
+ * // { name: 'Tom', age: '20' }
+ */
+export declare function fromQueryString(queryString: string): Record<string, any>;
+/**
+ * 过滤对象的属性（根据值）
+ * @param obj 对象
+ * @param predicate 判断函数
+ * @returns 过滤后的新对象
+ * @example
+ * filterValues({ a: 1, b: 2, c: 3 }, value => value > 1)
+ * // { b: 2, c: 3 }
+ */
+export declare function filterValues<T extends Record<string, any>>(obj: T, predicate: (value: any, key: string) => boolean): Partial<T>;
+/**
+ * 移除对象中的空值（null、undefined、空字符串）
+ * @param obj 对象
+ * @param removeEmptyString 是否移除空字符串，默认 true
+ * @returns 移除空值后的新对象
+ * @example
+ * removeEmpty({ a: 1, b: null, c: undefined, d: '', e: 0 })
+ * // { a: 1, e: 0 }
+ */
+export declare function removeEmpty<T extends Record<string, any>>(obj: T, removeEmptyString?: boolean): Partial<T>;
+/**
+ * 扁平化嵌套对象
+ * @param obj 嵌套对象
+ * @param prefix 前缀
+ * @returns 扁平化后的对象
+ * @example
+ * flattenObject({ a: 1, b: { c: 2, d: { e: 3 } } })
+ * // { a: 1, 'b.c': 2, 'b.d.e': 3 }
+ */
+export declare function flattenObject(obj: Record<string, any>, prefix?: string): Record<string, any>;
+/**
+ * 反扁平化对象
+ * @param obj 扁平对象
+ * @returns 嵌套对象
+ * @example
+ * unflattenObject({ a: 1, 'b.c': 2, 'b.d.e': 3 })
+ * // { a: 1, b: { c: 2, d: { e: 3 } } }
+ */
+export declare function unflattenObject(obj: Record<string, any>): Record<string, any>;
+/**
+ * 反转对象的键值
+ * @param obj 对象
+ * @returns 键值反转后的对象
+ * @example
+ * invert({ a: 1, b: 2, c: 3 })
+ * // { '1': 'a', '2': 'b', '3': 'c' }
+ */
+export declare function invert<T extends Record<string, string | number>>(obj: T): Record<string, string>;
+/**
+ * 获取对象所有值的数组
+ * @param obj 对象
+ * @returns 值的数组
+ * @example
+ * values({ a: 1, b: 2, c: 3 })
+ * // [1, 2, 3]
+ */
+export declare function values<T>(obj: Record<string, T>): T[];
+/**
+ * 获取对象所有键的数组
+ * @param obj 对象
+ * @returns 键的数组
+ * @example
+ * keys({ a: 1, b: 2, c: 3 })
+ * // ['a', 'b', 'c']
+ */
+export declare function keys<T extends Record<string, any>>(obj: T): Array<keyof T>;
+/**
+ * 获取对象所有键值对的数组
+ * @param obj 对象
+ * @returns 键值对数组
+ * @example
+ * entries({ a: 1, b: 2, c: 3 })
+ * // [['a', 1], ['b', 2], ['c', 3]]
+ */
+export declare function entries<T extends Record<string, any>>(obj: T): Array<[keyof T, T[keyof T]]>;

package/dist/utils/helper/perf.d.ts

@@ -0,0 +1,231 @@
+/**
+ * 性能优化工具函数
+ */
+/**
+ * 防抖函数：延迟执行，在规定时间内如果再次触发则重新计时
+ * @param fn 要执行的函数
+ * @param delay 延迟时间（毫秒）
+ * @param immediate 是否立即执行，默认 false
+ * @returns 防抖后的函数
+ * @example
+ * // 搜索框输入
+ * const handleSearch = debounce((keyword) => {
+ *   console.log('搜索:', keyword);
+ * }, 300);
+ *
+ * // 自动保存
+ * const autoSave = debounce(() => {
+ *   console.log('保存数据');
+ * }, 1000);
+ */
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay?: number, immediate?: boolean): {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+};
+/**
+ * 节流函数：在规定时间内只执行一次
+ * @param fn 要执行的函数
+ * @param delay 间隔时间（毫秒）
+ * @param options 配置选项
+ * @returns 节流后的函数
+ * @example
+ * // 滚动事件
+ * const handleScroll = throttle(() => {
+ *   console.log('滚动位置:', window.pageYOffset);
+ * }, 100);
+ *
+ * // 窗口resize
+ * const handleResize = throttle(() => {
+ *   console.log('窗口大小:', window.innerWidth);
+ * }, 200);
+ */
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, delay?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+};
+/**
+ * 只执行一次的函数
+ * @param fn 要执行的函数
+ * @returns 包装后的函数
+ * @example
+ * const initialize = once(() => {
+ *   console.log('初始化，只执行一次');
+ * });
+ *
+ * initialize(); // 输出：初始化，只执行一次
+ * initialize(); // 不会执行
+ */
+export declare function once<T extends (...args: any[]) => any>(fn: T): (...args: Parameters<T>) => ReturnType<T> | undefined;
+/**
+ * 延迟执行函数
+ * @param fn 要执行的函数
+ * @param delay 延迟时间（毫秒）
+ * @returns Promise
+ * @example
+ * await delay(1000); // 延迟1秒
+ * console.log('1秒后执行');
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * 睡眠函数（async/await 友好）
+ * @param ms 睡眠时间（毫秒）
+ * @returns Promise
+ * @example
+ * await sleep(1000);
+ * console.log('1秒后执行');
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * 重试函数
+ * @param fn 要执行的异步函数
+ * @param options 重试配置
+ * @returns Promise
+ * @example
+ * const result = await retry(
+ *   async () => await fetch('/api/data'),
+ *   { times: 3, delay: 1000 }
+ * );
+ */
+export declare function retry<T>(fn: () => Promise<T>, options?: {
+    times?: number;
+    delay?: number;
+    onRetry?: (error: any, attempt: number) => void;
+}): Promise<T>;
+/**
+ * 超时控制
+ * @param fn 要执行的异步函数
+ * @param timeout 超时时间（毫秒）
+ * @returns Promise
+ * @example
+ * try {
+ *   const result = await withTimeout(fetchData(), 5000);
+ * } catch (error) {
+ *   console.log('请求超时');
+ * }
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeout: number): Promise<T>;
+/**
+ * 函数结果缓存（记忆化）
+ * @param fn 要缓存的函数
+ * @param resolver 生成缓存 key 的函数
+ * @returns 缓存后的函数
+ * @example
+ * const fibonacci = memoize((n: number): number => {
+ *   if (n <= 1) return n;
+ *   return fibonacci(n - 1) + fibonacci(n - 2);
+ * });
+ *
+ * fibonacci(40); // 第一次计算
+ * fibonacci(40); // 从缓存读取，速度快
+ */
+export declare function memoize<T extends (...args: any[]) => any>(fn: T, resolver?: (...args: Parameters<T>) => string): T & {
+    cache: Map<string, ReturnType<T>>;
+};
+/**
+ * 清除缓存
+ * @param fn 缓存函数
+ * @example
+ * const cachedFn = memoize(expensiveFunction);
+ * clearCache(cachedFn); // 清除所有缓存
+ */
+export declare function clearCache<T extends (...args: any[]) => any>(fn: T & {
+    cache?: Map<any, any>;
+}): void;
+/**
+ * 批处理函数：将多次调用合并为一次
+ * @param fn 要批处理的函数
+ * @param delay 等待时间（毫秒）
+ * @returns 批处理后的函数
+ * @example
+ * const batchSave = batch((items) => {
+ *   console.log('保存', items.length, '条数据');
+ * }, 100);
+ *
+ * batchSave('item1');
+ * batchSave('item2');
+ * batchSave('item3');
+ * // 100ms 后一次性保存 ['item1', 'item2', 'item3']
+ */
+export declare function batch<T>(fn: (items: T[]) => void, delay?: number): (item: T) => void;
+/**
+ * 并发控制：限制同时执行的 Promise 数量
+ * @param tasks 任务数组
+ * @param limit 并发限制数
+ * @returns Promise
+ * @example
+ * const urls = [...]; // 100个URL
+ * const results = await promiseLimit(
+ *   urls.map(url => () => fetch(url)),
+ *   5 // 同时最多5个请求
+ * );
+ */
+export declare function promiseLimit<T>(tasks: (() => Promise<T>)[], limit: number): Promise<T[]>;
+/**
+ * 串行执行 Promise
+ * @param tasks 任务数组
+ * @returns Promise
+ * @example
+ * await promiseSerial([
+ *   () => fetch('/api/1'),
+ *   () => fetch('/api/2'),
+ *   () => fetch('/api/3')
+ * ]); // 依次执行，等待前一个完成后再执行下一个
+ */
+export declare function promiseSerial<T>(tasks: (() => Promise<T>)[]): Promise<T[]>;
+/**
+ * 测量函数执行时间
+ * @param fn 要测量的函数
+ * @param label 标签
+ * @returns 包装后的函数
+ * @example
+ * const slowFunction = measureTime(() => {
+ *   // 耗时操作
+ * }, 'slowFunction');
+ *
+ * slowFunction(); // 控制台输出：slowFunction: 123.45ms
+ */
+export declare function measureTime<T extends (...args: any[]) => any>(fn: T, label?: string): T;
+/**
+ * 测量异步函数执行时间
+ * @param fn 要测量的异步函数
+ * @param label 标签
+ * @returns 包装后的函数
+ * @example
+ * const asyncFn = measureTimeAsync(async () => {
+ *   await fetchData();
+ * }, 'fetchData');
+ */
+export declare function measureTimeAsync<T extends (...args: any[]) => Promise<any>>(fn: T, label?: string): T;
+/**
+ * 请求去重：相同参数的请求只发一次
+ * @param fn 请求函数
+ * @returns 去重后的函数
+ * @example
+ * const fetchUser = dedupe(async (id) => {
+ *   return await fetch(`/api/user/${id}`);
+ * });
+ *
+ * // 同时发起多个相同请求，实际只会发一次
+ * Promise.all([
+ *   fetchUser(1),
+ *   fetchUser(1),
+ *   fetchUser(1)
+ * ]);
+ */
+export declare function dedupe<T extends (...args: any[]) => Promise<any>>(fn: T): T;
+/**
+ * RAF 节流：使用 requestAnimationFrame 实现的节流
+ * @param fn 要执行的函数
+ * @returns 节流后的函数
+ * @example
+ * const handleScroll = rafThrottle(() => {
+ *   // 滚动处理，与浏览器刷新率同步
+ * });
+ */
+export declare function rafThrottle<T extends (...args: any[]) => any>(fn: T): {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+};