@zwa73/utils 1.0.163 → 1.0.165

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { PRecord, AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await, AnyRecord, AllExtends } from "./UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, Await, AnyRecord, AllExtends } from "./UtilInterfaces";
 import { LogLevel } from "./UtilLogger";
 import { Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Timeout } from "./UtilSymbol";
 declare const HashMethodList: readonly ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "blake3"];
@@ -32,6 +32,12 @@ export type RepeatPromiseOpt = Partial<{
 }>;
 type SuccessOut<T> = Outcome<Success, T>;
 type TimeoutOut<T> = Outcome<Timeout, Promise<T>>;
+/**遍历对象的回调函数
+ * @param key       - 字段名
+ * @param value     - 字段值
+ * @param parent    - 父对象
+ */
+type EachFieldCallback = (key: string, value: JToken, parent: JObject) => void;
 /**常用函数 */
 export declare class UtilFunc {
     /**获取当前时间戳
@@ -111,21 +117,6 @@ export declare class UtilFunc {
      * @returns 超时则返回 处理函数委托 完成则返回结果
      */
     static timelimitPromise<T>(func: () => Promise<T> | T, timeLimit?: number): Promise<SuccessOut<T> | TimeoutOut<T>>;
-    /**部分类组合
-     * 将mixin的部分字段混入base
-     * @param base   - 基础类
-     * @param mixin  - 目标类
-     * @param key    - mixin 对象在 base 中的 key
-     * @param fields - 需要混入的字段
-     * @returns 混合完成的类
-     */
-    static composeClassPart<Base extends AnyRecord, Mixin extends AnyRecord, Field extends keyof Mixin>(base: Base, mixin: Mixin, key: string, ...fields: Field[]): ComposedClass<Base, Mixin, typeof key, Field>;
-    /**根据 MIXIN_FIELDS 自动混入
-     * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
-     */
-    static composeMixinable<Base extends AnyRecord, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
-    /**根据 MIXIN_FIELDS 自动混入 */
-    static composeRefMixinable<Base extends AnyRecord, Mixins extends RefMixinable<any, unknown>[]>(base: Base, ...mixins: Mixins): ComposedRefMixinable<Base, Mixins>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
@@ -133,6 +124,11 @@ export declare class UtilFunc {
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
     static mapEntries<T extends AnyRecord>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
+    /**遍历对象的所有字段
+     * @param obj       - 对象
+     * @param callback  - 回调函数
+     */
+    static eachField(obj: JToken, callback: EachFieldCallback): void;
     /**将JToken转换为字符串
      * @param token - 待转换的Token
      * @param opt   - 可选参数

package/dist/UtilFunctions.js

@@ -286,86 +286,6 @@ class UtilFunc {
             reslove(result);
         });
     }
-    /**部分类组合
-     * 将mixin的部分字段混入base
-     * @param base   - 基础类
-     * @param mixin  - 目标类
-     * @param key    - mixin 对象在 base 中的 key
-     * @param fields - 需要混入的字段
-     * @returns 混合完成的类
-     */
-    static composeClassPart(base, mixin, key, ...fields) {
-        const compObj = base;
-        if (compObj[key] !== undefined)
-            UtilLogger_1.SLogger.warn(`key: ${key} 已存在于基础类中, 混入可能导致类型问题`);
-        compObj[key] = mixin;
-        for (const fd of fields) {
-            if (compObj[fd] !== undefined)
-                UtilLogger_1.SLogger.warn(`field: ${fd} 已存在于基础类中, 混入可能导致类型问题, 如需覆盖, 请使用 ${key}=val`);
-            //func需绑定this无法直接设置属性
-            if (typeof mixin[fd] === 'function') {
-                compObj[fd] = (...args) => compObj[key][fd](...args);
-                //#region other
-                //const memo = (...args: any[]) => compObj[key][fd](...args);
-                //Object.defineProperty(compObj, fd, {
-                //    get:()=>memo,
-                //    set:()=>SLogger.warn(new Error(`试图修改一个由 composeClassPart 组合的函数字段:${String(fd)}, 修改已被忽略`)),
-                //    enumerable:true ,
-                //    //writable: true  ,
-                //    configurable: true
-                //});
-                //(compObj as any)[fd] = (...args: any[]) => (mixin[fd] as any).apply(mixin, args);
-                //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
-                //#endregion
-            }
-            else {
-                Object.defineProperty(compObj, fd, {
-                    get: () => compObj[key][fd],
-                    set: (value) => { compObj[key][fd] = value; },
-                    enumerable: true,
-                    //writable: true  ,
-                    configurable: true
-                });
-            }
-        }
-        return compObj;
-    }
-    /**根据 MIXIN_FIELDS 自动混入
-     * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
-     */
-    static composeMixinable(base, ...mixins) {
-        let out = base;
-        const fieldsSet = new Set();
-        for (const rawmixin of mixins) {
-            const mixin = rawmixin;
-            for (const field of mixin.MIXIN_FIELDS) {
-                const fixField = field;
-                if (fieldsSet.has(fixField))
-                    UtilLogger_1.SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-                else
-                    fieldsSet.add(fixField);
-            }
-            out = UtilFunc.composeClassPart(base, mixin, mixin.MIXIN_KEY, ...mixin.MIXIN_FIELDS);
-        }
-        return out;
-    }
-    /**根据 MIXIN_FIELDS 自动混入 */
-    static composeRefMixinable(base, ...mixins) {
-        let out = base;
-        const fieldsSet = new Set();
-        for (const mixin of mixins) {
-            const ctor = mixin.CTOR;
-            for (const field of ctor.MIXIN_FIELDS) {
-                const fixField = field;
-                if (fieldsSet.has(fixField))
-                    UtilLogger_1.SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-                else
-                    fieldsSet.add(fixField);
-            }
-            out = UtilFunc.composeClassPart(base, mixin, ctor.MIXIN_KEY, ...ctor.MIXIN_FIELDS);
-        }
-        return out;
-    }
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
@@ -378,6 +298,29 @@ class UtilFunc {
             return result;
         }, {});
     }
