maishu-scripts 1.2.1 → 1.3.0

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

@@ -0,0 +1,8 @@
+/**
+ * 编译特定Less文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+declare const compileFile: (filePath: string, outDir: string, projectPath: string) => Promise<void>;
+export default compileFile;

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

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const less_1 = __importDefault(require("less"));
+const errors_1 = require("../errors");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * 编译特定Less文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+const compileFile = async (filePath, outDir, projectPath) => {
+    if (!filePath)
+        throw errors_1.errors.argumentNull('filePath');
+    if (!outDir)
+        throw errors_1.errors.argumentNull('outDir');
+    if (!projectPath)
+        throw errors_1.errors.argumentNull('projectPath');
+    let content = fs_1.default.readFileSync(filePath, 'utf-8');
+    let result = await less_1.default.render(content, { filename: filePath });
+    let ext = path_1.default.extname(filePath);
+    let outExt = '.css';
+    let targetPath = path_1.default.join(projectPath, outDir, path_1.default.basename(filePath).replace(ext, outExt));
+    let outDirPath = path_1.default.resolve(targetPath, "..");
+    if (!fs_1.default.existsSync(outDirPath))
+        fs_1.default.mkdirSync(outDirPath, { recursive: true });
+    fs_1.default.writeFileSync(targetPath, result.css);
+};
+exports.default = compileFile;

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

@@ -0,0 +1,9 @@
+import type { FileAction } from '../../types';
+/**
+ * 编译特定SCSS文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+export declare const compileFile: FileAction;
+export default compileFile;

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

@@ -0,0 +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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFile = void 0;
+const sass = __importStar(require("sass"));
+const errors_1 = require("../errors");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * 编译特定SCSS文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+const compileFile = (filePath, outDir, projectPath) => {
+    if (!filePath)
+        throw errors_1.errors.argumentNull('filePath');
+    if (!outDir)
+        throw errors_1.errors.argumentNull('outDir');
+    if (!projectPath)
+        throw errors_1.errors.argumentNull('projectPath');
+    let content = fs.readFileSync(filePath, 'utf-8');
+    let result = sass.renderSync({ data: content });
+    let ext = path.extname(filePath);
+    let outExt = '.css';
+    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.css.toString());
+};
+exports.compileFile = compileFile;
+exports.default = exports.compileFile;

package/out/modules/compile.js

@@ -35,11 +35,15 @@ const path = __importStar(require("path"));
 const errors_1 = require("./errors");
 const biel_compile_1 = require("./actions/biel-compile");
 const copy_file_1 = __importDefault(require("./actions/copy-file"));
+const scss_compile_1 = __importDefault(require("./actions/scss-compile"));
+const less_compile_1 = __importDefault(require("./actions/less-compile"));
 const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"];
-const extCopy = [".js", ".html", ".css", ".jpg", ".png", ".gif", ".scss", ".less"];
+const extCopy = [".js", ".html", ".css", ".jpg", ".png", ".gif", ".less"];
 let fileActions = {
     ".ts": biel_compile_1.compileFile,
     ".tsx": biel_compile_1.compileFile,
+    ".scss": scss_compile_1.default,
+    ".less": less_compile_1.default,
 };
 extCopy.forEach(ext => fileActions[ext] = copy_file_1.default);
 /** 将 sourceDir 目录下所有文件生成到 outDir */
@@ -105,14 +109,6 @@ function watchDirectory(sourceRoot, outRoot, projectPath, callback) {
         }
     });
 }
-// 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.d.ts

