react-native-bundle-discovery 2.6.0 → 2.7.0-rc.0

package/package.json

@@ -1,17 +1,28 @@
 {
   "name": "react-native-bundle-discovery",
-  "version": "2.6.0",
-  "main": "index.js",
-  "repository": "git@github.com:retyui/react-native-bundle-discovery.git",
+  "version": "2.7.0-rc.0",
+  "description": "Metro serializer and Webpack/Rspack plugin that generates a JSON report of your React Native bundle",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/retyui/react-native-bundle-discovery.git",
+    "directory": "packages/serializer"
+  },
   "author": "David <4661784+retyui@users.noreply.github.com>",
   "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "prepublishOnly": "cp ../README.md README.md"
+    "build": "run -T tsdown",
+    "typecheck": "run -T tsc -p tsconfig.json",
+    "prepack": "cp ../../README.md README.md"
   },
   "dependencies": {
-    "chalk": "^4.1.2",
-    "acorn": "^8.0.4",
-    "acorn-walk": "^8.0.0"
+    "acorn": "^8.18.0",
+    "acorn-walk": "^8.3.5",
+    "chalk": "^4.1.2"
   },
   "peerDependencies": {
     "metro": "*"
@@ -21,7 +32,7 @@
       "optional": true
     }
   },
-  "files": [
-    "*.js"
-  ]
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/index.js

