@zwa73/utils 1.0.47 → 1.0.49

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { JToken, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "./UtilInterfaces";
+import { ComposedClass, ComposedClassMult, ComposedPartClass as ComposedPartClass, FuncPropNames, JToken, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "./UtilInterfaces";
 import * as cp from "child_process";
 import { SLogger } from "./UtilLogger";
 
@@ -92,6 +92,7 @@ export function exec(command: string) {
 	});
 }
 
+/**永不完成的Promise单例 */
 const NeverResolvedPromise = new Promise(()=>{});
 /**获得一个永不完成的Promise单例 */
 export function getNeverResolvedPromise<T>():Promise<T>{
@@ -112,9 +113,9 @@ type ProcessingPromise<T> = {
  * @async
  * @param {PromiseProcFn<T>} [procFn]       - 发起函数
  * @param {PromiseVerifyFn<T>} [verifyFn]   - 验证函数
- * @param {number} [repeatCount]    - 重试次数
- * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @returns {Promise<T|null>}       - 结果 null 为全部失败/超时
+ * @param {number} [repeatCount]            - 重试次数
+ * @param {number} [repeatTime]             - 超时时间/秒  最小为10秒
+ * @returns {Promise<T|null>}               - 结果 null 为全部失败/超时
  */
 export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:PromiseVerifyFn<T>,
     repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
@@ -215,5 +216,150 @@ export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:Promise
     }
 }
 
+
+/**柯里化函数类型 */
+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
+            : never
+    : never;
+
+/**柯里化转换  
+ * @param {T} fn - 将要转换的函数
+ * @returns {CurryFunc<T>} 柯里化的函数
+ */
+export function curry<T extends (...args: any[]) => any>(fn: T): CurryFunc<T> {
+    return (function curried(...args: any[]) {
+        if (args.length >= fn.length)
+            return fn(...args);
+        return (...restArgs: any[]) => curried(...args, ...restArgs);
+    }) as CurryFunc<T>;
+}
+/**
+let sumvoid = ()=>10;
+let a = curry(sumvoid);//?
+console.log(a());
+let sum = (a:number,b:string,c:number,d:boolean)=>a+b+c+d;
+let sumCu = curry(sum);//?
+let suma = sumCu(1)("ss");//?
+let sumb = sumCu(1,"1")(2);//?
+let sumc = sumCu(4);//?
+let sumz = sumCu(1,"b",3)(false);//?
+console.log(suma(2,true));
+console.log(sumb(true));
+console.log(sumc("s",3,false));
+*/
+/**可组合的函数 */
+type CompFunc<T = any, R = any> = (arg: T) => R;
+/**函数组合 从右到左执行 */
+export function compose<T>(...fs: CompFunc<T, T>[]): CompFunc<T, T>;
+export function compose<T, R>(f1: CompFunc<T, R>): CompFunc<T, R>;
+export function compose<T, R, R1>(f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R1>;
+export function compose<T, R, R1, R2>(f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R2>;
+export function compose<T, R, R1, R2, R3>(f4: CompFunc<R2, R3>, f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R3>;
+export function compose<T, R, R1, R2, R3, R4>(f5: CompFunc<R3, R4>,f4: CompFunc<R2, R3>, f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R4>;
+/**函数组合  
+ * 从右到左执行  
+ * @param {Function[]} funcs - 待组合的函数
+ * @returns {(arg: any)=>any} 组合完成的函数
+ */
+export function compose(...funcs: Function[]) {
+    return (arg: any) => funcs.reduceRight((value, func) => func(value), arg);
+}
+/**函数管道 从左到右执行  */
+export function pipeline<T>(...fs: CompFunc<T, T>[]): CompFunc<T, T>;
+export function pipeline<T, R>(f1: CompFunc<T, R>): CompFunc<T, R>;
+export function pipeline<T, R, R1>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>): CompFunc<T, R1>;
+export function pipeline<T, R, R1, R2>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>): CompFunc<T, R2>;
+export function pipeline<T, R, R1, R2, R3>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>, f4: CompFunc<R2, R3>): CompFunc<T, R3>;
+export function pipeline<T, R, R1, R2, R3, R4>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>, f4: CompFunc<R2, R3>, f5: CompFunc<R3, R4>): CompFunc<T, R4>;
+/**函数管道  
+ * 从左到右执行  
+ * @param {((arg: T) => T)} funcs - 待组合的函数
+ * @returns {((arg: T) => T)} 组合完成的函数
+ */
+export function pipeline<T>(...funcs: ((arg: T) => T)[]): (arg: T) => T {
+    return (arg: T): T => {
+        return funcs.reduce((value, func) => func(value), arg);
+    };
+}
+
+/**部分类组合  
+ * 将mixin的部分字段混入base  
+ * @param base   - 基础类
+ * @param mixin  - 目标类
+ * @param fields - 需要混入的字段
+ * @returns - 混合完成的类
+ */
+export function composePartClass<Base extends object,Mixin extends object>
+    (base:Base,mixin:Mixin,...fields:(keyof Mixin)[]):ComposedPartClass<Base,Mixin,keyof Mixin>{
+    const compObj = base as any;
+    for(const fd of fields){
+        Object.defineProperty(compObj, fd, {
+            get: ()=>mixin[fd],
+            set: (value)=>{mixin[fd] = value},
+            enumerable:true ,
+            //writable: true  ,
+            configurable: true
+        });
+        //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
+    }
+    return compObj;
+}
+/**类组合  
+ * 将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];
+        }
+    }
+    return obj;
+}
+
+/**对对象的每个属性应用映射函数，并返回一个新的对象。
+ * @template T      - 对象的类型
+ * @param obj       - 要处理的对象
+ * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
+ * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
+ */
+export function mapObject<T extends Object>
+    (obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T {
+    return Object.entries(obj).reduce((result, [key, value]) => {
+        result[key as keyof T] = mapper(key as keyof T, value);
+        return result;
+    }, {} as T);
 }
 
+}

