@modern-js/app-tools 2.58.2 → 2.59.0

package/dist/esm/commands/serve.js

@@ -0,0 +1,94 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { createProdServer } from "@modern-js/prod-server";
+import { SERVER_DIR, getMeta, getTargetDir, isApiOnly, logger } from "@modern-js/utils";
+import { loadServerPlugins } from "../utils/loadPlugins";
+import { printInstructions } from "../utils/printInstructions";
+var start = function() {
+  var _ref = _async_to_generator(function(api) {
+    var _userConfig_source, _userConfig_output_distPath, appContext, userConfig, hookRunners, distDirectory, appDirectory, internalDirectory, port, metaName, serverRoutes, serverConfigFile, apiOnly, runMode, meta, serverConfigPath, pluginInstances, app;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appContext = api.useAppContext();
+          userConfig = api.useResolvedConfigContext();
+          hookRunners = api.useHookRunners();
+          distDirectory = appContext.distDirectory, appDirectory = appContext.appDirectory, internalDirectory = appContext.internalDirectory, port = appContext.port, metaName = appContext.metaName, serverRoutes = appContext.serverRoutes, serverConfigFile = appContext.serverConfigFile;
+          logger.info("Starting production server...");
+          return [
+            4,
+            isApiOnly(appContext.appDirectory, userConfig === null || userConfig === void 0 ? void 0 : (_userConfig_source = userConfig.source) === null || _userConfig_source === void 0 ? void 0 : _userConfig_source.entriesDir, appContext.apiDirectory)
+          ];
+        case 1:
+          apiOnly = _state.sent();
+          if (apiOnly) {
+            runMode = "apiOnly";
+          }
+          meta = getMeta(metaName);
+          serverConfigPath = path.resolve(distDirectory, SERVER_DIR, "".concat(meta, ".server"));
+          return [
+            4,
+            loadServerPlugins(api, appDirectory, metaName)
+          ];
+        case 2:
+          pluginInstances = _state.sent();
+          return [
+            4,
+            createProdServer({
+              metaName,
+              pwd: distDirectory,
+              config: _object_spread_props(_object_spread({}, userConfig), {
+                dev: userConfig.dev,
+                // server-core can't get RegExp & Function output.enableInlineScripts by JSON.stringy;
+                output: _object_spread({
+                  path: (_userConfig_output_distPath = userConfig.output.distPath) === null || _userConfig_output_distPath === void 0 ? void 0 : _userConfig_output_distPath.root
+                }, userConfig.output || {})
+              }),
+              routes: serverRoutes,
+              plugins: pluginInstances,
+              serverConfigFile,
+              serverConfigPath,
+              appContext: {
+                appDirectory,
+                internalDirectory,
+                sharedDirectory: getTargetDir(appContext.sharedDirectory, appContext.appDirectory, appContext.distDirectory),
+                apiDirectory: getTargetDir(appContext.apiDirectory, appContext.appDirectory, appContext.distDirectory),
+                lambdaDirectory: getTargetDir(appContext.lambdaDirectory, appContext.appDirectory, appContext.distDirectory)
+              },
+              runMode
+            })
+          ];
+        case 3:
+          app = _state.sent();
+          app.listen(port, /* @__PURE__ */ _async_to_generator(function() {
+            return _ts_generator(this, function(_state2) {
+              switch (_state2.label) {
+                case 0:
+                  return [
+                    4,
+                    printInstructions(hookRunners, appContext, userConfig)
+                  ];
+                case 1:
+                  _state2.sent();
+                  return [
+                    2
+                  ];
+              }
+            });
+          }));
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function start2(api) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  start
+};

package/dist/esm/config/default.js

@@ -0,0 +1,190 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { MAIN_ENTRY_NAME } from "@modern-js/utils";
+import { getAutoInjectEnv } from "../utils/env";
+function createDefaultConfig(appContext) {
+  var dev = {
+    // `dev.port` should not have a default value
+    // because we will use `server.port` by default
+    port: void 0
+  };
+  var output = {
+    distPath: {
+      root: "dist",
+      html: "html",
+      js: "static/js",
+      css: "static/css",
+      server: "bundles",
+      worker: "worker"
+    },
+    cleanDistPath: true,
+    disableNodePolyfill: true,
+    enableInlineRouteManifests: true,
+    disableInlineRouteManifests: false
+  };
+  var _obj;
+  var source = {
+    entries: void 0,
+    mainEntryName: MAIN_ENTRY_NAME,
+    enableAsyncEntry: false,
+    enableCustomEntry: false,
+    disableDefaultEntries: false,
+    entriesDir: "./src",
+    configDir: "./config",
+    globalVars: getAutoInjectEnv(appContext),
+    alias: (_obj = {}, _define_property(_obj, appContext.internalDirAlias, appContext.internalDirectory), _define_property(_obj, appContext.internalSrcAlias, appContext.srcDirectory), _define_property(_obj, "@", appContext.srcDirectory), _define_property(_obj, "@shared", appContext.sharedDirectory), _obj)
+  };
+  var html = {
+    title: "",
+    mountId: "root",
+    meta: {
+      charset: {
+        charset: "utf-8"
+      },
+      viewport: "width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no",
+      "http-equiv": {
+        "http-equiv": "x-ua-compatible",
+        content: "ie=edge"
+      },
+      renderer: "webkit",
+      layoutmode: "standard",
+      imagemode: "force",
+      "wap-font-scale": "no",
+      "format-detection": "telephone=no"
+    }
+  };
+  var server = {
+    routes: void 0,
+    publicRoutes: void 0,
+    ssr: void 0,
+    ssrByEntries: void 0,
+    baseUrl: "/",
+    port: 8080
+  };
+  return {
+    source,
+    output,
+    server,
+    dev,
+    html,
+    tools: {
+      tsChecker: {
+        issue: {
+          exclude: [
+            {
+              file: "**/api/lambda/**/*"
+            }
+          ]
+        }
+      }
+    },
+    plugins: [],
+    builderPlugins: [],
+    runtime: {},
+    runtimeByEntries: {}
+  };
+}
+function createLegacyDefaultConfig(appContext) {
+  var _obj;
+  var defaultAlias = appContext ? (_obj = {}, _define_property(_obj, appContext.internalDirAlias, appContext.internalDirectory), _define_property(_obj, appContext.internalSrcAlias, appContext.srcDirectory), _define_property(_obj, "@", appContext.srcDirectory), _define_property(_obj, "@shared", appContext.sharedDirectory), _obj) : {};
+  var sourceDefaults = {
+    entries: void 0,
+    mainEntryName: MAIN_ENTRY_NAME,
+    enableAsyncEntry: false,
+    enableCustomEntry: false,
+    disableDefaultEntries: false,
+    entriesDir: "./src",
+    configDir: "./config",
+    apiDir: "./api",
+    envVars: [],
+    globalVars: getAutoInjectEnv(appContext),
+    alias: defaultAlias,
+    moduleScopes: void 0,
+    include: []
+  };
+  var outputDefaults = {
+    assetPrefix: "/",
+    htmlPath: "html",
+    jsPath: "static/js",
+    cssPath: "static/css",
+    mediaPath: "static/media",
+    path: "dist",
+    title: "",
+    titleByEntries: void 0,
+    meta: {
+      charset: {
+        charset: "utf-8"
+      },
+      viewport: "width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no",
+      "http-equiv": {
+        "http-equiv": "x-ua-compatible",
+        content: "ie=edge"
+      },
+      renderer: "webkit",
+      layoutmode: "standard",
+      imagemode: "force",
+      "wap-font-scale": "no",
+      "format-detection": "telephone=no"
+    },
+    metaByEntries: void 0,
+    inject: "head",
+    injectByEntries: void 0,
+    mountId: "root",
+    favicon: "",
+    faviconByEntries: void 0,
+    copy: void 0,
+    disableHtmlFolder: false,
+    disableCssModuleExtension: false,
+    disableCssExtract: false,
+    enableCssModuleTSDeclaration: false,
+    disableMinimize: false,
+    enableInlineStyles: false,
+    enableInlineScripts: false,
+    disableSourceMap: false,
+    disableInlineRuntimeChunk: false,
+    disableAssetsCache: false,
+    enableLatestDecorators: false,
+    polyfill: "entry",
+    dataUriLimit: 1e4,
+    templateParameters: {},
+    templateParametersByEntries: void 0,
+    cssModuleLocalIdentName: void 0,
+    disableNodePolyfill: false,
+    enableTsLoader: false
+  };
+  var serverDefaults = {
+    routes: void 0,
+    publicRoutes: void 0,
+    ssr: void 0,
+    ssrByEntries: void 0,
+    baseUrl: "/",
+    port: 8080
+  };
+  var devDefaults = {
+    assetPrefix: false,
+    https: false
+  };
+  var toolsDefaults = {
+    webpack: void 0,
+    babel: void 0,
+    postcss: void 0,
+    autoprefixer: void 0,
+    lodash: void 0,
+    devServer: void 0,
+    tsLoader: void 0,
+    terser: void 0,
+    minifyCss: void 0
+  };
+  return {
+    source: sourceDefaults,
+    output: outputDefaults,
+    server: serverDefaults,
+    dev: devDefaults,
+    tools: toolsDefaults,
+    runtime: {},
+    runtimeByEntries: {}
+  };
+}
+export {
+  createDefaultConfig,
+  createLegacyDefaultConfig
+};

package/dist/esm/config/index.js

@@ -0,0 +1,3 @@
+export * from "./legacy";
+export * from "./initialize";
+export * from "./default";

package/dist/esm/config/initialize/index.js

@@ -0,0 +1,9 @@
+import { initHtmlConfig, initSourceConfig } from "./inits";
+function initialNormalizedConfig(config, appContext, bundler) {
+  initHtmlConfig(config, appContext);
+  initSourceConfig(config, appContext, bundler);
+  return config;
+}
+export {
+  initialNormalizedConfig
+};

package/dist/esm/config/initialize/inits.js

@@ -0,0 +1,89 @@
+import path, { isAbsolute } from "path";
+import { findExists } from "@modern-js/utils";
+function initHtmlConfig(config, appContext) {
+  var ICON_EXTENSIONS = [
+    "png",
+    "jpg",
+    "jpeg",
+    "svg",
+    "ico"
+  ];
+  config.html.appIcon = createBuilderAppIcon(config, appContext);
+  config.html.favicon = createBuilderFavicon(config, appContext);
+  return config.html;
+  function createBuilderAppIcon(config2, appContext2) {
+    var appIcon = config2.html.appIcon;
+    var configDir = config2.source.configDir;
+    var getDefaultAppIcon = function() {
+      return findExists(ICON_EXTENSIONS.map(function(ext) {
+        return path.resolve(appContext2.appDirectory, configDir || "./config", "icon.".concat(ext));
+      }));
+    };
+    return appIcon || getDefaultAppIcon() || void 0;
+  }
+  function createBuilderFavicon(config2, appContext2) {
+    var configDir = config2.source.configDir;
+    var favicon = config2.html.favicon;
+    var getDefaultFavicon = function() {
+      return findExists(ICON_EXTENSIONS.map(function(ext) {
+        return path.resolve(appContext2.appDirectory, configDir || "./config", "favicon.".concat(ext));
+      }));
+    };
+    return favicon || getDefaultFavicon() || void 0;
+  }
+}
+function initSourceConfig(config, appContext, bundler) {
+  config.source.include = createBuilderInclude(config, appContext);
+  if (bundler === "webpack") {
+    config.source.moduleScopes = createBuilderModuleScope(config);
+  }
+}
+function createBuilderInclude(config, appContext) {
+  var include = config.source.include;
+  var defaultInclude = [
+    appContext.internalDirectory
+  ];
+  var transformInclude = (include || []).map(function(include2) {
+    if (typeof include2 === "string") {
+      if (isAbsolute(include2)) {
+        return include2;
+      }
+      return new RegExp(include2);
+    }
+    return include2;
+  }).concat(defaultInclude);
+  return transformInclude;
+}
+function createBuilderModuleScope(config) {
+  var moduleScopes = config.source.moduleScopes;
+  if (moduleScopes) {
+    var DEFAULT_SCOPES = [
+      "./src",
+      "./shared",
+      /node_modules/
+    ];
+    var builderModuleScope = applyScopeOptions(DEFAULT_SCOPES, moduleScopes);
+    return builderModuleScope;
+  } else {
+    return void 0;
+  }
+  function isPrimitiveScope(items) {
+    return items.every(function(item) {
+      return typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]";
+    });
+  }
+  function applyScopeOptions(defaults, options) {
+    if (Array.isArray(options)) {
+      if (isPrimitiveScope(options)) {
+        return defaults.concat(options);
+      }
+      return options.reduce(applyScopeOptions, defaults);
+    }
+    return options(defaults) || defaults;
+  }
+}
+export {
+  createBuilderModuleScope,
+  initHtmlConfig,
+  initSourceConfig
+};

package/dist/esm/config/legacy/createHtmlConfig.js

@@ -0,0 +1,21 @@
+function createHtmlConfig(config) {
+  var _config_output = config.output, disableHtmlFolder = _config_output.disableHtmlFolder, favicon = _config_output.favicon, faviconByEntries = _config_output.faviconByEntries, inject = _config_output.inject, injectByEntries = _config_output.injectByEntries, meta = _config_output.meta, metaByEntries = _config_output.metaByEntries, mountId = _config_output.mountId, title = _config_output.title, titleByEntries = _config_output.titleByEntries, templateParameters = _config_output.templateParameters, templateParametersByEntries = _config_output.templateParametersByEntries, crossorigin = _config_output.crossorigin;
+  return {
+    disableHtmlFolder,
+    favicon,
+    faviconByEntries,
+    inject,
+    injectByEntries,
+    meta,
+    metaByEntries,
+    mountId,
+    title,
+    titleByEntries,
+    crossorigin,
+    templateParameters,
+    templateParametersByEntries
+  };
+}
+export {
+  createHtmlConfig
+};

package/dist/esm/config/legacy/createOutputConfig.js

@@ -0,0 +1,45 @@
+function createOutputConfig(config) {
+  var _config_output = config.output, assetPrefix = _config_output.assetPrefix, copy = _config_output.copy, cssModuleLocalIdentName = _config_output.cssModuleLocalIdentName, cssPath = _config_output.cssPath, jsPath = _config_output.jsPath, htmlPath = _config_output.htmlPath, mediaPath = _config_output.mediaPath, enableTsLoader = _config_output.enableTsLoader, path = _config_output.path, disableInlineRuntimeChunk = _config_output.disableInlineRuntimeChunk, disableCssExtract = _config_output.disableCssExtract, disableMinimize = _config_output.disableMinimize, disableSourceMap = _config_output.disableSourceMap, disableTsChecker = _config_output.disableTsChecker, enableCssModuleTSDeclaration = _config_output.enableCssModuleTSDeclaration, enableInlineScripts = _config_output.enableInlineScripts, enableInlineStyles = _config_output.enableInlineStyles, polyfill = _config_output.polyfill, dataUriLimit = _config_output.dataUriLimit, disableAssetsCache = _config_output.disableAssetsCache, enableLatestDecorators = _config_output.enableLatestDecorators, disableCssModuleExtension = _config_output.disableCssModuleExtension, ssg = _config_output.ssg, disableNodePolyfill = _config_output.disableNodePolyfill;
+  return {
+    assetPrefix,
+    copy,
+    distPath: {
+      root: path,
+      css: cssPath,
+      js: jsPath,
+      html: htmlPath,
+      // modern.js v1 output all media files to `dist/media` by default
+      svg: mediaPath || "media",
+      image: mediaPath || "media",
+      font: mediaPath || "media",
+      media: mediaPath || "media"
+    },
+    dataUriLimit: {
+      svg: dataUriLimit,
+      image: dataUriLimit,
+      font: dataUriLimit,
+      media: dataUriLimit
+    },
+    cssModuleLocalIdentName,
+    disableCssExtract,
+    disableCssModuleExtension,
+    disableInlineRuntimeChunk,
+    disableMinimize,
+    disableSourceMap,
+    disableTsChecker: disableTsChecker || enableTsLoader,
+    enableCssModuleTSDeclaration,
+    enableInlineScripts,
+    enableInlineStyles,
+    polyfill,
+    disableFilenameHash: disableAssetsCache,
+    enableLatestDecorators,
+    ssg,
+    // set `true`, only in legacy config
+    enableAssetFallback: true,
+    enableAssetManifest: true,
+    disableNodePolyfill
+  };
+}
+export {
+  createOutputConfig
+};

package/dist/esm/config/legacy/createSourceConfig.js

@@ -0,0 +1,46 @@
+function createSourceConfig(config) {
+  var _config_source = config.source, alias = _config_source.alias, envVars = _config_source.envVars, globalVars = _config_source.globalVars, include = _config_source.include, moduleScopes = _config_source.moduleScopes, preEntry = _config_source.preEntry, entries = _config_source.entries, mainEntryName = _config_source.mainEntryName, enableAsyncEntry = _config_source.enableAsyncEntry, enableCustomEntry = _config_source.enableCustomEntry, disableDefaultEntries = _config_source.disableDefaultEntries, entriesDir = _config_source.entriesDir, configDir = _config_source.configDir;
+  var builderGlobalVars = globalVars || {};
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = (envVars || [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var envVar = _step.value;
+      var envVarValue = process.env[envVar];
+      envVarValue && (builderGlobalVars["process.env.".concat(envVar)] = envVarValue);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return {
+    alias,
+    moduleScopes,
+    globalVars: builderGlobalVars,
+    include,
+    preEntry,
+    entries,
+    mainEntryName,
+    enableAsyncEntry,
+    enableCustomEntry,
+    disableDefaultEntries,
+    entriesDir,
+    configDir,
+    resolveExtensionPrefix: {
+      web: ".web",
+      node: ".node"
+    }
+  };
+}
+export {
+  createSourceConfig
+};

package/dist/esm/config/legacy/createToolsConfig.js

@@ -0,0 +1,28 @@
+function createToolsConfig(config) {
+  var _config_tools = config.tools, autoprefixer = _config_tools.autoprefixer, babel = _config_tools.babel, minifyCss = _config_tools.minifyCss, terser = _config_tools.terser, webpack = _config_tools.webpack, webpackChain = _config_tools.webpackChain, tsLoader = _config_tools.tsLoader, styledComponents = _config_tools.styledComponents, sass = _config_tools.sass, postcss = _config_tools.postcss, less = _config_tools.less, htmlPlugin = _config_tools.htmlPlugin, devServer = _config_tools.devServer, tailwindcss = _config_tools.tailwindcss, jest = _config_tools.jest, esbuild = _config_tools.esbuild;
+  var enableTsLoader = config.output.enableTsLoader;
+  return {
+    tsLoader: enableTsLoader ? tsLoader : void 0,
+    autoprefixer,
+    babel,
+    minifyCss,
+    terser,
+    webpack,
+    webpackChain,
+    styledComponents,
+    sass,
+    postcss,
+    less,
+    htmlPlugin,
+    devServer,
+    tailwindcss,
+    jest,
+    esbuild: {
+      loader: false,
+      minimize: esbuild
+    }
+  };
+}
+export {
+  createToolsConfig
+};

package/dist/esm/config/legacy/index.js

@@ -0,0 +1,43 @@
+import { createHtmlConfig } from "./createHtmlConfig";
+import { createOutputConfig } from "./createOutputConfig";
+import { createSourceConfig } from "./createSourceConfig";
+import { createToolsConfig } from "./createToolsConfig";
+function transformNormalizedConfig(config) {
+  var html = createHtmlConfig(config);
+  var output = createOutputConfig(config);
+  var source = createSourceConfig(config);
+  var tools = createToolsConfig(config);
+  var bff = config.bff, dev = config.dev, deploy = config.deploy, runtime = config.runtime, runtimeByEntries = config.runtimeByEntries, server = config.server, cliOptions = config.cliOptions, plugins = config.plugins, testing = config.testing, autoLoadPlugins = config.autoLoadPlugins;
+  return {
+    source,
+    html,
+    output,
+    tools,
+    bff,
+    dev,
+    deploy,
+    runtime,
+    runtimeByEntries,
+    server,
+    cliOptions,
+    testing,
+    devtools: {},
+    builderPlugins: [],
+    plugins,
+    security: {},
+    _raw: {},
+    experiments: {},
+    environments: {},
+    autoLoadPlugins,
+    performance: {
+      removeMomentLocale: true
+    }
+  };
+}
+function checkIsLegacyConfig(config) {
+  return Boolean(config.legacy);
+}
+export {
+  checkIsLegacyConfig,
+  transformNormalizedConfig
+};

package/dist/esm/defineConfig.js

@@ -0,0 +1,16 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+var defineConfig = function(config) {
+  return config;
+};
+var defineLegacyConfig = function(config) {
+  var _config_autoLoadPlugins;
+  return _object_spread_props(_object_spread({}, config), {
+    legacy: true,
+    autoLoadPlugins: (_config_autoLoadPlugins = config.autoLoadPlugins) !== null && _config_autoLoadPlugins !== void 0 ? _config_autoLoadPlugins : true
+  });
+};
+export {
+  defineConfig,
+  defineLegacyConfig
+};

package/dist/esm/esm/esbuild-loader.mjs

@@ -0,0 +1,20 @@
+import { pathToFileURL } from 'url';
+import { createMatchPath } from './utils.mjs';
+
+let matchPath;
+export async function initialize({ appDir, alias, tsconfigPath }) {
+  matchPath = createMatchPath({
+    alias,
+    appDir,
+    tsconfigPath,
+  });
+}
+
+export function resolve(specifier, context, defaultResolve) {
+  const match = matchPath(specifier);
+  return match
+    ? defaultResolve(pathToFileURL(match).href, context)
+    : defaultResolve(specifier, context);
+}
+
+export { load } from 'esbuild-register/loader';

package/dist/esm/esm/register-esm.mjs

@@ -0,0 +1,66 @@
+import assert from 'node:assert';
+import path from 'node:path';
+import { fs, isVersionAtLeast1819, readTsConfigByFile } from '@modern-js/utils';
+
+const checkDep = async dep => {
+  try {
+    await import(dep);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+export const registerEsm = async ({ appDir, distDir, alias }) => {
+  const nodeVersion = process.versions.node;
+  const versionArr = nodeVersion.split('.').map(Number);
+
+  assert(
+    isVersionAtLeast1819(nodeVersion),
+    `The node version of the esm project must be greater than 18.19.0, current version is ${nodeVersion}`,
+  );
+  const hasTsNode = await checkDep('ts-node');
+  const TS_CONFIG_FILENAME = `tsconfig.json`;
+  const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
+  const hasTsconfig = await fs.pathExists(tsconfigPath);
+  const { register } = await import('node:module');
+  if (hasTsNode && hasTsconfig) {
+    // These can be overridden by ts-node options in tsconfig.json
+    process.env.TS_NODE_TRANSPILE_ONLY = true;
+    process.env.TS_NODE_PROJECT = tsconfigPath;
+    process.env.TS_NODE_SCOPE = true;
+    process.env.TS_NODE_FILES = true;
+    process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${path.relative(
+      appDir,
+      distDir,
+    )}/`;
+    register('./ts-node-loader.mjs', import.meta.url, {
+      data: {
+        appDir,
+        distDir,
+        alias,
+        tsconfigPath,
+      },
+    });
+  } else {
+    process.env.MODERN_NODE_LOADER = 'esbuild';
+    let tsConfig = {};
+    if (hasTsconfig) {
+      tsConfig = readTsConfigByFile(tsconfigPath);
+    }
+    const esbuildRegister = await import('esbuild-register/dist/node');
+    esbuildRegister.register({
+      tsconfigRaw: hasTsconfig ? tsConfig : undefined,
+      hookIgnoreNodeModules: true,
+      hookMatcher: fileName => !fileName.startsWith(distDir),
+    });
+    register('./esbuild-loader.mjs', import.meta.url, {
+      data: {
+        appDir,
+        distDir,
+        alias,
+        tsconfigPath,
+      },
+    });
+  }
+};