+    /**遍历对象的所有字段
+     * @param obj       - 对象
+     * @param callback  - 回调函数
+     */
+    static eachField(obj, callback) {
+        if (obj == null)
+            return;
+        if (typeof obj === 'object' && 'toJSON' in obj && typeof obj.toJSON == 'function') {
+            UtilLogger_1.SLogger.warn('UtilFunc.eachField 错误 无法遍历IJData 已跳过');
+            return;
+        }
+        if (Array.isArray(obj)) {
+            for (const item of obj)
+                UtilFunc.eachField(item, callback);
+            return;
+        }
+        if (typeof obj === 'object') {
+            for (const [k, v] of Object.entries(obj)) {
+                UtilFunc.eachField(v, callback);
+                callback(k, v, obj);
+            }
+        }
+    }
     /**将JToken转换为字符串
      * @param token - 待转换的Token
      * @param opt   - 可选参数

package/dist/UtilInterfaces.d.ts

@@ -107,57 +107,6 @@ export type Await<T> = T extends Promise<infer U> ? U : T;
 export type FuncPropNames<T> = {
     [K in keyof T]: T[K] extends AnyFunc ? K : never;
 }[keyof T];
-/**部分组合的类
- * @template Base     - 基类
- * @template Mixin    - 待混入的类
- * @template PropKeys - 需要混入的成员key
- */
-export type ComposedClass<Base, Mixin, Key extends string, PropKeys extends keyof Mixin> = Base & Pick<Mixin, PropKeys> & {
-    [P in Key]: Mixin;
-};
-/**可自动混入的类型 */
-export type Mixinable<Mixin> = {
-    /**混入时自身所在位置
-     * 请使用字面量
-     */
-    readonly MIXIN_KEY: string;
-    /**可混入的字段
-     * 请使用字面量
-    */
-    readonly MIXIN_FIELDS: readonly (keyof Mixin)[];
-};
-/**是原型构造器类型 */
-export type IsCtor<T> = T extends {
-    new (): infer Ins;
-} ? T : never;
-/**可反射的
- * @template Ctor        - 构造器类型
- * @template Constraint  - 构造器约束
- */
-export type ReflectionAble<Ctor, Constraint = {}> = {
-    /**原型构造器 */
-    readonly CTOR: Ctor & Constraint;
-};
-/**可反射的 且 构造函数是可混入的类
- * @template Ctor        - 构造器类型
- * @template Instance    - 实例类型 如果采用了内部混入, 那么填入对外实际暴露的类型, 以支持混入多层字段
- * @template Constraint  - 构造器约束
- * @example
- * export class MixinModule implements RefMixinable<typeof MixinModule,MixinModule>{
- *   static readonly MIXIN_FIELDS = [
- *       'func_a',
- *       'field_b'
- *   ] as const;
- *   static readonly MIXIN_KEY = '__mixinModule';
- *   CTOR = MixinModule;
- * }
- */
-export type RefMixinable<Ctor, Instance, Constraint = {}> = ReflectionAble<Ctor, Mixinable<Instance> & Constraint>;
-/**自动组合可混入的类
- */
-export type ComposedMixinable<B, Ms extends unknown[]> = Ms extends [infer M, ...infer Rest] ? M extends Mixinable<M> ? ComposedMixinable<ComposedClass<B, M, M['MIXIN_KEY'], M['MIXIN_FIELDS'][number]>, Rest> : "一个混入类没有实现 Mixinable<self>" & Error : B;
-/**自动组合 可反射的 且 构造函数是可混入的 类 */
-export type ComposedRefMixinable<B, Ms extends unknown[]> = Ms extends [infer M, ...infer Rest] ? M extends RefMixinable<unknown, M> ? ComposedRefMixinable<ComposedClass<B, M, M['CTOR']['MIXIN_KEY'], M['CTOR']['MIXIN_FIELDS'][number]>, Rest> : "一个混入类没有实现  RefMixinable<typeof self, self>" & Error : B;
 /** extends封装
  * @template B - 基础类型
  * @template T - 判断的目标类型

package/package.json

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

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { PRecord, AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await, AnyRecord, AllExtends } from "@src/UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, Await, AnyRecord, AllExtends } 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";
@@ -55,6 +55,14 @@ type PromiseResult<T> = {
     /**请求下标/序号 */
     index:number;
 };
