@aiao/utils 0.0.1

package/indexing/fractional-indexing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 因为原来库编译有问题，拷贝原来来用 https://github.com/rocicorp/fractional-indexing
+ */
+export declare const BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+ * @param a
+ * @param b
+ * @param digits
+ * @return {string}
+ */
+export declare function generateKeyBetween(a: string | null | undefined, b: string | null | undefined, digits?: string): string;
+/**
+ * same preconditions as generateKeysBetween.
+ * n >= 0.
+ * Returns an array of n distinct keys in sorted order.
+ * If a and b are both null, returns [a0, a1, ...]
+ * If one or the other is null, returns consecutive "integer"
+ * keys.  Otherwise, returns relatively short keys between
+ * a and b.
+ * @param a
+ * @param b
+ * @param n
+ * @param digits
+ * @return {string[]}
+ */
+export declare function generateKeysBetween(a: string | null | undefined, b: string | null | undefined, n: number, digits?: string): string[];

package/number/canBeNumber.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 检查值是否可以安全地转换为数字
+ * 使用parseFloat()进行转换尝试，对于可以解析为有效数字的值返回true
+ * 特别注意：空字符串('')、true、false等特殊值的处理
+ *
+ * @param value - 要检查的值，可以是任何类型
+ * @returns 如果值可以转换为数字则返回true，否则返回false
+ * @example
+ * canBeNumber('123');      // 返回 true
+ * @example
+ * canBeNumber('123.45');   // 返回 true
+ * @example
+ * canBeNumber('  123  ');  // 返回 true（忽略首尾空格）
+ * @example
+ * canBeNumber('abc');      // 返回 false
+ * @example
+ * canBeNumber('12a3');     // 返回 false
+ * @example
+ * canBeNumber(null);       // 返回 false
+ * @example
+ * canBeNumber(undefined);  // 返回 false
+ * @example
+ * canBeNumber('');         // 返回 false（空字符串不能转换为数字）
+ * @note 与isNumber()不同，该函数检查的是值是否可以被转换为数字，而非值本身是否是数字类型
+ * @note 对于BigInt类型值（如123n），会返回false，因为parseFloat无法处理BigInt
+ */
+export declare const canBeNumber: (value: any) => boolean;

package/number/index.d.ts

@@ -0,0 +1,6 @@
+export { canBeNumber } from './canBeNumber';
+export { numberStep } from './numberStep';
+export { numberStepScreenSize } from './numberStepScreenSize';
+export { numberStrip } from './numberStrip';
+export { toInt } from './toInt';
+export { tryToNumber } from './tryToNumber';

package/number/numberStep.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 将数值向上取整到最接近的步长倍数
+ * 常用于表单控件、网格布局等需要按固定间隔取值的场景
+ *
+ * @param value - 需要取整的数值
+ * @param step - 步长间隔，必须为正数
+ * @returns 向上取整后的数值，是step的整数倍
+ * @example
+ * numberStep(7, 5);   // 返回 10（5的2倍）
+ * @example
+ * numberStep(5, 5);   // 返回 5（5的1倍）
+ * @example
+ * numberStep(3.2, 2); // 返回 4（2的2倍）
+ * @example
+ * numberStep(0.5, 1); // 返回 1（1的1倍）
+ * @note 实现原理：value除以step后向上取整，再乘以step
+ * @warning step必须为正数，否则可能导致非预期结果或除以零错误
+ */
+export declare const numberStep: (value: number, step: number) => number;

package/number/numberStepScreenSize.d.ts

@@ -0,0 +1 @@
+export declare const numberStepScreenSize: (value: number, step?: number, devicePixelRatio?: number) => number;

