maishu-scripts 1.3.0 → 1.4.0

package/out/modules/import-path-rewrite.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportPathRewrite = void 0;
 const path = __importStar(require("path"));

package/out/modules/project-compiler.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectCompiler = void 0;
 const errors_1 = require("./errors");

package/out/types.d.ts

@@ -0,0 +1 @@
+export type FileAction = (filePath: string, outPath: string, projectPath: string) => void;

package/out/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.3.0",
+    "version": "1.4.0",
     "description": "用于对 node 项目进行代码生成，打包，运行",
     "dependencies": {
         "@babel/core": "^7.24.3",
@@ -8,13 +8,14 @@
         "@babel/plugin-transform-react-jsx": "^7.23.4",
         "@babel/plugin-transform-typescript": "^7.24.1",
         "@types/node": "^20.12.2",
+        "@types/react": "^19.2.8",
         "babel-plugin-transform-typescript-metadata": "^0.3.2",
         "less": "^4.5.1",
         "maishu-toolkit": "^1.12.6",
         "node-watch": "^0.7.4",
         "nodemon": "^3.1.4",
         "sass": "^1.97.1",
-        "typescript": "^5.4.5"
+        "typescript": "^5.9.3"
     },
     "devDependencies": {
         "@babel/preset-env": "^7.24.3",

package/src/index.ts

@@ -1,5 +1,9 @@
+import _config from "./modules/configs";
+import copyFile from "./modules/actions/copy-file";
 export { generateCode, watchDirectory } from "./modules/compile";
 export { run } from "./modules/run";
-// let sourceDir = "src";
-// let outDir = "out";
-// generateCode(sourceDir, outDir);
+export const options = _config;
+export { create as createTsCompiler } from "./modules/actions/ts-compile";
+export { create as createBielCompiler } from "./modules/actions/babel-compile";
+export { copyFile };
+export { FileAction } from "./types";

package/src/modules/actions/{biel-compile.ts → babel-compile.ts}

@@ -4,16 +4,42 @@ import * as fs from "fs";
 import * as path from "path";
 import { errors } from "../errors";
 import { ProjectCompiler } from "../project-compiler";
+import { FileAction } from "../../types";
 
 const outExt = ProjectCompiler.tsOutExt;
 
+
+export function create(babelOptions?: babel.TransformOptions): 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;
+        }
+
+        return compileFile(sourcePath, outputPath, projectPath, babelOptions);
+    }
+    return action;
+}
+
 /** 
  * 编译特定文件，并生成到制定目录 
  * @param sourcePath 源文件路径
  * @param outputPath 输出目录
  * @param projectPath 项目路径
  * */
