maishu-scripts 1.4.1 → 1.4.5

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/src/modules/configs.ts

@@ -2,8 +2,7 @@ import { FileAction } from "../types";
 import scssCompile from "./actions/scss-compile";
 import lessCompile from "./actions/less-compile";
 import { create as createBielCompiler } from "./actions/babel-compile";
-import { create as createTsCompiler } from "./actions/ts-compile";
-import ts from "typescript";
+import copyFile from "./actions/copy-file";
 
 // const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
 
@@ -12,9 +11,10 @@ const fileActions: Record<string, FileAction> = {
     ".tsx": createBielCompiler(),
     ".scss": scssCompile,
     ".less": lessCompile,
+    ".map": copyFile,
 }
 
-class Options {
+export class Config {
     fileActions: Record<string, FileAction> = fileActions;
     skipFiles: Record<string, RegExp[]> = {
         ".tsx": [/\.d\.tsx?$/, /\.test\.tsx?$/, /\.spec\.tsx?$/],
@@ -24,6 +24,5 @@ class Options {
     };
 }
 
-const NAME = "maishu-scripts-options";
-(global as any)[NAME] = (global as any)[NAME] || new Options();
-export default (global as any)[NAME] as Options;
+const config = new Config();
+export default config;

package/src/modules/errors.ts

@@ -21,6 +21,14 @@ class Errors extends BaseErrors {
         error.name = Errors.prototype.invalidBabelConfigExtension.name;
         return error;
     }
+    copyFileError(sourcePath: string, destPath: string, innerError?: Error) {
+        let error = new Error(`Failed to copy file from "${sourcePath}" to "${destPath}"`);
+        error.name = Errors.prototype.copyFileError.name;
+        if (innerError) {
+            error.cause = innerError;
+        }
+        return error;
+    }
 }
 
 export const errors = new Errors();