react-native-bundle-discovery 2.3.0 → 2.5.0

package/README.md

@@ -90,6 +90,10 @@ npx react-native-bundle-discovery-cli metro-stats.json
 
 # Display all packages in the bundle report
 npx react-native-bundle-discovery-cli packages metro-stats.json [--sort size|name] [--format json|table|default]
+
+# Display the heaviest modules in the bundle report (default limit: 50, --limit 0 shows all)
+# --filter accepts plain text (case-insensitive) or a regexp: --filter '/\.json/i'
+npx react-native-bundle-discovery-cli modules metro-stats.json [--limit 50] [--filter <text|/regexp/>] [--sort size|name] [--format json|table|default]
 ```
 
 #### UI package

package/index.js

@@ -3,6 +3,7 @@ const { writeFileSync, existsSync } = require("fs");
 const { Buffer } = require("buffer");
 const chalk = require("chalk");
 const BundleDiscoveryPlugin = require("./webpack").BundleDiscoveryPlugin;
+const { withPackagesMetadata } = require("./packageMetadata");
 const NAME = require("./package.json").name;
 
 function getDefault(module) {
@@ -106,7 +107,7 @@ function toModuleStruct(m, includeCode) {
   };
 }
 
-function createJsonReport({
+async function createJsonReport({
   graph,
   entryPoint,
   includeEnvs,
@@ -116,12 +117,30 @@ function createJsonReport({
   rootFolder,
   silent,
   options,
+  fetchPackagesMetadata,
 }) {
   const { processModuleFilter = () => true } = options || {};
   const dependencies = Array.from(graph.dependencies.values()).filter(
     processModuleFilter,
   );
 
+  let packages = toPackages(preModules).concat(toPackages(dependencies));
+  const modules = preModules
+    .map((m) => toModuleStruct(m, includeCode))
+    .concat(dependencies.map((m) => toModuleStruct(m, includeCode)));
+
+  if (fetchPackagesMetadata) {
+    packages = await withPackagesMetadata(packages, {
+      onError: (error, pkg) => {
+        if (!silent) {
+          console.warn(
+            `${chalk.yellow(`[${NAME}]`)}: Failed to fetch metadata for ${pkg.name}@${pkg.version}: ${error.message}`,
+          );
+        }
+      },
+    });
+  }
+
   const stats = {
     date: Date.now(),
     entryPoint,
@@ -131,10 +150,8 @@ function createJsonReport({
       return acc;
     }, {}),
     rootFolder,
-    packages: toPackages(preModules).concat(toPackages(dependencies)),
-    modules: preModules
-      .map((m) => toModuleStruct(m, includeCode))
-      .concat(dependencies.map((m) => toModuleStruct(m, includeCode))),
+    packages,
+    modules,
   };
 
   writeFileSync(outputJsonPath, JSON.stringify(stats));
@@ -156,6 +173,7 @@ function createJsonReport({
  * @param {string} [options.outputJsonPath] - The path where the JSON report will be saved. Defaults to "metro-stats.json" in the project root.
  * @param {boolean} [options.includeCode=true] - Whether to include the source and output code in the JSON report.
  * @param {string[]} [options.includeEnvs=[]] - A list of environment variable names to include in the JSON report.
+ * @param {boolean} [options.fetchPackagesMetadata=true] - Whether to fetch packages metadata (publish date, deprecation, latest version) from the npm registry.
  * @returns {Function} - A custom serializer function to be used by Metro.
  * @throws {Error} - Throws an error if the project root does not exist.
  */
@@ -166,6 +184,7 @@ function createSerializer({
   includeCode = true,
   silent = false,
   includeEnvs = [],
+  fetchPackagesMetadata = true,
 } = {}) {
   const mySerializer = serializer || getDefaultSerializer();
 
@@ -179,6 +198,12 @@ function createSerializer({
   function customSerializer(entryPoint, preModules, graph, options) {
     const code = mySerializer(entryPoint, preModules, graph, options);
 
+    // Keeps the Node.js process alive until the report is written
+    // (otherwise it can exit while metadata requests are still pending)
+    const keepAlive = setInterval(() => {}, 1000);
+
+    // Graph/modules are read synchronously before the first `await`,
+    // so the report is not affected by later Metro graph mutations
     createJsonReport({
       graph,
       entryPoint,
@@ -189,7 +214,8 @@ function createSerializer({
       rootFolder: projectRoot,
       silent,
       options,
-    });
+      fetchPackagesMetadata,
+    }).finally(() => clearInterval(keepAlive));
 
     return code;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-bundle-discovery",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "main": "index.js",
   "repository": "git@github.com:retyui/react-native-bundle-discovery.git",
   "author": "David <4661784+retyui@users.noreply.github.com>",

package/packageMetadata.js

@@ -0,0 +1,155 @@
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const DEFAULT_TIMEOUT_MS = 1_000;
+const DEFAULT_CONCURRENCY = 8;
+
+// Simple in-memory cache: `${registry}|${name}` -> Promise<packument summary | null>
+// Keeps promises (not values) so concurrent lookups of the same package share one request,
+// and different versions of the same package share one packument.
+const cache = new Map();
+
+/**
+ * `@babel/runtime` -> `@babel%2fruntime`
+ */
+function encodePackageName(name) {
+  return name.startsWith("@") ? `@${encodeURIComponent(name.slice(1))}` : name;
+}
+
+async function fetchJson(url, timeoutMs) {
+  const res = await fetch(url, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (res.status === 404) {
+    return null;
+  }
+  if (!res.ok) {
+    throw new Error(`${res.status} ${res.statusText} (${url})`);
+  }
+  return res.json();
+}
+
+/**
+ * The version manifest (`/<name>/<version>`) has no publish date,
+ * so the packument is fetched once and only the fields we need are kept.
+ */
+async function fetchPackageSummary(name, { registry, timeoutMs }) {
+  const packument = await fetchJson(
+    `${registry}/${encodePackageName(name)}`,
+    timeoutMs,
+  );
+
+  if (!packument) {
+    return null;
+  }
+
+  const versions = {};
+  for (const [version, manifest] of Object.entries(packument.versions ?? {})) {
+    versions[version] = {
+      createdAt: packument.time?.[version] ?? null,
+      deprecated: manifest.deprecated || false,
+    };
+  }
+
+  return {
+    latestVersion: packument["dist-tags"]?.latest ?? null,
+    versions,
+  };
+}
+
+function getPackageSummary(name, { registry, timeoutMs }) {
+  const key = `${registry}|${name}`;
+
+  if (!cache.has(key)) {
+    const promise = fetchPackageSummary(name, { registry, timeoutMs }).catch(
+      (error) => {
+        // Don't cache failures (network issues, timeouts), retry on next report
+        cache.delete(key);
+        throw error;
+      },
+    );
+    cache.set(key, promise);
+  }
+
+  return cache.get(key);
+}
+
+/**
+ * Returns metadata of a specific (installed) package version, not the latest one.
+ *
+ * @returns {Promise<{createdAt: string|null, deprecated: string|false, isLatest: boolean, latestVersion: string|null} | null>}
+ *   `null` when the package/version is not found in the registry.
+ */
+async function getPackageMetadata(
+  name,
+  version,
+  { registry = DEFAULT_REGISTRY, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
+) {
+  const summary = await getPackageSummary(name, { registry, timeoutMs });
+  const info = summary?.versions[version];
+
+  if (!info) {
+    return null;
+  }
+
+  return {
+    createdAt: info.createdAt,
+    deprecated: info.deprecated,
+    isLatest: summary.latestVersion === version,
+    latestVersion: summary.latestVersion,
+  };
+}
+
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let index = 0;
+
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, worker),
+  );
+
+  return results;
+}
+
+/**
+ * Adds a `metadata` field to every package of the report.
+ * Failed lookups result in `metadata: null` and are passed to `onError`.
+ *
+ * @param {Array<{name: string, version: string}>} packages
+ */
+async function withPackagesMetadata(
+  packages,
+  {
+    registry = DEFAULT_REGISTRY,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    concurrency = DEFAULT_CONCURRENCY,
+    onError = () => {},
+  } = {},
+) {
+  return mapWithConcurrency(packages, concurrency, async (pkg) => {
+    if (!pkg.version) {
+      return { ...pkg, metadata: null };
+    }
+    try {
+      const metadata = await getPackageMetadata(pkg.name, pkg.version, {
+        registry,
+        timeoutMs,
+      });
+      return { ...pkg, metadata };
+    } catch (error) {
+      onError(error, pkg);
+      return { ...pkg, metadata: null };
+    }
+  });
+}
+
+module.exports = {
+  getPackageMetadata,
+  withPackagesMetadata,
+};

package/webpack.js

@@ -4,7 +4,9 @@ const path = require("node:path");
 const chalk = require("chalk");
 
 const { parseBundle } = require("./parseUtils.js");
+const { withPackagesMetadata } = require("./packageMetadata.js");
 const NAME = require("./package.json").name;
+const packageRegex = /(?:^|\/)node_modules\/((?:@[^\/]+\/)?[^\/]+)/g;
 
 /**
  * Simple Webpack/Rspack plugin
@@ -12,10 +14,11 @@ const NAME = require("./package.json").name;
  *   to metro-stats.json format used by `react-native-bundle-discovery`
  */
 class BundleDiscoveryPlugin {
-  constructor({ filename, options, enabled } = {}) {
+  constructor({ filename, options, enabled, fetchPackagesMetadata } = {}) {
     this.options = options;
     this.filename = filename || "metro-stats.json";
     this.enabled = enabled ?? true;
+    this.fetchPackagesMetadata = fetchPackagesMetadata ?? true;
   }
 
   extractSizesFromJsBundle(statAsset, options) {
@@ -47,6 +50,7 @@ class BundleDiscoveryPlugin {
         all: false,
         source: true,
       });
+
       // Format the stats into the desired structure
       const statsJson = this.formatStat(
         json,
@@ -57,16 +61,39 @@ class BundleDiscoveryPlugin {
       );
       // Write the formatted stats to the specified output file
       const outputPath = path.resolve(compiler.options.context, this.filename);
-      fs.writeFileSync(outputPath, JSON.stringify(statsJson, null, 2));
 
-      console.log(
-        `${chalk.yellow(`[${NAME}]`)}: Saved stats to ${chalk.green(
-          outputPath,
-        )}`,
-      );
+      // Keeps the Node.js process alive until the report is written
+      // (otherwise it can exit while metadata requests are still pending)
+      const keepAlive = setInterval(() => {}, 1000);
+
+      this.writeReport(statsJson, outputPath)
+        .catch((error) => {
+          console.error(
+            `${chalk.yellow(`[${NAME}]`)}: Failed to create JSON report: ${error.message}`,
+          );
+        })
+        .finally(() => clearInterval(keepAlive));
     });
   }
 
+  async writeReport(statsJson, outputPath) {
+    if (this.fetchPackagesMetadata) {
+      statsJson.packages = await withPackagesMetadata(statsJson.packages, {
+        onError: (error, pkg) => {
+          console.warn(
+            `${chalk.yellow(`[${NAME}]`)}: Failed to fetch metadata for ${pkg.name}@${pkg.version}: ${error.message}`,
+          );
+        },
+      });
+    }
+
+    fs.writeFileSync(outputPath, JSON.stringify(statsJson, null, 2));
+
+    console.log(
+      `${chalk.yellow(`[${NAME}]`)}: Saved stats to ${chalk.green(outputPath)}`,
+    );
+  }
+
   readSource(filePath) {
     const fallback = { code: "", lineCount: 0, sizeInBytes: 0 };
     try {
@@ -83,49 +110,83 @@ class BundleDiscoveryPlugin {
     }
   }
 
-  getPackageName(modulePath) {
-    if (!modulePath) {
-      return null;
-    }
-    const parts = modulePath.split("node_modules");
-    if (parts.length < 2) {
-      return null;
-    }
-    // WARN: Won't work with `pnpm's nested layout`
-    const packagePath = parts[1].split(path.sep).filter(Boolean);
-    if (packagePath.length === 0) {
-      return null;
-    }
-    if (packagePath[0].startsWith("@")) {
-      return `${packagePath[0]}/${packagePath[1]}`;
-    }
-    return packagePath[0];
-  }
-  getAbsolutePath(packageName, modulePath) {
-    if (!packageName) {
-      return null;
+  getPkgVersionFromPath(path) {
+    try {
+      // Extract the segment right before node_modules in `.pnpm/.../node_modules/`
+      const matches = [...path.matchAll(/\.pnpm\/([^/]+)\/node_modules/g)];
+      if (!matches.length) return null;
+
+      const lastPnpmFolder = matches[matches.length - 1][1];
+
+      // Folder format is `<name>@<version>[_<peers>]`, where `<name>` may be scoped
+      // (`@scope+name`, `@scope_name`), so skip the leading `@` of the scope
+      const versionMatch = lastPnpmFolder.match(/^@?[^@]+@([^_]+)/);
+
+      return versionMatch ? versionMatch[1] : null;
+    } catch {
+      return "";
     }
-    return modulePath.substring(
-      0,
-      modulePath.indexOf(packageName) + packageName.length,
-    );
   }
+
   getPackages(statsJson) {
-    const packagesMap = statsJson.modules.reduce((allPackages, mdl) => {
-      const name = this.getPackageName(mdl.nameForCondition);
-      if (!name) {
-        return allPackages;
+    const packagesMap = new Map();
+
+    for (const mdl of statsJson.modules) {
+      const filePath = mdl.nameForCondition;
+      if (!filePath) {
+        continue;
       }
-      const absolutePath = this.getAbsolutePath(name, mdl.nameForCondition);
-      if (!allPackages.has(absolutePath)) {
-        allPackages.set(absolutePath, {
-          name,
-          absolutePath,
-          version: require(path.join(absolutePath, "package.json")).version,
+
+      let match;
+      let lastMatch = null;
+
+      // Reset regex state for global matching
+      packageRegex.lastIndex = 0;
+
+      // Find the LAST valid node_modules/<pkg> pattern in the path
+      while ((match = packageRegex.exec(filePath)) !== null) {
+        lastMatch = match;
+      }
+
+      if (!lastMatch) continue;
+
+      const packageName = lastMatch[1];
+      const matchIndex = lastMatch.index;
+
+      // Account for potential leading slash in the regex match
+      const prefixOffset = filePath[matchIndex] === "/" ? 1 : 0;
+      const cutIndex =
+        matchIndex + prefixOffset + "node_modules/".length + packageName.length;
+
+      const absolutePath = filePath.slice(0, cutIndex);
+
+      let version = "";
+      try {
+        version = require(path.join(absolutePath, "package.json")).version;
+      } catch (e) {
+        const verFromPath = this.getPkgVersionFromPath(absolutePath);
+        if (verFromPath) {
+          version = verFromPath;
+        } else {
+          if (e?.code === "MODULE_NOT_FOUND") {
+            console.warn(`[${NAME}] getPackages: unexpected path resolution`, {
+              filePath,
+              absolutePath,
+            });
+          } else {
+            throw e;
+          }
+        }
+      }
+
+      if (!packagesMap.has(absolutePath)) {
+        packagesMap.set(absolutePath, {
+          name: packageName,
+          absolutePath: absolutePath,
+          version: version,
         });
       }
-      return allPackages;
-    }, new Map());
+    }
     return Array.from(packagesMap.values());
   }
   getEntryFile(statsJson, rootFolder) {
@@ -166,10 +227,15 @@ class BundleDiscoveryPlugin {
       statsJson,
       compilerOptions,
     );
+
     return {
+      kind: "webpack",
       date: statsJson.builtAt || Date.now(),
       entryPoint: this.getEntryFile(statsJson, compilerOptions.context),
-      rootFolder: compilerOptions.context,
+      rootFolder:
+        this.findCommonRoot(
+          statsJson.modules.map((m) => m.nameForCondition).filter(Boolean),
+        ) || compilerOptions.context,
       // envs: {},
       transformOptions: {
         // customTransformOptions: {},
@@ -195,7 +261,7 @@ class BundleDiscoveryPlugin {
             };
 
             return {
-              path: "runtime modules", // Can we rename it?
+              path: "__runtime__",
               source: sourceAndOutput,
               output: sourceAndOutput,
               dependencies: [],
@@ -209,7 +275,7 @@ class BundleDiscoveryPlugin {
             dependencies: modulesDeps.get(mdl.nameForCondition) ?? [],
           };
         })
-        .filter((e) => e !== null),
+        .filter((e) => e !== null && e.path),
       packages: this.getPackages(statsJson),
     };
   }
@@ -264,6 +330,44 @@ class BundleDiscoveryPlugin {
 
     return importsMap;
   }
+
+  findCommonRoot(paths) {
+    if (!paths || paths.length === 0) return "";
+    if (paths.length === 1) {
+      const lastSlash = paths[0].lastIndexOf("/");
+      return lastSlash === -1 ? "" : paths[0].slice(0, lastSlash);
+    }
+
+    const first = paths[0];
+    let maxLen = first.length;
+
+    // Short-circuit scanning loop across all paths
+    for (let i = 1; i < paths.length; i++) {
+      const current = paths[i];
+      const limit = Math.min(maxLen, current.length);
+      let j = 0;
+
+      // Fast character match using engine string optimizations
+      while (j < limit && first.charCodeAt(j) === current.charCodeAt(j)) {
+        j++;
+      }
+
+      maxLen = j;
+      if (maxLen === 0) return "";
+    }
+
+    // Exact match down to the root or full path segment
+    if (maxLen === first.length) {
+      const lastSlash = first.lastIndexOf("/");
+      return lastSlash === -1 ? "" : first.slice(0, lastSlash);
+    }
+
+    // Truncate to the last valid '/' boundary within maxLen
+    const commonSlice = first.slice(0, maxLen);
+    const lastSlash = commonSlice.lastIndexOf("/");
+
+    return lastSlash === -1 ? "" : commonSlice.slice(0, lastSlash);
+  }
 }
 
 module.exports = { BundleDiscoveryPlugin };