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

package/dist/js/node/analyze/generateCode.js

@@ -1,34 +1,71 @@
-"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 __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());
+  });
+};
+var generateCode_exports = {};
+__export(generateCode_exports, {
+  createImportStatements: () => createImportStatements,
+  generateCode: () => generateCode
 });
-exports.generateCode = exports.createImportStatements = void 0;
-var _path = _interopRequireDefault(require("path"));
-var _utils = require("@modern-js/utils");
-var _core = require("@modern-js/core");
-var _esbuild = _interopRequireDefault(require("esbuild"));
-var _commands = require("../utils/commands");
-var templates = _interopRequireWildcard(require("./templates"));
-var _getClientRoutes = require("./getClientRoutes");
-var _constants = require("./constants");
-var _utils2 = require("./utils");
-var _nestedRoutes = require("./nestedRoutes");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+module.exports = __toCommonJS(generateCode_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_core = require("@modern-js/core");
+var import_commands = require("../utils/commands");
+var templates = __toESM(require("./templates"));
+var import_getClientRoutes = require("./getClientRoutes");
+var import_constants = require("./constants");
+var import_utils2 = require("./utils");
+var import_nestedRoutes = require("./nestedRoutes");
+var import_Builder = require("./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) {
@@ -38,22 +75,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(", ")} }`;
   }
 };
-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,
@@ -62,243 +95,256 @@ 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");
 };
-exports.createImportStatements = createImportStatements;
-const buildLoader = async (entry, outfile) => {
-  const command = (0, _commands.getCommand)();
-  await _esbuild.default.build({
-    format: 'esm',
-    platform: 'browser',
-    target: 'esnext',
+const buildLoader = (entry, outfile) => __async(void 0, null, function* () {
+  yield import_Builder.loaderBuilder.build({
+    format: "esm",
+    platform: "browser",
+    target: "esnext",
     loader,
-    watch: command === 'dev' && {},
+    watch: (0, import_commands.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 = (0, _commands.getCommand)();
-  await _esbuild.default.build({
-    format: 'cjs',
-    platform: 'node',
-    target: 'esnext',
+});
+const buildServerLoader = (entry, outfile) => __async(void 0, null, function* () {
+  yield import_Builder.serverLoaderBuilder.build({
+    format: "cjs",
+    platform: "node",
+    target: "esnext",
     loader,
-    watch: command === 'dev' && {},
+    watch: (0, import_commands.isDevCommand)() && {},
     bundle: true,
-    logLevel: 'error',
+    logLevel: "error",
     entryPoints: [entry],
     outfile
   });
-};
-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 ? _getClientRoutes.getClientRoutesLegacy : _getClientRoutes.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 ? import_getClientRoutes.getClientRoutesLegacy : import_getClientRoutes.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 (0, import_nestedRoutes.walk)(
+                entrypoint.nestedRoutesEntry,
+                entrypoint.nestedRoutesEntry,
+                {
+                  name: internalSrcAlias,
+                  basename: srcDirectory
+                },
+                entrypoint.entryName
+              );
+              if (nestedRoute) {
+                initialRoutes.unshift(nestedRoute);
+              }
+            } else {
+              import_utils.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 (0, _nestedRoutes.walk)(entrypoint.nestedRoutesEntry, entrypoint.nestedRoutesEntry, {
-              name: internalSrcAlias,
-              basename: srcDirectory
-            }, entrypoint.entryName);
-            if (nestedRoute) {
-              initialRoutes.unshift(nestedRoute);
-            }
+          const config2 = (0, import_core.useResolvedConfigContext)();
+          const ssr = (0, import_utils.getEntryOptions)(
+            entryName,
+            config2.server.ssr,
+            config2.server.ssrByEntries,
+            packageName
+          );
+          let mode;
+          if (ssr) {
+            mode = typeof ssr === "object" ? ssr.mode || "string" : "string";
           } else {
-            _utils.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 = (0, _core.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) {
-            _utils.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) {
+              import_utils.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 = import_path.default.join(
+              internalDirectory,
+              entryName,
+              "route-server-loaders.js"
+            );
+            const outputRoutesServerFile = import_path.default.join(
+              distDirectory,
+              import_utils.LOADER_ROUTES_DIR,
+              entryName,
+              "index.js"
+            );
+            const code3 = templates.routesForServer({
+              routes,
+              internalDirectory,
+              entryName
+            });
+            yield import_utils.fs.ensureFile(routesServerFile);
+            yield import_utils.fs.writeFile(routesServerFile, code3);
+            const loaderEntryFile = import_path.default.join(
+              internalDirectory,
+              entryName,
+              import_constants.TEMP_LOADERS_DIR,
+              "entry.js"
+            );
+            const loaderIndexFile = import_path.default.join(
+              internalDirectory,
+              entryName,
+              import_constants.TEMP_LOADERS_DIR,
+              "index.js"
+            );
+            if (yield import_utils.fs.pathExists(loaderEntryFile)) {
+              yield buildLoader(loaderEntryFile, loaderIndexFile);
+            }
+            if (yield import_utils.fs.pathExists(routesServerFile)) {
+              yield buildServerLoader(routesServerFile, outputRoutesServerFile);
+            }
           }
+          import_utils.fs.outputFileSync(
+            import_path.default.resolve(
+              internalDirectory,
+              `./${entryName}/${import_constants.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: (0, import_utils2.getDefaultImports)({
+            entrypoint,
+            srcDirectory,
+            internalSrcAlias,
+            internalDirAlias,
             internalDirectory
           })
         });