package/number/numberStrip.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 去除数字的无用小数位，解决浮点数精度问题
+ * 通过限制有效数字位数来消除JavaScript浮点数运算产生的微小误差
+ * 例如：0.1 + 0.2 通常得到 0.30000000000000004，使用本函数可得到 0.3
+ *
+ * @param value - 需要处理的数字
+ * @param [precision=12] - 有效数字位数，默认为12位（范围1-21）
+ * @returns 处理后的数字，去除了无用的小数位
+ * @example
+ * numberStrip(0.1 + 0.2);       // 返回 0.3（解决浮点数精度问题）
+ * @example
+ * numberStrip(1.2345);          // 返回 1.2345（默认12位有效数字）
+ * @example
+ * numberStrip(12345.6789, 6);   // 返回 12345.7（6位有效数字）
+ * @example
+ * numberStrip(0.0000012345);     // 返回 0.0000012345
+ * @note 有效数字位数(precision)控制整体数字精度，而非仅小数部分
+ * @note 默认精度12位适用于大多数场景，可根据需要调整，但不应超过21位
+ * @note 内部使用Number.toPrecision()实现，然后通过parseFloat()转换回数字
+ */
+export declare const numberStrip: (value: number, precision?: number) => number;

package/number/toInt.d.ts

@@ -0,0 +1 @@
+export declare const toInt: (value: unknown) => number;

package/number/tryToNumber.d.ts

@@ -0,0 +1 @@
+export declare const tryToNumber: (value: any) => number;

package/object/deepFreeze.d.ts

@@ -0,0 +1,5 @@
+import { ReadonlyDeep } from 'type-fest';
+/**
+ * 深度冻结对象
+ */
+export declare const deepFreeze: <T extends object>(target: T) => ReadonlyDeep<T>;

package/object/flattenPathObjectToPlainObject.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 转换 扁平的路径对象到普通对象
+ * @param value
+ * @example
+ * { 'a.a': 1 } => { a: { a: 1 }}
+ */
+export declare const flattenPathObjectToPlainObject: (value: Record<string, any>) => {};

package/object/get.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 安全地从对象中获取嵌套属性，支持复杂路径解析
+ * 通过路径字符串访问对象的深层属性，当路径不存在时返回默认值
+ * 支持多种路径格式：点表示法、方括号表示法和逗号分隔的数组路径
+ *
+ * @template T - 返回值的类型
+ * @param obj - 要查询的对象，可以是任何类型
+ * @param path - 属性路径字符串，支持格式如 'a.b[0].c' 或 'a,b,c'
+ * @param [defaultValue] - 可选，当路径不存在时返回的默认值
+ * @returns 路径对应的属性值，或默认值，或undefined
+ * @example
+ * const obj = { a: { b: { c: 1 } } };
+ * get(obj, 'a.b.c'); // 返回 1
+ * @example
+ * get(obj, 'a.b.d', 'default'); // 返回 'default'（路径不存在）
+ * @example
+ * get([{ name: 'test' }], '[0].name'); // 返回 'test'（数组访问）
+ * @example
+ * get({ a: [{ b: 'value' }] }, 'a,0,b'); // 返回 'value'（逗号分隔路径）
+ * @note 路径解析支持多种分隔符：逗号(,)、方括号([])和点(.)
+ * @note 如果对象在路径的任何环节为null/undefined，将返回默认值
+ */
+export declare const get: <T = any>(obj: any, path: string, defaultValue?: any) => T;

package/object/getTag.d.ts

@@ -0,0 +1 @@
+export declare const getTag: (value: unknown) => string;

package/object/has.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 检查对象是否包含指定的嵌套属性（仅检查自有属性）
+ * 支持通过点表示法访问嵌套属性，如'a.b.c'
+ * 如果对象为null/undefined或任何父属性不存在，返回false
+ *
+ * @param obj - 要检查的对象，可以是任何类型
+ * @param key - 属性路径字符串，支持嵌套路径如'a.b.c'
+ * @returns 如果对象包含指定的自有属性则返回true，否则返回false
+ * @example
+ * has({ a: { b: 1 } }, 'a.b'); // 返回 true
+ * @example
+ * has({ a: 1 }, 'a'); // 返回 true
+ * @example
+ * has({ a: {} }, 'a.b'); // 返回 false（属性不存在）
+ * @example
+ * has(null, 'a'); // 返回 false（对象为null）
+ * @note 使用Object.hasOwnProperty检查属性，不考虑继承属性
+ * @note 支持任意深度的嵌套属性检查
+ */
+export declare const has: (obj: any, key: string) => boolean;

package/object/index.d.ts

