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

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

@@ -1,18 +1,48 @@
-export const JS_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx'];
-export const INDEX_FILE_NAME = 'index';
-export const APP_FILE_NAME = 'App';
-export const PAGES_DIR_NAME = 'pages';
-export const NESTED_ROUTES_DIR = 'routes';
-export const FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
-export const LOADER_EXPORT_NAME = 'loader';
-export const TEMP_LOADERS_DIR = '__loaders__';
-export const ENTRY_POINT_FILE_NAME = 'index.js';
-export const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.js';
-export const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
-export const FILE_SYSTEM_ROUTES_LAYOUT = '_layout';
-export const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = '_app';
-export const FILE_SYSTEM_ROUTES_INDEX = 'index';
-export const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
-export const HTML_PARTIALS_FOLDER = 'html';
-export const HTML_PARTIALS_EXTENSIONS = ['.htm', '.html', '.ejs'];
-export const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = 'internal_components';
+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"
+};
+export {
+  APP_FILE_NAME,
+  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

@@ -1,25 +1,54 @@
-import path from 'path';
-import { fs, LOADER_ROUTES_DIR, logger } from '@modern-js/utils';
-import { useResolvedConfigContext } from '@modern-js/core';
-import esbuild from 'esbuild';
-import { getCommand } from "../utils/commands";
+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,
+  LOADER_ROUTES_DIR,
+  logger
+} from "@modern-js/utils";
+import {
+  useResolvedConfigContext
+} from "@modern-js/core";
+import { isDevCommand } from "../utils/commands";
 import * as templates from "./templates";
 import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
-import { FILE_SYSTEM_ROUTES_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME, TEMP_LOADERS_DIR } from "./constants";
+import {
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  ENTRY_POINT_FILE_NAME,
+  ENTRY_BOOTSTRAP_FILE_NAME,
+  TEMP_LOADERS_DIR
+} from "./constants";
 import { getDefaultImports } from "./utils";
 import { walk } from "./nestedRoutes";
+import { loaderBuilder, serverLoaderBuilder } from "./Builder";
 const loader = {
-  '.js': 'jsx',
-  '.ts': 'tsx'
+  ".js": "jsx",
+  ".ts": "tsx"
 };
 const EXTERNAL_REGEXP = /^[^./]|^\.[^./]|^\.\.[^/]/;
