type-tls
Version:
type-tls 封装了与类型相关的工具，比如:获取数据的类型 或 类型名字、判断数据的类型 等
466 lines (411 loc) • 14.6 kB
TypeScript
/**
* 表示任意的函数类型
*/
export declare type AnyFunction = (...args: any) => any;
/**
* 获取数组元素的类型
* @typeParam Arr 数组
*/
export declare type ArrayItemType<Arr> = Arr extends (infer Item)[] ? Item : never;
/**
* 位标志相等测试
*/
export declare enum BitFlagEqualTestType {
/**
* 相等:A === B
*/
equal = "equal",// "相等"
/**
* 相交:A & B
*/
intersect = "intersect",// "相交"
/**
* 交等:A & B === A
*/
intersectEqual = "intersectEqual"
}
export declare namespace BitFlagEqualTestType {
/**
* 获取 位标志相等测试的函数
* @param testType 默认 intersectEqual
* @returns
*/
export function getEqualFun(testType?: BitFlagEqualTestType | null): (a: number, b: number) => number | boolean;
}
/**
* 精确类型
*
* @remarks
* 在精准类型中认为 JavaScript 的原始类型（非对象类型） 与 其对应的 包装类型（类类型）是不同的类型，即：
* number 和 Number、string 和 String、boolean 和 Boolean 等 是不同的类型；
* 对于原始类型，返回的结果 会与 typeof 返回的结果一样；
* 但，对于 undefined 和 null 会返回其自身值（即 undefined 和 null）作为类型值
*
* 各种类型的值 与 该方法的返回值 的映射如下：
* ```
* undefined ：undefined
* null : null
* string : "string"
* number : "number"
* bigint : "bigint"
* boolean : "boolean"
* symbol : "symbol"
* function : Function
* 没有原型的对象(如：通过 `Object.create(null)` 创建的对象) : "object"
* 其它任何类型的实例 : 返回该实例的构造函数
* ```
*/
export declare type ExactType = LooseType | Exclude<TypeOfReturnType, "undefined" | "function" | "object">;
/**
* 精确类型的字符串表示
*
* @remarks
* 在精准类型中认为 JavaScript 的原始类型（非对象类型） 与 其对应的 包装类型（类类型）是不同的类型，即：
* number 和 Number、string 和 String、boolean 和 Boolean 等 是不同的类型；
* 对于原始类型，返回的结果 会与 typeof 返回的结果一样；
* 但，对于 null 会返回 "null"
*
* 各种类型的值 与 该方法的返回值 的映射如下：
* ```
* undefined ："undefined"
* null : "null"
* function : "Function"
* string : "string"
* number : "number"
* bigint : "bigint"
* boolean : "boolean"
* symbol : "symbol"
* 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
* 其它任何类型的实例 : 返回该实例的构造函数的名字
* ```
*/
export declare type ExactTypeName = LooseTypeName | Exclude<TypeOfReturnType, "undefined" | "function" | "object">;
/**
* 格式化为数组格式
* @remarks
* 如果 ItemOrArray 是数组，则保持不变
* 如果 ItemOrArray 不是数组，则转为数组类型 ItemOrArray[]
*/
export declare type FormatAsArray<ItemOrArray> = ItemOrArray extends any[] ? ItemOrArray : ItemOrArray[];
/**
* 格式化为数组格式
* @remarks
* 如果 value 是数组，则保持不变
* 如果 value 不是数组，则转为数组类型
* @param value
* @returns
*/
export declare function formatAsArray<V>(value: V): FormatAsArray<V>;
/**
* 格式化对象成员为数组格式
* @remarks
* 如果 成员 是数组，则保持不变
* 如果 成员 不是数组，则转为数组类型
*/
export declare type FormatMemberAsArray<D> = {
[K in keyof D]: FormatAsArray<D[K]>;
};
/**
* 格式化对象成员为数组格式
* @remarks
* 如果 成员 是数组，则保持不变
* 如果 成员 不是数组，则转为数组类型
*
* @returns 返回来的 data 对象，此方法会改变原对象 data，耗会生成新的对象
*/
export declare function formatMemberAsArray<D extends {}>(data: D): FormatMemberAsArray<D>;
/**
* 获取 inst 的精确类型的字符串表示
* @param inst
* @returns inst 的类型字符串
*/
export declare function getExactTypeNameOf(inst: any): ExactTypeName;
/**
* 获取 inst 的精确类型
* @param inst
* @returns inst 的类型
*/
export declare function getExactTypeOf(inst: any): ExactType;
/**
* 获取 类型的字符串表示
*
* @param t - 一个 ExactType 类型的值
* @return t 的字符串表示的类型
*/
export declare function getNameOfType(t: ExactType): ExactTypeName;
/**
* 根据类型的名字获取其对应的类
* @param typeName - 类型的名字
*/
export declare function getTypeByName(typeName: string): Function | undefined;
/**
* 获取 inst 的类型字符串
*
* @remarks
* 注意：
* 本方法返回的结果如下：
* undefined ："undefined"
* null ： "null"
* 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
* 其它任何类型的实例 : 返回该实例的构造函数 或 包装对象的构造函数 的函数名字
*
* @param inst
* @returns inst 的类型字符串
*/
export declare function getTypeNameOf(inst: any): LooseTypeName;
/**
* 获取 inst 的宽松类型
*
* @remarks
* 注意：
* 本方法返回的结果如下：
* ```
* undefined ：undefined
* null ： null
* function : Function
* 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
* 其它任何类型的实例 : 返回该实例的构造函数 或 包装对象的构造函数
* ```
*
*
* @param inst
* @returns inst 的类型
*/
export declare function getTypeOf(inst: any): LooseType;
/**
* 判断是否是匿名函数
*
* @remarks
* 判断函数在被定义时是否是通过匿名函数来定义的。
* 匿名函数是指声明函数时没有写名字的函数。
* 注意：即使是匿名函数，函数对象上的 name 属性也可能是有值的，因为 js解析器 会自动将 函数表达式函数变量的名字作为匿名函数的名字，如下：
* ```ts
* var funName = function(){};
* ```
* 其中的匿名函数对象的 name 属性的值会是 `funName`
*
* 如果 函数对象上的 name 属性的值为 `""`，函数一定是匿名函数。
*/
export declare function isAnonymousFunction(fun: Function): boolean;
/**
* 判断 target 是否为 类数组对象
* @param target - 目标
* @returns
*/
export declare function isArrayLike(target: any): boolean;
/**
* 判断函数是否是箭头函数
* @param fun - 被判断的函数
*/
export declare function isArrowFunction(fun: Function): boolean;
/**
* 判断函数是否是 async 异步函数
* @remarks
* 异步函数 不包含 异步生成器函数 AsyncGeneratorFunction
* @param fun - 被判断的函数
*/
export declare function isAsyncFunction(fun: Function): boolean;
/**
* 判断函数是否是异步生成器函数
* @param fun - 被判断的函数
*/
export declare function isAsyncGeneratorFunction(fun: Function): boolean;
/**
* 判断 data 是否是 基本类型
* @remarks
* 基本类型 是指 那些不是 对象类型的类型，即，除了 object 和 function 类型以外，其它的都是基本类型，null 也算怎是 基本类型
* @param data - 任意类型的值
*/
export declare function isBaseType(data: any): boolean;
/**
* 判断函数是否是生成器函数
*
* @remarks
* 生成器函数 不包含 异步生成器函数 AsyncGeneratorFunction
* @param fun - 被判断的函数
*/
export declare function isGeneratorFunction(fun: Function): boolean;
/**
* 判断 code 是否是有校的 js 标识符
* @param code - 标识符的字符串
*/
export declare function isIdentifier(code: string): boolean;
/**
* 判断 目标 是否是可迭代的对象，即 实现了 可迭代协议
* @param target - 目标
*/
export declare function isIterable(target: any): boolean;
/**
* 判断 目标 是否是迭代器，即 实现了 迭代器协议
* @param target - 目标
*/
export declare function isIterator(target: any): boolean;
/**
* 判断目标是否是对象类型
*
* @remarks
* 仅通过 target instanceof Object 判断是不行的，因为 对于 Object.create(null) 创建的对象 通过 ` Object.create(null) instanceof Object ` 来判断 返回的是 false
* 即：通过 Object.create(null) 创建的对象是不被 instanceof 认为是继续于 Object 的
*
* typeof null 也返回 "object"
*
* @param target : any 目标对象
*/
export declare function isObject(target: any): boolean;
/**
* 获取值类型包含指定类型的所有 key
*
* @typeParam Target - 目标对象
* @typeParam Value - 要获取的key的对应值应包含的类型
*/
export declare type KeyOfContainsValue<Target, Value> = {
[K in keyof Target]: Value extends Target[K] ? K : never;
}[keyof Target];
/**
* 获取值类型不应包含指定类型的所有 key
*
* @typeParam Target - 目标对象
* @typeParam Value - 不应包含的值的类型
*/
export declare type KeyOfNonContainsValue<Target, Value> = {
[K in keyof Target]: Value extends Target[K] ? never : K;
}[keyof Target];
/**
* 获取值类型不是指定类型的所有 key
*
* @typeParam Target - 目标对象
* @typeParam Value - 被排除的值的类型
*/
export declare type KeyOfNonValue<Target, Value> = {
[K in keyof Target]: Target[K] extends Value ? never : K;
}[keyof Target];
/**
* 获取值类型为指定类型的所有 key
*
* @typeParam Target - 目标对象
* @typeParam Value - 要获取的key的对应值的类型
*/
export declare type KeyOfValue<Target, Value> = {
[K in keyof Target]: Target[K] extends Value ? K : never;
}[keyof Target];
/**
* 宽松的类型
*/
export declare type LooseType = undefined | null | Function | "object";
/**
* 宽松类型的字符串表示
*/
export declare type LooseTypeName = "undefined" | "null" | "Function" | "object" | string;
/**
* 获取对象的方法的某个参数的类型
*
* @typeParam Obj - 对象
* @typeParam Method - 对象方法的名字
* @typeParam ParamIndex - 参数的索引个数
*/
export declare type MethodParams<Obj, Method extends keyof Obj, ParamIndex extends number> = Obj[Method] extends AnyFunction ? Parameters<Obj[Method]>[ParamIndex] : never;
/**
* 获取对象的方法的返回的类型
*
* @typeParam Obj - 对象
* @typeParam Method - 对象方法的名字
*/
export declare type MethodReturnType<Obj, Method extends keyof Obj> = Obj[Method] extends AnyFunction ? ReturnType<Obj[Method]> : never;
/**
* 将某个类型变为可选的类型
*/
export declare type Optional<T> = T | null | undefined;
/**
* 可选的布尔类型
*/
export declare type OptionalBoolean = Optional<boolean>;
/**
* 从 Target 中挑选出那些成员值的类型包含 Value 类型的成员
*/
export declare type PickContainsValue<Target, Value> = {
[P in KeyOfContainsValue<Target, Value>]: Target[P];
};
/**
* 从 Target 中挑选出方法
*/
export declare type PickMethod<Target> = PickValue<Target, AnyFunction>;
/**
* 从 Target 中挑选出那些成员值的类型不包含 Value 类型的成员
*/
export declare type PickNonContainsValue<Target, Value> = {
[P in KeyOfNonContainsValue<Target, Value>]: Target[P];
};
/**
* 从 Target 中挑选出那些成员值不是 Value 的类型的成员
*/
export declare type PickNonValue<Target, Value> = {
[P in KeyOfNonValue<Target, Value>]: Target[P];
};
/**
* 从 Target 中挑选出属性
*/
export declare type PickProperty<Target> = PickNonValue<Target, AnyFunction>;
/**
* 从 T 中挑选出那些成员值为 Value 的类型的成员
*/
export declare type PickValue<Target, Value> = {
[P in KeyOfValue<Target, Value>]: Target[P];
};
/**
* 可将源类型 SourType 中的 类型 MatchType 替换为 新的类型 NewType
*/
export declare type Replace<SourType, MatchType, NewType> = SourType extends MatchType ? NewType : SourType;
/**
* 可将源类型 SourType 中的 null 替换为 新的类型 NewType
*/
export declare type ReplaceNull<SourType, NewType> = Replace<SourType, null, NewType>;
/**
* 可将源类型 SourType 中的 undefined 替换为 新的类型 NewType
*/
export declare type ReplaceUndefined<SourType, NewType> = Replace<SourType, undefined, NewType>;
/**
* 可将源类型 SourType 中的代表空的类型 void | undefined | null 替换为 新的类型 NewType
*/
export declare type ReplaceVoid<SourType, NewType> = Replace<SourType, void | undefined | null, NewType>;
/**
* 获取 Promise 解决的类型的值
* @remarks
* 对于非 Promise 类型的值，返回原类型本身
*/
export declare type ResolveData<P> = P extends Promise<infer D> ? D : P;
/**
* 将 T 及其对象成员属性值都改为 Partial 类型
* @remarks
* 比 Partial 又深入的一层
*/
export declare type TwoLayerPartial<T> = {
[P in keyof T]?: Partial<T[P]>;
};
export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float32Array | Float64Array;
/**
* typeof 的返回类型
*/
export declare type TypeOfReturnType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
/**
* 等待可异步的结果
*
* @remarks
* 当 asyncable 为同步值时，会同步调用 callback。
* 当 asyncable 为异步值时，会等待 asyncable 解决后再调用 callback。
*
* @param asyncable - 可异步的结果
* @param callback
* @returns
*/
export declare function waitAsyncable<Result, Return>(asyncable: Result, callback: WaitAsyncableCallback<Result, Return>): WaitAsyncableReturn<Result, Return>;
/**
* waitAsyncable 的回调函数的类型
* @param result - 同步的结果
* @param rejected - 异步是否被拒绝
*/
export declare type WaitAsyncableCallback<Result, Return> = (result: ResolveData<Result> | undefined, rejected: boolean, error: any) => Return;
/**
* waitAsyncable 的返回值的类型
*/
export declare type WaitAsyncableReturn<Result, Return> = Return extends Promise<any> ? Return : (Result extends Promise<any> ? Promise<Return> : Return);
export { }