package/src/UtilInterfaces.ts

@@ -80,4 +80,59 @@ export type PromiseStat = "Completed"|"Failed"|"Terminated";
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj:T)=>Promise<PromiseStat>|PromiseStat;
 /**发起promise的函数 */
-export type PromiseProcFn<T> = ()=>Promise<T>;
+export type PromiseProcFn<T> = ()=>Promise<T>;
+
+/**类型中任意函数的字符串名称 */
+export type FuncPropNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+/**部分组合的类 
+ * @template {Base}     - 基类
+ * @template {Mixin}    - 待混入的类
+ * @template {PropKeys} - 需要混入的成员key
+ */
+export type ComposedPartClass<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> = 
+    ComposedPartClass<ComposedPartClass<ComposedPartClass<
+    ComposedPartClass<ComposedPartClass<ComposedPartClass<
+    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<ComposedPartClass<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;

package/src/test/test.ts

@@ -0,0 +1,223 @@
+import { UtilFunc } from "../UtilFunctions";
+import { ComposedClassMult, ComposedPartClass, ComposedPartClassMult, FixedLengthTuple, FuncPropNames } from "../UtilInterfaces";
+
+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.composePartClass(tb, new A(), ...compKeys);
+    }
+    static init(){
+        return new B()._bc;
+    }
+    /**B的getData */
+    getData1(){return "BGetdata"}
+    getTest(){return this._bc.getData()}
+}
+type BComp = ComposedPartClass<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(){
+        return "mon"
+    }
+}
+class Monster1{
+    constructor(a:number){}
+    m1num=123;
+    monfunc1(){
+        return "mon1"
+    }
+}
+type OtherMonster = ComposedClassMult<{
+    om:string
+    mon:Monster
+},[Monster,Monster1]>
+const OtherMonster = {
+    init():OtherMonster{
+        let mon = new Monster(123);
+        let mon1 = new Monster1(223);
+        let om = {
+            om:"123",mon
+        }
+        return UtilFunc.composeClass(om,mon,mon1);
+    }
+}
+
+let om = OtherMonster.init();//?
+om.monfunc();//?
+om.monfunc1();//?
+om.m1num//?
+
+type ExtData = {
+    攻击         : number;
+    生命         : number;
+    防御         : number;
+    暴击         : number;
+    暴击伤害     : number;
+    攻击加成     : number;
+    生命加成     : number;
+    防御加成     : number;
+};
+const BASE_MAX = { 攻击: 24, 生命: 54, 防御: 16, 暴击: 5, 暴击伤害: 5, 攻击加成: 3.8, 生命加成: 3.8, 防御加成: 3.8 }
+const 精调前 = [
+    { 攻击  : 17, 生命: 0  , 防御: 0  , 暴击: 0   , 暴击伤害: 3.5 , 攻击加成: 3.0, 生命加成: 0, 防御加成: 3.4 } , // 霰弹 专用消焰器
+    { 攻击  : 19, 生命: 0  , 防御: 0  , 暴击: 4.5 , 暴击伤害: 4.5 , 攻击加成: 3.4, 生命加成: 0, 防御加成: 0   } , // 霰弹 专用消音器
+    { 攻击  : 21, 生命: 0  , 防御: 10 , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 3.8, 生命加成: 0, 防御加成: 3.0 } , // 机枪 重型制退器
+    { 攻击  : 17, 生命: 48 , 防御: 14 , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 2.6, 生命加成: 0, 防御加成: 0   } , // 冲锋 消焰器攻击头
+    { 攻击  : 23, 生命: 0  , 防御: 0  , 暴击: 5   , 暴击伤害: 0   , 攻击加成: 3.4, 生命加成: 0, 防御加成: 0   } , // 狙击 异位打击 快拆战术手电
+    { 攻击  : 17, 生命: 53 , 防御: 0  , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 3.4, 生命加成: 0, 防御加成: 0   } , // 霰弹 减伤支援 钢化铆钉
+    { 攻击  : 21, 生命: 0  , 防御: 0  , 暴击: 3.5 , 暴击伤害: 0   , 攻击加成: 3.0, 生命加成: 0, 防御加成: 0   } , // 冲锋 异位打击 内瞄式红点
+    { 攻击  : 17, 生命: 0  , 防御: 3.8, 暴击: 0   , 暴击伤害: 0   , 攻击加成: 2.6, 生命加成: 0, 防御加成: 0   } , // 机枪 双重对策 镭射插件
+    { 攻击  : 19, 生命: 38 , 防御: 0  , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 3.4, 生命加成: 0, 防御加成: 0   } , // 机枪 双重对策 折叠脚架
+] as const;
+const 精调后 = [
+    { 攻击  : 26, 生命: 0  , 防御: 0  , 暴击: 0   , 暴击伤害: 8.1 , 攻击加成: 7.5, 生命加成: 0, 防御加成: 5.8 } , // 霰弹 专用消焰器
+    { 攻击  : 31, 生命: 0  , 防御: 0  , 暴击: 10.4, 暴击伤害: 10.4, 攻击加成: 7.5, 生命加成: 0, 防御加成: 0   } , // 霰弹 专用消音器
+    { 攻击  : 49, 生命: 0  , 防御: 17 , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 7.6, 生命加成: 0, 防御加成: 6.9 } , // 机枪 重型制退器
+    { 攻击  : 46, 生命: 116, 防御: 27 , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 5.0, 生命加成: 0, 防御加成: 0   } , // 冲锋 消焰器攻击头
+    { 攻击  : 42, 生命: 0  , 防御: 0  , 暴击: 11.5, 暴击伤害: 0   , 攻击加成: 6.8, 生命加成: 0, 防御加成: 0   } , // 狙击 异位打击 快拆战术
+    { 攻击  : 34, 生命: 101, 防御: 0  , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 6.5, 生命加成: 0, 防御加成: 0   } , // 霰弹 减伤支援 钢化铆钉
+    { 攻击  : 38, 生命: 0  , 防御: 0  , 暴击: 8.4 , 暴击伤害: 0   , 攻击加成: 4.8, 生命加成: 0, 防御加成: 0   } , // 冲锋 异位打击 内瞄式红
+    { 攻击  : 43, 生命: 0  , 防御: 8.0, 暴击: 0   , 暴击伤害: 0   , 攻击加成: 7.3, 生命加成: 0, 防御加成: 0   } , // 机枪 双重对策 镭射插件
+    { 攻击  : 42, 生命: 54 , 防御: 0  , 暴击: 0   , 暴击伤害: 0   , 攻击加成: 6.2, 生命加成: 0, 防御加成: 0   } , // 机枪 双重对策 折叠脚架
+] as const;
+const Pointify = (ed:ExtData)=>
+    UtilFunc.mapObject(ed,(k,v)=> v ? v / BASE_MAX[k] : 0 );
+const Sump = (ed:ExtData)=> Object.values(ed).reduce((r,v)=>r+v);
+const pipeFunc = UtilFunc.pipeline(Pointify,Sump);
+const Display = (list:number[])=>list.reduce((r,v)=>`${r}\t${v.toFixed(2)}`,"").trim();
+const pre = 精调前.map((v)=>pipeFunc(v));
+const aft = 精调后.map((v)=>pipeFunc(v));
+const div = pre.map((dv,i)=>aft[i]/dv);
+Display(pre)//?
+Display(aft)//?
+Display(div)//?
+
+
+interface obja {
+    a: number;
+}
+// 定义一个函数，它将作为构造函数
+function MyObject() {
+    // @ts-ignore
+    this.a = 123;
+}
+
+
+let asloop = [
+    {
+        type:"effect_of_condition",
+        id:"loop",
+        effect:[
+            {if:{math:["i",">","0"]},
+            then:[
+                {u_message:"hello world"},
+                {math:["i","-=","1"]},
+                {run_eocs:"loop"},
+            ]}
+        ]
+    },
+    {
+        type:"effect_of_condition",
+        id:"main",
+        effect:[
+            {math:["i","=","10"]},
+            {run_eocs:"loop"}
+        ]
+    }
+]
+let asaloop = [
+    {
+        type:"effect_of_condition",
+        id:"loop",
+        effect:[
+            {u_message:"hello world"}
+        ]
+    },
+    {
+        type:"effect_of_condition",
+        id:"main",
+        effect:[
+            {
+                run_eoc_with:"efl",
+                variables:{
+                    i:"0",
+                    length:"10",
+                    eoc:"loop"
+                }
+            }
+        ]
+    }
+]
+
+
+const testa = {
+    _a: 123
+}
+Object.defineProperty(testa, 'a', {
+    get: () =>1,
+    set: function(value) {
+        console.log('Set:', value);
+    },
+    enumerable: true
+});
+Object.defineProperty(testa, 'c', {
+    value: 123,
+    writable: true,
+    enumerable: true,
+    configurable: true
+});
+testa.constructor.prototype//?
+testa//?
+let testkeys:any = [];
+for(let k in testa)
+    testkeys.push(k)
+testkeys//?
+

