maishu-scripts 1.3.0 → 1.4.0

package/out/index.d.ts

@@ -1,2 +1,11 @@
+import copyFile from "./modules/actions/copy-file";
 export { generateCode, watchDirectory } from "./modules/compile";
 export { run } from "./modules/run";
+export declare const options: {
+    fileActions: Record<string, import("./types").FileAction>;
+    skipFiles: Record<string, RegExp[]>;
+};
+export { create as createTsCompiler } from "./modules/actions/ts-compile";
+export { create as createBielCompiler } from "./modules/actions/babel-compile";
+export { copyFile };
+export { FileAction } from "./types";

package/out/index.js

@@ -1,11 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = exports.watchDirectory = exports.generateCode = void 0;
+exports.copyFile = exports.createBielCompiler = exports.createTsCompiler = exports.options = exports.run = exports.watchDirectory = exports.generateCode = void 0;
+const configs_1 = __importDefault(require("./modules/configs"));
+const copy_file_1 = __importDefault(require("./modules/actions/copy-file"));
+exports.copyFile = copy_file_1.default;
 var compile_1 = require("./modules/compile");
 Object.defineProperty(exports, "generateCode", { enumerable: true, get: function () { return compile_1.generateCode; } });
 Object.defineProperty(exports, "watchDirectory", { enumerable: true, get: function () { return compile_1.watchDirectory; } });
 var run_1 = require("./modules/run");
 Object.defineProperty(exports, "run", { enumerable: true, get: function () { return run_1.run; } });
-// let sourceDir = "src";
-// let outDir = "out";
-// generateCode(sourceDir, outDir);
+exports.options = configs_1.default;
+var ts_compile_1 = require("./modules/actions/ts-compile");
+Object.defineProperty(exports, "createTsCompiler", { enumerable: true, get: function () { return ts_compile_1.create; } });
+var babel_compile_1 = require("./modules/actions/babel-compile");
+Object.defineProperty(exports, "createBielCompiler", { enumerable: true, get: function () { return babel_compile_1.create; } });

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

@@ -0,0 +1,3 @@
+import * as babel from "@babel/core";
+import { FileAction } from "../../types";
+export declare function create(babelOptions?: babel.TransformOptions): FileAction;

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

@@ -0,0 +1,185 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+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;
+function create(babelOptions) {
+    const action = (sourcePath, outputPath, projectPath) => {
+        if (!babelOptions) {
+            let bablePath;
+            let sourceDir = path.dirname(sourcePath);
+            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;
+        }
+        return compileFile(sourcePath, outputPath, projectPath, babelOptions);
+    };
+    return action;
+}
+/**
+ * 编译特定文件，并生成到制定目录
+ * @param sourcePath 源文件路径
+ * @param outputPath 输出目录
+ * @param projectPath 项目路径
+ * */
+async function compileFile(sourcePath, outputPath, projectPath, babelOptions) {
+    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: babel.TransformOptions;
+    let bablePath;
+    //= projectPath ?
+    //  ProjectCompiler.getBabelConfig(projectPath, sourceDir) : ProjectCompiler.getDefaultBabelConfig();
+    if (projectPath) {
+        //     let c = ProjectCompiler.getBabelConfig(projectPath, sourceDir);
+        //     bablePath = c.path;
+        //     babelOptions = c.options;
+    }
+    else {
+        //     babelOptions = 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;
+        }
+    }
+}

package/out/modules/actions/copy-file.js

