@modern-js/app-tools 2.54.2 → 2.54.3-alpha.4

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

@@ -106,9 +106,14 @@ var createNodePreset = function(appContext, config) {
               };
               return [
                 4,
-                handleDependencies(appDirectory, outputDirectory, [
-                  "@modern-js/prod-server"
-                ], filter)
+                handleDependencies({
+                  appDir: appDirectory,
+                  serverRootDir: outputDirectory,
+                  includeEntries: [
+                    require.resolve("@modern-js/prod-server")
+                  ],
+                  entryFilter: filter
+                })
               ];
             case 1:
               _state.sent();

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

@@ -207,9 +207,13 @@ var createVercelPreset = function(appContext, modernConfig, needModernServer) {
               }
               return [
                 4,
-                handleDependencies(appDirectory, funcsDirectory, [
-                  "@modern-js/prod-server"
-                ])
+                handleDependencies({
+                  appDir: appDirectory,
+                  serverRootDir: funcsDirectory,
+                  includeEntries: [
+                    require.resolve("@modern-js/prod-server")
+                  ]
+                })
               ];
             case 1:
               _state.sent();

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) => {
+import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles as defaultTraceFiles, findPackageParents, resolveTracedPath, readDirRecursive } from "./utils";
+const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage }) => {
   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([
@@ -110,9 +100,17 @@ const handleDependencies = async (appDir, serverRootDir, include, entryFilter) =
       }
       tracedPackage.versions[pkgJSON.version] = tracedPackageVersion;
     }
-    tracedFile.path.startsWith(tracedFile.pkgPath) && tracedPackageVersion.path === tracedFile.pkgPath && tracedPackageVersion.files.push(tracedFile.path);
     tracedFile.pkgName = pkgName;
     tracedFile.pkgVersion = pkgJSON.version;
+    const shouldCopyWholePackage = copyWholePackage === null || copyWholePackage === void 0 ? void 0 : copyWholePackage(pkgName);
+    if (tracedFile.path.startsWith(tracedFile.pkgPath) && tracedPackageVersion.pkgJSON.version === tracedFile.pkgVersion) {
+      if (shouldCopyWholePackage) {
+        const allFiles = await readDirRecursive(tracedFile.pkgPath);
+        tracedPackageVersion.files.push(...allFiles);
+      } else {
+        tracedPackageVersion.files.push(tracedFile.path);
+      }
+    }
   }
   const multiVersionPkgs = {};
   const singleVersionPackages = [];