@@ -1,301 +0,0 @@
-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) {
-  return module.__esModule ? module.default : module;
-}
-
-function getDefaultSerializer() {
-  const metroPath = parse(require.resolve("metro/package.json")).dir;
-  const bundleToString = getDefault(
-    require(`${metroPath}/src/lib/bundleToString.js`),
-  );
-  const baseJSBundle = getDefault(
-    require(`${metroPath}/src/DeltaBundler/Serializers/baseJSBundle.js`),
-  );
-
-  return function defaultSerializer(entryPoint, preModules, graph, options) {
-    let bundle = baseJSBundle(entryPoint, preModules, graph, options);
-
-    // Sentry support
-    // https://docs.sentry.io/platforms/react-native/manual-setup/metro/#wrap-your-custom-serializer
-    if (typeof options?.sentryBundleCallback === "function") {
-      bundle = options.sentryBundleCallback(bundle);
-    }
-
-    return bundleToString(bundle).code;
-  };
-}
-
-function getStringSizeInBytes(str) {
-  return Buffer.byteLength(str, "utf8");
-}
-
-/**
- * `/Users/i/app/node_modules/metro/node_modules/@babel/runtime/helpers/createClass.js` -> `@babel/runtime`
- * `/Users/i/app/node_modules/react/jsx-runtime.js` -> `react`
- */
-function getPackageNameFromPath(path) {
-  const parts = path.split("node_modules/");
-  const lastPart = parts[parts.length - 1];
-  if (lastPart.startsWith("@")) {
-    return lastPart.split("/").slice(0, 2).join("/");
-  }
-  return lastPart.split("/")[0];
-}
-
-/**
- * `/Users/i/app/node_modules/metro/node_modules/@babel/runtime/helpers/createClass.js` -> `/Users/i/app/node_modules/metro/node_modules/@babel/runtime`
- * `/Users/i/app/node_modules/react/jsx-runtime.js` -> `/Users/i/app/node_modules/react`
- */
-function getPackageAbsolutePath(path, pkgName) {
-  const parts = path.split("node_modules/");
-  parts[parts.length - 1] = pkgName;
-  return parts.join("node_modules/");
-}
-
-function toPackages(modules) {
-  const packages = new Map();
-  modules.forEach((module) => {
-    if (!module.path.includes("node_modules/")) {
-      return;
-    }
-
-    const pkgName = getPackageNameFromPath(module.path);
-    const absolutePkgPath = getPackageAbsolutePath(module.path, pkgName);
-
-    if (!packages.has(absolutePkgPath)) {
-      packages.set(absolutePkgPath, {
-        name: pkgName,
-        absolutePath: absolutePkgPath,
-        version: require(resolve(absolutePkgPath, "package.json")).version,
-      });
-    }
-  });
-
-  return Array.from(packages.values()).sort((a, b) =>
-    a.name.localeCompare(b.name),
-  );
-}
-
-function toModuleStruct(m, includeCode) {
-  const sourceCode = m.getSource().toString("utf8");
-  const outputCode = m.output[0].data.code;
-  return {
-    path: m.path,
-    source: {
-      code: includeCode ? sourceCode : "",
-      lineCount: sourceCode.split("\n").length,
-      sizeInBytes: getStringSizeInBytes(sourceCode),
-    },
-    output: {
-      code: includeCode ? outputCode : "",
-      lineCount: m.output[0].data.lineCount,
-      sizeInBytes: getStringSizeInBytes(outputCode),
-    },
-    dependencies: Array.from(m?.dependencies?.values?.() ?? [])
-      .filter((e) => e.absolutePath)
-      .map((e) => ({
-        absolutePath: e.absolutePath,
-        name: e.data.name,
-      })),
-  };
-}
-
-async function createJsonReport({
-  graph,
-  entryPoint,
-  includeEnvs,
-  preModules,
-  includeCode,
-  outputJsonPath,
-  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,
-    transformOptions: graph.transformOptions,
-    envs: includeEnvs.reduce((acc, envName) => {
-      acc[envName] = process.env[envName];
-      return acc;
-    }, {}),
-    rootFolder,
-    packages,
-    modules,
-  };
-
-  writeFileSync(outputJsonPath, JSON.stringify(stats));
-
-  if (!silent) {
-    console.log(
-      `${chalk.yellow(`[${NAME}]`)}: Saved stats to ${chalk.green(outputJsonPath)}`,
-    );
-  }
-}
-
-/**
- * Creates a custom serializer function for Metro bundler, which generates a JSON report
- * and optionally modifies the serialization process.
- *
- * @param {Object} options - Configuration options for the serializer.
- * @param {Function} [options.serializer] - A custom serializer function. If not provided, a default serializer is used.
- * @param {string} options.projectRoot - The root directory of the project. Must exist.
- * @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.
- */
-function createSerializer({
-  serializer,
-  projectRoot,
-  outputJsonPath,
-  includeCode = true,
-  silent = false,
-  includeEnvs = [],
-  fetchPackagesMetadata = true,
-} = {}) {
-  const mySerializer = serializer || getDefaultSerializer();
-
-  if (!existsSync(projectRoot)) {
-    throw new Error(`[${NAME}]: Project root does not exist: ${projectRoot}`);
-  }
-
-  const myOutputJsonPath =
-    outputJsonPath ?? resolve(projectRoot, "metro-stats.json");
-
-  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,
-      includeEnvs,
-      preModules,
-      includeCode,
-      outputJsonPath: myOutputJsonPath,
-      rootFolder: projectRoot,
-      silent,
-      options,
-      fetchPackagesMetadata,
-    }).finally(() => clearInterval(keepAlive));
-
-    return code;
-  }
-
-  return customSerializer;
-}
-
-/**
- * Usage:
- *
- * ```js
- * // metro.config.js
- * const { createResolveRequest } = require("react-native-bundle-discovery");
- * const resolveRequest = createResolveRequest({
- *   removePromisePolyfill: true,
- * });
- * const config = {
- *   resolver: {
- *     resolveRequest,
- *   },
- * };
- * ```
- */
-const empty = { type: "empty" };
-const createResolveRequest = ({
-  removeNewRenderer = false, // Should be true when new ARCH is disabled
-  removeUTFSequence = false, // Remove useless code
-} = {}) => {
-  const resolveRequest = (context, ...rest) => {
-    const result = context.resolveRequest(context, ...rest);
-    if (context.dev) {
-      return result;
-    }
-    if (
-      removeUTFSequence &&
-      result?.filePath?.endsWith("/react-native/Libraries/UTFSequence.js")
-    ) {
-      return empty;
-    }
-    if (
-      removeNewRenderer &&
-      result?.filePath?.endsWith(
-        "/react-native/Libraries/Renderer/shims/ReactFabric.js",
-      )
-    ) {
-      return empty;
-    }
-    return result;
-  };
-  return resolveRequest;
-};
-
-/**
- * @deprecated Use `createResolveRequest` instead.
- */
-const createProcessModuleFilter =
-  ({
-    removePromisePolyfill = false, // Remove useless polyfill (Hermes already has Promise)
-    removeUTFSequence = false, // Remove useless code
-  } = {}) =>
-  (module) => {
-    if (
-      removePromisePolyfill &&
-      module.path.endsWith("/react-native/Libraries/Promise.js")
-    ) {
-      return false;
-    }
-    if (
-      removeUTFSequence &&
-      module.path.endsWith("/react-native/Libraries/UTFSequence.js")
-    ) {
-      return false;
-    }
-
-    return true;
-  };
-
-module.exports = {
-  createSerializer,
-  createResolveRequest,
-  createProcessModuleFilter,
-  BundleDiscoveryPlugin,
-};

package/packageMetadata.js

@@ -1,155 +0,0 @@
-const DEFAULT_REGISTRY = "https://registry.npmjs.org";
-const DEFAULT_TIMEOUT_MS = 5_000;
-const DEFAULT_CONCURRENCY = 5;
-
-// 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,
-};