type-tls 2.7.0 → 3.0.0

package/dist/index.d.ts

@@ -1,630 +1,5 @@
-/**
- * 判断 code 是否是有校的 js 标识符
- * @param code - 标识符的字符串
- */
-export declare function isIdentifier(code: string): boolean;
-/**
- * 判断函数是否是箭头函数
- * @param fun - 被判断的函数
- */
-export declare function isArrowFunction(fun: Function): boolean;
-/**
- * 判断函数是否是 async 异步函数
- * @remarks
- * 异步函数 不包含 异步生成器函数 AsyncGeneratorFunction
- * @param fun - 被判断的函数
- */
-export declare function isAsyncFunction(fun: Function): boolean;
-/**
- * 判断函数是否是生成器函数
- *
- * @remarks
- * 生成器函数 不包含 异步生成器函数 AsyncGeneratorFunction
- * @param fun - 被判断的函数
- */
-export declare function isGeneratorFunction(fun: Function): boolean;
-/**
- * 判断函数是否是异步生成器函数
- * @param fun - 被判断的函数
- */
-export declare function isAsyncGeneratorFunction(fun: Function): boolean;
-/**
- * 判断是否是匿名函数
- *
- * @remarks
- * 判断函数在被定义时是否是通过匿名函数来定义的。
- * 匿名函数是指声明函数时没有写名字的函数。
- * 注意：即使是匿名函数，函数对象上的 name 属性也可能是有值的，因为 js解析器 会自动将 函数表达式函数变量的名字作为匿名函数的名字，如下：
- * ```ts
- * var funName = function(){};
- * ```
- * 其中的匿名函数对象的 name 属性的值会是 `funName`
- *
- * 如果 函数对象上的 name 属性的值为 `""`，函数一定是匿名函数。
- */
-export declare function isAnonymousFunction(fun: Function): boolean;
-/**
- * 表示任意的函数类型
- */
-export declare type AnyFunction = (...args: any) => any;
-/**
- * 判断目标是否是对象类型
- *
- * @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;
-/**
- * typeof 的返回类型
- */
-export declare type TypeOfReturnType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-/**
- * 宽松的类型
- */
-export declare type LooseType = undefined | null | Function | "object";
-/**
- * 宽松类型的字符串表示
- */
-export declare type LooseTypeName = "undefined" | "null" | "Function" | "object" | string;
-/**
- * 精确类型
- *
- * @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">;
-/**
- * 获取 inst 的宽松类型
- *
- * @remarks
- * 注意：
- * 本方法返回的结果如下：
- * ```
- * undefined ：undefined
- * null ： null
- * function : Function
- * 没有原型的对象(如：通过 Object.create(null) 创建的对象) : "object"
- * 其它任何类型的实例  : 返回该实例的构造函数  或 包装对象的构造函数
- * ```
- *
- *
- * @param inst
- * @returns inst 的类型
- */
-export declare function getTypeOf(inst: any): LooseType;
-/**
- * 获取 类型的字符串表示
- *
- * @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 的精确类型
- * @param inst
- * @returns inst 的类型
- */
-export declare function getExactTypeOf(inst: any): ExactType;
-/**
- * 获取 inst 的精确类型的字符串表示
- * @param inst
- * @returns  inst 的类型字符串
- */
-export declare function getExactTypeNameOf(inst: any): ExactTypeName;
-/**
- * 判断 data 是否是 基本类型
- * @remarks
- * 基本类型 是指 那些不是 对象类型的类型，即，除了 object 和 function  类型以外，其它的都是基本类型，null 也算怎是 基本类型
- * @param data - 任意类型的值
- */
-export declare function isBaseType(data: any): boolean;
-/**
- * 判断 target 是否为 类数组对象
- * @param target  -  目标
- * @returns
- */
-export declare function isArrayLike(target: any): boolean;
-/**
- * 判断 目标 是否是可迭代的对象，即 实现了 可迭代协议
- * @param target - 目标
- */
-export declare function isIterable(target: any): boolean;
-/**
- * 判断 目标 是否是迭代器，即 实现了 迭代器协议
- * @param target - 目标
- */
-export declare function isIterator(target: any): boolean;
-/**
- * 将某个类型变为可选的类型
- */
-export declare type Optional<T> = T | null | undefined;
-/**
- * 可选的布尔类型
- */
-export declare type OptionalBoolean = Optional<boolean>;
-/**
- * 获取值类型为指定类型的所有 key
- *
- * @typeParam Target - 目标对象
- * @typeParam Value - 要获取的key的对应值的类型
- */
-export declare type KeyOfValue<Target, Value> = {
-	[K in keyof Target]: Target[K] extends Value ? K : never;
-}[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 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];
-/**
- * 从 T 中挑选出那些成员值为 Value 的类型的成员
- */
-export declare type PickValue<Target, Value> = {
-	[P in KeyOfValue<Target, Value>]: Target[P];
-};
-/**
- * 从 Target 中挑选出那些成员值不是 Value 的类型的成员
- */
-export declare type PickNonValue<Target, Value> = {
-	[P in KeyOfNonValue<Target, Value>]: Target[P];
-};
-/**
- * 从 Target 中挑选出那些成员值的类型包含 Value 类型的成员
- */
-export declare type PickContainsValue<Target, Value> = {
-	[P in KeyOfContainsValue<Target, Value>]: Target[P];
-};
-/**
- * 从 Target 中挑选出那些成员值的类型不包含 Value 类型的成员
- */
-export declare type PickNonContainsValue<Target, Value> = {
-	[P in KeyOfNonContainsValue<Target, Value>]: Target[P];
-};
-/**
- * 从 Target 中挑选出属性
- */
-export declare type PickProperty<Target> = PickNonValue<Target, AnyFunction>;
-/**
- * 从 Target 中挑选出方法
- */
-export declare type PickMethod<Target> = PickValue<Target, AnyFunction>;
-/**
- * 可将源类型 SourType 中的 类型 MatchType 替换为 新的类型 NewType
- */
-export declare type Replace<SourType, MatchType, NewType> = SourType extends MatchType ? NewType : SourType;
-/**
- * 可将源类型 SourType 中的 undefined 替换为 新的类型 NewType
- */
-export declare type ReplaceUndefined<SourType, NewType> = Replace<SourType, undefined, NewType>;
-/**
- * 可将源类型 SourType 中的 null 替换为 新的类型 NewType
- */
-export declare type ReplaceNull<SourType, NewType> = Replace<SourType, null, NewType>;
-/**
- * 可将源类型 SourType 中的代表空的类型 void | undefined | null 替换为 新的类型 NewType
- */
-export declare type ReplaceVoid<SourType, NewType> = Replace<SourType, void | undefined | null, NewType>;
-/**
- * 混合
- * @internal
- */
-export declare function mixin<T, S>(target: T, source: S): T & S;
-/**
- * 混合
- * @internal
- */
-export declare function mixin<T, S1, S2>(target: T, source1: S1, source2: S2): T & S1 & S2;
-/**
- * 混合
- * @internal
- */
-export declare function mixin<T, S1, S2, S3>(target: T, source1: S1, source2: S2, source3: S3): T & S1 & S2 & S3;
-/**
- * 混合
- * @internal
- */
-export declare function mixin<T, S1, S2, S3, S4>(target: T, source1: S1, source2: S2, source3: S3, source4: S3): T & S1 & S2 & S3 & S4;
-/**
- * 混合
- *
- * @remarks
- * 将 source 的所有成员混入 target 对象中。
- *
- * 与 `Object.assign()` 的功能类似，不同的是 `mixin()` 会在 target 对象中 保持 source 对象属性的  PropertyDescriptors
- *
- * @param target - 目标对象，所有 源对象 的属性都要被混入进到 目标对象中
- * @param sources - 源对象，所有 源对象 的属性都要被混入进到 目标对象中
- * @returns 混入后的 target
- */
-export declare function mixin(target: any, ...sources: any[]): any;
-/**
- * 定义混合的类型便利函数
- *
- * @remarks
- * 它会更改 mixin 中方法的this指向为 target & mixin，不会真的执行混合操作
- *
- * @param target - 混合的目标，用作 this 的类型
- * @param mixin - 混合对象，会自动更改其this的类型
- * @returns 返回注入了 this 类型的 mixin 对象本身
- */
-export declare function defineMixin<T, M>(target: T, mixin: M & ThisType<T & M>): M & ThisType<T & M>;
-/**
- * 创建定义混合的类型便利函数
- *
- * @remarks
- * 它返回的便利函数的功能与 {@link defineMixin} 的功能一样，唯一区别是不再需要接收 target 参数了
- *
- * @returns 可以用于 定义混合的 类型便利函数
- */
-export declare function createDefineMixin<T>(): <M>(target: T, mixin: M & ThisType<T & M>) => M & ThisType<T & M>;
-/**
- * 混合目标
- *
- * @remarks
- * 与 {@link defineMixin} 的区别是：`targetMixin` 会执行对 target 的混合操作，而 {@link defineMixin} 不会
- *
- *
- * @param target - 混合的目标，用作 this 的类型
- * @param m - 混合对象，会自动更改其this的类型
- * @returns 返回注入了 this 类型的 mixin 对象本身
- */
-export declare function targetMixin<T, M>(target: T, m: M & ThisType<T & M>): M & ThisType<T & M>;
-/**
- * 创建用于混合目标的便捷函数
- *
- * @remarks
- * 它返回的便利函数的功能与 {@link targetMixin} 的功能一样，唯一区别是不再需要接收 target 参数了
- *
- * @param target - 混合的目标，用作 this 的类型
- * @returns 可以用于 混合目标 的便利函数
- */
-export declare function createTargetMixin<T>(target: T): <M>(m: M & ThisType<T & M>) => M & ThisType<T & M>;
-/**
- * 混合目标
- *
- * @remarks
- * 会执行对 CEarth 类的扩展操作。
- * 与 {@link targetMixin} 的区别仅仅是返回类型不一样。
- *
- * @param target - 混合的目标，用作 this 的类型
- * @param m - 混合对象，会自动更改其this的类型
- * @returns 返回混合后的 target 对象
- */
-export declare function mixinTarget<T, M>(target: T, m: M & ThisType<T & M>): M & ThisType<T & M> & T;
-/**
- * 创建用于混合目标工具函数
- *
- * @remarks
- * 它返回的便利函数的功能与 {@link mixinTarget} 的功能一样，唯一区别是不再需要接收 target 参数了
- *
- * @returns 可以用于 混合目标 的便利函数
- */
-export declare function createMixinTarget<T>(target: T): <M>(m: M & ThisType<T & M>) => M & ThisType<T & M> & T;
-/**
- * 类的类型、构造函数的类型
- *
- * @typeParam Arg - 构建函数的参数类型
- * @typeParam Instance - 构建函数的返回的实例类型
- */
-export interface ClassType<Arg extends any[] = any[], Instance = any> {
-	new (...args: Arg): Instance;
-}
-/**
- * 用于定义扩展选项中的私有成员
- */
-export interface PrivateMemberOfExtend<TargetType extends new (...args: any) => any> {
-	/**
-	 * 扩展类中用于定义在创建实例时的初始化的方法
-	 * @remarks
-	 * 该方法会在创建实例时自动执行，并将构建函数接收到的参数透传给方方法。
-	 *
-	 * 注意：
-	 * _constructor  会被保存在 目标类中的 _constructors 属性中，它是一个数组。
-	 *
-	 * 目标类 需要在自己的构建函数中逐个调用 cla._constructors 中的函数
-	 *
-	 * @param args
-	 */
-	_constructor?: (...args: (TargetType extends new (...args: infer A) => any ? A : never)) => void;
-}
-/**
- * 定义扩展的类型便利函数
- *
- * @remarks
- * 它会更改 ext 中方法的this指向为 cla & ext，不会真的执行扩展操作。
- *
- * 其中 ext._constructor  会被保存在 cla._constructors 属性中，它是一个数组。
- *
- * cla 需要在自己的构建函数中逐个调用 cla._constructors 中的函数
- *
- * @param cla - 扩展的目标，用作 this 的类型
- * @param ext - 描述扩展内容的对象，会自动更改其this的类型
- * @returns 返回注入了 this 类型的 ext 对象本身
- */
-export declare function defineExtend<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): E & ThisType<C & E>;
-/**
- * 扩展目标
- *
- * @remarks
- * 与 {@link defineExtend} 的区别是：`targetExtend` 会执行对 cla 的扩展操作，而 {@link defineExtend} 不会
- *
- *
- * @param cla - 扩展的目标，也用作 this 的类型
- * @param ext - 扩展描述对象，会自动更改其this的类型
- * @returns 返回注入了 this 类型的 ext 对象本身
- */
-export declare function targetExtend<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): E & ThisType<InstanceType<C> & E>;
-/**
- * 创建用于扩展目标的便捷函数
- *
- * @remarks
- * 它返回的便利函数的功能与 {@link targetExtend} 的功能一样，唯一区别是不再需要接收 cla 参数了
- *
- * @param cla - 扩展的目标，也用作 this 的类型
- * @returns 可以用于 扩展目标 的便利函数
- */
-export declare function createTargetExtend<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>) => E & ThisType<C & E>;
-/**
- * 扩展目标
- *
- * @remarks
- * 会执行对 CEarth 类的扩展操作。
- * 与 {@link targetExtend} 的区别仅仅是返回类型不一样。
- *
- * @param cla - 扩展的目标，也用作 this 的类型
- * @param ext - 扩展对象，会自动更改其this的类型
- * @returns 返回扩展后的 cla 对象
- */
-export declare function extendTarget<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
-/**
- * 创建用于扩展目标工具函数
- *
- * @remarks
- * 它返回的便利函数的功能与 {@link extendTarget} 的功能一样，唯一区别是不再需要接收 cla 参数了
- *
- * @param cla - 扩展的目标，也用作 this 的类型
- * @returns 可以用于 扩展目标 的便利函数
- */
-export declare function createExtendTarget<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>) => ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
-/**
- * 获取对象的方法的某个参数的类型
- *
- * @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;
-/**
- * 获取数组元素的类型
- * @typeParam Arr 数组
- */
-export declare type ArrayItemType<Arr> = Arr extends (infer Item)[] ? Item : never;
-/**
- * 获取 Promise 解决的类型的值
- * @remarks
- * 对于非 Promise 类型的值，返回原类型本身
- */
-export declare type ResolveData<P> = P extends Promise<infer D> ? D : P;
-/**
- * waitAsyncable 的返回值的类型
- */
-export declare type WaitAsyncableReturn<Result, Return> = Return extends Promise<any> ? Return : (Result extends Promise<any> ? Promise<Return> : Return);
-/**
- * waitAsyncable 的回调函数的类型
- * @param result -  同步的结果
- * @param rejected - 异步是否被拒绝
- */
-export declare type WaitAsyncableCallback<Result, Return> = (result: ResolveData<Result> | undefined, rejected: boolean, error: any) => Return;
-/**
- * 等待可异步的结果
- *
- * @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>;
-/**
- * 二维向量
- */
-export interface IVector2 {
-	x: number;
-	y: number;
-}
-/**
- * 三维向量
- */
-export interface IVector3 extends IVector2 {
-	z: number;
-}
-/**
- * 四维向量
- */
-export interface IVector4 extends IVector3 {
-	w: number;
-}
-/**
- * 向量
- */
-export declare type IVector = IVector2 | IVector3 | IVector4;
-/**
- * 轴名
- */
-export declare type AxisName = "x" | "y" | "z";
-/**
- * 轴
- */
-export declare enum Axis {
-	x = 0,
-	y = 1,
-	z = 2
-}
-/**
- * 轴的方法
- */
-export declare namespace Axis {
-	/**
-	 * 将轴索引转为轴名字
-	 * @param index - 索引
-	 * @returns
-	 */
-	function toKey(index: Axis): AxisName;
-	/**
-	 * 将轴名字转为轴索引
-	 * @param name
-	 * @returns
-	 */
-	function toIndex(name: AxisName): Axis;
-	/**
-	 * 获取剩余的另外两个轴
-	 * @remarks
-	 * 获取除 axis 之外的另外两个轴，且这两轴的顺序符合叉乘得 axis 轴的顺序
-	 * @param axis
-	 * @returns
-	 */
-	function getCrossAxiss(axis: Axis): [
-		Axis,
-		Axis
-	];
-}
-/**
- * 四维轴的名字
- */
-export declare type Axis4Name = "x" | "y" | "z";
-/**
- * 四维轴
- */
-export declare enum Axis4 {
-	x = 0,
-	y = 1,
-	z = 2,
-	w = 3
-}
-/**
- * 四维轴的方法
- */
-export declare namespace Axis4 {
-	/**
-	 * 将轴索引转为轴名字
-	 * @param index - 索引
-	 * @returns
-	 */
-	function toKey(index: Axis4): Axis4Name;
-	/**
-	 * 将轴名字转为轴索引
-	 * @param name
-	 * @returns
-	 */
-	function toIndex(name: Axis4Name): Axis4;
-	/**
-	 * 获取剩余的另外两个轴
-	 * @remarks
-	 * 获取除 axis 之外的另外两个轴，且这两轴的顺序符合叉乘得 axis 轴的顺序
-	 * @param axis
-	 * @returns
-	 */
-	function getCrossAxiss(axis: Axis4): [
-		Axis4,
-		Axis4
-	];
-}
-
-export {};
+export * from './base';
+export * from './function';
+export * from './member';
+export * from './async';
+export * from './buffer';

package/dist/member.d.ts

@@ -0,0 +1,21 @@
+import { AnyFunction } from "./function";
+/**
+ * 获取对象的方法的某个参数的类型
+ *
+ * @typeParam Obj - 对象
+ * @typeParam Method - 对象方法的名字
+ * @typeParam ParamIndex - 参数的索引个数
+ */
+export type MethodParams<Obj, Method extends keyof Obj, ParamIndex extends number> = Obj[Method] extends AnyFunction ? Parameters<Obj[Method]>[ParamIndex] : never;
+/**
+ * 获取对象的方法的返回的类型
+ *
+ * @typeParam Obj - 对象
+ * @typeParam Method - 对象方法的名字
+ */
+export type MethodReturnType<Obj, Method extends keyof Obj> = Obj[Method] extends AnyFunction ? ReturnType<Obj[Method]> : never;
+/**
+ * 获取数组元素的类型
+ * @typeParam Arr 数组
+ */
+export type ArrayItemType<Arr> = Arr extends (infer Item)[] ? Item : never;

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.29.5"
+      "packageVersion": "7.39.1"
     }
   ]
 }