@modern-js/server-utils 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/compilers/typescript/tsconfigPathsPlugin.js

@@ -1,204 +1,170 @@
 "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 tsconfigPathsPlugin_exports = {};
-__export(tsconfigPathsPlugin_exports, {
-  tsconfigPathsBeforeHookFactory: () => tsconfigPathsBeforeHookFactory
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module1)=>{
+        var getter = module1 && module1.__esModule ? ()=>module1['default'] : ()=>module1;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    tsconfigPathsBeforeHookFactory: ()=>tsconfigPathsBeforeHookFactory
 });
-module.exports = __toCommonJS(tsconfigPathsPlugin_exports);
-var os = __toESM(require("os"));
-var import_path = __toESM(require("path"));
-var import_tsconfig_paths = require("@modern-js/utils/tsconfig-paths");
-var ts = __toESM(require("typescript"));
-const isRegExpKey = (str) => {
-  return str.startsWith("^") || str.endsWith("$");
-};
-const resolveAliasPath = (baseUrl, filePath) => {
-  if (filePath.startsWith(".") || filePath.startsWith("..")) {
-    return import_path.default.resolve(baseUrl, filePath);
-  }
-  return filePath;
-};
-const createAliasMatcher = (baseUrl, alias) => {
-  const aliasPairs = Object.keys(alias).reduce((o, key) => {
-    if (isRegExpKey(key)) {
-      const regexp = new RegExp(key);
-      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
-      o.push([
-        regexp,
-        aliasPath
-      ]);
-    } else {
-      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
-      o.push([
-        key,
-        aliasPath
-      ]);
-    }
-    return o;
-  }, []);
-  const cacheMap = /* @__PURE__ */ new Map();
-  return (requestedModule) => {
-    if (cacheMap.has(requestedModule)) {
-      return cacheMap.get(requestedModule);
-    }
-    for (const [key, value] of aliasPairs) {
-      if (key instanceof RegExp) {
-        if (key.test(requestedModule)) {
-          cacheMap.set(requestedModule, value);
-          return value;
-        }
-      }
-      if (requestedModule === key) {
-        cacheMap.set(requestedModule, value);
-        return value;
-      }
-    }
-  };
+const external_os_namespaceObject = require("os");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
+const external_typescript_namespaceObject = require("typescript");
+const isRegExpKey = (str)=>str.startsWith('^') || str.endsWith('$');
+const resolveAliasPath = (baseUrl, filePath)=>{
+    if (filePath.startsWith('.') || filePath.startsWith('..')) return external_path_default().resolve(baseUrl, filePath);
+    return filePath;
 };
-const isDynamicImport = (tsBinary, node) => {
-  return tsBinary.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
-};
-function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
-  const tsPaths = {};
-  const alias = {};
-  Object.keys(paths).forEach((key) => {
-    if (Array.isArray(paths[key])) {
-      tsPaths[key] = paths[key];
-    } else {
-      alias[key] = paths[key];
-    }
-  });
-  const matchAliasPath = createAliasMatcher(baseUrl, alias);
-  const matchTsPath = (0, import_tsconfig_paths.createMatchPath)(baseUrl, tsPaths, [
-    "main"
-  ]);
-  const matchPath = (requestedModule, readJSONSync, fileExists, extensions) => {
-    const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
-    if (result) {
-      return result;
-    }
-    return matchAliasPath(requestedModule);
-  };
-  if (Object.keys(paths).length === 0) {
-    return void 0;
-  }
-  return (ctx) => {
-    return (sf) => {
-      const visitNode = (node) => {
-        if (isDynamicImport(tsBinary, node)) {
-          const importPathWithQuotes = node.arguments[0].getText(sf);
-          const text = importPathWithQuotes.slice(1, importPathWithQuotes.length - 1);
-          const result = getNotAliasedPath(sf, matchPath, text);
-          if (!result) {
-            return node;
-          }
-          return tsBinary.factory.updateCallExpression(node, node.expression, node.typeArguments, tsBinary.factory.createNodeArray([
-            tsBinary.factory.createStringLiteral(result)
-          ]));
+const createAliasMatcher = (baseUrl, alias)=>{
+    const aliasPairs = Object.keys(alias).reduce((o, key)=>{
+        if (isRegExpKey(key)) {
+            const regexp = new RegExp(key);
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                regexp,
+                aliasPath
+            ]);
+        } else {
+            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+            o.push([
+                key,
+                aliasPath
+            ]);
         }
-        if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) {
-          try {
-            var _node_moduleSpecifier;
-            const importPathWithQuotes = node === null || node === void 0 ? void 0 : (_node_moduleSpecifier = node.moduleSpecifier) === null || _node_moduleSpecifier === void 0 ? void 0 : _node_moduleSpecifier.getText();
-            if (!importPathWithQuotes) {
-              return node;
-            }
-            const text = importPathWithQuotes.substring(1, importPathWithQuotes.length - 1);
-            const result = getNotAliasedPath(sf, matchPath, text);
-            if (!result) {
-              return node;
+        return o;
+    }, []);
+    const cacheMap = new Map();
+    return (requestedModule)=>{
+        if (cacheMap.has(requestedModule)) return cacheMap.get(requestedModule);
+        for (const [key, value] of aliasPairs){
+            if (key instanceof RegExp) {
+                if (key.test(requestedModule)) {
+                    cacheMap.set(requestedModule, value);
+                    return value;
+                }
             }
-            const moduleSpecifier = tsBinary.factory.createStringLiteral(result);
-            moduleSpecifier.parent = node.moduleSpecifier.parent;
-            let newNode;
-            if (tsBinary.isImportDeclaration(node)) {
-              newNode = tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
-            } else {
-              newNode = tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+            if (requestedModule === key) {
+                cacheMap.set(requestedModule, value);
+                return value;
             }
-            newNode.flags = node.flags;
-            return newNode;
-          } catch {
-            return node;
-          }
         }
-        return tsBinary.visitEachChild(node, visitNode, ctx);
-      };
-      return tsBinary.visitNode(sf, visitNode);
     };
-  };
+};
+const isDynamicImport = (tsBinary, node)=>tsBinary.isCallExpression(node) && node.expression.kind === external_typescript_namespaceObject.SyntaxKind.ImportKeyword;
+function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
+    const tsPaths = {};
+    const alias = {};
+    Object.keys(paths).forEach((key)=>{
+        if (Array.isArray(paths[key])) tsPaths[key] = paths[key];
+        else alias[key] = paths[key];
+    });
+    const matchAliasPath = createAliasMatcher(baseUrl, alias);
+    const matchTsPath = (0, tsconfig_paths_namespaceObject.createMatchPath)(baseUrl, tsPaths, [
+        'main'
+    ]);
+    const matchPath = (requestedModule, readJSONSync, fileExists, extensions)=>{
+        const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
+        if (result) return result;
+        return matchAliasPath(requestedModule);
+    };
+    if (0 === Object.keys(paths).length) return;
+    return (ctx)=>(sf)=>{
+            const visitNode = (node)=>{
+                if (isDynamicImport(tsBinary, node)) {
+                    const importPathWithQuotes = node.arguments[0].getText(sf);
+                    const text = importPathWithQuotes.slice(1, importPathWithQuotes.length - 1);
+                    const result = getNotAliasedPath(sf, matchPath, text);
+                    if (!result) return node;
+                    return tsBinary.factory.updateCallExpression(node, node.expression, node.typeArguments, tsBinary.factory.createNodeArray([
+                        tsBinary.factory.createStringLiteral(result)
+                    ]));
+                }
+                if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) try {
+                    const importPathWithQuotes = node?.moduleSpecifier?.getText();
+                    if (!importPathWithQuotes) return node;
+                    const text = importPathWithQuotes.substring(1, importPathWithQuotes.length - 1);
+                    const result = getNotAliasedPath(sf, matchPath, text);
+                    if (!result) return node;
+                    const moduleSpecifier = tsBinary.factory.createStringLiteral(result);
+                    moduleSpecifier.parent = node.moduleSpecifier.parent;
+                    let newNode;
+                    newNode = tsBinary.isImportDeclaration(node) ? tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause) : tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+                    newNode.flags = node.flags;
+                    return newNode;
+                } catch  {
+                    return node;
+                }
+                return tsBinary.visitEachChild(node, visitNode, ctx);
+            };
+            return tsBinary.visitNode(sf, visitNode);
+        };
 }
 function getNotAliasedPath(sf, matcher, text) {
-  let result = matcher(text, void 0, void 0, [
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx"
-  ]);
-  if (!result) {
-    return;
-  }
-  if (os.platform() === "win32") {
-    result = result.replace(/\\/g, "/");
-  }
-  if (!import_path.default.isAbsolute(result)) {
-    if (!result.startsWith(".") && !result.startsWith("..")) {
-      try {
-        const packagePath = require.resolve(result, {
-          paths: [
-            process.cwd(),
-            ...module.paths
-          ]
-        });
-        if (packagePath) {
-          return result;
-        }
-      } catch {
-      }
-    }
-    try {
-      const packagePath = require.resolve(text, {
-        paths: [
-          process.cwd(),
-          ...module.paths
-        ]
-      });
-      if (packagePath) {
-        return text;
-      }
-    } catch {
+    let result = matcher(text, void 0, void 0, [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx'
+    ]);
+    if (!result) return;
+    if ('win32' === external_os_namespaceObject.platform()) result = result.replace(/\\/g, '/');
+    if (!external_path_default().isAbsolute(result)) {
+        if (!result.startsWith('.') && !result.startsWith('..')) try {
+            const packagePath = require.resolve(result, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return result;
+        } catch  {}
+        try {
+            const packagePath = require.resolve(text, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return text;
+        } catch  {}
     }
-  }
-  const resolvedPath = import_path.posix.relative((0, import_path.dirname)(sf.fileName), result) || "./";
-  return resolvedPath[0] === "." ? resolvedPath : `./${resolvedPath}`;
+    const resolvedPath = external_path_namespaceObject.posix.relative((0, external_path_namespaceObject.dirname)(sf.fileName), result) || './';
+    return '.' === resolvedPath[0] ? resolvedPath : `./${resolvedPath}`;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  tsconfigPathsBeforeHookFactory
+exports.tsconfigPathsBeforeHookFactory = __webpack_exports__.tsconfigPathsBeforeHookFactory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "tsconfigPathsBeforeHookFactory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/compilers/typescript/typescriptLoader.js

@@ -1,48 +1,54 @@
 "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 typescriptLoader_exports = {};
-__export(typescriptLoader_exports, {
-  TypescriptLoader: () => TypescriptLoader
+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__, {
+    TypescriptLoader: ()=>TypescriptLoader
 });
-module.exports = __toCommonJS(typescriptLoader_exports);
 class TypescriptLoader {
-  load() {
-    if (this.tsBinary) {
-      return this.tsBinary;
+    load() {
+        if (this.tsBinary) return this.tsBinary;
+        try {
+            const tsPath = require.resolve("typescript", {
+                paths: [
+                    this.appDirectory || process.cwd()
+                ]
+            });
+            const ts = require(tsPath);
+            return ts;
+        } catch (error) {
+            throw new Error('TypeScript could not be found! Please, install "typescript" package.');
+        }
     }
-    try {
-      const tsPath = require.resolve("typescript", {
-        paths: [
-          this.appDirectory || process.cwd()
-        ]
-      });
-      const ts = require(tsPath);
-      return ts;
-    } catch (error) {
-      throw new Error('TypeScript could not be found! Please, install "typescript" package.');
+    constructor({ appDirectory }){
+        this.appDirectory = appDirectory;
     }
-  }
-  constructor({ appDirectory }) {
-    this.appDirectory = appDirectory;
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TypescriptLoader
+exports.TypescriptLoader = __webpack_exports__.TypescriptLoader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TypescriptLoader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/index.js

@@ -1,31 +1,71 @@
 "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 __webpack_modules__ = {
+    "./common" (module) {
+        module.exports = require("./common/index.js");
+    },
+    "./compilers/babel" (module) {
+        module.exports = require("./compilers/babel/index.js");
+    }
 };
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-__export(src_exports, {
-  compile: () => import_common.compile
-});
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./compilers/babel"), module.exports);
-var import_common = require("./common");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  compile,
-  ...require("./compilers/babel")
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+        compile: ()=>_common__rspack_import_1.compile
+    });
+    var _compilers_babel__rspack_import_0 = __webpack_require__("./compilers/babel");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _compilers_babel__rspack_import_0)if ([
+        "compile",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_compilers_babel__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _common__rspack_import_1 = __webpack_require__("./common");
+})();
+exports.compile = __webpack_exports__.compile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/esm/common/index.mjs

@@ -0,0 +1,29 @@
+import { isAbsolute } from "path";
+import { fs } from "@modern-js/utils";
+const FILE_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs',
+    '.ejs'
+];
+const validateAbsolutePath = (filename, message)=>{
+    if (!isAbsolute(filename)) throw new Error(message);
+};
+const validateAbsolutePaths = (filenames, messageFunc)=>{
+    filenames.forEach((filename)=>validateAbsolutePath(filename, messageFunc(filename)));
+};
+const compile = async (appDirectory, modernConfig, compileOptions)=>{
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    validateAbsolutePaths(sourceDirs, (dir)=>`source dir ${dir} is not an absolute path.`);
+    validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+    const compiler = modernConfig?.server?.compiler;
+    const isTsProject = tsconfigPath && await fs.pathExists(tsconfigPath);
+    if (isTsProject && 'babel' !== compiler) {
+        const { compileByTs } = await import("../compilers/typescript");
+        await compileByTs(appDirectory, modernConfig, compileOptions);
+    } else {
+        const { compileByBabel } = await import("../compilers/babel");
+        await compileByBabel(appDirectory, modernConfig, compileOptions);
+    }
+};
+export { FILE_EXTENSIONS, compile };

package/dist/esm/compilers/babel/index.mjs

@@ -0,0 +1,57 @@
+import { basename as external_path_basename, extname, join } from "path";
+import { compiler } from "@modern-js/babel-compiler";
+import { fs, getAliasConfig, json5 } from "@modern-js/utils";
+import { FILE_EXTENSIONS } from "../../common";
+import { applyUserBabelConfig, getBabelConfig } from "./preset";
+export * from "@babel/core";
+const readTsConfig = (tsconfigPath, noExistReturn = null)=>{
+    if (!fs.existsSync(tsconfigPath)) return noExistReturn;
+    const content = fs.readFileSync(tsconfigPath, 'utf-8');
+    return json5.parse(content);
+};
+const existTsConfigFile = (tsconfigAbsolutePath)=>{
+    const tsconfig = readTsConfig(tsconfigAbsolutePath);
+    return Boolean(tsconfig);
+};
+const resolveBabelConfig = (appDirectory, config, option, isEsm)=>{
+    const { alias, babelConfig } = config;
+    const aliasConfig = getAliasConfig(alias, {
+        appDirectory,
+        ...option
+    });
+    const defaultBabelConfig = getBabelConfig({
+        appDirectory,
+        alias: aliasConfig,
+        isEsm
+    });
+    return applyUserBabelConfig(defaultBabelConfig, babelConfig);
+};
+const compileByBabel = async (appDirectory, config, compileOptions)=>{
+    const { sourceDirs, distDir, tsconfigPath, moduleType } = compileOptions;
+    const isEsm = 'module' === moduleType;
+    const results = await Promise.all(sourceDirs.map(async (sourceDir)=>{
+        const babelConfig = resolveBabelConfig(appDirectory, config, {
+            tsconfigPath: tsconfigPath ? tsconfigPath : ''
+        }, isEsm);
+        if (await fs.pathExists(sourceDir)) {
+            const basename = external_path_basename(sourceDir);
+            const targetDir = join(distDir, basename);
+            await fs.copy(sourceDir, targetDir, {
+                filter: (src)=>![
+                        '.ts',
+                        '.js'
+                    ].includes(extname(src)) && src !== tsconfigPath
+            });
+        }
+        return compiler({
+            rootDir: appDirectory,
+            distDir,
+            sourceDir,
+            extensions: FILE_EXTENSIONS
+        }, babelConfig);
+    }));
+    results.forEach((result)=>{
+        if (1 === result.code) throw new Error(result.message);
+    });
+};
+export { compileByBabel, existTsConfigFile, readTsConfig, resolveBabelConfig };