maishu-scripts 1.0.0 → 1.1.2

package/out/index.d.ts

@@ -0,0 +1,2 @@
+export { generateCode, watchDirectory } from "./modules/compile";
+export { run } from "./modules/run";

package/out/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.watchDirectory = exports.generateCode = void 0;
+var compile_1 = require("./modules/compile");
+Object.defineProperty(exports, "generateCode", { enumerable: true, get: function () { return compile_1.generateCode; } });
+Object.defineProperty(exports, "watchDirectory", { enumerable: true, get: function () { return compile_1.watchDirectory; } });
+var run_1 = require("./modules/run");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return run_1.run; } });
+// let sourceDir = "src";
+// let outDir = "out";
+// generateCode(sourceDir, outDir);

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

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

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFile = void 0;
+const babel = require("@babel/core");
+const fs = require("fs");
+const path = require("path");
+const errors_1 = require("../errors");
+const project_compiler_1 = require("../project-compiler");
+const outExt = project_compiler_1.ProjectCompiler.tsOutExt;
+/**
+ * 编译特定文件，并生成到制定目录
+ * @param sourcePath 源文件路径
+ * @param outDir 输出目录
+ * @param projectPath 项目路径
+ * */
+async function compileFile(sourcePath, outDir, projectPath) {
+    if (!sourcePath)
+        throw errors_1.errors.argumentNull("sourcePath");
+    if (!outDir)
+        throw errors_1.errors.argumentNull("outDir");
+    // 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: true
+    });
+    if (!r || r.code == null)
+        throw errors_1.errors.compileError(sourcePath);
+    let ext = extname(sourcePath);
+    let outExt = fileOutExt(sourcePath);
+    let targetPath = path.join(outDir, path.basename(sourcePath).replace(ext, outExt)); //sourcePath.replace(new RegExp(ext + "$"), outExt).replace(path.dirname(sourcePath), outDir);
+    let outDirPath = path.resolve(targetPath, "..");
+    if (r.map) {
+        r.map.file = path.basename(targetPath);
+        let sources = r.map.sources || [];
+        let sourceDir = path.dirname(sourcePath);
+        sources.forEach((s, i) => {
+            sources[i] = path.relative(outDirPath, path.join(sourceDir, s));
+        });
+        r.map.sources = sources;
+        let mapPath = targetPath + ".map";
+        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);
+    }
+    if (!fs.existsSync(outDirPath))
+        fs.mkdirSync(outDirPath, { recursive: true });
+    fs.writeFileSync(targetPath, r.code);
+}
+exports.compileFile = compileFile;
+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;
+        }
+    }
+}

package/out/modules/compile.d.ts

