@aiao/utils 0.0.1

package/type-definition/result-types.d.ts

@@ -0,0 +1,11 @@
+import { XOR } from 'ts-xor';
+export interface SuccessResult<SuccessDataType = any> {
+    data: SuccessDataType;
+}
+export interface ErrorResult<ErrorDataType = any> {
+    error: ErrorDataType;
+}
+/**
+ * 结果返回类型
+ */
+export type Result<SuccessDataType = any, ErrorDataType = any> = XOR<SuccessResult<SuccessDataType>, ErrorResult<ErrorDataType>>;

package/types/AnyFunction.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 通用函数类型，可接受任意参数并返回任意类型
+ * 用于需要表示各种函数类型的场景，提供最大的灵活性
+ *
+ * @example
+ * // 匹配无参数函数
+ * const func1: AnyFunction = () => 'hello';
+ *
+ * @example
+ * // 匹配带参数函数
+ * const func2: AnyFunction = (a: number, b: string) => a + b;
+ *
+ * @example
+ * // 匹配异步函数
+ * const func3: AnyFunction = async () => { await Promise.resolve(); return 42; };
+ *
+ * @note 此类型提供了最大的灵活性，但牺牲了类型安全性
+ * @note 对于需要类型安全的场景，建议使用更具体的函数类型
+ */
+export type AnyFunction = (...args: any[]) => any;

package/types/DeepPartial.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 创建一个类型的深度部分类型
+ * 所有属性（包括嵌套对象和数组元素的属性）都变为可选
+ *
+ * @template T - 要创建深度部分类型的原始类型
+ * @example
+ * // 基本用法
+ * interface User {
+ *   name: string;
+ *   age: number;
+ *   address: {
+ *     street: string;
+ *     city: string;
+ *   };
+ *   hobbies: string[];
+ * }
+ *
+ * // 深度部分类型
+ * const partialUser: DeepPartial<User> = {
+ *   name: 'John',
+ *   address: {
+ *     street: 'Main St',
+ *   },
+ *   hobbies: ['reading'],
+ * };
+ *
+ * @example
+ * // 嵌套数组
+ * interface Data {
+ *   items: {
+ *     id: number;
+ *     name: string;
+ *   }[];
+ * }
+ *
+ * const partialData: DeepPartial<Data> = {
+ *   items: [{
+ *     id: 1,
+ *   }],
+ * };
+ *
+ * @note 此类型递归地将所有属性变为可选，包括嵌套对象和数组元素
+ * @note 对于数组类型，会递归应用到数组元素的类型
+ * @note 对于只读数组，保持其只读特性的同时递归应用到元素类型
+ */
+export declare type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer UE> ? ReadonlyArray<DeepPartial<UE>> : DeepPartial<T[P]>;
+};

package/types/index.d.ts

@@ -0,0 +1,24 @@
+export * from './AnyFunction';
+export * from './DeepPartial';
+export * from './isArray';
+export * from './isArrayBuffer';
+export * from './isBoolean';
+export * from './isDate';
+export * from './isEmpty';
+export { isFloat } from './isFloat';
+export * from './isFunction';
+export * from './isInt';
+export * from './isIntArray';
+export * from './isNil';
+export * from './isNumber';
+export * from './isNumberArray';
+export * from './isObject';
+export * from './isObjectLike';
+export * from './isPlainObject';
+export { isPrimitive } from './isPrimitive';
+export * from './isPromise';
+export { isRegExp } from './isRegExp';
+export * from './isString';
+export * from './isStringArray';
+export * from './isSymbol';
+export { isUint8Array } from './isUint8Array';

package/types/isArray.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 检查值是否为数组
+ * 这是对JavaScript内置Array.isArray函数的重导出
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是数组则返回true，否则返回false
+ * @example
+ * isArray([]); // 返回 true
+ * @example
+ * isArray([1, 2, 3]); // 返回 true
+ * @example
+ * isArray({}); // 返回 false（对象不是数组）
+ * @example
+ * isArray(null); // 返回 false（null不是数组）
+ * @example
+ * isArray("array"); // 返回 false（字符串不是数组）
+ * @note 这是对原生Array.isArray函数的直接重导出，保持与原生函数相同的行为
+ */
+export declare const isArray: (arg: any) => arg is any[];

