@modern-js/app-tools 2.0.0-beta.3 → 2.0.0-beta.4

package/dist/js/node/analyze/templates.js

@@ -1,20 +1,81 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  fileSystemRoutes: () => fileSystemRoutes,
+  html: () => html,
+  index: () => index,
+  renderFunction: () => renderFunction,
+  routesForServer: () => routesForServer
 });
-exports.routesForServer = exports.renderFunction = exports.index = exports.html = exports.fileSystemRoutes = void 0;
-var _path = _interopRequireDefault(require("path"));
-var _utils = require("@modern-js/utils");
-var _constants = require("./constants");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-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; }
+module.exports = __toCommonJS(stdin_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+var __defProp2 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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());
+  });
+};
 const index = ({
   mountId,
   imports,
-  renderFunction,
+  renderFunction: renderFunction2,
   exportStatement
 }) => `
 const IS_BROWSER = typeof window !== 'undefined' && window.name !== 'nodejs';
@@ -28,28 +89,25 @@ let AppWrapper = null;
 let root = null;
 
 function render() {
-  ${renderFunction}
+  ${renderFunction2}
 }
 
 AppWrapper = render();
 
 ${exportStatement};
 `;
-exports.index = index;
 const renderFunction = ({
   plugins,
   customBootstrap,
-  fileSystemRoutes
+  fileSystemRoutes: fileSystemRoutes2
 }) => `
   AppWrapper = createApp({
     plugins: [
-     ${plugins.map(({
-  name,
-  options,
-  args
-}) => `${name}({...${options}, ...App?.config?.${args || name}}),`).join('\n')}
+     ${plugins.map(
+  ({ name, options, args }) => `${name}({...${options}, ...App?.config?.${args || name}}),`
+).join("\n")}
     ]
-  })(${fileSystemRoutes ? '' : `App`})
+  })(${fileSystemRoutes2 ? "" : `App`})
 
   if (IS_BROWSER) {
     ${customBootstrap ? `customBootstrap(AppWrapper);` : `bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM);`}
@@ -57,20 +115,19 @@ const renderFunction = ({
 
   return AppWrapper
 `;
-exports.renderFunction = renderFunction;
-const html = partials => `
+const html = (partials) => `
 <!DOCTYPE html>
 <html>
 <head>
   <%= meta %>
   <title><%= title %></title>
 
-  ${partials.top.join('\n')}
+  ${partials.top.join("\n")}
 
   <script>
     window.__assetPrefix__ = '<%= assetPrefix %>';
-  </script>
-  ${partials.head.join('\n')}
+  <\/script>
+  ${partials.head.join("\n")}
 
   <!--<?- chunksMap.css ?>-->
 </head>