@@ -0,0 +1,6 @@
+/** 将 sourceDir 目录下所有文件生成到 outDir */
+export declare function generateCode(sourceDir: string, outDir: string, projectPath?: string): void;
+/** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
+export declare function watchDirectory(sourceRoot: string, outRoot: string, projectPath?: string): void;
+export declare function copyFile(filePath: string, outDir: string): void;
+export declare function isIgnoredFile(filePath: string): boolean;

package/out/modules/compile.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIgnoredFile = exports.copyFile = exports.watchDirectory = exports.generateCode = void 0;
+const fs = require("fs");
+const node_watch_1 = require("node-watch");
+const path = require("path");
+const errors_1 = require("./errors");
+const biel_compile_1 = require("./compile/biel-compile");
+const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"];
+const outExt = ".js";
+let fileActions = {
+    ".ts": biel_compile_1.compileFile,
+    ".tsx": biel_compile_1.compileFile,
+};
+/** 将 sourceDir 目录下所有文件生成到 outDir */
+function generateCode(sourceDir, outDir, projectPath) {
+    if (!sourceDir)
+        throw errors_1.errors.argumentNull("sourceDir");
+    if (!outDir)
+        throw errors_1.errors.argumentNull("outDir");
+    if (!fs.existsSync(sourceDir))
+        throw errors_1.errors.pathNotExists(sourceDir);
+    let files = fs.readdirSync(sourceDir);
+    for (let file of files) {
+        let filePath = path.join(sourceDir, file);
+        if (!fs.statSync(filePath).isFile()) {
+            continue;
+        }
+        let isSkip = isIgnoredFile(filePath); //skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+        if (isSkip) {
+            console.log(`Skip ${filePath}`);
+            continue;
+        }
+        let ext = extname(file);
+        let action = fileActions[ext];
+        if (action) {
+            action(filePath, outDir, projectPath);
+        }
+    }
+    let dirs = fs.readdirSync(sourceDir);
+    for (let dir of dirs) {
+        let fullPath = path.join(sourceDir, dir);
+        let outDirPath = path.join(outDir, dir);
+        if (fs.statSync(fullPath).isDirectory()) {
+            generateCode(fullPath, outDirPath, projectPath);
+        }
+    }
+}
+exports.generateCode = generateCode;
+/** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
+function watchDirectory(sourceRoot, outRoot, projectPath) {
+    (0, node_watch_1.default)(sourceRoot, { recursive: true }, async (evt, name) => {
+        let action = fileActions[extname(name)];
+        let outPath = path.dirname(name).replace(sourceRoot, outRoot);
+        if (action) {
+            action(name, outPath, projectPath);
+        }
+    });
+}
+exports.watchDirectory = watchDirectory;
+function copyFile(filePath, outDir) {
+    if (!filePath)
+        throw errors_1.errors.argumentNull("filePath");
+    if (!outDir)
+        throw errors_1.errors.argumentNull("outDir");
+    let out = filePath.replace(path.dirname(filePath), outDir);
+    let outDirPath = path.resolve(out, "..");
+    fs.mkdirSync(outDirPath, { recursive: true });
+    fs.copyFileSync(filePath, out);
+}
+exports.copyFile = copyFile;
+function isIgnoredFile(filePath) {
+    if (!filePath)
+        throw errors_1.errors.argumentNull("filePath");
+    let isSkip = skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+    return isSkip;
+}
+exports.isIgnoredFile = isIgnoredFile;
+function extname(file) {
+    // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
+    let ext = path.extname(file);
+    return ext;
+}

package/out/modules/errors.d.ts

@@ -0,0 +1,9 @@
+import { Errors as BaseErrors } from "maishu-toolkit/out/errors";
+declare class Errors extends BaseErrors {
+    compileError(filePath: string): Error;
+    pathNotExists(path: string): Error;
+    notAbsolutePath(path: string): Error;
+    invalidBabelConfigExtension(extension: string, configPath: string): Error;
+}
+export declare const errors: Errors;
+export {};

package/out/modules/errors.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = void 0;
+const errors_1 = require("maishu-toolkit/out/errors");
+class Errors extends errors_1.Errors {
+    compileError(filePath) {
+        let error = new Error(`Compile error in file: ${filePath}`);
+        error.name = Errors.prototype.compileError.name;
+        return error;
+    }
+    pathNotExists(path) {
+        let error = new Error(`Path not exists: ${path}`);
+        error.name = Errors.prototype.pathNotExists.name;
+        return error;
+    }
+    notAbsolutePath(path) {
+        let error = new Error(`Path is not absolute: ${path}`);
+        error.name = Errors.prototype.notAbsolutePath.name;
+        return error;
+    }
+    invalidBabelConfigExtension(extension, configPath) {
+        let error = new Error(`Invalid babel config file extension: ${extension}, babel config file path: ${configPath}.`);
+        error.name = Errors.prototype.invalidBabelConfigExtension.name;
+        return error;
+    }
+}
+exports.errors = new Errors();

package/out/modules/import-path-rewrite.d.ts

@@ -0,0 +1,7 @@
+export declare class ImportPathRewrite {
+    private filePath;
+    private outExt;
+    constructor(filePath: string, node: babel.types.File, outExt: string);
+    private traverse;
+    private extname;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportPathRewrite = void 0;
+const path = require("path");
+const fs = require("fs");
+// const outExt = ".js";
+class ImportPathRewrite {
+    filePath;
+    outExt;
+    constructor(filePath, node, outExt) {
+        this.filePath = filePath;
+        this.outExt = outExt;
+        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 = this.extname(node.source.value);
+                    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 += this.outExt;
+                    }
+                }
+                break;
+        }
+    }
+    extname(file) {
+        // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
+        let ext = path.extname(file);
+        return ext;
+    }
+}
+exports.ImportPathRewrite = ImportPathRewrite;

package/out/modules/project-compiler.d.ts

@@ -0,0 +1,34 @@
+import * as babel from "@babel/core";
+export declare class ProjectCompiler {
+    private projectPath;
+    private sourceDirectoryNanme;
+    private outputDirectoryName;
+    private fileActions;
+    private skipFiles;
+    static tsOutExt: string;
+    constructor(projectPath: string, sourceDirectoryNanme: string, outputDirectoryName: string);
+    /**
+      * 编译特定文件，并生成到制定目录
+      * @param sourcePath 源文件路径
+      * @param outDir 输出目录
+      * */
+    compileFile(filePath: string, outDir: string): Promise<void>;
+    private compileTypeScriptFileByBabel;
+    static loadBabelConfig(configPath: string): babel.TransformOptions;
+    static findBabelConfigPath(projectPath: string, directoryPath: string): string | null;
+    static getBabelConfig(projectPath: string, directoryPath: string): {
+        options: babel.TransformOptions;
+        path: string;
+    };
+    static getDefaultBabelConfig(): babel.TransformOptions;
+    /**
+     * 获取源文件所对应生成文件的扩展名
+     * @param file 源文件名
+     * */
+    private fileOutExt;
+    private isIgnoredFile;
+    generateCode(): void;
+    generateCode(sourceDir: string, outDir: string): void;
+    watchDirectory(): void;
+    run(): void;
+}

