@zwa73/utils 1.0.131 → 1.0.134

package/dist/QuickFunction.d.ts

@@ -1,4 +1,4 @@
 import { UtilFT } from "./UtilFileTools";
 import { UtilFunc } from "./UtilFunctions";
-export declare const outcome: typeof UtilFunc.outcome, matchProc: typeof UtilFunc.matchProc, sucesProc: typeof UtilFunc.sucesProc, isFailed: typeof UtilFunc.isFailed, isSafeNumber: typeof UtilFunc.isSafeNumber, isSuccess: typeof UtilFunc.isSuccess, likeNone: typeof UtilFunc.likeNone, expect: typeof UtilFunc.expect, assertType: typeof UtilFunc.assertType, assertLiteral: typeof UtilFunc.assertLiteral, deepClone: typeof UtilFunc.deepClone, sleep: typeof UtilFunc.sleep, stringifyJToken: typeof UtilFunc.stringifyJToken, getTime: typeof UtilFunc.getTime, mapEntries: typeof UtilFunc.mapEntries, dedent: typeof UtilFunc.dedent, throwError: typeof UtilFunc.throwError, eitherify: typeof UtilFunc.eitherify, taskEitherify: typeof UtilFunc.taskEitherify;
+export declare const outcome: typeof UtilFunc.outcome, matchProc: typeof UtilFunc.matchProc, sucesProc: typeof UtilFunc.sucesProc, isFailed: typeof UtilFunc.isFailed, isSafeNumber: typeof UtilFunc.isSafeNumber, isSuccess: typeof UtilFunc.isSuccess, likeNone: typeof UtilFunc.likeNone, expect: typeof UtilFunc.expect, assertType: typeof UtilFunc.assertType, assertLiteral: typeof UtilFunc.assertLiteral, deepClone: typeof UtilFunc.deepClone, sleep: typeof UtilFunc.sleep, stringifyJToken: typeof UtilFunc.stringifyJToken, getTime: typeof UtilFunc.getTime, mapEntries: typeof UtilFunc.mapEntries, dedent: typeof UtilFunc.dedent, throwError: typeof UtilFunc.throwError, eitherize: typeof UtilFunc.eitherize, taskEitherize: typeof UtilFunc.taskEitherize, memoize: typeof UtilFunc.memoize, ivk: typeof UtilFunc.ivk;
 export declare const stylizePath: typeof UtilFT.stylizePath, posixizePath: typeof UtilFT.posixizePath, win32izePath: typeof UtilFT.win32izePath, currosizePath: typeof UtilFT.currosizePath;

package/dist/QuickFunction.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.currosizePath = exports.win32izePath = exports.posixizePath = exports.stylizePath = exports.taskEitherify = exports.eitherify = exports.throwError = exports.dedent = exports.mapEntries = exports.getTime = exports.stringifyJToken = exports.sleep = exports.deepClone = exports.assertLiteral = exports.assertType = exports.expect = exports.likeNone = exports.isSuccess = exports.isSafeNumber = exports.isFailed = exports.sucesProc = exports.matchProc = exports.outcome = void 0;
+exports.currosizePath = exports.win32izePath = exports.posixizePath = exports.stylizePath = exports.ivk = exports.memoize = exports.taskEitherize = exports.eitherize = exports.throwError = exports.dedent = exports.mapEntries = exports.getTime = exports.stringifyJToken = exports.sleep = exports.deepClone = exports.assertLiteral = exports.assertType = exports.expect = exports.likeNone = exports.isSuccess = exports.isSafeNumber = exports.isFailed = exports.sucesProc = exports.matchProc = exports.outcome = void 0;
 const UtilFileTools_1 = require("./UtilFileTools");
 const UtilFunctions_1 = require("./UtilFunctions");
 const UtilSymbol_1 = require("./UtilSymbol");