-const createImportSpecifier = specifiers => {
-  let defaults = '';
+const createImportSpecifier = (specifiers) => {
+  let defaults = "";
   const named = [];
-  for (const {
-    local,
-    imported
-  } of specifiers) {
+  for (const { local, imported } of specifiers) {
     if (local && imported) {
       named.push(`${imported} as ${local}`);
     } else if (local) {
@@ -29,22 +58,18 @@ const createImportSpecifier = specifiers => {
     }
   }
   if (defaults && named.length) {
-    return `${defaults}, { ${named.join(', ')} }`;
+    return `${defaults}, { ${named.join(", ")} }`;
   } else if (defaults) {
     return defaults;
   } else {
-    return `{ ${named.join(', ')} }`;
+    return `{ ${named.join(", ")} }`;
   }
 };
-export const createImportStatements = statements => {
-  // merge import statements with the same value.
+const createImportStatements = (statements) => {
+  var _a, _b;
   const deDuplicated = [];
-  const seen = new Map();
-  for (const {
-    value,
-    specifiers,
-    initialize
-  } of statements) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const { value, specifiers, initialize } of statements) {
     if (!seen.has(value)) {
       deDuplicated.push({
         value,
@@ -53,241 +78,255 @@ export const createImportStatements = statements => {
       });
       seen.set(value, specifiers);
     } else {
-      var _deDuplicated$modifyI, _deDuplicated$modifyI2;
       seen.get(value).push(...specifiers);
-      // make "initialize" param can be connected when multiple plugins were imported from same package
-      const modifyIndex = deDuplicated.findIndex(v => v.value === value);
-      const originInitialize = (_deDuplicated$modifyI = (_deDuplicated$modifyI2 = deDuplicated[modifyIndex]) === null || _deDuplicated$modifyI2 === void 0 ? void 0 : _deDuplicated$modifyI2.initialize) !== null && _deDuplicated$modifyI !== void 0 ? _deDuplicated$modifyI : '';
-      deDuplicated[modifyIndex].initialize = originInitialize.concat(`\n${initialize || ''}`);
+      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}';\n${initialize || ''}`).join('\n');
+  return deDuplicated.map(
+    ({ value, specifiers, initialize }) => `import ${createImportSpecifier(specifiers)} from '${value}';
+${initialize || ""}`
+  ).join("\n");
 };
-const buildLoader = async (entry, outfile) => {
-  const command = getCommand();
-  await esbuild.build({
-    format: 'esm',
-    platform: 'browser',
-    target: 'esnext',
+const buildLoader = (entry, outfile) => __async(void 0, null, function* () {
+  yield loaderBuilder.build({
+    format: "esm",
+    platform: "browser",
+    target: "esnext",
     loader,
-    watch: command === 'dev' && {},
+    watch: isDevCommand() && {},
     bundle: true,
-    logLevel: 'error',
+    logLevel: "error",
     entryPoints: [entry],
     outfile,
-    plugins: [{
-      name: 'make-all-packages-external',
-      setup(build) {
-        // https://github.com/evanw/esbuild/issues/619#issuecomment-751995294
-        build.onResolve({
-          filter: EXTERNAL_REGEXP
-        }, args => {
-          let external = true;
-          // FIXME: windows external entrypoint
-          if (args.kind === 'entry-point') {
-            external = false;
-          }
-          return {
-            path: args.path,
-            external
-          };
-        });
+    plugins: [
+      {
+        name: "make-all-packages-external",
+        setup(build) {
+          build.onResolve({ filter: EXTERNAL_REGEXP }, (args) => {
+            let external = true;
+            if (args.kind === "entry-point") {
+              external = false;
+            }
+            return {
+              path: args.path,
+              external
+            };
+          });
+        }
       }
-    }]
+    ]
   });
-};
-const buildServerLoader = async (entry, outfile) => {
-  const command = getCommand();
-  await esbuild.build({
-    format: 'cjs',
-    platform: 'node',
-    target: 'esnext',
+});
+const buildServerLoader = (entry, outfile) => __async(void 0, null, function* () {
+  yield serverLoaderBuilder.build({
+    format: "cjs",
+    platform: "node",
+    target: "esnext",
     loader,
-    watch: command === 'dev' && {},
+    watch: isDevCommand() && {},
     bundle: true,
-    logLevel: 'error',
+    logLevel: "error",
     entryPoints: [entry],
     outfile
   });
-};
-export const generateCode = async (appContext, config, entrypoints, api) => {
-  var _config$runtime, _config$runtime$route;
+});
+const generateCode = (appContext, config, entrypoints, api) => __async(void 0, null, function* () {
+  var _a, _b, _c;
   const {
     internalDirectory,
     distDirectory,
     srcDirectory,
     internalDirAlias,
-    internalSrcAlias
+    internalSrcAlias,
+    packageName
   } = appContext;
   const hookRunners = api.useHookRunners();
-  const islegacy = Boolean(config === null || config === void 0 ? void 0 : (_config$runtime = config.runtime) === null || _config$runtime === void 0 ? void 0 : (_config$runtime$route = _config$runtime.router) === null || _config$runtime$route === void 0 ? void 0 : _config$runtime$route.legacy);
-  const {
-    mountId
-  } = config.html;
-  const getRoutes = islegacy ? getClientRoutesLegacy : getClientRoutes;
-  await Promise.all(entrypoints.map(generateEntryCode));
-  async function generateEntryCode(entrypoint) {
-    const {
-      entryName,
-      isAutoMount,
-      customBootstrap,
-      fileSystemRoutes
-    } = entrypoint;
-    if (isAutoMount) {
-      // generate routes file for file system routes entrypoint.
-      if (fileSystemRoutes) {
-        let initialRoutes = [];
-        let nestedRoute = null;
-        if (entrypoint.entry) {
-          initialRoutes = getRoutes({
+  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,
-            srcDirectory,
-            srcAlias: internalSrcAlias,
-            internalDirectory,
-            internalDirAlias
+            routes: initialRoutes
           });
-        }
-        if (entrypoint.nestedRoutesEntry) {
-          if (!islegacy) {
-            nestedRoute = await walk(entrypoint.nestedRoutesEntry, entrypoint.nestedRoutesEntry, {
-              name: internalSrcAlias,
-              basename: srcDirectory
-            }, entrypoint.entryName);
-            if (nestedRoute) {
-              initialRoutes.unshift(nestedRoute);
-            }
+          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 {
-            logger.error('Nested routes is not supported in legacy mode.');
-            // eslint-disable-next-line no-process-exit
-            process.exit(1);
+            mode = false;
           }
-        }
-        const {
-          routes
-        } = await hookRunners.modifyFileSystemRoutes({
-          entrypoint,
-          routes: initialRoutes
-        });
-        const config = useResolvedConfigContext();
-        const ssr = config === null || config === void 0 ? void 0 : config.server.ssr;
-        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');
-            // eslint-disable-next-line no-process-exit
-            process.exit(1);
+          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,
+              internalDirAlias
+            })
+          });
+          if (entrypoint.nestedRoutesEntry) {
+            const routesServerFile = path.join(
+              internalDirectory,
+              entryName,
+              "route-server-loaders.js"
+            );
+            const outputRoutesServerFile = path.join(
+              distDirectory,
+              LOADER_ROUTES_DIR,
+              entryName,
+              "index.js"
+            );
+            const code3 = templates.routesForServer({
+              routes,
+              internalDirectory,
+              entryName
+            });
+            yield fs.ensureFile(routesServerFile);
+            yield fs.writeFile(routesServerFile, code3);
+            const loaderEntryFile = path.join(
+              internalDirectory,
+              entryName,
+              TEMP_LOADERS_DIR,
+              "entry.js"
+            );
+            const loaderIndexFile = path.join(
+              internalDirectory,
+              entryName,
+              TEMP_LOADERS_DIR,
+              "index.js"
+            );
+            if (yield fs.pathExists(loaderEntryFile)) {
+              yield buildLoader(loaderEntryFile, loaderIndexFile);
+            }
+            if (yield fs.pathExists(routesServerFile)) {
+              yield buildServerLoader(routesServerFile, outputRoutesServerFile);
+            }
+          }
+          fs.outputFileSync(
+            path.resolve(
+              internalDirectory,
+              `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`
+            ),
+            code2,
+            "utf8"
+          );
         }
-        const {
-          code
-        } = await hookRunners.beforeGenerateRoutes({
+        const { imports: importStatements } = yield hookRunners.modifyEntryImports({
           entrypoint,
-          code: await templates.fileSystemRoutes({
-            routes,
-            ssrMode: mode,
-            nestedRoutesEntry: entrypoint.nestedRoutesEntry,
-            entryName: entrypoint.entryName,
+          imports: getDefaultImports({
+            entrypoint,
+            srcDirectory,
+            internalSrcAlias,
+            internalDirAlias,
             internalDirectory
           })
         });
-
-        // extract nested router loaders
-        if (entrypoint.nestedRoutesEntry) {
-          const routesServerFile = path.join(internalDirectory, entryName, 'route-server-loaders.js');
-          const outputRoutesServerFile = path.join(distDirectory, LOADER_ROUTES_DIR, entryName, 'index.js');
-          const code = templates.routesForServer({
-            routes: routes,
-            internalDirectory,
-            entryName
-          });
-          await fs.ensureFile(routesServerFile);
-          await fs.writeFile(routesServerFile, code);
-          const loaderEntryFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'entry.js');
-          const loaderIndexFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, 'index.js');
-          if (await fs.pathExists(loaderEntryFile)) {
-            await buildLoader(loaderEntryFile, loaderIndexFile);
-          }
-          if (await fs.pathExists(routesServerFile)) {
-            await buildServerLoader(routesServerFile, outputRoutesServerFile);
-          }
-        }
-        fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
-      }
-
-      // call modifyEntryImports hook
-      const {
-        imports: importStatements
-      } = await hookRunners.modifyEntryImports({
-        entrypoint,
-        imports: getDefaultImports({
+        const { plugins } = yield hookRunners.modifyEntryRuntimePlugins({
           entrypoint,
-          srcDirectory,
-          internalSrcAlias,
-          internalDirAlias,
-          internalDirectory
-        })
-      });
-
-      // call modifyEntryRuntimePlugins hook
-      const {
-        plugins
-      } = await hookRunners.modifyEntryRuntimePlugins({
-        entrypoint,
-        plugins: []
-      });
-
-      // call modifyEntryRenderFunction hook
-      const {
-        code: renderFunction
-      } = await hookRunners.modifyEntryRenderFunction({
-        entrypoint,
-        code: templates.renderFunction({
-          plugins,
-          customBootstrap,
-          fileSystemRoutes
-        })
-      });
-
-      // call modifyEntryExport hook
-      const {
-        exportStatement
-      } = await hookRunners.modifyEntryExport({
-        entrypoint,
-        exportStatement: 'export default AppWrapper;'
-      });
-      const code = templates.index({
-        mountId: mountId,
-        imports: createImportStatements(importStatements),
-        renderFunction,
-        exportStatement
-      });
-      const entryFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
-      entrypoint.entry = entryFile;
-
-      // generate entry file.
-      if (config.source.enableAsyncEntry) {
-        const {
-          code: asyncEntryCode
-        } = await hookRunners.modifyAsyncEntry({
+          plugins: []
+        });
+        const { code: renderFunction } = yield hookRunners.modifyEntryRenderFunction({
           entrypoint,
-          code: `import('./${ENTRY_BOOTSTRAP_FILE_NAME}');`
+          code: templates.renderFunction({
+            plugins,
+            customBootstrap,
+            fileSystemRoutes
+          })
         });
-        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');
+        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
+};