react-native-bundle-discovery 2.1.0 → 2.2.0-rc.2

package/README.md

@@ -3,13 +3,11 @@
 [![react-native-bundle-discovery on npm](https://badgen.net/npm/v/react-native-bundle-discovery)](https://www.npmjs.com/package/react-native-bundle-discovery)
 [![react-native-bundle-discovery downloads](https://badgen.net/npm/dm/react-native-bundle-discovery)](https://www.npmtrends.com/react-native-bundle-discovery)
 
-
 A simple package that helps developers visualize and analyze the bundle size of React Native apps.
 With this tool, you can easily explore your app's codebase, identify large or heavy packages, and inspect the structure of modules and code within your project.
 
 <img width="800" alt="" src="./assets/img.png" />
 
-
 ### Packages:
 
 - `react-native-bundle-discovery` - simple JS library to generate a JSON report of the bundle.
@@ -17,13 +15,20 @@ 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:
 
-1. As in independent tool (UI + CLI) 
+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
@@ -62,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 \
@@ -112,30 +117,34 @@ npx react-native-bundle-discovery-ui build metro-stats.json
 | outputJsonPath: string | `<root>/metro-stats.json` | The path where the JSON report will be saved. Defaults to `metro-stats.json` in project root.                                            |
 | includeCode: boolean   | `true`                    | Whether to include the source and output code in the JSON report.                                                                        |
 
-### `createProcessModuleFilter(options: ProcessModuleFilterOptions)`
+**⚠️ Be cautious sharing reports with `includeCode` enabled**
+
+Enabling this option significantly increases report size and **embeds the source code** of your assets.
 
+If your code is proprietary 🔒, share these reports responsibly 🤝!
+
+---
 
-| Prop                   | Default value             | Description                   |
-| ---------------------- | ------------------------- | ----------------------------- |
-| removePromisePolyfill: boolean | `false` | Remove the Promise polyfill as Hermes provide own impl. (issue: [#57702](https://github.com/react/react-native/issues/57702)) |
-| removeOldRenderer: boolean     | `false` | Whether to remove the old renderer. Set to `true` when New Arch is enabled    |
-| removeNewRenderer: boolean     | `false` | Whether to remove the new renderer. Set to `true` when New Arch is disabled    |
-| removeUTFSequence: boolean     | `false` | Remove useless undocumented RN module.     |
+### `createResolveRequest(options: ResolveRequestOptions)`
 
+| Prop                           | Default value | Description                                                                                                                   |
+| ------------------------------ | ------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| removePromisePolyfill: boolean | `false`       | Remove the Promise polyfill as Hermes provide own impl. (issue: [#57702](https://github.com/react/react-native/issues/57702)) |
+| removeUTFSequence: boolean     | `false`       | Remove useless undocumented RN module.                                                                                        |
 
-Simple helper that devs can use to filter out unnecessary modules from the bundle report.
+Helper that creates a custom resolve request function to filter out unnecessary modules from the bundle.
 You can get recommendations during the analysis of the bundle report using the CLI tool.
 
 ```js
 // metro.config.js
-const {createProcessModuleFilter} = require('react-native-bundle-discovery');
+const { createResolveRequest } = require("react-native-bundle-discovery");
+const resolveRequest = createResolveRequest({
+  removePromisePolyfill: true,
+  removeUTFSequence: true,
+});
 const config = {
-  serializer: {
-    processModuleFilter: createProcessModuleFilter({
-      removePromisePolyfill: true,
-      removeOldRenderer: true,
-      removeUTFSequence: true,
-    }),
+  resolver: {
+    resolveRequest,
   },
 };
 ```

package/index.js

@@ -2,7 +2,7 @@ const { parse, resolve } = require("path");
 const { writeFileSync, existsSync } = require("fs");
 const { Buffer } = require("buffer");
 const chalk = require("chalk");
-
+const BundleDiscoveryPlugin = require("./webpack").BundleDiscoveryPlugin;
 const NAME = require("./package.json").name;
 
 function getDefault(module) {
@@ -215,8 +215,6 @@ function createSerializer({
  */
 const empty = { type: "empty" };
 const createResolveRequest = ({
-  removePromisePolyfill = false, // Remove useless polyfill (Hermes already has Promise)
-  removeOldRenderer = false, // Should be true when new ARCH is enabled
   removeNewRenderer = false, // Should be true when new ARCH is disabled
   removeUTFSequence = false, // Remove useless code
 } = {}) => {
@@ -231,20 +229,6 @@ const createResolveRequest = ({
     ) {
       return empty;
     }
-    if (
-      removePromisePolyfill &&
-      result?.filePath?.endsWith("/react-native/Libraries/Promise.js")
-    ) {
-      return empty;
-    }
-    if (
-      removeOldRenderer &&
-      result?.filePath?.endsWith(
-        "/react-native/Libraries/Renderer/shims/ReactNative.js",
-      )
-    ) {
-      return empty;
-    }
     if (
       removeNewRenderer &&
       result?.filePath?.endsWith(
@@ -264,8 +248,6 @@ const createResolveRequest = ({
 const createProcessModuleFilter =
   ({
     removePromisePolyfill = false, // Remove useless polyfill (Hermes already has Promise)
-    removeOldRenderer = false, // Should be true when new ARCH is enabled
-    removeNewRenderer = false, // Should be true when new ARCH is disabled
     removeUTFSequence = false, // Remove useless code
   } = {}) =>
   (module) => {
@@ -275,22 +257,6 @@ const createProcessModuleFilter =
     ) {
       return false;
     }
-    if (
-      removeOldRenderer &&
-      module.path.endsWith(
-        "/react-native/Libraries/Renderer/shims/ReactNative.js",
-      )
-    ) {
-      return false;
-    }
-    if (
-      removeNewRenderer &&
-      module.path.endsWith(
-        "/react-native/Libraries/Renderer/shims/ReactFabric.js",
-      )
-    ) {
-      return false;
-    }
     if (
       removeUTFSequence &&
       module.path.endsWith("/react-native/Libraries/UTFSequence.js")
@@ -302,7 +268,8 @@ const createProcessModuleFilter =
   };
 
 module.exports = {
-  createResolveRequest,
   createSerializer,
+  createResolveRequest,
   createProcessModuleFilter,
+  BundleDiscoveryPlugin,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-bundle-discovery",
-  "version": "2.1.0",
+  "version": "2.2.0-rc.2",
   "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/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,221 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const chalk = require("chalk");
+
+const { parseBundle } = require("./parseUtils.js");
+const NAME = require("./package.json").name;
+
+/**
+ * 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 } = {}) {
+    this.options = options;
+    this.filename = filename || "metro-stats.json";
+    this.enabled = enabled || 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
+        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);
+      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;
+    }
+  }
+
+  getPackageName(modulePath) {
+    if (!modulePath) {
+      return null;
+    }
+    const parts = modulePath.split("node_modules");
+    if (parts.length < 2) {
+      return null;
+    }
+    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;
+    }
+    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 absolutePath = this.getAbsolutePath(name, mdl.nameForCondition);
+      if (!allPackages.has(absolutePath)) {
+        allPackages.set(absolutePath, {
+          name,
+          absolutePath,
+          version: require(path.join(absolutePath, "package.json")).version,
+        });
+      }
+      return allPackages;
+    }, new Map());
+    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) {
+    return {
+      date: statsJson.builtAt || Date.now(),
+      entryPoint: this.getEntryFile(statsJson, compilerOptions.context),
+      rootFolder: 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") {
+            const sourceAndOutput = {
+              code: bundleModules.runtimeSrc ?? "",
+              lineCount: bundleModules.runtimeSrc?.split("\n").length ?? 0,
+              sizeInBytes: Buffer.byteLength(
+                bundleModules.runtimeSrc ?? "",
+                "utf-8",
+              ),
+            };
+            return {
+              path: "__prelude__",
+              source: sourceAndOutput,
+              output: sourceAndOutput,
+              dependencies: [],
+            };
+          }
+
+          return {
+            path: mdl.nameForCondition,
+            source: this.readSource(mdl.nameForCondition),
+            output: this.getModuleOutput(mdl, bundleModules),
+            dependencies:
+              mdl.reasons
+                ?.filter((r) => r.type !== "entry")
+                .map((reason) => {
+                  return {
+                    absolutePath: path.isAbsolute(reason.resolvedModule)
+                      ? reason.resolvedModule
+                      : path.resolve(
+                          compilerOptions.context,
+                          reason.resolvedModule,
+                        ),
+                    name: reason.userRequest,
+                  };
+                }) ?? [],
+          };
+        })
+        .filter((e) => e !== null),
+      packages: this.getPackages(statsJson),
+    };
+  }
+}
+
+module.exports = { BundleDiscoveryPlugin };