maishu-scripts 1.4.1 → 1.4.2

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,7 +128,7 @@ function generateCodeByOptions(options) {
             console.log(`Skip ${filePath}`);
             continue;
         }
-        let action = fileActions?.(filePath) || configs_1.default.fileActions[ext];
+        let action = fileActions?.(filePath) || configs_1.default.fileActions[ext] || defaultAction;
         if (action) {
             action(filePath, outDir, projectPath);
             if (callback) {
@@ -139,12 +141,14 @@ 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.replace(/\\/g, "/");
         sourceDir = sourceDir.replace(/\\/g, "/");
@@ -159,7 +163,7 @@ 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;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.4.1",
+    "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/compile.test.ts

@@ -1,189 +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");
-        filePath = filePath.replace(/\\/g, "/");
-        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,7 +120,7 @@ function generateCodeByOptions(options: Options) {
             continue;
         }
 
-        let action = fileActions?.(filePath) || configs.fileActions[ext];
+        let action = fileActions?.(filePath) || configs.fileActions[ext] || defaultAction;
         if (action) {
             action(filePath, outDir, projectPath);
             if (callback) {
@@ -130,15 +134,18 @@ 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, name) => {
+    watch(sourceDir, { recursive: true }, async (evt: "update" | "remove", name: string) => {
         const filePath = name.replace(/\\/g, "/");
         sourceDir = sourceDir.replace(/\\/g, "/");
         outDir = outDir.replace(/\\/g, "/");
@@ -155,7 +162,7 @@ function watchDirectoryByOptions(options: Options) {
             return;
         }
 
-        let action = fileActions?.(filePath) || configs.fileActions[ext];
+        let action = fileActions?.(filePath) || configs.fileActions[ext] || defaultAction;
         if (!action) {
             return;
         }

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;
-        }
-    }
-}