maishu-scripts 1.0.2 → 1.2.0

package/out/main.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@nestjs/core");
+const app_module_1 = require("./app.module");
+async function bootstrap() {
+    const app = await core_1.NestFactory.create(app_module_1.AppModule);
+    await app.listen(3000);
+}
+bootstrap();

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/actions/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 outputPath 输出目录
+ * @param projectPath 项目路径
+ * */
+async function compileFile(sourcePath, outputPath, projectPath) {
+    if (!sourcePath)
+        throw errors_1.errors.argumentNull("sourcePath");
+    if (!outputPath)
+        throw errors_1.errors.argumentNull("outputPath");
+    if (!projectPath)
+        throw errors_1.errors.argumentNull("projectPath");
+    // if (!fs.existsSync(sourcePath)) throw errors.pathNotExists(sourcePath);
+    if (!fs.existsSync(sourcePath)) {
+        console.warn(`Path not exists: ${sourcePath}`);
+        return;
+    }
+    let sourceDir = path.dirname(sourcePath);
+    let babelOptions;
+    let bablePath;
+    //= projectPath ?
+    //  ProjectCompiler.getBabelConfig(projectPath, sourceDir) : ProjectCompiler.getDefaultBabelConfig();
+    if (projectPath) {
+        let c = project_compiler_1.ProjectCompiler.getBabelConfig(projectPath, sourceDir);
+        bablePath = c.path;
+        babelOptions = c.options;
+    }
+    else {
+        babelOptions = project_compiler_1.ProjectCompiler.getDefaultBabelConfig();
+        bablePath = '';
+    }
+    babelOptions.filename = sourcePath;
+    babelOptions.code = false;
+    babelOptions.ast = true;
+    // let fileResult = babel.transformFileSync(sourcePath, {
+    //     filename: sourcePath, code: false, ast: true, plugins,
+    //     presets
+    // });
+    let fileResult = babel.transformFileSync(sourcePath, babelOptions);
+    if (!fileResult)
+        throw errors_1.errors.compileError(sourcePath);
+    let ast = fileResult.ast;
+    if (!ast)
+        throw errors_1.errors.compileError(sourcePath);
+    new ImportPathRewrite(sourcePath, ast);
+    let r = babel.transformFromAstSync(ast, undefined, {
+        filename: sourcePath, plugins: babelOptions.plugins,
+        presets: babelOptions.presets, sourceMaps: babelOptions.sourceMaps
+    });
+    if (!r || r.code == null)
+        throw errors_1.errors.compileError(sourcePath);
+    let ext = extname(sourcePath);
+    let outExt = fileOutExt(sourcePath);
+    let targetPath = path.join(outputPath, path.basename(sourcePath).replace(ext, outExt)); //sourcePath.replace(new RegExp(ext + "$"), outExt).replace(path.dirname(sourcePath), outDir);
+    let outDirPath = path.resolve(targetPath, "..");
+    let mapPath = targetPath + ".map";
+    if (r.map) {
+        r.map.file = path.basename(targetPath);
+        r.map.sources = [path.relative(outputPath, sourcePath)];
+        if (!fs.existsSync(outDirPath))
+            fs.mkdirSync(outDirPath, { recursive: true });
+        fs.writeFileSync(mapPath, JSON.stringify(r.map));
+        r.code += `\n//babel file path = ${bablePath}`;
+        r.code += "\n//# sourceMappingURL=" + path.basename(mapPath);
+    }
+    else if (fs.existsSync(mapPath)) {
+        fs.rmSync(targetPath);
+    }
+    if (!fs.existsSync(outDirPath))
+        fs.mkdirSync(outDirPath, { recursive: true });
+    fs.writeFileSync(targetPath, r.code);
+}
+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/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,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const fs = require("fs");
+const path = require("path");
+let copyFile = (filePath, outPath, projectPath) => {
+    if (!filePath)
+        throw errors_1.errors.argumentNull("filePath");
+    if (!outPath)
+        throw errors_1.errors.argumentNull("outPath");
+    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,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTypeScriptConfigPath = exports.getTypescriptConfig = exports.compileFile = void 0;
+const ts = require("typescript");
+const errors_1 = require("../errors");
+const fs = require("fs");
+const path = 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);
+}
+exports.compileFile = compileFile;
+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;
+}
+exports.getTypescriptConfig = getTypescriptConfig;
+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);
+}
+exports.findTypeScriptConfigPath = findTypeScriptConfigPath;
+function defaultCompilerOptions() {
+    let r = {
+        module: ts.ModuleKind.CommonJS,
+        target: ts.ScriptTarget.ESNext,
+    };
+    return r;
+}

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

@@ -4,4 +4,4 @@
  * @param outDir 输出目录
  * @param projectPath 项目路径
  * */
-export declare function compileFile(sourcePath: string, outDir: string, projectPath?: string): Promise<void>;
+export declare function compileFile(sourcePath: string, outDir: string, projectPath: string): Promise<void>;

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

@@ -18,6 +18,8 @@ async function compileFile(sourcePath, outDir, projectPath) {
         throw errors_1.errors.argumentNull("sourcePath");
     if (!outDir)
         throw errors_1.errors.argumentNull("outDir");
+    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}`);

package/out/modules/compile/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/compile/ts-compile.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTypeScriptConfigPath = exports.getTypescriptConfig = exports.compileFile = void 0;
+const ts = require("typescript");
+const errors_1 = require("../errors");
+const fs = require("fs");
+const path = 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);
+}
+exports.compileFile = compileFile;
+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;
+}
+exports.getTypescriptConfig = getTypescriptConfig;
+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);
+}
+exports.findTypeScriptConfigPath = findTypeScriptConfigPath;
+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): 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): void;
 export declare function isIgnoredFile(filePath: string): boolean;

package/out/modules/compile.js

@@ -1,23 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIgnoredFile = exports.copyFile = exports.watchDirectory = exports.generateCode = void 0;
+exports.isIgnoredFile = 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 biel_compile_1 = require("./actions/biel-compile");
+const copy_file_1 = 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"];
 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) {
     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);
@@ -49,6 +53,12 @@ function generateCode(sourceDir, outDir, projectPath) {
 exports.generateCode = generateCode;
 /** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
 function watchDirectory(sourceRoot, outRoot, projectPath) {
+    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);
@@ -58,17 +68,14 @@ function watchDirectory(sourceRoot, outRoot, 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;
+// 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");

package/out/modules/project-compiler.js

@@ -88,7 +88,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 });

package/out/modules/run.d.ts

@@ -1 +1 @@
-export declare function run(): void;
+export declare function run(args?: string[]): void;

package/out/modules/run.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.0.2",
+    "version": "1.2.0",
     "description": "用于对 node 项目进行代码生成，打包，运行",
     "dependencies": {
         "@babel/core": "^7.24.3",

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,18 @@
+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");
+
+    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,27 @@
-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"];
 
-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) {
 
     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);
@@ -55,7 +57,11 @@ 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) {
+    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);
@@ -65,17 +71,17 @@ export function watchDirectory(sourceRoot: string, outRoot: string, projectPath?
     })
 }
 
-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

@@ -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";
 
-export function run() {
+export function run(args?: string[]) {
     nodemon({
-        script: "./out/main.js",
+        script: "./out/main.js",//!args ? "./out/main.js" : "./out/main.js " + args,
         watch: ["./out/"],
+        args: args
     })
 }

package/src/types.d.ts

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

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();