package/out/modules/project-compiler.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectCompiler = void 0;
+const nodemon = require("nodemon");
+const errors_1 = require("./errors");
+const fs = require("fs");
+const path = require("path");
+const babel = require("@babel/core");
+const import_path_rewrite_1 = require("./import-path-rewrite");
+const node_watch_1 = require("node-watch");
+const tsOutExt = ".js";
+class ProjectCompiler {
+    projectPath;
+    sourceDirectoryNanme;
+    outputDirectoryName;
+    fileActions;
+    skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"];
+    static tsOutExt = tsOutExt;
+    constructor(projectPath, sourceDirectoryNanme, outputDirectoryName) {
+        this.projectPath = projectPath;
+        this.sourceDirectoryNanme = sourceDirectoryNanme;
+        this.outputDirectoryName = outputDirectoryName;
+        if (!projectPath)
+            throw errors_1.errors.argumentNull("projectPath");
+        if (!sourceDirectoryNanme)
+            throw errors_1.errors.argumentNull("sourceDirectoryNanme");
+        if (!outputDirectoryName)
+            throw errors_1.errors.argumentNull("outputDirectoryName");
+        if (!path.isAbsolute(projectPath))
+            throw errors_1.errors.notAbsolutePath(projectPath);
+        let sourcePath = path.join(projectPath, sourceDirectoryNanme);
+        if (!fs.existsSync(sourcePath))
+            throw errors_1.errors.pathNotExists(sourcePath);
+        this.fileActions = {
+            ".ts": this.compileFile.bind(this),
+            ".tsx": this.compileFile.bind(this),
+        };
+    }
+    /**
+      * 编译特定文件，并生成到制定目录
+      * @param sourcePath 源文件路径
+      * @param outDir 输出目录
+      * */
+    async compileFile(filePath, outDir) {
+        this.compileTypeScriptFileByBabel(filePath, outDir);
+    }
+    async compileTypeScriptFileByBabel(sourcePath, outDir) {
+        if (!sourcePath)
+            throw errors_1.errors.argumentNull("sourcePath");
+        if (!outDir)
+            throw errors_1.errors.argumentNull("outDir");
+        if (!fs.existsSync(sourcePath))
+            throw errors_1.errors.pathNotExists(sourcePath);
+        let sourceDir = path.dirname(sourcePath);
+        let babelConfig = ProjectCompiler.getBabelConfig(this.projectPath, sourceDir);
+        let babelOptions = babelConfig.options;
+        let babelPath = babelConfig.path;
+        babelOptions.filename = sourcePath;
+        babelOptions.code = false;
+        babelOptions.ast = true;
+        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 import_path_rewrite_1.ImportPathRewrite(sourcePath, ast, tsOutExt);
+        let r = babel.transformFromAstSync(ast, undefined, {
+            filename: sourcePath, plugins: babelOptions.plugins,
+            presets: babelOptions.presets, sourceMaps: true
+        });
+        if (!r || r.code == null)
+            throw errors_1.errors.compileError(sourcePath);
+        let ext = path.extname(sourcePath);
+        let outExt = this.fileOutExt(sourcePath);
+        let targetPath = path.join(outDir, path.basename(sourcePath).replace(ext, outExt));
+        let outDirPath = path.resolve(targetPath, "..");
+        if (r.map) {
+            r.map.file = path.basename(targetPath);
+            let sources = r.map.sources || [];
+            let sourceDir = path.dirname(sourcePath);
+            sources.forEach((s, i) => {
+                sources[i] = path.relative(outDirPath, path.join(sourceDir, s));
+            });
+            r.map.sources = sources;
+            let mapPath = targetPath + ".map";
+            if (!fs.existsSync(outDirPath))
+                fs.mkdirSync(outDirPath, { recursive: true });
+            fs.writeFileSync(mapPath, JSON.stringify(r.map));
+            r.code += `\n//babelPath:${babelPath}`;
+            r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
+        }
+        if (!fs.existsSync(outDirPath))
+            fs.mkdirSync(outDirPath, { recursive: true });
+        fs.writeFileSync(targetPath, r.code);
+    }
+    static loadBabelConfig(configPath) {
+        if (!configPath)
+            throw errors_1.errors.argumentNull("configPath");
+        if (!fs.existsSync(configPath))
+            throw errors_1.errors.pathNotExists(configPath);
+        let ext = path.extname(configPath);
+        if (ext === ".json") {
+            let content = fs.readFileSync(configPath, "utf-8");
+            return JSON.parse(content);
+        }
+        if (ext === ".js") {
+            let module = require(configPath);
+            let config = Object.assign({}, module.default || module);
+            return config;
+        }
+        throw errors_1.errors.invalidBabelConfigExtension(ext, configPath);
+    }
+    static findBabelConfigPath(projectPath, directoryPath) {
+        if (!path.isAbsolute(directoryPath)) {
+            directoryPath = path.join(projectPath, directoryPath);
+        }
+        console.assert(path.isAbsolute(projectPath), `projectPath ${projectPath} is not absolute`);
+        console.assert(path.isAbsolute(directoryPath), `directoryPath ${directoryPath} is not absolute`);
+        let jsonConfigPath = path.join(directoryPath, "babel.config.json");
+        let jsConfigPath = path.join(directoryPath, "babel.config.js");
+        if (fs.existsSync(jsConfigPath)) {
+            return jsConfigPath;
+        }
+        if (fs.existsSync(jsonConfigPath)) {
+            return jsonConfigPath;
+        }
+        if (projectPath == directoryPath)
+            return null;
+        let parentPath = path.resolve(directoryPath, "..");
+        return this.findBabelConfigPath(projectPath, parentPath);
+    }
+    static getBabelConfig(projectPath, directoryPath) {
+        let configPath = this.findBabelConfigPath(projectPath, directoryPath);
+        let babelOptions;
+        if (configPath) {
+            babelOptions = this.loadBabelConfig(configPath);
+        }
+        else {
+            babelOptions = this.getDefaultBabelConfig();
+        }
+        babelOptions.ast = true;
+        babelOptions.code = false;
+        return { options: babelOptions, path: configPath || '' };
+    }
+    static getDefaultBabelConfig() {
+        let plugins = [
+            "babel-plugin-transform-typescript-metadata",
+            ["@babel/plugin-proposal-decorators", { legacy: true }],
+            ["@babel/plugin-transform-typescript", { isTSX: true }],
+            ["@babel/plugin-transform-react-jsx", { "pragma": "React.createElement", "pragmaFrag": "React.Fragment" }],
+        ];
+        let presets = [
+            ['@babel/preset-env', { targets: { node: 'current' } }],
+        ];
+        let babelOptions = { plugins, presets };
+        return babelOptions;
+    }
+    /**
+     * 获取源文件所对应生成文件的扩展名
+     * @param file 源文件名
+     * */
+    fileOutExt(file) {
+        let ext = path.extname(file);
+        if (ext === ".ts")
+            return tsOutExt;
+        if (ext === ".tsx")
+            return tsOutExt;
+        return ext;
+    }
+    isIgnoredFile(filePath) {
+        if (!filePath)
+            throw errors_1.errors.argumentNull("filePath");
+        let isSkip = this.skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+        return isSkip;
+    }
+    generateCode(sourceDir, outDir) {
+        // if (!sourceDir) throw errors.argumentNull("sourceDir");
+        // if (!outDir) throw errors.argumentNull("outDir");
+        if (!sourceDir)
+            sourceDir = path.join(this.projectPath, this.sourceDirectoryNanme);
+        if (!outDir)
+            outDir = path.join(this.projectPath, this.outputDirectoryName);
+        let fileActions = this.fileActions;
+        if (!fs.existsSync(sourceDir))
+            throw errors_1.errors.pathNotExists(sourceDir);
+        let files = fs.readdirSync(sourceDir);
+        for (let file of files) {
+            let filePath = path.join(sourceDir, file);
+            if (!fs.statSync(filePath).isFile()) {
+                continue;
+            }
+            let isSkip = this.isIgnoredFile(filePath); //skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+            if (isSkip) {
+                console.log(`Skip ${filePath}`);
+                continue;
+            }
+            let ext = path.extname(file);
+            let action = fileActions[ext];
+            if (action) {
+                action(filePath, outDir);
+            }
+        }
+        let dirs = fs.readdirSync(sourceDir);
+        for (let dir of dirs) {
+            let fullPath = path.join(sourceDir, dir);
+            let outDirPath = path.join(outDir, dir);
+            if (fs.statSync(fullPath).isDirectory()) {
+                this.generateCode(fullPath, outDirPath);
+            }
+        }
+    }
+    watchDirectory() {
+        (0, node_watch_1.default)(this.sourceDirectoryNanme, { recursive: true }, async (evt, name) => {
+            let action = this.fileActions[path.extname(name)];
+            let outPath = path.dirname(name).replace(this.sourceDirectoryNanme, this.outputDirectoryName);
+            if (action) {
+                action(name, outPath);
+            }
+        });
+    }
+    run() {
+        nodemon({
+            script: `./${this.outputDirectoryName}/main.js`,
+            watch: [`./${this.outputDirectoryName}/`],
+        });
+    }
+}
+exports.ProjectCompiler = ProjectCompiler;