package/types/isArrayBuffer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 检查值是否为ArrayBuffer类型
+ * 使用instanceof运算符进行判断
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是ArrayBuffer则返回true，否则返回false
+ * @example
+ * isArrayBuffer(new ArrayBuffer(8)); // 返回 true
+ * @example
+ * isArrayBuffer(new ArrayBuffer(0)); // 返回 true（空的ArrayBuffer）
+ * @example
+ * isArrayBuffer([]); // 返回 false（数组不是ArrayBuffer）
+ * @example
+ * isArrayBuffer(null); // 返回 false（null不是ArrayBuffer）
+ * @example
+ * isArrayBuffer(undefined); // 返回 false（undefined不是ArrayBuffer）
+ * @example
+ * isArrayBuffer(new Uint8Array()); // 返回 false（Uint8Array不是ArrayBuffer）
+ * @note 函数使用instanceof运算符判断是否为ArrayBuffer实例
+ * @note ArrayBuffer是用于表示通用的、固定长度的原始二进制数据缓冲区
+ * @note 与TypedArray（如Uint8Array）的区别：ArrayBuffer是原始二进制数据，而TypedArray是对其的视图
+ */
+export declare const isArrayBuffer: (value: unknown) => value is ArrayBuffer;

package/types/isBoolean.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 检查值是否为布尔类型
+ * 支持直接布尔值、布尔对象和实现了valueOf()返回布尔值的对象
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是布尔类型则返回true，否则返回false
+ * @example
+ * isBoolean(true); // 返回 true
+ * @example
+ * isBoolean(false); // 返回 true
+ * @example
+ * isBoolean(new Boolean(true)); // 返回 true（布尔对象）
+ * @example
+ * isBoolean('true'); // 返回 false（字符串不是布尔类型）
+ * @example
+ * isBoolean(1); // 返回 false（数字1不是布尔类型）
+ * @example
+ * isBoolean(0); // 返回 false（数字0不是布尔类型）
+ * @example
+ * isBoolean(null); // 返回 false（null不是布尔类型）
+ * @example
+ * isBoolean(undefined); // 返回 false（undefined不是布尔类型）
+ * @note 函数使用三种方式判断：直接比较true/false、检查valueOf()返回值类型
+ * @note 对于布尔对象(new Boolean())，valueOf()返回其原始布尔值
+ * @note 与typeof的区别：typeof new Boolean(true)返回'object'，但isBoolean返回true
+ */
+export declare function isBoolean(value: any): value is boolean;

package/types/isDate.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 检查值是否为Date对象
+ * 使用instanceof和Object.prototype.toString.call()两种方式进行判断
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是Date对象则返回true，否则返回false
+ * @example
+ * isDate(new Date()); // 返回 true
+ * @example
+ * isDate(new Date('2023-01-01')); // 返回 true
+ * @example
+ * isDate('2023-01-01'); // 返回 false（字符串不是Date对象）
+ * @example
+ * isDate(null); // 返回 false（null不是Date对象）
+ * @example
+ * isDate(undefined); // 返回 false（undefined不是Date对象）
+ * @example
+ * isDate({}); // 返回 false（普通对象不是Date对象）
+ * @example
+ * isDate(new Date('invalid date')); // 返回 true（即使是无效日期也是Date对象）
+ * @note 函数使用两种方式判断：instanceof和Object.prototype.toString.call()
+ * @note 对于无效日期（Invalid Date），函数仍返回true，因为它仍是Date对象
+ * @note 与isDateString的区别：此函数检查是否为Date对象，而非日期字符串
+ */
+export declare function isDate(value: unknown): value is Date;

