@modern-js/babel-compiler 2.69.4 → 3.0.0-alpha.0

package/dist/cjs/utils.js

@@ -1,42 +1,39 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  addSourceMappingUrl: () => addSourceMappingUrl
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    addSourceMappingUrl: ()=>addSourceMappingUrl
 });
-module.exports = __toCommonJS(utils_exports);
-var path = __toESM(require("path"));
+const external_path_namespaceObject = require("path");
 function addSourceMappingUrl(code, loc) {
-  return `${code}
-//# sourceMappingURL=${path.normalize(path.basename(loc))}`;
+    return `${code}\n//# sourceMappingURL=${external_path_namespaceObject.normalize(external_path_namespaceObject.basename(loc))}`;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  addSourceMappingUrl
+exports.addSourceMappingUrl = __webpack_exports__.addSourceMappingUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "addSourceMappingUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/validate.js

@@ -1,72 +1,78 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var validate_exports = {};
-__export(validate_exports, {
-  sourceDirAndFileNamesValidMessage: () => sourceDirAndFileNamesValidMessage,
-  validate: () => validate,
-  validateSourceDirAndFileNames: () => validateSourceDirAndFileNames,
-  validateWatchDir: () => validateWatchDir,
-  watchDirValidMessage: () => watchDirValidMessage
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    sourceDirAndFileNamesValidMessage: ()=>sourceDirAndFileNamesValidMessage,
+    validateSourceDirAndFileNames: ()=>validateSourceDirAndFileNames,
+    validateWatchDir: ()=>validateWatchDir,
+    watchDirValidMessage: ()=>watchDirValidMessage,
+    validate: ()=>validate
 });
-module.exports = __toCommonJS(validate_exports);
-var import_utils = require("@modern-js/utils");
-const sourceDirAndFileNamesValidMessage = "At least one of the sourceDir and filenames configurations must be configured";
-const watchDirValidMessage = "should set watchDir when enableWatch is true";
-const validateSourceDirAndFileNames = (compilerOptions) => {
-  const { sourceDir, filenames, quiet } = compilerOptions;
-  if (!sourceDir && !filenames) {
-    if (!quiet) {
-      import_utils.logger.error(sourceDirAndFileNamesValidMessage);
+const utils_namespaceObject = require("@modern-js/utils");
+const sourceDirAndFileNamesValidMessage = 'At least one of the sourceDir and filenames configurations must be configured';
+const watchDirValidMessage = 'should set watchDir when enableWatch is true';
+const validateSourceDirAndFileNames = (compilerOptions)=>{
+    const { sourceDir, filenames, quiet } = compilerOptions;
+    if (!sourceDir && !filenames) {
+        if (!quiet) utils_namespaceObject.logger.error(sourceDirAndFileNamesValidMessage);
+        return {
+            code: 1,
+            message: sourceDirAndFileNamesValidMessage,
+            virtualDists: []
+        };
     }
-    return {
-      code: 1,
-      message: sourceDirAndFileNamesValidMessage,
-      virtualDists: []
-    };
-  }
-  return null;
+    return null;
 };
-const validateWatchDir = (compilerOptions) => {
-  const { watchDir, enableWatch, quiet } = compilerOptions;
-  if (enableWatch && !watchDir) {
-    if (!quiet) {
-      import_utils.logger.error(watchDirValidMessage);
+const validateWatchDir = (compilerOptions)=>{
+    const { watchDir, enableWatch, quiet } = compilerOptions;
+    if (enableWatch && !watchDir) {
+        if (!quiet) utils_namespaceObject.logger.error(watchDirValidMessage);
+        return {
+            code: 1,
+            message: watchDirValidMessage,
+            virtualDists: []
+        };
     }
-    return {
-      code: 1,
-      message: watchDirValidMessage,
-      virtualDists: []
-    };
-  }
-  return null;
+    return null;
 };
-const validate = (compilerOptions) => {
-  if (compilerOptions.enableWatch) {
-    return validateWatchDir(compilerOptions);
-  }
-  return validateSourceDirAndFileNames(compilerOptions);
+const validate = (compilerOptions)=>{
+    if (compilerOptions.enableWatch) return validateWatchDir(compilerOptions);
+    return validateSourceDirAndFileNames(compilerOptions);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  sourceDirAndFileNamesValidMessage,
-  validate,
-  validateSourceDirAndFileNames,
-  validateWatchDir,
-  watchDirValidMessage
+exports.sourceDirAndFileNamesValidMessage = __webpack_exports__.sourceDirAndFileNamesValidMessage;
+exports.validate = __webpack_exports__.validate;
+exports.validateSourceDirAndFileNames = __webpack_exports__.validateSourceDirAndFileNames;
+exports.validateWatchDir = __webpack_exports__.validateWatchDir;
+exports.watchDirValidMessage = __webpack_exports__.watchDirValidMessage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "sourceDirAndFileNamesValidMessage",
+    "validate",
+    "validateSourceDirAndFileNames",
+    "validateWatchDir",
+    "watchDirValidMessage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/esm/build.mjs

@@ -0,0 +1,42 @@
+import { fs, logger } from "@modern-js/utils";
+import { compiler } from "./compiler";
+import { defaultDistFileExtMap } from "./constants";
+const build = async (option, babelConfig = {})=>{
+    const { rootDir, enableVirtualDist, filenames, clean, distDir, distFileExtMap = defaultDistFileExtMap, verbose = false, quiet = false } = option;
+    const virtualDists = [];
+    if (clean) await fs.remove(distDir);
+    fs.ensureDir(distDir);
+    const messageDetails = [];
+    for (const filename of filenames)try {
+        const dist = compiler({
+            rootDir,
+            enableVirtualDist,
+            filepath: filename,
+            distDir,
+            verbose,
+            quiet,
+            babelConfig,
+            distFileExtMap
+        });
+        if (enableVirtualDist && dist) virtualDists.push(dist);
+    } catch (e) {
+        messageDetails.push({
+            filename,
+            content: e.toString()
+        });
+    }
+    const happenError = messageDetails.length > 0;
+    if (!quiet) if (happenError) logger.error(`Compilation failure ${messageDetails.length} ${1 !== messageDetails.length ? 'files' : 'file'} with Babel.`);
+    else logger.info(`Successfully compiled ${filenames.length} ${1 !== filenames.length ? 'files' : 'file'} with Babel.`);
+    if (happenError) return {
+        code: 1,
+        message: `Compilation failure ${messageDetails.length} ${1 !== messageDetails.length ? 'files' : 'file'} with Babel.`,
+        messageDetails
+    };
+    return {
+        code: 0,
+        message: `Successfully compiled ${filenames.length} ${1 !== filenames.length ? 'files' : 'file'} with Babel.`,
+        virtualDists
+    };
+};
+export { build };

package/dist/esm/buildWatch.mjs

@@ -0,0 +1,78 @@
+import { EventEmitter } from "events";
+import { normalize, relative } from "path";
+import { WatchChangeType, logger, watch } from "@modern-js/utils";
+import { build } from "./build";
+import { CompilerErrorResult } from "./compilerErrorResult";
+const BuildWatchEvent = {
+    firstCompiler: 'first-compiler',
+    compiling: 'compiling',
+    watchingCompiler: 'watching-compiler'
+};
+class BuildWatchEmitter extends EventEmitter {
+    setInitFn(fn) {
+        this._initFn = fn;
+    }
+    async watch() {
+        if ('function' == typeof this._initFn) return this._initFn(this);
+        return null;
+    }
+}
+const runBuildWatch = async (option, babelConfig = {}, emitter)=>{
+    emitter.emit(BuildWatchEvent.compiling);
+    const errorResult = new CompilerErrorResult();
+    const watchDir = option.watchDir;
+    const { distDir, quiet } = option;
+    const firstBuildResult = await build(option, babelConfig);
+    const { code } = firstBuildResult;
+    if (1 === code) {
+        errorResult.init(firstBuildResult);
+        emitter.emit(BuildWatchEvent.firstCompiler, errorResult.value);
+    } else emitter.emit(BuildWatchEvent.firstCompiler, firstBuildResult);
+    return watch(`${watchDir}/**/*.{js,jsx,ts,tsx}`, async ({ changeType, changedFilePath })=>{
+        emitter.emit(BuildWatchEvent.compiling);
+        if (changeType === WatchChangeType.UNLINK) {
+            const removeFiles = [
+                normalize(`./${distDir}/${relative(watchDir, changedFilePath)}`)
+            ];
+            if (!quiet) logger.info(`remove file: ${removeFiles.join(',')}`);
+            const result = {
+                code: 0,
+                message: `remove file: ${removeFiles.join(',')}`,
+                removeFiles
+            };
+            emitter.emit(BuildWatchEvent.watchingCompiler, result);
+            return;
+        }
+        const result = await build({
+            ...option,
+            filenames: [
+                changedFilePath
+            ]
+        }, babelConfig);
+        if (1 === result.code) {
+            errorResult.update(result.messageDetails || []);
+            emitter.emit(BuildWatchEvent.watchingCompiler, errorResult.value);
+            quiet || logger.info(errorResult.value.message);
+        } else {
+            errorResult.removeByFileName(changedFilePath);
+            if (errorResult.checkExistError()) {
+                emitter.emit(BuildWatchEvent.watchingCompiler, {
+                    ...errorResult.value,
+                    virtualDists: result.virtualDists
+                });
+                quiet || logger.info(errorResult.value.message);
+            } else {
+                emitter.emit(BuildWatchEvent.watchingCompiler, result);
+                quiet || logger.info(result.message);
+            }
+        }
+    }, [
+        `${watchDir}/**/*.d.ts`
+    ]);
+};
+const buildWatch = (option, babelConfig = {})=>{
+    const buildWatchEmitter = new BuildWatchEmitter();
+    buildWatchEmitter.setInitFn(runBuildWatch.bind(null, option, babelConfig));
+    return buildWatchEmitter;
+};
+export { BuildWatchEmitter, BuildWatchEvent, buildWatch, runBuildWatch };

package/dist/esm/compiler.mjs

@@ -0,0 +1,76 @@
+import { basename, dirname, extname, join, relative } from "path";
+import { transformFileSync } from "@babel/core";
+import { fs, logger } from "@modern-js/utils";
+import { defaultDistFileExtMap } from "./constants";
+import { addSourceMappingUrl } from "./utils";
+const defaultDistDir = 'dist';
+const isRes = (r)=>Boolean(r);
+const getDistFilePath = (option)=>{
+    const { filepath, rootDir, distDir, extMap } = option;
+    const ext = extname(filepath);
+    return join(distDir, relative(rootDir, filepath).replace(ext, extMap[ext]));
+};
+const resolveSourceMap = (option)=>{
+    const { babelRes, sourceFilePath, distFilePath, enableVirtualDist = false } = option;
+    const mapLoc = `${distFilePath}.map`;
+    babelRes.code = addSourceMappingUrl(babelRes.code, mapLoc);
+    if (babelRes.map) {
+        babelRes.map.file = basename(distFilePath);
+        babelRes.map.sources = [
+            relative(dirname(distFilePath), sourceFilePath)
+        ];
+    }
+    const sourceMapVirtualDist = {
+        sourcemap: JSON.stringify(babelRes.map),
+        sourceMapPath: mapLoc
+    };
+    if (enableVirtualDist) return sourceMapVirtualDist;
+    fs.ensureDirSync(dirname(mapLoc));
+    fs.writeFileSync(mapLoc, JSON.stringify(babelRes.map));
+    return sourceMapVirtualDist;
+};
+const compiler = (option)=>{
+    const { filepath, rootDir, enableVirtualDist = false, distDir = join(dirname(rootDir), defaultDistDir), verbose = false, babelConfig = {}, distFileExtMap = defaultDistFileExtMap, quiet = false } = option;
+    const babelRes = transformFileSync(filepath, babelConfig);
+    let virtualDist = null;
+    if (!isRes(babelRes)) throw new Error(`${filepath} happen error`);
+    const distFilePath = getDistFilePath({
+        filepath,
+        rootDir,
+        distDir,
+        extMap: distFileExtMap
+    });
+    if (enableVirtualDist) virtualDist = {
+        distPath: distFilePath,
+        sourceMapPath: '',
+        code: '',
+        sourcemap: ''
+    };
+    if (babelRes?.map && babelConfig.sourceMaps && 'inline' !== babelConfig.sourceMaps) if (virtualDist) virtualDist = {
+        ...virtualDist,
+        ...resolveSourceMap({
+            babelRes,
+            sourceFilePath: filepath,
+            distFilePath,
+            enableVirtualDist
+        })
+    };
+    else resolveSourceMap({
+        babelRes,
+        sourceFilePath: filepath,
+        distFilePath,
+        enableVirtualDist
+    });
+    if (virtualDist) virtualDist = {
+        ...virtualDist,
+        distPath: distFilePath,
+        code: babelRes.code
+    };
+    else {
+        fs.ensureDirSync(dirname(distFilePath));
+        fs.writeFileSync(distFilePath, babelRes.code);
+    }
+    if (verbose && !quiet) logger.info(`${filepath} => ${distFilePath}`);
+    return virtualDist;
+};
+export { compiler, getDistFilePath, isRes, resolveSourceMap };

package/dist/esm/compilerErrorResult.mjs

@@ -0,0 +1,34 @@
+class CompilerErrorResult {
+    init(initErrorResult) {
+        this._messageDetails = initErrorResult?.messageDetails || [];
+    }
+    update(messageDetails) {
+        for (const messageDetail of messageDetails){
+            const addError = !this._messageDetails.some((detail)=>{
+                if (detail.filename === messageDetail.filename) {
+                    detail.content = messageDetail.content;
+                    return true;
+                }
+                return false;
+            });
+            if (addError) this._messageDetails.push(messageDetail);
+        }
+    }
+    removeByFileName(filename) {
+        this._messageDetails = this._messageDetails.filter((detail)=>detail.filename !== filename);
+    }
+    get value() {
+        return {
+            code: 1,
+            message: `Compilation failure ${this._messageDetails?.length} files with Babel.`,
+            messageDetails: this._messageDetails
+        };
+    }
+    checkExistError() {
+        return this._messageDetails.length > 0;
+    }
+    constructor(initErrorResult){
+        this.init(initErrorResult);
+    }
+}
+export { CompilerErrorResult };

package/dist/esm/constants.mjs

@@ -0,0 +1,7 @@
+const defaultDistFileExtMap = {
+    '.js': '.js',
+    '.jsx': '.js',
+    '.ts': '.js',
+    '.tsx': '.js'
+};
+export { defaultDistFileExtMap };

package/dist/esm/defaults.mjs

@@ -0,0 +1,17 @@
+import { defaultDistFileExtMap } from "./constants";
+const defaultOptions = {
+    enableWatch: false,
+    enableVirtualDist: false,
+    extensions: [],
+    filenames: [],
+    distFileExtMap: defaultDistFileExtMap,
+    ignore: [],
+    quiet: false,
+    verbose: false,
+    clean: false
+};
+const mergeDefaultOption = (compilerOptions)=>({
+        ...defaultOptions,
+        ...compilerOptions
+    });
+export { mergeDefaultOption };

package/dist/esm/getFinalOption.mjs

@@ -0,0 +1,50 @@
+import { DEFAULT_EXTENSIONS } from "@babel/core";
+import { glob } from "@modern-js/utils";
+import { mergeDefaultOption } from "./defaults";
+const getGlobPattern = (dir, extensions)=>{
+    if (extensions.length > 1) return `${dir}/**/*{${extensions.join(',')}}`;
+    if (1 === extensions.length) return `${dir}/**/*${extensions[0]}`;
+    return `${dir}/**/*`;
+};
+const getFinalExtensions = (extensions)=>{
+    const isExtensions = (ext)=>Array.isArray(ext);
+    const isExtensionsFunc = (ext)=>'function' == typeof ext;
+    if (isExtensions(extensions)) return [
+        ...extensions,
+        ...DEFAULT_EXTENSIONS
+    ];
+    if (isExtensionsFunc(extensions)) return extensions(DEFAULT_EXTENSIONS);
+    return DEFAULT_EXTENSIONS;
+};
+const getFilesFromDir = ({ dir, finalExt = [], ignore = [] })=>{
+    let globFindFilenames = [];
+    const globPattern = getGlobPattern(dir, finalExt);
+    globFindFilenames = glob.sync(globPattern, {
+        ignore
+    });
+    return globFindFilenames;
+};
+const getFinalCompilerOption = (option)=>{
+    const optionWithDefault = mergeDefaultOption(option);
+    const { sourceDir, ignore, enableWatch = false, watchDir, extensions = DEFAULT_EXTENSIONS } = option;
+    let globFindFilenames = [];
+    const finalExt = getFinalExtensions(extensions);
+    if (sourceDir) globFindFilenames = getFilesFromDir({
+        dir: sourceDir,
+        ignore,
+        finalExt
+    });
+    if (enableWatch) globFindFilenames = getFilesFromDir({
+        dir: watchDir,
+        ignore,
+        finalExt
+    });
+    return {
+        ...optionWithDefault,
+        filenames: [
+            ...optionWithDefault.filenames,
+            ...globFindFilenames
+        ]
+    };
+};
+export { getFilesFromDir, getFinalCompilerOption, getFinalExtensions, getGlobPattern };

package/dist/{esm-node/index.js → esm/index.mjs}

@@ -2,20 +2,13 @@ import { build } from "./build";
 import { buildWatch } from "./buildWatch";
 import { getFinalCompilerOption } from "./getFinalOption";
 import { validate } from "./validate";
+export * from "./buildWatch";
+export * from "./type";
 async function compiler(compilerOptions, babelOptions = {}) {
-  const validRet = validate(compilerOptions);
-  if (validRet) {
-    return validRet;
-  }
-  const finalCompilerOption = getFinalCompilerOption(compilerOptions);
-  if (compilerOptions.enableWatch) {
-    return buildWatch(finalCompilerOption, babelOptions);
-  } else {
+    const validRet = validate(compilerOptions);
+    if (validRet) return validRet;
+    const finalCompilerOption = getFinalCompilerOption(compilerOptions);
+    if (compilerOptions.enableWatch) return buildWatch(finalCompilerOption, babelOptions);
     return build(finalCompilerOption, babelOptions);
-  }
 }
-export * from "./buildWatch";
-export * from "./type";
-export {
-  compiler
-};
+export { compiler };

package/dist/esm/utils.mjs

@@ -0,0 +1,5 @@
+import { basename, normalize } from "path";
+function addSourceMappingUrl(code, loc) {
+    return `${code}\n//# sourceMappingURL=${normalize(basename(loc))}`;
+}
+export { addSourceMappingUrl };

package/dist/esm/validate.mjs

@@ -0,0 +1,32 @@
+import { logger } from "@modern-js/utils";
+const sourceDirAndFileNamesValidMessage = 'At least one of the sourceDir and filenames configurations must be configured';
+const watchDirValidMessage = 'should set watchDir when enableWatch is true';
+const validateSourceDirAndFileNames = (compilerOptions)=>{
+    const { sourceDir, filenames, quiet } = compilerOptions;
+    if (!sourceDir && !filenames) {
+        if (!quiet) logger.error(sourceDirAndFileNamesValidMessage);
+        return {
+            code: 1,
+            message: sourceDirAndFileNamesValidMessage,
+            virtualDists: []
+        };
+    }
+    return null;
+};
+const validateWatchDir = (compilerOptions)=>{
+    const { watchDir, enableWatch, quiet } = compilerOptions;
+    if (enableWatch && !watchDir) {
+        if (!quiet) logger.error(watchDirValidMessage);
+        return {
+            code: 1,
+            message: watchDirValidMessage,
+            virtualDists: []
+        };
+    }
+    return null;
+};
+const validate = (compilerOptions)=>{
+    if (compilerOptions.enableWatch) return validateWatchDir(compilerOptions);
+    return validateSourceDirAndFileNames(compilerOptions);
+};
+export { sourceDirAndFileNamesValidMessage, validate, validateSourceDirAndFileNames, validateWatchDir, watchDirValidMessage };

package/dist/esm-node/build.mjs

@@ -0,0 +1,42 @@
+import { fs, logger } from "@modern-js/utils";
+import { compiler } from "./compiler.mjs";
+import { defaultDistFileExtMap } from "./constants.mjs";
+const build = async (option, babelConfig = {})=>{
+    const { rootDir, enableVirtualDist, filenames, clean, distDir, distFileExtMap = defaultDistFileExtMap, verbose = false, quiet = false } = option;
+    const virtualDists = [];
+    if (clean) await fs.remove(distDir);
+    fs.ensureDir(distDir);
+    const messageDetails = [];
+    for (const filename of filenames)try {
+        const dist = compiler({
+            rootDir,
+            enableVirtualDist,
+            filepath: filename,
+            distDir,
+            verbose,
+            quiet,
+            babelConfig,
+            distFileExtMap
+        });
+        if (enableVirtualDist && dist) virtualDists.push(dist);
+    } catch (e) {
+        messageDetails.push({
+            filename,
+            content: e.toString()
+        });
+    }
+    const happenError = messageDetails.length > 0;
+    if (!quiet) if (happenError) logger.error(`Compilation failure ${messageDetails.length} ${1 !== messageDetails.length ? 'files' : 'file'} with Babel.`);
+    else logger.info(`Successfully compiled ${filenames.length} ${1 !== filenames.length ? 'files' : 'file'} with Babel.`);
+    if (happenError) return {
+        code: 1,
+        message: `Compilation failure ${messageDetails.length} ${1 !== messageDetails.length ? 'files' : 'file'} with Babel.`,
+        messageDetails
+    };
+    return {
+        code: 0,
+        message: `Successfully compiled ${filenames.length} ${1 !== filenames.length ? 'files' : 'file'} with Babel.`,
+        virtualDists
+    };
+};
+export { build };