package/out/modules/run.d.ts

@@ -0,0 +1 @@
+export declare function run(): void;

package/out/modules/run.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const nodemon = require("nodemon");
+function run() {
+    nodemon({
+        script: "./out/main.js",
+        watch: ["./out/"],
+    });
+}
+exports.run = run;

package/out/start.d.ts

@@ -0,0 +1 @@
+export {};

package/out/start.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("./modules/compile");
+const run_1 = require("./modules/run");
+let sourceDir = "src";
+let outDir = "out";
+(0, compile_1.generateCode)(sourceDir, outDir);
+(0, compile_1.watchDirectory)(sourceDir, outDir);
+(0, run_1.run)();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.0.0",
+    "version": "1.1.2",
     "description": "用于对 node 项目进行代码生成，打包，运行",
     "dependencies": {
         "@babel/core": "^7.24.3",
@@ -20,5 +20,10 @@
         "@types/babel__core": "^7.20.5",
         "@types/jest": "^29.5.12",
         "jest": "^29.7.0"
-    }
-}
+    },
+    "main": "./out/index.js",
+    "files": [
+        "out",
+        "src"
+    ]
+}

package/{index.ts → src/index.ts}

@@ -1,5 +1,5 @@
 export { generateCode, watchDirectory } from "./modules/compile";
