@modern-js/app-tools 2.53.0 → 2.53.1-alpha.1

package/dist/cjs/plugins/deploy/dependencies/index.js

@@ -36,19 +36,9 @@ var import_utils = require("@modern-js/utils");
 var import_pkg_types = require("pkg-types");
 var import_mlly = require("mlly");
 var import_utils2 = require("./utils");
-const handleDependencies = async (appDir, serverRootDir, include, entryFilter) => {
+const handleDependencies = async (appDir, serverRootDir, includeEntries, entryFilter, modifyPackageJson) => {
   const base = "/";
   const entryFiles = await (0, import_utils2.findEntryFiles)(serverRootDir, entryFilter);
-  const includeEntries = include.map((item) => {
-    if ((0, import_node_path.isAbsolute)(item)) {
-      return item;
-    }
-    try {
-      return require.resolve(item);
-    } catch (error) {
-    }
-    return item;
-  });
   const fileTrace = await (0, import_utils2.traceFiles)(entryFiles.concat(includeEntries), serverRootDir, base);
   const currentProjectModules = import_node_path.default.join(appDir, "node_modules");
   const tracedFiles = Object.fromEntries(await Promise.all([
@@ -199,7 +189,7 @@ const handleDependencies = async (appDir, serverRootDir, include, entryFilter) =
     }
   }
   const outputPkgPath = import_node_path.default.join(serverRootDir, "package.json");
-  await import_utils.fs.writeJSON(outputPkgPath, {
+  const newPkgJson = {
     name: `${projectPkgJson.name || "modernjs-project"}-prod`,
     version: projectPkgJson.version || "0.0.0",
     private: true,
@@ -209,7 +199,9 @@ const handleDependencies = async (appDir, serverRootDir, include, entryFilter) =
         Object.keys(pkg.versions)[0]
       ])
     ].sort(([a], [b]) => a.localeCompare(b)))
-  });
+  };
+  const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
+  await import_utils.fs.writeJSON(outputPkgPath, finalPkgJson);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/plugins/deploy/platforms/netlify.js

@@ -125,7 +125,7 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
         return;
       }
       await (0, import_dependencies.handleDependencies)(appDirectory, funcsDirectory, [
-        "@modern-js/prod-server"
+        require.resolve("@modern-js/prod-server")
       ]);
     }
   };

package/dist/cjs/plugins/deploy/platforms/node.js

@@ -79,7 +79,7 @@ const createNodePreset = (appContext, config) => {
         return !filePath.startsWith(staticDirectory);
       };
       await (0, import_dependencies.handleDependencies)(appDirectory, outputDirectory, [
-        "@modern-js/prod-server"
+        require.resolve("@modern-js/prod-server")
       ], filter);
     }
   };

package/dist/cjs/plugins/deploy/platforms/vercel.js

@@ -137,7 +137,7 @@ const createVercelPreset = (appContext, modernConfig, needModernServer) => {
         return;
       }
       await (0, import_dependencies.handleDependencies)(appDirectory, funcsDirectory, [
-        "@modern-js/prod-server"
+        require.resolve("@modern-js/prod-server")
       ]);
     }
   };

package/dist/esm/plugins/deploy/dependencies/index.js