-
-        // extract nested router loaders
-        if (entrypoint.nestedRoutesEntry) {
-          const routesServerFile = _path.default.join(internalDirectory, entryName, 'route-server-loaders.js');
-          const outputRoutesServerFile = _path.default.join(distDirectory, _utils.LOADER_ROUTES_DIR, entryName, 'index.js');
-          const code = templates.routesForServer({
-            routes: routes,
-            internalDirectory,
-            entryName
-          });
-          await _utils.fs.ensureFile(routesServerFile);
-          await _utils.fs.writeFile(routesServerFile, code);
-          const loaderEntryFile = _path.default.join(internalDirectory, entryName, _constants.TEMP_LOADERS_DIR, 'entry.js');
-          const loaderIndexFile = _path.default.join(internalDirectory, entryName, _constants.TEMP_LOADERS_DIR, 'index.js');
-          if (await _utils.fs.pathExists(loaderEntryFile)) {
-            await buildLoader(loaderEntryFile, loaderIndexFile);
-          }
-          if (await _utils.fs.pathExists(routesServerFile)) {
-            await buildServerLoader(routesServerFile, outputRoutesServerFile);
-          }
-        }
-        _utils.fs.outputFileSync(_path.default.resolve(internalDirectory, `./${entryName}/${_constants.FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
-      }
-
-      // call modifyEntryImports hook
-      const {
-        imports: importStatements
-      } = await hookRunners.modifyEntryImports({
-        entrypoint,
-        imports: (0, _utils2.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.default.resolve(internalDirectory, `./${entryName}/${_constants.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: templates.renderFunction({
+            plugins,
+            customBootstrap,
+            fileSystemRoutes
+          })
+        });
+        const { exportStatement } = yield hookRunners.modifyEntryExport({
           entrypoint,
-          code: `import('./${_constants.ENTRY_BOOTSTRAP_FILE_NAME}');`
+          exportStatement: "export default AppWrapper;"
+        });
+        const code = templates.index({
+          mountId,
+          imports: createImportStatements(importStatements),
+          renderFunction,
+          exportStatement
         });
-        _utils.fs.outputFileSync(entryFile, asyncEntryCode, 'utf8');
-        const bootstrapFile = _path.default.resolve(internalDirectory, `./${entryName}/${_constants.ENTRY_BOOTSTRAP_FILE_NAME}`);
-        _utils.fs.outputFileSync(bootstrapFile, code, 'utf8');
-      } else {
-        _utils.fs.outputFileSync(entryFile, code, 'utf8');
+        const entryFile = import_path.default.resolve(
+          internalDirectory,
+          `./${entryName}/${import_constants.ENTRY_POINT_FILE_NAME}`
+        );
+        entrypoint.entry = entryFile;
+        if (config.source.enableAsyncEntry) {
+          const { code: asyncEntryCode } = yield hookRunners.modifyAsyncEntry({
+            entrypoint,
+            code: `import('./${import_constants.ENTRY_BOOTSTRAP_FILE_NAME}');`
+          });
+          import_utils.fs.outputFileSync(entryFile, asyncEntryCode, "utf8");
+          const bootstrapFile = import_path.default.resolve(
+            internalDirectory,
+            `./${entryName}/${import_constants.ENTRY_BOOTSTRAP_FILE_NAME}`
+          );
+          import_utils.fs.outputFileSync(bootstrapFile, code, "utf8");
+        } else {
+          import_utils.fs.outputFileSync(entryFile, code, "utf8");
+        }
       }
-    }
+    });
   }
-};
-exports.generateCode = generateCode;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createImportStatements,
+  generateCode
+});