-exports.outcome = UtilFunctions_1.UtilFunc.outcome, exports.matchProc = UtilFunctions_1.UtilFunc.matchProc, exports.sucesProc = UtilFunctions_1.UtilFunc.sucesProc, exports.isFailed = UtilFunctions_1.UtilFunc.isFailed, exports.isSafeNumber = UtilFunctions_1.UtilFunc.isSafeNumber, exports.isSuccess = UtilFunctions_1.UtilFunc.isSuccess, exports.likeNone = UtilFunctions_1.UtilFunc.likeNone, exports.expect = UtilFunctions_1.UtilFunc.expect, exports.assertType = UtilFunctions_1.UtilFunc.assertType, exports.assertLiteral = UtilFunctions_1.UtilFunc.assertLiteral, exports.deepClone = UtilFunctions_1.UtilFunc.deepClone, exports.sleep = UtilFunctions_1.UtilFunc.sleep, exports.stringifyJToken = UtilFunctions_1.UtilFunc.stringifyJToken, exports.getTime = UtilFunctions_1.UtilFunc.getTime, exports.mapEntries = UtilFunctions_1.UtilFunc.mapEntries, exports.dedent = UtilFunctions_1.UtilFunc.dedent, exports.throwError = UtilFunctions_1.UtilFunc.throwError, exports.eitherify = UtilFunctions_1.UtilFunc.eitherify, exports.taskEitherify = UtilFunctions_1.UtilFunc.taskEitherify;
+exports.outcome = UtilFunctions_1.UtilFunc.outcome, exports.matchProc = UtilFunctions_1.UtilFunc.matchProc, exports.sucesProc = UtilFunctions_1.UtilFunc.sucesProc, exports.isFailed = UtilFunctions_1.UtilFunc.isFailed, exports.isSafeNumber = UtilFunctions_1.UtilFunc.isSafeNumber, exports.isSuccess = UtilFunctions_1.UtilFunc.isSuccess, exports.likeNone = UtilFunctions_1.UtilFunc.likeNone, exports.expect = UtilFunctions_1.UtilFunc.expect, exports.assertType = UtilFunctions_1.UtilFunc.assertType, exports.assertLiteral = UtilFunctions_1.UtilFunc.assertLiteral, exports.deepClone = UtilFunctions_1.UtilFunc.deepClone, exports.sleep = UtilFunctions_1.UtilFunc.sleep, exports.stringifyJToken = UtilFunctions_1.UtilFunc.stringifyJToken, exports.getTime = UtilFunctions_1.UtilFunc.getTime, exports.mapEntries = UtilFunctions_1.UtilFunc.mapEntries, exports.dedent = UtilFunctions_1.UtilFunc.dedent, exports.throwError = UtilFunctions_1.UtilFunc.throwError, exports.eitherize = UtilFunctions_1.UtilFunc.eitherize, exports.taskEitherize = UtilFunctions_1.UtilFunc.taskEitherize, exports.memoize = UtilFunctions_1.UtilFunc.memoize, exports.ivk = UtilFunctions_1.UtilFunc.ivk;
 exports.stylizePath = UtilFileTools_1.UtilFT.stylizePath, exports.posixizePath = UtilFileTools_1.UtilFT.posixizePath, exports.win32izePath = UtilFileTools_1.UtilFT.win32izePath, exports.currosizePath = UtilFileTools_1.UtilFT.currosizePath;
 if (false) {
     let aaser = (0, exports.assertLiteral)({ a: 1 });

package/dist/UtilDecorators.d.ts

@@ -1,3 +1,4 @@
+import { NeedInit } from "./UtilInterfaces";
 type TDTg<T> = (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
 type DTg = (target: Object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**用于打印方法运行时间
@@ -26,4 +27,6 @@ export declare function DeferAsync<T extends (...args: any) => Promise<any>>(def
 export declare function Catch<T extends (...args: any) => any>(catchLogic: (error: any, ...args: Parameters<T>) => ReturnType<T>): TDTg<T>;
 /**异步的try-catch包装 */
 export declare function CatchAsync<T extends (...args: any) => Promise<any>>(catchLogic: (error: any, ...args: Parameters<T>) => ReturnType<T>): TDTg<T>;
+/**等待完成init */
+export declare function AwaitInited<T extends NeedInit>(target: T, propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>): TypedPropertyDescriptor<(...args: any[]) => Promise<any>>;
 export {};

package/dist/UtilDecorators.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CatchAsync = exports.Catch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = exports.LogTimeAsync = exports.LogTime = void 0;
+exports.AwaitInited = exports.CatchAsync = exports.Catch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = exports.LogTimeAsync = exports.LogTime = void 0;
 const UtilFunctions_1 = require("./UtilFunctions");
 const UtilLogger_1 = require("./UtilLogger");
 /**用于打印方法运行时间
@@ -179,6 +179,16 @@ function CatchAsync(catchLogic) {
     };
 }
 exports.CatchAsync = CatchAsync;
+/**等待完成init */
+function AwaitInited(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function (...args) {
+        await this.inited;
+        return await originalMethod.apply(this, args);
+    };
+    return descriptor;
+}
+exports.AwaitInited = AwaitInited;
 function AddNumberDecorator(n) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;

package/dist/UtilFunctions.d.ts

@@ -237,25 +237,24 @@ export declare class UtilFunc {
         lineNumber: `${number}:${number}`;
     } | undefined;
     private static publicIp?;
-    /**获取当前公网ipv4
-     */
+    /**获取当前公网ipv4 */
     static getPublicIpv4(): Promise<string>;
-    /**将传入函数包装为显示处理错误的函数
+    /**将传入函数包装为显式处理错误的函数
      * @param func - 待转换函数
      * @returns 转换完成的函数
      */
-    static eitherify<T extends AnyFunc>(func: T): (...args: Parameters<T>) => Outcome<typeof Success, ReturnType<T>> | Outcome<typeof Failed, Error>;
-    /**将传入的异步函数包装为显示处理错误的函数
+    static eitherize<T extends AnyFunc>(func: T): (...args: Parameters<T>) => Outcome<typeof Success, ReturnType<T>> | Outcome<typeof Failed, Error>;
+    /**将传入的异步函数包装为显式处理错误的函数
      * @param func - 待转换函数
      * @returns 转换完成的函数
      */
-    static taskEitherify<T extends (...args: any) => Promise<any>>(func: T): (...args: Parameters<T>) => Promise<Outcome<typeof Failed, Error> | Outcome<typeof Success, Await<ReturnType<T>>>>;
+    static taskEitherize<T extends (...args: any) => Promise<any>>(func: T): (...args: Parameters<T>) => Promise<Outcome<typeof Failed, Error> | Outcome<typeof Success, Await<ReturnType<T>>>>;
     /**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。
      * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。
      * 请注意，这个函数使用了eval()，可能会带来安全风险。
      *
-     * @param {string} moduleName - 需要导入的模块的名称。
-     * @returns {Promise<any>} 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
+     * @param moduleName - 需要导入的模块的名称。
+     * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
      *
      * @example
      * async function main() {
@@ -267,5 +266,22 @@ export declare class UtilFunc {
      * @since Node.js 13.2，Node.js开始支持动态import。
      */
     static dynamicImport(moduleName: string): Promise<any>;
+    /**缓存池 */
+    static cachePool: WeakMap<Function, Map<string, {
+        result: any;
+        timestamp: number;
+    }>>;
+    /**立即执行传入的函数
+     * @param fn - 需要立即执行的函数。
+     * @returns 返回 fn 函数的执行结果。
+     */
+    static ivk<T extends () => any>(fn: T): ReturnType<T>;
+    /**创建一个带有缓存有效期的memoize函数
+     * 只在传入值均为JToken时有效
+     * @param fn     - 需要被memoize的函数
+     * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
+     * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
+     */
+    static memoize<T extends (...args: JToken[]) => any>(fn: T, expiry?: number): T;
 }
 export {};

package/dist/UtilFunctions.js

@@ -623,18 +623,17 @@ class UtilFunc {
         return undefined;
     }
     static publicIp;
-    /**获取当前公网ipv4
-     */
+    /**获取当前公网ipv4 */
     static async getPublicIpv4() {
         if (UtilFunc.publicIp === undefined)
             UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip');
         return UtilFunc.publicIp.publicIpv4();
     }
-    /**将传入函数包装为显示处理错误的函数
+    /**将传入函数包装为显式处理错误的函数
      * @param func - 待转换函数
      * @returns 转换完成的函数
      */
-    static eitherify(func) {
+    static eitherize(func) {
         return (...args) => {
             try {
                 const result = func(...args);
@@ -647,11 +646,11 @@ class UtilFunc {
             }
         };
     }
-    /**将传入的异步函数包装为显示处理错误的函数
+    /**将传入的异步函数包装为显式处理错误的函数
      * @param func - 待转换函数
      * @returns 转换完成的函数
      */
-    static taskEitherify(func) {
+    static taskEitherize(func) {
         return async (...args) => {
             try {
                 const result = await func(...args);
@@ -668,8 +667,8 @@ class UtilFunc {
      * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。
      * 请注意，这个函数使用了eval()，可能会带来安全风险。
      *
-     * @param {string} moduleName - 需要导入的模块的名称。
-     * @returns {Promise<any>} 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
+     * @param moduleName - 需要导入的模块的名称。
+     * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
      *
      * @example
      * async function main() {
@@ -683,6 +682,38 @@ class UtilFunc {
     static async dynamicImport(moduleName) {
         return await eval(`import('${moduleName}')`);
     }
+    /**缓存池 */
+    static cachePool = new WeakMap();
+    /**立即执行传入的函数
+     * @param fn - 需要立即执行的函数。
+     * @returns 返回 fn 函数的执行结果。
+     */
+    static ivk(fn) {
+        return fn();
+    }
+    /**创建一个带有缓存有效期的memoize函数
+     * 只在传入值均为JToken时有效
+     * @param fn     - 需要被memoize的函数
+     * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
+     * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
+     */
+    static memoize(fn, expiry = Infinity) {
+        const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(() => {
+            const c = new Map();
+            UtilFunc.cachePool.set(fn, c);
+            return c;
+        });
+        return ((...args) => {
+            const key = JSON.stringify(args);
+            const now = Date.now();
+            const cached = cache.get(key);
+            if (cached && now - cached.timestamp < expiry)
+                return cached.result;
+            const result = fn(...args);
+            cache.set(key, { result, timestamp: now });
+            return result;
+        });
+    }
 }
 exports.UtilFunc = UtilFunc;
 __decorate([

package/dist/UtilInterfaces.d.ts

@@ -187,4 +187,11 @@ export type ExtractOutcome<T, K extends Keyable> = T extends Outcome<infer O, un
  * 输出schema后替换为 ^.*$ 的 string 匹配
  */
 export type SchemaString = `${string}SchemaString`;
+/**需要初始化 */
+export type NeedInit = {
+    /**完成初始化的标记 */
+    inited: Promise<void>;
+};
+/**可选的record */
+export type PRecord<K extends Keyable, V> = Partial<Record<K, V>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.131",
+	"version": "1.0.134",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {

package/scripts/postinstall.js

@@ -32,7 +32,7 @@ function showUpgradeMessages(prevVersion, currentVersion) {
     // 遍历infoTable中的所有版本
     for (const version in INFO_TABLE) {
         const versionNumber = versionToNumber(version);
-        console.log(versionNumber,prevVersionNumber,currentVersionNumber)
+        //console.log(versionNumber,prevVersionNumber,currentVersionNumber)
         // 如果用户的上一个版本低于这个版本，而当前版本高于或等于这个版本
         if (versionNumber > prevVersionNumber && versionNumber <= currentVersionNumber) {
             // 显示这个版本的提示信息

package/src/QuickFunction.ts

@@ -21,8 +21,10 @@ export const {
     mapEntries,
     dedent,
     throwError,
-    eitherify,
-    taskEitherify,
+    eitherize,
+    taskEitherize,
+    memoize,
+    ivk,
 } = UtilFunc;
 
 export const {

package/src/UtilDecorators.ts

@@ -1,5 +1,5 @@
 import { UtilFunc } from "./UtilFunctions";
-import { Await } from "./UtilInterfaces";
+import { Await, NeedInit } from "./UtilInterfaces";
 import { SLogger } from "./UtilLogger";
 
 type TDTg<T> = 
@@ -169,7 +169,18 @@ export function CatchAsync<T extends (...args:any)=>Promise<any>>
     };
 }
 
+/**等待完成init */
+export function AwaitInited<T extends NeedInit>
+    (target:T, propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>) {
+    const originalMethod = descriptor.value!;
 
+    descriptor.value = async function(this:T,...args: any[]) {
+        await this.inited;
+        return await originalMethod.apply(this, args);
+    };
+
+    return descriptor;
+}
 
 
 function AddNumberDecorator(n: number) {
@@ -190,6 +201,8 @@ function AddNumberDecorator(n: number) {
 }
 
 
+
+
 class Example {
     @AddNumberDecorator(10)
     myMethod(num: number): number {

package/src/UtilFunctions.ts

@@ -1,9 +1,9 @@
 import * as crypto from "crypto";
-import { AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqStat, ReqVerifyFn, ProperSubset, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await } from "@src/UtilInterfaces";
+import { AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await } from "@src/UtilInterfaces";
 import * as cp from "child_process";
 import { LogLevel, SLogger } from "@src/UtilLogger";
 import { Completed, Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
-import { Catch, DeferAsync, LogTimeAsync } from "./UtilDecorators";
+import { LogTimeAsync } from "./UtilDecorators";
 import opath from 'path';
 import { UtilFT } from "./UtilFileTools";
 import {inspect} from 'util';
@@ -715,19 +715,18 @@ static getFuncLoc(stack=1) {
 
 private static publicIp?:typeof publicIp;
 
-/**获取当前公网ipv4
- */
+/**获取当前公网ipv4 */
 static async getPublicIpv4(){
     if(UtilFunc.publicIp===undefined)
         UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip') as typeof publicIp;
     return UtilFunc.publicIp.publicIpv4();
 }
 
-/**将传入函数包装为显示处理错误的函数
+/**将传入函数包装为显式处理错误的函数
  * @param func - 待转换函数
  * @returns 转换完成的函数
  */
-static eitherify<T extends AnyFunc>(func:T) {
+static eitherize<T extends AnyFunc>(func:T) {
     return (...args: Parameters<T>) => {
         try {
             const result:ReturnType<T> = func(...args as any);
@@ -739,11 +738,11 @@ static eitherify<T extends AnyFunc>(func:T) {
         }
     };
 }
-/**将传入的异步函数包装为显示处理错误的函数
+/**将传入的异步函数包装为显式处理错误的函数
  * @param func - 待转换函数
  * @returns 转换完成的函数
  */
-static taskEitherify<T extends (...args:any)=>Promise<any>>(func:T) {
+static taskEitherize<T extends (...args:any)=>Promise<any>>(func:T) {
     return async (...args: Parameters<T>) => {
         try {
             const result:Await<ReturnType<T>> = await func(...args as any);
@@ -760,8 +759,8 @@ static taskEitherify<T extends (...args:any)=>Promise<any>>(func:T) {
  * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。  
  * 请注意，这个函数使用了eval()，可能会带来安全风险。  
  *
- * @param {string} moduleName - 需要导入的模块的名称。
- * @returns {Promise<any>} 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
+ * @param moduleName - 需要导入的模块的名称。
+ * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
  *
  * @example
  * async function main() {
@@ -776,4 +775,45 @@ static async dynamicImport(moduleName:string):Promise<any> {
     return await eval(`import('${moduleName}')`);
 }
 
+/**缓存池 */
+static cachePool = new WeakMap<Function, Map<string, { result: any, timestamp: number }>>();
+
+
+
+/**立即执行传入的函数  
+ * @param fn - 需要立即执行的函数。
+ * @returns 返回 fn 函数的执行结果。
+ */
+static ivk<T extends ()=>any>(fn:T): ReturnType<T> {
+    return fn();
+}
+
+/**创建一个带有缓存有效期的memoize函数  
+ * 只在传入值均为JToken时有效
+ * @param fn     - 需要被memoize的函数
+ * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
+ * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
+ */
+static memoize<T extends (...args:JToken[])=>any> (fn: T, expiry = Infinity): T {
+    const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(()=>{
+        const c = new Map();
+        UtilFunc.cachePool.set(fn, c);
+        return c;
+    });
+
+    return ((...args: Parameters<T>): ReturnType<T> => {
+        const key = JSON.stringify(args);
+        const now = Date.now();
+        const cached = cache.get(key);
+
+        if (cached && now - cached.timestamp < expiry)
+            return cached.result;
+
+        const result = fn(...args);
+        cache.set(key, { result, timestamp: now });
+        return result;
+    }) as T;
+}
+
+
 }

package/src/UtilInterfaces.ts

@@ -277,4 +277,11 @@ export type ExtractOutcome<T,K extends Keyable> =
  */
 export type SchemaString = `${string}SchemaString`;
 
+/**需要初始化 */
+export type NeedInit = {
+    /**完成初始化的标记 */
+    inited: Promise<void>;
+};
 
+/**可选的record */
+export type PRecord<K extends Keyable,V> = Partial<Record<K,V>>;