maishu-scripts 1.4.1 → 1.4.5

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

@@ -1,40 +1,245 @@
-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");
-    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");
-        let babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, staticPath);
-        expect(babelConfigPath).toBe(path.join(staticPath, "babel.config.json"));
-
-        let componentsPath = path.join(staticPath, "components");
-        expect(fs.existsSync(componentsPath)).toBeTruthy();
-        babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, componentsPath);
-        expect(babelConfigPath).toBe(path.join(staticPath, "babel.config.json"));
-
-        let designPath = path.join(staticPath, "design");
-        babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, designPath);
-        expect(babelConfigPath).toBe(path.join(designPath, "babel.config.js"));
-    })
-
-    test("loadBabelConfig test", function () {
-
-        let staticPath = path.join(projectPath, "src", "static");
-        let designPath = path.join(staticPath, "design");
-        let babelConfigPath = ProjectCompiler.findBabelConfigPath(projectPath, designPath);
-        expect(babelConfigPath).not.toBe(null);
-        let babelConfig = ProjectCompiler.loadBabelConfig(babelConfigPath as string);
-        expect(babelConfig).not.toBe(undefined);
-        expect(babelConfig.presets).not.toBe(undefined);
-
-    })
-
-});
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import { ProjectCompiler } from "./project-compiler";
+import { errors } from "./errors";
+
+describe('ProjectCompiler', () => {
+    let projectPath = path.join(__dirname, "..", "..", "test");
+
+    beforeAll(() => {
+        if (!fs.existsSync(projectPath)) {
+            throw errors.pathNotExists(projectPath);
+        }
+    });
+
+    // ========== findBabelConfigPath ==========
+
+    describe('findBabelConfigPath', () => {
+        test('should find babel.config.json in the same directory', () => {
+            const staticPath = path.join(projectPath, "src", "static");
+            const result = ProjectCompiler.findBabelConfigPath(projectPath, staticPath);
+            expect(result).toBe(path.join(staticPath, "babel.config.json"));
+        });
+
+        test('should find babel.config.js in the same directory', () => {
+            const designPath = path.join(projectPath, "src", "static", "design");
+            const result = ProjectCompiler.findBabelConfigPath(projectPath, designPath);
+            expect(result).toBe(path.join(designPath, "babel.config.js"));
+        });
+
+        test('should find config in parent directory when child has none', () => {
+            const staticPath = path.join(projectPath, "src", "static");
+            const componentsPath = path.join(staticPath, "components");
+            expect(fs.existsSync(componentsPath)).toBeTruthy();
+
+            const result = ProjectCompiler.findBabelConfigPath(projectPath, componentsPath);
+            expect(result).toBe(path.join(staticPath, "babel.config.json"));
+        });
+
+        test('should find config in project root when config exists at root', () => {
+            // projectPath is test/, which has src/babel.config.js but not at root
+            // Use src path which has babel.config.js
+            const srcPath = path.join(projectPath, "src");
+            const result = ProjectCompiler.findBabelConfigPath(srcPath, srcPath);
+            expect(result).not.toBeNull();
+            expect(result).toContain('babel.config.js');
+        });
+
+        test('should return null when no babel config found anywhere', () => {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-test-'));
+            try {
+                const subDir = path.join(tmpDir, 'sub');
+                fs.mkdirSync(subDir);
+                const result = ProjectCompiler.findBabelConfigPath(tmpDir, subDir);
+                expect(result).toBeNull();
+            } finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+
+        test('should prefer babel.config.js over babel.config.json when both exist', () => {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-test-'));
+            try {
+                const jsConfig = path.join(tmpDir, 'babel.config.js');
+                const jsonConfig = path.join(tmpDir, 'babel.config.json');
+                fs.writeFileSync(jsConfig, 'module.exports = {};');
+                fs.writeFileSync(jsonConfig, '{}');
+
+                const result = ProjectCompiler.findBabelConfigPath(tmpDir, tmpDir);
+                expect(result).toBe(jsConfig);
+            } finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+
+        test('should resolve relative directoryPath to absolute', () => {
+            const staticPath = path.join(projectPath, "src", "static");
+            const relativeDir = path.relative(projectPath, staticPath);
+            const result = ProjectCompiler.findBabelConfigPath(projectPath, relativeDir);
+            expect(result).not.toBeNull();
+        });
+    });
+
+    // ========== loadBabelConfig ==========
+
+    describe('loadBabelConfig', () => {
+        test('should load config from .json file', () => {
+            const staticPath = path.join(projectPath, "src", "static");
+            const configPath = path.join(staticPath, "babel.config.json");
+            const config = ProjectCompiler.loadBabelConfig(configPath);
+
+            expect(config).toBeDefined();
+            expect(config.plugins).toBeDefined();
+            expect(config.plugins).toContainEqual("@babel/plugin-transform-typescript");
+        });
+
+        test('should load config from .js file', () => {
+            const designPath = path.join(projectPath, "src", "static", "design");
+            const configPath = path.join(designPath, "babel.config.js");
+            const config = ProjectCompiler.loadBabelConfig(configPath);
+
+            expect(config).toBeDefined();
+            expect(config.presets).toBeDefined();
+            expect(config.presets!.length).toBeGreaterThan(0);
+        });
+
+        test('should throw argumentNull when configPath is empty', () => {
+            expect(() => ProjectCompiler.loadBabelConfig("")).toThrow();
+        });
+
+        test('should throw pathNotExists when configPath does not exist', () => {
+            expect(() => ProjectCompiler.loadBabelConfig("/nonexistent/babel.config.json")).toThrow();
+        });
+
+        test('should throw invalidBabelConfigExtension for unsupported file extension', () => {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-test-'));
+            try {
+                const configPath = path.join(tmpDir, 'babel.config.yaml');
+                fs.writeFileSync(configPath, 'test: true');
+
+                expect(() => ProjectCompiler.loadBabelConfig(configPath)).toThrow();
+            } finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+
+        test('should load config from .js file with default export', () => {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-test-'));
+            try {
+                const configPath = path.join(tmpDir, 'babel.config.js');
+                fs.writeFileSync(configPath, 'module.exports = { presets: ["@babel/preset-env"] };');
+                // Clear require cache
+                delete require.cache[require.resolve(configPath)];
+
+                const config = ProjectCompiler.loadBabelConfig(configPath);
+                expect(config.presets).toBeDefined();
+                expect(config.presets).toContainEqual("@babel/preset-env");
+            } finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+    });
+
+    // ========== getBabelConfig ==========
+
+    describe('getBabelConfig', () => {
+        test('should return config with ast=true and code=false when config exists', () => {
+            const staticPath = path.join(projectPath, "src", "static");
+            const result = ProjectCompiler.getBabelConfig(projectPath, staticPath);
+
+            expect(result.options).toBeDefined();
+            expect(result.options.ast).toBe(true);
+            expect(result.options.code).toBe(false);
+            expect(result.path).toBeTruthy();
+        });
+
+        test('should return default config when no config file found', () => {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-test-'));
+            try {
+                const result = ProjectCompiler.getBabelConfig(tmpDir, tmpDir);
+
+                expect(result.options).toBeDefined();
+                expect(result.options.ast).toBe(true);
+                expect(result.options.code).toBe(false);
+                expect(result.options.plugins).toBeDefined();
+                expect(result.options.presets).toBeDefined();
+                expect(result.path).toBe('');
+            } finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+
+        test('should set ast=true and code=false on found config', () => {
+            const staticPath = path.join(projectPath, "src", "static");
+            const result = ProjectCompiler.getBabelConfig(projectPath, staticPath);
+
+            expect(result.options.ast).toBe(true);
+            expect(result.options.code).toBe(false);
+        });
+
+        test('should return path to the found config file', () => {
+            const staticPath = path.join(projectPath, "src", "static");
+            const result = ProjectCompiler.getBabelConfig(projectPath, staticPath);
+            expect(result.path).toContain('babel.config.json');
+        });
+    });
+
+    // ========== getDefaultBabelConfig ==========
+
+    describe('getDefaultBabelConfig', () => {
+        test('should return config with plugins and presets', () => {
+            const config = ProjectCompiler.getDefaultBabelConfig();
+
+            expect(config).toBeDefined();
+            expect(config.plugins).toBeDefined();
+            expect(config.presets).toBeDefined();
+        });
+
+        test('should include expected plugins', () => {
+            const config = ProjectCompiler.getDefaultBabelConfig();
+            const pluginNames = config.plugins!.map(p => Array.isArray(p) ? p[0] : p);
+
+            expect(pluginNames).toContain("babel-plugin-transform-typescript-metadata");
+            expect(pluginNames).toContain("@babel/plugin-transform-typescript");
+            expect(pluginNames).toContain("@babel/plugin-transform-react-jsx");
+        });
+
+        test('should include expected presets', () => {
+            const config = ProjectCompiler.getDefaultBabelConfig();
+            const presetNames = config.presets!.map(p => Array.isArray(p) ? p[0] : p);
+
+            expect(presetNames).toContain("@babel/preset-env");
+        });
+
+        test('should have decorator plugin with legacy option', () => {
+            const config = ProjectCompiler.getDefaultBabelConfig();
+            const decoratorsPlugin = config.plugins!.find(p =>
+                Array.isArray(p) && p[0] === "@babel/plugin-proposal-decorators"
+            );
+
+            expect(decoratorsPlugin).toBeDefined();
+            expect(Array.isArray(decoratorsPlugin)).toBe(true);
+            expect((decoratorsPlugin as any[])[1]).toEqual({ legacy: true });
+        });
+
+        test('should include typescript plugin with isTSX option', () => {
+            const config = ProjectCompiler.getDefaultBabelConfig();
+            const tsPlugin = config.plugins!.find(p =>
+                Array.isArray(p) && p[0] === "@babel/plugin-transform-typescript"
+            );
+
+            expect(tsPlugin).toBeDefined();
+            expect(Array.isArray(tsPlugin)).toBe(true);
+            expect((tsPlugin as any[])[1]).toEqual({ isTSX: true });
+        });
+    });
+
+    // ========== tsOutExt ==========
+
+    describe('tsOutExt', () => {
+        test('should be ".js"', () => {
+            expect(ProjectCompiler.tsOutExt).toBe(".js");
+        });
+    });
+});

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

@@ -1,7 +0,0 @@
-/**
- * 编译特定文件，并生成到制定目录
- * @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

@@ -1,153 +0,0 @@
-"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;
-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 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);
-}
-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;
-        }
-    }
-}