package/types/isEmpty.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 检查值是否为空
+ * 支持多种类型的空值判断，包括null、undefined、空字符串、空数组、空对象等
+ *
+ * @param value - 要检查的值
+ * @returns 如果值为空则返回true，否则返回false
+ * @example
+ * isEmpty(null); // 返回 true
+ * @example
+ * isEmpty(undefined); // 返回 true
+ * @example
+ * isEmpty(''); // 返回 true（空字符串）
+ * @example
+ * isEmpty([]); // 返回 true（空数组）
+ * @example
+ * isEmpty({}); // 返回 true（空对象）
+ * @example
+ * isEmpty(0); // 返回 true（数字0）
+ * @example
+ * isEmpty(false); // 返回 true（布尔值false）
+ * @example
+ * isEmpty(new Date('invalid date')); // 返回 true（无效日期）
+ * @example
+ * isEmpty('hello'); // 返回 false（非空字符串）
+ * @example
+ * isEmpty([1, 2]); // 返回 false（非空数组）
+ * @example
+ * isEmpty({ name: 'John' }); // 返回 false（非空对象）
+ * @example
+ * isEmpty(42); // 返回 false（非零数字）
+ * @example
+ * isEmpty(() => {}); // 返回 false（函数）
+ * @example
+ * isEmpty(Symbol('foo')); // 返回 false（符号）
+ * @note 空值定义：null、undefined、空字符串、空数组、空对象、数字0、布尔值false、无效日期
+ * @note 函数和符号类型永远不会被视为空值
+ * @note 对于有length属性的对象（如数组、字符串），length为0时视为空
+ * @note 对于有size属性的对象（如Map、Set），size为0时视为空
+ */
+export declare const isEmpty: (value: unknown) => boolean;

package/types/isFloat.d.ts

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

package/types/isFunction.d.ts

@@ -0,0 +1,2 @@
+import { AnyFunction } from './AnyFunction';
+export declare const isFunction: (value: any) => value is AnyFunction;

package/types/isInt.d.ts

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

package/types/isIntArray.d.ts

@@ -0,0 +1 @@
+export declare function isIntArray(value: unknown): value is number[];

package/types/isNil.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 检查值是否为null或undefined
+ * 使用严格相等（===）进行比较
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是null或undefined则返回true，否则返回false
+ * @example
+ * isNil(null); // 返回 true
+ * @example
+ * isNil(undefined); // 返回 true
+ * @example
+ * isNil(0); // 返回 false（0不是null或undefined）
+ * @example
+ * isNil(''); // 返回 false（空字符串不是null或undefined）
+ * @example
+ * isNil(false); // 返回 false（false不是null或undefined）
+ * @note 此函数在判断null和undefined时使用严格相等运算符（===）
+ * @note 与isEmpty的区别：isNil仅检查null和undefined，而isEmpty还会检查空字符串、空数组等
+ */
+export declare const isNil: (value: unknown) => value is null | undefined;

package/types/isNumber.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 检查值是否为有效数字（排除NaN）
+ * 使用Number(value) === value进行判断，确保值是数字且不是NaN
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是有效数字则返回true，否则返回false
+ * @example
+ * isNumber(123); // 返回 true
+ * @example
+ * isNumber(0); // 返回 true
+ * @example
+ * isNumber(-42); // 返回 true
+ * @example
+ * isNumber(3.14); // 返回 true
+ * @example
+ * isNumber(NaN); // 返回 false（NaN不是有效数字）
+ * @example
+ * isNumber('123'); // 返回 false（字符串不是数字）
+ * @example
+ * isNumber(null); // 返回 false（null不是数字）
+ * @example
+ * isNumber(undefined); // 返回 false（undefined不是数字）
+ * @example
+ * isNumber(new Number(123)); // 返回 false（Number对象不是数字字面量）
+ * @note 与typeof的区别：typeof NaN返回'number'，但isNumber(NaN)返回false
+ * @note 函数使用try-catch块处理可能的类型转换异常
+ * @note 数字字面量和Infinity都会返回true（Infinity是有效数字）
+ */
+export declare const isNumber: (value: any) => value is number;

