@modern-js/app-tools 2.48.6 → 2.49.1-alpha.0

package/dist/cjs/plugins/deploy/entrys/vercel.js

@@ -0,0 +1,95 @@
+"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 vercel_exports = {};
+__export(vercel_exports, {
+  genVercelEntry: () => genVercelEntry
+});
+module.exports = __toCommonJS(vercel_exports);
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../utils");
+function genVercelEntry({ config, plugins, appContext } = {}) {
+  const defaultConfig = {
+    server: {
+      port: 8080
+    },
+    output: {
+      path: "."
+    }
+  };
+  return `
+
+  const fs = require('node:fs/promises');
+  const path = require('node:path');
+  const { createNetlifyFunction } = require('@modern-js/prod-server/netlify');
+  ${(0, import_utils2.genPluginImportsCode)(plugins || [])}
+
+  let requestHandler = null;
+
+  if(!process.env.NODE_ENV){
+    process.env.NODE_ENV = 'production';
+  }
+
+  async function createHandler() {
+    try {
+      let routes = [];
+      const routeFilepath = path.join(__dirname, "${import_utils.ROUTE_SPEC_FILE}");
+      try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, "utf-8");
+        const routeSpec = JSON.parse(content);
+        routes = routeSpec.routes;
+      } catch (error) {
+        console.warn('route.json not found, continuing with empty routes.');
+      }
+
+      const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        config: ${JSON.stringify(config || defaultConfig)},
+        serverConfigFile: '${import_utils.DEFAULT_SERVER_CONFIG}',
+        plugins: ${(0, import_utils2.getPluginsCode)(plugins || [])},
+        appContext: ${appContext ? (0, import_utils2.severAppContextTemplate)(appContext) : "undefined"},
+        disableCustomHook: true
+      }
+
+      requestHandler = await createNetlifyFunction(prodServerOptions)
+
+      return requestHandler
+    } catch(error) {
+      console.error(error);
+      process.exit(1);
+    }
+  }
+
+  createHandler();
+
+  const handleRequest = async(request, context) => {
+    if(typeof requestHandler !== 'function'){
+      await createHandler();
+    }
+    return requestHandler(request, context);
+  }
+
+  export default handleRequest;
+  `;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genVercelEntry
+});

package/dist/cjs/plugins/deploy/index.js