-
+export { run } from "./modules/run";
 // let sourceDir = "src";
 // let outDir = "out";
 // generateCode(sourceDir, outDir);

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

@@ -1,73 +1,17 @@
+
 import * as babel from "@babel/core";
 import * as fs from "fs";
-import watch from "node-watch";
 import * as path from "path";
-import { errors } from "./errors";
-import { ProjectCompiler } from "./project-compiler";
-
-const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
-const outExt = ".js";
-
-type FileAction = (filePath: string, outDir: string, projectPath?: string) => void;
-let fileActions: { [ext: string]: FileAction } = {
-    ".ts": compileFile,
-    ".tsx": compileFile,
-}
-
-/** 将 sourceDir 目录下所有文件生成到 outDir */
-export function generateCode(sourceDir: string, outDir: string, projectPath?: string) {
-
-    if (!sourceDir) throw errors.argumentNull("sourceDir");
-    if (!outDir) throw errors.argumentNull("outDir");
-
-    if (!fs.existsSync(sourceDir))
-        throw errors.pathNotExists(sourceDir);
-
-    let files = fs.readdirSync(sourceDir);
-    for (let file of files) {
-        let filePath = path.join(sourceDir, file);
-        if (!fs.statSync(filePath).isFile()) {
-            continue;
-        }
-
-        let isSkip = isIgnoredFile(filePath);//skipFiles.some(pattern => new RegExp(pattern).test(filePath));
-        if (isSkip) {
-            console.log(`Skip ${filePath}`);
-            continue;
-        }
-
-        let ext = extname(file);
-        let action = fileActions[ext];
-        if (action) {
-            action(filePath, outDir, projectPath);
-        }
-    }
-
-    let dirs = fs.readdirSync(sourceDir);
-    for (let dir of dirs) {
-        let fullPath = path.join(sourceDir, dir);
-        let outDirPath = path.join(outDir, dir);
-        if (fs.statSync(fullPath).isDirectory()) {
-            generateCode(fullPath, outDirPath, projectPath);
-        }
-    }
-}
+import { errors } from "../errors";
+import { ProjectCompiler } from "../project-compiler";
 
