@zwa73/utils 1.0.71 → 1.0.73

package/dist/UtilFP.d.ts

@@ -1,7 +1,7 @@
 /**常用函数式编程库 */
 export declare namespace UtilFP {
     /**柯里化函数类型 */
-    type CurryFunc<T, PrevArgs extends any[] = []> = T extends (...args: infer Args) => infer Result ? Args extends [infer Arg, ...infer RestArgs] ? RestArgs extends [] ? (...args: [...PrevArgs, Arg]) => Result : (...args: [...PrevArgs, Arg]) => CurryFunc<(...rest: RestArgs) => Result> & CurryFunc<(...args: RestArgs) => Result, [...PrevArgs, Arg]> : Args extends [] ? () => Result : "CurryFunc错误 可选无法被识别" & Error : never;
+    type CurryFunc<T, PrevArgs extends unknown[] = []> = T extends (...args: infer Args) => infer Result ? Args extends [infer Arg, ...infer RestArgs] ? RestArgs extends [] ? (...args: [...PrevArgs, Arg]) => Result : (...args: [...PrevArgs, Arg]) => CurryFunc<(...rest: RestArgs) => Result> & CurryFunc<(...args: RestArgs) => Result, [...PrevArgs, Arg]> : Args extends [] ? () => Result : "CurryFunc错误 可选无法被识别" & Error : never;
     /**柯里化转换
     * @param {T} fn - 将要转换的函数
     * @returns {CurryFunc<T>} 柯里化的函数

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { ComposedClassMult, ComposedClassPart, ComposedMixinable, JToken, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
+import { ComposedClass, ComposedMixinable, JToken, Mixinable, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
 /**常用函数 */
 export declare namespace UtilFunc {
     /**获取当前时间戳
@@ -61,19 +61,13 @@ export declare namespace UtilFunc {
      * 将mixin的部分字段混入base
      * @param base   - 基础类
      * @param mixin  - 目标类
+     * @param key    - mixin 对象在 base 中的 key
      * @param fields - 需要混入的字段
      * @returns 混合完成的类
      */
-    function composeClassPart<Base extends object, Mixin extends object, Field extends keyof Mixin>(base: Base, mixin: Mixin, ...fields: Field[]): ComposedClassPart<Base, Mixin, Field>;
+    function composeClassPart<Base extends object, Mixin extends object, Field extends keyof Mixin>(base: Base, mixin: Mixin, key: string, ...fields: Field[]): ComposedClass<Base, Mixin, typeof key, Field>;
     /**根据 MIXIN_FIELDS 自动混入 */
-    function composeMixinable<B extends object, M1, M2, M3, M4, M5, M6, M7, M8, M9>(base: B, m1?: M1, m2?: M2, m3?: M3, m4?: M4, m5?: M5, m6?: M6, m7?: M7, m8?: M8, m9?: M9): ComposedMixinable<B, [M1, M2, M3, M4, M5, M6, M4, M8, M9]>;
-    /**类组合
-     * 将mixinList每个成员的字段混入base
-     * @param base      - 基础类
-     * @param mixinList - 目标类
-     * @returns - 混合完成的类
-     */
-    function composeClass<Base extends object, MixinList extends object[]>(base: Base, ...mixinList: MixinList): ComposedClassMult<Base, MixinList>;
+    function composeMixinable<Base extends object, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象

package/dist/UtilFunctions.js

@@ -201,81 +201,60 @@ var UtilFunc;
      * 将mixin的部分字段混入base
      * @param base   - 基础类
      * @param mixin  - 目标类
+     * @param key    - mixin 对象在 base 中的 key
      * @param fields - 需要混入的字段
      * @returns 混合完成的类
      */
-    function composeClassPart(base, mixin, ...fields) {
+    function 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`);
             Object.defineProperty(compObj, fd, {
-                get: ()=>mixin[fd],
-                set: (value)=>{mixin[fd] = value},
-                enumerable:true ,
+                get: () => compObj[key][fd],
+                set: (value) => { compObj[key][fd] = value; },
+                enumerable: true,
                 //writable: true  ,
                 configurable: true
             });
-            */
-            if (typeof mixin[fd] === 'function') {
-                compObj[fd] = (...args) => mixin[fd].apply(mixin, args);
-                //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
-            }
-            else {
-                Object.defineProperty(compObj, fd, {
-                    get: () => mixin[fd],
-                    set: (value) => { mixin[fd] = value; },
-                    enumerable: true,
-                    //writable: true  ,
-                    configurable: true
-                });
-            }
+            //if(typeof mixin[fd] === 'function') {
+            //    compObj[fd] = (...args: any[]) => compObj[key][fd](...args);
+            //    //(compObj as any)[fd] = (...args: any[]) => (mixin[fd] as any).apply(mixin, args);
+            //    //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
+            //} else {
+            //    Object.defineProperty(compObj, fd, {
+            //        get: ()=>compObj[key][fd],
+            //        set: (value)=>{compObj[key][fd] = value},
+            //        enumerable:true ,
+            //        //writable: true  ,
+            //        configurable: true
+            //    });
+            //}
         }
         return compObj;
     }
     UtilFunc.composeClassPart = composeClassPart;
+    /**根据 MIXIN_FIELDS 自动混入 */
     function composeMixinable(base, ...mixins) {
         let out = base;
-        for (const mixin of mixins)
-            out = composeClassPart(base, mixin, ...mixin.MIXIN_FIELDS);
-        return out;
-    }
-    UtilFunc.composeMixinable = composeMixinable;
-    /**类组合
-     * 将mixinList每个成员的字段混入base
-     * @param base      - 基础类
-     * @param mixinList - 目标类
-     * @returns - 混合完成的类
-     */
-    function composeClass(base, ...mixinList) {
-        let obj = base;
-        for (let mixin of mixinList) {
-            let propks = Object.getOwnPropertyNames(mixin.constructor.prototype);
-            for (const key of propks) {
-                if (key != "constructor") {
-                    Object.defineProperty(obj, key, {
-                        get: () => mixin[key],
-                        set: (value) => { mixin[key] = value; },
-                        enumerable: true,
-                        //writable: true,
-                        configurable: true
-                    });
-                    //obj[key] = (mixin as any)[key];
-                }
-            }
-            for (const key in mixin) {
-                Object.defineProperty(obj, key, {
-                    get: () => mixin[key],
-                    set: (value) => { mixin[key] = value; },
-                    enumerable: true,
-                    //writable: true  ,
-                    configurable: true
-                });
-                //obj[key] = (mixin as any)[key];
+        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 = composeClassPart(base, mixin, mixin.MIXIN_KEY, ...mixin.MIXIN_FIELDS);
         }
-        return obj;
+        return out;
     }
-    UtilFunc.composeClass = composeClass;
+    UtilFunc.composeMixinable = composeMixinable;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象

package/dist/UtilInterfaces.d.ts

@@ -72,39 +72,20 @@ export type FuncPropNames<T> = {
  * @template Mixin    - 待混入的类
  * @template PropKeys - 需要混入的成员key
  */
-export type ComposedClassPart<Base extends object, Mixin extends object, PropKeys extends keyof Mixin> = Base & Pick<Mixin, PropKeys>;
-/**组合的类 嵌套变体 */
-export type ComposedPartClassMult<Base extends object, Mixin1 extends object = {}, PropKeys1 extends keyof Mixin1 = keyof Mixin1, Mixin2 extends object = {}, PropKeys2 extends keyof Mixin2 = keyof Mixin2, Mixin3 extends object = {}, PropKeys3 extends keyof Mixin3 = keyof Mixin3, Mixin4 extends object = {}, PropKeys4 extends keyof Mixin4 = keyof Mixin4, Mixin5 extends object = {}, PropKeys5 extends keyof Mixin5 = keyof Mixin5, Mixin6 extends object = {}, PropKeys6 extends keyof Mixin6 = keyof Mixin6> = ComposedClassPart<ComposedClassPart<ComposedClassPart<ComposedClassPart<ComposedClassPart<ComposedClassPart<Base, Mixin1, PropKeys1>, Mixin2, PropKeys2>, Mixin3, PropKeys3>, Mixin4, PropKeys4>, Mixin5, PropKeys5>, Mixin6, PropKeys6>;
-/**组合的类
- * @template Base     - 基类
- * @template Mixin    - 待混入的类
- */
-export type ComposedClass<Base extends object, Mixin extends object> = Base & Mixin;
-/**组合的类 多组合变体
- * @template Base     - 基类
- * @template MixinList- 待混入的类型数组
- */
-export type ComposedClassMult<Base extends object, MixinList extends object[]> = MixinList extends [infer Mixin, ...infer Rest] ? Mixin extends object ? Rest extends object[] ? ComposedClassMult<ComposedClass<Base, Mixin>, Rest> : Base : Base : Base;
-/**将一个类型的所有方法的 `this` 参数改为 `T` 类型
- * @template Methods - 待更改的函数表
- * @template T - 目标this类型
- */
-export type MethodsThisAs<Methods, T> = {
-    [K in keyof Methods]: Methods[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : Methods[K];
+export type ComposedClass<Base extends object, Mixin extends object, Key extends string, PropKeys extends keyof Mixin> = Base & Pick<Mixin, PropKeys> & {
+    [P in Key]: Mixin;
 };
-/**尝试断言一个类的原型
- * 其所有函数的 this 都必须为某个类型
- * assignThisAs<Self,T>(Self.prototype);
- * @template Self   - 类的类型
- * @template T      - 目标this类型
- * @param prototype - 类的原型
- */
-export declare function assertThisAs<Self, T>(prototype: MethodsThisAs<Self, T>): void;
 /**可自动混入的类型 */
 export type Mixinable<Mixin> = {
-    /**可混入的字段 */
-    readonly MIXIN_FIELDS: ReadonlyArray<keyof Mixin>;
+    /**混入时自身所在位置
+     * 请使用字面量
+     */
+    readonly MIXIN_KEY: string;
+    /**可混入的字段
+     * 请使用字面量
+    */
+    readonly MIXIN_FIELDS: readonly (keyof Mixin)[];
 };
 /**自动组合可混入的类 */
-export type ComposedMixinable<B extends object, Ms extends Array<unknown>> = Ms extends [infer M, ...infer Rest] ? M extends Mixinable<M> ? ComposedMixinable<ComposedClassPart<B, M, M['MIXIN_FIELDS'][number]>, Rest> : B : B;
+export type ComposedMixinable<B extends object, 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 {};

package/dist/UtilInterfaces.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertThisAs = exports.stringifyJToken = void 0;
+exports.stringifyJToken = void 0;
 /**将JToken转换为字符串
  * @param token - 待转换的Token
  * @param space - 插入的空格 数字为空格数量 默认为制表符\t
@@ -12,12 +12,3 @@ function stringifyJToken(token, space = "\t") {
     return JSON.stringify(token, null, space);
 }
 exports.stringifyJToken = stringifyJToken;
-/**尝试断言一个类的原型
- * 其所有函数的 this 都必须为某个类型
- * assignThisAs<Self,T>(Self.prototype);
- * @template Self   - 类的类型
- * @template T      - 目标this类型
- * @param prototype - 类的原型
- */
-function assertThisAs(prototype) { }
-exports.assertThisAs = assertThisAs;

package/dist/backup.d.ts

@@ -0,0 +1,32 @@
+/**类组合
+ * 将mixinList每个成员的字段混入base
+ * @param base      - 基础类
+ * @param mixinList - 目标类
+ * @returns - 混合完成的类
+ */
+export declare function composeClassFull<Base extends object, MixinList extends object[]>(base: Base, ...mixinList: MixinList): ComposedFullClassMult<Base, MixinList>;
+/**组合的类
+ * @template Base     - 基类
+ * @template Mixin    - 待混入的类
+ */
+export type ComposedFullClass<Base extends object, Mixin extends object> = Base & Mixin;
+/**组合的类 多组合变体
+ * @template Base     - 基类
+ * @template MixinList- 待混入的类型数组
+ */
+export type ComposedFullClassMult<Base extends object, MixinList extends object[]> = MixinList extends [infer Mixin, ...infer Rest] ? Mixin extends object ? Rest extends object[] ? ComposedFullClassMult<ComposedFullClass<Base, Mixin>, Rest> : Base : Base : Base;
+/**将一个类型的所有方法的 `this` 参数改为 `T` 类型
+ * @template Methods - 待更改的函数表
+ * @template T - 目标this类型
+ */
+export type MethodsThisAs<Methods, T> = {
+    [K in keyof Methods]: Methods[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : Methods[K];
+};
+/**尝试断言一个类的原型
+ * 其所有函数的 this 都必须为某个类型
+ * assignThisAs<Self,T>(Self.prototype);
+ * @template Self   - 类的类型
+ * @template T      - 目标this类型
+ * @param prototype - 类的原型
+ */
+export declare function assertThisAs<Self, T>(prototype: MethodsThisAs<Self, T>): void;

package/dist/backup.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertThisAs = exports.composeClassFull = void 0;
+/**类组合
+ * 将mixinList每个成员的字段混入base
+ * @param base      - 基础类
+ * @param mixinList - 目标类
+ * @returns - 混合完成的类
+ */
+function composeClassFull(base, ...mixinList) {
+    let obj = base;
+    for (let mixin of mixinList) {
+        let propks = Object.getOwnPropertyNames(mixin.constructor.prototype);
+        for (const key of propks) {
+            if (key != "constructor") {
+                Object.defineProperty(obj, key, {
+                    get: () => mixin[key],
+                    set: (value) => { mixin[key] = value; },
+                    enumerable: true,
+                    //writable: true,
+                    configurable: true
+                });
+                //obj[key] = (mixin as any)[key];
+            }
+        }
+        for (const key in mixin) {
+            Object.defineProperty(obj, key, {
+                get: () => mixin[key],
+                set: (value) => { mixin[key] = value; },
+                enumerable: true,
+                //writable: true  ,
+                configurable: true
+            });
+            //obj[key] = (mixin as any)[key];
+        }
+    }
+    return obj;
+}
+exports.composeClassFull = composeClassFull;
+/**尝试断言一个类的原型
+ * 其所有函数的 this 都必须为某个类型
+ * assignThisAs<Self,T>(Self.prototype);
+ * @template Self   - 类的类型
+ * @template T      - 目标this类型
+ * @param prototype - 类的原型
+ */
+function assertThisAs(prototype) { }
+exports.assertThisAs = assertThisAs;

package/dist/test/composeTest.d.ts

@@ -1,10 +1,14 @@
 import { Mixinable } from "..";
-declare class A implements Mixinable<A> {
-    private num;
+type MixinA = Mixinable<A>;
+declare class A implements MixinA {
+    anum: number;
+    constructor(n?: number);
     getNum: () => number;
     /**A的函数 */
     getA: () => this;
-    MIXIN_FIELDS: readonly ["getNum", "getA"];
+    readonly MIXIN_KEY: "__a";
+    static MIXIN_FIELDS: readonly ["getNum", "getA", "anum"];
+    readonly MIXIN_FIELDS: readonly ["getNum", "getA", "anum"];
 }
 declare class B implements Mixinable<B> {
     private text;
@@ -15,15 +19,60 @@ declare class B implements Mixinable<B> {
     static getNewB: () => B;
     /**保留的函数 */
     privateFunc(): void;
-    MIXIN_FIELDS: readonly ["getText", "getB"];
+    readonly MIXIN_KEY: "__b";
+    static readonly MIXIN_FIELDS: readonly ["getText", "getB"];
+    readonly MIXIN_FIELDS: readonly ["getText", "getB"];
 }
 declare class _C {
-    static create(): _C & Pick<B, "getText" | "getB"> & Pick<A, "getNum" | "getA"> & Record<"bindFunc", () => "这是动态绑定的函数">;
+    static create(): _C & Pick<B, "getText" | "getB"> & {
+        __b: B;
+    } & Pick<A, "anum" | "getNum" | "getA"> & {
+        __a: A;
+    } & Record<"bindFunc", () => "这是动态绑定的函数">;
     private constructor();
-    getC(this: C): _C & Pick<B, "getText" | "getB"> & Pick<A, "getNum" | "getA"> & Record<"bindFunc", () => "这是动态绑定的函数">;
+    getC(this: C): _C & Pick<B, "getText" | "getB"> & {
+        __b: B;
+    } & Pick<A, "anum" | "getNum" | "getA"> & {
+        __a: A;
+    } & Record<"bindFunc", () => "这是动态绑定的函数">;
     testFunc(this: C): number;
+    readonly MIXIN_KEY: "__c";
+    static readonly MIXIN_FIELDS: readonly ["getNum", "getA", "anum", "getText", "getB", "getC", "__a"];
+    readonly MIXIN_FIELDS: readonly ["getNum", "getA", "anum", "getText", "getB", "getC", "__a"];
 }
-declare function composeC(obj: _C): _C & Pick<B, "getText" | "getB"> & Pick<A, "getNum" | "getA"> & Record<"bindFunc", () => "这是动态绑定的函数">;
+declare function composeC(obj: _C): _C & Pick<B, "getText" | "getB"> & {
+    __b: B;
+} & Pick<A, "anum" | "getNum" | "getA"> & {
+    __a: A;
+} & Record<"bindFunc", () => "这是动态绑定的函数">;
 export type C = ReturnType<typeof composeC>;
 export declare const C: typeof _C;
+declare class _D {
+    #private;
+    private constructor();
+    static create(): _D & Pick<_C & Pick<B, "getText" | "getB"> & {
+        __b: B;
+    } & Pick<A, "anum" | "getNum" | "getA"> & {
+        __a: A;
+    } & Record<"bindFunc", () => "这是动态绑定的函数">, "__a" | "anum" | "getNum" | "getA" | "getText" | "getB" | "getC"> & {
+        __c: _C & Pick<B, "getText" | "getB"> & {
+            __b: B;
+        } & Pick<A, "anum" | "getNum" | "getA"> & {
+            __a: A;
+        } & Record<"bindFunc", () => "这是动态绑定的函数">;
+    } & Record<"bindFunc", () => "这是动态绑定的函数">;
+}
+declare function composeD(obj: _D): _D & Pick<_C & Pick<B, "getText" | "getB"> & {
+    __b: B;
+} & Pick<A, "anum" | "getNum" | "getA"> & {
+    __a: A;
+} & Record<"bindFunc", () => "这是动态绑定的函数">, "__a" | "anum" | "getNum" | "getA" | "getText" | "getB" | "getC"> & {
+    __c: _C & Pick<B, "getText" | "getB"> & {
+        __b: B;
+    } & Pick<A, "anum" | "getNum" | "getA"> & {
+        __a: A;
+    } & Record<"bindFunc", () => "这是动态绑定的函数">;
+} & Record<"bindFunc", () => "这是动态绑定的函数">;
+export type D = ReturnType<typeof composeD>;
+export declare const D: typeof _D;
 export {};

package/dist/test/composeTest.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.C = void 0;
+exports.D = exports.C = void 0;
 const __1 = require("..");
 class A {
-    num = 1;
-    getNum = () => this.num;
+    anum = 1;
+    constructor(n = 1) { this.anum = n; }
+    getNum = () => this.anum;
     /**A的函数 */
     getA = () => this;
-    MIXIN_FIELDS = ['getNum', 'getA'];
+    MIXIN_KEY = "__a";
+    static MIXIN_FIELDS = ['getNum', 'getA', 'anum'];
+    MIXIN_FIELDS = A.MIXIN_FIELDS;
 }
 class B {
     text = "B的text";
@@ -20,7 +23,9 @@ class B {
     privateFunc() {
         console.log();
     }
-    MIXIN_FIELDS = ['getText', 'getB'];
+    MIXIN_KEY = "__b";
+    static MIXIN_FIELDS = ['getText', 'getB'];
+    MIXIN_FIELDS = B.MIXIN_FIELDS;
 }
 class _C {
     static create() {
@@ -35,6 +40,13 @@ class _C {
         console.log(this);
         return 2;
     }
+    MIXIN_KEY = "__c";
+    static MIXIN_FIELDS = [
+        ...A.MIXIN_FIELDS,
+        ...B.MIXIN_FIELDS,
+        'getC', '__a'
+    ];
+    MIXIN_FIELDS = exports.C.MIXIN_FIELDS;
 }
 function composeC(obj) {
     let ob1 = __1.UtilFunc.composeMixinable(obj, new B(), new A());
@@ -42,10 +54,35 @@ function composeC(obj) {
     return ob3;
 }
 exports.C = _C;
-(0, __1.assertThisAs)(exports.C.prototype);
 const insc = exports.C.create(); //?
+console.log(insc.__a);
 insc.getC().testFunc(); //?
+insc.getNum(); //?
+insc.anum; //?
+insc.__a = new A(2);
+insc.getNum(); //?
+insc.anum; //?
 insc.testFunc(); //?
 insc.getText(); //?
 insc.getB().getText(); //?
 insc.bindFunc(); //?
+class _D {
+    constructor() { }
+    ;
+    static create() {
+        return composeD(new _D());
+    }
+    #d = 123;
+}
+function composeD(obj) {
+    let ob1 = __1.UtilFunc.composeMixinable(obj, exports.C.create());
+    let ob3 = __1.UtilFP.bindTo('bindFunc', () => "这是动态绑定的函数", ob1);
+    return ob3;
+}
+exports.D = _D;
+let insd = exports.D.create();
+insd; //?
+insd.getB(); //?
+insd.getNum(); //?
+insd.__a = new A(3);
+insd.getNum(); //?

package/dist/test/test.js

@@ -2,58 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const UtilFP_1 = require("../UtilFP");
 const UtilFunctions_1 = require("../UtilFunctions");
-const compKeys = ["getData", "getA"];
-class A {
-    abc = 223;
-    /**A的getData */
-    getData() {
-        return this.abc;
-    }
-    /**获取A */
-    getA() {
-        return this;
-    }
-}
-class C {
-    abc = 3333;
-    /**A的getData */
-    resetData() {
-        return this.abc;
-    }
-    /**获取C */
-    getC() {
-        return this;
-    }
-    /**获取C */
-    getC1() {
-        return this;
-    }
-}
-class B {
-    _bc;
-    constructor() {
-        const tb = this;
-        this._bc = UtilFunctions_1.UtilFunc.composeClassPart(tb, new A(), ...compKeys);
-    }
-    static init() {
-        return new B()._bc;
-    }
-    /**B的getData */
-    getData1() { return "BGetdata"; }
-    getTest() { return this._bc.getData(); }
-}
-const BComp = {
-    init() {
-        return B.init();
-    }
-};
-let c = BComp.init();
-console.log(1);
-let d = c.getData(); //?
-c.getA;
-c.getData1(); //?
-c.getTest(); //?
-let r3 = null;
+const backup_1 = require("../backup");
+// 使用示例
 class Monster {
     constructor(a) { }
     monfunc() {
@@ -74,7 +24,7 @@ const OtherMonster = {
         let om = {
             om: "123", mon
         };
-        return UtilFunctions_1.UtilFunc.composeClass(om, mon, mon1);
+        return (0, backup_1.composeClassFull)(om, mon, mon1);
     }
 };
 let om = OtherMonster.init(); //?

package/package.json

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

package/src/UtilFP.ts

@@ -3,7 +3,7 @@
 export namespace UtilFP {
 
 /**柯里化函数类型 */
-type CurryFunc<T, PrevArgs extends any[] = []> = T extends (...args: infer Args) => infer Result
+type CurryFunc<T, PrevArgs extends unknown[] = []> = T extends (...args: infer Args) => infer Result
 ? Args extends [infer Arg, ...infer RestArgs]
     ? RestArgs extends []
         ? (...args: [...PrevArgs, Arg]) => Result

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { ComposedClass, ComposedClassMult, ComposedClassPart, ComposedMixinable, FuncPropNames, JToken, Mixinable, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
+import { ComposedClass, ComposedMixinable, FuncPropNames, JToken, Mixinable, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
 import * as cp from "child_process";
 import { SLogger } from "@src/UtilLogger";
 
@@ -217,89 +217,66 @@ export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:Promise
  * 将mixin的部分字段混入base  
  * @param base   - 基础类
  * @param mixin  - 目标类
+ * @param key    - mixin 对象在 base 中的 key
  * @param fields - 需要混入的字段
  * @returns 混合完成的类
  */
 export function composeClassPart
     <Base extends object,Mixin extends object,Field extends keyof Mixin>
-    (base:Base,mixin:Mixin,...fields:Field[]):ComposedClassPart<Base,Mixin,Field>{
+    (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`);
         Object.defineProperty(compObj, fd, {
-            get: ()=>mixin[fd],
-            set: (value)=>{mixin[fd] = value},
+            get: ()=>compObj[key][fd],
+            set: (value)=>{compObj[key][fd] = value},
             enumerable:true ,
             //writable: true  ,
             configurable: true
         });
-        */
-        if(typeof mixin[fd] === 'function') {
-            (compObj as any)[fd] = (...args: any[]) => (mixin[fd] as any).apply(mixin, args);
-            //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
-        } else {
-            Object.defineProperty(compObj, fd, {
-                get: ()=>mixin[fd],
-                set: (value)=>{mixin[fd] = value},
-                enumerable:true ,
-                //writable: true  ,
-                configurable: true
-            });
-        }
+        //if(typeof mixin[fd] === 'function') {
+        //    compObj[fd] = (...args: any[]) => compObj[key][fd](...args);
+        //    //(compObj as any)[fd] = (...args: any[]) => (mixin[fd] as any).apply(mixin, args);
+        //    //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
+        //} 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 自动混入 */
 export function composeMixinable
-    <B extends object, 
-    M1, M2, M3,M4, M5, M6,M7, M8, M9>
-    (base:B,m1?:M1,m2?:M2,m3?:M3,m4?:M4,m5?:M5,m6?:M6,m7?:M7,m8?:M8,m9?:M9):
-    ComposedMixinable<B,[M1,M2,M3,M4,M5,M6,M4,M8,M9]>
-export function composeMixinable<Base extends object, Mixin extends Mixinable<Mixin>>(base:Base,...mixins:Mixin[]){
+    <Base extends object, Mixins extends Mixinable<any>[]>
+    (base:Base,...mixins:Mixins):
+    ComposedMixinable<Base,Mixins>{
     let out = base;
-    for(const mixin of mixins)
-        out = composeClassPart(base,mixin,...mixin.MIXIN_FIELDS);
-    return out;
-}
-
-/**类组合  
- * 将mixinList每个成员的字段混入base  
- * @param base      - 基础类
- * @param mixinList - 目标类
- * @returns - 混合完成的类
- */
-export function composeClass<Base extends object,MixinList extends object[]>
-    (base:Base,...mixinList:MixinList):ComposedClassMult<Base,MixinList>{
-    let obj = base as any;
-    for(let mixin of mixinList as any){
-        let propks = Object.getOwnPropertyNames(mixin.constructor.prototype)
-        for(const key of propks){
-            if(key != "constructor"){
-                Object.defineProperty(obj, key, {
-                    get: ()=>mixin[key],
-                    set: (value)=>{mixin[key] = value},
-                    enumerable:true,
-                    //writable: true,
-                    configurable: true
-                });
-                //obj[key] = (mixin as any)[key];
-            }
-        }
-        for(const key in mixin){
-            Object.defineProperty(obj, key, {
-                get: ()=>mixin[key],
-                set: (value)=>{mixin[key] = value},
-                enumerable:true ,
-                //writable: true  ,
-                configurable: true
-            });
-            //obj[key] = (mixin as any)[key];
+    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 = composeClassPart(base,mixin,mixin.MIXIN_KEY,...mixin.MIXIN_FIELDS);
     }
-    return obj;
+    return out as any;
 }
 
+
 /**对对象的每个属性应用映射函数，并返回一个新的对象。
  * @template T      - 对象的类型
  * @param obj       - 要处理的对象

package/src/UtilInterfaces.ts

@@ -92,81 +92,25 @@ export type FuncPropNames<T> = {
  * @template Mixin    - 待混入的类
  * @template PropKeys - 需要混入的成员key
  */
-export type ComposedClassPart<Base extends object, Mixin extends object, PropKeys extends keyof Mixin> = 
-    Base & Pick<Mixin, PropKeys>;
-
-/**组合的类 嵌套变体 */
-export type ComposedPartClassMult<Base extends object, 
-    Mixin1 extends object = {}, PropKeys1 extends keyof Mixin1 = keyof Mixin1,
-    Mixin2 extends object = {}, PropKeys2 extends keyof Mixin2 = keyof Mixin2,
-    Mixin3 extends object = {}, PropKeys3 extends keyof Mixin3 = keyof Mixin3,
-    Mixin4 extends object = {}, PropKeys4 extends keyof Mixin4 = keyof Mixin4,
-    Mixin5 extends object = {}, PropKeys5 extends keyof Mixin5 = keyof Mixin5,
-    Mixin6 extends object = {}, PropKeys6 extends keyof Mixin6 = keyof Mixin6> = 
-    ComposedClassPart<ComposedClassPart<ComposedClassPart<
-    ComposedClassPart<ComposedClassPart<ComposedClassPart<
-    Base,
-    Mixin1,PropKeys1>,Mixin2,PropKeys2>,Mixin3,PropKeys3>,
-    Mixin4,PropKeys4>,Mixin5,PropKeys5>,Mixin6,PropKeys6>
-
-/**递归多组合 仅单key有效 */
-type ComposedClassOnceKey<Base extends object,Data extends [object,string][]> = 
-    Data extends [[infer Mixin extends object, infer FuncKeys], ...infer Rest]
-        ? FuncKeys extends FuncPropNames<Mixin>
-            ? Rest extends [any, any][]
-                ? ComposedClassOnceKey<ComposedClassPart<Base, Mixin, FuncKeys>,Rest>
-                : Base
-            : Base
-        : Base;
-
-/**组合的类  
- * @template Base     - 基类
- * @template Mixin    - 待混入的类
- */
-export type ComposedClass<Base extends object,Mixin extends object> = Base&Mixin;
-/**组合的类 多组合变体  
- * @template Base     - 基类
- * @template MixinList- 待混入的类型数组
- */
-export type ComposedClassMult<Base extends object,MixinList extends object[]> = 
-    MixinList extends [infer Mixin, ...infer Rest]
-        ? Mixin extends object
-            ? Rest extends object[]
-                ? ComposedClassMult<ComposedClass<Base,Mixin>,Rest>
-                : Base
-            : Base
-        : Base;
-
-/**将一个类型的所有方法的 `this` 参数改为 `T` 类型
- * @template Methods - 待更改的函数表
- * @template T - 目标this类型
- */
-export type MethodsThisAs<Methods, T> = {
-    [K in keyof Methods]:
-        Methods[K] extends (...args: infer A) => infer R
-            ? (this: T, ...args: A) => R
-            : Methods[K];
-};
-
-/**尝试断言一个类的原型  
- * 其所有函数的 this 都必须为某个类型  
- * assignThisAs<Self,T>(Self.prototype);  
- * @template Self   - 类的类型
- * @template T      - 目标this类型
- * @param prototype - 类的原型
- */
-export function assertThisAs<Self,T>(prototype: MethodsThisAs<Self, T>) {}
+export type ComposedClass<Base extends object, Mixin extends object, Key extends string, PropKeys extends keyof Mixin> = 
+    Base & Pick<Mixin, PropKeys> & {[P in Key]:Mixin};
 
 /**可自动混入的类型 */
 export type Mixinable<Mixin> = {
-    /**可混入的字段 */
-    readonly MIXIN_FIELDS:ReadonlyArray<keyof Mixin>
+    /**混入时自身所在位置  
+     * 请使用字面量  
+     */
+    readonly MIXIN_KEY: string;
+    /**可混入的字段  
+     * 请使用字面量
+    */
+    readonly MIXIN_FIELDS: readonly (keyof Mixin)[];
 };
 
 /**自动组合可混入的类 */
-export type ComposedMixinable<B extends object, Ms extends Array<unknown>> = 
+export type ComposedMixinable<B extends object, Ms extends unknown[]> = 
     Ms extends [infer M, ...infer Rest]
         ? M extends Mixinable<M>
-            ? ComposedMixinable<ComposedClassPart<B,M,M['MIXIN_FIELDS'][number]>,Rest>
-            : B
+            ? ComposedMixinable<ComposedClass<B,M,M['MIXIN_KEY'],M['MIXIN_FIELDS'][number]>,Rest>
+            : "一个混入类没有实现 Mixinable<self>" & Error
         : B

package/src/backup.ts

@@ -0,0 +1,102 @@
+import { ComposedClass, FuncPropNames } from "./UtilInterfaces";
+
+/**类组合  
+ * 将mixinList每个成员的字段混入base  
+ * @param base      - 基础类
+ * @param mixinList - 目标类
+ * @returns - 混合完成的类
+ */
+export function composeClassFull<Base extends object,MixinList extends object[]>
+    (base:Base,...mixinList:MixinList):ComposedFullClassMult<Base,MixinList>{
+    let obj = base as any;
+    for(let mixin of mixinList as any){
+        let propks = Object.getOwnPropertyNames(mixin.constructor.prototype)
+        for(const key of propks){
+            if(key != "constructor"){
+                Object.defineProperty(obj, key, {
+                    get: ()=>mixin[key],
+                    set: (value)=>{mixin[key] = value},
+                    enumerable:true,
+                    //writable: true,
+                    configurable: true
+                });
+                //obj[key] = (mixin as any)[key];
+            }
+        }
+        for(const key in mixin){
+            Object.defineProperty(obj, key, {
+                get: ()=>mixin[key],
+                set: (value)=>{mixin[key] = value},
+                enumerable:true ,
+                //writable: true  ,
+                configurable: true
+            });
+            //obj[key] = (mixin as any)[key];
+        }
+    }
+    return obj;
+}
+
+///**组合的类 嵌套变体 */
+//export type ComposedClassMult<Base extends object, 
+//    Mixin1 extends object = {}, PropKeys1 extends keyof Mixin1 = keyof Mixin1,
+//    Mixin2 extends object = {}, PropKeys2 extends keyof Mixin2 = keyof Mixin2,
+//    Mixin3 extends object = {}, PropKeys3 extends keyof Mixin3 = keyof Mixin3,
+//    Mixin4 extends object = {}, PropKeys4 extends keyof Mixin4 = keyof Mixin4,
+//    Mixin5 extends object = {}, PropKeys5 extends keyof Mixin5 = keyof Mixin5,
+//    Mixin6 extends object = {}, PropKeys6 extends keyof Mixin6 = keyof Mixin6> = 
+//    ComposedClass<ComposedClass<ComposedClass<
+//    ComposedClass<ComposedClass<ComposedClass<
+//    Base,
+//    Mixin1,PropKeys1>,Mixin2,PropKeys2>,Mixin3,PropKeys3>,
+//    Mixin4,PropKeys4>,Mixin5,PropKeys5>,Mixin6,PropKeys6>
+//
+///**递归多组合 仅单key有效 */
+//type ComposedClassOnceKey<Base extends object,Data extends [object,string][]> = 
+//    Data extends [[infer Mixin extends object, infer FuncKeys], ...infer Rest]
+//        ? FuncKeys extends FuncPropNames<Mixin>
+//            ? Rest extends [any, any][]
+//                ? ComposedClassOnceKey<ComposedClass<Base, Mixin, FuncKeys>,Rest>
+//                : Base
+//            : Base
+//        : Base;
+
+
+
+/**组合的类  
+ * @template Base     - 基类
+ * @template Mixin    - 待混入的类
+ */
+export type ComposedFullClass<Base extends object,Mixin extends object> = Base&Mixin;
+/**组合的类 多组合变体  
+ * @template Base     - 基类
+ * @template MixinList- 待混入的类型数组
+ */
+export type ComposedFullClassMult<Base extends object,MixinList extends object[]> = 
+    MixinList extends [infer Mixin, ...infer Rest]
+        ? Mixin extends object
+            ? Rest extends object[]
+                ? ComposedFullClassMult<ComposedFullClass<Base,Mixin>,Rest>
+                : Base
+            : Base
+        : Base;
+
+/**将一个类型的所有方法的 `this` 参数改为 `T` 类型
+ * @template Methods - 待更改的函数表
+ * @template T - 目标this类型
+ */
+export type MethodsThisAs<Methods, T> = {
+    [K in keyof Methods]:
+        Methods[K] extends (...args: infer A) => infer R
+            ? (this: T, ...args: A) => R
+            : Methods[K];
+};
+
+/**尝试断言一个类的原型  
+ * 其所有函数的 this 都必须为某个类型  
+ * assignThisAs<Self,T>(Self.prototype);  
+ * @template Self   - 类的类型
+ * @template T      - 目标this类型
+ * @param prototype - 类的原型
+ */
+export function assertThisAs<Self,T>(prototype: MethodsThisAs<Self, T>) {}

package/src/test/composeTest.ts

@@ -1,11 +1,17 @@
-import { Mixinable, UtilFP, UtilFunc, assertThisAs } from ".."
+import { assertThisAs } from "@src/backup";
+import { Mixinable, UtilFP, UtilFunc } from ".."
+import { Writable } from "stream";
 
-class A implements Mixinable<A>{
-    private num = 1;
-    getNum = ()=>this.num;
+type MixinA = Mixinable<A>;
+class A implements MixinA{
+    anum = 1;
+    constructor(n=1){this.anum=n}
+    getNum = ()=>this.anum;
     /**A的函数 */
     getA=()=>this;
-    MIXIN_FIELDS =['getNum','getA'] as const;
+    readonly MIXIN_KEY = "__a" as const;
+    static MIXIN_FIELDS = ['getNum','getA','anum'] as const;
+    readonly MIXIN_FIELDS = A.MIXIN_FIELDS;
 }
 class B implements Mixinable<B>{
     private text = "B的text";
@@ -18,7 +24,9 @@ class B implements Mixinable<B>{
     privateFunc(){
         console.log()
     }
-    MIXIN_FIELDS = ['getText','getB'] as const;
+    readonly MIXIN_KEY = "__b" as const;
+    static readonly MIXIN_FIELDS = ['getText','getB'] as const;
+    readonly MIXIN_FIELDS = B.MIXIN_FIELDS;
 }
 class _C {
     static create(){
@@ -32,6 +40,13 @@ class _C {
         console.log(this);
         return 2;
     }
+    readonly MIXIN_KEY = "__c" as const;
+    static readonly MIXIN_FIELDS = [
+        ...A.MIXIN_FIELDS,
+        ...B.MIXIN_FIELDS,
+        'getC','__a'
+    ] as const;
+    readonly MIXIN_FIELDS = C.MIXIN_FIELDS;
 }
 function composeC(obj:_C){
     let ob1 = UtilFunc.composeMixinable(obj,new B(),new A());
@@ -40,12 +55,39 @@ function composeC(obj:_C){
 }
 export type C = ReturnType<typeof composeC>;
 export const C = _C;
-assertThisAs<_C,C>(C.prototype);
 
 const insc:C=C.create();//?
+console.log(insc.__a)
 insc.getC().testFunc()//?
+insc.getNum()//?
+insc.anum//?
+insc.__a = new A(2);
+insc.getNum()//?
+insc.anum//?
 insc.testFunc();//?
 insc.getText();//?
 insc.getB().getText()//?
 insc.bindFunc()//?
 
+class _D{
+    private constructor(){};
+    static create(){
+        return composeD(new _D());
+    }
+    #d = 123;
+}
+function composeD(obj:_D){
+    let ob1 = UtilFunc.composeMixinable(obj,C.create());
+    let ob3 = UtilFP.bindTo('bindFunc',()=>"这是动态绑定的函数",ob1);
+    return ob3;
+}
+export type D = ReturnType<typeof composeD>;
+export const D = _D;
+
+let insd:D = D.create();
+insd//?
+insd.getB()//?
+insd.getNum()//?
+insd.__a = new A(3);
+insd.getNum()//?
+

package/src/test/test.ts

@@ -1,68 +1,10 @@
 import { UtilFP } from "@src/UtilFP";
 import { UtilFunc } from "@src/UtilFunctions";
-import { ComposedClassMult, ComposedClassPart, ComposedPartClassMult, FixedLengthTuple, FuncPropNames } from "@src/UtilInterfaces";
+import { ComposedClass, FixedLengthTuple, FuncPropNames } from "@src/UtilInterfaces";
+import { ComposedFullClassMult, composeClassFull } from "@src/backup";
 
-const compKeys = ["getData","getA"] as const;
-
-class A {
-    abc=223;
-    /**A的getData */
-    getData(){
-        return this.abc
-    }
-    /**获取A */
-    getA(){
-        return this;
-    }
-}
-class C {
-    abc=3333;
-    /**A的getData */
-    resetData(){
-        return this.abc
-    }
-    /**获取C */
-    getC(){
-        return this;
-    }
-    /**获取C */
-    private getC1(){
-        return this;
-    }
-}
-class B{
-    private _bc:BComp;
-    private constructor(){
-        const tb:B = this;
-        this._bc = UtilFunc.composeClassPart(tb, new A(), ...compKeys);
-    }
-    static init(){
-        return new B()._bc;
-    }
-    /**B的getData */
-    getData1(){return "BGetdata"}
-    getTest(){return this._bc.getData()}
-}
-type BComp = ComposedClassPart<B, A, typeof compKeys[number]>;
-const BComp = {
-    init(){
-        return B.init();
-    }
-}
-
-let c:BComp = BComp.init();
-console.log(1);
-let d = c.getData();//?
-c.getA
-c.getData1();//?
-c.getTest();//?
 
 // 使用示例
-type R3 = ComposedPartClassMult<B, A, "getData"|"getA", C>
-let r3:R3 = null as any;
-
-
-
 class Monster{
     constructor(a:number){}
     monfunc(){
@@ -76,18 +18,18 @@ class Monster1{
         return "mon1"
     }
 }
-type OtherMonster = ComposedClassMult<{
+type OtherMonster = ComposedFullClassMult<{
     om:string
     mon:Monster
 },[Monster,Monster1]>
 const OtherMonster = {
-    init():OtherMonster{
+    init(){
         let mon = new Monster(123);
         let mon1 = new Monster1(223);
         let om = {
             om:"123",mon
         }
-        return UtilFunc.composeClass(om,mon,mon1);
+        return composeClassFull(om,mon,mon1);
     }
 }