+
+/**遍历对象的回调函数
+ * @param key       - 字段名
+ * @param value     - 字段值
+ * @param parent    - 父对象
+ */
+type EachFieldCallback = (key: string, value: JToken,parent: JObject) => void;
+
 /**常用函数 */
 export class UtilFunc{
 /**获取当前时间戳  
@@ -339,99 +347,6 @@ static timelimitPromise<T>
     })
 }
 
-
-
-/**部分类组合  
- * 将mixin的部分字段混入base  
- * @param base   - 基础类
- * @param mixin  - 目标类
- * @param key    - mixin 对象在 base 中的 key
- * @param fields - 需要混入的字段
- * @returns 混合完成的类
- */
-static composeClassPart
-    <Base extends AnyRecord,Mixin extends AnyRecord,Field extends keyof Mixin>
-    (base:Base,mixin:Mixin,key:string,...fields:Field[]):ComposedClass<Base,Mixin,typeof key,Field>{
-    const compObj = base as any;
-    if(compObj[key]!==undefined)
-        SLogger.warn(`key: ${key as string} 已存在于基础类中, 混入可能导致类型问题`);
-    compObj[key] = mixin;
-    for(const fd of fields){
-        if(compObj[fd]!==undefined)
-            SLogger.warn(`field: ${fd as string} 已存在于基础类中, 混入可能导致类型问题, 如需覆盖, 请使用 ${key}=val`);
-        //func需绑定this无法直接设置属性
-        if(typeof mixin[fd] === 'function') {
-            compObj[fd] = (...args: any[]) => compObj[key][fd](...args);
-            //#region other
-            //const memo = (...args: any[]) => compObj[key][fd](...args);
-            //Object.defineProperty(compObj, fd, {
-            //    get:()=>memo,
-            //    set:()=>SLogger.warn(new Error(`试图修改一个由 composeClassPart 组合的函数字段:${String(fd)}, 修改已被忽略`)),
-            //    enumerable:true ,
-            //    //writable: true  ,
-            //    configurable: true
-            //});
-            //(compObj as any)[fd] = (...args: any[]) => (mixin[fd] as any).apply(mixin, args);
-            //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
-            //#endregion
-        } else {
-            Object.defineProperty(compObj, fd, {
-                get: ()=>compObj[key][fd],
-                set: (value)=>{compObj[key][fd] = value},
-                enumerable:true ,
-                //writable: true  ,
-                configurable: true
-            });
-        }
-    }
-    return compObj;
-}
-
-/**根据 MIXIN_FIELDS 自动混入  
- * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
- */
-static composeMixinable
-    <Base extends AnyRecord, Mixins extends Mixinable<any>[]>
-    (base:Base,...mixins:Mixins):
-    ComposedMixinable<Base,Mixins>{
-    let out = base;
-    const fieldsSet = new Set<string>();
-    for(const rawmixin of mixins){
-        const mixin=rawmixin as any;
-        for(const field of mixin.MIXIN_FIELDS) {
-            const fixField = field as string;
-            if(fieldsSet.has(fixField))
-                SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-            else
-                fieldsSet.add(fixField);
-        }
-        out = UtilFunc.composeClassPart(base,mixin,mixin.MIXIN_KEY,...mixin.MIXIN_FIELDS);
-    }
-    return out as any;
-}
-
-/**根据 MIXIN_FIELDS 自动混入 */
-static composeRefMixinable
-    <Base extends AnyRecord, Mixins extends RefMixinable<any,unknown>[]>
-    (base:Base,...mixins:Mixins):
-    ComposedRefMixinable<Base,Mixins>{
-    let out = base;
-    const fieldsSet = new Set<string>();
-    for(const mixin of mixins){
-        const ctor = mixin.CTOR;
-        for(const field of ctor.MIXIN_FIELDS) {
-            const fixField = field as string;
-            if(fieldsSet.has(fixField))
-                SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-            else
-                fieldsSet.add(fixField);
-        }
-        out = UtilFunc.composeClassPart(base,mixin,ctor.MIXIN_KEY,...ctor.MIXIN_FIELDS);
-    }
-    return out as any;
-}
-
-
 /**对对象的每个属性应用映射函数，并返回一个新的对象。
  * @template T      - 对象的类型
  * @param obj       - 要处理的对象
@@ -446,6 +361,29 @@ static mapEntries<T extends AnyRecord>
     }, {} as T);
 }
 
+/**遍历对象的所有字段
+ * @param obj       - 对象
+ * @param callback  - 回调函数
+ */
+static eachField(obj: JToken, callback: EachFieldCallback): void {
+    if(obj==null) return;
+    if(typeof obj === 'object' && 'toJSON' in obj && typeof obj.toJSON == 'function'){
+        SLogger.warn('UtilFunc.eachField 错误 无法遍历IJData 已跳过');
+        return;
+    }
+    if(Array.isArray(obj)){
+        for (const item of obj)
+            UtilFunc.eachField(item, callback);
+        return;
+    }
+    if (typeof obj === 'object') {
+        for (const [k, v] of Object.entries(obj)) {
+            UtilFunc.eachField(v, callback);
+            callback(k, v, obj as JObject);
+        }
+    }
+}
+
 /**将JToken转换为字符串
  * @param token - 待转换的Token
  * @param opt   - 可选参数

package/src/UtilInterfaces.ts

@@ -157,74 +157,6 @@ export type FuncPropNames<T> = {
     [K in keyof T]: T[K] extends AnyFunc ? K : never;
 }[keyof T];
 
-/**部分组合的类 
- * @template Base     - 基类
- * @template Mixin    - 待混入的类
- * @template PropKeys - 需要混入的成员key
- */
-export type ComposedClass<Base, Mixin, Key extends string, PropKeys extends keyof Mixin> = 
-    Base & Pick<Mixin, PropKeys> & {[P in Key]:Mixin};
-
-/**可自动混入的类型 */
-export type Mixinable<Mixin> = {
-    /**混入时自身所在位置  
-     * 请使用字面量  
-     */
-    readonly MIXIN_KEY: string;
-    /**可混入的字段  
-     * 请使用字面量
-    */
-    readonly MIXIN_FIELDS: readonly (keyof Mixin)[];
-};
-/**是原型构造器类型 */
-export type IsCtor<T> = T extends {new():infer Ins}
-    ? T : never;
-/**可反射的  
- * @template Ctor        - 构造器类型
- * @template Constraint  - 构造器约束
- */
-export type ReflectionAble<Ctor,Constraint={}> = {
-    /**原型构造器 */
-    readonly CTOR:Ctor&Constraint
-};
-/**可反射的 且 构造函数是可混入的类  
- * @template Ctor        - 构造器类型
- * @template Instance    - 实例类型 如果采用了内部混入, 那么填入对外实际暴露的类型, 以支持混入多层字段
- * @template Constraint  - 构造器约束
- * @example
- * export class MixinModule implements RefMixinable<typeof MixinModule,MixinModule>{
- *   static readonly MIXIN_FIELDS = [
- *       'func_a',
- *       'field_b'
- *   ] as const;
- *   static readonly MIXIN_KEY = '__mixinModule';
- *   CTOR = MixinModule;
- * }
- */
-export type RefMixinable<Ctor,Instance,Constraint={}> =
-    ReflectionAble<Ctor,Mixinable<Instance>&Constraint>;
-
-
-/**自动组合可混入的类  
- */
-export type ComposedMixinable<B, Ms extends unknown[]> = 
-    Ms extends [infer M, ...infer Rest]
-        ? M extends Mixinable<M>
-            ? ComposedMixinable<ComposedClass<B,M,M['MIXIN_KEY'],M['MIXIN_FIELDS'][number]>,Rest>
-            : "一个混入类没有实现 Mixinable<self>" & Error
-        : B
-
-/**自动组合 可反射的 且 构造函数是可混入的 类 */
-export type ComposedRefMixinable<B, Ms extends unknown[]> = 
-    Ms extends [infer M, ...infer Rest]
-        ? M extends RefMixinable<unknown,M>
-            ? ComposedRefMixinable<ComposedClass<B,M,
-                M['CTOR']['MIXIN_KEY'],
-                M['CTOR']['MIXIN_FIELDS'][number]>,
-                Rest>
-            : "一个混入类没有实现  RefMixinable<typeof self, self>" & Error
-        : B
-
 /** extends封装  
  * @template B - 基础类型
  * @template T - 判断的目标类型