@@ -0,0 +1,15 @@
+export { deepFreeze } from './deepFreeze';
+export * from './flattenPathObjectToPlainObject';
+export * from './get';
+export * from './has';
+export * from './isEqual';
+export * from './isEqualUint8Array';
+export * from './omit';
+export * from './omitBy';
+export * from './pick';
+export * from './pickBy';
+export * from './plainObjectToFlattenPathObject';
+export * from './set';
+export * from './setWith';
+export * from './toPlainObject';
+export * from './zipObject';

package/object/isEqual.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 深度比较两个值是否相等，支持多种数据类型和复杂结构
+ * 递归比较对象的属性和数组的元素，处理特殊类型如RegExp、Uint8Array和NaN
+ * 与===不同，此函数认为NaN等于NaN，并且会比较对象的原型和自有属性
+ *
+ * @param a - 要比较的第一个值
+ * @param b - 要比较的第二个值
+ * @returns 如果两个值深度相等则返回true，否则返回false
+ * @example
+ * isEqual(1, 1); // 返回 true
+ * @example
+ * isEqual({ a: 1 }, { a: 1 }); // 返回 true（对象深度比较）
+ * @example
+ * isEqual([1, 2, 3], [1, 2, 3]); // 返回 true（数组比较）
+ * @example
+ * isEqual(NaN, NaN); // 返回 true（特殊处理NaN）
+ * @example
+ * isEqual(/abc/i, /abc/i); // 返回 true（正则表达式比较）
+ * @example
+ * isEqual(new Uint8Array([1,2]), new Uint8Array([1,2])); // 返回 true（Uint8Array比较）
+ * @note 比较对象时会检查构造函数和自有属性，不考虑原型链上的属性
+ * @note 循环引用对象可能导致无限递归
+ * @note 函数不支持比较函数、Promise等引用类型的内部状态
+ */
+export declare const isEqual: (a: any, b: any) => boolean;

package/object/isEqualUint8Array.d.ts

@@ -0,0 +1 @@
+export declare function isEqualUint8Array(u8_1: Uint8Array, u8_2: Uint8Array): boolean;

package/object/omit.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 从对象中排除指定的属性，创建并返回一个新对象
+ * 包含源对象的所有自有属性，除了指定要排除的属性
+ * 当输入对象为null/undefined时返回空对象，当排除列表为空时返回原对象的浅拷贝
+ *
+ * @template T - 输入对象的类型
+ * @template Keys - 要排除的属性键集合类型
+ * @param obj - 源对象，如果为null/undefined则返回空对象
+ * @param keys - 要排除的属性键数组
+ * @returns 排除指定属性后的新对象
+ * @example
+ * omit({ a: 1, b: 2, c: 3 }, ['b']);
+ * // 返回 { a: 1, c: 3 }
+ * @example
+ * omit({ name: 'John', age: 30, email: 'john@example.com' }, ['age', 'email']);
+ * // 返回 { name: 'John' }
+ * @example
+ * omit({ a: 1 }, []); // 返回 { a: 1 }（排除空数组）
+ * @example
+ * omit(null, ['a']); // 返回 {}（输入为null）
+ * @note 函数会创建源对象的浅拷贝，原对象不会被修改
+ * @note 只排除自有属性，继承属性不受影响
+ */
+export declare const omit: <T extends Record<string, any>, Keys extends keyof T>(obj: T, keys: Keys[]) => Omit<T, Keys>;

package/object/omitBy.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 创建一个新对象，通过方法除了指定的属性
+ * @param obj
+ * @param keys
+ * @returns
+ */
+export declare function omitBy<T extends Record<string, any>>(object: T, fn: (value: any, key: string) => boolean): T;

package/object/pick.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 从对象中选取指定的属性，创建并返回一个新对象
+ * 只包含指定的自有属性，忽略继承属性和不存在的属性
+ * 当输入对象为null/undefined时，返回空对象
+ *
+ * @template T - 输入对象的类型
+ * @template Keys - 要选取的属性键集合类型
+ * @param obj - 源对象，如果为null/undefined则返回空对象
+ * @param keys - 要选取的属性键数组
+ * @returns 只包含选取属性的新对象
+ * @example
+ * pick({ a: 1, b: 2, c: 3 }, ['a', 'c']);
+ * // 返回 { a: 1, c: 3 }
+ * @example
+ * pick({ name: 'John', age: 30 }, ['name']);
+ * // 返回 { name: 'John' }
+ * @example
+ * pick(null, ['a', 'b']); // 返回 {}
+ * @example
+ * pick({ a: 1 }, ['b']); // 返回 {}（属性不存在）
+ * @note 只选取对象的自有属性，不包括继承的属性
+ * @note 对于不存在的属性，会被忽略而不会出现在结果中
+ */
+export declare function pick<T extends object, Keys extends keyof T>(obj: T, keys: Keys[]): Pick<T, Keys>;

