@zwa73/dev-utils 1.0.53 → 1.0.55

package/dist/Command/GenI18n.js

@@ -7,30 +7,35 @@ exports.CmdGenI18n = void 0;
 const utils_1 = require("@zwa73/utils");
 const ts_morph_1 = require("ts-morph");
 const UtilAst_1 = require("../UtilAst");
-const fs_1 = __importDefault(require("fs"));
 const pathe_1 = __importDefault(require("pathe"));
-async function procFile(p, filePath) {
+function format(str) {
+    return str.replace(/\\(.)/g, '$1').replace(/%/g, '\\%');
+}
+async function procFile(p, filePath, funckey) {
     const date = new Date().toISOString();
-    const content = await fs_1.default.promises.readFile(filePath, 'utf-8');
-    const b = p.createSourceFile(pathe_1.default.relative(process.cwd(), filePath), content);
+    //const content = await fs.promises.readFile(filePath,'utf-8');
+    const b = p.addSourceFileAtPath(filePath);
+    //const b = p.createSourceFile(path.relative(process.cwd(),filePath),content,{overwrite:true});
     const ds = b.getDescendantsOfKind(ts_morph_1.SyntaxKind.TaggedTemplateExpression);
     const dats = [];
     for (const d of ds) {
+        if (!funckey.includes(d.getTag().getText()))
+            continue;
         const template = d.getTemplate();
         let result = '';
         let i = 0;
         UtilAst_1.UtilAst.withKind(template, {
-            [ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral]: (t) => result += t.getLiteralText(),
+            [ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral]: (t) => result += format(t.getLiteralText()),
             [ts_morph_1.SyntaxKind.TemplateExpression]: (t) => {
                 t.getChildren().forEach((c) => {
                     UtilAst_1.UtilAst.withKind(c, {
-                        [ts_morph_1.SyntaxKind.TemplateHead]: (sc) => result += sc.getLiteralText(),
+                        [ts_morph_1.SyntaxKind.TemplateHead]: (sc) => result += format(sc.getLiteralText()),
                         [ts_morph_1.SyntaxKind.SyntaxList]: (sc) => {
                             sc.getChildrenOfKind(ts_morph_1.SyntaxKind.TemplateSpan).forEach((span) => {
                                 span.getChildren().forEach((ssc) => {
                                     result += UtilAst_1.UtilAst.withKind(ssc, {
-                                        [ts_morph_1.SyntaxKind.TemplateMiddle]: (sssc) => sssc.getLiteralText(),
-                                        [ts_morph_1.SyntaxKind.TemplateTail]: (sssc) => sssc.getLiteralText(),
+                                        [ts_morph_1.SyntaxKind.TemplateMiddle]: (sssc) => format(sssc.getLiteralText()),
+                                        [ts_morph_1.SyntaxKind.TemplateTail]: (sssc) => format(sssc.getLiteralText()),
                                     }) ?? String(`%${i++}`);
                                 });
                             });
@@ -51,12 +56,14 @@ async function procFile(p, filePath) {
     }
     return dats;
 }
-async function scanI18n(i18nDataDir, include, exclude) {
+async function scanI18n(i18nDataDir, include, exclude, funckey) {
+    const fixedKey = typeof funckey == 'string' ? [funckey] : funckey;
     const filePaths = (await utils_1.UtilFT.fileSearchGlob(process.cwd(), include, { ingore: exclude }))
         .filter(p => ['.ts', '.tsx'].includes(pathe_1.default.parse(p).ext));
     const project = new ts_morph_1.Project();
     await utils_1.SI18n.init(i18nDataDir, '*');
-    (await Promise.all(filePaths.map(p => procFile(project, p))))
+    //console.log(filePaths);
+    (await Promise.all(filePaths.map(p => procFile(project, p, fixedKey))))
         .flat().forEach(dat => utils_1.SI18n.addOriginalText(dat));
     await utils_1.SI18n.saveTable();
 }
@@ -65,10 +72,23 @@ const CmdGenI18n = (program) => program
     .command("Gen-I18n")
     .alias("geni18n")
     .description("根据文件行为树生成i18n数据")
-    .option("-o, --output <path>", "输出的数据目录位置")
-    .option("-i, --include <glob>", "包含的glob 默认 src/**/*.macro.ts", "src/**/*.macro.ts")
+    .option("-o, --output <path>", "输出的数据目录位置 默认 i18n", 'i18n')
+    .option("-i, --include <glob>", "包含的glob 默认 src/**/*.ts", "src/**/*.ts")
     .option("-g, --exclude <glob>", "忽略的glob")
+    .option("-f, --funckey <string|string[]>", "扫描的目标函数名, 默认 t", (i) => {
+    const v = (0, utils_1.ivk)(() => {
+        try {
+            return JSON.parse(i);
+        }
+        catch (e) {
+            return undefined;
+        }
+    });
+    if (Array.isArray(v))
+        return v;
+    return i;
+}, 't')
     .action(async (opt) => {
-    await scanI18n(opt.output, opt.include, opt.exclude);
+    await scanI18n(opt.output, opt.include, opt.exclude, opt.funckey);
 });
 exports.CmdGenI18n = CmdGenI18n;

package/dist/Command/GenSchema.js

@@ -10,13 +10,15 @@ const CmdGenSchema = (program) => program
     .option("-i, --include <glob>", "包含的glob 默认 src/**/*.schema.ts", "src/**/*.schema.ts")
     .option("-g, --exclude <glob>", "忽略的glob")
     .option("-p, --project <path>", "tsconfig路径 默认tsconfig.json", "tsconfig.json")
-    .option("-o, --out-dir <dir>", "schema输出路径目录 默认 ./schema/")
+    .option("-o, --out <dir>", "schema输出路径目录 默认 ./schema/")
+    .option("-t, --type <string>", "若传入则仅输出 type 对应的类型 此时将直接输出至outDir/type.json, 且不会展开")
     .action(async (opt) => {
     await UtilDevTool_1.UtilDT.generateSchema(process.cwd(), {
         include: opt.include,
         exclude: opt.exclude,
         project: opt.project,
         outDir: opt.outDir,
+        typeName: opt.type
     });
 });
 exports.CmdGenSchema = CmdGenSchema;

package/dist/UtilDevTool.d.ts

@@ -18,6 +18,8 @@ export declare namespace UtilDT {
         coverDefine: JObject;
         /**schema输出路径目录 如 ./schema/ */
         outDir: string;
+        /**若传入则仅输出 typeName 对应的类型 此时将直接输出至outDir/typeName.json, 且不会展开 */
+        typeName?: string;
     }> & BuildMatchOpt;
     /**生成匹配的文件的所有type的schema
      * @async
@@ -28,6 +30,7 @@ export declare namespace UtilDT {
      * @param opt.coverDefine - 将会覆盖 definitions 对应内容的表
      * @param opt.project     - tsconfig路径
      * @param opt.outDir      - schema输出路径目录 默认 ./schema/
+     * @param opt.typeName    - 若传入则仅输出 typeName 对应的类型 此时将直接输出至outDir/typeName.json, 且不会展开
      */
     export function generateSchema(dir: string, opt?: BuildSchemaOpt): Promise<void>;
     /**运行所有匹配的的js/ts文件

package/dist/UtilDevTool.js

@@ -42,6 +42,7 @@ var UtilDT;
      * @param opt.coverDefine - 将会覆盖 definitions 对应内容的表
      * @param opt.project     - tsconfig路径
      * @param opt.outDir      - schema输出路径目录 默认 ./schema/
+     * @param opt.typeName    - 若传入则仅输出 typeName 对应的类型 此时将直接输出至outDir/typeName.json, 且不会展开
      */
     async function generateSchema(dir, opt) {
         //生成
@@ -49,6 +50,7 @@ var UtilDT;
             required: true,
             aliasRef: true,
             tsNodeRegister: true,
+            ignoreErrors: true,
         };
         const compilerOptions = {
             strictNullChecks: true,
@@ -57,21 +59,30 @@ var UtilDT;
             Object.assign(compilerOptions, (await utils_1.UtilFT.loadJSONFile(opt.project)).compilerOptions);
         const files = await utils_1.UtilFT.fileSearchGlob(dir, opt?.include ?? "**/*.schema.ts", { ingore: opt?.exclude });
         const program = TJS.getProgramFromFiles(files, compilerOptions);
-        const schema = TJS.generateSchema(program, "*", settings);
+        const schema = TJS.generateSchema(program, opt?.typeName ?? "*", settings);
         const outDir = opt?.outDir ?? pathe_1.default.join(process.cwd(), 'schema');
-        const schemasPath = pathe_1.default.join(outDir, 'schemas.json');
-        //进行预处理并展开
-        await expandSchema(schemasPath, schema, opt?.coverDefine ?? {});
+        const schemasPath = opt?.typeName != undefined
+            ? pathe_1.default.join(outDir, `${opt.typeName}.json`)
+            : pathe_1.default.join(outDir, 'schemas.json');
+        //预处理
+        const proced = procSchema(schema, opt?.coverDefine ?? {});
+        await Promise.all([
+            utils_1.UtilFT.writeJSONFile(schemasPath, schema),
+            //全范围类型则展开
+            opt?.typeName != undefined ? undefined : expandSchema(proced, schemasPath),
+        ]);
     }
     UtilDT.generateSchema = generateSchema;
-    /**展开schema以供使用 */
-    async function expandSchema(schemasPath, schema, coverDefine) {
+    function procSchema(schema, coverDefine) {
         //覆盖
         coverObj(schema["definitions"], coverDefine);
         //替换SchemaString标识符
         schema = JSON.parse(JSON.stringify(schema).replace(/\^\.\*SchemaString\$/g, '^.*$'));
+        return schema;
+    }
+    /**展开schema以供使用 */
+    async function expandSchema(schema, schemasPath) {
         const plist = [];
-        plist.push(utils_1.UtilFT.writeJSONFile(schemasPath, schema));
         const definitions = schema["definitions"];
         //展开定义
         for (const typeName in definitions) {

package/i18n/base_lang.json

@@ -0,0 +1,23 @@
+{
+	"base_lang": "zh-CN",
+	"texts": [
+		{
+			"original": "你好？%0，吗？",
+			"scan_time": "2024-07-22T04:08:33.552Z",
+			"position": "F:/Sosarciel/SosarcielCore/NodeJs/dev-utils/jest/UtilI18n/test.ts:6:13",
+			"source": "Ast"
+		},
+		{
+			"original": "abcdefg %0rst",
+			"scan_time": "2024-07-22T04:08:33.552Z",
+			"position": "F:/Sosarciel/SosarcielCore/NodeJs/dev-utils/jest/UtilI18n/test.ts:7:13",
+			"source": "Ast"
+		},
+		{
+			"original": "higklmn%0",
+			"scan_time": "2024-07-22T04:08:33.552Z",
+			"position": "F:/Sosarciel/SosarcielCore/NodeJs/dev-utils/jest/UtilI18n/test.ts:7:25",
+			"source": "Ast"
+		}
+	]
+}

package/i18n/lang/en.json

@@ -0,0 +1,10 @@
+{
+	"base_lang": "zh-CN",
+	"modify_time": "2024-07-22T04:08:33.570Z",
+	"target_lang": "en",
+	"translate_table": {
+		"你好？%0，吗？": "hello? %0 \\%0",
+		"abcdefg %0rst": "ABCDEFG %0RST",
+		"higklmn%0": "HIJKLMN%0"
+	}
+}

package/i18n/template.json

@@ -0,0 +1,10 @@
+{
+	"base_lang": "zh-CN",
+	"modify_time": "2024-07-22T04:08:33.570Z",
+	"target_lang": "template",
+	"translate_table": {
+		"你好？%0，吗？": null,
+		"abcdefg %0rst": null,
+		"higklmn%0": null
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/dev-utils",
-	"version": "1.0.53",
+	"version": "1.0.55",
 	"description": "编译与调试工具",
 	"main": "index.js",
 	"scripts": {
@@ -16,7 +16,7 @@
 	"author": "zwa73",
 	"license": "ISC",
 	"dependencies": {
-		"@zwa73/utils": "^1.0.143",
+		"@zwa73/utils": "^1.0.144",
 		"commander": "^11.1.0",
 		"pathe": "^1.1.2",
 		"ts-morph": "^23.0.0",

package/src/Command/GenI18n.ts

@@ -1,32 +1,37 @@
 import { Command } from "commander";
-import { I18nTextData, SI18n, UtilFT } from "@zwa73/utils";
-import { Project,SourceFile,SyntaxKind } from 'ts-morph';
+import { AnyFunc, I18nTextData, SI18n, UtilFT, ivk } from "@zwa73/utils";
+import { Project,SyntaxKind } from 'ts-morph';
 import { UtilAst } from "@src/UtilAst";
-import fs from 'fs';
 import path from 'pathe';
 
-async function procFile(p:Project,filePath:string){
+function format(str:string){
+    return str.replace(/\\(.)/g,'$1').replace(/%/g,'\\%');
+}
+
+async function procFile(p:Project,filePath:string,funckey:string[]){
     const date = new Date().toISOString();
-    const content = await fs.promises.readFile(filePath,'utf-8');
-    const b = p.createSourceFile(path.relative(process.cwd(),filePath),content);
+    //const content = await fs.promises.readFile(filePath,'utf-8');
+    const b = p.addSourceFileAtPath(filePath);
+    //const b = p.createSourceFile(path.relative(process.cwd(),filePath),content,{overwrite:true});
     const ds = b.getDescendantsOfKind(SyntaxKind.TaggedTemplateExpression);
     const dats:I18nTextData[] = [];
     for(const d of ds){
+        if(!funckey.includes(d.getTag().getText())) continue;
         const template = d.getTemplate();
         let result = '';
         let i=0;
         UtilAst.withKind(template,{
-            [SyntaxKind.NoSubstitutionTemplateLiteral]:(t)=>result+=t.getLiteralText(),
+            [SyntaxKind.NoSubstitutionTemplateLiteral]:(t)=>result+=format(t.getLiteralText()),
             [SyntaxKind.TemplateExpression]:(t)=>{
                 t.getChildren().forEach((c)=>{
                     UtilAst.withKind(c,{
-                        [SyntaxKind.TemplateHead]:(sc)=>result += sc.getLiteralText(),
+                        [SyntaxKind.TemplateHead]:(sc)=>result += format(sc.getLiteralText()),
                         [SyntaxKind.SyntaxList]:(sc)=>{
                             sc.getChildrenOfKind(SyntaxKind.TemplateSpan).forEach((span)=>{
                                 span.getChildren().forEach((ssc)=>{
                                     result += UtilAst.withKind(ssc,{
-                                        [SyntaxKind.TemplateMiddle]:(sssc)=>sssc.getLiteralText(),
-                                        [SyntaxKind.TemplateTail]  :(sssc)=>sssc.getLiteralText(),
+                                        [SyntaxKind.TemplateMiddle]:(sssc)=>format(sssc.getLiteralText()),
+                                        [SyntaxKind.TemplateTail]  :(sssc)=>format(sssc.getLiteralText()),
                                     })??String(`%${i++}`);
                                 })
                             })
@@ -48,12 +53,14 @@ async function procFile(p:Project,filePath:string){
     return dats;
 }
 
-async function scanI18n(i18nDataDir:string,include:string,exclude:string){
+async function scanI18n(i18nDataDir:string,include:string,exclude:string,funckey:string[]|string){
+    const fixedKey = typeof funckey == 'string' ? [funckey] : funckey;
     const filePaths = (await UtilFT.fileSearchGlob(process.cwd(),include,{ingore:exclude}))
         .filter(p=>['.ts','.tsx'].includes(path.parse(p).ext));
     const project = new Project();
     await SI18n.init(i18nDataDir,'*');
-    (await Promise.all(filePaths.map(p=>procFile(project,p))))
+    //console.log(filePaths);
+    (await Promise.all(filePaths.map(p=>procFile(project,p,fixedKey))))
         .flat().forEach(dat=>SI18n.addOriginalText(dat));
     await SI18n.saveTable();
 }
@@ -63,13 +70,25 @@ export const CmdGenI18n = (program:Command) => program
     .command("Gen-I18n")
     .alias("geni18n")
     .description("根据文件行为树生成i18n数据")
-    .option("-o, --output <path>" , "输出的数据目录位置")
-    .option("-i, --include <glob>", "包含的glob 默认 src/**/*.macro.ts","src/**/*.macro.ts")
+    .option("-o, --output <path>" , "输出的数据目录位置 默认 i18n",'i18n')
+    .option("-i, --include <glob>", "包含的glob 默认 src/**/*.ts","src/**/*.ts")
     .option("-g, --exclude <glob>", "忽略的glob")
+    .option("-f, --funckey <string|string[]>", "扫描的目标函数名, 默认 t",(i:string)=>{
+        const v = ivk(()=>{
+            try{
+                return JSON.parse(i);
+            } catch(e){
+                return undefined;
+            }
+        })
+        if(Array.isArray(v)) return v;
+        return i;
+    },'t')
     .action(async (opt) => {
         await scanI18n(
-            opt.output,
+            opt.output ,
             opt.include,
             opt.exclude,
+            opt.funckey,
         );
     });

package/src/Command/GenSchema.ts

@@ -9,12 +9,14 @@ export const CmdGenSchema = (program:Command) => program
     .option("-i, --include <glob>", "包含的glob 默认 src/**/*.schema.ts","src/**/*.schema.ts")
     .option("-g, --exclude <glob>", "忽略的glob")
     .option("-p, --project <path>", "tsconfig路径 默认tsconfig.json","tsconfig.json")
-    .option("-o, --out-dir <dir>" , "schema输出路径目录 默认 ./schema/")
+    .option("-o, --out <dir>", "schema输出路径目录 默认 ./schema/")
+    .option("-t, --type <string>", "若传入则仅输出 type 对应的类型 此时将直接输出至outDir/type.json, 且不会展开")
     .action(async (opt) => {
         await UtilDT.generateSchema(process.cwd(), {
-            include: opt.include,
-            exclude: opt.exclude,
-            project: opt.project,
-            outDir: opt.outDir,
+            include : opt.include,
+            exclude : opt.exclude,
+            project : opt.project,
+            outDir  : opt.outDir,
+            typeName: opt.type
         });
     });

package/src/UtilDevTool.ts

@@ -25,6 +25,8 @@ type BuildSchemaOpt = Partial<{
     coverDefine:JObject;
     /**schema输出路径目录 如 ./schema/ */
     outDir:string;
+    /**若传入则仅输出 typeName 对应的类型 此时将直接输出至outDir/typeName.json, 且不会展开 */
+    typeName?:string;
 }>&BuildMatchOpt;
 
 
@@ -38,6 +40,7 @@ type BuildSchemaOpt = Partial<{
  * @param opt.coverDefine - 将会覆盖 definitions 对应内容的表
  * @param opt.project     - tsconfig路径
  * @param opt.outDir      - schema输出路径目录 默认 ./schema/
+ * @param opt.typeName    - 若传入则仅输出 typeName 对应的类型 此时将直接输出至outDir/typeName.json, 且不会展开
  */
 export async function generateSchema(dir:string,opt?:BuildSchemaOpt){
     //生成
@@ -45,6 +48,7 @@ export async function generateSchema(dir:string,opt?:BuildSchemaOpt){
         required: true,
         aliasRef:true,
         tsNodeRegister:true,
+        ignoreErrors:true,
     };
     const compilerOptions: TJS.CompilerOptions = {
         strictNullChecks: true,
@@ -56,21 +60,29 @@ export async function generateSchema(dir:string,opt?:BuildSchemaOpt){
         files,
         compilerOptions,
     );
-    const schema = TJS.generateSchema(program, "*", settings) as JObject;
+    const schema = TJS.generateSchema(program, opt?.typeName??"*", settings) as JObject;
     const outDir = opt?.outDir ?? path.join(process.cwd(),'schema');
-    const schemasPath = path.join(outDir,'schemas.json');
-    //进行预处理并展开
-    await expandSchema(schemasPath,schema,opt?.coverDefine??{});
+    const schemasPath = opt?.typeName !=undefined
+        ? path.join(outDir,`${opt.typeName}.json`)
+        : path.join(outDir,'schemas.json');
+    //预处理
+    const proced = procSchema(schema,opt?.coverDefine??{});
+    await Promise.all([
+        UtilFT.writeJSONFile(schemasPath,schema),
+        //全范围类型则展开
+        opt?.typeName !=undefined ? undefined : expandSchema(proced,schemasPath),
+    ]);
 }
-/**展开schema以供使用 */
-async function expandSchema(schemasPath:string,schema:JObject,coverDefine:JObject){
+function procSchema(schema:JObject,coverDefine:JObject){
     //覆盖
     coverObj(schema["definitions"] as JObject,coverDefine);
     //替换SchemaString标识符
     schema = JSON.parse(JSON.stringify(schema).replace(/\^\.\*SchemaString\$/g,'^.*$'));
+    return schema;
+}
+/**展开schema以供使用 */
+async function expandSchema(schema:JObject,schemasPath:string){
     const plist:Promise<void>[] = [];
-    plist.push(UtilFT.writeJSONFile(schemasPath,schema));
-
     const definitions = schema["definitions"] as Record<string,JObject>;
     //展开定义
     for(const typeName in definitions){