maishu-scripts 1.2.0 → 1.3.0

package/out/modules/run.js

@@ -1,12 +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");
-function run(args) {
-    nodemon({
+exports.run = run;
+const nodemon_1 = __importDefault(require("nodemon"));
+function run() {
+    (0, nodemon_1.default)({
         script: "./out/main.js", //!args ? "./out/main.js" : "./out/main.js " + args,
         watch: ["./out/"],
-        args: args
+        ignoreRoot: ['./out/static/'],
     });
 }
-exports.run = run;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "maishu-scripts",
-    "version": "1.2.0",
+    "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.0",
+        "nodemon": "^3.1.4",
+        "sass": "^1.97.1",
         "typescript": "^5.4.5"
     },
     "devDependencies": {
@@ -19,11 +21,15 @@
         "@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",
     "files": [
         "out",
         "src"
-    ]
-}
+    ],
+    "scripts": {
+        "build": "tsc"
+    }
+}

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

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

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

@@ -7,6 +7,10 @@ let copyFile: FileAction = (filePath: string, outPath: string, projectPath: stri
     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, "..");
 

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,19 +5,25 @@ 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"];
+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);
 
 /** 将 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");
@@ -43,6 +49,9 @@ export function generateCode(sourceDir: string, outDir: string, projectPath: str
         let action = fileActions[ext];
         if (action) {
             action(filePath, outDir, projectPath);
+            if (callback) {
+                callback(filePath, outDir, projectPath);
+            }
         }
     }
 
@@ -57,7 +66,7 @@ export function generateCode(sourceDir: string, outDir: string, projectPath: str
 }
 
 /** 监听 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");
@@ -65,24 +74,21 @@ export function watchDirectory(sourceRoot: string, outRoot: string, 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");
-
-//     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

@@ -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";
@@ -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}/`],
-        })
-    }
+ 
 }

package/src/modules/run.ts

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

package/out/main.js

@@ -1,9 +0,0 @@
-"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/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>;