maishu-scripts 1.2.1 → 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/less-compile.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 编译特定Less文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+declare const compileFile: (filePath: string, outDir: string, projectPath: string) => Promise<void>;
+export default compileFile;

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

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const less_1 = __importDefault(require("less"));
+const errors_1 = require("../errors");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * 编译特定Less文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+const compileFile = async (filePath, outDir, projectPath) => {
+    if (!filePath)
+        throw errors_1.errors.argumentNull('filePath');
+    if (!outDir)
+        throw errors_1.errors.argumentNull('outDir');
+    if (!projectPath)
+        throw errors_1.errors.argumentNull('projectPath');
+    let content = fs_1.default.readFileSync(filePath, 'utf-8');
+    let result = await less_1.default.render(content, { filename: filePath });
+    let ext = path_1.default.extname(filePath);
+    let outExt = '.css';
+    let targetPath = path_1.default.join(projectPath, outDir, path_1.default.basename(filePath).replace(ext, outExt));
+    let outDirPath = path_1.default.resolve(targetPath, "..");
+    if (!fs_1.default.existsSync(outDirPath))
+        fs_1.default.mkdirSync(outDirPath, { recursive: true });
+    fs_1.default.writeFileSync(targetPath, result.css);
+};
+exports.default = compileFile;

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

@@ -0,0 +1,9 @@
+import type { FileAction } from '../../types';
+/**
+ * 编译特定SCSS文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+export declare const compileFile: FileAction;
+export default compileFile;

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

@@ -0,0 +1,65 @@
+"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.compileFile = void 0;
+const sass = __importStar(require("sass"));
+const errors_1 = require("../errors");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * 编译特定SCSS文件，并生成到指定目录
+ * @param filePath 源文件路径，绝对路径
+ * @param outDir 输出目录，相对于项目路径
+ * @param projectPath 项目路径，绝对路径
+ */
+const compileFile = (filePath, outDir, projectPath) => {
+    if (!filePath)
+        throw errors_1.errors.argumentNull('filePath');
+    if (!outDir)
+        throw errors_1.errors.argumentNull('outDir');
+    if (!projectPath)
+        throw errors_1.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());
+};
+exports.compileFile = compileFile;
+exports.default = exports.compileFile;

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 {};