@@ -1,19 +1,7 @@
 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): {
@@ -21,14 +9,4 @@ export declare class ProjectCompiler {
         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

@@ -22,104 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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_1 = __importDefault(require("nodemon"));
 const errors_1 = require("./errors");
 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 = __importDefault(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(sourcePath);
-        }
-        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");
@@ -182,74 +93,5 @@ class ProjectCompiler {
         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() {
-        (0, nodemon_1.default)({
-            script: `./${this.outputDirectoryName}/main.js`,
-            watch: [`./${this.outputDirectoryName}/`],
-        });
-    }
 }
 exports.ProjectCompiler = ProjectCompiler;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.2.1",
+    "version": "1.3.0",
     "description": "用于对 node 项目进行代码生成，打包，运行",
     "dependencies": {
         "@babel/core": "^7.24.3",
@@ -9,9 +9,11 @@
         "@babel/plugin-transform-typescript": "^7.24.1",
         "@types/node": "^20.12.2",
         "babel-plugin-transform-typescript-metadata": "^0.3.2",
+        "less": "^4.5.1",
         "maishu-toolkit": "^1.12.6",
         "node-watch": "^0.7.4",
         "nodemon": "^3.1.4",
+        "sass": "^1.97.1",
         "typescript": "^5.4.5"
     },
     "devDependencies": {
@@ -19,6 +21,7 @@
         "@babel/preset-typescript": "^7.24.1",
         "@types/babel__core": "^7.20.5",
         "@types/jest": "^29.5.12",
+        "@types/less": "^3.0.8",
         "jest": "^29.7.0"
     },
     "main": "./out/index.js",

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

@@ -146,3 +146,5 @@ class ImportPathRewrite {
     }
 
 }
+
+

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

@@ -0,0 +1,34 @@
+import lessCompile from './less-compile';
+import path from 'path';
+import fs from 'fs';
+
+describe('less-compile', () => {
+    it('should compile less files', async () => {
+        // generate a less test file
+        const lessTestFile = path.join(__dirname, 'test.less');
+        let lessTestFileContent = `
+            .test {
+                color: red;
+             }
+        `;
+        fs.writeFileSync(lessTestFile, lessTestFileContent);
+
+        // compile the less test file
+        await lessCompile(lessTestFile, 'dist', __dirname);
+
+        const lessTestCompiledFile = path.join(__dirname, 'dist', 'test.css');
+
+
+        // check if the compiled file exists
+        // 移除 lessTestFileContent 空格，换行符
+        lessTestFileContent = lessTestFileContent.replace(/\s/g, '').replace(/[\r\n]/g, '');
+        let compiledFileContent = fs.readFileSync(lessTestCompiledFile, 'utf-8');
+        compiledFileContent = compiledFileContent.replace(/\s/g, '').replace(/[\r\n]/g, '');
+        expect(compiledFileContent).toBe(lessTestFileContent);
+
+        // clean up
+        fs.unlinkSync(lessTestFile);
+        fs.unlinkSync(lessTestCompiledFile);
+
+    });
+});

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

@@ -0,0 +1,35 @@
+import less from 'less';
+import { errors } from '../errors';
+import fs from 'fs';
+import path from 'path';
+import { FileAction } from '../../types';
+
+/**
+ * 编译特定Less文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+const compileFile = async (filePath: string, outDir: string, projectPath: string) => {
+    if (!filePath)
+        throw errors.argumentNull('filePath');
+    if (!outDir)
+        throw errors.argumentNull('outDir');
+    if (!projectPath)
+        throw errors.argumentNull('projectPath');
+
+    let content = fs.readFileSync(filePath, 'utf-8');
+    let result = await less.render(content, { filename: filePath });
+
+    let ext = path.extname(filePath);
+    let outExt = '.css';
+    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.css);
+}
+
+export default compileFile;

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

@@ -0,0 +1,38 @@
+import scssCompile from './scss-compile';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('scss-compile', () => {
+
+    it('should compile scss files', () => {
+
+        // generate test file
+        const testFile = path.join(__dirname, 'test.scss');
+        const testContent = `$color: red;
+        .test {
+            background-color: $color;
+         }`;
+        fs.writeFileSync(testFile, testContent);
+
+        scssCompile(testFile, 'dist', __dirname);
+
+        const expectedFile = path.join(__dirname, 'dist', 'test.css');
+        let expectedContent = `.test {
+    background-color: red;
+}
+`;
+        // 移除 expectedContent 中空格和换行符
+        expectedContent = expectedContent.replace(/\s+/g, '').replace(/[\r\n]/g, '');
+        let fileContent = fs.readFileSync(expectedFile, 'utf-8');
+        fileContent = fileContent.replace(/\s+/g, '').replace(/[\r\n]/g, '');
+
+        expect(fileContent).toBe(expectedContent);
+
+        // clean up
+        fs.unlinkSync(testFile);
+        fs.unlinkSync(expectedFile);
+
+
+    })
+
+})

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

@@ -0,0 +1,35 @@
+import * as sass from 'sass';
+import { errors } from '../errors';
+import * as fs from 'fs';
+import * as path from 'path';
+import type { FileAction } from '../../types';
+
+/**
+ * 编译特定SCSS文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+export const compileFile: FileAction = (filePath: string, outDir: string, projectPath: string) => {
+    if (!filePath)
+        throw errors.argumentNull('filePath');
+    if (!outDir)
+        throw errors.argumentNull('outDir');
+    if (!projectPath)
+        throw errors.argumentNull('projectPath');
+
+    let content = fs.readFileSync(filePath, 'utf-8');
+    let result = sass.renderSync({ data: content });
+
+    let ext = path.extname(filePath);
+    let outExt = '.css';
+    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.css.toString());
+}
+
+export default compileFile;

package/src/modules/compile.test.ts

@@ -30,19 +30,4 @@ describe("Compile Test", function () {
         expect(ignored).toBe(true);
     })
 
-    test("temp", function () {
-        let sourceFile = "D:\\startdard-process\\plm-projects\\tc-api-proxy\\src\\app.controller.ts";
-        let sourceCode = fs.readFileSync(sourceFile, "utf8");
-        let r = ts.transpileModule(sourceCode, {
-            compilerOptions: {
-                module: ts.ModuleKind.CommonJS,
-                target: ts.ScriptTarget.ES2015,
-                sourceMap: true
-            }
-        })
-
-        console.log(r);
-
-    })
-
 })

package/src/modules/compile.ts

@@ -5,13 +5,17 @@ import { errors } from "./errors";
 import { compileFile as bielCompileFile } from "./actions/biel-compile";
 import copyFile from "./actions/copy-file";
 import { FileAction } from "../types";
+import scssCompile from "./actions/scss-compile";
+import lessCompile from "./actions/less-compile";
 
 const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
-const extCopy = [".js", ".html", ".css", ".jpg", ".png", ".gif", ".scss", ".less"];
+const extCopy = [".js", ".html", ".css", ".jpg", ".png", ".gif", ".less"];
 
 let fileActions: { [ext: string]: FileAction } = {
     ".ts": bielCompileFile,
     ".tsx": bielCompileFile,
+    ".scss": scssCompile,
+    ".less": lessCompile,
 }
 
 extCopy.forEach(ext => fileActions[ext] = copyFile);
@@ -85,18 +89,6 @@ 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");
-
-//     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");
 

package/src/modules/project-compiler.ts

@@ -12,96 +12,10 @@ type FileAction = (filePath: string, outDir: string) => void;
 
 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");
-        if (!outputDirectoryName) throw errors.argumentNull("outputDirectoryName");
-
-        if (!path.isAbsolute(projectPath))
-            throw errors.notAbsolutePath(projectPath);
-
-        let sourcePath = path.join(projectPath, sourceDirectoryNanme);
-        if (!fs.existsSync(sourcePath))
-            throw errors.pathNotExists(sourcePath);
-
-        this.fileActions = {
-            ".ts": this.compileFile.bind(this),
-            ".tsx": this.compileFile.bind(this),
-        }
-
-    }
-
-    /** 
-      * 编译特定文件，并生成到制定目录 
-      * @param sourcePath 源文件路径
-      * @param outDir 输出目录
-      * */
-    async compileFile(filePath: string, outDir: string) {
-        this.compileTypeScriptFileByBabel(filePath, outDir);
-    }
-
-    private async compileTypeScriptFileByBabel(sourcePath: string, outDir: string) {
-        if (!sourcePath) throw errors.argumentNull("sourcePath");
-        if (!outDir) throw errors.argumentNull("outDir");
-        if (!fs.existsSync(sourcePath)) throw 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.compileError(sourcePath);
-
-        let ast = fileResult.ast;
-        if (!ast)
-            throw errors.compileError(sourcePath);
-
-        new 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.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(sourcePath);
-        }
-
-        if (!fs.existsSync(outDirPath))
-            fs.mkdirSync(outDirPath, { recursive: true });
-
-        fs.writeFileSync(targetPath, r.code);
-
-    }
 
     static loadBabelConfig(configPath: string): babel.TransformOptions {
         if (!configPath) throw errors.argumentNull("configPath");
@@ -179,90 +93,7 @@ export class ProjectCompiler {
         return babelOptions;
     }
 
-    /** 
-     * 获取源文件所对应生成文件的扩展名 
-     * @param file 源文件名
-     * */
-    private fileOutExt(file: string) {
-        let ext = path.extname(file);
-        if (ext === ".ts")
-            return tsOutExt;
-
-        if (ext === ".tsx")
-            return tsOutExt;
-
-        return ext;
-    }
-
-    private isIgnoredFile(filePath: string) {
-        if (!filePath) throw errors.argumentNull("filePath");
-
-        let isSkip = this.skipFiles.some(pattern => new RegExp(pattern).test(filePath));
-        return isSkip;
-    }
-
-    generateCode(): void;
-    generateCode(sourceDir: string, outDir: string): void;
-    generateCode(sourceDir?: string, outDir?: string): void {
-
-        // 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.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() {//sourceRoot: string, outRoot: string
-        watch(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}/`],
-        })
-    }
+ 
 }