react-native-bundle-discovery 2.2.0 → 2.5.0

package/README.md

@@ -15,6 +15,8 @@ With this tool, you can easily explore your app's codebase, identify large or he
 - `react-native-bundle-discovery-cli` - CLI to analyze the bundle report.
 - `react-native-bundle-discovery-rozenite-plugin` - Rozenite plugin to integrate UI tool to [React Native DevTools](https://reactnative.dev/docs/react-native-devtools).
 
+---
+
 ### Setup:
 
 There are two ways to install the package:
@@ -22,6 +24,11 @@ There are two ways to install the package:
 1. As in independent tool (UI + CLI)
 2. Or as a [Rozenite](_rozenite/README.md) plugin (see: [_rozenite/README.md](_rozenite/README.md))
 
+
+> 🚀 If you've migrated to [Re.Pack](https://re-pack.dev/), you can still use this package to analyze 📊 JS bundles 📦 generated by Re.Pack.
+>
+> 💡 Learn more: 📖 [Re.Pack.md](./Re.Pack.md)
+
 #### 1. Install (independent tool)
 
 ```bash
@@ -60,7 +67,7 @@ See: [_rozenite/README.md](_rozenite/README.md)
 
 ### 3. Build the app
 
-As example, for iOS you can run the following command, and it will generate the `metro-stats.json` file in the root of your project:
+For example, for iOS you can run the following command, and it will generate the `metro-stats.json` file in the root of your project:
 
 ```bash
 npx react-native bundle \
@@ -83,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

@@ -2,7 +2,8 @@ const { parse, resolve } = require("path");
 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;
   }
@@ -268,7 +294,8 @@ const createProcessModuleFilter =
   };
 
 module.exports = {
-  createResolveRequest,
   createSerializer,
+  createResolveRequest,
   createProcessModuleFilter,
+  BundleDiscoveryPlugin,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-bundle-discovery",
-  "version": "2.2.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>",
@@ -9,7 +9,9 @@
     "prepublishOnly": "cp ../README.md README.md"
   },
   "dependencies": {
-    "chalk": "^4.1.2"
+    "chalk": "^4.1.2",
+    "acorn": "^8.0.4",
+    "acorn-walk": "^8.0.0"
   },
   "peerDependencies": {
     "metro": "*"
@@ -20,6 +22,6 @@
     }
   },
   "files": [
-    "index.js"
+    "*.js"
   ]
 }

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/parseUtils.js

