maishu-scripts 1.1.2 → 1.2.1

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

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

package/out/modules/{compile → actions}/biel-compile.js

@@ -1,23 +1,48 @@
 "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 = void 0;
-const babel = require("@babel/core");
-const fs = require("fs");
-const path = require("path");
+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 outDir 输出目录
+ * @param outputPath 输出目录
  * @param projectPath 项目路径
  * */
-async function compileFile(sourcePath, outDir, projectPath) {
+async function compileFile(sourcePath, outputPath, projectPath) {
     if (!sourcePath)
         throw errors_1.errors.argumentNull("sourcePath");
-    if (!outDir)
-        throw errors_1.errors.argumentNull("outDir");
+    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}`);
@@ -53,34 +78,31 @@ async function compileFile(sourcePath, outDir, projectPath) {
     new ImportPathRewrite(sourcePath, ast);
     let r = babel.transformFromAstSync(ast, undefined, {
         filename: sourcePath, plugins: babelOptions.plugins,
-        presets: babelOptions.presets, sourceMaps: true
+        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(outDir, path.basename(sourcePath).replace(ext, outExt)); //sourcePath.replace(new RegExp(ext + "$"), outExt).replace(path.dirname(sourcePath), outDir);
+    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);
-        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";
+        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);
 }
-exports.compileFile = compileFile;
 function extname(file) {
     // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
     let ext = path.extname(file);

package/out/modules/actions/copy-file.d.ts

@@ -0,0 +1,3 @@
+import { FileAction } from "../../types";
+declare let copyFile: FileAction;
+export default copyFile;

package/out/modules/actions/copy-file.js

@@ -0,0 +1,42 @@
+"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 });
+const errors_1 = require("../errors");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let copyFile = (filePath, outPath, projectPath) => {
+    if (!filePath)
+        throw errors_1.errors.argumentNull("filePath");
+    if (!outPath)
+        throw errors_1.errors.argumentNull("outPath");
+    if (!fs.existsSync(filePath)) {
+        return;
+    }
+    let out = filePath.replace(path.dirname(filePath), outPath);
+    let outDirPath = path.resolve(out, "..");
+    fs.mkdirSync(outDirPath, { recursive: true });
+    fs.copyFileSync(filePath, out);
+};
+exports.default = copyFile;

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

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+/**
+ * 编译特定文件，并生成到制定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ * */
+export declare function compileFile(filePath: string, outDir: string, projectPath: string): Promise<void>;
+export declare function getTypescriptConfig(projectPath: string, directoryPath: string): ts.CompilerOptions;
+export declare function findTypeScriptConfigPath(projectPath: string, directoryPath: string): string | null;

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

@@ -0,0 +1,96 @@
+"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;
+exports.getTypescriptConfig = getTypescriptConfig;
+exports.findTypeScriptConfigPath = findTypeScriptConfigPath;
+const ts = __importStar(require("typescript"));
+const errors_1 = require("../errors");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const project_compiler_1 = require("../project-compiler");
+const TS_CONFIG_FILE = 'tsconfig.json';
+/**
+ * 编译特定文件，并生成到制定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ * */
+async function compileFile(filePath, outDir, projectPath) {
+    if (!filePath)
+        throw errors_1.errors.argumentNull('sourcePath');
+    if (!outDir)
+        throw errors_1.errors.argumentNull('outDir');
+    if (!projectPath)
+        throw errors_1.errors.argumentNull('projectPath');
+    if (!path.isAbsolute(filePath))
+        throw errors_1.errors.notAbsolutePath(filePath);
+    let content = fs.readFileSync(filePath, 'utf-8');
+    let compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+    let result = ts.transpileModule(content, { compilerOptions });
+    console.log(result.outputText);
+    let ext = path.extname(filePath);
+    let outExt = project_compiler_1.ProjectCompiler.tsOutExt;
+    let targetPath = path.join(projectPath, outDir, path.basename(filePath).replace(ext, outExt));
+    let outDirPath = path.resolve(targetPath, "..");
+    if (!fs.existsSync(outDirPath))
+        fs.mkdirSync(outDirPath, { recursive: true });
+    fs.writeFileSync(targetPath, result.outputText);
+}
+function getTypescriptConfig(projectPath, directoryPath) {
+    let configPath = findTypeScriptConfigPath(projectPath, directoryPath);
+    let compilerOptions;
+    if (!configPath) {
+        compilerOptions = defaultCompilerOptions();
+    }
+    else {
+        let configContent = fs.readFileSync(configPath, 'utf-8');
+        let config = JSON.parse(configContent);
+        compilerOptions = config.compilerOptions;
+    }
+    return compilerOptions;
+}
+function findTypeScriptConfigPath(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 tsConfigPath = path.join(directoryPath, TS_CONFIG_FILE);
+    if (fs.existsSync(tsConfigPath)) {
+        return tsConfigPath;
+    }
+    if (projectPath == directoryPath)
+        return null;
+    let parentPath = path.resolve(directoryPath, "..");
+    return findTypeScriptConfigPath(projectPath, parentPath);
+}
+function defaultCompilerOptions() {
+    let r = {
+        module: ts.ModuleKind.CommonJS,
+        target: ts.ScriptTarget.ESNext,
+    };
+    return r;
+}

package/out/modules/compile.d.ts

@@ -1,6 +1,5 @@
 /** 将 sourceDir 目录下所有文件生成到 outDir */
-export declare function generateCode(sourceDir: string, outDir: string, projectPath?: string): void;
+export declare function generateCode(sourceDir: string, outDir: string, projectPath: string, callback?: (filePath: string, outDir: string, projectPath: string) => void): 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 watchDirectory(sourceRoot: string, outRoot: string, projectPath: string, callback?: (filePath: string, outDir: string, projectPath: string) => void): void;
 export declare function isIgnoredFile(filePath: string): boolean;

package/out/modules/compile.js

@@ -1,23 +1,55 @@
 "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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 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");
+exports.generateCode = generateCode;
+exports.watchDirectory = watchDirectory;
+exports.isIgnoredFile = isIgnoredFile;
+const fs = __importStar(require("fs"));
+const node_watch_1 = __importDefault(require("node-watch"));
+const path = __importStar(require("path"));
 const errors_1 = require("./errors");
-const biel_compile_1 = require("./compile/biel-compile");
+const biel_compile_1 = require("./actions/biel-compile");
+const copy_file_1 = __importDefault(require("./actions/copy-file"));
 const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"];
-const outExt = ".js";
+const extCopy = [".js", ".html", ".css", ".jpg", ".png", ".gif", ".scss", ".less"];
 let fileActions = {
     ".ts": biel_compile_1.compileFile,
     ".tsx": biel_compile_1.compileFile,
 };
+extCopy.forEach(ext => fileActions[ext] = copy_file_1.default);
 /** 将 sourceDir 目录下所有文件生成到 outDir */
-function generateCode(sourceDir, outDir, projectPath) {
+function generateCode(sourceDir, outDir, projectPath, callback) {
     if (!sourceDir)
         throw errors_1.errors.argumentNull("sourceDir");
     if (!outDir)
         throw errors_1.errors.argumentNull("outDir");
+    if (!projectPath)
+        throw errors_1.errors.argumentNull("projectPath");
     if (!fs.existsSync(sourceDir))
         throw errors_1.errors.pathNotExists(sourceDir);
     let files = fs.readdirSync(sourceDir);
@@ -35,6 +67,9 @@ function generateCode(sourceDir, outDir, projectPath) {
         let action = fileActions[ext];
         if (action) {
             action(filePath, outDir, projectPath);
+            if (callback) {
+                callback(filePath, outDir, projectPath);
+            }
         }
     }
     let dirs = fs.readdirSync(sourceDir);
@@ -46,36 +81,44 @@ function generateCode(sourceDir, outDir, projectPath) {
         }
     }
 }
-exports.generateCode = generateCode;
 /** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
-function watchDirectory(sourceRoot, outRoot, projectPath) {
+function watchDirectory(sourceRoot, outRoot, projectPath, callback) {
+    if (!sourceRoot)
+        throw errors_1.errors.argumentNull("sourceRoot");
+    if (!outRoot)
+        throw errors_1.errors.argumentNull("outRoot");
+    if (!projectPath)
+        throw errors_1.errors.argumentNull("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) {
+        if (!action) {
+            return;
+        }
+        try {
             action(name, outPath, projectPath);
+            if (callback)
+                callback(name, outPath, projectPath);
+        }
+        catch (e) {
+            console.error(e);
         }
     });
 }
-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;
+// 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);
+// }
 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);

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

@@ -1,8 +1,31 @@
 "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.ImportPathRewrite = void 0;
-const path = require("path");
-const fs = require("fs");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 // const outExt = ".js";
 class ImportPathRewrite {
     filePath;

package/out/modules/project-compiler.js

@@ -1,13 +1,39 @@
 "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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectCompiler = void 0;
-const nodemon = require("nodemon");
+const nodemon_1 = __importDefault(require("nodemon"));
 const errors_1 = require("./errors");
-const fs = require("fs");
-const path = require("path");
-const babel = require("@babel/core");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const babel = __importStar(require("@babel/core"));
 const import_path_rewrite_1 = require("./import-path-rewrite");
-const node_watch_1 = require("node-watch");
+const node_watch_1 = __importDefault(require("node-watch"));
 const tsOutExt = ".js";
 class ProjectCompiler {
     projectPath;
@@ -88,7 +114,7 @@ class ProjectCompiler {
                 fs.mkdirSync(outDirPath, { recursive: true });
             fs.writeFileSync(mapPath, JSON.stringify(r.map));
             r.code += `\n//babelPath:${babelPath}`;
-            r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
+            r.code += "\n//# sourceMappingURL=" + path.basename(sourcePath);
         }
         if (!fs.existsSync(outDirPath))
             fs.mkdirSync(outDirPath, { recursive: true });