@@ -3,14 +3,14 @@ import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { _ as _ts_values } from "@swc/helpers/_/_ts_values";
-import path, { isAbsolute } from "node:path";
+import path from "node:path";
 import { fs as fse, pkgUp, semver } from "@modern-js/utils";
 import { readPackageJSON } from "pkg-types";
 import { parseNodeModulePath } from "mlly";
 import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles, findPackageParents, resolveTracedPath } from "./utils";
 var handleDependencies = function() {
-  var _ref = _async_to_generator(function(appDir, serverRootDir, include, entryFilter) {
-    var base, entryFiles, includeEntries, fileTrace, currentProjectModules, tracedFiles, _, tracedPackages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, tracedFile, pkgName, tracedPackage, pkgJSON, tracedPackageVersion, err, multiVersionPkgs, singleVersionPackages, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tracedPackage1, versions, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, version, projectPkgJson, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, outputPkgPath;
+  var _ref = _async_to_generator(function(appDir, serverRootDir, includeEntries, entryFilter, modifyPackageJson) {
+    var base, entryFiles, fileTrace, currentProjectModules, tracedFiles, _, tracedPackages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, tracedFile, pkgName, tracedPackage, pkgJSON, tracedPackageVersion, err, multiVersionPkgs, singleVersionPackages, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tracedPackage1, versions, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, version, projectPkgJson, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, outputPkgPath, newPkgJson, finalPkgJson;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -21,16 +21,6 @@ var handleDependencies = function() {
           ];
         case 1:
           entryFiles = _state.sent();
-          includeEntries = include.map(function(item) {
-            if (isAbsolute(item)) {
-              return item;
-            }
-            try {
-              return require.resolve(item);
-            } catch (error) {
-            }
-            return item;
-          });
           return [
             4,
             traceFiles(entryFiles.concat(includeEntries), serverRootDir, base)
@@ -546,22 +536,24 @@ var handleDependencies = function() {
           ];
         case 21:
           outputPkgPath = path.join(serverRootDir, "package.json");
+          newPkgJson = {
+            name: "".concat(projectPkgJson.name || "modernjs-project", "-prod"),
+            version: projectPkgJson.version || "0.0.0",
+            private: true,
+            dependencies: Object.fromEntries(_to_consumable_array(Object.values(tracedPackages).map(function(pkg) {
+              return [
+                pkg.name,
+                Object.keys(pkg.versions)[0]
+              ];
+            })).sort(function(param, param1) {
+              var _param = _sliced_to_array(param, 1), a = _param[0], _param1 = _sliced_to_array(param1, 1), b = _param1[0];
+              return a.localeCompare(b);
+            }))
+          };
+          finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
           return [
             4,
-            fse.writeJSON(outputPkgPath, {
-              name: "".concat(projectPkgJson.name || "modernjs-project", "-prod"),
-              version: projectPkgJson.version || "0.0.0",
-              private: true,
-              dependencies: Object.fromEntries(_to_consumable_array(Object.values(tracedPackages).map(function(pkg) {
-                return [
-                  pkg.name,
-                  Object.keys(pkg.versions)[0]
-                ];
-              })).sort(function(param, param1) {
-                var _param = _sliced_to_array(param, 1), a = _param[0], _param1 = _sliced_to_array(param1, 1), b = _param1[0];
-                return a.localeCompare(b);
-              }))
-            })
+            fse.writeJSON(outputPkgPath, finalPkgJson)
           ];
         case 22:
           _state.sent();
@@ -571,7 +563,7 @@ var handleDependencies = function() {
       }
     });
   });
-  return function handleDependencies2(appDir, serverRootDir, include, entryFilter) {
+  return function handleDependencies2(appDir, serverRootDir, includeEntries, entryFilter, modifyPackageJson) {
     return _ref.apply(this, arguments);
   };
 }();

package/dist/esm/plugins/deploy/platforms/netlify.js

@@ -272,7 +272,7 @@ var createNetlifyPreset = function(appContext, modernConfig, needModernServer) {
               return [
                 4,
                 handleDependencies(appDirectory, funcsDirectory, [
-                  "@modern-js/prod-server"
+                  require.resolve("@modern-js/prod-server")
                 ])
               ];
             case 3:

package/dist/esm/plugins/deploy/platforms/node.js

@@ -105,7 +105,7 @@ var createNodePreset = function(appContext, config) {
               return [
                 4,
                 handleDependencies(appDirectory, outputDirectory, [
-                  "@modern-js/prod-server"
+                  require.resolve("@modern-js/prod-server")
                 ], filter)
               ];
             case 1:

package/dist/esm/plugins/deploy/platforms/vercel.js

@@ -206,7 +206,7 @@ var createVercelPreset = function(appContext, modernConfig, needModernServer) {
               return [
                 4,
                 handleDependencies(appDirectory, funcsDirectory, [
-                  "@modern-js/prod-server"
+                  require.resolve("@modern-js/prod-server")
                 ])
               ];
             case 1:

package/dist/esm-node/plugins/deploy/dependencies/index.js

@@ -1,21 +1,11 @@
-import path, { isAbsolute } from "node:path";
+import path from "node:path";
 import { fs as fse, pkgUp, semver } from "@modern-js/utils";
 import { readPackageJSON } from "pkg-types";
 import { parseNodeModulePath } from "mlly";
 import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles, findPackageParents, resolveTracedPath } from "./utils";
-const handleDependencies = async (appDir, serverRootDir, include, entryFilter) => {
+const handleDependencies = async (appDir, serverRootDir, includeEntries, entryFilter, modifyPackageJson) => {
   const base = "/";
   const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
-  const includeEntries = include.map((item) => {
-    if (isAbsolute(item)) {
-      return item;
-    }
-    try {
-      return require.resolve(item);
-    } catch (error) {
-    }
-    return item;
-  });
   const fileTrace = await traceFiles(entryFiles.concat(includeEntries), serverRootDir, base);
   const currentProjectModules = path.join(appDir, "node_modules");
   const tracedFiles = Object.fromEntries(await Promise.all([
@@ -166,7 +156,7 @@ const handleDependencies = async (appDir, serverRootDir, include, entryFilter) =
     }
   }
   const outputPkgPath = path.join(serverRootDir, "package.json");
-  await fse.writeJSON(outputPkgPath, {
+  const newPkgJson = {
     name: `${projectPkgJson.name || "modernjs-project"}-prod`,
     version: projectPkgJson.version || "0.0.0",
     private: true,
@@ -176,7 +166,9 @@ const handleDependencies = async (appDir, serverRootDir, include, entryFilter) =
         Object.keys(pkg.versions)[0]
       ])
     ].sort(([a], [b]) => a.localeCompare(b)))
-  });
+  };
+  const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
+  await fse.writeJSON(outputPkgPath, finalPkgJson);
 };
 export {
   handleDependencies

package/dist/esm-node/plugins/deploy/platforms/netlify.js

@@ -92,7 +92,7 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
         return;
       }
       await handleDependencies(appDirectory, funcsDirectory, [
-        "@modern-js/prod-server"
+        require.resolve("@modern-js/prod-server")
       ]);
     }
   };

