@zwa73/utils 1.0.202 → 1.0.204

package/src/UtilI18n.ts

@@ -1,278 +0,0 @@
-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 parseLangFlag = (lf:LangFlag|'*')=>{
-    const match = lf.match(/^([^-]+)(.+)/)!
-    return {1:match[1],2:match[2]!='' ? match[2]:undefined};
-}
-
-const MarkRegex = /%([^%]+)%$/;
-const BaseFile = 'base_lang.json';
-const TemplateFile = 'template.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|'template')[];
-    /**解析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 async init(i18nDataDir:string,lang:LangFlag|'*'='*'){
-        const date = new Date().toISOString();
-        const mergePath = path.join(i18nDataDir,BaseFile);
-        const table = await UtilFT.loadJSONFile<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=['template'];
-        //覆盖入单语言文件
-        const singleDir = path.join(i18nDataDir,LangDir);
-        (await Promise.all((await UtilFT.fileSearchGlob(singleDir,`**/${parseLangFlag(lang)[1]}*.json`))
-            .map(async p=>await UtilFT.loadJSONFile(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(lang!=undefined && lang!='*' && !SI18n._vaildLang.includes(lang))
-            SI18n._vaildLang.push(lang);
-
-        SI18n._lang = lang=="*" ? undefined : lang;
-        SI18n._dataDir = i18nDataDir;
-    }
-    /**根据提供的字符串，返回对应的国际化字符串
-     * @param text    - 字符串数组
-     * @param markStr - 特殊标记文本
-     * @returns 对应的国际化字符串。
-     * @example
-     * t(`你好${v0}, ${v1}`,'hello3');
-     */
-    static t(text:string,markStr:string):string;
-    /**根据提供的模板字符串和值，返回对应的国际化字符串。
-     * @param strings - 模板字符串数组。
-     * @param values  - 值数组。
-     * @returns 对应的国际化字符串。
-     * @example
-     * t`你好${v0}, ${v1}${SI18n.mark('hello2')}`
-     */
-    static t(strings:TemplateStringsArray,...values:any[]):string;
-    static t(strings:string|TemplateStringsArray,...values:any[]){
-        if(typeof strings =='string'){
-            const mark = values.length>=1 ? SI18n.mark(values[0]) : '';
-            return SI18n.getI18n(strings.replace(/%/g,'\\%')+mark, SI18n._lang!)
-                        .replace(/\\%/g,'%');
-        }
-        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);
-            obj = SI18n.addOriginalText({
-                original:p.base,
-                scan_time:new Date().toISOString(),
-                lang_table:{},
-                mark:p.mark,
-                source:'Runtime'
-            });
-        }
-        if(lang==undefined) return obj.original;
-        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 addOriginalText(dat:I18nTextData){
-        const key = SI18n.formatI18nKey(dat.original,dat.mark);
-        SI18n._table!.text_table[key] = dat;
-        return SI18n._table!.text_table[key];
-    }
-    /**保存数据 */
-    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)=>{
-            if(t.target_lang == 'template' as LangFlag){
-                const tmppath = path.join(SI18n._dataDir!,TemplateFile);
-                return await UtilFT.writeJSONFile(tmppath,t);
-            }
-            const singlePath = path.join(SI18n._dataDir!,LangDir,t.target_lang);
-            return await UtilFT.writeJSONFile(singlePath,t);
-        }))
-    }
-}

package/src/UtilInterfaces.ts

@@ -1,264 +0,0 @@
-import { Failed, Success, Terminated } from "./UtilSymbol";
-
-
-/**可以序列化为JSON文件的对象 */
-export type JToken = JObject|JArray|JValue|IJData;
-/**在stringify输出时 undefine 会被转为 null */
-export type JValue = number|string|boolean|null|undefined;
-/**在stringify输出时 值为 undefine 的成员会被转为 null */
-export type JArray = Array<JToken>;
-/**在stringify输出时 值为 undefine 的键会被忽略 */
-export type JObject = {
-    [key:string]:JToken;
-}
-/**可以保存为JToken的类 */
-export interface IJData{
-	/**保存为JToken
-	 */
-	toJSON():JToken;
-}
-/**任何可能有ReturnType的函数 */
-export type AnyFunc = (...args:any)=>any;
-
-/**任意可作为键值的类型 */
-export type Keyable = string | number | symbol;
-
-/**排除可选项目  
- * 将基础类型中与默认选项重合的部分变为可选  
- * @template B - 基础类型
- * @template D - 默认选项
- */
-export type PartialOption<B,D> = keyof D extends keyof B
-    ? Omit<B,keyof D> & Partial<Pick<B,keyof D>>
-    : never;
-
-/**真子集 测试 T 是否为 B 的真子集
- * @template B - 超集
- * @template T - 子集
- */
-export type ProperSubset<B, T> = T extends B ? B extends T ? never : T : never;
-/**真子集检查 测试 T 是否为 B 的真子集
- * 相等时返回   'E'
- * 真子集时返回 'P'
- * 不相交时返回 'N'
- * @template B - 超集
- * @template T - 子集
- */
-export type ProperSubsetCheck<B, T> = T extends B ? B extends T ? "E" : "P" : "N";
-
-/**字面量 检查 L 是否为字面量
- * @template L - 目标量
- */
-export type Literal<L> =
-    ProperSubset<string , L> |
-    ProperSubset<number , L> |
-    ProperSubset<boolean, L> |
-    ProperSubset<symbol , L> |
-    ProperSubset<any[]  , L> |
-    ProperSubset<Record<any,any>, L> |
-    Extract<L, null | undefined>;
-
-/**字面量检查 测试 L 是否为字面量
- * 是字面量时返回   true
- * 不是字面量时返回 false
- * @template L - 目标量
- */
-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;
-
-/**递归判断元组 List 每个元素是否 extends T */
-export type AllExtends<List extends any[], T> =
-    List extends [infer First, ...infer Rest]
-        ? First extends T
-            ? AllExtends<Rest,T>
-            : false
-        : true;
-
-
-/**返回将Mixin分配给Base的结果,相同字段时Mixin覆盖Base */
-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;
-}
-
-/**转为可写的 */
-export type Writeable<T> = {
-	-readonly [P in keyof T]: T[P]
-};
-/**翻转K和V */
-export type Inverted<T extends Record<keyof T, string | number | symbol>> = {
-    [K in keyof T as T[K]]: K;
-};
-/**N长度 T类型的元组  */
-export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> =
-    R['length'] extends N ? R : FixedLengthTuple<T, N, [T, ...R]>;
-
-
-/**不影响智能补全的任意字符串
- * (string&Object)
- * (string&String)
- */
-export type AnyString = (string&{});
-
-/**联合类型转为交叉类型  
- * 利用分布式条件将U展开为联合函数(k:U1)=>void | (k:U2)=>void  
- * 再从中提取可以传递给任意联合函数的类型  
- */
-export type UnionToIntersection<U> =
-    (U extends any
-        ? (k: U)=>void
-        : never) extends ((k: infer I)=>void)
-            ? I
-            : never
-
-/**创建一个新的类型，这个新的类型包含了基础类型 B 的所有属性，
- * 以及一个名为 K[N] 类型为 T 的新属性。
- * 所有 K 中非 K[N] 的其他属性都是可选的并且不能被赋值（因为它们的类型是 never）。
- */
-type ExclusiveSub<B, T, K extends string[], N extends number> =
-    B & { [P in K[N]]: T } & { [P in Exclude<K[number], K[N]>]?: never };
-
-/**递归地创建一个元组类型, 所有成员类型都有一个 K[number] 键 并且与其他成员互斥
- * 这个元组类型的每个元素都是通过 ExclusiveSub 类型创建的。
- */
-type ExclusiveRecursive<B, T, K extends string[], R extends unknown[] = []> =
-    R['length'] extends K['length'] ? R
-    : ExclusiveRecursive<B, T, K, [ExclusiveSub<B, T, K, R['length']>, ...R]>;
-
-/**互斥表
- * 从 ExclusiveRecursive 类型创建的元组中创建一个或类型, 可以是任意一个元组元素类型
- */
-export type ExclusiveRecord<B, T, K extends string[], TMP = ExclusiveRecursive<B, T, K>> = TMP[keyof TMP];
-
-/**符合JObject约束的互斥表 */
-export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string[],
-    TMP extends JArray = ExclusiveRecursive<B,T,K>> = TMP[number];
-
-
-/**Promise完成状态 成功/失败/终止  
- * 成功 将直接返回 结果  
- * 终止 将直接返回 结果  
- * 失败 将重试  
- */
-export type PromiseStatus = Success|Failed|Terminated;
-/**状态验证函数 */
-export type StatusVerifyFn<T> = (obj:T)=>Promise<PromiseStatus>|PromiseStatus;
-
-/**获取Promise的结果类型 如同await那样
- * @deprecated 请使用官方的 Awaited<T> 类型
- */
-export type Await<T> = T extends Promise<infer U> ? U : T;
-
-
-/**类型中任意函数的字符串名称 */
-export type FuncPropNames<T> = {
-    [K in keyof T]: T[K] extends AnyFunc ? K : never;
-}[keyof T];
-
-/** extends封装  
- * @template B - 基础类型
- * @template T - 判断的目标类型
- * @template Y - 如果为真的返回值
- * @template N - 如果为假的返回值
- */
-export type ExtendThen<B,T,Y,N = never> = B extends T ? Y : N;
-/** 一个联合类型 B 中如果包含 联合类型 T 中的任意项  
- * 无效  
- * @template B - 基础类型
- * @template T - 判断的目标类型
- * @template Y - 如果为真的返回值
- * @template N - 如果为假的返回值
- */
-type UnionInclude<B,T,Y,N = never> =
-    B extends Exclude<B,T>
-        ? N : Y
-/**排除可选字段 */
-export type RequiredOnly<T> = {
-    [K in keyof T as
-        T[K] extends Exclude<T[K],undefined>
-            ? K
-            : never
-    ]: T[K]
-};
-/**添加前缀 */
-export type WithPrefix<T,P extends string> = {
-    [K in (keyof T) as
-        K extends string
-            ? `${P}${K}`
-            : K
-    ]: T[K]
-};
-
-/**附带状态的返回结果用于状态返回值的封装  
- * @template K - 类型键值
- * @template V - 值
- */
-export type Outcome<K extends Keyable,V> = {
-    /**状态类型 */
-    readonly status:K;
-    /**值 */
-    readonly result:V;
-}
-/**可进行匹配的对象  
- * 如果是Outcome则自动处理status  
- */
-export type Matchable<T extends Keyable> = T|Outcome<T,unknown>;
-/**可进行匹配的 outcome或symbol 中的状态类型 */
-export type MatchableFlag<T> =
-    T extends infer O|Outcome<infer O,unknown>
-        ? O : never;
-
-/**从联合 Outcome 中 根据 K 提取对应 Outcome
- * @template T - 联合Outcome匹配的类型
- * @template K - 所需的状态
-*/
-export type ExtractOutcome<T,K extends Keyable> =
-    T extends Outcome<infer O,unknown>
-        ? O extends Exclude<O,K>
-            ? never : T
-        : never;
-
-/**用于辅助解析智能补全的类型  
- * 输出schema后替换为 ^.*$ 的 string 匹配  
- */
-export type SchemaString = `${string}SchemaString`;
-
-/**需要初始化 */
-export type NeedInit = {
-    /**完成初始化的标记 */
-    inited: Promise<any>;
-};
-
-/**可选的record PartialRecord */
-export type PRecord<K extends Keyable,V> = Partial<Record<K,V>>;
-/** 可以是Promise MaybePromise*/
-export type MPromise<T> = T | Promise<T>;
-/**任何Record */
-export type AnyRecord = Record<Keyable,any>;
-
-/**注释元组
- * @template T - 提供注释的类型, 索引需从0开始
- */
-export type CmtTuple<T extends {[K:number]:unknown},Tuple extends unknown[]=[]> =
-    unknown extends T[Tuple['length']]
-        ? T & Tuple
-        : CmtTuple<T,[...Tuple,T[Tuple['length']]]>;
-
-/**非严格模式下将会判断为false的值, 不包含NaN */
-export type Flasy = false | 0 | -0 | "" | null | undefined;
-
-
-/**srt段 */
-export type SrtSegment = {
-    /**开始时间, 以毫秒为单位 */
-    start: number;
-    /**结束时间, 以毫秒为单位 */
-    end  : number;
-    /**字幕文本 */
-    text : string;
-};