@@ -0,0 +1,140 @@
+"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 deploy_exports = {};
+__export(deploy_exports, {
+  default: () => deploy_default
+});
+module.exports = __toCommonJS(deploy_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("./utils");
+var import_dependencies = require("./dependencies");
+var deploy_default = () => ({
+  name: "@modern-js/plugin-deploy",
+  pre: [
+    "@modern-js/plugin-bff",
+    "@modern-js/plugin-server"
+  ],
+  setup: (api) => {
+    return {
+      async beforeDeploy() {
+        const deployTarget = process.env.MODERNJS_DEPLOY || "node";
+        const appContext = api.useAppContext();
+        const { appDirectory, distDirectory, serverInternalPlugins, sharedDirectory, apiDirectory, lambdaDirectory, metaName } = appContext;
+        const configContext = api.useResolvedConfigContext();
+        const outputDirectory = import_path.default.join(appDirectory, ".output");
+        let funcsDirectory = outputDirectory;
+        let staticDirectory = import_path.default.join(outputDirectory, "static");
+        await import_utils.fs.remove(outputDirectory);
+        if (deployTarget === "node") {
+          await import_utils.fs.copy(distDirectory, outputDirectory, {
+            filter: (src) => {
+              const distStaticDirectory = import_path.default.join(distDirectory, "static");
+              return !src.includes(distStaticDirectory);
+            }
+          });
+        }
+        if (deployTarget === "vercel") {
+          funcsDirectory = import_path.default.join(outputDirectory, "functions");
+          staticDirectory = import_path.default.join(outputDirectory, "static");
+          await import_utils.fs.copy(distDirectory, funcsDirectory, {
+            filter: (src) => {
+              const distStaticDirectory = import_path.default.join(distDirectory, "static");
+              return !src.includes(distStaticDirectory);
+            }
+          });
+          await import_utils.fs.copy(import_path.default.join(distDirectory, "static"), staticDirectory);
+          await import_utils.fs.writeJSON(import_path.default.join(funcsDirectory, ".vc-config.json"), {
+            runtime: "nodejs16.x",
+            handler: "index.js",
+            launcherType: "Nodejs",
+            shouldAddHelpers: false,
+            supportsResponseStreaming: true
+          });
+        }
+        const { bff } = configContext;
+        const config = {
+          output: {
+            path: "."
+          },
+          bff
+        };
+        const plugins = (0, import_utils.getInternalPlugins)(appDirectory, serverInternalPlugins);
+        const serverAppContext = {
+          sharedDirectory: `path.join(__dirname, "${import_path.default.relative(appDirectory, sharedDirectory)}")`,
+          apiDirectory: `path.join(__dirname, "${import_path.default.relative(appDirectory, apiDirectory)}")`,
+          lambdaDirectory: `path.join(__dirname, "${import_path.default.relative(appDirectory, lambdaDirectory)}")`,
+          metaName
+        };
+        let code = ``;
+        console.log("deployTarget111111111", deployTarget);
+        switch (deployTarget) {
+          case "node": {
+            const { genNodeEntry } = await Promise.resolve().then(() => __toESM(require("./entrys/node")));
+            code = genNodeEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          case "vercel": {
+            const { genVercelEntry } = await Promise.resolve().then(() => __toESM(require("./entrys/vercel")));
+            code = genVercelEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          case "netlify": {
+            const { genNetlifyEntry } = await Promise.resolve().then(() => __toESM(require("./entrys/netlify")));
+            code = genNetlifyEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          default: {
+            code = `throw new Error("unknown deploy target, MODERNJS_DEPLOY should be set");`;
+          }
+        }
+        const { useSSR, useAPI, useWebServer } = (0, import_utils2.getProjectUsage)(appDirectory, distDirectory);
+        const entryFilePath = import_path.default.join(funcsDirectory, "index.js");
+        if (useSSR || useAPI || useWebServer) {
+          await import_utils.fs.writeFile(entryFilePath, code);
+        }
+        await (0, import_dependencies.handleDependencies)(appDirectory, funcsDirectory, [
+          "@modern-js/prod-server"
+        ]);
+      }
+    };
+  }
+});

package/dist/cjs/plugins/deploy/utils.js

@@ -0,0 +1,150 @@
+"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, {
+  applyProductionCondition: () => applyProductionCondition,
+  applyPublicCondition: () => applyPublicCondition,
+  genPluginImportsCode: () => genPluginImportsCode,
+  getPluginsCode: () => getPluginsCode,
+  getProjectUsage: () => getProjectUsage,
+  linkPackage: () => linkPackage,
+  severAppContextTemplate: () => severAppContextTemplate,
+  writePackage: () => writePackage
+});
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_node_os = __toESM(require("node:os"));
+var import_utils = require("@modern-js/utils");
+var import_mlly = require("mlly");
+const severAppContextTemplate = (serverAppContext) => {
+  return `{
+    sharedDirectory: ${serverAppContext.sharedDirectory},
+    apiDirectory: ${serverAppContext.apiDirectory},
+    lambdaDirectory: ${serverAppContext.lambdaDirectory},
+  }`;
+};
+const getPluginsCode = (plugins) => `[${plugins.map((_, index) => `plugin_${index}()`).join(",")}]`;
+const genPluginImportsCode = (plugins) => {
+  return plugins.map((plugin, index) => `
+      let plugin_${index} = require('${plugin}')
+      plugin_${index} = plugin_${index}.default || plugin_${index}
+      `).join(";\n");
+};
+const getProjectUsage = (appDirectory, distDirectory) => {
+  const routeJSON = import_path.default.join(distDirectory, import_utils.ROUTE_SPEC_FILE);
+  const { routes } = import_utils.fs.readJSONSync(routeJSON);
+  let useSSR = false;
+  let useAPI = false;
+  routes.forEach((route) => {
+    if (route.isSSR) {
+      useSSR = true;
+    }
+    if (route.isApi) {
+      useAPI = true;
+    }
+  });
+  const useWebServer = (0, import_utils.isDepExists)(appDirectory, "@modern-js/plugin-server");
+  return {
+    useSSR,
+    useAPI,
+    useWebServer
+  };
+};
+function applyProductionCondition(exports) {
+  if (!exports || typeof exports === "string") {
+    return;
+  }
+  if (exports.production) {
+    if (typeof exports.production === "string") {
+      exports.default = exports.production;
+    } else {
+      Object.assign(exports, exports.production);
+    }
+  }
+  for (const key in exports) {
+    applyProductionCondition(exports[key]);
+  }
+}
+function applyPublicCondition(pkg) {
+  var _pkg_publishConfig;
+  if (pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig = pkg.publishConfig) === null || _pkg_publishConfig === void 0 ? void 0 : _pkg_publishConfig.exports) {
+    var _pkg_publishConfig1;
+    pkg.exports = pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig1 = pkg.publishConfig) === null || _pkg_publishConfig1 === void 0 ? void 0 : _pkg_publishConfig1.exports;
+  }
+}
+const writePackage = async (pkg, version, projectDir, _pkgPath) => {
+  const pkgPath = _pkgPath || pkg.name;
+  for (const src of pkg.versions[version].files) {
+    if (src.includes("node_modules")) {
+      const { subpath } = (0, import_mlly.parseNodeModulePath)(src);
+      const dest = import_path.default.join(projectDir, "node_modules", pkgPath, subpath);
+      const dirname = import_path.default.dirname(dest);
+      await import_utils.fs.ensureDir(dirname);
+      await import_utils.fs.copyFile(src, dest);
+    } else {
+      const subpath = import_path.default.relative(pkg.versions[version].path, src);
+      const dest = import_path.default.join(projectDir, "node_modules", pkgPath, subpath);
+      const dirname = import_path.default.dirname(dest);
+      await import_utils.fs.ensureDir(dirname);
+      await import_utils.fs.copyFile(src, dest);
+    }
+  }
+  const { pkgJSON } = pkg.versions[version];
+  applyPublicCondition(pkgJSON);
+  const packageJsonPath = import_path.default.join(projectDir, "node_modules", pkgPath, "package.json");
+  await import_utils.fs.ensureDir(import_path.default.dirname(packageJsonPath));
+  await import_utils.fs.writeFile(packageJsonPath, JSON.stringify(pkgJSON, null, 2));
+};
+const isWindows = import_node_os.default.platform() === "win32";
+const linkPackage = async (from, to, projectRootDir) => {
+  const src = import_path.default.join(projectRootDir, "node_modules", from);
+  const dest = import_path.default.join(projectRootDir, "node_modules", to);
+  const dstStat = await import_utils.fs.lstat(dest).catch(() => null);
+  const exists = dstStat === null || dstStat === void 0 ? void 0 : dstStat.isSymbolicLink();
+  if (exists) {
+    return;
+  }
+  await import_utils.fs.mkdir(import_path.default.dirname(dest), {
+    recursive: true
+  });
+  await import_utils.fs.symlink(import_path.default.relative(import_path.default.dirname(dest), src), dest, isWindows ? "junction" : "dir").catch((error) => {
+    console.error("Cannot link", from, "to", to, error);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyProductionCondition,
+  applyPublicCondition,
+  genPluginImportsCode,
+  getPluginsCode,
+  getProjectUsage,
+  linkPackage,
+  severAppContextTemplate,
+  writePackage
+});

package/dist/cjs/utils/createServer.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,25 +15,17 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 createServer_exports = {};
 __export(createServer_exports, {
   closeServer: () => closeServer,
   createServer: () => createServer,
   getServer: () => getServer,
-  injectDataLoaderPlugin: () => injectDataLoaderPlugin,
   setServer: () => setServer
 });
 module.exports = __toCommonJS(createServer_exports);
 var import_server = require("@modern-js/server");
+var import_prod_server = require("@modern-js/prod-server");
 let server = null;
 const getServer = () => server;
 const setServer = (newServer) => {
@@ -43,33 +33,21 @@ const setServer = (newServer) => {
 };
 const closeServer = async () => {
   if (server) {
-    await server.close();
+    server.close();
     server = null;
   }
 };
 const createServer = async (options) => {
   if (server) {
-    await server.close();
+    server.close();
   }
-  server = new import_server.Server(options);
-  const app = await server.init();
-  return app;
-};
-const injectDataLoaderPlugin = (internalPlugins) => {
-  const DataLoaderPlugin = require.resolve("@modern-js/plugin-data-loader/server");
-  return {
-    ...internalPlugins,
-    "@modern-js/plugin-data-loader": {
-      path: DataLoaderPlugin,
-      forced: true
-    }
-  };
+  server = await (0, import_server.createDevServer)(options, import_prod_server.initProdMiddlewares);
+  return server;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   closeServer,
   createServer,
   getServer,
-  injectDataLoaderPlugin,
   setServer
 });

package/dist/cjs/utils/env.js

@@ -21,10 +21,10 @@ __export(env_exports, {
   getAutoInjectEnv: () => getAutoInjectEnv
 });
 module.exports = __toCommonJS(env_exports);
-var import_utils = require("@modern-js/utils");
+var import_universal = require("@modern-js/utils/universal");
 function getAutoInjectEnv(appContext) {
   const { metaName } = appContext;
-  const prefix = `${(0, import_utils.cutNameByHyphen)(metaName)}_`.toUpperCase();
+  const prefix = `${(0, import_universal.cutNameByHyphen)(metaName)}_`.toUpperCase();
   const envReg = new RegExp(`^${prefix}`);
   return Object.keys(process.env).reduce((prev, key) => {
     const value = process.env[key];

package/dist/cjs/utils/register.js

@@ -0,0 +1,103 @@
+"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 register_exports = {};
+__export(register_exports, {
+  registerCompiler: () => registerCompiler
+});
+module.exports = __toCommonJS(register_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_utils = require("@modern-js/utils");
+const registerCompiler = async (appDir = process.cwd(), distDir, alias) => {
+  const TS_CONFIG_FILENAME = `tsconfig.json`;
+  const tsconfigPath = import_node_path.default.resolve(appDir, TS_CONFIG_FILENAME);
+  const isTsProject = await import_utils.fs.pathExists(tsconfigPath);
+  const aliasConfig = (0, import_utils.getAliasConfig)(alias, {
+    appDirectory: appDir,
+    tsconfigPath
+  });
+  const { paths = {}, absoluteBaseUrl = "./" } = aliasConfig;
+  const tsPaths = Object.keys(paths).reduce((o, key) => {
+    let tsPath = paths[key];
+    if (typeof tsPath === "string" && import_node_path.default.isAbsolute(tsPath)) {
+      tsPath = import_node_path.default.relative(absoluteBaseUrl, tsPath);
+    }
+    if (typeof tsPath === "string") {
+      tsPath = [
+        tsPath
+      ];
+    }
+    return {
+      ...o,
+      [`${key}`]: tsPath
+    };
+  }, {});
+  let tsConfig = {};
+  if (isTsProject) {
+    tsConfig = (0, import_utils.readTsConfigByFile)(tsconfigPath);
+  }
+  try {
+    const tsNode = await Promise.resolve().then(() => __toESM(require("ts-node")));
+    const tsNodeOptions = tsConfig["ts-node"];
+    if (isTsProject) {
+      tsNode.register({
+        project: tsconfigPath,
+        scope: true,
+        // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
+        files: true,
+        transpileOnly: true,
+        ignore: [
+          "(?:^|/)node_modules/",
+          `(?:^|/)${distDir}/`
+        ],
+        ...tsNodeOptions
+      });
+    }
+  } catch (error) {
+    const esbuildRegister = await Promise.resolve().then(() => __toESM(require("esbuild-register/dist/node")));
+    esbuildRegister.register({
+      tsconfigRaw: isTsProject ? tsConfig : void 0,
+      hookIgnoreNodeModules: true,
+      hookMatcher: (fileName) => !fileName.startsWith(distDir)
+    });
+  }
+  const tsConfigPaths = await Promise.resolve().then(() => __toESM(require("@modern-js/utils/tsconfig-paths")));
+  if (await import_utils.fs.pathExists(appDir)) {
+    const loaderRes = tsConfigPaths.loadConfig(appDir);
+    if (loaderRes.resultType === "success") {
+      tsConfigPaths.register({
+        baseUrl: absoluteBaseUrl || "./",
+        paths: tsPaths
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerCompiler
+});

package/dist/esm/builder/builder-webpack/index.js

@@ -26,7 +26,7 @@ function _createWebpackBuilderForModern() {
           _normalizedConfig_tools = normalizedConfig.tools, esbuildOptions = _normalizedConfig_tools.esbuild;
           return [
             4,
-            import("@rsbuild/plugin-esbuild")
+            import("@modern-js/rsbuild-plugin-esbuild")
           ];
         case 2:
           pluginEsbuild = _state.sent().pluginEsbuild;

package/dist/esm/commands/build.js

@@ -6,9 +6,10 @@ import { ResolvedConfigContext } from "@modern-js/core";
 import { logger } from "@modern-js/utils";
 import { generateRoutes } from "../utils/routes";
 import { buildServerConfig } from "../utils/config";
+import { registerCompiler } from "../utils/register";
 var build = function() {
   var _ref = _async_to_generator(function(api, options) {
-    var resolvedConfig, appContext, hookRunners, apiOnly, appDirectory, distDirectory, serverConfigFile, distDirectory1, appDirectory1, serverConfigFile1;
+    var _resolvedConfig_source, resolvedConfig, appContext, hookRunners, apiOnly, appDirectory, distDirectory, serverConfigFile, distDirectory1, appDirectory1, serverConfigFile1;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -18,11 +19,17 @@ var build = function() {
           resolvedConfig = api.useResolvedConfigContext();
           appContext = api.useAppContext();
           hookRunners = api.useHookRunners();
+          return [
+            4,
+            registerCompiler(appContext.appDirectory, appContext.distDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.alias)
+          ];
+        case 1:
+          _state.sent();
           apiOnly = appContext.apiOnly;
           if (!apiOnly)
             return [
               3,
-              5
+              6
             ];
           appDirectory = appContext.appDirectory, distDirectory = appContext.distDirectory, serverConfigFile = appContext.serverConfigFile;
           return [
@@ -32,7 +39,7 @@ var build = function() {
               bundlerConfigs: void 0
             })
           ];
-        case 1:
+        case 2:
           _state.sent();
           return [
             4,
@@ -42,13 +49,13 @@ var build = function() {
               configFile: serverConfigFile
             })
           ];
-        case 2:
+        case 3:
           _state.sent();
           return [
             4,
             generateRoutes(appContext)
           ];
-        case 3:
+        case 4:
           _state.sent();
           return [
             4,
@@ -57,12 +64,12 @@ var build = function() {
               stats: void 0
             })
           ];
-        case 4:
+        case 5:
           _state.sent();
           return [
             2
           ];
-        case 5:
+        case 6:
           resolvedConfig = _object_spread_props(_object_spread({}, resolvedConfig), {
             cliOptions: options
           });
@@ -76,7 +83,7 @@ var build = function() {
               configFile: serverConfigFile1
             })
           ];
-        case 6:
+        case 7:
           _state.sent();
           logger.info("Starting production build...");
           if (!appContext.builder) {
@@ -86,7 +93,7 @@ var build = function() {
             4,
             appContext.builder.build()
           ];
-        case 7:
+        case 8:
           _state.sent();
           return [
             2