package/types/isNumberArray.d.ts

@@ -0,0 +1 @@
+export declare function isNumberArray(value: unknown): value is number[];

package/types/isObject.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 检查值是否为纯对象（通过Object构造函数创建的对象）
+ * 排除数组、null、日期、正则表达式等特殊对象
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是纯对象则返回true，否则返回false
+ * @example
+ * isObject({}); // 返回 true
+ * @example
+ * isObject({ a: 1 }); // 返回 true
+ * @example
+ * isObject([]); // 返回 false（数组不是纯对象）
+ * @example
+ * isObject(null); // 返回 false（null不是对象）
+ * @example
+ * isObject(new Date()); // 返回 false（日期对象不是纯对象）
+ * @example
+ * isObject(Object.create(null)); // 返回 false（没有constructor属性）
+ * @note 此函数使用value.constructor === Object进行判断，因此不识别通过Object.create(null)创建的对象
+ * @note 与isObjectLike的区别：isObjectLike仅检查值是否为非null的对象，而isObject还要求是通过Object构造函数创建的
+ */
+export declare const isObject: (value: unknown) => value is object;

package/types/isObjectLike.d.ts

@@ -0,0 +1 @@
+export declare const isObjectLike: (value: unknown) => value is object;

package/types/isPlainObject.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 检查值是否为纯对象（通过Object构造函数创建的普通对象）
+ * 排除数组、日期、正则表达式、Map、Set等特殊对象
+ *
+ * @param object - 要检查的值
+ * @returns 如果值是纯对象则返回true，否则返回false
+ * @example
+ * isPlainObject({}); // 返回 true（空对象）
+ * @example
+ * isPlainObject({ name: 'John', age: 30 }); // 返回 true（带属性的普通对象）
+ * @example
+ * isPlainObject(new Object()); // 返回 true（通过Object构造函数创建的对象）
+ * @example
+ * isPlainObject([]); // 返回 false（数组不是纯对象）
+ * @example
+ * isPlainObject(new Date()); // 返回 false（日期对象不是纯对象）
+ * @example
+ * isPlainObject(null); // 返回 false（null不是对象）
+ * @example
+ * isPlainObject(Object.create(null)); // 返回 true（原型为null的对象视为纯对象）
+ * @example
+ * isPlainObject(new Map()); // 返回 false（Map对象不是纯对象）
+ * @note 函数通过检查toString标签和原型链来判断是否为纯对象
+ * @note 与isObject的区别：isObject包含所有对象类型，而isPlainObject仅包含普通对象
+ * @note 原型为null的对象（Object.create(null)）也被视为纯对象
+ */
+export declare function isPlainObject(object: unknown): object is object;

package/types/isPrimitive.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 检查值是否为JavaScript原始类型
+ * JavaScript原始类型包括null、undefined、字符串、数字、布尔值、符号和大整数
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是原始类型则返回true，否则返回false
+ * @example
+ * isPrimitive(null); // 返回 true
+ * @example
+ * isPrimitive(undefined); // 返回 true
+ * @example
+ * isPrimitive('hello'); // 返回 true（字符串是原始类型）
+ * @example
+ * isPrimitive(123); // 返回 true（数字是原始类型）
+ * @example
+ * isPrimitive(true); // 返回 true（布尔值是原始类型）
+ * @example
+ * isPrimitive(Symbol('foo')); // 返回 true（符号是原始类型）
+ * @example
+ * isPrimitive(BigInt(123)); // 返回 true（大整数是原始类型）
+ * @example
+ * isPrimitive({}); // 返回 false（对象不是原始类型）
+ * @example
+ * isPrimitive([]); // 返回 false（数组不是原始类型）
+ * @example
+ * isPrimitive(() => {}); // 返回 false（函数不是原始类型）
+ * @example
+ * isPrimitive(new Date()); // 返回 false（日期对象不是原始类型）
+ * @note 函数使用typeof运算符和null检查来判断是否为原始类型
+ * @note 原始类型是不可变的值，没有方法和属性（尽管JavaScript允许访问它们的包装对象方法）
+ * @note 函数实现使用`value == null`来同时检查null和undefined
+ */
+export declare function isPrimitive(value: unknown): value is null | undefined | string | number | boolean | symbol | bigint;