-export async function compileFile(sourcePath: string, outputPath: string, projectPath: string) {
+async function compileFile(sourcePath: string, outputPath: string, projectPath: string, babelOptions: babel.TransformOptions) {
     if (!sourcePath) throw errors.argumentNull("sourcePath");
     if (!outputPath) throw errors.argumentNull("outputPath");
     if (!projectPath) throw errors.argumentNull("projectPath");
@@ -25,23 +51,23 @@ export async function compileFile(sourcePath: string, outputPath: string, projec
     }
 
     let sourceDir = path.dirname(sourcePath);
-    let babelOptions: babel.TransformOptions;
+    // let babelOptions: babel.TransformOptions;
     let bablePath: string;
     //= projectPath ?
     //  ProjectCompiler.getBabelConfig(projectPath, sourceDir) : ProjectCompiler.getDefaultBabelConfig();
     if (projectPath) {
-        let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
-        bablePath = c.path;
-        babelOptions = c.options;
+        //     let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
+        //     bablePath = c.path;
+        //     babelOptions = c.options;
     }
     else {
-        babelOptions = ProjectCompiler.getDefaultBabelConfig();
-        bablePath = '';
+        //     babelOptions = ProjectCompiler.getDefaultBabelConfig();
+        //     bablePath = '';
     }
 
-    babelOptions.filename = sourcePath;
-    babelOptions.code = false;
-    babelOptions.ast = true;
+    // babelOptions.filename = sourcePath;
+    // babelOptions.code = false;
+    // babelOptions.ast = true;
 
 
     // let fileResult = babel.transformFileSync(sourcePath, {
@@ -78,7 +104,7 @@ export async function compileFile(sourcePath: string, outputPath: string, projec
             fs.mkdirSync(outDirPath, { recursive: true });
 
         fs.writeFileSync(mapPath, JSON.stringify(r.map));
-        r.code += `\n//babel file path = ${bablePath}`;
+        // r.code += `\n//babel file path = ${bablePath}`;
         r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
     }
     else if (fs.existsSync(mapPath)) {

package/src/modules/actions/copy-file.ts

@@ -3,7 +3,7 @@ import { errors } from "../errors";
 import * as fs from "fs";
 import * as path from "path";
 
-let copyFile: FileAction = (filePath: string, outPath: string, projectPath: string) => {
+let copyFile: FileAction = (filePath: string, outPath: string) => {
     if (!filePath) throw errors.argumentNull("filePath");
     if (!outPath) throw errors.argumentNull("outPath");
 

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

@@ -1,6 +1,7 @@
-import { compileFile, findTypeScriptConfigPath, getTypescriptConfig } from './ts-compile';
+import { create as createCompiler, findTypeScriptConfigPath, getTypescriptConfig } from './ts-compile';
 import * as path from 'path';
 import * as fs from 'fs';
+import ts from 'typescript';
 
 describe('ts-compile', () => {
 
@@ -18,7 +19,8 @@ describe('ts-compile', () => {
             fs.rmSync(jsFile, { recursive: true, force: true });
         }
 
-        await compileFile(tsFile, outDir, projectPath);
+        const compileFile = createCompiler();
+        compileFile(tsFile, outDir, projectPath);
         expect(fs.existsSync(jsFile));
     })
 
@@ -36,4 +38,30 @@ describe('ts-compile', () => {
         expect(scriptPath).toBe(findTypeScriptConfigPath(projectPath, "src/static"));
 
     })
+
+    test("should get typescript config", function () {
+        let config = getTypescriptConfig(projectPath, "src/static/design");
+        expect(config).not.toBeNull();
+        expect(config).not.toBeUndefined();
+    })
+
+    test("create 带 compilerOptions 参数", function () {
+        const outDir = "dist";
+        let compilerOptions: ts.CompilerOptions = {
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.ESNext,
+        };
+        let compileFile = createCompiler(compilerOptions);
+        expect(compileFile).not.toBeNull();
+        expect(compileFile).not.toBeUndefined();
+
+        let tsFile = path.join(__dirname, '..', '..', '..', 'test', 'src', 'main.ts');
+        const fileOutPath = path.join(projectPath, outDir, "main.js");
+        fs.rmSync(fileOutPath, { force: true });
+
+        expect(fs.existsSync(tsFile)).toBeTruthy();
+        compileFile(tsFile, outDir, projectPath);
+
+        expect(fs.existsSync(fileOutPath)).toBeTruthy();
+    })
 });

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

@@ -3,6 +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';
 
 const TS_CONFIG_FILE = 'tsconfig.json';
 
@@ -10,13 +11,24 @@ type TypeScriptProjectConfig = {
     compilerOptions: ts.CompilerOptions;
 }
 
+export function create(compilerOptions?: ts.CompilerOptions): FileAction {
+    const action: FileAction = async (filePath: string, outDir: string, projectPath: string) => {
+        if (!compilerOptions) {
+            compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+        }
+        return compileFile(filePath, outDir, projectPath, compilerOptions)
+    }
+
+    return action;
+}
+
 /** 
  * 编译特定文件，并生成到制定目录 
  * @param filePath 源文件路径，绝对路径
  * @param outDir 输出目录，相对于项目路径
  * @param projectPath 项目路径，绝对路径
  * */
-export async function compileFile(filePath: string, outDir: string, projectPath: string) {
+async function compileFile(filePath: string, outDir: string, projectPath: string, compilerOptions: ts.CompilerOptions) {
     if (!filePath)
         throw errors.argumentNull('sourcePath');
     if (!outDir)
@@ -24,16 +36,11 @@ export async function compileFile(filePath: string, outDir: string, projectPath:
     if (!projectPath)
         throw errors.argumentNull('projectPath');
 
-    if (!path.isAbsolute(filePath))
-        throw errors.notAbsolutePath(filePath);
-
 
     let content = fs.readFileSync(filePath, 'utf-8');
-    let compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+    // let compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
     let result = ts.transpileModule(content, { compilerOptions });
 
-    console.log(result.outputText);
-
     let ext = path.extname(filePath);
     let outExt = ProjectCompiler.tsOutExt;
     let targetPath = path.join(projectPath, outDir, path.basename(filePath).replace(ext, outExt));
@@ -43,6 +50,14 @@ export async function compileFile(filePath: string, outDir: string, projectPath:
         fs.mkdirSync(outDirPath, { recursive: true });
 
     fs.writeFileSync(targetPath, result.outputText);
+
+    // 编译声明文件
+    if (compilerOptions.declaration && result.outputText) {
+        const d = ts.transpileDeclaration(content, { compilerOptions });
+        const declPath = targetPath.replace(outExt, '.d.ts');
+        fs.writeFileSync(declPath, d.outputText);
+    }
+
 }
 
 export function getTypescriptConfig(projectPath: string, directoryPath: string): ts.CompilerOptions {

package/src/modules/compile.test.ts

@@ -1,11 +1,13 @@
-import { generateCode, isIgnoredFile } from "./compile";
+import { generateCode, isIgnoredFile, watchDirectory } from "./compile";
 import * as path from "path";
 import * as fs from "fs";
-import * as ts from "typescript";
+import { create as createTsCompiler } from "../modules/actions/ts-compile";
+import ts from "typescript";
+import { FileAction } from "../types";
 
 describe("Compile Test", function () {
 
-    it("copyFile test", function () {
+    test("copyFile test", function () {
 
         let srcPath = "test/src";
         let srcExists = fs.existsSync(srcPath);
@@ -24,10 +26,163 @@ describe("Compile Test", function () {
         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);
+
+
+    })
+
 })