maishu-scripts 1.2.1 → 1.4.0

package/src/modules/configs.test.ts

@@ -0,0 +1,32 @@
+import { assert } from 'console';
+import configs from './configs';
+import { create as createTsCompiler } from "./actions/ts-compile";
+import ts from 'typescript';
+
+describe('configs', () => {
+    it('引入的 configs 不为空', () => {
+        expect(configs).not.toBeNull();
+        expect(configs).not.toBeUndefined();
+    });
+
+    it("configs fileActions 应该可以修改", () => {
+
+        const action1 = configs.fileActions['.ts'];
+        expect(action1).not.toBeUndefined();
+        expect(action1).not.toBeNull();
+
+        configs.fileActions['.ts'] = createTsCompiler({
+            target: ts.ScriptTarget.ES2015,
+            module: ts.ModuleKind.CommonJS,
+            strict: true,
+        });
+
+        const action2 = configs.fileActions['.ts'];
+        expect(action2).not.toBeUndefined();
+        expect(action2).not.toBeNull();
+        expect(action2).not.toBe(action1);
+
+        expect(action1.toString()).not.toBe(action2.toString());
+
+    })
+});

package/src/modules/configs.ts

@@ -0,0 +1,29 @@
+import { FileAction } from "../types";
+import scssCompile from "./actions/scss-compile";
+import lessCompile from "./actions/less-compile";
+import { create as createBielCompiler } from "./actions/babel-compile";
+import { create as createTsCompiler } from "./actions/ts-compile";
+import ts from "typescript";
+
+// const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
+
+const fileActions: Record<string, FileAction> = {
+    ".ts": createBielCompiler(),
+    ".tsx": createBielCompiler(),
+    ".scss": scssCompile,
+    ".less": lessCompile,
+}
+
+class Options {
+    fileActions: Record<string, FileAction> = fileActions;
+    skipFiles: Record<string, RegExp[]> = {
+        ".tsx": [/\.d\.tsx?$/, /\.test\.tsx?$/, /\.spec\.tsx?$/],
+        ".ts": [/\.d\.ts$/, /\.test\.ts$/, /\.spec\.ts$/],
+        ".scss": [],
+        ".less": [],
+    };
+}
+
+const NAME = "maishu-scripts-options";
+(global as any)[NAME] = (global as any)[NAME] || new Options();
+export default (global as any)[NAME] as Options;

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