@modern-js/app-tools 2.10.0 → 2.10.1-alpha.0

package/dist/cjs/builder/index.js

@@ -31,11 +31,13 @@ __export(builder_exports, {
 });
 module.exports = __toCommonJS(builder_exports);
 var import_utils = require("@modern-js/utils");
+var import_builder_rspack_provider = require("@modern-js/builder-rspack-provider");
 async function createBuilderGenerator(bundler) {
   if (bundler === "rspack") {
     try {
       const { createRspackBuilderForModern } = await Promise.resolve().then(() => __toESM(require("./builder-rspack")));
-      import_utils.logger.info("Using Rspack ✨");
+      const version = await (0, import_builder_rspack_provider.getRspackVersion)();
+      import_utils.logger.info(`Using Rspack v${version} 🦀`);
       return createRspackBuilderForModern;
     } catch (_) {
       throw new Error(

package/dist/cjs/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -32,6 +32,8 @@ __export(RouterPlugin_exports, {
 module.exports = __toCommonJS(RouterPlugin_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
+var import_constants = require("@modern-js/utils/constants");
+var import_constants2 = require("@modern-js/utils/universal/constants");
 const PLUGIN_NAME = "ModernjsRoutePlugin";
 class RouterPlugin {
   apply(compiler) {
@@ -66,7 +68,8 @@ class RouterPlugin {
             publicPath: true,
             assets: true,
             chunkGroups: true,
-            chunks: true
+            chunks: true,
+            ids: true
           });
           const { publicPath, chunks = [] } = stats;
           const routeAssets = {};
@@ -92,7 +95,12 @@ class RouterPlugin {
           };
           const injectedContent = `
             ;(function(){
-              window.${import_utils.ROUTE_MANIFEST} = ${JSON.stringify(manifest)};
+              window.${import_constants2.ROUTE_MANIFEST} = ${JSON.stringify(manifest, (k, v) => {
+            if (k === "assets") {
+              return void 0;
+            }
+            return v;
+          })};
             })();
           `;
           const entrypointsArray = Array.from(
@@ -122,7 +130,7 @@ class RouterPlugin {
               void 0
             );
           }
-          const filename = import_path.default.join(outputPath, import_utils.ROUTE_MINIFEST_FILE);
+          const filename = import_path.default.join(outputPath, import_constants.ROUTE_MANIFEST_FILE);
           await import_utils.fs.ensureFile(filename);
           await import_utils.fs.writeFile(filename, JSON.stringify(manifest, null, 2));
         }

package/dist/cjs/commands/serve.js

@@ -36,7 +36,7 @@ var import_printInstructions = require("../utils/printInstructions");
 var import_createServer = require("../utils/createServer");
 var import_getServerInternalPlugins = require("../utils/getServerInternalPlugins");
 const start = async (api) => {
-  var _a;
+  var _a, _b;
   const appContext = api.useAppContext();
   const userConfig = api.useResolvedConfigContext();
   const hookRunners = api.useHookRunners();
@@ -49,7 +49,14 @@ const start = async (api) => {
   const serverInternalPlugins = await (0, import_getServerInternalPlugins.getServerInternalPlugins)(api);
   const app = await (0, import_prod_server.default)({
     pwd: appDirectory,
-    config: userConfig,
+    config: {
+      ...userConfig,
+      dev: userConfig.dev,
+      output: {
+        path: (_b = userConfig.output.distPath) == null ? void 0 : _b.root,
+        ...userConfig.output || {}
+      }
+    },
     appContext: {
       sharedDirectory: (0, import_utils.getTargetDir)(
         appContext.sharedDirectory,

package/dist/esm/builder/index.js

@@ -123,26 +123,27 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import { logger } from "@modern-js/utils";
+import { getRspackVersion } from "@modern-js/builder-rspack-provider";
 function createBuilderGenerator(bundler) {
     return _createBuilderGenerator.apply(this, arguments);
 }
 function _createBuilderGenerator() {
     _createBuilderGenerator = _asyncToGenerator(function(bundler) {
-        var createRspackBuilderForModern, _, createWebpackBuilderForModern;
+        var createRspackBuilderForModern, version, _, createWebpackBuilderForModern;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     if (!(bundler === "rspack")) return [
                         3,
-                        4
+                        5
                     ];
                     _state.label = 1;
                 case 1:
                     _state.trys.push([
                         1,
-                        3,
+                        4,
                         ,
-                        4
+                        5
                     ]);
                     return [
                         4,
@@ -150,20 +151,26 @@ function _createBuilderGenerator() {
                     ];
                 case 2:
                     createRspackBuilderForModern = _state.sent().createRspackBuilderForModern;
-                    logger.info("Using Rspack ✨");
+                    return [
+                        4,
+                        getRspackVersion()
+                    ];
+                case 3:
+                    version = _state.sent();
+                    logger.info("Using Rspack v".concat(version, " \uD83E\uDD80"));
                     return [
                         2,
                         createRspackBuilderForModern
                     ];
-                case 3:
+                case 4:
                     _ = _state.sent();
                     throw new Error("Failed to use Rspack, please check if you have `@modern-js/builder-rspack-provider` installed");
-                case 4:
+                case 5:
                     return [
                         4,
                         import("./builder-webpack")
                     ];
-                case 5:
+                case 6:
                     createWebpackBuilderForModern = _state.sent().createWebpackBuilderForModern;
                     return [
                         2,

package/dist/esm/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -200,7 +200,9 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import path from "path";
-import { fs, ROUTE_MANIFEST, logger, ROUTE_MINIFEST_FILE } from "@modern-js/utils";
+import { fs, logger } from "@modern-js/utils";
+import { ROUTE_MANIFEST_FILE } from "@modern-js/utils/constants";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 var PLUGIN_NAME = "ModernjsRoutePlugin";
 var RouterPlugin = /*#__PURE__*/ function() {
     "use strict";
@@ -244,7 +246,8 @@ var RouterPlugin = /*#__PURE__*/ function() {
                                         publicPath: true,
                                         assets: true,
                                         chunkGroups: true,
-                                        chunks: true
+                                        chunks: true,
+                                        ids: true
                                     });
                                     publicPath = stats.publicPath, _stats_chunks = stats.chunks, chunks = _stats_chunks === void 0 ? [] : _stats_chunks;
                                     routeAssets = {};
@@ -285,7 +288,12 @@ var RouterPlugin = /*#__PURE__*/ function() {
                                     manifest = {
                                         routeAssets: routeAssets
                                     };
-                                    injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest), ";\n            })();\n          ");
+                                    injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest, function(k, v) {
+                                        if (k === "assets") {
+                                            return void 0;
+                                        }
+                                        return v;
+                                    }), ";\n            })();\n          ");
                                     entrypointsArray = Array.from(compilation.entrypoints.entries());
                                     entryChunkIds = entrypointsArray.map(function(entrypoint) {
                                         return entrypoint[0];
@@ -328,7 +336,7 @@ var RouterPlugin = /*#__PURE__*/ function() {
                                             }
                                         }
                                     }
-                                    filename = path.join(outputPath, ROUTE_MINIFEST_FILE);
+                                    filename = path.join(outputPath, ROUTE_MANIFEST_FILE);
                                     return [
                                         4,
                                         fs.ensureFile(filename)

package/dist/esm/commands/serve.js

@@ -27,6 +27,58 @@ function _asyncToGenerator(fn) {
         });
     };
 }
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 var __generator = this && this.__generator || function(thisArg, body) {
     var f, y, t, g, _ = {
         label: 0,
@@ -129,7 +181,7 @@ import { injectDataLoaderPlugin } from "../utils/createServer";
 import { getServerInternalPlugins } from "../utils/getServerInternalPlugins";
 var start = function() {
     var _ref = _asyncToGenerator(function(api) {
-        var _userConfig_source, appContext, userConfig, hookRunners, appDirectory, port, serverConfigFile, apiOnly, serverInternalPlugins, app;
+        var _userConfig_source, _userConfig_output_distPath, appContext, userConfig, hookRunners, appDirectory, port, serverConfigFile, apiOnly, serverInternalPlugins, app;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -154,7 +206,12 @@ var start = function() {
                         4,
                         server({
                             pwd: appDirectory,
-                            config: userConfig,
+                            config: _objectSpreadProps(_objectSpread({}, userConfig), {
+                                dev: userConfig.dev,
+                                output: _objectSpread({
+                                    path: (_userConfig_output_distPath = userConfig.output.distPath) === null || _userConfig_output_distPath === void 0 ? void 0 : _userConfig_output_distPath.root
+                                }, userConfig.output || {})
+                            }),
                             appContext: {
                                 sharedDirectory: getTargetDir(appContext.sharedDirectory, appContext.appDirectory, appContext.distDirectory),
                                 apiDirectory: getTargetDir(appContext.apiDirectory, appContext.appDirectory, appContext.distDirectory),

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

@@ -1,9 +1,11 @@
 import { logger } from "@modern-js/utils";
+import { getRspackVersion } from "@modern-js/builder-rspack-provider";
 async function createBuilderGenerator(bundler) {
   if (bundler === "rspack") {
     try {
       const { createRspackBuilderForModern } = await import("./builder-rspack");
-      logger.info("Using Rspack ✨");
+      const version = await getRspackVersion();
+      logger.info(`Using Rspack v${version} 🦀`);
       return createRspackBuilderForModern;
     } catch (_) {
       throw new Error(

package/dist/esm-node/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -1,10 +1,7 @@
 import path from "path";
-import {
-  fs,
-  ROUTE_MANIFEST,
-  logger,
-  ROUTE_MINIFEST_FILE
-} from "@modern-js/utils";
+import { fs, logger } from "@modern-js/utils";
+import { ROUTE_MANIFEST_FILE } from "@modern-js/utils/constants";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 const PLUGIN_NAME = "ModernjsRoutePlugin";
 class RouterPlugin {
   apply(compiler) {
@@ -39,7 +36,8 @@ class RouterPlugin {
             publicPath: true,
             assets: true,
             chunkGroups: true,
-            chunks: true
+            chunks: true,
+            ids: true
           });
           const { publicPath, chunks = [] } = stats;
           const routeAssets = {};
@@ -65,7 +63,12 @@ class RouterPlugin {
           };
           const injectedContent = `
             ;(function(){
-              window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest)};
+              window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest, (k, v) => {
+            if (k === "assets") {
+              return void 0;
+            }
+            return v;
+          })};
             })();
           `;
           const entrypointsArray = Array.from(
@@ -95,7 +98,7 @@ class RouterPlugin {
               void 0
             );
           }
-          const filename = path.join(outputPath, ROUTE_MINIFEST_FILE);
+          const filename = path.join(outputPath, ROUTE_MANIFEST_FILE);
           await fs.ensureFile(filename);
           await fs.writeFile(filename, JSON.stringify(manifest, null, 2));
         }

package/dist/esm-node/commands/serve.js

@@ -4,7 +4,7 @@ import { printInstructions } from "../utils/printInstructions";
 import { injectDataLoaderPlugin } from "../utils/createServer";
 import { getServerInternalPlugins } from "../utils/getServerInternalPlugins";
 const start = async (api) => {
-  var _a;
+  var _a, _b;
   const appContext = api.useAppContext();
   const userConfig = api.useResolvedConfigContext();
   const hookRunners = api.useHookRunners();
@@ -17,7 +17,14 @@ const start = async (api) => {
   const serverInternalPlugins = await getServerInternalPlugins(api);
   const app = await server({
     pwd: appDirectory,
-    config: userConfig,
+    config: {
+      ...userConfig,
+      dev: userConfig.dev,
+      output: {
+        path: (_b = userConfig.output.distPath) == null ? void 0 : _b.root,
+        ...userConfig.output || {}
+      }
+    },
     appContext: {
       sharedDirectory: getTargetDir(
         appContext.sharedDirectory,

package/dist/js/modern/analyze/constants.js

@@ -0,0 +1,54 @@
+const JS_EXTENSIONS = [".js", ".ts", ".jsx", ".tsx"];
+const INDEX_FILE_NAME = "index";
+const APP_FILE_NAME = "App";
+const PAGES_DIR_NAME = "pages";
+const NESTED_ROUTES_DIR = "routes";
+const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
+const LOADER_EXPORT_NAME = "loader";
+const TEMP_LOADERS_DIR = "__loaders__";
+const ENTRY_POINT_FILE_NAME = "index.js";
+const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.js";
+const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+const FILE_SYSTEM_ROUTES_LAYOUT = "_layout";
+const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = "_app";
+const FILE_SYSTEM_ROUTES_INDEX = "index";
+const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+const HTML_PARTIALS_FOLDER = "html";
+const HTML_PARTIALS_EXTENSIONS = [".htm", ".html", ".ejs"];
+const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+const NESTED_ROUTE = {
+  LAYOUT_FILE: "layout",
+  LAYOUT_LOADER_FILE: "layout.loader",
+  PAGE_FILE: "page",
+  PAGE_LOADER_FILE: "page.loader",
+  LOADING_FILE: "loading",
+  ERROR_FILE: "error",
+  LOADER_FILE: "loader"
+};
+const APP_CONFIG_NAME = "config";
+const APP_INIT_EXPORTED = "init";
+const APP_INIT_IMPORTED = "appInit";
+export {
+  APP_CONFIG_NAME,
+  APP_FILE_NAME,
+  APP_INIT_EXPORTED,
+  APP_INIT_IMPORTED,
+  ENTRY_BOOTSTRAP_FILE_NAME,
+  ENTRY_POINT_FILE_NAME,
+  FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
+  FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT,
+  FILE_SYSTEM_ROUTES_IGNORED_REGEX,
+  FILE_SYSTEM_ROUTES_INDEX,
+  FILE_SYSTEM_ROUTES_LAYOUT,
+  HTML_PARTIALS_EXTENSIONS,
+  HTML_PARTIALS_FOLDER,
+  INDEX_FILE_NAME,
+  JS_EXTENSIONS,
+  LOADER_EXPORT_NAME,
+  NESTED_ROUTE,
+  NESTED_ROUTES_DIR,
+  PAGES_DIR_NAME,
+  TEMP_LOADERS_DIR
+};

package/dist/js/modern/analyze/generateCode.js

@@ -0,0 +1,247 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import path from "path";
+import { fs, getEntryOptions, logger } from "@modern-js/utils";
+import {
+  useResolvedConfigContext
+} from "@modern-js/core";
+import * as templates from "./templates";
+import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
+import {
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  ENTRY_POINT_FILE_NAME,
+  ENTRY_BOOTSTRAP_FILE_NAME
+} from "./constants";
+import { getDefaultImports, getServerLoadersFile } from "./utils";
+import { walk } from "./nestedRoutes";
+const createImportSpecifier = (specifiers) => {
+  let defaults = "";
+  const named = [];
+  for (const { local, imported } of specifiers) {
+    if (local && imported) {
+      named.push(`${imported} as ${local}`);
+    } else if (local) {
+      defaults = local;
+    } else {
+      named.push(imported);
+    }
+  }
+  if (defaults && named.length) {
+    return `${defaults}, { ${named.join(", ")} }`;
+  } else if (defaults) {
+    return defaults;
+  } else {
+    return `{ ${named.join(", ")} }`;
+  }
+};
+const createImportStatements = (statements) => {
+  var _a, _b;
+  const deDuplicated = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const { value, specifiers, initialize } of statements) {
+    if (!seen.has(value)) {
+      deDuplicated.push({
+        value,
+        specifiers,
+        initialize
+      });
+      seen.set(value, specifiers);
+    } else {
+      seen.get(value).push(...specifiers);
+      const modifyIndex = deDuplicated.findIndex((v) => v.value === value);
+      const originInitialize = (_b = (_a = deDuplicated[modifyIndex]) == null ? void 0 : _a.initialize) != null ? _b : "";
+      deDuplicated[modifyIndex].initialize = originInitialize.concat(
+        `
+${initialize || ""}`
+      );
+    }
+  }
+  return deDuplicated.map(
+    ({ value, specifiers, initialize }) => `import ${createImportSpecifier(specifiers)} from '${value}';
+${initialize || ""}`
+  ).join("\n");
+};
+const generateCode = (appContext, config, entrypoints, api) => __async(void 0, null, function* () {
+  var _a, _b, _c;
+  const {
+    internalDirectory,
+    srcDirectory,
+    internalDirAlias,
+    internalSrcAlias,
+    packageName
+  } = appContext;
+  const hookRunners = api.useHookRunners();
+  const isV5 = typeof ((_a = config.runtime) == null ? void 0 : _a.router) !== "boolean" && ((_c = (_b = config == null ? void 0 : config.runtime) == null ? void 0 : _b.router) == null ? void 0 : _c.mode) === "react-router-5";
+  const { mountId } = config.html;
+  const getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
+  yield Promise.all(entrypoints.map(generateEntryCode));
+  function generateEntryCode(entrypoint) {
+    return __async(this, null, function* () {
+      const { entryName, isAutoMount, customBootstrap, fileSystemRoutes } = entrypoint;
+      if (isAutoMount) {
+        if (fileSystemRoutes) {
+          let initialRoutes = [];
+          let nestedRoute = null;
+          if (entrypoint.entry) {
+            initialRoutes = getRoutes({
+              entrypoint,
+              srcDirectory,
+              srcAlias: internalSrcAlias,
+              internalDirectory,
+              internalDirAlias
+            });
+          }
+          if (entrypoint.nestedRoutesEntry) {
+            if (!isV5) {
+              nestedRoute = yield walk(
+                entrypoint.nestedRoutesEntry,
+                entrypoint.nestedRoutesEntry,
+                {
+                  name: internalSrcAlias,
+                  basename: srcDirectory
+                },
+                entrypoint.entryName
+              );
+              if (nestedRoute) {
+                initialRoutes.unshift(nestedRoute);
+              }
+            } else {
+              logger.error("Nested routes is not supported in legacy mode.");
+              process.exit(1);
+            }
+          }
+          const { routes } = yield hookRunners.modifyFileSystemRoutes({
+            entrypoint,
+            routes: initialRoutes
+          });
+          const config2 = useResolvedConfigContext();
+          const ssr = getEntryOptions(
+            entryName,
+            config2.server.ssr,
+            config2.server.ssrByEntries,
+            packageName
+          );
+          let mode;
+          if (ssr) {
+            mode = typeof ssr === "object" ? ssr.mode || "string" : "string";
+          } else {
+            mode = false;
+          }
+          if (mode === "stream") {
+            const hasPageRoute = routes.some(
+              (route) => "type" in route && route.type === "page"
+            );
+            if (hasPageRoute) {
+              logger.error(
+                "Streaming ssr is not supported when pages dir exists"
+              );
+              process.exit(1);
+            }
+          }
+          const { code: code2 } = yield hookRunners.beforeGenerateRoutes({
+            entrypoint,
+            code: yield templates.fileSystemRoutes({
+              routes,
+              ssrMode: mode,
+              nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+              entryName: entrypoint.entryName,
+              internalDirectory
+            })
+          });
+          if (entrypoint.nestedRoutesEntry && mode) {
+            const routesServerFile = getServerLoadersFile(
+              internalDirectory,
+              entryName
+            );
+            const code3 = templates.routesForServer({
+              routes
+            });
+            yield fs.ensureFile(routesServerFile);
+            yield fs.writeFile(routesServerFile, code3);
+          }
+          fs.outputFileSync(
+            path.resolve(
+              internalDirectory,
+              `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`
+            ),
+            code2,
+            "utf8"
+          );
+        }
+        const { imports: importStatements } = yield hookRunners.modifyEntryImports({
+          entrypoint,
+          imports: getDefaultImports({
+            entrypoint,
+            srcDirectory,
+            internalSrcAlias,
+            internalDirAlias,
+            internalDirectory
+          })
+        });
+        const { plugins } = yield hookRunners.modifyEntryRuntimePlugins({
+          entrypoint,
+          plugins: []
+        });
+        const { code: renderFunction } = yield hookRunners.modifyEntryRenderFunction({
+          entrypoint,
+          code: templates.renderFunction({
+            plugins,
+            customBootstrap,
+            fileSystemRoutes
+          })
+        });
+        const { exportStatement } = yield hookRunners.modifyEntryExport({
+          entrypoint,
+          exportStatement: "export default AppWrapper;"
+        });
+        const code = templates.index({
+          mountId,
+          imports: createImportStatements(importStatements),
+          renderFunction,
+          exportStatement
+        });
+        const entryFile = path.resolve(
+          internalDirectory,
+          `./${entryName}/${ENTRY_POINT_FILE_NAME}`
+        );
+        entrypoint.entry = entryFile;
+        if (config.source.enableAsyncEntry) {
+          const { code: asyncEntryCode } = yield hookRunners.modifyAsyncEntry({
+            entrypoint,
+            code: `import('./${ENTRY_BOOTSTRAP_FILE_NAME}');`
+          });
+          fs.outputFileSync(entryFile, asyncEntryCode, "utf8");
+          const bootstrapFile = path.resolve(
+            internalDirectory,
+            `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`
+          );
+          fs.outputFileSync(bootstrapFile, code, "utf8");
+        } else {
+          fs.outputFileSync(entryFile, code, "utf8");
+        }
+      }
+    });
+  }
+});
+export {
+  createImportStatements,
+  generateCode
+};