package/types/isPromise.d.ts

@@ -0,0 +1 @@
+export declare const isPromise: <T = any>(value: any) => value is Promise<T>;

package/types/isRegExp.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 检查值是否为正则表达式类型
+ * 使用instanceof运算符进行判断
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是正则表达式则返回true，否则返回false
+ * @example
+ * isRegExp(/abc/); // 返回 true
+ * @example
+ * isRegExp(new RegExp('abc')); // 返回 true
+ * @example
+ * isRegExp('/abc/'); // 返回 false（字符串不是正则表达式）
+ * @example
+ * isRegExp(null); // 返回 false（null不是正则表达式）
+ * @example
+ * isRegExp(undefined); // 返回 false（undefined不是正则表达式）
+ * @example
+ * isRegExp({}); // 返回 false（普通对象不是正则表达式）
+ * @note 函数使用instanceof运算符判断是否为RegExp实例
+ * @note 正则表达式字面量和通过RegExp构造函数创建的正则表达式都会返回true
+ * @note 字符串形式的正则表达式（如'/abc/'）不会被识别为正则表达式
+ */
+export declare function isRegExp(value: unknown): value is RegExp;

package/types/isString.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 检查值是否为字符串类型
+ * 使用typeof运算符进行判断，返回布尔值
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是字符串则返回true，否则返回false
+ * @example
+ * isString('hello'); // 返回 true
+ * @example
+ * isString(''); // 返回 true（空字符串也是字符串）
+ * @example
+ * isString(123); // 返回 false（数字不是字符串）
+ * @example
+ * isString(null); // 返回 false（null不是字符串）
+ * @example
+ * isString(undefined); // 返回 false（undefined不是字符串）
+ * @example
+ * isString(new String('hello')); // 返回 false（String对象不是字符串字面量）
+ * @note 使用typeof运算符判断，对于String对象返回'object'而非'string'
+ * @note 字符串字面量和空字符串都会返回true
+ */
+export declare function isString(value: unknown): value is string;

package/types/isStringArray.d.ts

@@ -0,0 +1 @@
+export declare const isStringArray: (value: any[]) => value is string[];

package/types/isSymbol.d.ts

@@ -0,0 +1 @@
+export declare const isSymbol: (value: any) => value is symbol;

package/types/isUint8Array.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 检查值是否为Uint8Array类型
+ * 使用instanceof运算符进行判断
+ *
+ * @param value - 要检查的值
+ * @returns 如果值是Uint8Array则返回true，否则返回false
+ * @example
+ * isUint8Array(new Uint8Array([1, 2, 3])); // 返回 true
+ * @example
+ * isUint8Array(new Uint8Array(0)); // 返回 true（空的Uint8Array）
+ * @example
+ * isUint8Array([]); // 返回 false（数组不是Uint8Array）
+ * @example
+ * isUint8Array(null); // 返回 false（null不是Uint8Array）
+ * @example
+ * isUint8Array(undefined); // 返回 false（undefined不是Uint8Array）
+ * @example
+ * isUint8Array(new ArrayBuffer(8)); // 返回 false（ArrayBuffer不是Uint8Array）
+ * @example
+ * isUint8Array(new Uint16Array()); // 返回 false（Uint16Array不是Uint8Array）
+ * @note 函数使用instanceof运算符判断是否为Uint8Array实例
+ * @note Uint8Array是8位无符号整数类型化数组，范围为0到255
+ * @note 与ArrayBuffer的区别：Uint8Array是对ArrayBuffer的视图，提供了对二进制数据的特定类型访问
+ */
+export declare const isUint8Array: (value: unknown) => value is Uint8Array;