@zwa73/utils 1.0.134 → 1.0.135

package/dist/UtilCom.d.ts

@@ -1,5 +1,22 @@
-import { JObject, ReqVerifyFn } from "./UtilInterfaces";
+import { AnyString, JObject, ReqVerifyFn } from "./UtilInterfaces";
 import { RepeatPromiseOpt } from "./UtilFunctions";
+export type ComPostOption = {
+    /**请求域名 */
+    hostname: string;
+    /**请求路径 */
+    path: string;
+    /**方式 post为 POST */
+    method: 'POST';
+    /**端口 */
+    port?: number;
+    /**请求头 */
+    headers?: {
+        /**内容类型 */
+        'Content-Type'?: 'application/json' | AnyString;
+        /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
+        'Content-Length'?: number;
+    };
+};
 type RepeatPostOpt = Partial<{
     /**httppost 超时中断时间限制 */
     postTimeLimit?: number;
@@ -13,7 +30,7 @@ export declare namespace UtilCom {
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
+    function shttpsPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | null>;
     /**发送一个 http POST请求并接受数据
      * @async
      * @param json 	    - 数据对象
@@ -21,7 +38,7 @@ export declare namespace UtilCom {
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
+    function shttpPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | null>;
     /**重复一个 https POST请求并接受数据
      * @async
      * @param json 	   - 数据对象
@@ -34,7 +51,7 @@ export declare namespace UtilCom {
      * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsRepeatPost(json: JObject, options: Object, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
+    function shttpsRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
@@ -48,6 +65,6 @@ export declare namespace UtilCom {
      * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpRepeatPost(json: JObject, options: Object, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
+    function shttpRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
 }
 export {};

package/dist/UtilCom.js

@@ -73,7 +73,7 @@ var UtilCom;
                             return;
                         }
                         try {
-                            let obj = JSON.parse(resdata);
+                            const obj = JSON.parse(resdata);
                             UtilLogger_1.SLogger.http(funcName + " 接受信息:", UtilFunctions_1.UtilFunc.stringifyJToken(obj));
                             resolve(obj);
                             return;

package/dist/UtilFP.d.ts

@@ -1,4 +1,4 @@
-import { Keyable, Literal, Matchable, MatchableFlag, ProperSubsetCheck } from "./UtilInterfaces";
+import { AnyRecord, Keyable, Literal, Matchable, MatchableFlag, ProperSubsetCheck } from "./UtilInterfaces";
 import { FailedLike } from "./UtilSymbol";
 /**常用函数式编程库 */
 export declare namespace UtilFP {
@@ -76,7 +76,7 @@ export declare namespace UtilFP {
      * 然后返回一个新的对象新的对象包含了基础对象的所有属性,
      * 以及一个新的属性, 这个新的属性的键是`key`, 值是`value`
      */
-    export function bind<K extends Keyable, V>(key: Literal<K>, value: V): <B extends {}>(base?: B) => keyof B extends K ? "Base中已有对应键" & Error : {
+    export function bind<K extends Keyable, V>(key: Literal<K>, value: V): <B extends AnyRecord>(base?: B) => keyof B extends K ? "Base中已有对应键" & Error : {
         [P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;
     };
     /**绑定一个键到一个基础对象上,
@@ -88,7 +88,7 @@ export declare namespace UtilFP {
      * 然后返回一个新的对象新的对象包含了基础对象的所有属性,
      * 以及一个新的属性, 这个新的属性的键是`key`, 值是基础对象
      */
-    export function bind<K extends Keyable>(key: Literal<K>): <B extends {}>(base?: B) => {
+    export function bind<K extends Keyable>(key: Literal<K>): <B extends AnyRecord>(base?: B) => {
         [P in K]: B;
     };
     /**绑定一个键和一个值到一个基础对象上, 并返回一个新的对象
@@ -102,7 +102,7 @@ export declare namespace UtilFP {
      * @param base  - 基础对象
      * @returns 完成绑定的基础对象
      */
-    export function bind<K extends Keyable, V, B extends {}>(key: Literal<K>, value: V, base: B): keyof B extends K ? "Base中已有对应键" & Error : {
+    export function bind<K extends Keyable, V, B extends AnyRecord>(key: Literal<K>, value: V, base: B): keyof B extends K ? "Base中已有对应键" & Error : {
         [P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;
     };
     /**创建一个对对象的每个属性进行映射的函数

package/dist/UtilFileTools.d.ts

@@ -29,6 +29,15 @@ type LoadJsonFileOpt<T> = Partial<{
     default: T;
     /**以json5模式加载 略慢 默认false */
     json5: boolean;
+    /**不自动修改扩展名为json */
+    forceExt: boolean;
+}>;
+/**json文件写入选项 */
+type WriteJsonFileOpt = Partial<{
+    /**使用紧凑风格 */
+    compress: boolean;
+    /**不自动修改扩展名为json */
+    forceExt: boolean;
 }>;
 /**文件工具 */
 export declare namespace UtilFT {
@@ -81,8 +90,9 @@ export declare namespace UtilFT {
     /**加载json文件 同步
      * @param filePath - 文件路径
      * @param opt      - 可选参数
-     * @param opt.default - 默认值
-     * @param opt.json5   - json5模式
+     * @param opt.default  - 默认值
+     * @param opt.json5    - json5模式
+     * @param opt.forceExt - 不自动修改扩展名为json
      * @returns 加载完成的对象或默认值
      */
     function loadJSONFileSync<T extends JToken>(filePath: string, opt: LoadJsonFileOpt<T>): T;
@@ -96,8 +106,9 @@ export declare namespace UtilFT {
      * @async
      * @param filePath - 文件路径
      * @param opt      - 可选参数
-     * @param opt.default - 默认值
-     * @param opt.json5   - json5模式
+     * @param opt.default  - 默认值
+     * @param opt.json5    - json5模式
+     * @param opt.forceExt - 不自动修改扩展名为json
      * @returns 加载完成的对象或默认值
      */
     function loadJSONFile<T extends JToken>(filePath: string, opt: LoadJsonFileOpt<T>): Promise<T>;
@@ -106,8 +117,11 @@ export declare namespace UtilFT {
      * @async
      * @param filePath - 文件路径
      * @param token    - 所要写入的JToken
+     * @param opt      - 可选参数
+     * @param opt.compress - 使用紧凑风格
+     * @param opt.forceExt - 不自动修改扩展名为json
      */
-    function writeJSONFile(filePath: string, token: JToken): Promise<void>;
+    function writeJSONFile(filePath: string, token: JToken, opt?: WriteJsonFileOpt): Promise<void>;
     /**保证路径为某个风格
      * @param filePath - 输入路径
      * @param style    - 目标风格 undefined 时不改变

package/dist/UtilFileTools.js

@@ -142,12 +142,11 @@ var UtilFT;
     }
     UtilFT.ensurePathExistsSync = ensurePathExistsSync;
     function loadJSONFileSync(filePath, opt) {
-        if (pathe_1.default.extname(filePath) !== '.json')
+        if (opt?.forceExt !== true && pathe_1.default.extname(filePath) !== '.json')
             filePath += '.json';
-        let str = "";
-        // 判断文件路径是否存在
-        if (pathExistsSync(filePath))
-            str = fs.readFileSync(filePath, "utf-8");
+        const str = pathExistsSync(filePath)
+            ? fs.readFileSync(filePath, "utf-8")
+            : "";
         // 如果不存在则返回默认值
         if (str == "" || str == null) {
             if (opt?.default !== undefined)
@@ -160,12 +159,11 @@ var UtilFT;
     }
     UtilFT.loadJSONFileSync = loadJSONFileSync;
     async function loadJSONFile(filePath, opt) {
-        if (pathe_1.default.extname(filePath) !== '.json')
+        if (opt?.forceExt !== true && pathe_1.default.extname(filePath) !== '.json')
             filePath += '.json';
-        let str = "";
-        // 判断文件路径是否存在
-        if (await pathExists(filePath))
-            str = await fs.promises.readFile(filePath, "utf-8");
+        const str = (await pathExists(filePath))
+            ? await fs.promises.readFile(filePath, "utf-8")
+            : "";
         // 如果不存在则返回默认值
         if (str == "" || str == null) {
             if (opt?.default !== undefined)
@@ -182,10 +180,13 @@ var UtilFT;
      * @async
      * @param filePath - 文件路径
      * @param token    - 所要写入的JToken
+     * @param opt      - 可选参数
+     * @param opt.compress - 使用紧凑风格
+     * @param opt.forceExt - 不自动修改扩展名为json
      */
-    async function writeJSONFile(filePath, token) {
-        const str = UtilFunctions_1.UtilFunc.stringifyJToken(token);
-        if (pathe_1.default.extname(filePath) !== '.json')
+    async function writeJSONFile(filePath, token, opt) {
+        const str = UtilFunctions_1.UtilFunc.stringifyJToken(token, opt);
+        if (opt?.forceExt !== true && pathe_1.default.extname(filePath) !== '.json')
             filePath += '.json';
         // 判断文件路径是否存在 不存在则创建
         if (!(await pathExists(filePath)))

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await } from "./UtilInterfaces";
+import { AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await, AnyRecord } 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"];
@@ -8,6 +8,13 @@ type ExecOpt = Partial<{
     outlvl: LogLevel;
     errlvl: LogLevel;
 }>;
+/**序列化选项 */
+type StringifyOpt = Partial<{
+    /**使用紧凑风格 */
+    compress: boolean;
+    /**插入的空格 数字为空格数量 默认为制表符\t */
+    space: string | number | null | undefined;
+}>;
 /**Promise重试选项 */
 export type RepeatPromiseOpt = Partial<{
     /**重试次数 默认3*/
@@ -34,7 +41,7 @@ export declare class UtilFunc {
      * @param defaultVal - 默认值
      * @returns 最终值
      */
-    static initField<T extends object, K extends keyof T>(obj: T, field: K, defaultVal: T[K]): T[K];
+    static initField<T extends AnyRecord, K extends keyof T>(obj: T, field: K, defaultVal: T[K]): T[K];
     /**初始化一个数据对象
      * @param obj       - 目标对象
      * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
@@ -107,26 +114,28 @@ export declare class UtilFunc {
      * @param fields - 需要混入的字段
      * @returns 混合完成的类
      */
-    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>;
+    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 object, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
+    static composeMixinable<Base extends AnyRecord, 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): ComposedRefMixinable<Base, Mixins>;
+    static composeRefMixinable<Base extends AnyRecord, Mixins extends RefMixinable<any, unknown>[]>(base: Base, ...mixins: Mixins): ComposedRefMixinable<Base, Mixins>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
      * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
-    static mapEntries<T extends object>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
+    static mapEntries<T extends AnyRecord>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
     /**将JToken转换为字符串
      * @param token - 待转换的Token
-     * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+     * @param opt   - 可选参数
+     * @param opt.space     - 插入的空格 数字为空格数量 默认为制表符\t
+     * @param opt.compress  - 使用紧凑风格
      * @returns 转换完成的字符串
      */
-    static stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
+    static stringifyJToken(token: JToken | IJData, opt?: StringifyOpt): string;
     /**代办表 用于队列处理等待 */
     static pendingMap: Record<Keyable, AnyFunc[]>;
     /**队列处理
@@ -202,7 +211,7 @@ export declare class UtilFunc {
      */
     static isSafeNumber(num: unknown): boolean;
     /**将一个字段加入一个对象中，将改变对象，返回新类型 */
-    static bindTo<K extends Keyable, V, B extends {} = {}>(key: Literal<K>, value: V, base?: B): keyof B extends K ? "Base中已有对应键" & Error : {
+    static bindTo<K extends Keyable, V, B extends AnyRecord = {}>(key: Literal<K>, value: V, base?: B): keyof B extends K ? "Base中已有对应键" & Error : {
         [P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;
     };
     /**移除多行字符串中每行开始的最小空格数。

package/dist/UtilFunctions.js

@@ -377,13 +377,30 @@ class UtilFunc {
     }
     /**将JToken转换为字符串
      * @param token - 待转换的Token
-     * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+     * @param opt   - 可选参数
+     * @param opt.space     - 插入的空格 数字为空格数量 默认为制表符\t
+     * @param opt.compress  - 使用紧凑风格
      * @returns 转换完成的字符串
      */
-    static stringifyJToken(token, space = "\t") {
-        if (space == null)
-            space = undefined;
-        return JSON.stringify(token, null, space);
+    static stringifyJToken(token, opt) {
+        opt ??= {};
+        let { compress, space } = opt;
+        space ??= "\t";
+        space = space === null ? undefined : space;
+        if (!compress)
+            return JSON.stringify(token, null, space);
+        const compressReplacer = (key, value) => {
+            if (Array.isArray(value) && value.every(item => typeof item === 'number' || typeof item === 'string' ||
+                typeof item === 'boolean' || item == null))
+                return `@@@${JSON.stringify(value)}@@@`;
+            const str = JSON.stringify(value);
+            if (str.length <= 100)
+                return `@@@${str}@@@`;
+            return value;
+        };
+        return JSON.stringify(token, compressReplacer, space)
+            .replace(/"@@@(.*?)@@@"/g, `$1`)
+            .replace(/\\([\\"])/g, '$1');
     }
     /**代办表 用于队列处理等待 */
     static pendingMap = {};

package/dist/UtilInterfaces.d.ts

@@ -49,7 +49,7 @@ export type Literal<L> = ProperSubset<string, L> | ProperSubset<number, L> | Pro
  */
 export type LiteralCheck<L> = ProperSubsetCheck<string, L> extends "P" ? true : ProperSubsetCheck<number, L> extends "P" ? true : ProperSubsetCheck<boolean, L> extends "P" ? true : ProperSubsetCheck<symbol, L> extends "P" ? true : ProperSubsetCheck<any[], L> extends "P" ? true : ProperSubsetCheck<Record<any, any>, L> extends "P" ? true : L extends null | undefined ? true : false;
 /**返回将Mixin分配给Base的结果,相同字段时Mixin覆盖Base */
-export type AssignObject<Base extends {}, Mixin extends {}> = {
+export type AssignObject<Base extends AnyRecord, Mixin extends AnyRecord> = {
     [P in keyof Mixin | keyof Base]: P extends keyof Mixin ? Mixin[P] : P extends keyof Base ? Base[P] : never;
 };
 /**转为可写的 */
@@ -138,8 +138,17 @@ export type ReflectionAble<Ctor, Constraint = {}> = {
 };
 /**可反射的 且 构造函数是可混入的类
  * @template Ctor        - 构造器类型
- * @template Instance    - 实例类型
+ * @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>;
 /**自动组合可混入的类
@@ -194,4 +203,12 @@ export type NeedInit = {
 };
 /**可选的record */
 export type PRecord<K extends Keyable, V> = Partial<Record<K, V>>;
+/**任何Record */
+export type AnyRecord = Record<Keyable, any>;
+/**注释元组
+ * @template T - 提供注释的类型, 索引需从0开始
+ */
+export type AnnotableTuple<T extends {
+    [K: number]: unknown;
+}, Tuple extends unknown[] = []> = unknown extends T[Tuple['length']] ? T & Tuple : AnnotableTuple<T, [...Tuple, T[Tuple['length']]]>;
 export {};

package/package.json

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

package/src/UtilCom.ts

@@ -1,10 +1,26 @@
-import { JObject, ReqVerifyFn } from "@src/UtilInterfaces";
+import { AnyString, JObject, ReqVerifyFn } from "@src/UtilInterfaces";
 import * as https from 'https';
 import * as http from 'http';
 import { SLogger } from "@src/UtilLogger";
 import { RepeatPromiseOpt, UtilFunc } from "@src/UtilFunctions";
 
-
+export type ComPostOption = {
+    /**请求域名 */
+    hostname: string;
+    /**请求路径 */
+    path: string;
+    /**方式 post为 POST */
+    method: 'POST';
+    /**端口 */
+    port?:number;
+    /**请求头 */
+    headers?: {
+        /**内容类型 */
+        'Content-Type'?: 'application/json'|AnyString;
+        /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
+        'Content-Length'?: number;
+    }
+}
 
 type RepeatPostOpt = Partial<{
     /**httppost 超时中断时间限制 */
@@ -21,7 +37,7 @@ export namespace UtilCom{
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit?:number):Promise<JObject|null>{
+function sPost(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
     //转换为毫秒
     const hasTimeLimit = (timeLimit ? timeLimit>=10 : false );
     if(hasTimeLimit && timeLimit!=undefined) timeLimit*=1000;
@@ -60,7 +76,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit?:nu
                         return;
                     }
                     try{
-                        let obj = JSON.parse(resdata);
+                        const obj = JSON.parse(resdata);
                         SLogger.http(funcName+" 接受信息:",UtilFunc.stringifyJToken(obj));
                         resolve(obj);
                         return;
@@ -109,7 +125,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit?:nu
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-export function shttpsPost(json:JObject,options:Object,timeLimit?:number):Promise<JObject|null>{
+export function shttpsPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
     return sPost("https",json,options,timeLimit);
 }
 
@@ -120,7 +136,7 @@ export function shttpsPost(json:JObject,options:Object,timeLimit?:number):Promis
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-export function shttpPost(json:JObject,options:Object,timeLimit?:number):Promise<JObject|null>{
+export function shttpPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
     return sPost("http",json,options,timeLimit);
 }
 
@@ -139,7 +155,7 @@ export function shttpPost(json:JObject,options:Object,timeLimit?:number):Promise
  * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,verifyFn?:ReqVerifyFn<JObject|null>,opt:RepeatPostOpt={}):Promise<JObject|null>{
+async function sRepeatPost(posttype:"http"|"https",json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt:RepeatPostOpt={}):Promise<JObject|null>{
     opt.count        = opt.count??3;
     opt.tryInterval = opt.tryInterval??180;
     opt.tryDelay    = opt.tryDelay??1;
@@ -161,7 +177,7 @@ async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,v
  * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-export function shttpsRepeatPost(json:JObject,options:Object,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
+export function shttpsRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
     return sRepeatPost("https",json,options,verifyFn,opt);
 }
 
@@ -178,7 +194,7 @@ export function shttpsRepeatPost(json:JObject,options:Object,verifyFn?:ReqVerify
  * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-export function shttpRepeatPost(json:JObject,options:Object,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
+export function shttpRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
     return sRepeatPost("http",json,options,verifyFn,opt);
 }
 

package/src/UtilFP.ts

@@ -1,5 +1,5 @@
 import { isFailed, likeNone } from "./QuickFunction";
-import { Keyable, Literal, Matchable, MatchableFlag, ProperSubset, ProperSubsetCheck } from "./UtilInterfaces";
+import { AnyRecord, Keyable, Literal, Matchable, MatchableFlag, ProperSubset, ProperSubsetCheck } from "./UtilInterfaces";
 import { Failed, FailedLike, None } from "./UtilSymbol";
 
 /**常用函数式编程库 */
@@ -116,7 +116,7 @@ export function pipe<T>(input: T, ...fs: ((arg: T) => T)[]): T {
  * 以及一个新的属性, 这个新的属性的键是`key`, 值是`value`  
  */
 export function bind<K extends Keyable, V>
-    (key: Literal<K>,value: V): <B extends {}>
+    (key: Literal<K>,value: V): <B extends AnyRecord>
     (base?: B) => keyof B extends K
         ? "Base中已有对应键"&Error
         : {[P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;};
@@ -130,7 +130,7 @@ export function bind<K extends Keyable, V>
  * 以及一个新的属性, 这个新的属性的键是`key`, 值是基础对象
  */
 export function bind<K extends Keyable>
-    (key: Literal<K>): <B extends {}>
+    (key: Literal<K>): <B extends AnyRecord>
     (base?: B) => { [P in K]: B };
 /**绑定一个键和一个值到一个基础对象上, 并返回一个新的对象  
  * 新的对象包含了基础对象的所有属性, 以及一个新的属性,  
@@ -143,7 +143,7 @@ export function bind<K extends Keyable>
  * @param base  - 基础对象
  * @returns 完成绑定的基础对象
  */
-export function bind<K extends Keyable, V, B extends {}>
+export function bind<K extends Keyable, V, B extends AnyRecord>
     (key: Literal<K>,value: V, base:B):keyof B extends K
         ? "Base中已有对应键"&Error
         : {[P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;};
@@ -156,7 +156,7 @@ export function bind
         return <B>(base?: B) =>
             ({[key as Keyable]:base});
 
-    return <B extends {}>
+    return <B extends AnyRecord>
         (base?: B):{
             [P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;
         } => base !== undefined

package/src/UtilFileTools.ts

@@ -40,8 +40,19 @@ type LoadJsonFileOpt<T> = Partial<{
     default:T;
     /**以json5模式加载 略慢 默认false */
     json5:boolean;
+    /**不自动修改扩展名为json */
+    forceExt:boolean;
 }>
 
+/**json文件写入选项 */
+type WriteJsonFileOpt = Partial<{
+    /**使用紧凑风格 */
+    compress:boolean;
+    /**不自动修改扩展名为json */
+    forceExt:boolean;
+}>
+
+
 /**文件工具 */
 export namespace UtilFT{
 
@@ -157,19 +168,19 @@ export function loadJSONFileSync(filePath: string): JToken
 /**加载json文件 同步
  * @param filePath - 文件路径
  * @param opt      - 可选参数
- * @param opt.default - 默认值
- * @param opt.json5   - json5模式
+ * @param opt.default  - 默认值
+ * @param opt.json5    - json5模式
+ * @param opt.forceExt - 不自动修改扩展名为json
  * @returns 加载完成的对象或默认值
  */
 export function loadJSONFileSync<T extends JToken>(filePath: string,opt:LoadJsonFileOpt<T>): T
 export function loadJSONFileSync<T extends JToken>(filePath: string,opt?:LoadJsonFileOpt<T>): T {
-    if (path.extname(filePath) !== '.json') filePath += '.json';
-
-    let str = "";
+    if(opt?.forceExt!==true && path.extname(filePath) !== '.json')
+        filePath += '.json';
 
-    // 判断文件路径是否存在
-    if(pathExistsSync(filePath))
-        str = fs.readFileSync(filePath, "utf-8");
+    const str = pathExistsSync(filePath)
+        ? fs.readFileSync(filePath, "utf-8")
+        : "";
 
     // 如果不存在则返回默认值
     if (str == "" || str == null){
@@ -192,19 +203,19 @@ export async function loadJSONFile(filePath: string): Promise<JToken>
  * @async
  * @param filePath - 文件路径
  * @param opt      - 可选参数
- * @param opt.default - 默认值
- * @param opt.json5   - json5模式
+ * @param opt.default  - 默认值
+ * @param opt.json5    - json5模式
+ * @param opt.forceExt - 不自动修改扩展名为json
  * @returns 加载完成的对象或默认值
  */
 export async function loadJSONFile<T extends JToken>(filePath: string,opt:LoadJsonFileOpt<T>): Promise<T>
 export async function loadJSONFile<T extends JToken>(filePath: string,opt?:LoadJsonFileOpt<T>): Promise<T> {
-    if (path.extname(filePath) !== '.json') filePath += '.json';
-
-    let str = "";
+    if(opt?.forceExt!==true && path.extname(filePath) !== '.json')
+        filePath += '.json';
 
-    // 判断文件路径是否存在
-    if(await pathExists(filePath))
-        str = await fs.promises.readFile(filePath, "utf-8");
+    const str = (await pathExists(filePath))
+        ? await fs.promises.readFile(filePath, "utf-8")
+        : "";
 
     // 如果不存在则返回默认值
     if (str == "" || str == null){
@@ -222,13 +233,18 @@ export async function loadJSONFile<T extends JToken>(filePath: string,opt?:LoadJ
  * @async
  * @param filePath - 文件路径
  * @param token    - 所要写入的JToken
+ * @param opt      - 可选参数
+ * @param opt.compress - 使用紧凑风格
+ * @param opt.forceExt - 不自动修改扩展名为json
  */
 export async function writeJSONFile(
     filePath: string,
-    token: JToken
+    token: JToken,
+    opt?: WriteJsonFileOpt
 ): Promise<void> {
-    const str = UtilFunc.stringifyJToken(token);
-    if (path.extname(filePath) !== '.json') filePath += '.json';
+    const str = UtilFunc.stringifyJToken(token,opt);
+    if(opt?.forceExt!==true && path.extname(filePath) !== '.json')
+        filePath += '.json';
 
     // 判断文件路径是否存在 不存在则创建
     if(!(await pathExists(filePath)))

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-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 { AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await, AnyRecord } 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";
@@ -18,6 +18,14 @@ type ExecOpt = Partial<{
     errlvl:LogLevel,
 }>
 
+/**序列化选项 */
+type StringifyOpt = Partial<{
+    /**使用紧凑风格 */
+    compress:boolean;
+    /**插入的空格 数字为空格数量 默认为制表符\t */
+    space:string|number|null|undefined;
+}>
+
 /**Promise重试选项 */
 export type RepeatPromiseOpt = Partial<{
     /**重试次数 默认3*/
@@ -59,7 +67,7 @@ static getTime(): number {
  * @param defaultVal - 默认值
  * @returns 最终值
  */
-static initField<T extends object,K extends keyof T>(
+static initField<T extends AnyRecord,K extends keyof T>(
     obj: T,
     field: K,
     defaultVal: T[K]
@@ -333,7 +341,7 @@ static timelimitPromise<T>
  * @returns 混合完成的类
  */
 static composeClassPart
-    <Base extends object,Mixin extends object,Field extends keyof Mixin>
+    <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)
@@ -374,7 +382,7 @@ static composeClassPart
  * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
  */
 static composeMixinable
-    <Base extends object, Mixins extends Mixinable<any>[]>
+    <Base extends AnyRecord, Mixins extends Mixinable<any>[]>
     (base:Base,...mixins:Mixins):
     ComposedMixinable<Base,Mixins>{
     let out = base;
@@ -395,7 +403,7 @@ static composeMixinable
 
 /**根据 MIXIN_FIELDS 自动混入 */
 static composeRefMixinable
-    <Base extends object, Mixins extends RefMixinable<any,unknown>[]>
+    <Base extends AnyRecord, Mixins extends RefMixinable<any,unknown>[]>
     (base:Base,...mixins:Mixins):
     ComposedRefMixinable<Base,Mixins>{
     let out = base;
@@ -421,7 +429,7 @@ static composeRefMixinable
  * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
  * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
  */
-static mapEntries<T extends object>
+static mapEntries<T extends AnyRecord>
     (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);
@@ -431,13 +439,32 @@ static mapEntries<T extends object>
 
 /**将JToken转换为字符串
  * @param token - 待转换的Token
- * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+ * @param opt   - 可选参数
+ * @param opt.space     - 插入的空格 数字为空格数量 默认为制表符\t
+ * @param opt.compress  - 使用紧凑风格
  * @returns 转换完成的字符串
  */
-static stringifyJToken(token:JToken|IJData,space:string|number|null|undefined="\t"){
-    if(space==null)
-        space=undefined;
-    return JSON.stringify(token,null,space);
+static stringifyJToken(token:JToken|IJData,opt?:StringifyOpt){
+    opt ??= {};
+    let {compress,space} = opt;
+    space ??="\t";
+    space = space===null ? undefined : space;
+
+    if(!compress) return JSON.stringify(token,null,space);
+
+    const compressReplacer = (key: string, value: any)=> {
+        if (Array.isArray(value) && value.every(item =>
+            typeof item === 'number' || typeof item === 'string' ||
+            typeof item === 'boolean' || item == null))
+            return `@@@${JSON.stringify(value)}@@@`;
+        const str = JSON.stringify(value);
+        if(str.length<=100) return `@@@${str}@@@`;
+        return value;
+    }
+
+    return JSON.stringify(token,compressReplacer,space)
+        .replace(/"@@@(.*?)@@@"/g,`$1`)
+        .replace(/\\([\\"])/g, '$1');
 }
 
 /**代办表 用于队列处理等待 */
@@ -643,7 +670,7 @@ static isSafeNumber(num: unknown): boolean {
 }
 
 /**将一个字段加入一个对象中，将改变对象，返回新类型 */
-static bindTo<K extends Keyable, V, B extends {} = {}>
+static bindTo<K extends Keyable, V, B extends AnyRecord = {}>
     (key: Literal<K>,value: V, base?:B):keyof B extends K
         ? "Base中已有对应键"&Error
         : {[P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;}{

package/src/UtilInterfaces.ts

@@ -73,7 +73,7 @@ export type LiteralCheck<L> =
     L extends null | undefined ? true : false;
 
 /**返回将Mixin分配给Base的结果,相同字段时Mixin覆盖Base */
-export type AssignObject<Base extends {}, Mixin extends {}> = {
+export type AssignObject<Base extends AnyRecord, Mixin extends AnyRecord> = {
     [P in keyof Mixin | keyof Base]: P extends keyof Mixin ? Mixin[P] : P extends keyof Base ? Base[P] : never;
 }
 
@@ -180,8 +180,17 @@ export type ReflectionAble<Ctor,Constraint={}> = {
 };
 /**可反射的 且 构造函数是可混入的类  
  * @template Ctor        - 构造器类型
- * @template Instance    - 实例类型
+ * @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>;
@@ -284,4 +293,14 @@ export type NeedInit = {
 };
 
 /**可选的record */
-export type PRecord<K extends Keyable,V> = Partial<Record<K,V>>;
+export type PRecord<K extends Keyable,V> = Partial<Record<K,V>>;
+/**任何Record */
+export type AnyRecord = Record<Keyable,any>;
+
+/**注释元组
+ * @template T - 提供注释的类型, 索引需从0开始
+ */
+export type AnnotableTuple<T extends {[K:number]:unknown},Tuple extends unknown[]=[]> =
+    unknown extends T[Tuple['length']]
+        ? T & Tuple
+        : AnnotableTuple<T,[...Tuple,T[Tuple['length']]]>;