@zwa73/utils 1.0.136 → 1.0.138

package/dist/UtilFileTools.d.ts

@@ -34,7 +34,7 @@ type LoadJsonFileOpt<T> = Partial<{
 }>;
 /**json文件写入选项 */
 type WriteJsonFileOpt = Partial<{
-    /**使用紧凑风格 */
+    /**使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误 */
     compress: boolean;
     /**不自动修改扩展名为json */
     forceExt: boolean;
@@ -118,7 +118,7 @@ export declare namespace UtilFT {
      * @param filePath - 文件路径
      * @param token    - 所要写入的JToken
      * @param opt      - 可选参数
-     * @param opt.compress - 使用紧凑风格
+     * @param opt.compress - 使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误
      * @param opt.forceExt - 不自动修改扩展名为json
      */
     function writeJSONFile(filePath: string, token: JToken, opt?: WriteJsonFileOpt): Promise<void>;

package/dist/UtilFileTools.js

@@ -181,7 +181,7 @@ var UtilFT;
      * @param filePath - 文件路径
      * @param token    - 所要写入的JToken
      * @param opt      - 可选参数
-     * @param opt.compress - 使用紧凑风格
+     * @param opt.compress - 使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误
      * @param opt.forceExt - 不自动修改扩展名为json
      */
     async function writeJSONFile(filePath, token, opt) {

package/dist/UtilFunctions.d.ts

@@ -10,7 +10,7 @@ type ExecOpt = Partial<{
 }>;
 /**序列化选项 */
 type StringifyOpt = Partial<{
-    /**使用紧凑风格 */
+    /**使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误 */
     compress: boolean;
     /**插入的空格 数字为空格数量 默认为制表符\t */
     space: string | number | null | undefined;
@@ -132,7 +132,7 @@ export declare class UtilFunc {
      * @param token - 待转换的Token
      * @param opt   - 可选参数
      * @param opt.space     - 插入的空格 数字为空格数量 默认为制表符\t
-     * @param opt.compress  - 使用紧凑风格
+     * @param opt.compress  - 使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误
      * @returns 转换完成的字符串
      */
     static stringifyJToken(token: JToken | IJData, opt?: StringifyOpt): string;
@@ -291,6 +291,6 @@ export declare class UtilFunc {
      * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
      * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
      */
-    static memoize<T extends (...args: JToken[]) => any>(fn: T, expiry?: number): T;
+    static memoize<T extends (...args: UnionToIntersection<JToken>[]) => any>(fn: T, expiry?: number): T;
 }
 export {};

package/dist/UtilFunctions.js

@@ -379,7 +379,7 @@ class UtilFunc {
      * @param token - 待转换的Token
      * @param opt   - 可选参数
      * @param opt.space     - 插入的空格 数字为空格数量 默认为制表符\t
-     * @param opt.compress  - 使用紧凑风格
+     * @param opt.compress  - 使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误
      * @returns 转换完成的字符串
      */
     static stringifyJToken(token, opt) {
@@ -401,8 +401,7 @@ class UtilFunc {
             return value;
         };
         return JSON.stringify(token, compressReplacer, space)
-            .replace(/"@@@(.*?)@@@"/g, `$1`)
-            .replace(/\\([\\"])/g, '$1');
+            .replace(/"@@@(.*?)@@@"/g, (match, p1) => p1.replace(/\\([\\"])/g, '$1'));
     }
     /**代办表 用于队列处理等待 */
     static pendingMap = {};

package/dist/UtilI18n.d.ts

@@ -0,0 +1,105 @@
+import { PRecord } from "./UtilInterfaces";
+/**语言:地区 表 */
+declare const I18nFlagTable: {
+    readonly zh: readonly ["CN", "TW"];
+    readonly en: readonly ["US"];
+};
+/**语言标签 */
+export type LangFlag = {
+    [P in keyof typeof I18nFlagTable]: `${P}-${typeof I18nFlagTable[P][number]}`;
+}[keyof typeof I18nFlagTable] | keyof typeof I18nFlagTable;
+/**源语言文本数据 */
+export type I18nOrigTextData = {
+    /**原文 */
+    original: string;
+    /**出现位置 */
+    position?: string;
+    /**特殊说明 */
+    desc?: string;
+    /**无效的 默认false */
+    invalid?: boolean;
+    /**特殊标记 */
+    mark?: string;
+    /**抓取时间戳 */
+    scan_time: string;
+    /**抓取方式 */
+    source: 'Regex' | 'Ast' | 'Runtime' | 'Manual';
+};
+/**I18n源语言数据 */
+export type I18nOrigTable = {
+    /**基础语言 */
+    base_lang: LangFlag;
+    texts: I18nOrigTextData[];
+};
+/**单语言I18N数据 */
+export type I18nSingleTable = {
+    /**基础语言 */
+    base_lang: LangFlag;
+    /**目标语言 */
+    target_lang: LangFlag;
+    /**更改时间戳 */
+    modify_time: string;
+    /**文本翻译表 */
+    translate_table: Record<string, string | null>;
+};
+/**处理过的i18n文本数据 */
+export type I18nTextData = I18nOrigTextData & {
+    lang_table: PRecord<LangFlag, string>;
+};
+/**处理过的I18n数据 */
+export type I18nTable = Omit<I18nOrigTable, 'texts'> & {
+    text_table: Record<string, I18nTextData>;
+};
+/**运行时I18n工具
+ * 需先调用 init初始化
+ */
+export declare class SI18n {
+    private static _table?;
+    private static _lang?;
+    private static _dataDir?;
+    private static _vaildLang?;
+    /**解析i18n索引 */
+    static parseI18nKey(i18nKey: string): {
+        base: string;
+        mark: string | undefined;
+    };
+    /**格式化文本与mark为i18n索引key */
+    static formatI18nKey(str: string, mark?: string): string;
+    /**特殊标记
+     * 若添加在文本末尾则不会作为原文文本显示, 仅供索引
+     * @param mk - 特殊标记文本
+     */
+    static mark(mk: string): `%%%${string}%%%`;
+    /**初始化函数，加载国际化数据，设置语言，并在进程退出前保存数据。
+     * @param i18nDataDir - 国际化数据的路径。
+     * @param lang        - 要设置的语言。
+     */
+    static init(i18nDataDir: string, lang: LangFlag): void;
+    /**根据提供的字符串，返回对应的国际化字符串
+     * @param text - 字符串数组。
+     * @returns 对应的国际化字符串。
+     */
+    static t(text: string): string;
+    /**根据提供的模板字符串和值，返回对应的国际化字符串。
+     * @param strings - 模板字符串数组。
+     * @param values  - 值数组。
+     * @returns 对应的国际化字符串。
+     */
+    static t(strings: TemplateStringsArray, ...values: any[]): string;
+    /**根据提供的键和语言，返回对应的国际化字符串。
+     * 如果没有找到对应的字符串，将会抛出错误。
+     * @param key  - 要查找的键。
+     * @param lang - 要查找的语言。
+     * @returns 对应的国际化字符串。
+     */
+    static getI18n(key: string, lang: LangFlag): string;
+    /**尝试获取指定语言的翻译，如果没有找到，将回滚到其他可用的语言。
+     * @param lang - 要查找的语言。
+     * @param dat  - 包含翻译的数据对象。
+     * @returns 找到的翻译，如果没有找到，将返回原始字符串。
+     */
+    static tryAndRollback(lang: LangFlag, dat: I18nTable['text_table'][string]): string;
+    /**保存数据 */
+    static saveTable(): Promise<void>;
+}
+export {};

package/dist/UtilI18n.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SI18n = void 0;
+const UtilFileTools_1 = require("./UtilFileTools");
+const UtilFunctions_1 = require("./UtilFunctions");
+const UtilLogger_1 = require("./UtilLogger");
+const pathe_1 = __importDefault(require("pathe"));
+/**语言:地区 表 */
+const I18nFlagTable = {
+    "zh": ["CN", "TW"],
+    "en": ["US"]
+};
+/**语言标签列表 */
+const LangFlagList = Object.entries(I18nFlagTable)
+    .map(([k, v]) => `${k}-${v}`)
+    .concat(Object.keys(I18nFlagTable));
+const MarkRegex = /%%%([^%]+)%%%$/;
+const BaseFile = 'base_lang.json';
+const LangDir = 'lang';
+/**运行时I18n工具
+ * 需先调用 init初始化
+ */
+class SI18n {
+    static _table;
+    static _lang;
+    static _dataDir;
+    static _vaildLang;
+    /**解析i18n索引 */
+    static parseI18nKey(i18nKey) {
+        const match = i18nKey.match(/([\s\S]+?)(%%%[^%]+%%%)?$/);
+        const base = match[1];
+        const mark = match[2] == '' || match[2] == undefined
+            ? undefined
+            : match[2].match(/^%%%([^%]+)%%%$/)[1];
+        return { base, mark };
+    }
+    /**格式化文本与mark为i18n索引key */
+    static formatI18nKey(str, mark) {
+        return str + (mark == undefined ? '' : SI18n.mark(mark));
+    }
+    /**特殊标记
+     * 若添加在文本末尾则不会作为原文文本显示, 仅供索引
+     * @param mk - 特殊标记文本
+     */
+    static mark(mk) {
+        return `%%%${mk}%%%`;
+    }
+    /**初始化函数，加载国际化数据，设置语言，并在进程退出前保存数据。
+     * @param i18nDataDir - 国际化数据的路径。
+     * @param lang        - 要设置的语言。
+     */
+    static init(i18nDataDir, lang) {
+        const date = new Date().toISOString();
+        const mergePath = pathe_1.default.join(i18nDataDir, BaseFile);
+        const table = UtilFileTools_1.UtilFT.loadJSONFileSync(mergePath, { default: {
+                base_lang: 'zh-CN',
+                texts: [],
+            } });
+        const { texts, ...rest } = table;
+        SI18n._table = {
+            ...rest,
+            text_table: texts.reduce((acc, cur) => ({ ...acc, [SI18n.formatI18nKey(cur.original, cur.mark)]: { ...cur, lang_table: {} } }), {}),
+        };
+        SI18n._vaildLang = [];
+        //覆盖入单语言文件
+        const singleDir = pathe_1.default.join(i18nDataDir, LangDir);
+        UtilFileTools_1.UtilFT.fileSearchGlobSync(singleDir, `**/${lang}*.json`)
+            .map(p => UtilFileTools_1.UtilFT.loadJSONFileSync(p))
+            .forEach(t => {
+            SI18n._vaildLang?.push(t.target_lang);
+            return Object.entries(t.translate_table)
+                .forEach(([k, v]) => {
+                if (v == null)
+                    return;
+                const ttable = SI18n._table.text_table;
+                ttable[k] ??= {
+                    original: k,
+                    scan_time: date,
+                    source: 'Runtime',
+                    lang_table: {}
+                };
+                const ltable = ttable[k].lang_table;
+                ltable[t.target_lang] ??= v;
+            });
+        });
+        if (!SI18n._vaildLang.includes(lang))
+            SI18n._vaildLang.push(lang);
+        SI18n._lang = lang;
+        SI18n._dataDir = i18nDataDir;
+    }
+    static t(strings, ...values) {
+        if (typeof strings == 'string') {
+            const p = SI18n.parseI18nKey(strings);
+            return SI18n.getI18n(p.base.replace(/%/g, '\\%') + (p.mark == undefined ? '' : SI18n.mark(p.mark)), SI18n._lang);
+        }
+        let i18nKey = ``;
+        const vakyeKeys = values.map((v, i) => `%${i}`);
+        for (let i = 0; i < values.length; i++)
+            i18nKey += strings[i].replace(/%/g, '\\%') + vakyeKeys[i];
+        i18nKey += strings[strings.length - 1];
+        //检查是否为mark
+        if (MarkRegex.test(String(values[values.length - 1])) && strings[strings.length - 1] == '')
+            i18nKey = i18nKey.replace(vakyeKeys[vakyeKeys.length - 1], '') + String(values[values.length - 1]);
+        //console.log(1,i18nKey)
+        let trans = SI18n.getI18n(i18nKey, SI18n._lang);
+        //console.log(2,trans)
+        vakyeKeys.forEach((k, i) => trans = trans.replace(new RegExp(`((?<!\\\\)${k})`), String(values[i])));
+        //console.log(3,trans)
+        return trans.replace(/\\%/g, '%');
+    }
+    /**根据提供的键和语言，返回对应的国际化字符串。
+     * 如果没有找到对应的字符串，将会抛出错误。
+     * @param key  - 要查找的键。
+     * @param lang - 要查找的语言。
+     * @returns 对应的国际化字符串。
+     */
+    static getI18n(key, lang) {
+        if (SI18n._table == undefined)
+            UtilFunctions_1.UtilFunc.throwError('SI18n 未初始化');
+        let obj = SI18n._table.text_table[key];
+        if (obj == undefined) {
+            UtilLogger_1.SLogger.warn(`SI18n 未在 ${SI18n._dataDir} 找到 ${key} 对应的数据, 已自动添加`);
+            const p = SI18n.parseI18nKey(key);
+            SI18n._table.text_table[key] = {
+                original: p.base,
+                scan_time: new Date().toISOString(),
+                lang_table: {},
+                mark: p.mark,
+                source: 'Runtime'
+            };
+            obj = SI18n._table.text_table[key];
+        }
+        if (obj.invalid === true)
+            return obj.original;
+        return SI18n.tryAndRollback(lang, obj);
+    }
+    /**尝试获取指定语言的翻译，如果没有找到，将回滚到其他可用的语言。
+     * @param lang - 要查找的语言。
+     * @param dat  - 包含翻译的数据对象。
+     * @returns 找到的翻译，如果没有找到，将返回原始字符串。
+     */
+    static tryAndRollback(lang, dat) {
+        const langTable = {
+            [SI18n._table.base_lang]: dat.original,
+            ...dat.lang_table
+        };
+        if (langTable[lang] != undefined)
+            return langTable[lang];
+        const l1 = lang.match(/^([^-]+)/)[1];
+        const rb = Object.entries(langTable).find(([k, v]) => k.includes(l1));
+        if (rb)
+            return rb[1];
+        return dat.original;
+    }
+    /**保存数据 */
+    static async saveTable() {
+        const { text_table, ...rest } = SI18n._table;
+        const date = new Date().toISOString();
+        //console.log(text_table)
+        //保存原始文本数据
+        const tb = {
+            ...rest,
+            texts: Object.values(text_table).map((d) => {
+                const { lang_table, ...rest } = d;
+                return rest;
+            })
+        };
+        const mergePath = pathe_1.default.join(SI18n._dataDir, BaseFile);
+        await UtilFileTools_1.UtilFT.writeJSONFile(mergePath, tb);
+        //保存所有语言数据
+        const tbMap = {};
+        Object.values(text_table).forEach(d => {
+            if (d.invalid === true)
+                return;
+            SI18n._vaildLang?.forEach((vl) => {
+                const lf = vl;
+                tbMap[lf] ??= {
+                    base_lang: rest.base_lang,
+                    modify_time: date,
+                    target_lang: lf,
+                    translate_table: {}
+                };
+                const v = d.lang_table[lf];
+                tbMap[lf].translate_table[SI18n.formatI18nKey(d.original, d.mark)] = v ?? null;
+            });
+        });
+        await Promise.all(Object.values(tbMap).map(async (t) => {
+            const singlePath = pathe_1.default.join(SI18n._dataDir, LangDir, t.target_lang);
+            return await UtilFileTools_1.UtilFT.writeJSONFile(singlePath, t);
+        }));
+    }
+}
+exports.SI18n = SI18n;

package/dist/UtilInterfaces.d.ts

@@ -199,7 +199,7 @@ export type SchemaString = `${string}SchemaString`;
 /**需要初始化 */
 export type NeedInit = {
     /**完成初始化的标记 */
-    inited: Promise<void>;
+    inited: Promise<any>;
 };
 /**可选的record */
 export type PRecord<K extends Keyable, V> = Partial<Record<K, V>>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.136",
+	"version": "1.0.138",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {
@@ -36,6 +36,7 @@
 		"@zwa73/dev-utils": "^1.0.50",
 		"jest": "^29.7.0",
 		"ts-jest": "^29.1.2",
+		"ts-morph": "^23.0.0",
 		"tsc-alias": "^1.8.8",
 		"typescript": "^5.3.3"
 	}

package/src/UtilFileTools.ts

@@ -46,7 +46,7 @@ type LoadJsonFileOpt<T> = Partial<{
 
 /**json文件写入选项 */
 type WriteJsonFileOpt = Partial<{
-    /**使用紧凑风格 */
+    /**使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误 */
     compress:boolean;
     /**不自动修改扩展名为json */
     forceExt:boolean;
@@ -234,7 +234,7 @@ export async function loadJSONFile<T extends JToken>(filePath: string,opt?:LoadJ
  * @param filePath - 文件路径
  * @param token    - 所要写入的JToken
  * @param opt      - 可选参数
- * @param opt.compress - 使用紧凑风格
+ * @param opt.compress - 使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误
  * @param opt.forceExt - 不自动修改扩展名为json
  */
 export async function writeJSONFile(

package/src/UtilFunctions.ts

@@ -20,7 +20,7 @@ type ExecOpt = Partial<{
 
 /**序列化选项 */
 type StringifyOpt = Partial<{
-    /**使用紧凑风格 */
+    /**使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误 */
     compress:boolean;
     /**插入的空格 数字为空格数量 默认为制表符\t */
     space:string|number|null|undefined;
@@ -441,7 +441,7 @@ static mapEntries<T extends AnyRecord>
  * @param token - 待转换的Token
  * @param opt   - 可选参数
  * @param opt.space     - 插入的空格 数字为空格数量 默认为制表符\t
- * @param opt.compress  - 使用紧凑风格
+ * @param opt.compress  - 使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误
  * @returns 转换完成的字符串
  */
 static stringifyJToken(token:JToken|IJData,opt?:StringifyOpt){
@@ -464,8 +464,8 @@ static stringifyJToken(token:JToken|IJData,opt?:StringifyOpt){
     }
 
     return JSON.stringify(token,compressReplacer,space)
-        .replace(/"@@@(.*?)@@@"/g,`$1`)
-        .replace(/\\([\\"])/g, '$1');
+        .replace(/"@@@(.*?)@@@"/g, (match, p1) =>
+            p1.replace(/\\([\\"])/g, '$1'));
 }
 
 /**代办表 用于队列处理等待 */
@@ -822,7 +822,7 @@ static ivk<T extends ()=>any>(fn:T): ReturnType<T> {
  * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
  * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
  */
-static memoize<T extends (...args:JToken[])=>any> (fn: T, expiry = Infinity): T {
+static memoize<T extends (...args:UnionToIntersection<JToken>[])=>any> (fn: T, expiry = Infinity): T {
     const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(()=>{
         const c = new Map();
         UtilFunc.cachePool.set(fn, c);

package/src/UtilI18n.ts

@@ -0,0 +1,258 @@
+import { UtilFT } from "./UtilFileTools";
+import { UtilFunc } from "./UtilFunctions";
+import { PRecord } from "./UtilInterfaces";
+import { SLogger } from "./UtilLogger";
+import path from 'pathe';
+
+/**语言:地区 表 */
+const I18nFlagTable = {
+    "zh":["CN","TW"],
+    "en":["US"]
+} as const;
+
+/**语言标签 */
+export type LangFlag  = {
+    [P in keyof typeof I18nFlagTable]: `${P}-${typeof I18nFlagTable[P][number]}`
+}[keyof typeof I18nFlagTable]|keyof typeof I18nFlagTable;
+
+/**语言标签列表 */
+const LangFlagList = Object.entries(I18nFlagTable)
+    .map(([k,v])=>`${k}-${v}` as LangFlag)
+    .concat(Object.keys(I18nFlagTable) as LangFlag[]);
+
+
+
+/**源语言文本数据 */
+export type I18nOrigTextData = {
+    /**原文 */
+    original:string;
+    /**出现位置 */
+    position?:string;
+    /**特殊说明 */
+    desc?:string;
+    /**无效的 默认false */
+    invalid?:boolean;
+    /**特殊标记 */
+    mark?:string;
+    /**抓取时间戳 */
+    scan_time:string;
+    /**抓取方式 */
+    source:'Regex'|'Ast'|'Runtime'|'Manual'
+};
+/**I18n源语言数据 */
+export type I18nOrigTable = {
+    /**基础语言 */
+    base_lang:LangFlag;
+    texts:I18nOrigTextData[]
+}
+/**单语言I18N数据 */
+export type I18nSingleTable = {
+    /**基础语言 */
+    base_lang:LangFlag;
+    /**目标语言 */
+    target_lang:LangFlag;
+    /**更改时间戳 */
+    modify_time:string;
+    /**文本翻译表 */
+    translate_table:Record<string,string|null>;
+}
+
+
+/**处理过的i18n文本数据 */
+export type I18nTextData = I18nOrigTextData&{lang_table:PRecord<LangFlag,string>};
+/**处理过的I18n数据 */
+export type I18nTable = Omit<I18nOrigTable,'texts'>&{
+    text_table:Record<string,I18nTextData>;
+}
+
+
+const MarkRegex = /%%%([^%]+)%%%$/;
+const BaseFile = 'base_lang.json';
+const LangDir = 'lang';
+/**运行时I18n工具  
+ * 需先调用 init初始化
+ */
+export class SI18n {
+    private static _table?:I18nTable;
+    private static _lang?:LangFlag;
+    private static _dataDir?:string;
+    private static _vaildLang?:LangFlag[];
+    /**解析i18n索引 */
+    static parseI18nKey(i18nKey:string){
+        const match = i18nKey.match(/([\s\S]+?)(%%%[^%]+%%%)?$/)!;
+        const base = match[1];
+        const mark = match[2]==''||match[2]==undefined
+            ? undefined
+            : match[2].match(/^%%%([^%]+)%%%$/)![1];
+        return {base,mark};
+    }
+    /**格式化文本与mark为i18n索引key */
+    static formatI18nKey(str:string,mark?:string){
+        return str + (mark==undefined ? '' : SI18n.mark(mark));
+    }
+    /**特殊标记  
+     * 若添加在文本末尾则不会作为原文文本显示, 仅供索引
+     * @param mk - 特殊标记文本
+     */
+    static mark(mk:string):`%%%${string}%%%`{
+        return `%%%${mk}%%%`
+    }
+    /**初始化函数，加载国际化数据，设置语言，并在进程退出前保存数据。
+     * @param i18nDataDir - 国际化数据的路径。
+     * @param lang        - 要设置的语言。
+     */
+    static init(i18nDataDir:string,lang:LangFlag){
+        const date = new Date().toISOString();
+        const mergePath = path.join(i18nDataDir,BaseFile);
+        const table = UtilFT.loadJSONFileSync<I18nOrigTable>(mergePath,{default:{
+            base_lang:'zh-CN',
+            texts:[],
+        }});
+        const {texts,...rest} = table;
+        SI18n._table={
+            ...rest,
+            text_table:texts.reduce((acc, cur) =>
+                ({...acc,[SI18n.formatI18nKey(cur.original,cur.mark)]:{...cur,lang_table:{}}}),
+            {} as Record<string,I18nTextData>),
+        }
+        SI18n._vaildLang=[];
+        //覆盖入单语言文件
+        const singleDir = path.join(i18nDataDir,LangDir);
+        UtilFT.fileSearchGlobSync(singleDir,`**/${lang}*.json`)
+            .map(p=>UtilFT.loadJSONFileSync(p) as I18nSingleTable)
+            .forEach(t=>{
+                SI18n._vaildLang?.push(t.target_lang);
+                return Object.entries(t.translate_table)
+                    .forEach(([k,v])=>{
+                        if(v==null) return;
+                        const ttable = SI18n._table!.text_table;
+                        ttable[k] ??= {
+                            original:k,
+                            scan_time:date,
+                            source:'Runtime',
+                            lang_table:{}
+                        }
+                        const ltable = ttable[k].lang_table;
+                        ltable[t.target_lang] ??= v;
+                    })
+            });
+
+
+        if(!SI18n._vaildLang.includes(lang))
+            SI18n._vaildLang.push(lang);
+        SI18n._lang = lang;
+        SI18n._dataDir = i18nDataDir;
+    }
+    /**根据提供的字符串，返回对应的国际化字符串
+     * @param text - 字符串数组。
+     * @returns 对应的国际化字符串。
+     */
+    static t(text:string):string;
+    /**根据提供的模板字符串和值，返回对应的国际化字符串。
+     * @param strings - 模板字符串数组。
+     * @param values  - 值数组。
+     * @returns 对应的国际化字符串。
+     */
+    static t(strings:TemplateStringsArray,...values:any[]):string;
+    static t(strings:string|TemplateStringsArray,...values:any[]){
+        if(typeof strings =='string'){
+            const p = SI18n.parseI18nKey(strings);
+            return SI18n.getI18n(p.base.replace(/%/g,'\\%')+(p.mark==undefined?'':SI18n.mark(p.mark)), SI18n._lang!);
+        }
+        let i18nKey = ``;
+        const vakyeKeys = values.map((v,i)=>`%${i}`);
+        for (let i = 0; i < values.length; i++)
+            i18nKey += strings[i].replace(/%/g,'\\%') + vakyeKeys[i];
+        i18nKey += strings[strings.length - 1];
+
+        //检查是否为mark
+        if(MarkRegex.test(String(values[values.length-1])) && strings[strings.length - 1]=='')
+            i18nKey = i18nKey.replace(vakyeKeys[vakyeKeys.length - 1],'') + String(values[values.length-1]);
+        //console.log(1,i18nKey)
+        let trans = SI18n.getI18n(i18nKey, SI18n._lang!);
+        //console.log(2,trans)
+        vakyeKeys.forEach((k,i)=>trans = trans.replace(new RegExp(
+            `((?<!\\\\)${k})`
+        ),String(values[i])));
+        //console.log(3,trans)
+        return trans.replace(/\\%/g,'%');
+    }
+    /**根据提供的键和语言，返回对应的国际化字符串。
+     * 如果没有找到对应的字符串，将会抛出错误。
+     * @param key  - 要查找的键。
+     * @param lang - 要查找的语言。
+     * @returns 对应的国际化字符串。
+     */
+    static getI18n(key:string,lang:LangFlag){
+        if(SI18n._table==undefined) UtilFunc.throwError('SI18n 未初始化');
+        let obj = SI18n._table.text_table[key];
+        if(obj==undefined){
+            SLogger.warn(`SI18n 未在 ${SI18n._dataDir} 找到 ${key} 对应的数据, 已自动添加`);
+            const p = SI18n.parseI18nKey(key);
+            SI18n._table.text_table[key] = {
+                original:p.base,
+                scan_time:new Date().toISOString(),
+                lang_table:{},
+                mark:p.mark,
+                source:'Runtime'
+            }
+            obj = SI18n._table.text_table[key];
+        }
+        if(obj.invalid===true) return obj.original;
+        return SI18n.tryAndRollback(lang,obj);
+    }
+    /**尝试获取指定语言的翻译，如果没有找到，将回滚到其他可用的语言。
+     * @param lang - 要查找的语言。
+     * @param dat  - 包含翻译的数据对象。
+     * @returns 找到的翻译，如果没有找到，将返回原始字符串。
+     */
+    static tryAndRollback(lang:LangFlag,dat:I18nTable['text_table'][string]){
+        const langTable:PRecord<LangFlag,string> = {
+            [SI18n._table!.base_lang]:dat.original,
+            ...dat.lang_table
+        };
+        if(langTable[lang]!=undefined) return langTable[lang]!;
+        const l1 = lang.match(/^([^-]+)/)![1];
+        const rb = Object.entries(langTable).find(([k,v])=>k.includes(l1));
+        if(rb) return rb[1];
+        return dat.original;
+    }
+    /**保存数据 */
+    static async saveTable(){
+        const {text_table,...rest} = SI18n._table!;
+        const date = new Date().toISOString();
+        //console.log(text_table)
+
+        //保存原始文本数据
+        const tb:I18nOrigTable = {
+            ...rest,
+            texts:Object.values(text_table).map((d)=>{
+                const {lang_table,...rest} = d;
+                return rest;
+            })
+        }
+        const mergePath = path.join(SI18n._dataDir!,BaseFile);
+        await UtilFT.writeJSONFile(mergePath,tb);
+
+        //保存所有语言数据
+        const tbMap:PRecord<LangFlag,I18nSingleTable> = {};
+        Object.values(text_table).forEach(d=>{
+            if(d.invalid===true) return;
+            SI18n._vaildLang?.forEach((vl)=>{
+                const lf = vl as LangFlag;
+                tbMap[lf] ??={
+                    base_lang:rest.base_lang,
+                    modify_time:date,
+                    target_lang:lf,
+                    translate_table:{}
+                }
+                const v = d.lang_table[lf];
+                tbMap[lf]!.translate_table[SI18n.formatI18nKey(d.original,d.mark)] = v ?? null;
+            })
+        });
+        await Promise.all(Object.values(tbMap).map(async (t)=>{
+            const singlePath = path.join(SI18n._dataDir!,LangDir,t.target_lang);
+            return await UtilFT.writeJSONFile(singlePath,t);
+        }))
+    }
+}

package/src/UtilInterfaces.ts

@@ -289,7 +289,7 @@ export type SchemaString = `${string}SchemaString`;
 /**需要初始化 */
 export type NeedInit = {
     /**完成初始化的标记 */
-    inited: Promise<void>;
+    inited: Promise<any>;
 };
 
 /**可选的record */