@zwa73/utils 1.0.107 → 1.0.109

package/dist/UtilFileTools.d.ts

@@ -17,11 +17,15 @@ type EnsurePathExistsOpt = Partial<{
 type FileSearchGlobOpt = Partial<{
     /**忽略的文件 默认 undefined */
     ingore: string | string[];
+    /**输出的路径风格 默认跟随系统 */
+    normalize: "posix" | "win32";
 }>;
 /**regex搜索选项 */
 type FileSearchRegexOpt = Partial<{
     /**搜索子目录 默认 true */
     relative: boolean;
+    /**输出的路径风格 默认跟随系统 */
+    normalize: "posix" | "win32";
 }>;
 /**文件工具 */
 export declare namespace UtilFT {
@@ -98,21 +102,23 @@ export declare namespace UtilFT {
      */
     function writeJSONFile(filePath: string, token: JToken): Promise<void>;
     /**搜索路径符合正则表达式的文件
-     * @param folder        - 文件夹路径
+     * @param dir           - 起始目录
      * @param traitRegex    - 正则表达式
      * @param opt           - 可选参数
      * @param opt.relative  - 搜索子目录
+     * @param opt.normalize - 输出的路径风格 默认跟随系统
      * @returns 文件名路径数组
      */
-    function fileSearchRegex(folder: string, traitRegex: string, opt?: FileSearchRegexOpt): string[];
+    function fileSearchRegex(dir: string, traitRegex: string, opt?: FileSearchRegexOpt): string[];
     /**搜索符合Glob匹配的文件
-     * @param folder      - 文件夹路径
+     * @param dir         - 起始目录
      * @param globPattern - glob匹配
      * @param opt         - 可选参数
-     * @param opt.ignore  - 忽略的文件
+     * @param opt.ignore    - 忽略的文件
+     * @param opt.normalize - 输出的路径风格 默认跟随系统
      * @returns 文件绝对路径数组
      */
-    function fileSearchGlob(folder: string, globPattern: string | string[], opt?: FileSearchGlobOpt): string[];
+    function fileSearchGlob(dir: string, globPattern: string | string[], opt?: FileSearchGlobOpt): string[];
     /**
      * @deprecated 请使用 fileSearchRegex 或 fileSearchGlob
      */

package/dist/UtilFileTools.js

@@ -194,19 +194,21 @@ var UtilFT;
     }
     UtilFT.writeJSONFile = writeJSONFile;
     /**搜索路径符合正则表达式的文件
-     * @param folder        - 文件夹路径
+     * @param dir           - 起始目录
      * @param traitRegex    - 正则表达式
      * @param opt           - 可选参数
      * @param opt.relative  - 搜索子目录
+     * @param opt.normalize - 输出的路径风格 默认跟随系统
      * @returns 文件名路径数组
      */
-    function fileSearchRegex(folder, traitRegex, opt) {
+    function fileSearchRegex(dir, traitRegex, opt) {
         const relative = opt?.relative ?? true;
         const outArray = [];
-        const subFiles = fs.readdirSync(folder, { withFileTypes: true });
+        const subFiles = fs.readdirSync(dir, { withFileTypes: true });
+        //如果使用 g 会导致 RegExp.lastIndex 更改, 将会导致匹配错误
         const regex = new RegExp(traitRegex);
         for (const subFile of subFiles) {
-            const subFilePath = path.join(folder, subFile.name);
+            const subFilePath = path.join(dir, subFile.name);
             //判断是否是文件夹，递归调用
             if (subFile.isDirectory()) {
                 if (relative)
@@ -216,21 +218,31 @@ var UtilFT;
             if (regex.test(subFilePath))
                 outArray.push(subFilePath);
         }
-        return outArray;
+        return outArray.map((filePath) => {
+            if (opt?.normalize === undefined)
+                return filePath;
+            return path[opt.normalize].normalize(filePath);
+        });
+        ;
     }
     UtilFT.fileSearchRegex = fileSearchRegex;
     /**搜索符合Glob匹配的文件
-     * @param folder      - 文件夹路径
+     * @param dir         - 起始目录
      * @param globPattern - glob匹配
      * @param opt         - 可选参数
-     * @param opt.ignore  - 忽略的文件
+     * @param opt.ignore    - 忽略的文件
+     * @param opt.normalize - 输出的路径风格 默认跟随系统
      * @returns 文件绝对路径数组
      */
-    function fileSearchGlob(folder, globPattern, opt) {
+    function fileSearchGlob(dir, globPattern, opt) {
         const fixedPath = typeof globPattern === "string"
-            ? path.join(folder, path.posix.normalize(globPattern))
-            : globPattern.map((p) => path.join(folder, path.posix.normalize(p)));
-        return (0, glob_1.globSync)(fixedPath, { ignore: opt?.ingore, absolute: true });
+            ? path.join(dir, path.posix.normalize(globPattern))
+            : globPattern.map((p) => path.join(dir, path.posix.normalize(p)));
+        return (0, glob_1.globSync)(fixedPath, { ignore: opt?.ingore, absolute: true }).map((filePath) => {
+            if (opt?.normalize === undefined)
+                return filePath;
+            return path[opt.normalize].normalize(filePath);
+        });
     }
     UtilFT.fileSearchGlob = fileSearchGlob;
     /**

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunc, ComposedClass, ComposedMixinable, ComposedCtorMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, LiteralCheck, Matchable, MatchableFlag, Mixinable, Outcome, PromiseVerifyFn, RefMixinable, UnionToIntersection } from "./UtilInterfaces";
+import { AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, LiteralCheck, Matchable, MatchableFlag, Mixinable, Outcome, PromiseVerifyFn, RefMixinable, UnionToIntersection } from "./UtilInterfaces";
 import { LogLevel } from "./UtilLogger";
 import { FailedLike, None, StatusSymbol, Success, SuccessLike, Timeout } from "./UtilSymbol";
 type SuccessOut<T> = Outcome<Success, T>;
@@ -83,11 +83,11 @@ export declare class UtilFunc {
      */
     static 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 自动混入
-     * @deprecated 请使用 composeRefMixinable
+     * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
      */
     static composeMixinable<Base extends object, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
     /**根据 MIXIN_FIELDS 自动混入 */
-    static composeRefMixinable<Base extends object, Mixins extends RefMixinable<any, unknown>[]>(base: Base, ...mixins: Mixins): ComposedCtorMixinable<Base, Mixins>;
+    static composeRefMixinable<Base extends object, Mixins extends RefMixinable<any, unknown>[]>(base: Base, ...mixins: Mixins): ComposedRefMixinable<Base, Mixins>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象

package/dist/UtilFunctions.js

@@ -255,17 +255,21 @@ class UtilFunc {
         for (const fd of fields) {
             if (compObj[fd] !== undefined)
                 UtilLogger_1.SLogger.warn(`field: ${fd} 已存在于基础类中, 混入可能导致类型问题, 如需覆盖, 请使用 ${key}=val`);
-            //Object.defineProperty(compObj, fd, {
-            //    get: ()=>compObj[key][fd],
-            //    set: (value)=>{compObj[key][fd] = value},
-            //    enumerable:true ,
-            //    //writable: true  ,
-            //    configurable: true
-            //});
+            //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, {
@@ -280,7 +284,7 @@ class UtilFunc {
         return compObj;
     }
     /**根据 MIXIN_FIELDS 自动混入
-     * @deprecated 请使用 composeRefMixinable
+     * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
      */
     static composeMixinable(base, ...mixins) {
         let out = base;

package/dist/UtilInterfaces.d.ts

@@ -117,16 +117,17 @@ export type ReflectionAble<Ctor, Constraint = {}> = {
     /**原型构造器 */
     readonly CTOR: Ctor & Constraint;
 };
-/**构造函数是可混入的类
- * @template Ctor - 构造器类型
+/**可反射的 且 构造函数是可混入的类
+ * @template Ctor        - 构造器类型
  * @template Instance    - 实例类型
  * @template Constraint  - 构造器约束
  */
 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 ComposedCtorMixinable<B, Ms extends unknown[]> = Ms extends [infer M, ...infer Rest] ? M extends RefMixinable<unknown, M> ? ComposedCtorMixinable<ComposedClass<B, M, M['CTOR']['MIXIN_KEY'], M['CTOR']['MIXIN_FIELDS'][number]>, Rest> : "一个混入类没有实现  RefMixinable<typeof self, 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.107",
+	"version": "1.0.109",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {

package/src/UtilFileTools.ts

@@ -25,12 +25,16 @@ type EnsurePathExistsOpt = Partial<{
 type FileSearchGlobOpt = Partial<{
     /**忽略的文件 默认 undefined */
     ingore:string|string[];
+    /**输出的路径风格 默认跟随系统 */
+    normalize:"posix"|"win32";
 }>
 
 /**regex搜索选项 */
 type FileSearchRegexOpt = Partial<{
     /**搜索子目录 默认 true */
     relative:boolean;
+    /**输出的路径风格 默认跟随系统 */
+    normalize:"posix"|"win32";
 }>
 
 /**文件工具 */
@@ -228,19 +232,21 @@ export async function writeJSONFile(
 }
 
 /**搜索路径符合正则表达式的文件
- * @param folder        - 文件夹路径
+ * @param dir           - 起始目录
  * @param traitRegex    - 正则表达式
  * @param opt           - 可选参数
  * @param opt.relative  - 搜索子目录
+ * @param opt.normalize - 输出的路径风格 默认跟随系统
  * @returns 文件名路径数组
  */
-export function fileSearchRegex(folder: string, traitRegex: string, opt?:FileSearchRegexOpt) {
+export function fileSearchRegex(dir: string, traitRegex: string, opt?:FileSearchRegexOpt) {
     const relative = opt?.relative ?? true;
     const outArray: string[] = [];
-    const subFiles = fs.readdirSync(folder,{withFileTypes:true});
+    const subFiles = fs.readdirSync(dir,{withFileTypes:true});
+    //如果使用 g 会导致 RegExp.lastIndex 更改, 将会导致匹配错误
     const regex = new RegExp(traitRegex);
     for (const subFile of subFiles) {
-        const subFilePath = path.join(folder, subFile.name);
+        const subFilePath = path.join(dir, subFile.name);
         //判断是否是文件夹，递归调用
         if (subFile.isDirectory()) {
             if(relative) outArray.push(...fileSearchRegex(path.join(subFilePath, path.sep), traitRegex));
@@ -248,20 +254,27 @@ export function fileSearchRegex(folder: string, traitRegex: string, opt?:FileSea
         }
         if (regex.test(subFilePath)) outArray.push(subFilePath);
     }
-    return outArray;
+    return outArray.map((filePath)=>{
+        if(opt?.normalize===undefined) return filePath;
+        return path[opt.normalize].normalize(filePath);
+    });;
 }
 /**搜索符合Glob匹配的文件
- * @param folder      - 文件夹路径
+ * @param dir         - 起始目录
  * @param globPattern - glob匹配
  * @param opt         - 可选参数
- * @param opt.ignore  - 忽略的文件
+ * @param opt.ignore    - 忽略的文件
+ * @param opt.normalize - 输出的路径风格 默认跟随系统
  * @returns 文件绝对路径数组
  */
-export function fileSearchGlob(folder: string, globPattern:string|string[],opt?:FileSearchGlobOpt){
+export function fileSearchGlob(dir: string, globPattern:string|string[],opt?:FileSearchGlobOpt){
     const fixedPath = typeof globPattern === "string"
-        ? path.join(folder,path.posix.normalize(globPattern))
-        : globPattern.map((p)=>path.join(folder,path.posix.normalize(p)));
-    return globSync(fixedPath,{ignore:opt?.ingore,absolute:true});
+        ? path.join(dir,path.posix.normalize(globPattern))
+        : globPattern.map((p)=>path.join(dir,path.posix.normalize(p)));
+    return globSync(fixedPath,{ignore:opt?.ingore,absolute:true}).map((filePath)=>{
+        if(opt?.normalize===undefined) return filePath;
+        return path[opt.normalize].normalize(filePath);
+    });
 }
 /**
  * @deprecated 请使用 fileSearchRegex 或 fileSearchGlob

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { AnyFunc, ComposedClass, ComposedMixinable, ComposedCtorMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, LiteralCheck, Matchable, MatchableFlag, Mixinable, Outcome, PromiseStat, PromiseVerifyFn, RefMixinable, UnionToIntersection } from "@src/UtilInterfaces";
+import { AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, LiteralCheck, Matchable, MatchableFlag, Mixinable, Outcome, PromiseStat, PromiseVerifyFn, RefMixinable, UnionToIntersection } 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";
@@ -280,17 +280,21 @@ static composeClassPart
     for(const fd of fields){
         if(compObj[fd]!==undefined)
             SLogger.warn(`field: ${fd as string} 已存在于基础类中, 混入可能导致类型问题, 如需覆盖, 请使用 ${key}=val`);
-        //Object.defineProperty(compObj, fd, {
-        //    get: ()=>compObj[key][fd],
-        //    set: (value)=>{compObj[key][fd] = value},
-        //    enumerable:true ,
-        //    //writable: true  ,
-        //    configurable: true
-        //});
+        //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],
@@ -304,8 +308,8 @@ static composeClassPart
     return compObj;
 }
 
-/**根据 MIXIN_FIELDS 自动混入 
- * @deprecated 请使用 composeRefMixinable
+/**根据 MIXIN_FIELDS 自动混入  
+ * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
  */
 static composeMixinable
     <Base extends object, Mixins extends Mixinable<any>[]>
@@ -331,7 +335,7 @@ static composeMixinable
 static composeRefMixinable
     <Base extends object, Mixins extends RefMixinable<any,unknown>[]>
     (base:Base,...mixins:Mixins):
-    ComposedCtorMixinable<Base,Mixins>{
+    ComposedRefMixinable<Base,Mixins>{
     let out = base;
     const fieldsSet = new Set<string>();
     for(const mixin of mixins){

package/src/UtilInterfaces.ts

@@ -152,8 +152,8 @@ export type ReflectionAble<Ctor,Constraint={}> = {
     /**原型构造器 */
     readonly CTOR:Ctor&Constraint
 };
-/**构造函数是可混入的类  
- * @template Ctor - 构造器类型
+/**可反射的 且 构造函数是可混入的类  
+ * @template Ctor        - 构造器类型
  * @template Instance    - 实例类型
  * @template Constraint  - 构造器约束
  */
@@ -161,7 +161,8 @@ 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>
@@ -169,11 +170,11 @@ export type ComposedMixinable<B, Ms extends unknown[]> =
             : "一个混入类没有实现 Mixinable<self>" & Error
         : B
 
-/**自动组合构造类型是可混入的类 */
-export type ComposedCtorMixinable<B, Ms extends unknown[]> = 
+/**自动组合 可反射的 且 构造函数是可混入的 类 */
+export type ComposedRefMixinable<B, Ms extends unknown[]> = 
     Ms extends [infer M, ...infer Rest]
         ? M extends RefMixinable<unknown,M>
-            ? ComposedCtorMixinable<ComposedClass<B,M,
+            ? ComposedRefMixinable<ComposedClass<B,M,
                 M['CTOR']['MIXIN_KEY'],
                 M['CTOR']['MIXIN_FIELDS'][number]>,
                 Rest>
@@ -196,8 +197,7 @@ export type ExtendThen<B,T,Y,N = never> = B extends T ? Y : N;
  */
 type UnionInclude<B,T,Y,N = never> =
     B extends Exclude<B,T>
-        ? N
-        : Y
+        ? N : Y
 /**排除可选字段 */
 export type RequiredOnly<T> = {
     [K in keyof T as