@@ -15,18 +15,28 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("../errors");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-let copyFile = (filePath, outPath, projectPath) => {
+let copyFile = (filePath, outPath) => {
     if (!filePath)
         throw errors_1.errors.argumentNull("filePath");
     if (!outPath)

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

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileFile = void 0;
 const sass = __importStar(require("sass"));

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

@@ -1,10 +1,5 @@
 import * as ts from 'typescript';
-/**
- * 编译特定文件，并生成到制定目录
- * @param filePath 源文件路径，绝对路径
- * @param outDir 输出目录，相对于项目路径
- * @param projectPath 项目路径，绝对路径
- * */
-export declare function compileFile(filePath: string, outDir: string, projectPath: string): Promise<void>;
+import { FileAction } from '../../types';
+export declare function create(compilerOptions?: ts.CompilerOptions): FileAction;
 export declare function getTypescriptConfig(projectPath: string, directoryPath: string): ts.CompilerOptions;
 export declare function findTypeScriptConfigPath(projectPath: string, directoryPath: string): string | null;

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

@@ -15,15 +15,25 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileFile = compileFile;
+exports.create = create;
 exports.getTypescriptConfig = getTypescriptConfig;
 exports.findTypeScriptConfigPath = findTypeScriptConfigPath;
 const ts = __importStar(require("typescript"));
@@ -32,25 +42,31 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const project_compiler_1 = require("../project-compiler");
 const TS_CONFIG_FILE = 'tsconfig.json';
+function create(compilerOptions) {
+    const action = async (filePath, outDir, projectPath) => {
+        if (!compilerOptions) {
+            compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+        }
+        return compileFile(filePath, outDir, projectPath, compilerOptions);
+    };
+    return action;
+}
 /**
  * 编译特定文件，并生成到制定目录
  * @param filePath 源文件路径，绝对路径
  * @param outDir 输出目录，相对于项目路径
  * @param projectPath 项目路径，绝对路径
  * */
-async function compileFile(filePath, outDir, projectPath) {
+async function compileFile(filePath, outDir, projectPath, compilerOptions) {
     if (!filePath)
         throw errors_1.errors.argumentNull('sourcePath');
     if (!outDir)
         throw errors_1.errors.argumentNull('outDir');
     if (!projectPath)
         throw errors_1.errors.argumentNull('projectPath');
-    if (!path.isAbsolute(filePath))
-        throw errors_1.errors.notAbsolutePath(filePath);
     let content = fs.readFileSync(filePath, 'utf-8');
-    let compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
+    // let compilerOptions = getTypescriptConfig(projectPath, path.dirname(filePath));
     let result = ts.transpileModule(content, { compilerOptions });
-    console.log(result.outputText);
     let ext = path.extname(filePath);
     let outExt = project_compiler_1.ProjectCompiler.tsOutExt;
     let targetPath = path.join(projectPath, outDir, path.basename(filePath).replace(ext, outExt));
@@ -58,6 +74,12 @@ async function compileFile(filePath, outDir, projectPath) {
     if (!fs.existsSync(outDirPath))
         fs.mkdirSync(outDirPath, { recursive: true });
     fs.writeFileSync(targetPath, result.outputText);
+    // 编译声明文件
+    if (compilerOptions.declaration && result.outputText) {
+        const d = ts.transpileDeclaration(content, { compilerOptions });
+        const declPath = targetPath.replace(outExt, '.d.ts');
+        fs.writeFileSync(declPath, d.outputText);
+    }
 }
 function getTypescriptConfig(projectPath, directoryPath) {
     let configPath = findTypeScriptConfigPath(projectPath, directoryPath);

package/out/modules/compile.d.ts

@@ -1,5 +1,18 @@
+import { FileAction } from "../types";
+type Callback = (filePath: string, outDir: string, projectPath: string) => void;
 /** 将 sourceDir 目录下所有文件生成到 outDir */
-export declare function generateCode(sourceDir: string, outDir: string, projectPath: string, callback?: (filePath: string, outDir: string, projectPath: string) => void): void;
-/** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
-export declare function watchDirectory(sourceRoot: string, outRoot: string, projectPath: string, callback?: (filePath: string, outDir: string, projectPath: string) => void): void;
+export declare function generateCode(sourceDir: Options): void;
+export declare function generateCode(sourceDir: string, outDir: string, projectPath: string, callback?: Callback): void;
+/** 监听 sourceDir 目录下所有文件变化，并生成到 outDir */
+export declare function watchDirectory(sourceDir: Options): void;
+export declare function watchDirectory(sourceDir: string, outDir: string, projectPath: string, callback?: Callback): void;
 export declare function isIgnoredFile(filePath: string): boolean;
+type Options = {
+    sourceDir: string;
+    outDir: string;
+    projectPath: string;
+    skipFiles?: RegExp[];
+    fileAction?: (fileName: string) => FileAction | undefined;
+    callback?: Callback;
+};
+export {};

package/out/modules/compile.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -33,21 +43,68 @@ const fs = __importStar(require("fs"));
 const node_watch_1 = __importDefault(require("node-watch"));
 const path = __importStar(require("path"));
 const errors_1 = require("./errors");
-const biel_compile_1 = require("./actions/biel-compile");
+// import { compileFile as tsCompileFile } from "./actions/ts-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 configs_1 = __importDefault(require("./configs"));
 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 */
-function generateCode(sourceDir, outDir, projectPath, callback) {
+extCopy.forEach(ext => configs_1.default.fileActions[ext] = copy_file_1.default);
+function generateCode(arg1, outDir, projectPath, callback) {
+    let options = {};
+    if (typeof arg1 == "object") {
+        options = arg1;
+    }
+    else {
+        options.sourceDir = arg1;
+        options.outDir = outDir;
+        options.projectPath = projectPath;
+        options.callback = callback;
+    }
+    if (!options.sourceDir)
+        throw errors_1.errors.argumentNull("sourceDir");
+    if (!options.outDir)
+        throw errors_1.errors.argumentNull("outDir");
+    if (!options.projectPath)
+        throw errors_1.errors.argumentNull("projectPath");
+    if (!fs.existsSync(options.sourceDir))
+        throw errors_1.errors.pathNotExists(options.sourceDir);
+    return generateCodeByOptions(options);
+}
+function watchDirectory(arg1, outDir, projectPath, callback) {
+    let options = {};
+    if (typeof arg1 == "object") {
+        options = arg1;
+    }
+    else {
+        options.sourceDir = arg1;
+        options.outDir = outDir;
+        options.projectPath = projectPath;
+        options.callback = callback;
+    }
+    if (!options.sourceDir)
+        throw errors_1.errors.argumentNull("sourceDir");
+    if (!options.outDir)
+        throw errors_1.errors.argumentNull("outDir");
+    if (!options.projectPath)
+        throw errors_1.errors.argumentNull("projectPath");
+    if (!fs.existsSync(options.sourceDir))
+        throw errors_1.errors.pathNotExists(options.sourceDir);
+    return watchDirectoryByOptions(options);
+}
+function isIgnoredFile(filePath) {
+    if (!filePath)
+        throw errors_1.errors.argumentNull("filePath");
+    const ext = extname(filePath);
+    const skipFiles = configs_1.default.skipFiles[ext] || [];
+    let isSkip = skipFiles.some(pattern => pattern.test(filePath));
+    return isSkip;
+}
+function extname(file) {
+    // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
+    let ext = path.extname(file);
+    return ext;
+}
+function generateCodeByOptions(options) {
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback } = options;
     if (!sourceDir)
         throw errors_1.errors.argumentNull("sourceDir");
     if (!outDir)
@@ -62,13 +119,18 @@ function generateCode(sourceDir, outDir, projectPath, callback) {
         if (!fs.statSync(filePath).isFile()) {
             continue;
         }
-        let isSkip = isIgnoredFile(filePath); //skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+        let ext = extname(file);
+        skipFiles = skipFiles || configs_1.default.skipFiles[ext] || [];
+        let isSkip = skipFiles.some(pattern => pattern.test(filePath));
         if (isSkip) {
             console.log(`Skip ${filePath}`);
             continue;
         }
-        let ext = extname(file);
-        let action = fileActions[ext];
+        fileActions = fileActions || function (fileName) {
+            const ext = path.extname(fileName);
+            return configs_1.default.fileActions[ext];
+        };
+        let action = fileActions(filePath);
         if (action) {
             action(filePath, outDir, projectPath);
             if (callback) {
@@ -81,25 +143,30 @@ function generateCode(sourceDir, outDir, projectPath, callback) {
         let fullPath = path.join(sourceDir, dir);
         let outDirPath = path.join(outDir, dir);
         if (fs.statSync(fullPath).isDirectory()) {
-            generateCode(fullPath, outDirPath, projectPath);
+            generateCodeByOptions({ sourceDir: fullPath, outDir: outDirPath, projectPath: projectPath, skipFiles, fileAction: fileActions, callback });
         }
     }
 }
-/** 监听 sourceRoot 目录下所有文件变化，并生成到 outRoot */
-function watchDirectory(sourceRoot, outRoot, projectPath, callback) {
-    if (!sourceRoot)
-        throw errors_1.errors.argumentNull("sourceRoot");
-    if (!outRoot)
-        throw errors_1.errors.argumentNull("outRoot");
-    if (!projectPath)
-        throw errors_1.errors.argumentNull("projectPath");
-    (0, node_watch_1.default)(sourceRoot, { recursive: true }, async (evt, name) => {
-        let action = fileActions[extname(name)];
-        let outPath = path.dirname(name).replace(sourceRoot, outRoot);
+function watchDirectoryByOptions(options) {
+    let { sourceDir, outDir, projectPath, skipFiles, fileAction: fileActions, callback } = options;
+    (0, node_watch_1.default)(sourceDir, { recursive: true }, async (evt, name) => {
+        const filePath = name;
+        const ext = extname(filePath);
+        skipFiles = skipFiles || configs_1.default.skipFiles[ext] || [];
+        let isSkip = skipFiles.some(pattern => pattern.test(filePath)); //isIgnoredFile(filePath);//skipFiles.some(pattern => new RegExp(pattern).test(filePath));
+        if (isSkip) {
+            console.log(`Skip ${filePath}`);
+            return;
+        }
+        if (evt === "remove") {
+            return;
+        }
+        let action = fileActions?.(filePath) || configs_1.default.fileActions[ext];
         if (!action) {
             return;
         }
         try {
+            let outPath = path.dirname(name).replace(sourceDir, outDir);
             action(name, outPath, projectPath);
             if (callback)
                 callback(name, outPath, projectPath);
@@ -109,14 +176,3 @@ function watchDirectory(sourceRoot, outRoot, projectPath, callback) {
         }
     });
 }
-function isIgnoredFile(filePath) {
-    if (!filePath)
-        throw errors_1.errors.argumentNull("filePath");
-    let isSkip = skipFiles.some(pattern => new RegExp(pattern).test(filePath));
-    return isSkip;
-}
-function extname(file) {
-    // let ext = /\.[a-zA-Z]+/.exec(file)?.[0] || '';
-    let ext = path.extname(file);
-    return ext;
-}

package/out/modules/configs.d.ts

@@ -0,0 +1,7 @@
+import { FileAction } from "../types";
+declare class Options {
+    fileActions: Record<string, FileAction>;
+    skipFiles: Record<string, RegExp[]>;
+}
+declare const _default: Options;
+export default _default;

package/out/modules/configs.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const scss_compile_1 = __importDefault(require("./actions/scss-compile"));
+const less_compile_1 = __importDefault(require("./actions/less-compile"));
+const babel_compile_1 = require("./actions/babel-compile");
+// const skipFiles = ["\\S+\\.d\\.tsx?$", "\\S+\\.test\\.tsx?$", "\\S+\\.spec\\.tsx?$"]
+const fileActions = {
+    ".ts": (0, babel_compile_1.create)(),
+    ".tsx": (0, babel_compile_1.create)(),
+    ".scss": scss_compile_1.default,
+    ".less": less_compile_1.default,
+};
+class Options {
+    fileActions = fileActions;
+    skipFiles = {
+        ".tsx": [/\.d\.tsx?$/, /\.test\.tsx?$/, /\.spec\.tsx?$/],
+        ".ts": [/\.d\.ts$/, /\.test\.ts$/, /\.spec\.ts$/],
+        ".scss": [],
+        ".less": [],
+    };
+}
+const NAME = "maishu-scripts-options";
+global[NAME] = global[NAME] || new Options();
+exports.default = global[NAME];