maishu-scripts 1.4.2 → 1.4.5

package/src/modules/configs.ts

@@ -2,8 +2,7 @@ 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";
+import copyFile from "./actions/copy-file";
 
 // const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
 
@@ -12,9 +11,10 @@ const fileActions: Record<string, FileAction> = {
     ".tsx": createBielCompiler(),
     ".scss": scssCompile,
     ".less": lessCompile,
+    ".map": copyFile,
 }
 
-class Options {
+export class Config {
     fileActions: Record<string, FileAction> = fileActions;
     skipFiles: Record<string, RegExp[]> = {
         ".tsx": [/\.d\.tsx?$/, /\.test\.tsx?$/, /\.spec\.tsx?$/],
@@ -24,6 +24,5 @@ class Options {
     };
 }
 
-const NAME = "maishu-scripts-options";
-(global as any)[NAME] = (global as any)[NAME] || new Options();
-export default (global as any)[NAME] as Options;
+const config = new Config();
+export default config;

package/src/modules/errors.ts

@@ -21,6 +21,14 @@ class Errors extends BaseErrors {
         error.name = Errors.prototype.invalidBabelConfigExtension.name;
         return error;
     }
+    copyFileError(sourcePath: string, destPath: string, innerError?: Error) {
+        let error = new Error(`Failed to copy file from "${sourcePath}" to "${destPath}"`);
+        error.name = Errors.prototype.copyFileError.name;
+        if (innerError) {
+            error.cause = innerError;
+        }
+        return error;
+    }
 }
 
 export const errors = new Errors();

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");
+        });
+    });
+});