metro 0.84.2 → 0.84.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.84.2",
+  "version": "0.84.4",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -27,31 +27,30 @@
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
     "accepts": "^2.0.0",
-    "chalk": "^4.0.0",
     "ci-info": "^2.0.0",
     "connect": "^3.6.5",
     "debug": "^4.4.0",
     "error-stack-parser": "^2.0.6",
     "flow-enums-runtime": "^0.0.6",
     "graceful-fs": "^4.2.4",
-    "hermes-parser": "0.33.3",
+    "hermes-parser": "0.35.0",
     "image-size": "^1.0.2",
     "invariant": "^2.2.4",
     "jest-worker": "^29.7.0",
     "jsc-safe-url": "^0.2.2",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.84.2",
-    "metro-cache": "0.84.2",
-    "metro-cache-key": "0.84.2",
-    "metro-config": "0.84.2",
-    "metro-core": "0.84.2",
-    "metro-file-map": "0.84.2",
-    "metro-resolver": "0.84.2",
-    "metro-runtime": "0.84.2",
-    "metro-source-map": "0.84.2",
-    "metro-symbolicate": "0.84.2",
-    "metro-transform-plugins": "0.84.2",
-    "metro-transform-worker": "0.84.2",
+    "metro-babel-transformer": "0.84.4",
+    "metro-cache": "0.84.4",
+    "metro-cache-key": "0.84.4",
+    "metro-config": "0.84.4",
+    "metro-core": "0.84.4",
+    "metro-file-map": "0.84.4",
+    "metro-resolver": "0.84.4",
+    "metro-runtime": "0.84.4",
+    "metro-source-map": "0.84.4",
+    "metro-symbolicate": "0.84.4",
+    "metro-transform-plugins": "0.84.4",
+    "metro-transform-worker": "0.84.4",
     "mime-types": "^3.0.1",
     "nullthrows": "^1.1.1",
     "serialize-error": "^2.1.0",
@@ -72,7 +71,7 @@
     "dedent": "^0.7.0",
     "jest-snapshot": "^29.7.0",
     "jest-snapshot-serializer-raw": "^1.2.0",
-    "metro-babel-register": "0.84.2",
+    "metro-babel-register": "0.84.4",
     "metro-memory-fs": "*",
     "mock-req": "^0.2.0",
     "mock-res": "^0.6.0",

package/src/Assets.js

@@ -221,26 +221,33 @@ async function getAsset(
       `'${relativePath}' cannot be loaded as its extension is not registered in assetExts`,
     );
   }