package/object/pickBy.d.ts

@@ -0,0 +1 @@
+export declare function pickBy<T extends Record<string, any>>(object: T, fn: (value: any, key: string) => boolean): T;

package/object/plainObjectToFlattenPathObject.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 扁平化对象
+ * @param object
+ * @returns
+ * in { a: { a: [0, 1] } }
+ * out { 'a.a[0]': 0, 'a.a[1]': 1 }
+ */
+export declare function plainObjectToFlattenPathObject(object: object): Record<string, any>;

package/object/set.d.ts

@@ -0,0 +1,27 @@
+export declare function setBase(object: Record<string, any>, path: string, value: any, fun?: (currentValue: any, key: string, object: any) => any): Record<string, any>;
+/**
+ * 设置对象中指定路径的属性值，自动创建不存在的嵌套路径
+ * 支持点表示法和方括号表示法的路径，根据下一个路径段类型自动创建数组或对象
+ * 例如：路径'a[0].b'会创建数组和对象结构
+ *
+ * @template T - 输入对象的类型
+ * @param object - 要修改的对象，会被原地修改
+ * @param path - 属性路径字符串，支持格式如 'a.b[0].c' 或 'a[1].b'
+ * @param value - 要设置的值
+ * @returns 修改后的对象（与输入对象是同一引用）
+ * @example
+ * const obj = {};
+ * set(obj, 'a.b.c', 1);
+ * // obj 变为 { a: { b: { c: 1 } } }
+ * @example
+ * const arr = [];
+ * set(arr, '[0].name', 'test');
+ * // arr 变为 [{ name: 'test' }]
+ * @example
+ * set({ a: 1 }, 'a.b', 2);
+ * // 返回 { a: { b: 2 } }（覆盖原属性值）
+ * @note 函数会原地修改输入对象，而非创建新对象
+ * @note 路径中的数字索引会创建数组，其他情况创建普通对象
+ * @note 空路径段（如'a..b'）会被忽略
+ */
+export declare function set(object: Record<string, any>, path: string, value: any): Record<string, any>;

package/object/setWith.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 这个方法类似 set 除了它接受一个 customFun 决定如何设置对象路径的值。
+ * 如果 fun 返回 undefined 将会有它的处理方法代替。
+ * customFun 会传入3个参数：(nsValue, key, nsObject)
+ *
+ * @export
+ * @param object
+ * @param path
+ * @param value
+ * @param customFun
+ */
+export declare function setWith(object: Record<string, any>, path: string, value: any, customFun: (currentValue: any, key: string, object: string) => any): Record<string, any>;

package/object/toPlainObject.d.ts

@@ -0,0 +1 @@
+export declare const toPlainObject: (value: any) => Record<string, any>;

