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

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

@@ -1,20 +1,54 @@
-import path from 'path';
-import { fs, logger } from '@modern-js/utils';
-import { useResolvedConfigContext } from '@modern-js/core';
-import esbuild from 'esbuild';
+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 { getCommand } 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 } 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";
-const createImportSpecifier = specifiers => {
-  let defaults = '';
+import { loaderBuilder, serverLoaderBuilder } from "./Builder";
+const loader = {
+  ".js": "jsx",
+  ".ts": "tsx"
+};
+const EXTERNAL_REGEXP = /^[^./]|^\.[^./]|^\.\.[^/]/;
+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) {
@@ -24,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,
@@ -48,226 +78,257 @@ 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 loader = {
-    '.js': 'jsx',
-    '.ts': 'tsx'
-  };
-  const EXTERNAL_REGEXP = /^[^./]|^\.[^./]|^\.\.[^/]/;
+const buildLoader = (entry, outfile) => __async(void 0, null, function* () {
   const command = getCommand();
-  await esbuild.build({
-    format: 'cjs',
-    platform: 'node',
-    target: 'esnext',
+  yield loaderBuilder.build({
+    format: "esm",
+    platform: "browser",
+    target: "esnext",
     loader,
-    watch: command === 'dev' && {},
+    watch: command === "dev" && {},
     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
+            };
+          });
+        }
       }
-    }]
+    ]
   });
-};
-export const generateCode = async (appContext, config, entrypoints, api) => {
-  var _config$runtime, _config$runtime$route;
+});
+const buildServerLoader = (entry, outfile) => __async(void 0, null, function* () {
+  const command = getCommand();
+  yield serverLoaderBuilder.build({
+    format: "cjs",
+    platform: "node",
+    target: "esnext",
+    loader,
+    watch: command === "dev" && {},
+    bundle: true,
+    logLevel: "error",
+    entryPoints: [entry],
+    outfile
+  });
+});
+const generateCode = (appContext, config, entrypoints, api) => __async(void 0, null, function* () {
+  var _a, _b;
   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 islegacy = Boolean((_b = (_a = config == null ? void 0 : config.runtime) == null ? void 0 : _a.router) == null ? void 0 : _b.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({
+  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 (!islegacy) {
+              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: 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, 'routes.server.js');
-          const outputRoutesServerFile = path.join(distDirectory, 'loader-routes', entryName, 'index.js');
-          const code = templates.routesForServer({
-            routes: routes,
-            alias: {
-              name: internalSrcAlias,
-              basename: srcDirectory
-            }
-          });
-          await fs.ensureFile(routesServerFile);
-          await fs.writeFile(routesServerFile, code);
-          await buildLoader(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
+          })
+        });
+        const { exportStatement } = yield hookRunners.modifyEntryExport({
+          entrypoint,
+          exportStatement: "export default AppWrapper;"
+        });
+        const code = templates.index({
+          mountId,
+          imports: createImportStatements(importStatements),
+          renderFunction,
+          exportStatement
         });
-        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 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
+};

package/dist/js/modern/analyze/getBundleEntry.js

@@ -1,68 +1,70 @@
-import path from 'path';
-import { ensureAbsolutePath, fs, findExists, MAIN_ENTRY_NAME } from '@modern-js/utils';
+import path from "path";
+import {
+  ensureAbsolutePath,
+  fs,
+  findExists,
+  MAIN_ENTRY_NAME
+} from "@modern-js/utils";
 import { getFileSystemEntry } from "./getFileSystemEntry";
 import { JS_EXTENSIONS } from "./constants";
-const ensureExtensions = file => {
+const ensureExtensions = (file) => {
   if (!path.extname(file)) {
-    return findExists(JS_EXTENSIONS.map(ext => `${file}${ext}`)) || file;
+    return findExists(JS_EXTENSIONS.map((ext) => `${file}${ext}`)) || file;
   }
   return file;
 };
-const ifAlreadyExists = (entrypoints, checked) => entrypoints.some(entrypoint => {
+const ifAlreadyExists = (entrypoints, checked) => entrypoints.some((entrypoint) => {
   if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
-    // reset entryName
     checked.entryName = entrypoint.entryName;
     return true;
   }
-  // filesystem routes entrypoint conflict with normal entrypoint.
   if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
-    throw new Error(`Entry configuration conflicts\n Your configuration: ${checked.entry}.\n Default entrypoint: ${entrypoint.entry}\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`);
+    throw new Error(
+      `Entry configuration conflicts
+ Your configuration: ${checked.entry}.
+ Default entrypoint: ${entrypoint.entry}
+ Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`
+    );
   }
   return false;
 });
-export const getBundleEntry = (appContext, config) => {
+const getBundleEntry = (appContext, config) => {
+  const { appDirectory, packageName } = appContext;
   const {
-    appDirectory,
-    packageName
-  } = appContext;
-  const {
-    source: {
-      disableDefaultEntries,
-      entries,
-      entriesDir
-    }
+    source: { disableDefaultEntries, entries, entriesDir }
   } = config;
   const defaults = disableDefaultEntries ? [] : getFileSystemEntry(appContext, config);
-
-  // merge entrypoints from user config with directory convention.
   if (entries) {
-    Object.keys(entries).forEach(name => {
+    Object.keys(entries).forEach((name) => {
       const value = entries[name];
-      const entrypoint = typeof value === 'string' ? {
+      const entrypoint = typeof value === "string" ? {
         entryName: name,
         entry: ensureAbsolutePath(appDirectory, value),
         isAutoMount: true,
-        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : undefined
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : void 0
       } : {
         entryName: name,
         entry: ensureAbsolutePath(appDirectory, value.entry),
         isAutoMount: !value.disableMount,
-        fileSystemRoutes: value.enableFileSystemRoutes ? {} : undefined
+        fileSystemRoutes: value.enableFileSystemRoutes ? {} : void 0
       };
+      if (entrypoint.fileSystemRoutes) {
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
       if (!ifAlreadyExists(defaults, entrypoint)) {
         defaults.push(entrypoint);
       }
     });
   }
   if (!disableDefaultEntries) {
-    // find main entry point which server route is '/'.
-    const entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir || '');
-    const found = defaults.find(({
-      entryName,
-      entry,
-      nestedRoutesEntry: _nestedRoutesEntry = ''
-    }) => entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(_nestedRoutesEntry) === entriesDirAbs);
+    const entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir || "");
+    const found = defaults.find(
+      ({ entryName, entry, nestedRoutesEntry = "" }) => entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs
+    );
     found && (found.entryName = MAIN_ENTRY_NAME);
   }
   return defaults;
-};
+};
+export {
+  getBundleEntry
+};