-  if (fileExistsInFileMap != null) {
-    if (!fileExistsInFileMap(absolutePath)) {
-      throw new Error(
-        `'${relativePath}' could not be found, because it is not within the projectRoot or watchFolders, or it is blocked via the resolver.blockList config`,
-      );
-    }
-  } else {
-    if (!pathBelongsToRoots(absolutePath, [projectRoot, ...watchFolders])) {
-      throw new Error(
-        `'${relativePath}' could not be found, because it cannot be found in the project root or any watch folder`,
-      );
-    }
+  if (
+    fileExistsInFileMap == null &&
+    !pathBelongsToRoots(absolutePath, [projectRoot, ...watchFolders])
+  ) {
+    throw new Error(
+      `'${relativePath}' could not be found, because it cannot be found in the project root or any watch folder`,
+    );
   }
   const record = await getAbsoluteAssetRecord(absolutePath, platform ?? null);
   for (let i = 0; i < record.scales.length; i++) {
     if (record.scales[i] >= assetData.resolution) {
+      if (
+        fileExistsInFileMap != null &&
+        !fileExistsInFileMap(record.files[i])
+      ) {
+        continue;
+      }
       return _fs.default.promises.readFile(record.files[i]);
     }
   }
-  return _fs.default.promises.readFile(record.files[record.files.length - 1]);
+  const lastFile = record.files[record.files.length - 1];
+  if (fileExistsInFileMap != null && !fileExistsInFileMap(lastFile)) {
+    throw new Error(
+      `'${relativePath}' could not be found, because it is not within the projectRoot or watchFolders, or it is blocked via the resolver.blockList config`,
+    );
+  }
+  return _fs.default.promises.readFile(lastFile);
 }
 function pathBelongsToRoots(pathToCheck, roots) {
   for (const rootFolder of roots) {

package/src/Assets.js.flow

@@ -299,29 +299,36 @@ export async function getAsset(
   }
 
   // NOTE: If fileExistsInFileMap is not provided, we fall back to pathBelongsToRoots for backward compatibility, as getAsset is part of the public API.
-  if (fileExistsInFileMap != null) {
-    if (!fileExistsInFileMap(absolutePath)) {
-      throw new Error(
-        `'${relativePath}' could not be found, because it is not within the projectRoot or watchFolders, or it is blocked via the resolver.blockList config`,
-      );
-    }
-  } else {
-    if (!pathBelongsToRoots(absolutePath, [projectRoot, ...watchFolders])) {
-      throw new Error(
-        `'${relativePath}' could not be found, because it cannot be found in the project root or any watch folder`,
-      );
-    }
+  if (
+    fileExistsInFileMap == null &&
+    !pathBelongsToRoots(absolutePath, [projectRoot, ...watchFolders])
+  ) {
+    throw new Error(
+      `'${relativePath}' could not be found, because it cannot be found in the project root or any watch folder`,
+    );
   }
 
   const record = await getAbsoluteAssetRecord(absolutePath, platform ?? null);
 
   for (let i = 0; i < record.scales.length; i++) {
     if (record.scales[i] >= assetData.resolution) {
+      if (
+        fileExistsInFileMap != null &&
+        !fileExistsInFileMap(record.files[i])
+      ) {
+        continue;
+      }
       return fs.promises.readFile(record.files[i]);
     }
   }
 
-  return fs.promises.readFile(record.files[record.files.length - 1]);
+  const lastFile = record.files[record.files.length - 1];
+  if (fileExistsInFileMap != null && !fileExistsInFileMap(lastFile)) {
+    throw new Error(
+      `'${relativePath}' could not be found, because it is not within the projectRoot or watchFolders, or it is blocked via the resolver.blockList config`,
+    );
+  }
+  return fs.promises.readFile(lastFile);
 }
 
 function pathBelongsToRoots(

package/src/Bundler/util.js.flow

@@ -17,7 +17,7 @@ import * as babylon from '@babel/parser';
 import template from '@babel/template';
 import * as babelTypes from '@babel/types';
 
-type SubTree<T: ModuleTransportLike> = (
+type SubTree<T extends ModuleTransportLike> = (
   moduleTransport: T,
   moduleTransportsByPath: Map<string, T>,
 ) => Iterable<number>;
@@ -66,7 +66,7 @@ function filterObject(
   return copied;
 }
 
-export function createRamBundleGroups<T: ModuleTransportLike>(
+export function createRamBundleGroups<T extends ModuleTransportLike>(
   ramGroups: ReadonlyArray<string>,
   groupableModules: ReadonlyArray<T>,
   subtree: SubTree<T>,
@@ -123,7 +123,7 @@ export function createRamBundleGroups<T: ModuleTransportLike>(
   return result;
 }
 
-function* filter<A: number, B: number>(
+function* filter<A extends number, B extends number>(
   iterator: ArrayMap<A, B>,
   predicate: ([A, Array<B>]) => boolean,
 ): Generator<[A, Array<B>], void, void> {

package/src/DeltaBundler/DeltaCalculator.d.ts

@@ -6,7 +6,7 @@
  *
  * @noformat
  * @oncall react_native
- * @generated SignedSource<<b825a92cd295988e6e972591f11221fd>>
+ * @generated SignedSource<<d06b53dd09157df95aeb941035d4ebf0>>
  *
  * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
  * Original file: packages/metro/src/DeltaBundler/DeltaCalculator.js
@@ -16,7 +16,6 @@
  */
 
 import type {DeltaResult, Options} from './types';
-import type {RootPerfLogger} from 'metro-config';
 import type {ChangeEvent} from 'metro-file-map';
 
 import {Graph} from './Graph';
@@ -60,15 +59,6 @@ declare class DeltaCalculator<T> extends EventEmitter {
    */
   getGraph(): Graph<T>;
   _handleMultipleFileChanges: (changeEvent: ChangeEvent) => void;
-  /**
-   * Handles a single file change. To avoid doing any work before it's needed,
-   * the listener only stores the modified file, which will then be used later
-   * when the delta needs to be calculated.
-   */
-  _handleFileChange: (
-    $$PARAM_0$$: ChangeEvent['eventsQueue'][number],
-    logger: null | undefined | RootPerfLogger,
-  ) => unknown;
   _getChangedDependencies(
     modifiedFiles: Set<string>,
     deletedFiles: Set<string>,

package/src/DeltaBundler/DeltaCalculator.js

@@ -5,12 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _Graph = require("./Graph");
+var _crypto = _interopRequireDefault(require("crypto"));
 var _events = _interopRequireDefault(require("events"));
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:DeltaCalculator");
+const changeEventIds = new WeakMap();
 class DeltaCalculator extends _events.default {
   _deletedFiles = new Set();
   _modifiedFiles = new Set();
@@ -94,60 +96,67 @@ class DeltaCalculator extends _events.default {
   getGraph() {
     return this._graph;
   }
-  _handleMultipleFileChanges = (changeEvent) => {
-    changeEvent.eventsQueue.forEach((eventInfo) => {
-      this._handleFileChange(eventInfo, changeEvent.logger);
-    });
-  };
-  _handleFileChange = ({ type, filePath, metadata }, logger) => {
-    debug("Handling %s: %s (type: %s)", type, filePath, metadata.type);
+  #shouldReset(canonicalPath, metadata) {
+    if (metadata.isSymlink) {
+      return true;
+    }
     if (
-      metadata.type === "l" ||
-      (this._options.unstable_enablePackageExports &&
-        filePath.endsWith(_path.default.sep + "package.json"))
+      this._options.unstable_enablePackageExports &&
+      (canonicalPath === "package.json" ||
+        canonicalPath.endsWith(_path.default.sep + "package.json"))
     ) {
-      this._requiresReset = true;
-      this.emit("change", {
-        logger,
-      });
+      return true;
+    }
+    return false;
+  }
+  _handleMultipleFileChanges = (changeEvent) => {
+    const { changes, logger, rootDir } = changeEvent;
+    for (const [canonicalPath, metadata] of changes.addedFiles) {
+      debug("Handling add: %s", canonicalPath);
+      if (this.#shouldReset(canonicalPath, metadata)) {
+        this._requiresReset = true;
+      }
+      const absolutePath = _path.default.join(rootDir, canonicalPath);
+      if (this._deletedFiles.has(absolutePath)) {
+        this._deletedFiles.delete(absolutePath);
+        this._modifiedFiles.add(absolutePath);
+      } else {
+        this._addedFiles.add(absolutePath);
+        this._modifiedFiles.delete(absolutePath);
+      }
     }
-    let state;
-    if (this._deletedFiles.has(filePath)) {
-      state = "deleted";
-    } else if (this._modifiedFiles.has(filePath)) {
-      state = "modified";
-    } else if (this._addedFiles.has(filePath)) {
-      state = "added";
+    for (const [canonicalPath, metadata] of changes.modifiedFiles) {
+      debug("Handling change: %s", canonicalPath);
+      if (this.#shouldReset(canonicalPath, metadata)) {
+        this._requiresReset = true;
+      }
+      const absolutePath = _path.default.join(rootDir, canonicalPath);
+      if (!this._addedFiles.has(absolutePath)) {
+        this._modifiedFiles.add(absolutePath);
+      }
+      this._deletedFiles.delete(absolutePath);
     }
-    let nextState;
-    if (type === "delete") {
-      nextState = "deleted";
-    } else if (type === "add") {
-      nextState = state === "deleted" ? "modified" : "added";
-    } else {
-      nextState = state === "added" ? "added" : "modified";
+    for (const [canonicalPath, metadata] of changes.removedFiles) {
+      debug("Handling delete: %s", canonicalPath);
+      if (this.#shouldReset(canonicalPath, metadata)) {
+        this._requiresReset = true;
+      }
+      const absolutePath = _path.default.resolve(rootDir, canonicalPath);
+      if (this._addedFiles.has(absolutePath)) {
+        this._addedFiles.delete(absolutePath);
+      } else {
+        this._deletedFiles.add(absolutePath);
+        this._modifiedFiles.delete(absolutePath);
+      }
     }
-    switch (nextState) {
-      case "deleted":
-        this._deletedFiles.add(filePath);
-        this._modifiedFiles.delete(filePath);
-        this._addedFiles.delete(filePath);
-        break;
-      case "added":
-        this._addedFiles.add(filePath);
-        this._deletedFiles.delete(filePath);
-        this._modifiedFiles.delete(filePath);
-        break;
-      case "modified":
-        this._modifiedFiles.add(filePath);
-        this._deletedFiles.delete(filePath);
-        this._addedFiles.delete(filePath);
-        break;
-      default:
-        nextState;
+    let changeId = changeEventIds.get(changeEvent);
+    if (changeId == null) {
+      changeId = _crypto.default.randomUUID();
+      changeEventIds.set(changeEvent, changeId);
     }
     this.emit("change", {
       logger,
+      changeId,
     });
   };
   async _getChangedDependencies(modifiedFiles, deletedFiles, addedFiles) {

package/src/DeltaBundler/DeltaCalculator.js.flow

@@ -10,16 +10,24 @@
  */
 
 import type {DeltaResult, Options} from './types';
-import type {RootPerfLogger} from 'metro-config';
 import type {ChangeEvent} from 'metro-file-map';
 
 import {Graph} from './Graph';
+import crypto from 'crypto';
 import EventEmitter from 'events';
 import path from 'path';
 
 // eslint-disable-next-line import/no-commonjs
 const debug = require('debug')('Metro:DeltaCalculator');
 
+/**
+ * Assigns a unique, stable `changeId` to each `ChangeEvent` from the file
+ * watcher. Since all `DeltaCalculator` instances share the same
+ * `ChangeEvent` object reference per file system change, the `WeakMap`
+ * ensures each gets the same `changeId`.
+ */
+const changeEventIds: WeakMap<ChangeEvent, string> = new WeakMap();
+
 /**
  * This class is in charge of calculating the delta of changed modules that
  * happen between calls. To do so, it subscribes to file changes, so it can
@@ -172,76 +180,79 @@ export default class DeltaCalculator<T> extends EventEmitter {
     return this._graph;
   }
 
-  _handleMultipleFileChanges = (changeEvent: ChangeEvent) => {
-    changeEvent.eventsQueue.forEach(eventInfo => {
-      this._handleFileChange(eventInfo, changeEvent.logger);
-    });
-  };
+  #shouldReset(
+    canonicalPath: string,
+    metadata: {+isSymlink: boolean, ...},
+  ): boolean {
+    if (metadata.isSymlink) {
+      return true;
+    }
 
-  /**
-   * Handles a single file change. To avoid doing any work before it's needed,
-   * the listener only stores the modified file, which will then be used later
-   * when the delta needs to be calculated.
-   */
-  _handleFileChange = (
-    {type, filePath, metadata}: ChangeEvent['eventsQueue'][number],
-    logger: ?RootPerfLogger,
-  ): unknown => {
-    debug('Handling %s: %s (type: %s)', type, filePath, metadata.type);
     if (
-      metadata.type === 'l' ||
-      (this._options.unstable_enablePackageExports &&
-        filePath.endsWith(path.sep + 'package.json'))
+      this._options.unstable_enablePackageExports &&
+      (canonicalPath === 'package.json' ||
+        canonicalPath.endsWith(path.sep + 'package.json'))
     ) {
-      this._requiresReset = true;
-      this.emit('change', {logger});
+      return true;
     }
-    let state: void | 'deleted' | 'modified' | 'added';
-    if (this._deletedFiles.has(filePath)) {
-      state = 'deleted';
-    } else if (this._modifiedFiles.has(filePath)) {
-      state = 'modified';
-    } else if (this._addedFiles.has(filePath)) {
-      state = 'added';
+
+    return false;
+  }
+
+  _handleMultipleFileChanges = (changeEvent: ChangeEvent) => {
+    const {changes, logger, rootDir} = changeEvent;
+
+    // Process added files: deleted+added = modified, otherwise added
+    for (const [canonicalPath, metadata] of changes.addedFiles) {
+      debug('Handling add: %s', canonicalPath);
+      if (this.#shouldReset(canonicalPath, metadata)) {
+        this._requiresReset = true;
+      }
+      const absolutePath = path.join(rootDir, canonicalPath);
+      if (this._deletedFiles.has(absolutePath)) {
+        this._deletedFiles.delete(absolutePath);
+        this._modifiedFiles.add(absolutePath);
+      } else {
+        this._addedFiles.add(absolutePath);
+        this._modifiedFiles.delete(absolutePath);
+      }
     }
 
-    let nextState: 'deleted' | 'modified' | 'added';
-    if (type === 'delete') {
-      nextState = 'deleted';
-    } else if (type === 'add') {
-      // A deleted+added file is modified
-      nextState = state === 'deleted' ? 'modified' : 'added';
-    } else {
-      // type === 'change'
-      // An added+modified file is added
-      nextState = state === 'added' ? 'added' : 'modified';
+    // Process modified files: added+modified stays added, otherwise modified
+    for (const [canonicalPath, metadata] of changes.modifiedFiles) {
+      debug('Handling change: %s', canonicalPath);
+      if (this.#shouldReset(canonicalPath, metadata)) {
+        this._requiresReset = true;
+      }
+      const absolutePath = path.join(rootDir, canonicalPath);
+      if (!this._addedFiles.has(absolutePath)) {
+        this._modifiedFiles.add(absolutePath);
+      }
+      this._deletedFiles.delete(absolutePath);
     }
 
-    switch (nextState) {
-      case 'deleted':
-        this._deletedFiles.add(filePath);
-        this._modifiedFiles.delete(filePath);
-        this._addedFiles.delete(filePath);
-        break;
-      case 'added':
-        this._addedFiles.add(filePath);
-        this._deletedFiles.delete(filePath);
-        this._modifiedFiles.delete(filePath);
-        break;
-      case 'modified':
-        this._modifiedFiles.add(filePath);
-        this._deletedFiles.delete(filePath);
-        this._addedFiles.delete(filePath);
-        break;
-      default:
-        nextState as empty;
+    // Process removed files: added+deleted = no change, otherwise deleted
+    for (const [canonicalPath, metadata] of changes.removedFiles) {
+      debug('Handling delete: %s', canonicalPath);
+      if (this.#shouldReset(canonicalPath, metadata)) {
+        this._requiresReset = true;
+      }
+      const absolutePath = path.resolve(rootDir, canonicalPath);
+      if (this._addedFiles.has(absolutePath)) {
+        this._addedFiles.delete(absolutePath);
+      } else {
+        this._deletedFiles.add(absolutePath);
+        this._modifiedFiles.delete(absolutePath);
+      }
     }
 
-    // Notify users that there is a change in some of the bundle files. This
-    // way the client can choose to refetch the bundle.
-    this.emit('change', {
-      logger,
-    });
+    let changeId = changeEventIds.get(changeEvent);
+    if (changeId == null) {
+      changeId = crypto.randomUUID();
+      changeEventIds.set(changeEvent, changeId);
+    }
+
+    this.emit('change', {logger, changeId});
   };
 
   async _getChangedDependencies(

package/src/DeltaBundler/getTransformCacheKey.js

@@ -14,7 +14,9 @@ function getTransformCacheKey(opts) {
   const { transformerPath, transformerConfig } = opts.transformerConfig;
   const Transformer = require.call(null, transformerPath);
   const transformerKey = Transformer.getCacheKey
-    ? Transformer.getCacheKey(transformerConfig)
+    ? Transformer.getCacheKey(transformerConfig, {
+        projectRoot: opts.projectRoot,
+      })
     : "";
   return _crypto.default
     .createHash("sha1")

package/src/DeltaBundler/getTransformCacheKey.js.flow

@@ -19,7 +19,10 @@ import {getCacheKey} from 'metro-cache-key';
 const VERSION = require('../../package.json').version;
 
 type CacheKeyProvider = {
-  getCacheKey?: JsTransformerConfig => string,
+  getCacheKey?: (
+    config: JsTransformerConfig,
+    opts?: Readonly<{projectRoot: string}>,
+  ) => string,
 };
 
 export default function getTransformCacheKey(opts: {
@@ -32,7 +35,9 @@ export default function getTransformCacheKey(opts: {
   // eslint-disable-next-line no-useless-call
   const Transformer: CacheKeyProvider = require.call(null, transformerPath);
   const transformerKey = Transformer.getCacheKey
-    ? Transformer.getCacheKey(transformerConfig)
+    ? Transformer.getCacheKey(transformerConfig, {
+        projectRoot: opts.projectRoot,
+      })
     : '';
 
   return crypto

package/src/HmrServer.d.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @noformat
- * @generated SignedSource<<759aad52b112d43c0af68fdad28e4453>>
+ * @generated SignedSource<<ab4c245134631e14db114a9d49da79d1>>
  *
  * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
  * Original file: packages/metro/src/HmrServer.js
@@ -75,12 +75,24 @@ declare class HmrServer<TClient extends Client> {
   _handleFileChange(
     group: ClientGroup,
     options: {isInitialUpdate: boolean},
-    changeEvent: null | undefined | {logger: null | undefined | RootPerfLogger},
+    changeEvent:
+      | null
+      | undefined
+      | {
+          readonly logger: null | undefined | RootPerfLogger;
+          readonly changeId?: string;
+        },
   ): Promise<void>;
   _prepareMessage(
     group: ClientGroup,
     options: {isInitialUpdate: boolean},
-    changeEvent: null | undefined | {logger: null | undefined | RootPerfLogger},
+    changeEvent:
+      | null
+      | undefined
+      | {
+          readonly logger: null | undefined | RootPerfLogger;
+          readonly changeId?: string;
+        },
   ): Promise<HmrUpdateMessage | HmrErrorMessage>;
 }
 export default HmrServer;

package/src/HmrServer.js

@@ -214,6 +214,10 @@ class HmrServer {
         case "log-opt-in":
           client.optedIntoHMR = true;
           break;
+        case "heartbeat":
+          debug("Heartbeat received");
+          sendFn(String(message));
+          break;
         default:
           break;
       }
@@ -265,6 +269,9 @@ class HmrServer {
     send(sendFns, message);
     send(sendFns, {
       type: "update-done",
+      body: {
+        changeId: changeEvent?.changeId,
+      },
     });
     log({
       ...createActionEndEntry(processingHmrChange),