package/object/zipObject.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 创建一个对象，将映射指定键值
+ *
+ * @example
+ * const zipped = zipObject(['a', 'b'], [1, 2]) // { a: 1, b: 2 }
+ * const zipped = zipObject(['a', 'b'], (k, i) => k + i) // { a: 'a0', b: 'b1' }
+ * const zipped = zipObject(['a', 'b'], 1) // { a: 1, b: 1 }
+ */
+export declare function zipObject<K extends string | number | symbol, V>(keys: K[], values: V | ((key: K, idx: number) => V) | V[]): Record<K, V>;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@aiao/utils",
+  "version": "0.0.1",
+  "type": "module",
+  "dependencies": {
+    "ms": "^2.1.3",
+    "type-fest": "^4.41.0",
+    "fastest-levenshtein": "^1.0.16",
+    "ts-xor": "^1.3.0",
+    "rxjs": "~7.8.2"
+  },
+  "main": "index.js",
+  ".": {
+    "import": "./index.js",
+    "types": "./index.d.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/platform/index.d.ts

@@ -0,0 +1 @@
+export { IS_BROWSER } from './is-browser';

package/platform/is-browser.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 是否是浏览器
+ */
+export declare const IS_BROWSER: boolean;

package/random/index.d.ts

@@ -0,0 +1,6 @@
+export { randomArrayItem } from './randomArrayItem';
+export { randomFloat } from './randomFloat';
+export { randomInt } from './randomInt';
+export { randomString } from './randomString';
+export { randomUintByLength } from './randomUintByLength';
+export { randomUintString } from './randomUintString';

package/random/randomArrayItem.d.ts

@@ -0,0 +1 @@
+export declare const randomArrayItem: (array: any[]) => any;

package/random/randomFloat.d.ts

@@ -0,0 +1 @@
+export declare const randomFloat: (min?: number, max?: number) => number;

package/random/randomInt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 随机整数
+ *
+ * @param [min=Number.MIN_SAFE_INTEGER]
+ * @param [max=Number.MAX_SAFE_INTEGER]
+ */
+export declare function randomInt(min?: number, max?: number): number;

package/random/randomString.d.ts

@@ -0,0 +1,9 @@
+export declare const ZERO = "0";
+export declare const NUMBER_WITHOUT_ZERO = "123456789";
+export declare const NUMBERS: string;
+export declare const LOWER_LETTERS = "abcdefghijklmnopqrstuvwxyz";
+export declare const UPPER_LETTERS: string;
+export declare const LETTERS: string;
+export declare const SAFE_URL = "_-";
+export declare const URL_ALL: string;
+export declare const randomString: (size?: number, alphabet?: string) => string;

package/random/randomUintByLength.d.ts

@@ -0,0 +1 @@
+export declare const randomUintByLength: (length?: number) => number;

package/random/randomUintString.d.ts

@@ -0,0 +1 @@
+export declare const randomUintString: (length?: number) => string;

package/string/camelCase.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 将字符串转换为驼峰命名格式
+ * 驼峰命名规则：首字母小写，后续每个单词首字母大写，单词间无分隔符
+ * 支持处理包含连字符(-)、下划线(_)、空格或大小写混合的字符串
+ *
+ * @param str - 输入字符串，可以包含各种分隔符或混合大小写
+ * @returns 转换后的驼峰式字符串
+ * @example
+ * camelCase('hello-world');      // 返回 'helloWorld'
+ * @example
+ * camelCase('Hello_World');      // 返回 'helloWorld'
+ * @example
+ * camelCase('hello world');      // 返回 'helloWorld'
+ * @example
+ * camelCase('HelloWorld');       // 返回 'helloWorld'
+ * @example
+ * camelCase('  hello--world  '); // 返回 'helloWorld'（自动去除首尾空格）
+ * @example
+ * camelCase('');                 // 返回 ''（空字符串输入返回空字符串）
+ * @note 内部使用getWords()函数拆分单词，使用capitalize()函数处理单词首字母
+ */
+export declare function camelCase(str: string): string;

package/string/capitalize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 首字母大写
+ *
+ * @example capitalize('hello') -> 'Hello'
+ */
+export declare const capitalize: (str: string) => Capitalize<string>;
+export declare const capitalizeFirst: (lower: string) => Capitalize<string>;

package/string/compressToBase64Url.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 压缩字符串到 base64 中
+ */
+export declare const compressToBase64Url: (string: string, format?: "deflate" | "deflate-raw" | "gzip") => Promise<string>;

package/string/decompressFromBase64Url.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 从 base64 解压字符串
+ */
+export declare const decompressFromBase64Url: (string: string, format?: "deflate" | "deflate-raw" | "gzip") => Promise<string>;

package/string/getWords.d.ts

@@ -0,0 +1 @@
+export declare const getWords: (str: string) => string[];

package/string/index.d.ts

@@ -0,0 +1,17 @@
+export { camelCase } from './camelCase';
+export * from './capitalize';
+export { compressToBase64Url } from './compressToBase64Url';
+export { decompressFromBase64Url } from './decompressFromBase64Url';
+export { kebabCase } from './kebabCase';
+export { parseChineseNumber } from './parseChineseNumber';
+export { queryParse } from './queryParse';
+export { queryStringify } from './queryStringify';
+export { rmbUppercase } from './rmb';
+export { similarity } from './similarity';
+export { snakeCase } from './snakeCase';
+export { startCase } from './startCase';
+export { stringSingleline } from './stringSingleline';
+export { stringTemplate } from './stringTemplate';
+export { stringToArrayBuffer } from './stringToArrayBuffer';
+export * from './uncapitalize';
+export { urlJoin } from './urlJoin';

package/string/kebabCase.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 转换为 kebab-case
+ * @param value
+ * @returns
+ *
+ * @example
+ * camelCase -> 'camel-case'
+ */
+export declare const kebabCase: (str: string) => string;

package/string/parseChineseNumber.d.ts

@@ -0,0 +1 @@
+export declare function parseChineseNumber(s: string): number;

package/string/queryParse.d.ts

@@ -0,0 +1 @@
+export declare const queryParse: (query: string) => any;

package/string/queryStringify.d.ts

@@ -0,0 +1,5 @@
+interface IQuery {
+    [name: string]: string | number | Array<string | number>;
+}
+export declare const queryStringify: (query: IQuery) => string;
+export {};

package/string/rmb.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 转换人民币大写
+ * @param value
+ * @returns
+ */
+export declare const rmbUppercase: (value: number) => string;

package/string/similarity.d.ts

@@ -0,0 +1 @@
+export declare function similarity(a: string, b: string): number;

package/string/snakeCase.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 将字符串转换为蛇形格式
+ * @param str
+ * @returns
+ *
+ * @example
+ * camelCase -> camel_case
+ * camel case -> camel_case
+ */
+export declare const snakeCase: (str: string) => string;

package/string/startCase.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @example
+ * startCase('--foo-bar'); // => 'Foo Bar'
+ * startCase('fooBar'); // => 'Foo Bar'
+ * startCase('__foo_bar__'); // => 'Foo Bar'
+ */
+export declare const startCase: (value: string) => string;

package/string/stringSingleline.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 单行文本
+ */
+export declare const stringSingleline: (value: string) => string;

package/string/stringTemplate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 模板字符串
+ * @param templateString
+ * @param data
+ * @returns
+ */
+export declare const stringTemplate: (templateString: string, data: Record<string, any>) => string;

package/string/stringToArrayBuffer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 字符串转 ArrayBuffer
+ *
+ * @export
+ * @param str
+ */
+export declare function stringToArrayBuffer(str: string): ArrayBuffer;

package/string/uncapitalize.d.ts

@@ -0,0 +1,7 @@
+export declare const uncapitalizeFirst: (lower: string) => Uncapitalize<string>;
+/**
+ * 首字母小写
+ * @param str
+ * @returns
+ */
+export declare const uncapitalize: (str: string) => Uncapitalize<string>;

package/string/urlJoin.d.ts

@@ -0,0 +1 @@
+export declare const urlJoin: (...paths: Array<string | number>) => string;

package/tools/event.d.ts

@@ -0,0 +1,18 @@
+export interface Event {
+    type: string;
+}
+export interface CustomEvents {
+    [eventName: string]: any;
+}
+export type EventListener<T> = (event: T) => void;
+/**
+ * 自定义事件调度器
+ */
+export declare abstract class EventDispatcher<Events extends CustomEvents = CustomEvents> {
+    #private;
+    addEventListener<T extends keyof Events>(type: T, listener: EventListener<Events[T]>): void;
+    hasEventListener<T extends keyof Events>(type: T, listener: EventListener<Events[T]>): boolean;
+    removeEventListener<T extends keyof Events>(type: T, listener: EventListener<Events[T]>): void;
+    dispatchEvent(event: Events[keyof Events]): void;
+    removeAllEventListener(): void;
+}

package/tools/image.d.ts

@@ -0,0 +1,2 @@
+export declare const IMAGE_MIN_BASE64_BLACK = "data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=";
+export declare const IMAGE_MIN_BASE64_TRANSPARENT = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";

package/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { EventDispatcher } from './event';
+export * from './image';
+export * from './log';

package/tools/log.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 优化打印
+ */
+export declare const logError: (err: unknown, ...args: any[]) => void;

package/type-definition/index.d.ts

@@ -0,0 +1 @@
+export * from './result-types';