@@ -80,7 +137,7 @@ const html = partials => `
     We're sorry but react app doesn't work properly without JavaScript enabled. Please enable it to continue.
   </noscript>
   <div id="<%= mountId %>"><!--<?- html ?>--></div>
-  ${partials.body.join('\n')}
+  ${partials.body.join("\n")}
   <!--<?- chunksMap.js ?>-->
   <!--<?- SSRDataScript ?>-->
   <!--<?- bottomTemplate ?>-->
@@ -88,28 +145,32 @@ const html = partials => `
 
 </html>
 `;
-exports.html = html;
 const routesForServer = ({
   routes,
   internalDirectory,
   entryName
 }) => {
   const loaders = [];
-  const loaderIndexFile = _path.default.join(internalDirectory, entryName, _constants.TEMP_LOADERS_DIR, 'index.js');
-  const traverseRouteTree = route => {
+  const loaderIndexFile = import_path.default.join(
+    internalDirectory,
+    entryName,
+    import_constants.TEMP_LOADERS_DIR,
+    "index.js"
+  );
+  const traverseRouteTree = (route) => {
+    var _a;
     let children;
-    if ('children' in route && route.children) {
-      var _route$children;
-      children = route === null || route === void 0 ? void 0 : (_route$children = route.children) === null || _route$children === void 0 ? void 0 : _route$children.map(traverseRouteTree);
+    if ("children" in route && route.children) {
+      children = (_a = route == null ? void 0 : route.children) == null ? void 0 : _a.map(traverseRouteTree);
     }
     let loader;
-    if (route.type === 'nested') {
+    if (route.type === "nested") {
       if (route.loader) {
         loaders.push(route.loader);
         loader = `loader_${loaders.length - 1}`;
       }
     }
-    const finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+    const finalRoute = __spreadProps(__spreadValues({}, route), {
       loader,
       children
     });
@@ -119,63 +180,82 @@ const routesForServer = ({
   export const routes = [
   `;
   for (const route of routes) {
-    if ('type' in route) {
+    if ("type" in route) {
       const newRoute = traverseRouteTree(route);
-      routesCode += `${JSON.stringify(newRoute, null, 2).replace(/"(loader_[^"])"/g, '$1')},`;
+      routesCode += `${JSON.stringify(newRoute, null, 2).replace(
+        /"(loader_[^"])"/g,
+        "$1"
+      )},`;
     } else {
       routesCode += `${JSON.stringify(route, null, 2)}`;
     }
   }
-  routesCode += `\n];`;
-  let importLoadersCode = '';
+  routesCode += `
+];`;
+  let importLoadersCode = "";
   if (loaders.length > 0) {
     importLoadersCode = `
-    import { ${loaders.map((loader, index) => `loader_${index}`)} } from "${loaderIndexFile}"`;
+    import { ${loaders.map(
+      (loader, index2) => `loader_${index2}`
+    )} } from "${(0, import_utils.slash)(loaderIndexFile)}"`;
   }
   return `
     ${importLoadersCode}
     ${routesCode}
   `;
 };
-exports.routesForServer = routesForServer;
-const fileSystemRoutes = async ({
+const fileSystemRoutes = (_0) => __async(void 0, [_0], function* ({
   routes,
   ssrMode,
   nestedRoutesEntry,
   entryName,
-  internalDirectory
-}) => {
+  internalDirectory,
+  internalDirAlias
+}) {
   const loadings = [];
   const errors = [];
   const loaders = [];
   const loadersMap = {};
-  const loadersIndexFile = _path.default.join('@_modern_js_internal', entryName, _constants.TEMP_LOADERS_DIR, 'index.js');
-  const loadersMapFile = _path.default.join(internalDirectory, entryName, _constants.TEMP_LOADERS_DIR, 'map.json');
+  const loadersIndexFile = import_path.default.join(
+    internalDirAlias,
+    entryName,
+    import_constants.TEMP_LOADERS_DIR,
+    "index.js"
+  );
+  const loadersMapFile = import_path.default.join(
+    internalDirectory,
+    entryName,
+    import_constants.TEMP_LOADERS_DIR,
+    "map.json"
+  );
   const importLazyCode = `
     import { lazy } from "react";
     import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"
   `;
   let rootLayoutCode = ``;
-  let dataLoaderPath = '';
-  let componentLoaderPath = '';
+  let dataLoaderPath = "";
+  let componentLoaderPath = "";
   if (ssrMode) {
-    dataLoaderPath = require.resolve(`@modern-js/plugin-data-loader/loader`);
+    dataLoaderPath = require.resolve("@modern-js/plugin-data-loader/loader");
     if (nestedRoutesEntry) {
       dataLoaderPath = `${dataLoaderPath}?routesDir=${nestedRoutesEntry}&mapFile=${loadersMapFile}!`;
     }
-    componentLoaderPath = `${_path.default.join(__dirname, '../builder/loaders/routerLoader')}!`;
+    componentLoaderPath = `${import_path.default.join(
+      __dirname,
+      "../builder/loaders/routerLoader"
+    )}!`;
   }
-  const traverseRouteTree = route => {
+  const traverseRouteTree = (route) => {
+    var _a;
     let children;
-    if ('children' in route && route.children) {
-      var _route$children2;
-      children = route === null || route === void 0 ? void 0 : (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.map(traverseRouteTree);
+    if ("children" in route && route.children) {
+      children = (_a = route == null ? void 0 : route.children) == null ? void 0 : _a.map(traverseRouteTree);
     }
     let loading;
     let error;
     let loader;
-    let component = '';
-    if (route.type === 'nested') {
+    let component = "";
+    if (route.type === "nested") {
       if (route.loading) {
         loadings.push(route.loading);
         loading = `loading_${loadings.length - 1}`;
@@ -194,17 +274,16 @@ const fileSystemRoutes = async ({
         if (route.isRoot) {
           rootLayoutCode = `import RootLayout from '${route._component}'`;
           component = `RootLayout`;
-        } else if (ssrMode === 'string') {
+        } else if (ssrMode === "string") {
           component = `loadable(() => import(/* webpackChunkName: "${route.id}" */  '${componentLoaderPath}${route._component}'))`;
         } else {
-          // csr and streaming
           component = `lazy(() => import(/* webpackChunkName: "${route.id}" */  '${componentLoaderPath}${route._component}'))`;
         }
       }
     } else if (route._component) {
       component = `loadable(() => import('${route._component}'))`;
     }
-    const finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+    const finalRoute = __spreadProps(__spreadValues({}, route), {
       loading,
       loader,
       error,
@@ -219,45 +298,62 @@ const fileSystemRoutes = async ({
     export const routes = [
   `;
   for (const route of routes) {
-    if ('type' in route) {
+    if ("type" in route) {
       const newRoute = traverseRouteTree(route);
-      routeComponentsCode += `${JSON.stringify(newRoute, null, 2).replace(/"(loadable.*\))"/g, '$1').replace(/"(loadableLazy.*\))"/g, '$1').replace(/"(lazy.*\))"/g, '$1').replace(/"(loading_[^"])"/g, '$1').replace(/"(loader_[^"])"/g, '$1').replace(/"(RootLayout)"/g, '$1').replace(/"(error_[^"])"/g, '$1').replace(/\\"/g, '"')},`;
+      routeComponentsCode += `${JSON.stringify(newRoute, null, 2).replace(/"(loadable.*\))"/g, "$1").replace(/"(loadableLazy.*\))"/g, "$1").replace(/"(lazy.*\))"/g, "$1").replace(/"(loading_[^"])"/g, "$1").replace(/"(loader_[^"])"/g, "$1").replace(/"(RootLayout)"/g, "$1").replace(/"(error_[^"])"/g, "$1").replace(/\\"/g, '"')},`;
     } else {
       const component = `loadable(() => import('${route._component}'))`;
-      const finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+      const finalRoute = __spreadProps(__spreadValues({}, route), {
         component
       });
-      routeComponentsCode += `${JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, '$1').replace(/"(lazy[^"]*)"/g, '$1')},`;
+      routeComponentsCode += `${JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, "$1").replace(/"(lazy[^"]*)"/g, "$1")},`;
     }
   }
-  routeComponentsCode += `\n];`;
-  const importLoadingCode = loadings.map((loading, index) => {
-    return `import loading_${index} from '${loading}';\n`;
-  }).join('');
-  const importErrorComponentsCode = errors.map((error, index) => {
-    return `import error_${index} from '${error}';\n`;
-  }).join('');
-  let importLoadersCode = '';
+  routeComponentsCode += `
+];`;
+  const importLoadingCode = loadings.map((loading, index2) => {
+    return `import loading_${index2} from '${loading}';
+`;
+  }).join("");
+  const importErrorComponentsCode = errors.map((error, index2) => {
+    return `import error_${index2} from '${error}';
+`;
+  }).join("");
+  let importLoadersCode = "";
   if (loaders.length > 0) {
     importLoadersCode = `
-    import { ${loaders.map((loader, index) => `loader_${index}`)} } from "${dataLoaderPath}${loadersIndexFile}"
+    import { ${loaders.map(
+      (loader, index2) => `loader_${index2}`
+    )} } from "${(0, import_utils.slash)(dataLoaderPath)}${(0, import_utils.slash)(loadersIndexFile)}"
   `;
-    const loaderEntryCode = loaders.map((loader, index) => {
-      return `export * from './loader_${index}.js';`;
-    }).join('\n');
-    const loaderEntryFile = _path.default.join(internalDirectory, entryName, _constants.TEMP_LOADERS_DIR, 'entry.js');
-    await _utils.fs.ensureFile(loaderEntryFile);
-    await _utils.fs.writeFile(loaderEntryFile, loaderEntryCode);
-    await _utils.fs.writeJSON(loadersMapFile, loadersMap);
-    await Promise.all(loaders.map(async (loader, index) => {
-      const name = `loader_${index}`;
-      const filename = _path.default.join(internalDirectory, entryName, _constants.TEMP_LOADERS_DIR, `${name}.js`);
-      const code = `
-          export { loader as ${name} } from '${loader}'
+    const loaderEntryCode = loaders.map((loader, index2) => {
+      return `export * from './loader_${index2}.js';`;
+    }).join("\n");
+    const loaderEntryFile = import_path.default.join(
+      internalDirectory,
+      entryName,
+      import_constants.TEMP_LOADERS_DIR,
+      "entry.js"
+    );
+    yield import_utils.fs.ensureFile(loaderEntryFile);
+    yield import_utils.fs.writeFile(loaderEntryFile, loaderEntryCode);
+    yield import_utils.fs.writeJSON(loadersMapFile, loadersMap);
+    yield Promise.all(
+      loaders.map((loader, index2) => __async(void 0, null, function* () {
+        const name = `loader_${index2}`;
+        const filename = import_path.default.join(
+          internalDirectory,
+          entryName,
+          import_constants.TEMP_LOADERS_DIR,
+          `${name}.js`
+        );
+        const code = `
+          export { loader as ${name} } from '${(0, import_utils.slash)(loader)}'
         `;
-      await _utils.fs.ensureFile(filename);
-      await _utils.fs.writeFile(filename, code);
-    }));
+        yield import_utils.fs.ensureFile(filename);
+        yield import_utils.fs.writeFile(filename, code);
+      }))
+    );
   }
   return `
     ${importLazyCode}
@@ -267,5 +363,4 @@ const fileSystemRoutes = async ({
     ${importLoadersCode}
     ${routeComponentsCode}
   `;
-};
-exports.fileSystemRoutes = fileSystemRoutes;
+});

package/dist/js/node/analyze/utils.js

@@ -1,25 +1,70 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  getDefaultImports: () => getDefaultImports,
+  hasLoader: () => hasLoader,
+  isRouteComponentFile: () => isRouteComponentFile,
+  parseModule: () => parseModule,
+  replaceWithAlias: () => replaceWithAlias,
+  walkDirectory: () => walkDirectory
 });
-exports.walkDirectory = exports.replaceWithAlias = exports.parseModule = exports.isRouteComponentFile = exports.hasLoader = exports.getDefaultImports = void 0;
-var _fs = _interopRequireDefault(require("fs"));
-var _path = _interopRequireDefault(require("path"));
-var _utils = require("@modern-js/utils");
-var _esbuild = require("esbuild");
-var _esModuleLexer = require("es-module-lexer");
-var _constants = require("./constants");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const walkDirectory = dir => _fs.default.readdirSync(dir).reduce((previous, filename) => {
-  const filePath = _path.default.join(dir, filename);
-  if (_fs.default.statSync(filePath).isDirectory()) {
+module.exports = __toCommonJS(stdin_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_esbuild = require("esbuild");
+var import_es_module_lexer = require("es-module-lexer");
+var import_constants = require("./constants");
+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());
+  });
+};
+const walkDirectory = (dir) => import_fs.default.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = import_path.default.join(dir, filename);
+  if (import_fs.default.statSync(filePath).isDirectory()) {
     return [...previous, ...walkDirectory(filePath)];
   } else {
     return [...previous, filePath];
   }
 }, []);
-exports.walkDirectory = walkDirectory;
 const getDefaultImports = ({
   entrypoint,
   srcDirectory,
@@ -27,99 +72,87 @@ const getDefaultImports = ({
   internalDirAlias,
   internalDirectory
 }) => {
-  const {
-    entryName,
-    fileSystemRoutes,
-    customBootstrap,
-    entry
-  } = entrypoint;
-  const imports = [{
-    specifiers: [{
-      local: 'React'
-    }],
-    value: 'react'
-  }, {
-    specifiers: [{
-      local: 'ReactDOM'
-    }],
-    value: (0, _utils.isReact18)(_path.default.join(internalDirectory, '../../')) ? 'react-dom/client' : 'react-dom'
-  }, {
-    specifiers: [{
-      imported: 'createApp'
-    }, {
-      imported: 'bootstrap'
-    }],
-    value: '@modern-js/runtime'
-  }, customBootstrap && {
-    specifiers: [{
-      local: 'customBootstrap'
-    }],
-    value: (0, _utils.normalizeToPosixPath)(customBootstrap.replace(srcDirectory, internalSrcAlias))
-  }].filter(Boolean);
+  const { entryName, fileSystemRoutes, customBootstrap, entry } = entrypoint;
+  const imports = [
+    {
+      specifiers: [{ local: "React" }],
+      value: "react"
+    },
+    {
+      specifiers: [{ local: "ReactDOM" }],
+      value: (0, import_utils.isReact18)(import_path.default.join(internalDirectory, "../../")) ? "react-dom/client" : "react-dom"
+    },
+    {
+      specifiers: [{ imported: "createApp" }, { imported: "bootstrap" }],
+      value: "@modern-js/runtime"
+    },
+    customBootstrap && {
+      specifiers: [{ local: "customBootstrap" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        customBootstrap.replace(srcDirectory, internalSrcAlias)
+      )
+    }
+  ].filter(Boolean);
   if (fileSystemRoutes) {
     const route = {
-      specifiers: [{
-        imported: 'routes'
-      }],
-      value: (0, _utils.normalizeToPosixPath)(`${internalDirAlias}/${entryName}/${_constants.FILE_SYSTEM_ROUTES_FILE_NAME.replace('.js', '')}`)
+      specifiers: [{ imported: "routes" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        `${internalDirAlias}/${entryName}/${import_constants.FILE_SYSTEM_ROUTES_FILE_NAME.replace(
+          ".js",
+          ""
+        )}`
+      )
     };
     if (fileSystemRoutes.globalApp) {
       imports.push({
-        specifiers: [{
-          local: 'App'
-        }],
-        value: (0, _utils.normalizeToPosixPath)(fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias))
+        specifiers: [{ local: "App" }],
+        value: (0, import_utils.normalizeToPosixPath)(
+          fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias)
+        )
       });
     } else {
-      route.initialize = 'const App = false;';
+      route.initialize = "const App = false;";
     }
     imports.push(route);
   } else {
     imports.push({
-      specifiers: [{
-        local: 'App'
-      }],
-      value: (0, _utils.normalizeToPosixPath)(entry.replace(srcDirectory, internalSrcAlias))
+      specifiers: [{ local: "App" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        entry.replace(srcDirectory, internalSrcAlias)
+      )
     });
   }
   return imports;
 };
-exports.getDefaultImports = getDefaultImports;
-const isRouteComponentFile = filePath => {
+const isRouteComponentFile = (filePath) => {
   if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
     return false;
   }
-  if (['.js', '.jsx', '.ts', '.tsx'].includes(_path.default.extname(filePath))) {
+  if ([".js", ".jsx", ".ts", ".tsx"].includes(import_path.default.extname(filePath))) {
     return true;
   }
   return false;
 };
-exports.isRouteComponentFile = isRouteComponentFile;
-const replaceWithAlias = (base, filePath, alias) => (0, _utils.normalizeToPosixPath)(_path.default.join(alias, _path.default.relative(base, filePath)));
-exports.replaceWithAlias = replaceWithAlias;
-const parseModule = async ({
+const replaceWithAlias = (base, filePath, alias) => (0, import_utils.normalizeToPosixPath)(import_path.default.join(alias, import_path.default.relative(base, filePath)));
+const parseModule = (_0) => __async(void 0, [_0], function* ({
   source,
   filename
-}) => {
+}) {
   let content = source;
-  if (filename.endsWith('.tsx') || filename.endsWith('.jsx')) {
-    const result = await (0, _esbuild.transform)(content, {
-      loader: _path.default.extname(filename).slice(1),
-      format: 'esm'
+  if (filename.endsWith(".tsx") || filename.endsWith(".jsx")) {
+    const result = yield (0, import_esbuild.transform)(content, {
+      loader: import_path.default.extname(filename).slice(1),
+      format: "esm"
     });
     content = result.code;
   }
-
-  // eslint-disable-next-line @typescript-eslint/await-thenable
-  return await (0, _esModuleLexer.parse)(content);
-};
-exports.parseModule = parseModule;
-const hasLoader = async filename => {
-  const source = await _utils.fs.readFile(filename);
-  const [, moduleExports] = await parseModule({
+  return yield (0, import_es_module_lexer.parse)(content);
+});
+const hasLoader = (filename) => __async(void 0, null, function* () {
+  const source = yield import_utils.fs.readFile(filename);
+  const [, moduleExports] = yield parseModule({
     source: source.toString(),
     filename
   });
-  return moduleExports.some(e => e.n === _constants.LOADER_EXPORT_NAME);
-};
-exports.hasLoader = hasLoader;
+  return moduleExports.some((e) => e.n === import_constants.LOADER_EXPORT_NAME);
+});