-/** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
-export function watchDirectory(sourceRoot: string, outRoot: string, projectPath?: string) {
-    watch(sourceRoot, { recursive: true }, async (evt, name) => {
-        let action = fileActions[extname(name)];
-        let outPath = path.dirname(name).replace(sourceRoot, outRoot);
-        if (action) {
-            action(name, outPath, projectPath);
-        }
-    })
-}
+const outExt = ProjectCompiler.tsOutExt;
 
 /** 
  * 编译特定文件，并生成到制定目录 
  * @param sourcePath 源文件路径
  * @param outDir 输出目录
+ * @param projectPath 项目路径
  * */
 export async function compileFile(sourcePath: string, outDir: string, projectPath?: string) {
     if (!sourcePath) throw errors.argumentNull("sourcePath");
@@ -147,25 +91,6 @@ export async function compileFile(sourcePath: string, outDir: string, projectPat
 
 }
 
-export function copyFile(filePath: string, outDir: string) {
-    if (!filePath) throw errors.argumentNull("filePath");
-    if (!outDir) throw errors.argumentNull("outDir");
-
-    let out = filePath.replace(path.dirname(filePath), outDir);
-    let outDirPath = path.resolve(out, "..");
-
-    fs.mkdirSync(outDirPath, { recursive: true });
-
-    fs.copyFileSync(filePath, out);
-}
-
-export function isIgnoredFile(filePath: string) {
-    if (!filePath) throw errors.argumentNull("filePath");
-
-    let isSkip = skipFiles.some(pattern => new RegExp(pattern).test(filePath));
-    return isSkip;
-}
-
 function extname(file: string) {
     // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
     let ext = path.extname(file);
@@ -187,6 +112,7 @@ function fileOutExt(file: string) {
     return ext;
 }
 
+
 class ImportPathRewrite {
     constructor(private filePath: string, node: babel.types.File) {
         this.traverse(node);
@@ -218,4 +144,4 @@ class ImportPathRewrite {
         }
     }
 
-}
+}

package/{modules → src/modules}/compile.test.ts

@@ -1,7 +1,7 @@
 import { copyFile, generateCode, isIgnoredFile } from "./compile";
 import * as path from "path";
 import * as fs from "fs";
-import ts from "typescript";
+import * as ts from "typescript";
 
 describe("Compile Test", function () {
 

package/src/modules/compile.ts

@@ -0,0 +1,92 @@
+import * as babel from "@babel/core";
+import * as fs from "fs";
+import watch from "node-watch";
+import * as path from "path";
+import { errors } from "./errors";
+import { ProjectCompiler } from "./project-compiler";
+import { compileFile as bielCompileFile } from "./compile/biel-compile";
+
+const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
+const outExt = ".js";
+
+type FileAction = (filePath: string, outDir: string, projectPath?: string) => void;
+let fileActions: { [ext: string]: FileAction } = {
+    ".ts": bielCompileFile,
+    ".tsx": bielCompileFile,
+}
+
+/** 将 sourceDir 目录下所有文件生成到 outDir */
+export function generateCode(sourceDir: string, outDir: string, projectPath?: string) {
+
+    if (!sourceDir) throw errors.argumentNull("sourceDir");
+    if (!outDir) throw errors.argumentNull("outDir");
+
+    if (!fs.existsSync(sourceDir))
+        throw errors.pathNotExists(sourceDir);
+
+    let files = fs.readdirSync(sourceDir);
+    for (let file of files) {
+        let filePath = path.join(sourceDir, file);
+        if (!fs.statSync(filePath).isFile()) {
+            continue;
+        }
+
+        let isSkip = isIgnoredFile(filePath);//skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+        if (isSkip) {
+            console.log(`Skip ${filePath}`);
+            continue;
+        }
+
+        let ext = extname(file);
+        let action = fileActions[ext];
+        if (action) {
+            action(filePath, outDir, projectPath);
+        }
+    }
+
+    let dirs = fs.readdirSync(sourceDir);
+    for (let dir of dirs) {
+        let fullPath = path.join(sourceDir, dir);
+        let outDirPath = path.join(outDir, dir);
+        if (fs.statSync(fullPath).isDirectory()) {
+            generateCode(fullPath, outDirPath, projectPath);
+        }
+    }
+}
+
+/** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
+export function watchDirectory(sourceRoot: string, outRoot: string, projectPath?: string) {
+    watch(sourceRoot, { recursive: true }, async (evt, name) => {
+        let action = fileActions[extname(name)];
+        let outPath = path.dirname(name).replace(sourceRoot, outRoot);
+        if (action) {
+            action(name, outPath, projectPath);
+        }
+    })
+}
+
+export function copyFile(filePath: string, outDir: string) {
+    if (!filePath) throw errors.argumentNull("filePath");
+    if (!outDir) throw errors.argumentNull("outDir");
+
+    let out = filePath.replace(path.dirname(filePath), outDir);
+    let outDirPath = path.resolve(out, "..");
+
+    fs.mkdirSync(outDirPath, { recursive: true });
+
+    fs.copyFileSync(filePath, out);
+}
+
+export function isIgnoredFile(filePath: string) {
+    if (!filePath) throw errors.argumentNull("filePath");
+
+    let isSkip = skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+    return isSkip;
+}
+
+function extname(file: string) {
+    // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
+    let ext = path.extname(file);
+    return ext;
+}
+

package/{modules → src/modules}/project-compiler.test.ts

@@ -1,5 +1,5 @@
-import path from "path";
-import fs from "fs";
+import * as path from "path";
+import * as fs from "fs";
 import { ProjectCompiler } from "./project-compiler";
 describe('project-compiler test', function () {
 

package/{modules → src/modules}/project-compiler.ts

@@ -15,6 +15,8 @@ export class ProjectCompiler {
     private fileActions: { [ext: string]: FileAction };
     private skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"];
 
+    static tsOutExt = tsOutExt;
+
     constructor(private projectPath: string, private sourceDirectoryNanme: string, private outputDirectoryName: string) {
         if (!projectPath) throw errors.argumentNull("projectPath");
         if (!sourceDirectoryNanme) throw errors.argumentNull("sourceDirectoryNanme");

package/babel.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-    presets: [
-        ['@babel/preset-env', { targets: { node: 'current' } }],
-        '@babel/preset-typescript',
-    ],
-};

package/test/package.json

@@ -1,7 +0,0 @@
-{
-    "name": "test-src",
-    "devDependencies": {
-        "@nestjs/common": "^10.3.7",
-        "express": "^4.19.2"
-    }
-}

package/test/src/app.controller.ts

@@ -1,14 +0,0 @@
-import { Controller, Get } from '@nestjs/common';
-import { AppService } from './app.service';
-
-@Controller()
-export class AppController {
-  constructor(private readonly appService: AppService) {}
-
-  @Get()
-  getHello(): string {
-    return this.appService.getHello();
-  }
-
-  
-}

package/test/src/app.module.ts

@@ -1,17 +0,0 @@
-import { MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
-import { ProxyMiddleware } from './middleware/proxy';
-import { ProxyController } from './controllers/proxy';
-
-@Module({
-  imports: [],
-  controllers: [AppController],
-  providers: [AppService],
-})
-export class AppModule implements NestModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(ProxyMiddleware)
-      .forRoutes({ path: "proxy/*", method: RequestMethod.GET });
-  }
-}

package/test/src/app.service.ts

@@ -1,8 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class AppService {
-  getHello(): string {
-    return 'Hello World!';
-  }
-}

package/test/src/config.ts

@@ -1,16 +0,0 @@
-//const config = require("../config.js").default as Config;
-import config from "../config.mjs";
-
-export interface Config {
-    plmUrl: string,
-}
-
-// TODO: 校验配置项是否正确
-if (!config || !config.plmUrl)
-    throw new Error("plmUrl is required in config.js");
-
-
-
-export function getConfig(): Config {
-    return config;
-}

package/test/src/controllers/proxy.ts

@@ -1,13 +0,0 @@
-import { Controller, Get } from '@nestjs/common';
-
-@Controller("proxy")
-export class ProxyController {
-    constructor() { 
-
-    }
-
-    @Get("*")
-    create(): string {
-        return 'tc api proxy';
-    }
-}

package/test/src/main.ts

@@ -1,8 +0,0 @@
-import { NestFactory } from '@nestjs/core';
-import { AppModule } from './app.module';
-
-async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
-  await app.listen(3000);
-}
-bootstrap();

package/test/src/middleware/proxy.ts

@@ -1,36 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import { get, request } from 'http';
-import { getConfig } from '../config';
-
-let config = getConfig();
-export class ProxyMiddleware {
-    constructor() { }
-
-    static rootPath = '/proxy/';
-    
-    async use(req: Request, res: Response, next: NextFunction) {
-        const { url, headers, method, body } = req;
-
-        let targetUrl = url.replace(ProxyMiddleware.rootPath, '/');
-        targetUrl = config.plmUrl + targetUrl;
-        console.log('targetUrl', targetUrl);
-        
-        const options = {
-            url: targetUrl,
-            headers: headers,
-            method: method,
-            body: body
-        };
-
-        // url = url.replace(ProxyMiddleware.rootPath, '');
-
-
-        const proxyReq = request(options, (proxyRes) => {
-            res.writeHead(proxyRes.statusCode, proxyRes.headers);
-            proxyRes.pipe(res);
-        });
-
-        req.pipe(proxyReq);
-
-    }
-}

package/test/src/static/babel.config.json

@@ -1,6 +0,0 @@
-{
-    "presets": [],
-    "plugins": [
-        "@babel/plugin-transform-typescript"
-    ]
-}

package/test/src/static/design/babel.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-    presets: [
-        ['@babel/preset-env', { targets: { node: 'current' } }],
-        '@babel/preset-typescript',
-    ],
-};

package/test/tsconfig.json

@@ -1,8 +0,0 @@
-{
-    "compilerOptions": {
-        "noEmit": true,
-        "target": "ESNext",
-        "module": "commonjs",
-        "experimentalDecorators": true
-    }
-}