package/src/test/test2.ts

@@ -0,0 +1,40 @@
+import * as fs from "fs";
+import * as path from "path";
+import { globSync } from "glob";
+import { UtilFT } from "../UtilFileTools";
+
+// 将字符串转换为十六进制
+function stringToHex(str:string) {
+    const buf = Buffer.from(str, 'utf8');
+    return buf.toString('hex');
+}
+
+// 将十六进制转换为字符串
+function hexToString(hex:string) {
+    const buf = Buffer.from(hex, 'hex');
+    return buf.toString('utf8');
+}
+
+// 示例
+let str = "Hello World";
+let hex = "0B0000002D";
+
+console.log(stringToHex(str));  // 输出字符串对应的十六进制
+console.log(hexToString(hex));  // 输出十六进制对应的字符串
+hexToString("556E6974794653")//?
+/** 
+首先我有一个文件夹./in
+我在里面存放了一些整合加密的二进制文件，文件名符合正则/.*\.bk/
+我需要你帮我写解密程序，将其解密并分离为单独的文件，接下来我告诉你解密方式:
+读取文件后，我们先用split(hexToString(hex))对文本进行分割成多块，然后在每一块找到第二个"UnityFS"，
+再从第二个UnityFS的开头截取到每一块的末尾
+我举一个例子，假设我们有一段分割完成的文本块 "112233 UnityFS sasasd UnityFS我需要的内容"
+那么它截取完成之后应该是"UnityFS我需要的内容"
+最后，我们在将所有截取完成的文本块作为文件输出到./out/{filename}
+文件名就是 {原文件名+块编号.bs}
+开始写吧
+**/
+path.parse("123.bs").name;//?
+
+let filepath = "F:\\Sosarciel\\SosarcielCore\\NodeJs\\utils\\src"
+UtilFT.fileSearchGlob(`${filepath}/**/*.ts`,"**/test/**/*.ts");//?

package/tsconfig.json

@@ -7,6 +7,8 @@
     "outDir": "./dist",
     "declaration": true,
     "baseUrl": ".",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
     "paths": {
       "@/*": ["./*"],
       "DataController": ["./src/DataController"],