@@ -130,7 +128,11 @@ const handleDependencies = async (appDir, serverRootDir, include, entryFilter) =
   await Promise.all(singleVersionPackages.map((pkgName) => {
     const pkg = tracedPackages[pkgName];
     const version = Object.keys(pkg.versions)[0];
-    return writePackage(pkg, version, serverRootDir);
+    return writePackage({
+      pkg,
+      version,
+      projectDir: serverRootDir
+    });
   }));
   const projectPkgJson = await readPackageJSON(serverRootDir).catch(() => ({}));
   for (const [pkgName, pkgVersions] of Object.entries(multiVersionPkgs)) {
@@ -157,7 +159,12 @@ const handleDependencies = async (appDir, serverRootDir, include, entryFilter) =
     for (const [version, parentPkgs] of versionEntires) {
       const pkg = tracedPackages[pkgName];
       const pkgDestPath = `.modernjs/${pkgName}@${version}/node_modules/${pkgName}`;
-      await writePackage(pkg, version, serverRootDir, pkgDestPath);
+      await writePackage({
+        pkg,
+        version,
+        projectDir: serverRootDir,
+        _pkgPath: pkgDestPath
+      });
       await linkPackage(pkgDestPath, `${pkgName}`, serverRootDir);
       for (const parentPkg of parentPkgs) {
         const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
@@ -166,7 +173,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 +183,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/dependencies/utils.js

@@ -2,7 +2,7 @@ import path from "path";
 import os from "node:os";
 import { fs as fse } from "@modern-js/utils";
 import { parseNodeModulePath } from "mlly";
-import { nodeFileTrace, resolve } from "@vercel/nft";
+import { nodeFileTrace } from "@vercel/nft";
 function applyPublicCondition(pkg) {
   var _pkg_publishConfig;
   if (pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig = pkg.publishConfig) === null || _pkg_publishConfig === void 0 ? void 0 : _pkg_publishConfig.exports) {
@@ -10,7 +10,8 @@ function applyPublicCondition(pkg) {
     pkg.exports = pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig1 = pkg.publishConfig) === null || _pkg_publishConfig1 === void 0 ? void 0 : _pkg_publishConfig1.exports;
   }
 }
-const writePackage = async (pkg, version, projectDir, _pkgPath) => {
+const writePackage = async (options) => {
+  const { pkg, version, projectDir, _pkgPath } = options;
   const pkgPath = _pkgPath || pkg.name;
   for (const src of pkg.versions[version].files) {
     if (src.includes("node_modules")) {
@@ -84,31 +85,23 @@ const findEntryFiles = async (rootDir, entryFilter) => {
 const findPackageParents = (pkg, version, tracedFiles) => {
   const versionFiles = pkg.versions[version].files.map((path2) => tracedFiles[path2]);
   const parentPkgs = [
-    ...new Set(versionFiles.flatMap((file) => file.parents.map((parentPath) => {
-      const parentFile = tracedFiles[parentPath];
-      if (!parentFile || parentFile.pkgName === pkg.name) {
-        return null;
-      }
-      return `${parentFile.pkgName}@${parentFile.pkgVersion}`;
-    }).filter(Boolean)))
+    ...new Set(versionFiles.flatMap((file) => (
+      // Because it supports copyWholePackage configuration, not all files exist.
+      file === null || file === void 0 ? void 0 : file.parents.map((parentPath) => {
+        const parentFile = tracedFiles[parentPath];
+        if (!parentFile || parentFile.pkgName === pkg.name) {
+          return null;
+        }
+        return `${parentFile.pkgName}@${parentFile.pkgVersion}`;
+      }).filter(Boolean)
+    )))
   ];
-  return parentPkgs;
+  return parentPkgs.filter((parentPkg) => parentPkg);
 };
 const traceFiles = async (entryFiles, serverRootDir, base = "/") => {
   return await nodeFileTrace(entryFiles, {
     base,
-    processCwd: serverRootDir,
-    resolve: async (id, parent, job, isCjs) => {
-      if (id.startsWith("@modern-js/prod-server")) {
-        return require.resolve(id, {
-          paths: [
-            require.resolve("@modern-js/app-tools")
-          ]
-        });
-      } else {
-        return resolve(id, parent, job, isCjs);
-      }
-    }
+    processCwd: serverRootDir
   });
 };
 const resolveTracedPath = async (base, p) => fse.realpath(path.resolve(base, p));

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

@@ -0,0 +1,4 @@
+import { handleDependencies } from "./dependencies";
+export {
+  handleDependencies
+};

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

@@ -91,9 +91,13 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
       if (!needModernServer) {
         return;
       }
-      await handleDependencies(appDirectory, funcsDirectory, [
-        "@modern-js/prod-server"
-      ]);
+      await handleDependencies({
+        appDir: appDirectory,
+        serverRootDir: funcsDirectory,
+        includeEntries: [
+          require.resolve("@modern-js/prod-server")
+        ]
+      });
     }
   };
 };

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

@@ -45,9 +45,14 @@ const createNodePreset = (appContext, config) => {
       const filter = (filePath) => {
         return !filePath.startsWith(staticDirectory);
       };
-      await handleDependencies(appDirectory, outputDirectory, [
-        "@modern-js/prod-server"
-      ], filter);
+      await handleDependencies({
+        appDir: appDirectory,
+        serverRootDir: outputDirectory,
+        includeEntries: [
+          require.resolve("@modern-js/prod-server")
+        ],
+        entryFilter: filter
+      });
     }
   };
 };

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

@@ -103,9 +103,13 @@ const createVercelPreset = (appContext, modernConfig, needModernServer) => {
       if (!needModernServer) {
         return;
       }
-      await handleDependencies(appDirectory, funcsDirectory, [
-        "@modern-js/prod-server"
-      ]);
+      await handleDependencies({
+        appDir: appDirectory,
+        serverRootDir: funcsDirectory,
+        includeEntries: [
+          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;
+};