type-tls 2.4.3 → 2.4.5

package/dist/function.d.ts

@@ -1,49 +0,0 @@
-/**
- * 判断 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;

package/dist/member.d.ts

@@ -1,16 +0,0 @@
-import { AnyFunction } from "./function";
-/**
- * 获取对象的方法的某个参数的类型
- *
- * @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;

package/dist/mixin.d.ts

@@ -1,96 +0,0 @@
-/**
- * 混合
- * @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;

package/dist/type-tls.es.js

@@ -1,171 +0,0 @@
-var _a, _b, _c;
-function isObject(target) {
-  var tarType = typeof target;
-  return target && (tarType === "object" || tarType === "function");
-}
-function getTypeOf(inst) {
-  var typeInfo = inst;
-  if (inst != null) {
-    typeInfo = inst.constructor;
-    if (typeInfo == void 0) {
-      typeInfo = typeof inst;
-    }
-  }
-  return typeInfo;
-}
-function getNameOfType(t) {
-  switch (t) {
-    case void 0:
-      return "undefined";
-    case null:
-      return "null";
-  }
-  let tType = typeof t;
-  switch (tType) {
-    case "function":
-      return t.name;
-    case "string":
-      return t;
-    default:
-      return tType;
-  }
-}
-function getTypeByName(typeName) {
-  return globalThis[typeName];
-}
-function getTypeNameOf(inst) {
-  let t = getTypeOf(inst);
-  return getNameOfType(t);
-}
-function getExactTypeOf(inst) {
-  if (inst == null || isObject(inst)) {
-    return getTypeOf(inst);
-  }
-  return typeof inst;
-}
-function getExactTypeNameOf(inst) {
-  var t = getExactTypeOf(inst);
-  return getNameOfType(t);
-}
-function isBaseType(data) {
-  var typeStr = typeof data;
-  return data == null || typeStr !== "object" && typeStr !== "function";
-}
-function isArrayLike(target) {
-  let length = target && target.length;
-  return Number.isInteger(target.length) && length >= 0;
-}
-function isIterable(target) {
-  return target && typeof target[Symbol.iterator] === "function";
-}
-function isIterator(target) {
-  return target && typeof target.next === "function";
-}
-function mixin(target, ...sources) {
-  for (const s of sources) {
-    const propDes = Object.getOwnPropertyDescriptors(s);
-    Object.defineProperties(target, propDes);
-  }
-  return target;
-}
-function defineMixin(target, mixin2) {
-  return mixin2;
-}
-function createDefineMixin() {
-  return function defineMixin2(target, mixin2) {
-    return mixin2;
-  };
-}
-function targetMixin(target, m) {
-  mixin(target, m);
-  return m;
-}
-function createTargetMixin(target) {
-  return function targetMixin2(m) {
-    mixin(target, m);
-    return m;
-  };
-}
-function mixinTarget(target, m) {
-  mixin(target, m);
-  return target;
-}
-function createMixinTarget(target) {
-  return function mixinTarget2(m) {
-    mixin(target, m);
-    return target;
-  };
-}
-function defineExtend(cla, ext) {
-  return ext;
-}
-function targetExtend(cla, ext) {
-  var _a2;
-  mixin(cla.prototype, ext);
-  const _constructor = ext._constructor;
-  if (typeof _constructor === "function") {
-    const target = cla;
-    const _constructors = (_a2 = target._constructors) != null ? _a2 : target._constructors = [];
-    _constructors.push(_constructor);
-  }
-  return ext;
-}
-function createTargetExtend(cla) {
-  return function classExtend(ext) {
-    targetExtend(cla, ext);
-    return ext;
-  };
-}
-function extendTarget(cla, ext) {
-  targetExtend(cla, ext);
-  return cla;
-}
-function createExtendTarget(cla) {
-  return function extendTarget2(ext) {
-    targetExtend(cla, ext);
-    return cla;
-  };
-}
-const jsIdentifier = /^[A-Za-z_$]+[\w$]*$/;
-function isIdentifier(code) {
-  return jsIdentifier.test(code);
-}
-const arrowFunctionRegExpOfFunString = /(^\s*(async\s+)?\s*(\b[A-Za-z_$]+[\w$]*\b)\s*=>)|(^\s*(async\s+)?\s*\(\s*(\b[A-Za-z_$]+[\w$]*\b)?\s*(,\s*(\b[A-Za-z_$]+[\w$]*\b)\s*)*\)\s*=>)/;
-function isArrowFunction(fun) {
-  const funStr = fun.toString();
-  return arrowFunctionRegExpOfFunString.test(funStr);
-}
-const AsyncFun = (_a = globalThis.AsyncFunction) != null ? _a : async function() {
-}.constructor;
-function isAsyncFunction(fun) {
-  return fun instanceof AsyncFun;
-}
-const GeneratorFun = (_b = globalThis.GeneratorFunction) != null ? _b : function* () {
-}.constructor;
-function isGeneratorFunction(fun) {
-  return fun instanceof GeneratorFun;
-}
-const AsyncGeneratorFun = (_c = globalThis.AsyncGeneratorFunction) != null ? _c : async function* () {
-}.constructor;
-function isAsyncGeneratorFunction(fun) {
-  return fun instanceof AsyncGeneratorFun;
-}
-const funNameRegExpOfFunString = /(^\s*(async\s+)?function\s*(\s|\*)\s*)[A-Za-z_$]+[\w$]*(\s*\()/;
-function isAnonymousFunction(fun) {
-  if (fun.name) {
-    const funStr = fun.toString();
-    return !funNameRegExpOfFunString.test(funStr);
-  }
-  return true;
-}
-function waitAsyncable(asyncable, callback) {
-  if (asyncable instanceof Promise) {
-    return asyncable.then((syncRes) => {
-      return callback(syncRes, false, void 0);
-    }, (error) => {
-      return callback(void 0, true, error);
-    });
-  }
-  return callback(asyncable, false, void 0);
-}
-export { createDefineMixin, createExtendTarget, createMixinTarget, createTargetExtend, createTargetMixin, defineExtend, defineMixin, extendTarget, getExactTypeNameOf, getExactTypeOf, getNameOfType, getTypeByName, getTypeNameOf, getTypeOf, isAnonymousFunction, isArrayLike, isArrowFunction, isAsyncFunction, isAsyncGeneratorFunction, isBaseType, isGeneratorFunction, isIdentifier, isIterable, isIterator, isObject, mixin, mixinTarget, targetExtend, targetMixin, waitAsyncable };