maishu-scripts 1.4.0 → 1.4.2

package/out/modules/actions/babel-compile.d.ts

@@ -1,3 +1,3 @@
 import * as babel from "@babel/core";
-import { FileAction } from "../../types";
-export declare function create(babelOptions?: babel.TransformOptions): FileAction;
+import { FileAction, JavaScriptExtension } from "../../types";
+export declare function create(defaultBabelOptions?: babel.TransformOptions, outExit?: JavaScriptExtension): FileAction;

package/out/modules/actions/babel-compile.js

@@ -39,26 +39,30 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const errors_1 = require("../errors");
 const project_compiler_1 = require("../project-compiler");
-const outExt = project_compiler_1.ProjectCompiler.tsOutExt;
-function create(babelOptions) {
+// const outExt = ProjectCompiler.tsOutExt;
+function create(defaultBabelOptions, outExit) {
     const action = (sourcePath, outputPath, projectPath) => {
-        if (!babelOptions) {
-            let bablePath;
-            let sourceDir = path.dirname(sourcePath);
-            if (projectPath) {
-                let c = project_compiler_1.ProjectCompiler.getBabelConfig(projectPath, sourceDir);
-                bablePath = c.path;
-                babelOptions = c.options;
-            }
-            else {
-                babelOptions = project_compiler_1.ProjectCompiler.getDefaultBabelConfig();
-                bablePath = '';
-            }
-            babelOptions.filename = sourcePath;
-            babelOptions.code = false;
-            babelOptions.ast = true;
+        outExit = outExit || ".js";
+        if (defaultBabelOptions) {
+            return compileFile(sourcePath, outputPath, projectPath, defaultBabelOptions, outExit);
         }
-        return compileFile(sourcePath, outputPath, projectPath, babelOptions);
+        // 如果没有 babelOptions，则尝试从项目目录查找 babel 配置文件，如果没有，则使用默认配置。
+        let babelOptions;
+        let bablePath;
+        let sourceDir = path.dirname(sourcePath);
+        if (projectPath) {
+            let c = project_compiler_1.ProjectCompiler.getBabelConfig(projectPath, sourceDir);
+            bablePath = c.path;
+            babelOptions = c.options;
+        }
+        else {
+            babelOptions = project_compiler_1.ProjectCompiler.getDefaultBabelConfig();
+            bablePath = '';
+        }
+        babelOptions.filename = sourcePath;
+        babelOptions.code = false;
+        babelOptions.ast = true;
+        return compileFile(sourcePath, outputPath, projectPath, babelOptions, outExit);
     };
     return action;
 }
@@ -68,7 +72,7 @@ function create(babelOptions) {
  * @param outputPath 输出目录
  * @param projectPath 项目路径
  * */
-async function compileFile(sourcePath, outputPath, projectPath, babelOptions) {
+async function compileFile(sourcePath, outputPath, projectPath, babelOptions, outExt) {
     if (!sourcePath)
         throw errors_1.errors.argumentNull("sourcePath");
     if (!outputPath)
@@ -107,7 +111,7 @@ async function compileFile(sourcePath, outputPath, projectPath, babelOptions) {
     let ast = fileResult.ast;
     if (!ast)
         throw errors_1.errors.compileError(sourcePath);
-    new ImportPathRewrite(sourcePath, ast);
+    new ImportPathRewrite(sourcePath, ast, outExt);
     let r = babel.transformFromAstSync(ast, undefined, {
         filename: sourcePath, plugins: babelOptions.plugins,
         presets: babelOptions.presets, sourceMaps: babelOptions.sourceMaps
@@ -115,7 +119,7 @@ async function compileFile(sourcePath, outputPath, projectPath, babelOptions) {
     if (!r || r.code == null)
         throw errors_1.errors.compileError(sourcePath);
     let ext = extname(sourcePath);
-    let outExt = fileOutExt(sourcePath);
+    //let outExt = fileOutExt(sourcePath);
     let targetPath = path.join(outputPath, path.basename(sourcePath).replace(ext, outExt)); //sourcePath.replace(new RegExp(ext + "$"), outExt).replace(path.dirname(sourcePath), outDir);
     let outDirPath = path.resolve(targetPath, "..");
     let mapPath = targetPath + ".map";
@@ -144,18 +148,20 @@ function extname(file) {
  * 获取源文件所对应生成文件的扩展名
  * @param file 源文件名
  * */
-function fileOutExt(file) {
-    let ext = extname(file);
-    if (ext === ".ts")
-        return outExt;
-    if (ext === ".tsx")
-        return outExt;
-    return ext;
-}
+// function fileOutExt(file: string) {
+//     let ext = extname(file);
+//     if (ext === ".ts")
+//         return outExt;
+//     if (ext === ".tsx")
+//         return outExt;
+//     return ext;
+// }
 class ImportPathRewrite {
     filePath;
-    constructor(filePath, node) {
+    outExt;
+    constructor(filePath, node, outExt) {
         this.filePath = filePath;
+        this.outExt = outExt;
         this.traverse(node);
     }
     traverse(node) {
@@ -169,14 +175,14 @@ class ImportPathRewrite {
             case "ImportDeclaration":
                 if (node.source.type === "StringLiteral" && node.source.value.startsWith(".")) {
                     let ext = extname(node.source.value);
-                    if (ext != outExt) {
+                    if (ext != this.outExt) {
                         let dir = path.dirname(this.filePath);
                         let fullPath = path.join(dir, node.source.value);
                         console.log(`ImportDeclaration: ${fullPath} -> ${ext}`);
                         if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
                             node.source.value = node.source.value + "/index";
                         }
-                        node.source.value += outExt;
+                        node.source.value += this.outExt;
                     }
                 }
                 break;

package/out/modules/actions/ts-compile.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { FileAction } from '../../types';
-export declare function create(compilerOptions?: ts.CompilerOptions): FileAction;
+import { FileAction, JavaScriptExtension } from '../../types';
+export declare function create(defaultCompilerOptions?: ts.CompilerOptions, outExt?: JavaScriptExtension): FileAction;
 export declare function getTypescriptConfig(projectPath: string, directoryPath: string): ts.CompilerOptions;
 export declare function findTypeScriptConfigPath(projectPath: string, directoryPath: string): string | null;

package/out/modules/actions/ts-compile.js

@@ -40,14 +40,16 @@ const ts = __importStar(require("typescript"));
 const errors_1 = require("../errors");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const project_compiler_1 = require("../project-compiler");
 const TS_CONFIG_FILE = 'tsconfig.json';
-function create(compilerOptions) {
+function create(defaultCompilerOptions, outExt) {
+    outExt = outExt || ".js";
     const action = async (filePath, outDir, projectPath) => {
-        if (!compilerOptions) {
-            compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+        if (defaultCompilerOptions) {
+            return compileFile(filePath, outDir, projectPath, defaultCompilerOptions, outExt);
         }
-        return compileFile(filePath, outDir, projectPath, compilerOptions);
+        // 如果没有指定默认编译选项，则尝试从项目目录查找 tsconfig.json 文件，并使用其中的配置进行编译
+        const compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+        return compileFile(filePath, outDir, projectPath, compilerOptions, outExt);
     };
     return action;
 }
@@ -57,7 +59,7 @@ function create(compilerOptions) {
  * @param outDir 输出目录，相对于项目路径
  * @param projectPath 项目路径，绝对路径
  * */
-async function compileFile(filePath, outDir, projectPath, compilerOptions) {
+async function compileFile(filePath, outDir, projectPath, compilerOptions, outExt) {
     if (!filePath)
         throw errors_1.errors.argumentNull('sourcePath');
     if (!outDir)
@@ -68,7 +70,6 @@ async function compileFile(filePath, outDir, projectPath, compilerOptions) {
     // let compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
     let result = ts.transpileModule(content, { compilerOptions });
     let ext = path.extname(filePath);
-    let outExt = project_compiler_1.ProjectCompiler.tsOutExt;
     let targetPath = path.join(projectPath, outDir, path.basename(filePath).replace(ext, outExt));
     let outDirPath = path.resolve(targetPath, "..");
     if (!fs.existsSync(outDirPath))

package/out/modules/compile.d.ts

@@ -14,5 +14,6 @@ type Options = {
     skipFiles?: RegExp[];
     fileAction?: (fileName: string) => FileAction | undefined;
     callback?: Callback;
+    defaultAction?: FileAction;
 };
 export {};

package/out/modules/compile.js

@@ -104,7 +104,9 @@ function extname(file) {
     return ext;
 }
 function generateCodeByOptions(options) {
-    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback } = options;
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
+    if (!defaultAction)
+        defaultAction = copy_file_1.default;
     if (!sourceDir)
         throw errors_1.errors.argumentNull("sourceDir");
     if (!outDir)
@@ -126,11 +128,7 @@ function generateCodeByOptions(options) {
             console.log(`Skip ${filePath}`);
             continue;
         }
-        fileActions = fileActions || function (fileName) {
-            const ext = path.extname(fileName);
-            return configs_1.default.fileActions[ext];
-        };
-        let action = fileActions(filePath);
+        let action = fileActions?.(filePath) || configs_1.default.fileActions[ext] || defaultAction;
         if (action) {
             action(filePath, outDir, projectPath);
             if (callback) {
@@ -143,14 +141,18 @@ function generateCodeByOptions(options) {
         let fullPath = path.join(sourceDir, dir);
         let outDirPath = path.join(outDir, dir);
         if (fs.statSync(fullPath).isDirectory()) {
-            generateCodeByOptions({ sourceDir: fullPath, outDir: outDirPath, projectPath: projectPath, skipFiles, fileAction: fileActions, callback });
+            generateCodeByOptions({ sourceDir: fullPath, outDir: outDirPath, projectPath: projectPath, skipFiles, fileAction: fileActions, callback, defaultAction });
         }
     }
 }
 function watchDirectoryByOptions(options) {
-    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback } = options;
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
+    if (!defaultAction)
+        defaultAction = copy_file_1.default;
     (0, node_watch_1.default)(sourceDir, { recursive: true }, async (evt, name) => {
-        const filePath = name;
+        const filePath = name.replace(/\\/g, "/");
+        sourceDir = sourceDir.replace(/\\/g, "/");
+        outDir = outDir.replace(/\\/g, "/");
         const ext = extname(filePath);
         skipFiles = skipFiles || configs_1.default.skipFiles[ext] || [];
         let isSkip = skipFiles.some(pattern => pattern.test(filePath)); //isIgnoredFile(filePath);//skipFiles.some(pattern => new RegExp(pattern).test(filePath));
@@ -161,15 +163,15 @@ function watchDirectoryByOptions(options) {
         if (evt === "remove") {
             return;
         }
-        let action = fileActions?.(filePath) || configs_1.default.fileActions[ext];
+        let action = fileActions?.(filePath) || configs_1.default.fileActions[ext] || defaultAction;
         if (!action) {
             return;
         }
         try {
-            let outPath = path.dirname(name).replace(sourceDir, outDir);
-            action(name, outPath, projectPath);
+            let outPath = path.dirname(filePath).replace(sourceDir, outDir);
+            action(filePath, outPath, projectPath);
             if (callback)
-                callback(name, outPath, projectPath);
+                callback(filePath, outPath, projectPath);
         }
         catch (e) {
             console.error(e);

package/out/types.d.ts

@@ -1 +1,2 @@
 export type FileAction = (filePath: string, outPath: string, projectPath: string) => void;
+export type JavaScriptExtension = ".js" | ".mjs" | ".cjs";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.4.0",
+    "version": "1.4.2",
     "description": "用于对 node 项目进行代码生成，打包，运行",
     "dependencies": {
         "@babel/core": "^7.24.3",
@@ -31,6 +31,7 @@
         "src"
     ],
     "scripts": {
-        "build": "tsc"
+        "build": "tsc -p tsconfig.build.json",
+        "test": "jest"
     }
-}
+}

package/src/modules/actions/babel-compile.ts

@@ -4,31 +4,37 @@ import * as fs from "fs";
 import * as path from "path";
 import { errors } from "../errors";
 import { ProjectCompiler } from "../project-compiler";
-import { FileAction } from "../../types";
+import { FileAction, JavaScriptExtension } from "../../types";
 
-const outExt = ProjectCompiler.tsOutExt;
+// const outExt = ProjectCompiler.tsOutExt;
 
 
-export function create(babelOptions?: babel.TransformOptions): FileAction {
+export function create(defaultBabelOptions?: babel.TransformOptions, outExit?: JavaScriptExtension): FileAction {
     const action: FileAction = (sourcePath: string, outputPath: string, projectPath: string) => {
-        if (!babelOptions) {
-            let bablePath: string;
-            let sourceDir = path.dirname(sourcePath);
-            if (projectPath) {
-                let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
-                bablePath = c.path;
-                babelOptions = c.options;
-            }
-            else {
-                babelOptions = ProjectCompiler.getDefaultBabelConfig();
-                bablePath = '';
-            }
-            babelOptions.filename = sourcePath;
-            babelOptions.code = false;
-            babelOptions.ast = true;
+        outExit = outExit || ".js";
+        if (defaultBabelOptions) {
+            return compileFile(sourcePath, outputPath, projectPath, defaultBabelOptions, outExit);
         }
 
-        return compileFile(sourcePath, outputPath, projectPath, babelOptions);
+        // 如果没有 babelOptions，则尝试从项目目录查找 babel 配置文件，如果没有，则使用默认配置。
+        let babelOptions: babel.TransformOptions;
+        let bablePath: string;
+        let sourceDir = path.dirname(sourcePath);
+        if (projectPath) {
+            let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
+            bablePath = c.path;
+            babelOptions = c.options;
+        }
+        else {
+            babelOptions = ProjectCompiler.getDefaultBabelConfig();
+            bablePath = '';
+        }
+
+        babelOptions.filename = sourcePath;
+        babelOptions.code = false;
+        babelOptions.ast = true;
+
+        return compileFile(sourcePath, outputPath, projectPath, babelOptions, outExit);
     }
     return action;
 }
@@ -39,7 +45,7 @@ export function create(babelOptions?: babel.TransformOptions): FileAction {
  * @param outputPath 输出目录
  * @param projectPath 项目路径
  * */
-async function compileFile(sourcePath: string, outputPath: string, projectPath: string, babelOptions: babel.TransformOptions) {
+async function compileFile(sourcePath: string, outputPath: string, projectPath: string, babelOptions: babel.TransformOptions, outExt: JavaScriptExtension) {
     if (!sourcePath) throw errors.argumentNull("sourcePath");
     if (!outputPath) throw errors.argumentNull("outputPath");
     if (!projectPath) throw errors.argumentNull("projectPath");
@@ -82,7 +88,7 @@ async function compileFile(sourcePath: string, outputPath: string, projectPath:
     if (!ast)
         throw errors.compileError(sourcePath);
 
-    new ImportPathRewrite(sourcePath, ast);
+    new ImportPathRewrite(sourcePath, ast, outExt);
     let r = babel.transformFromAstSync(ast, undefined, {
         filename: sourcePath, plugins: babelOptions.plugins,
         presets: babelOptions.presets, sourceMaps: babelOptions.sourceMaps
@@ -91,7 +97,7 @@ async function compileFile(sourcePath: string, outputPath: string, projectPath:
         throw errors.compileError(sourcePath);
 
     let ext = extname(sourcePath);
-    let outExt = fileOutExt(sourcePath);
+    //let outExt = fileOutExt(sourcePath);
     let targetPath = path.join(outputPath, path.basename(sourcePath).replace(ext, outExt));//sourcePath.replace(new RegExp(ext + "$"), outExt).replace(path.dirname(sourcePath), outDir);
     let outDirPath = path.resolve(targetPath, "..");
 
@@ -128,20 +134,20 @@ function extname(file: string) {
  * 获取源文件所对应生成文件的扩展名 
  * @param file 源文件名
  * */
-function fileOutExt(file: string) {
-    let ext = extname(file);
-    if (ext === ".ts")
-        return outExt;
+// function fileOutExt(file: string) {
+//     let ext = extname(file);
+//     if (ext === ".ts")
+//         return outExt;
 
-    if (ext === ".tsx")
-        return outExt;
+//     if (ext === ".tsx")
+//         return outExt;
 
-    return ext;
-}
+//     return ext;
+// }
 
 
 class ImportPathRewrite {
-    constructor(private filePath: string, node: babel.types.File) {
+    constructor(private filePath: string, node: babel.types.File, private outExt: JavaScriptExtension) {
         this.traverse(node);
     }
 
@@ -156,14 +162,14 @@ class ImportPathRewrite {
             case "ImportDeclaration":
                 if (node.source.type === "StringLiteral" && node.source.value.startsWith(".")) {
                     let ext = extname(node.source.value);
-                    if (ext != outExt) {
+                    if (ext != this.outExt) {
                         let dir = path.dirname(this.filePath);
                         let fullPath = path.join(dir, node.source.value);
                         console.log(`ImportDeclaration: ${fullPath} -> ${ext}`)
                         if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
                             node.source.value = node.source.value + "/index";
                         }
-                        node.source.value += outExt;
+                        node.source.value += this.outExt;
                     }
                 }
                 break;

package/src/modules/actions/ts-compile.ts

@@ -3,7 +3,7 @@ import { errors } from '../errors';
 import * as fs from 'fs';
 import * as path from 'path';
 import { ProjectCompiler } from '../project-compiler';
-import { FileAction } from '../../types';
+import { FileAction, JavaScriptExtension } from '../../types';
 
 const TS_CONFIG_FILE = 'tsconfig.json';
 
@@ -11,12 +11,16 @@ type TypeScriptProjectConfig = {
     compilerOptions: ts.CompilerOptions;
 }
 
-export function create(compilerOptions?: ts.CompilerOptions): FileAction {
+export function create(defaultCompilerOptions?: ts.CompilerOptions, outExt?: JavaScriptExtension): FileAction {
+    outExt = outExt || ".js";
     const action: FileAction = async (filePath: string, outDir: string, projectPath: string) => {
-        if (!compilerOptions) {
-            compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+        if (defaultCompilerOptions) {
+            return compileFile(filePath, outDir, projectPath, defaultCompilerOptions, outExt);
         }
-        return compileFile(filePath, outDir, projectPath, compilerOptions)
+
+        // 如果没有指定默认编译选项，则尝试从项目目录查找 tsconfig.json 文件，并使用其中的配置进行编译
+        const compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+        return compileFile(filePath, outDir, projectPath, compilerOptions, outExt);
     }
 
     return action;
@@ -28,7 +32,7 @@ export function create(compilerOptions?: ts.CompilerOptions): FileAction {
  * @param outDir 输出目录，相对于项目路径
  * @param projectPath 项目路径，绝对路径
  * */
-async function compileFile(filePath: string, outDir: string, projectPath: string, compilerOptions: ts.CompilerOptions) {
+async function compileFile(filePath: string, outDir: string, projectPath: string, compilerOptions: ts.CompilerOptions, outExt: JavaScriptExtension) {
     if (!filePath)
         throw errors.argumentNull('sourcePath');
     if (!outDir)
@@ -42,7 +46,6 @@ async function compileFile(filePath: string, outDir: string, projectPath: string
     let result = ts.transpileModule(content, { compilerOptions });
 
     let ext = path.extname(filePath);
-    let outExt = ProjectCompiler.tsOutExt;
     let targetPath = path.join(projectPath, outDir, path.basename(filePath).replace(ext, outExt));
     let outDirPath = path.resolve(targetPath, "..");
 

package/src/modules/compile.test.ts

@@ -1,188 +1,236 @@
-import { generateCode, isIgnoredFile, watchDirectory } from "./compile";
-import * as path from "path";
-import * as fs from "fs";
-import { create as createTsCompiler } from "../modules/actions/ts-compile";
-import ts from "typescript";
-import { FileAction } from "../types";
-
-describe("Compile Test", function () {
-
-    test("copyFile test", function () {
-
-        let srcPath = "test/src";
-        let srcExists = fs.existsSync(srcPath);
-        expect(srcExists).toBe(true);
-    })
-
-    test("generateCode test", function () {
-
-        let srcPath = "test/src";
-        let destPath = "test/out";
-        if (fs.existsSync(destPath)) {
-            fs.rmdirSync(destPath, { recursive: true });
-        }
-
-        let projectPath = path.join(__dirname, "..", "..");
-        generateCode(srcPath, destPath, projectPath);
-    })
-
-    test("generateCode with callback test", function () {
-
-        let srcPath = "test/src";
-        let destPath = "test/out";
-        if (fs.existsSync(destPath)) {
-            fs.rmdirSync(destPath, { recursive: true });
-        }
-
-        let projectPath = path.join(__dirname, "..", "..");
-        const callback = jest.fn();
-        generateCode(srcPath, destPath, projectPath, callback);
-        expect(callback.mock.calls.length).toBeGreaterThan(0);
-    })
-
-    test("generateCode with skipFiles test", function () {
-
-        let srcPath = "test/src";
-        let destPath = "test/out";
-        if (fs.existsSync(destPath)) {
-            fs.rmdirSync(destPath, { recursive: true });
-        }
-
-        let projectPath = path.join(__dirname, "..", "..");
-        let executedPaths: string[] = [];
-        generateCode(srcPath, destPath, projectPath, (filePath: string) => {
-            executedPaths.push(filePath);
-        });
-
-        // 'test\\src\\controllers\\proxy.ts'
-        expect(executedPaths.some(p => p.includes("controllers")));
-
-        // 忽略掉 controllers 目录
-        const skipFiles = [new RegExp("controllers")];
-        executedPaths = [];
-        generateCode({
-            sourceDir: srcPath, outDir: destPath, projectPath, skipFiles,
-            callback(filePath: string) {
-                executedPaths.push(filePath);
-            }
-        })
-        expect(executedPaths.some(p => p.includes("controllers"))).toBe(false);
-    })
-
-    test("generateCode 根据文件夹使用不同的 TS 编译器", function () {
-
-        let srcPath = "test/src";
-        let destPath = "test/out";
-        if (fs.existsSync(destPath)) {
-            fs.rmdirSync(destPath, { recursive: true });
-        }
-
-        const srcCompiler = createTsCompiler({
-            target: ts.ScriptTarget.ES2015,
-            module: ts.ModuleKind.CommonJS,
-            declaration: true,
-        });
-
-        const staticCompiler = createTsCompiler({
-            target: ts.ScriptTarget.ES5,
-            module: ts.ModuleKind.AMD,
-            declaration: false,
-        });
-
-        let projectPath = path.join(__dirname, "..", "..");
-        const mainFile = "main.ts";
-        const staticFile = "static/index.ts";
-        const mainFilePath = path.resolve(srcPath, mainFile);
-        expect(fs.existsSync(mainFilePath)).toBeTruthy();
-        const staticFilePath = path.resolve(srcPath, staticFile);
-        expect(fs.existsSync(staticFilePath)).toBeTruthy();
-
-
-        generateCode({
-            sourceDir: srcPath, outDir: destPath, projectPath,
-            fileAction(filePath: string) {
-                const ext = path.extname(filePath);
-                if (ext !== ".ts" && ext !== ".tsx") {
-                    return undefined;
-                }
-                filePath = filePath.replace(/\\/g, "/");
-                if (filePath.startsWith("test/src/static/")) {
-                    return staticCompiler;
-                }
-                return srcCompiler;
-            },
-            callback(filePath: string) {
-            }
-        })
-
-        const mainOutFile = "main.js";
-        const staticOutFile = "static/index.js";
-        const mainOutFilePath = path.resolve(destPath, mainOutFile);
-        const staticOutFilePath = path.resolve(destPath, staticOutFile);
-        expect(fs.existsSync(mainOutFilePath)).toBeTruthy();
-        expect(fs.existsSync(staticOutFilePath)).toBeTruthy();
-
-        const mainFileContent = fs.readFileSync(mainOutFilePath, "utf-8");
-        const staticFileContent = fs.readFileSync(staticOutFilePath, "utf-8");
-
-        expect(mainFileContent.includes("Object.defineProperty(exports, \"__esModule\"")).toBe(true);
-        expect(staticFileContent.includes("define([")).toBe(true);
-
-    })
-
-    test("isIgnored test", function () {
-        let filePath = "D:\\startdard-process\\plm-projects\\tc-api-proxy\\src\\app.controller.spec.ts";
-        let ignored = isIgnoredFile(filePath);
-        expect(ignored).toBe(true);
-    })
-
-    test("watchDirectory test, 修改文件应该触发回调, 删除文不应该触发回调", async function () {
-
-        let srcPath = "test/src";
-        let destPath = "test/out";
-
-        // 在 srcPath 中创建文件
-        let filePath = path.join(srcPath, "test.txt");
-        fs.writeFileSync(filePath, "test");
-        const fileAction = jest.fn();
-
-        setTimeout(() => {
-            // 监听 srcPath
-            let projectPath = path.join(__dirname, "..", "..");
-            let executedPaths: string[] = [];
-            // watchDirectory(srcPath, destPath, projectPath,  (filePath: string) => {
-            //     executedPaths.push(filePath);
-            // });
-            watchDirectory({
-                sourceDir: srcPath, outDir: destPath, projectPath,
-                fileAction: () => {
-                    return fileAction;
-                },
-                callback(filePath: string) {
-                    executedPaths.push(filePath);
-                }
-            })
-        }, 0);
-
-        await new Promise(resolve => setTimeout(resolve, 1000 * 1));
-        // 修改文件
-        fs.writeFileSync(filePath, "test2");
-
-        await new Promise(resolve => setTimeout(resolve, 1000 * 1));
-        expect(fileAction.mock.calls.length).toBe(1);
-        expect(fileAction.mock.calls[0][0]).toBe(filePath);
-
-
-        const calltimes = fileAction.mock.calls.length;
-        setTimeout(() => {
-            // 删除文件
-            fs.unlinkSync(filePath);
-        }, 1000 * 1);
-
-        await new Promise(resolve => setTimeout(resolve, 1000 * 1));
-        expect(fileAction.mock.calls.length).toBe(calltimes);
-
-
-    })
-
-})
+import { generateCode, isIgnoredFile, watchDirectory } from "./compile";
+import * as path from "path";
+import * as fs from "fs";
+import { create as createTsCompiler } from "./actions/ts-compile";
+import ts from "typescript";
+import copyFile from "./actions/copy-file";
+import { errors } from "./errors";
+
+// 公共常量
+const SRC_PATH = "test/src";
+const DEST_PATH = "test/out";
+const PROJECT_PATH = path.join(__dirname, "..", "..");
+
+// 清理输出目录的工具函数
+function cleanDir(dir: string) {
+    if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true });
+    }
+}
+
+describe("Compile Test", function () {
+
+    test("copyFile test", function () {
+        let srcExists = fs.existsSync(SRC_PATH);
+        expect(srcExists).toBe(true);
+    })
+
+    test("generateCode test", function () {
+        cleanDir(DEST_PATH);
+        generateCode(SRC_PATH, DEST_PATH, PROJECT_PATH);
+    })
+
+    test("generateCode with callback test", function () {
+        cleanDir(DEST_PATH);
+        const callback = jest.fn();
+        generateCode(SRC_PATH, DEST_PATH, PROJECT_PATH, callback);
+        expect(callback.mock.calls.length).toBeGreaterThan(0);
+    })
+
+    test("generateCode with skipFiles test", function () {
+        cleanDir(DEST_PATH);
+
+        let executedPaths: string[] = [];
+        generateCode(SRC_PATH, DEST_PATH, PROJECT_PATH, (filePath: string) => {
+            executedPaths.push(filePath);
+        });
+
+        expect(executedPaths.some(p => p.includes("controllers"))).toBe(true);
+
+        // 忽略掉 controllers 目录
+        const skipFiles = [new RegExp("controllers")];
+        executedPaths = [];
+        generateCode({
+            sourceDir: SRC_PATH, outDir: DEST_PATH, projectPath: PROJECT_PATH, skipFiles,
+            callback(filePath: string) {
+                executedPaths.push(filePath);
+            }
+        })
+        expect(executedPaths.some(p => p.includes("controllers"))).toBe(false);
+    })
+
+    test("generateCode 根据文件夹使用不同的 TS 编译器", async function () {
+        cleanDir(DEST_PATH);
+
+        const srcCompiler = createTsCompiler({
+            target: ts.ScriptTarget.ES2015,
+            module: ts.ModuleKind.CommonJS,
+            declaration: true,
+        });
+
+        const staticCompiler = createTsCompiler({
+            target: ts.ScriptTarget.ES5,
+            module: ts.ModuleKind.AMD,
+            declaration: false,
+        });
+
+        const mainFile = "main.ts";
+        const staticFile = "static/index.ts";
+        const mainFilePath = path.resolve(SRC_PATH, mainFile);
+        expect(fs.existsSync(mainFilePath)).toBeTruthy();
+        const staticFilePath = path.resolve(SRC_PATH, staticFile);
+        expect(fs.existsSync(staticFilePath)).toBeTruthy();
+
+        generateCode({
+            sourceDir: SRC_PATH, outDir: DEST_PATH, projectPath: PROJECT_PATH,
+            fileAction(filePath: string) {
+                const ext = path.extname(filePath);
+                if (ext !== ".ts" && ext !== ".tsx") {
+                    return undefined;
+                }
+                filePath = filePath.replace(/\\/g, "/");
+                if (filePath.startsWith("test/src/static/")) {
+                    return staticCompiler;
+                }
+                return srcCompiler;
+            },
+            callback(_filePath: string) {
+            }
+        })
+
+        // 等待异步编译完成
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        const mainOutFile = "main.js";
+        const staticOutFile = "static/index.js";
+        const mainOutFilePath = path.resolve(DEST_PATH, mainOutFile);
+        const staticOutFilePath = path.resolve(DEST_PATH, staticOutFile);
+        expect(fs.existsSync(mainOutFilePath)).toBeTruthy();
+        expect(fs.existsSync(staticOutFilePath)).toBeTruthy();
+
+        const mainFileContent = fs.readFileSync(mainOutFilePath, "utf-8");
+        const staticFileContent = fs.readFileSync(staticOutFilePath, "utf-8");
+
+        expect(mainFileContent.includes("Object.defineProperty(exports, \"__esModule\"")).toBe(true);
+        expect(staticFileContent.includes("define([")).toBe(true);
+    })
+
+    test("generateCode 参数校验", function () {
+        expect(() => generateCode("", DEST_PATH, PROJECT_PATH)).toThrow();
+        expect(() => generateCode(SRC_PATH, "", PROJECT_PATH)).toThrow();
+        expect(() => generateCode(SRC_PATH, DEST_PATH, "")).toThrow();
+        expect(() => generateCode("/nonexistent/path", DEST_PATH, PROJECT_PATH)).toThrow();
+    })
+
+    test("generateCode with defaultAction", function () {
+        cleanDir(DEST_PATH);
+
+        const customAction = jest.fn();
+        generateCode({
+            sourceDir: SRC_PATH, outDir: DEST_PATH, projectPath: PROJECT_PATH,
+            fileAction() {
+                return undefined; // fileAction 始终返回 undefined
+            },
+            defaultAction: customAction as any,
+        })
+
+        // defaultAction 应该被调用
+        expect(customAction.mock.calls.length).toBeGreaterThan(0);
+    })
+
+    test("generateCode defaultAction 默认为 copyFile", function () {
+        cleanDir(DEST_PATH);
+
+        // 不指定 fileAction 和 defaultAction，未知扩展名应使用 copyFile 作为兜底
+        const jsFile = path.join(SRC_PATH, "test-default-action.js");
+        fs.writeFileSync(jsFile, "console.log('test');");
+
+        try {
+            generateCode({
+                sourceDir: SRC_PATH, outDir: DEST_PATH, projectPath: PROJECT_PATH,
+                fileAction() {
+                    return undefined; // 不提供任何 action
+                },
+            })
+
+            // copyFile 应该将 .js 文件复制到输出目录
+            const outFile = path.resolve(DEST_PATH, "test-default-action.js");
+            expect(fs.existsSync(outFile)).toBe(true);
+        } finally {
+            // 清理临时文件
+            if (fs.existsSync(jsFile)) fs.unlinkSync(jsFile);
+            const outFile = path.resolve(DEST_PATH, "test-default-action.js");
+            if (fs.existsSync(outFile)) fs.unlinkSync(outFile);
+        }
+    })
+
+    describe("isIgnoredFile", function () {
+
+        test(".spec.ts 文件应该被忽略", function () {
+            let filePath = "D:\\project\\src\\app.controller.spec.ts";
+            let ignored = isIgnoredFile(filePath);
+            expect(ignored).toBe(true);
+        })
+
+        test(".test.ts 文件应该被忽略", function () {
+            let filePath = "D:\\project\\src\\app.controller.test.ts";
+            let ignored = isIgnoredFile(filePath);
+            expect(ignored).toBe(true);
+        })
+
+        test(".d.ts 文件应该被忽略", function () {
+            let filePath = "D:\\project\\src\\app.d.ts";
+            let ignored = isIgnoredFile(filePath);
+            expect(ignored).toBe(true);
+        })
+
+        test("普通 .ts 文件不应被忽略", function () {
+            let filePath = "D:\\project\\src\\app.controller.ts";
+            let ignored = isIgnoredFile(filePath);
+            expect(ignored).toBe(false);
+        })
+
+        test("空参数应抛出异常", function () {
+            expect(() => isIgnoredFile("")).toThrow();
+        })
+
+    })
+
+    test("watchDirectory test, 修改文件应该触发回调, 删除文件不应该触发回调", async function () {
+        let filePath = path.join(SRC_PATH, "test.txt");
+        filePath = filePath.replace(/\\/g, "/");
+        fs.writeFileSync(filePath, "test");
+        const fileAction = jest.fn();
+
+        setTimeout(() => {
+            let executedPaths: string[] = [];
+            watchDirectory({
+                sourceDir: SRC_PATH, outDir: DEST_PATH, projectPath: PROJECT_PATH,
+                fileAction: () => {
+                    return fileAction;
+                },
+                callback(filePath: string) {
+                    executedPaths.push(filePath);
+                }
+            })
+        }, 0);
+
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // 修改文件
+        fs.writeFileSync(filePath, "test2");
+
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        expect(fileAction.mock.calls.length).toBe(1);
+        expect(fileAction.mock.calls[0][0]).toBe(filePath);
+
+        const calltimes = fileAction.mock.calls.length;
+        setTimeout(() => {
+            // 删除文件
+            fs.unlinkSync(filePath);
+        }, 1000);
+
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        expect(fileAction.mock.calls.length).toBe(calltimes);
+    })
+
+})

package/src/modules/compile.ts

@@ -84,11 +84,15 @@ type Options = {
     sourceDir: string, outDir: string, projectPath: string,
     skipFiles?: RegExp[],
     fileAction?: (fileName: string) => FileAction | undefined,
-    callback?: Callback
+    callback?: Callback,
+    defaultAction?: FileAction
 }
 function generateCodeByOptions(options: Options) {
 
-    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback } = options;
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
+
+    if (!defaultAction)
+        defaultAction = copyFile;
 
 
     if (!sourceDir) throw errors.argumentNull("sourceDir");
@@ -116,11 +120,7 @@ function generateCodeByOptions(options: Options) {
             continue;
         }
 
-        fileActions = fileActions || function (fileName: string) {
-            const ext = path.extname(fileName);
-            return configs.fileActions[ext];
-        };
-        let action = fileActions(filePath);
+        let action = fileActions?.(filePath) || configs.fileActions[ext] || defaultAction;
         if (action) {
             action(filePath, outDir, projectPath);
             if (callback) {
@@ -134,16 +134,22 @@ function generateCodeByOptions(options: Options) {
         let fullPath = path.join(sourceDir, dir);
         let outDirPath = path.join(outDir, dir);
         if (fs.statSync(fullPath).isDirectory()) {
-            generateCodeByOptions({ sourceDir: fullPath, outDir: outDirPath, projectPath: projectPath, skipFiles, fileAction: fileActions, callback });
+            generateCodeByOptions({ sourceDir: fullPath, outDir: outDirPath, projectPath: projectPath, skipFiles, fileAction: fileActions, callback, defaultAction });
         }
     }
 }
 
 function watchDirectoryByOptions(options: Options) {
-    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback } = options;
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback, defaultAction } = options;
+
+    if (!defaultAction)
+        defaultAction = copyFile;
+
+    watch(sourceDir, { recursive: true }, async (evt: "update" | "remove", name: string) => {
+        const filePath = name.replace(/\\/g, "/");
+        sourceDir = sourceDir.replace(/\\/g, "/");
+        outDir = outDir.replace(/\\/g, "/");
 
-    watch(sourceDir, { recursive: true }, async (evt, name) => {
-        const filePath = name;
         const ext = extname(filePath);
         skipFiles = skipFiles || configs.skipFiles[ext] || [];
         let isSkip = skipFiles.some(pattern => pattern.test(filePath));//isIgnoredFile(filePath);//skipFiles.some(pattern => new RegExp(pattern).test(filePath));
@@ -156,16 +162,16 @@ function watchDirectoryByOptions(options: Options) {
             return;
         }
 
-        let action = fileActions?.(filePath) || configs.fileActions[ext];
+        let action = fileActions?.(filePath) || configs.fileActions[ext] || defaultAction;
         if (!action) {
             return;
         }
 
         try {
-            let outPath = path.dirname(name).replace(sourceDir, outDir);
-            action(name, outPath, projectPath);
+            let outPath = path.dirname(filePath).replace(sourceDir, outDir);
+            action(filePath, outPath, projectPath);
             if (callback)
-                callback(name, outPath, projectPath);
+                callback(filePath, outPath, projectPath);
         }
         catch (e) {
             console.error(e);

package/src/types.ts

@@ -1 +1,2 @@
-export type FileAction = (filePath: string, outPath: string, projectPath: string) => void;
+export type FileAction = (filePath: string, outPath: string, projectPath: string) => void;
+export type JavaScriptExtension = ".js" | ".mjs" | ".cjs";

package/out/modules/actions/biel-compile.d.ts

@@ -1,7 +0,0 @@
-/**
- * 编译特定文件，并生成到制定目录
- * @param sourcePath 源文件路径
- * @param outputPath 输出目录
- * @param projectPath 项目路径
- * */
-export declare function compileFile(sourcePath: string, outputPath: string, projectPath: string): Promise<void>;

package/out/modules/actions/biel-compile.js

@@ -1,153 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileFile = compileFile;
-const babel = __importStar(require("@babel/core"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const errors_1 = require("../errors");
-const project_compiler_1 = require("../project-compiler");
-const outExt = project_compiler_1.ProjectCompiler.tsOutExt;
-/**
- * 编译特定文件，并生成到制定目录
- * @param sourcePath 源文件路径
- * @param outputPath 输出目录
- * @param projectPath 项目路径
- * */
-async function compileFile(sourcePath, outputPath, projectPath) {
-    if (!sourcePath)
-        throw errors_1.errors.argumentNull("sourcePath");
-    if (!outputPath)
-        throw errors_1.errors.argumentNull("outputPath");
-    if (!projectPath)
-        throw errors_1.errors.argumentNull("projectPath");
-    // if (!fs.existsSync(sourcePath)) throw errors.pathNotExists(sourcePath);
-    if (!fs.existsSync(sourcePath)) {
-        console.warn(`Path not exists: ${sourcePath}`);
-        return;
-    }
-    let sourceDir = path.dirname(sourcePath);
-    let babelOptions;
-    let bablePath;
-    //= projectPath ?
-    //  ProjectCompiler.getBabelConfig(projectPath, sourceDir) : ProjectCompiler.getDefaultBabelConfig();
-    if (projectPath) {
-        let c = project_compiler_1.ProjectCompiler.getBabelConfig(projectPath, sourceDir);
-        bablePath = c.path;
-        babelOptions = c.options;
-    }
-    else {
-        babelOptions = project_compiler_1.ProjectCompiler.getDefaultBabelConfig();
-        bablePath = '';
-    }
-    babelOptions.filename = sourcePath;
-    babelOptions.code = false;
-    babelOptions.ast = true;
-    // let fileResult = babel.transformFileSync(sourcePath, {
-    //     filename: sourcePath, code: false, ast: true, plugins,
-    //     presets
-    // });
-    let fileResult = babel.transformFileSync(sourcePath, babelOptions);
-    if (!fileResult)
-        throw errors_1.errors.compileError(sourcePath);
-    let ast = fileResult.ast;
-    if (!ast)
-        throw errors_1.errors.compileError(sourcePath);
-    new ImportPathRewrite(sourcePath, ast);
-    let r = babel.transformFromAstSync(ast, undefined, {
-        filename: sourcePath, plugins: babelOptions.plugins,
-        presets: babelOptions.presets, sourceMaps: babelOptions.sourceMaps
-    });
-    if (!r || r.code == null)
-        throw errors_1.errors.compileError(sourcePath);
-    let ext = extname(sourcePath);
-    let outExt = fileOutExt(sourcePath);
-    let targetPath = path.join(outputPath, path.basename(sourcePath).replace(ext, outExt)); //sourcePath.replace(new RegExp(ext + "$"), outExt).replace(path.dirname(sourcePath), outDir);
-    let outDirPath = path.resolve(targetPath, "..");
-    let mapPath = targetPath + ".map";
-    if (r.map) {
-        r.map.file = path.basename(targetPath);
-        r.map.sources = [path.relative(outputPath, sourcePath)];
-        if (!fs.existsSync(outDirPath))
-            fs.mkdirSync(outDirPath, { recursive: true });
-        fs.writeFileSync(mapPath, JSON.stringify(r.map));
-        r.code += `\n//babel file path = ${bablePath}`;
-        r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
-    }
-    else if (fs.existsSync(mapPath)) {
-        fs.rmSync(targetPath);
-    }
-    if (!fs.existsSync(outDirPath))
-        fs.mkdirSync(outDirPath, { recursive: true });
-    fs.writeFileSync(targetPath, r.code);
-}
-function extname(file) {
-    // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
-    let ext = path.extname(file);
-    return ext;
-}
-/**
- * 获取源文件所对应生成文件的扩展名
- * @param file 源文件名
- * */
-function fileOutExt(file) {
-    let ext = extname(file);
-    if (ext === ".ts")
-        return outExt;
-    if (ext === ".tsx")
-        return outExt;
-    return ext;
-}
-class ImportPathRewrite {
-    filePath;
-    constructor(filePath, node) {
-        this.filePath = filePath;
-        this.traverse(node);
-    }
-    traverse(node) {
-        switch (node.type) {
-            case "Program":
-                node.body.forEach(c => this.traverse(c));
-                break;
-            case "File":
-                this.traverse(node.program);
-                break;
-            case "ImportDeclaration":
-                if (node.source.type === "StringLiteral" && node.source.value.startsWith(".")) {
-                    let ext = extname(node.source.value);
-                    if (ext != outExt) {
-                        let dir = path.dirname(this.filePath);
-                        let fullPath = path.join(dir, node.source.value);
-                        console.log(`ImportDeclaration: ${fullPath} -> ${ext}`);
-                        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
-                            node.source.value = node.source.value + "/index";
-                        }
-                        node.source.value += outExt;
-                    }
-                }
-                break;
-        }
-    }
-}