@@ -0,0 +1,615 @@
+//////////////////////////////////////////////////////////////////////////////////////////
+// Copy of: https://github.com/webpack/webpack-bundle-analyzer/blob/main/src/parseUtils.js
+// Thanks to the Webpack maintainers! 🙏
+//////////////////////////////////////////////////////////////////////////////////////////
+/** @typedef {import("acorn").Node} Node */
+/** @typedef {import("acorn").CallExpression} CallExpression */
+/** @typedef {import("acorn").ExpressionStatement} ExpressionStatement */
+/** @typedef {import("acorn").Expression} Expression */
+/** @typedef {import("acorn").SpreadElement} SpreadElement */
+
+const fs = require("node:fs");
+const acorn = require("acorn");
+const walk = require("acorn-walk");
+
+/**
+ * @param {Expression} node node
+ * @returns {boolean} true when id is numeric, otherwise false
+ */
+function isNumericId(node) {
+  return (
+    node.type === "Literal" &&
+    node.value !== null &&
+    node.value !== undefined &&
+    Number.isInteger(node.value) &&
+    /** @type {number} */ (node.value) >= 0
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when module id, otherwise false
+ */
+function isModuleId(node) {
+  return (
+    node !== null &&
+    node.type === "Literal" &&
+    (isNumericId(node) || typeof node.value === "string")
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement} node node
+ * @returns {boolean} true when module wrapper, otherwise false
+ */
+function isModuleWrapper(node) {
+  return (
+    // It's an anonymous function expression that wraps module
+    ((node.type === "FunctionExpression" ||
+      node.type === "ArrowFunctionExpression") &&
+      !node.id) ||
+    // If `DedupePlugin` is used it can be an ID of duplicated module...
+    isModuleId(node) ||
+    // or an array of shape [<module_id>, ...args]
+    (node.type === "ArrayExpression" &&
+      node.elements.length > 1 &&
+      isModuleId(node.elements[0]))
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when module hash, otherwise false
+ */
+function isModulesHash(node) {
+  return (
+    node !== null &&
+    node.type === "ObjectExpression" &&
+    node.properties
+      .filter((property) => property.type !== "SpreadElement")
+      .map((node) => node.value)
+      .every(isModuleWrapper)
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when module array, otherwise false
+ */
+function isModulesArray(node) {
+  return (
+    node !== null &&
+    node.type === "ArrayExpression" &&
+    node.elements.every(
+      (elem) =>
+        // Some of array items may be skipped because there is no module with such id
+        !elem || isModuleWrapper(elem),
+    )
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when simple modules list, otherwise false
+ */
+function isSimpleModulesList(node) {
+  return (
+    // Modules are contained in hash. Keys are module ids.
+    isModulesHash(node) ||
+    // Modules are contained in array. Indexes are module ids.
+    isModulesArray(node)
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when optimized modules array, otherwise false
+ */
+function isOptimizedModulesArray(node) {
+  // Checking whether modules are contained in `Array(<minimum ID>).concat(...modules)` array:
+  // https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
+  // The `<minimum ID>` + array indexes are module ids
+  return (
+    node !== null &&
+    node.type === "CallExpression" &&
+    node.callee.type === "MemberExpression" &&
+    // Make sure the object called is `Array(<some number>)`
+    node.callee.object.type === "CallExpression" &&
+    node.callee.object.callee.type === "Identifier" &&
+    node.callee.object.callee.name === "Array" &&
+    node.callee.object.arguments.length === 1 &&
+    node.callee.object.arguments[0].type !== "SpreadElement" &&
+    isNumericId(node.callee.object.arguments[0]) &&
+    // Make sure the property X called for `Array(<some number>).X` is `concat`
+    node.callee.property.type === "Identifier" &&
+    node.callee.property.name === "concat" &&
+    // Make sure exactly one array is passed in to `concat`
+    node.arguments.length === 1 &&
+    isModulesArray(node.arguments[0])
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when modules list, otherwise false
+ */
+function isModulesList(node) {
+  return (
+    isSimpleModulesList(node) ||
+    // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
+    isOptimizedModulesArray(node)
+  );
+}
+
+/** @typedef {{ start: number, end: number }} Location */
+
+/**
+ * @param {Node} node node
+ * @returns {Location} location
+ */
+function getModuleLocation(node) {
+  return {
+    start: node.start,
+    end: node.end,
+  };
+}
+
+/** @typedef {Record<number, Location>} ModulesLocations */
+/** @typedef {{ locations: ModulesLocations, hasWebpackRuntime: boolean, isTopLevel: boolean }} Webpack5IIFECandidate */
+
+/**
+ * @param {Expression | SpreadElement} node node
+ * @returns {ModulesLocations} modules locations
+ */
+function getModulesLocations(node) {
+  if (node.type === "ObjectExpression") {
+    // Modules hash
+    const modulesNodes = node.properties;
+
+    return modulesNodes.reduce((result, moduleNode) => {
+      if (moduleNode.type !== "Property") {
+        return result;
+      }
+
+      const moduleId =
+        moduleNode.key.type === "Identifier"
+          ? moduleNode.key.name
+          : // @ts-expect-error need verify why we need it, tests not cover it case
+            moduleNode.key.value;
+
+      if (moduleId === "undefined") {
+        return result;
+      }
+
+      result[moduleId] = getModuleLocation(moduleNode.value);
+
+      return result;
+    }, /** @type {ModulesLocations} */ ({}));
+  }
+
+  const isOptimizedArray = node.type === "CallExpression";
+
+  if (node.type === "ArrayExpression" || isOptimizedArray) {
+    // Modules array or optimized array
+    const minId =
+      isOptimizedArray &&
+      node.callee.type === "MemberExpression" &&
+      node.callee.object.type === "CallExpression" &&
+      node.callee.object.arguments[0].type === "Literal"
+        ? // Get the [minId] value from the Array() call first argument literal value
+          /** @type {number} */ (node.callee.object.arguments[0].value)
+        : // `0` for simple array
+          0;
+    const modulesNodes = isOptimizedArray
+      ? // The modules reside in the `concat()` function call arguments
+        node.arguments[0].type === "ArrayExpression"
+        ? node.arguments[0].elements
+        : []
+      : node.elements;
+
+    return modulesNodes.reduce((result, moduleNode, i) => {
+      if (moduleNode) {
+        result[i + minId] = getModuleLocation(moduleNode);
+      }
+
+      return result;
+    }, /** @type {ModulesLocations} */ ({}));
+  }
+
+  return {};
+}
+
+/**
+ * @param {ExpressionStatement} node node
+ * @returns {CallExpression | null} IIFE call expression
+ */
+function getIIFECallExpression(node) {
+  if (node.expression.type === "CallExpression") {
+    return node.expression;
+  }
+
+  if (
+    node.expression.type === "UnaryExpression" &&
+    node.expression.argument.type === "CallExpression"
+  ) {
+    return node.expression.argument;
+  }
+
+  return null;
+}
+
+/**
+ * @param {Node} node node
+ * @param {string} modulesVariableName modules variable name
+ * @returns {boolean} true when the node calls a module wrapper
+ */
+function callsModulesMap(node, modulesVariableName) {
+  let callsModule = false;
+
+  walk.simple(node, {
+    CallExpression(callExpression) {
+      const { callee } = callExpression;
+
+      if (
+        callee.type === "MemberExpression" &&
+        ((callee.object.type === "Identifier" &&
+          callee.object.name === modulesVariableName) ||
+          (callee.object.type === "MemberExpression" &&
+            callee.object.object.type === "Identifier" &&
+            callee.object.object.name === modulesVariableName))
+      ) {
+        callsModule = true;
+      }
+    },
+  });
+
+  return callsModule;
+}
+
+/**
+ * @param {import("acorn").BlockStatement} body body
+ * @param {import("acorn").VariableDeclaration} modulesDeclaration modules declaration
+ * @param {string} modulesVariableName modules variable name
+ * @returns {boolean} true when the candidate contains Webpack module loading
+ */
+function hasWebpackModulesRuntime(
+  body,
+  modulesDeclaration,
+  modulesVariableName,
+) {
+  const declarationIndex = body.body.indexOf(modulesDeclaration);
+
+  return body.body
+    .slice(declarationIndex + 1)
+    .some((statement) => callsModulesMap(statement, modulesVariableName));
+}
+
+/**
+ * @param {CallExpression} node node
+ * @param {boolean} isTopLevel is top-level IIFE
+ * @returns {Webpack5IIFECandidate | null} modules candidate
+ */
+function getWebpack5IIFEModulesCandidate(node, isTopLevel) {
+  if (
+    node.arguments.length !== 0 ||
+    (node.callee.type !== "FunctionExpression" &&
+      node.callee.type !== "ArrowFunctionExpression") ||
+    node.callee.params.length !== 0 ||
+    node.callee.body.type !== "BlockStatement"
+  ) {
+    return null;
+  }
+
+  const firstVariableDeclaration = node.callee.body.body.find(
+    (node) => node.type === "VariableDeclaration",
+  );
+
+  if (firstVariableDeclaration) {
+    for (const declaration of firstVariableDeclaration.declarations) {
+      if (declaration.init && isModulesList(declaration.init)) {
+        const locations = getModulesLocations(declaration.init);
+
+        if (Object.keys(locations).length === 0) {
+          continue;
+        }
+
+        return {
+          locations,
+          hasWebpackRuntime:
+            declaration.id.type === "Identifier" &&
+            hasWebpackModulesRuntime(
+              node.callee.body,
+              firstVariableDeclaration,
+              declaration.id.name,
+            ),
+          isTopLevel,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * @param {Webpack5IIFECandidate[]} candidates candidates
+ * @returns {Webpack5IIFECandidate | null} selected candidate
+ */
+function selectWebpack5IIFECandidate(candidates) {
+  return (
+    candidates.find(
+      (candidate) => candidate.hasWebpackRuntime && candidate.isTopLevel,
+    ) ||
+    candidates.find((candidate) => candidate.hasWebpackRuntime) ||
+    candidates.find((candidate) => candidate.isTopLevel) ||
+    null
+  );
+}
+
+/**
+ * @param {Webpack5IIFECandidate[]} candidates candidates
+ * @param {(string | number)[] | undefined} expectedModuleIds expected module ids
+ * @returns {ModulesLocations | null} selected modules locations
+ */
+function selectWebpack5IIFEModulesLocations(candidates, expectedModuleIds) {
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  if (expectedModuleIds?.length) {
+    const expectedIds = new Set(expectedModuleIds.map(String));
+    const rankedCandidates = candidates
+      .map((candidate) => ({
+        candidate,
+        expectedIdsIntersection: Object.keys(candidate.locations).filter(
+          (moduleId) => expectedIds.has(moduleId),
+        ).length,
+      }))
+      .toSorted(
+        (candidateA, candidateB) =>
+          candidateB.expectedIdsIntersection -
+          candidateA.expectedIdsIntersection,
+      );
+
+    if (rankedCandidates[0].expectedIdsIntersection > 0) {
+      const bestCandidates = rankedCandidates
+        .filter(
+          (rankedCandidate) =>
+            rankedCandidate.expectedIdsIntersection ===
+            rankedCandidates[0].expectedIdsIntersection,
+        )
+        .map((rankedCandidate) => rankedCandidate.candidate);
+
+      return selectWebpack5IIFECandidate(bestCandidates)?.locations || null;
+    }
+  }
+
+  return selectWebpack5IIFECandidate(candidates)?.locations || null;
+}
+
+/**
+ * @param {Expression} node node
+ * @returns {boolean} true when chunks ids, otherwose false
+ */
+function isChunkIds(node) {
+  // Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
+  return node.type === "ArrayExpression" && node.elements.every(isModuleId);
+}
+
+/**
+ * @param {(Expression | SpreadElement | null)[]} args arguments
+ * @returns {boolean} true when async chunk arguments, otherwise false
+ */
+function mayBeAsyncChunkArguments(args) {
+  return (
+    args.length >= 2 &&
+    args[0] !== null &&
+    args[0].type !== "SpreadElement" &&
+    isChunkIds(args[0])
+  );
+}
+
+/**
+ * Returns bundle source except modules
+ * @param {string} content content
+ * @param {ModulesLocations | null} modulesLocations modules locations
+ * @returns {string} runtime code
+ */
+function getBundleRuntime(content, modulesLocations) {
+  const sortedLocations = Object.values(modulesLocations || {}).toSorted(
+    (a, b) => a.start - b.start,
+  );
+
+  let result = "";
+  let lastIndex = 0;
+
+  for (const { start, end } of sortedLocations) {
+    result += content.slice(lastIndex, start);
+    lastIndex = end;
+  }
+
+  return result + content.slice(lastIndex);
+}
+
+/**
+ * @param {CallExpression} node node
+ * @returns {boolean} true when is async chunk push expression, otheriwse false
+ */
+function isAsyncChunkPushExpression(node) {
+  const { callee, arguments: args } = node;
+
+  return (
+    callee.type === "MemberExpression" &&
+    callee.property.type === "Identifier" &&
+    callee.property.name === "push" &&
+    callee.object.type === "AssignmentExpression" &&
+    args.length === 1 &&
+    args[0].type === "ArrayExpression" &&
+    mayBeAsyncChunkArguments(args[0].elements) &&
+    isModulesList(args[0].elements[1])
+  );
+}
+
+/**
+ * @param {CallExpression} node node
+ * @returns {boolean} true when is async web worker, otherwise false
+ */
+function isAsyncWebWorkerChunkExpression(node) {
+  const { callee, type, arguments: args } = node;
+
+  return (
+    type === "CallExpression" &&
+    callee.type === "MemberExpression" &&
+    args.length === 2 &&
+    args[0].type !== "SpreadElement" &&
+    isChunkIds(args[0]) &&
+    isModulesList(args[1])
+  );
+}
+
+/** @typedef {Record<string, string>} Modules */
+
+/**
+ * @param {string} bundlePath bundle path
+ * @param {{ sourceType?: "script" | "module", expectedModuleIds?: (string | number)[] }} opts options
+ * @returns {{ modules: Modules, src: string, runtimeSrc: string }} parsed result
+ */
+module.exports.parseBundle = function parseBundle(bundlePath, opts) {
+  const { sourceType = "script", expectedModuleIds } = opts || {};
+
+  const content = fs.readFileSync(bundlePath, "utf8");
+  const ast = acorn.parse(content, {
+    sourceType,
+    ecmaVersion: "latest",
+  });
+
+  /** @type {Set<CallExpression>} */
+  const topLevelIIFECalls = new Set();
+
+  for (const node of ast.body) {
+    if (node.type === "ExpressionStatement") {
+      const iifeCall = getIIFECallExpression(node);
+
+      if (iifeCall) {
+        topLevelIIFECalls.add(iifeCall);
+      }
+    }
+  }
+
+  /** @type {{ locations: ModulesLocations | null, webpack5IIFECandidates: Webpack5IIFECandidate[] }} */
+  const walkState = {
+    locations: null,
+    webpack5IIFECandidates: [],
+  };
+
+  walk.recursive(ast, walkState, {
+    AssignmentExpression(node, state) {
+      if (state.locations) return;
+
+      // Modules are stored in exports.modules:
+      // exports.modules = {};
+      const { left, right } = node;
+
+      if (
+        left &&
+        left.type === "MemberExpression" &&
+        left.object &&
+        left.object.type === "Identifier" &&
+        left.object.name === "exports" &&
+        left.property &&
+        left.property.type === "Identifier" &&
+        left.property.name === "modules" &&
+        isModulesHash(right)
+      ) {
+        state.locations = getModulesLocations(right);
+      }
+    },
+
+    CallExpression(node, state, callback) {
+      if (state.locations) return;
+
+      const args = node.arguments;
+      const webpack5IIFEModulesCandidate = getWebpack5IIFEModulesCandidate(
+        node,
+        topLevelIIFECalls.has(node),
+      );
+
+      if (webpack5IIFEModulesCandidate) {
+        state.webpack5IIFECandidates.push(webpack5IIFEModulesCandidate);
+      }
+
+      // Main chunk with webpack loader.
+      // Modules are stored in first argument:
+      // (function (...) {...})(<modules>)
+      if (
+        node.callee.type === "FunctionExpression" &&
+        !node.callee.id &&
+        args.length === 1 &&
+        isSimpleModulesList(args[0])
+      ) {
+        state.locations = getModulesLocations(args[0]);
+        return;
+      }
+
+      // Async Webpack < v4 chunk without webpack loader.
+      // webpackJsonp([<chunks>], <modules>, ...)
+      // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+      if (
+        node.callee.type === "Identifier" &&
+        mayBeAsyncChunkArguments(args) &&
+        args[1].type !== "SpreadElement" &&
+        isModulesList(args[1])
+      ) {
+        state.locations = getModulesLocations(args[1]);
+        return;
+      }
+
+      // Async Webpack v4 chunk without webpack loader.
+      // (window.webpackJsonp=window.webpackJsonp||[]).push([[<chunks>], <modules>, ...]);
+      // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+      if (
+        isAsyncChunkPushExpression(node) &&
+        args[0].type === "ArrayExpression" &&
+        args[0].elements[1]
+      ) {
+        state.locations = getModulesLocations(args[0].elements[1]);
+        return;
+      }
+
+      // Webpack v4 WebWorkerChunkTemplatePlugin
+      // globalObject.chunkCallbackName([<chunks>],<modules>, ...);
+      // Both globalObject and chunkCallbackName can be changed through the config, so we can't check them.
+      if (isAsyncWebWorkerChunkExpression(node)) {
+        state.locations = getModulesLocations(args[1]);
+        return;
+      }
+
+      // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack
+      // features (e.g. `umd` library output) can wrap modules list into additional IIFE.
+      for (const arg of args) {
+        callback(arg, state);
+      }
+    },
+  });
+
+  const modulesLocations =
+    walkState.locations ||
+    selectWebpack5IIFEModulesLocations(
+      walkState.webpack5IIFECandidates,
+      expectedModuleIds,
+    );
+  /** @type {Modules} */
+  const modules = {};
+
+  if (modulesLocations) {
+    for (const [id, loc] of Object.entries(modulesLocations)) {
+      modules[id] = content.slice(loc.start, loc.end);
+    }
+  }
+
+  return {
+    modules,
+    src: content,
+    runtimeSrc: getBundleRuntime(content, modulesLocations),
+  };
+};

package/webpack.js

@@ -0,0 +1,373 @@
+const fs = require("node:fs");
+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
+ *   to adapt stats object https://webpack.js.org/api/stats/
+ *   to metro-stats.json format used by `react-native-bundle-discovery`
+ */
+class BundleDiscoveryPlugin {
+  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) {
+    const assetFile = path.join(options.output.path, statAsset.name);
+    try {
+      return parseBundle(assetFile, {
+        sourceType: statAsset.info.javascriptModule ? "module" : "script",
+      });
+    } catch (e) {
+      return null;
+    }
+  }
+
+  apply(compiler) {
+    if (!this.enabled) {
+      return;
+    }
+
+    compiler.hooks.done.tap("GenerateStatsJsonPlugin", (stats) => {
+      // Extract the relevant information from the stats object
+      const json = stats.toJson({
+        version: true,
+        builtAt: true,
+        modules: true,
+        reasons: true,
+        assets: true,
+        ids: true,
+        ...this.options,
+        all: false,
+        source: true,
+      });
+
+      // Format the stats into the desired structure
+      const statsJson = this.formatStat(
+        json,
+        // Parse JS bundle to extract modules sizes
+        // WANR: The stats asset list can contain multiple emitted files and is not guaranteed to put the JavaScript bundle first (and can be empty after a failed compilation)
+        this.extractSizesFromJsBundle(json.assets[0], compiler.options),
+        compiler.options,
+      );
+      // Write the formatted stats to the specified output file
+      const outputPath = path.resolve(compiler.options.context, this.filename);
+
+      // 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 {
+      const code = fs.readFileSync(filePath, "utf-8");
+      const lineCount = code.split("\n").length;
+      const sizeInBytes = Buffer.byteLength(code, "utf-8");
+      return {
+        code: this.options?.source === false ? "" : code,
+        lineCount,
+        sizeInBytes,
+      };
+    } catch {
+      return fallback;
+    }
+  }
+
+  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 "";
+    }
+  }
+
+  getPackages(statsJson) {
+    const packagesMap = new Map();
+
+    for (const mdl of statsJson.modules) {
+      const filePath = mdl.nameForCondition;
+      if (!filePath) {
+        continue;
+      }
+
+      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 Array.from(packagesMap.values());
+  }
+  getEntryFile(statsJson, rootFolder) {
+    const fallbackValue = path.join(rootFolder, "index.js");
+    return (
+      statsJson.modules.find(
+        (mdl) =>
+          !mdl.nameForCondition?.includes("node_modules/") &&
+          mdl.reasons?.length === 1 &&
+          mdl.reasons?.[0].type === "entry",
+      )?.nameForCondition || fallbackValue
+    );
+  }
+  getModuleOutput(mdl, bundleModules) {
+    const jsCodeStrFromJSBundle = bundleModules?.modules?.[mdl.id];
+    if (jsCodeStrFromJSBundle) {
+      const formatted =
+        jsCodeStrFromJSBundle.startsWith("function(") &&
+        jsCodeStrFromJSBundle.endsWith("}")
+          ? jsCodeStrFromJSBundle.replace("function(", "function module(")
+          : jsCodeStrFromJSBundle;
+
+      return {
+        code: formatted,
+        lineCount: formatted.split("\n").length ?? 0,
+        sizeInBytes: Buffer.byteLength(jsCodeStrFromJSBundle, "utf-8"),
+      };
+    }
+    return {
+      code: mdl.source ?? "",
+      lineCount: mdl.source?.split("\n").length ?? 0,
+      sizeInBytes: mdl.size ?? 0,
+    };
+  }
+
+  formatStat(statsJson, bundleModules, compilerOptions) {
+    const modulesDeps = this.buildImportsMapFromReasons(
+      statsJson,
+      compilerOptions,
+    );
+
+    return {
+      kind: "webpack",
+      date: statsJson.builtAt || Date.now(),
+      entryPoint: this.getEntryFile(statsJson, compilerOptions.context),
+      rootFolder:
+        this.findCommonRoot(
+          statsJson.modules.map((m) => m.nameForCondition).filter(Boolean),
+        ) || compilerOptions.context,
+      // envs: {},
+      transformOptions: {
+        // customTransformOptions: {},
+        dev: compilerOptions.mode !== "production",
+        minify: compilerOptions.optimization?.minimize ?? false,
+        platform: compilerOptions.name ?? "ios",
+        // type: "module",
+        // unstable_transformProfile: "default",
+      },
+      modules: statsJson.modules
+        .map((mdl) => {
+          if (mdl.type === "runtime modules") {
+            if (!bundleModules) {
+              return null;
+            }
+            const sourceAndOutput = {
+              code: bundleModules.runtimeSrc ?? "",
+              lineCount: bundleModules.runtimeSrc?.split("\n").length ?? 0,
+              sizeInBytes: Buffer.byteLength(
+                bundleModules.runtimeSrc ?? "",
+                "utf-8",
+              ),
+            };
+
+            return {
+              path: "__runtime__",
+              source: sourceAndOutput,
+              output: sourceAndOutput,
+              dependencies: [],
+            };
+          }
+
+          return {
+            path: mdl.nameForCondition,
+            source: this.readSource(mdl.nameForCondition),
+            output: this.getModuleOutput(mdl, bundleModules),
+            dependencies: modulesDeps.get(mdl.nameForCondition) ?? [],
+          };
+        })
+        .filter((e) => e !== null && e.path),
+      packages: this.getPackages(statsJson),
+    };
+  }
+
+  buildImportsMapFromReasons(statsJson, compilerOptions) {
+    const modules = Array.isArray(statsJson?.modules) ? statsJson.modules : [];
+    const importsMap = new Map();
+
+    const getAbs = (p) => {
+      if (!p || typeof p !== "string") return null;
+      if (path.isAbsolute(p)) return p;
+      return compilerOptions?.context
+        ? path.resolve(compilerOptions?.context, p)
+        : p;
+    };
+
+    const getModulePath = (m) =>
+      m?.path || m?.nameForCondition || m?.identifier || null;
+
+    for (const depModule of modules) {
+      const depAbsolutePath = getAbs(getModulePath(depModule));
+      if (!depAbsolutePath) continue;
+
+      const reasons = Array.isArray(depModule.reasons) ? depModule.reasons : [];
+      for (const reason of reasons) {
+        if (reason?.type === "entry") continue;
+
+        // importer (who imports current dep module)
+        const importerPath = getAbs(
+          reason?.modulePath ||
+            reason?.moduleNameForCondition ||
+            reason?.resolvedModule ||
+            reason?.moduleIdentifier,
+        );
+        if (!importerPath) continue;
+
+        if (!importsMap.has(importerPath)) {
+          importsMap.set(importerPath, []);
+        }
+
+        const deps = importsMap.get(importerPath);
+
+        // uniq by absolutePath
+        if (!deps.some((d) => d.absolutePath === depAbsolutePath)) {
+          deps.push({
+            absolutePath: depAbsolutePath,
+            name: reason?.userRequest || "",
+          });
+        }
+      }
+    }
+
+    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 };