react-native-bundle-discovery 2.2.0-rc.1 → 2.2.0-rc.3

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) {
@@ -270,13 +270,6 @@ const createProcessModuleFilter =
 module.exports = {
   createSerializer,
   createResolveRequest,
-  get createProcessModuleFilter() {
-    console.warn(
-      `[${NAME}]: ⚠️'createProcessModuleFilter' is deprecated. Use 'createResolveRequest' instead.`,
-    );
-    return createProcessModuleFilter;
-  },
-  get BundleDiscoveryPlugin() {
-    return require("./webpack").BundleDiscoveryPlugin;
-  },
+  createProcessModuleFilter,
+  BundleDiscoveryPlugin,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-bundle-discovery",
-  "version": "2.2.0-rc.1",
+  "version": "2.2.0-rc.3",
   "main": "index.js",
   "repository": "git@github.com:retyui/react-native-bundle-discovery.git",
   "author": "David <4661784+retyui@users.noreply.github.com>",
@@ -22,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 };