@@ -220,7 +246,7 @@ class ProjectCompiler {
         });
     }
     run() {
-        nodemon({
+        (0, nodemon_1.default)({
             script: `./${this.outputDirectoryName}/main.js`,
             watch: [`./${this.outputDirectoryName}/`],
         });

package/out/modules/run.js

@@ -1,11 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-const nodemon = require("nodemon");
+exports.run = run;
+const nodemon_1 = __importDefault(require("nodemon"));
 function run() {
-    nodemon({
-        script: "./out/main.js",
+    (0, nodemon_1.default)({
+        script: "./out/main.js", //!args ? "./out/main.js" : "./out/main.js " + args,
         watch: ["./out/"],
+        ignoreRoot: ['./out/static/'],
     });
 }
-exports.run = run;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.1.2",
+    "version": "1.2.1",
     "description": "用于对 node 项目进行代码生成，打包，运行",
     "dependencies": {
         "@babel/core": "^7.24.3",
@@ -11,7 +11,7 @@
         "babel-plugin-transform-typescript-metadata": "^0.3.2",
         "maishu-toolkit": "^1.12.6",
         "node-watch": "^0.7.4",
-        "nodemon": "^3.1.0",
+        "nodemon": "^3.1.4",
         "typescript": "^5.4.5"
     },
     "devDependencies": {
@@ -25,5 +25,8 @@
     "files": [
         "out",
         "src"
-    ]
-}
+    ],
+    "scripts": {
+        "build": "tsc"
+    }
+}

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

@@ -10,12 +10,14 @@ const outExt = ProjectCompiler.tsOutExt;
 /** 
  * 编译特定文件，并生成到制定目录 
  * @param sourcePath 源文件路径
- * @param outDir 输出目录
+ * @param outputPath 输出目录
  * @param projectPath 项目路径
  * */
-export async function compileFile(sourcePath: string, outDir: string, projectPath?: string) {
+export async function compileFile(sourcePath: string, outputPath: string, projectPath: string) {
     if (!sourcePath) throw errors.argumentNull("sourcePath");
-    if (!outDir) throw errors.argumentNull("outDir");
+    if (!outputPath) throw errors.argumentNull("outputPath");
+    if (!projectPath) throw errors.argumentNull("projectPath");
+
     // if (!fs.existsSync(sourcePath)) throw errors.pathNotExists(sourcePath);
     if (!fs.existsSync(sourcePath)) {
         console.warn(`Path not exists: ${sourcePath}`);
@@ -57,25 +59,21 @@ export async function compileFile(sourcePath: string, outDir: string, projectPat
     new ImportPathRewrite(sourcePath, ast);
     let r = babel.transformFromAstSync(ast, undefined, {
         filename: sourcePath, plugins: babelOptions.plugins,
-        presets: babelOptions.presets, sourceMaps: true
+        presets: babelOptions.presets, sourceMaps: babelOptions.sourceMaps
     });
     if (!r || r.code == null)
         throw 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 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);
-        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";
+        r.map.sources = [path.relative(outputPath, sourcePath)];
+
         if (!fs.existsSync(outDirPath))
             fs.mkdirSync(outDirPath, { recursive: true });
 
@@ -83,6 +81,9 @@ export async function compileFile(sourcePath: string, outDir: string, projectPat
         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 });

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

@@ -0,0 +1,22 @@
+import { FileAction } from "../../types";
+import { errors } from "../errors";
+import * as fs from "fs";
+import * as path from "path";
+
+let copyFile: FileAction = (filePath: string, outPath: string, projectPath: string) => {
+    if (!filePath) throw errors.argumentNull("filePath");
+    if (!outPath) throw errors.argumentNull("outPath");
+
+    if (!fs.existsSync(filePath)) {
+        return;
+    }
+
+    let out = filePath.replace(path.dirname(filePath), outPath);
+    let outDirPath = path.resolve(out, "..");
+
+    fs.mkdirSync(outDirPath, { recursive: true });
+
+    fs.copyFileSync(filePath, out);
+}
+
+export default copyFile;

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

@@ -0,0 +1,39 @@
+import { compileFile, findTypeScriptConfigPath, getTypescriptConfig } from './ts-compile';
+import * as path from 'path';
+import * as fs from 'fs';
+
+describe('ts-compile', () => {
+
+    let projectPath = path.join(__dirname, '..', '..', '..', 'test');
+    let outDir = "out";
+
+    test('should compile typescript files', async () => {
+
+        let tsFile = path.join(__dirname, '..', '..', '..', 'test', 'src', 'main.ts');
+        expect(fs.existsSync(tsFile)).toBeTruthy();
+
+
+        let jsFile = path.join(projectPath, outDir, "main.js");
+        if (fs.existsSync(jsFile)) {
+            fs.rmSync(jsFile, { recursive: true, force: true });
+        }
+
+        await compileFile(tsFile, outDir, projectPath);
+        expect(fs.existsSync(jsFile));
+    })
+
+    test("should throw error if static path tsconfig.json not found", function () {
+
+        let scriptPath = findTypeScriptConfigPath(projectPath, "src/static");
+        expect(scriptPath).not.toBeNull();
+
+    })
+
+    test("design path tsconfig.json same as static path tsconfig.json", function () {
+
+        let scriptPath = findTypeScriptConfigPath(projectPath, "src/static/design");
+        expect(scriptPath).not.toBeNull();
+        expect(scriptPath).toBe(findTypeScriptConfigPath(projectPath, "src/static"));
+
+    })
+});

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

@@ -0,0 +1,91 @@
+import * as ts from 'typescript';
+import { errors } from '../errors';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ProjectCompiler } from '../project-compiler';
+
+const TS_CONFIG_FILE = 'tsconfig.json';
+
+type TypeScriptProjectConfig = {
+    compilerOptions: ts.CompilerOptions;
+}
+
+/** 
+ * 编译特定文件，并生成到制定目录 
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ * */
+export async function compileFile(filePath: string, outDir: string, projectPath: string) {
+    if (!filePath)
+        throw errors.argumentNull('sourcePath');
+    if (!outDir)
+        throw errors.argumentNull('outDir');
+    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 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));
+    let outDirPath = path.resolve(targetPath, "..");
+
+    if (!fs.existsSync(outDirPath))
+        fs.mkdirSync(outDirPath, { recursive: true });
+
+    fs.writeFileSync(targetPath, result.outputText);
+}
+
+export function getTypescriptConfig(projectPath: string, directoryPath: string): ts.CompilerOptions {
+    let configPath = findTypeScriptConfigPath(projectPath, directoryPath);
+    let compilerOptions: ts.CompilerOptions;
+    if (!configPath) {
+        compilerOptions = defaultCompilerOptions();
+    }
+    else {
+        let configContent = fs.readFileSync(configPath, 'utf-8');
+        let config = JSON.parse(configContent) as TypeScriptProjectConfig;
+        compilerOptions = config.compilerOptions;
+    }
+
+    return compilerOptions;
+}
+
+export function findTypeScriptConfigPath(projectPath: string, directoryPath: string): string | null {
+    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 tsConfigPath = path.join(directoryPath, TS_CONFIG_FILE);
+
+    if (fs.existsSync(tsConfigPath)) {
+        return tsConfigPath;
+    }
+
+    if (projectPath == directoryPath)
+        return null;
+
+    let parentPath = path.resolve(directoryPath, "..");
+
+    return findTypeScriptConfigPath(projectPath, parentPath);
+}
+
+function defaultCompilerOptions(): ts.CompilerOptions {
+    let r: ts.CompilerOptions = {
+        module: ts.ModuleKind.CommonJS,
+        target: ts.ScriptTarget.ESNext,
+    }
+
+    return r;
+}

package/src/modules/compile.test.ts

@@ -1,11 +1,11 @@
-import { copyFile, generateCode, isIgnoredFile } from "./compile";
+import { generateCode, isIgnoredFile } from "./compile";
 import * as path from "path";
 import * as fs from "fs";
 import * as ts from "typescript";
 
 describe("Compile Test", function () {
 
-    test("copyFile test", function () {
+    it("copyFile test", function () {
 
         let srcPath = "test/src";
         let srcExists = fs.existsSync(srcPath);
@@ -19,7 +19,9 @@ describe("Compile Test", function () {
         if (fs.existsSync(destPath)) {
             fs.rmdirSync(destPath, { recursive: true });
         }
-        generateCode(srcPath, destPath);
+
+        let projectPath = path.join(__dirname, "..", "..");
+        generateCode(srcPath, destPath, projectPath);
     })
 
     test("isIgnored test", function () {

package/src/modules/compile.ts

@@ -1,25 +1,29 @@
-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";
+import { compileFile as bielCompileFile } from "./actions/biel-compile";
+import copyFile from "./actions/copy-file";
+import { FileAction } from "../types";
 
 const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
-const outExt = ".js";
+const extCopy = [".js", ".html", ".css", ".jpg", ".png", ".gif", ".scss", ".less"];
 
-type FileAction = (filePath: string, outDir: string, projectPath?: string) => void;
 let fileActions: { [ext: string]: FileAction } = {
     ".ts": bielCompileFile,
     ".tsx": bielCompileFile,
 }
 
+extCopy.forEach(ext => fileActions[ext] = copyFile);
+
 /** 将 sourceDir 目录下所有文件生成到 outDir */
-export function generateCode(sourceDir: string, outDir: string, projectPath?: string) {
+export function generateCode(sourceDir: string, outDir: string, projectPath: string,
+    callback?: (filePath: string, outDir: string, projectPath: string) => void
+) {
 
     if (!sourceDir) throw errors.argumentNull("sourceDir");
     if (!outDir) throw errors.argumentNull("outDir");
+    if (!projectPath) throw errors.argumentNull("projectPath");
 
     if (!fs.existsSync(sourceDir))
         throw errors.pathNotExists(sourceDir);
@@ -41,6 +45,9 @@ export function generateCode(sourceDir: string, outDir: string, projectPath?: st
         let action = fileActions[ext];
         if (action) {
             action(filePath, outDir, projectPath);
+            if (callback) {
+                callback(filePath, outDir, projectPath);
+            }
         }
     }
 
@@ -55,27 +62,40 @@ export function generateCode(sourceDir: string, outDir: string, projectPath?: st
 }
 
 /** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
-export function watchDirectory(sourceRoot: string, outRoot: string, projectPath?: string) {
+export function watchDirectory(sourceRoot: string, outRoot: string, projectPath: string, callback?: (filePath: string, outDir: string, projectPath: string) => void) {
+    if (!sourceRoot) throw errors.argumentNull("sourceRoot");
+    if (!outRoot) throw errors.argumentNull("outRoot");
+    if (!projectPath) throw errors.argumentNull("projectPath");
+
     watch(sourceRoot, { recursive: true }, async (evt, name) => {
         let action = fileActions[extname(name)];
         let outPath = path.dirname(name).replace(sourceRoot, outRoot);
-        if (action) {
+        if (!action) {
+            return;
+        }
+
+        try {
             action(name, outPath, projectPath);
+            if (callback)
+                callback(name, outPath, projectPath);
+        }
+        catch (e) {
+            console.error(e);
         }
     })
 }
 
-export function copyFile(filePath: string, outDir: string) {
-    if (!filePath) throw errors.argumentNull("filePath");
-    if (!outDir) throw errors.argumentNull("outDir");
+// 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, "..");
+//     let out = filePath.replace(path.dirname(filePath), outDir);
+//     let outDirPath = path.resolve(out, "..");
 
-    fs.mkdirSync(outDirPath, { recursive: true });
+//     fs.mkdirSync(outDirPath, { recursive: true });
 
-    fs.copyFileSync(filePath, out);
-}
+//     fs.copyFileSync(filePath, out);
+// }
 
 export function isIgnoredFile(filePath: string) {
     if (!filePath) throw errors.argumentNull("filePath");

package/src/modules/project-compiler.test.ts

@@ -1,10 +1,14 @@
 import * as path from "path";
 import * as fs from "fs";
 import { ProjectCompiler } from "./project-compiler";
+import { errors } from "./errors";
 describe('project-compiler test', function () {
 
-    let projectPath = path.join(__dirname, "..", "test");
-    let projectCompiler = new ProjectCompiler(projectPath, "src", "out");
+    let projectPath = path.join(__dirname, "..", "..", "test");
+    if (fs.existsSync(projectPath) === false)
+        throw errors.pathNotExists(projectPath);
+
+    // let projectCompiler = new ProjectCompiler(projectPath, "src", "out");
 
     test("findBabelConfigPath test", function () {
         let staticPath = path.join(projectPath, "src", "static");

package/src/modules/project-compiler.ts

@@ -1,4 +1,4 @@
-import * as nodemon from "nodemon";
+import nodemon from "nodemon";
 import { errors } from "./errors";
 import * as fs from "fs";
 import * as path from "path";
@@ -93,7 +93,7 @@ export class ProjectCompiler {
 
             fs.writeFileSync(mapPath, JSON.stringify(r.map));
             r.code += `\n//babelPath:${babelPath}`;
-            r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
+            r.code += "\n//# sourceMappingURL=" + path.basename(sourcePath);
         }
 
         if (!fs.existsSync(outDirPath))

package/src/modules/run.ts

@@ -1,8 +1,9 @@
-import * as nodemon from "nodemon";
+import nodemon from "nodemon";
 
 export function run() {
     nodemon({
-        script: "./out/main.js",
+        script: "./out/main.js",//!args ? "./out/main.js" : "./out/main.js " + args,
         watch: ["./out/"],
+        ignoreRoot: ['./out/static/'],
     })
 }

package/src/types.d.ts

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

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

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

package/out/start.d.ts

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

package/out/start.js

@@ -1,9 +0,0 @@
-"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/src/start.ts

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