package/dist/esm-node/plugins/deploy/platforms/node.js

@@ -46,7 +46,7 @@ const createNodePreset = (appContext, config) => {
         return !filePath.startsWith(staticDirectory);
       };
       await handleDependencies(appDirectory, outputDirectory, [
-        "@modern-js/prod-server"
+        require.resolve("@modern-js/prod-server")
       ], filter);
     }
   };

package/dist/esm-node/plugins/deploy/platforms/vercel.js

@@ -104,7 +104,7 @@ const createVercelPreset = (appContext, modernConfig, needModernServer) => {
         return;
       }
       await handleDependencies(appDirectory, funcsDirectory, [
-        "@modern-js/prod-server"
+        require.resolve("@modern-js/prod-server")
       ]);
     }
   };

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

@@ -0,0 +1,15 @@
+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 FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
+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';

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

@@ -0,0 +1,179 @@
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import * as templates from "./templates";
+import { getClientRoutes } from "./getClientRoutes";
+import { FILE_SYSTEM_ROUTES_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME } from "./constants";
+import { getDefaultImports } from "./utils";
+
+const createImportSpecifier = specifiers => {
+  let defaults = '';
+  const named = [];
+
+  for (const {
+    local,
+    imported
+  } of specifiers) {
+    if (local && imported) {
+      named.push(`${imported} as ${local}`);
+    } else if (local) {
+      defaults = local;
+    } else {
+      named.push(imported);
+    }
+  }
+
+  if (defaults && named.length) {
+    return `${defaults}, { ${named.join(', ')} }`;
+  } else if (defaults) {
+    return defaults;
+  } else {
+    return `{ ${named.join(', ')} }`;
+  }
+};
+
+export const createImportStatements = statements => {
+  // merge import statements with the same value.
+  const deDuplicated = [];
+  const seen = new Map();
+
+  for (const {
+    value,
+    specifiers,
+    initialize
+  } of statements) {
+    if (!seen.has(value)) {
+      deDuplicated.push({
+        value,
+        specifiers,
+        initialize
+      });
+      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 || ''}`);
+    }
+  }
+
+  return deDuplicated.map(({
+    value,
+    specifiers,
+    initialize
+  }) => `import ${createImportSpecifier(specifiers)} from '${value}';\n${initialize || ''}`).join('\n');
+};
+export const generateCode = async (appContext, config, entrypoints, api) => {
+  const {
+    internalDirectory,
+    srcDirectory,
+    internalDirAlias,
+    internalSrcAlias
+  } = appContext;
+  const hookRunners = api.useHookRunners();
+  const {
+    output: {
+      mountId
+    }
+  } = config;
+
+  for (const entrypoint of entrypoints) {
+    const {
+      entryName,
+      isAutoMount,
+      customBootstrap,
+      fileSystemRoutes
+    } = entrypoint;
+
+    if (isAutoMount) {
+      // generate routes file for file system routes entrypoint.
+      if (fileSystemRoutes) {
+        const initialRoutes = getClientRoutes({
+          entrypoint,
+          srcDirectory,
+          srcAlias: internalSrcAlias,
+          internalDirectory,
+          internalDirAlias
+        });
+        const {
+          routes
+        } = await hookRunners.modifyFileSystemRoutes({
+          entrypoint,
+          routes: initialRoutes
+        });
+        const {
+          code
+        } = await hookRunners.beforeGenerateRoutes({
+          entrypoint,
+          code: templates.fileSystemRoutes({
+            routes
+          })
+        });
+        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({
+          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({
+          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');
+      }
+    }
+  }
+};

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

@@ -0,0 +1,75 @@
+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 => {
+  if (!path.extname(file)) {
+    return findExists(JS_EXTENSIONS.map(ext => `${file}${ext}`)) || file;
+  }
+
+  return file;
+};
+
+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.`);
+  }
+
+  return false;
+});
+
+export const getBundleEntry = (appContext, config) => {
+  const {
+    appDirectory,
+    packageName
+  } = appContext;
+  const {
+    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 => {
+      const value = entries[name];
+      const entrypoint = typeof value === 'string' ? {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value),
+        isAutoMount: true,
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : undefined
+      } : {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value.entry),
+        isAutoMount: !value.disableMount,
+        fileSystemRoutes: value.enableFileSystemRoutes ? {} : undefined
+      };
+
+      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
+    }) => entryName === packageName || path.dirname(entry) === entriesDirAbs);
+    found && (found.entryName = MAIN_ENTRY_NAME);
+  }
+
+  return defaults;
+};