metro 0.84.1 → 0.84.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.84.1",
+  "version": "0.84.3",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -34,24 +34,24 @@
     "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.1",
-    "metro-cache": "0.84.1",
-    "metro-cache-key": "0.84.1",
-    "metro-config": "0.84.1",
-    "metro-core": "0.84.1",
-    "metro-file-map": "0.84.1",
-    "metro-resolver": "0.84.1",
-    "metro-runtime": "0.84.1",
-    "metro-source-map": "0.84.1",
-    "metro-symbolicate": "0.84.1",
-    "metro-transform-plugins": "0.84.1",
-    "metro-transform-worker": "0.84.1",
+    "metro-babel-transformer": "0.84.3",
+    "metro-cache": "0.84.3",
+    "metro-cache-key": "0.84.3",
+    "metro-config": "0.84.3",
+    "metro-core": "0.84.3",
+    "metro-file-map": "0.84.3",
+    "metro-resolver": "0.84.3",
+    "metro-runtime": "0.84.3",
+    "metro-source-map": "0.84.3",
+    "metro-symbolicate": "0.84.3",
+    "metro-transform-plugins": "0.84.3",
+    "metro-transform-worker": "0.84.3",
     "mime-types": "^3.0.1",
     "nullthrows": "^1.1.1",
     "serialize-error": "^2.1.0",
@@ -72,7 +72,7 @@
     "dedent": "^0.7.0",
     "jest-snapshot": "^29.7.0",
     "jest-snapshot-serializer-raw": "^1.2.0",
-    "metro-babel-register": "0.84.1",
+    "metro-babel-register": "0.84.3",
     "metro-memory-fs": "*",
     "mock-req": "^0.2.0",
     "mock-res": "^0.6.0",

package/src/Assets.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<a58b1d0332fe424196b6d106eacdc2fe>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Assets.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+export type AssetInfo = {
+  readonly files: Array<string>;
+  readonly hash: string;
+  readonly name: string;
+  readonly scales: Array<number>;
+  readonly type: string;
+};
+export type AssetDataWithoutFiles = {
+  readonly __packager_asset: boolean;
+  readonly fileSystemLocation: string;
+  readonly hash: string;
+  readonly height: null | undefined | number;
+  readonly httpServerLocation: string;
+  readonly name: string;
+  readonly scales: Array<number>;
+  readonly type: string;
+  readonly width: null | undefined | number;
+};
+export type AssetDataFiltered = {
+  readonly __packager_asset: boolean;
+  readonly hash: string;
+  readonly height: null | undefined | number;
+  readonly httpServerLocation: string;
+  readonly name: string;
+  readonly scales: Array<number>;
+  readonly type: string;
+  readonly width: null | undefined | number;
+};
+export declare function isAssetTypeAnImage(type: string): boolean;
+export declare function getAssetSize(
+  type: string,
+  content: Buffer,
+  filePath: string,
+): null | undefined | {readonly width: number; readonly height: number};
+export type AssetData = AssetDataWithoutFiles & {
+  readonly files: Array<string>;
+};
+export type AssetDataPlugin = (
+  assetData: AssetData,
+) => AssetData | Promise<AssetData>;
+export declare function getAssetData(
+  assetPath: string,
+  localPath: string,
+  assetDataPlugins: ReadonlyArray<string>,
+  platform: null | undefined | string,
+  publicPath: string,
+): Promise<AssetData>;
+/**
+ * Returns all the associated files (for different resolutions) of an asset.
+ **/
+export declare function getAssetFiles(
+  assetPath: string,
+  platform?: null | undefined | string,
+): Promise<Array<string>>;
+/**
+ * Return a buffer with the actual image given a request for an image by path.
+ * The relativePath can contain a resolution postfix, in this case we need to
+ * find that image (or the closest one to it's resolution) in one of the
+ * project roots:
+ *
+ * 1. We first parse the directory of the asset
+ * 2. We then build a map of all assets and their scales in this directory
+ * 3. Then try to pick platform-specific asset records
+ * 4. Then pick the closest resolution (rounding up) to the requested one
+ */
+export declare function getAsset(
+  relativePath: string,
+  projectRoot: string,
+  watchFolders: ReadonlyArray<string>,
+  platform: null | undefined | string,
+  assetExts: ReadonlyArray<string>,
+  fileExistsInFileMap?: (absolutePath: string) => boolean,
+): Promise<Buffer>;

package/src/Bundler/util.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<adf0e819f93597b57ff231cca9c918ef>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Bundler/util.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {AssetDataWithoutFiles} from '../Assets';
+import type {ModuleTransportLike} from '../shared/types';
+import type {File} from '@babel/types';
+
+type SubTree<T extends ModuleTransportLike> = (
+  moduleTransport: T,
+  moduleTransportsByPath: Map<string, T>,
+) => Iterable<number>;
+export declare function generateAssetCodeFileAst(
+  assetRegistryPath: string,
+  assetDescriptor: AssetDataWithoutFiles,
+): File;
+export declare function createRamBundleGroups<T extends ModuleTransportLike>(
+  ramGroups: ReadonlyArray<string>,
+  groupableModules: ReadonlyArray<T>,
+  subtree: SubTree<T>,
+): Map<number, Set<number>>;

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/Bundler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<3d5664309abdece0f247fcd0c53c3aaf>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Bundler.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {TransformResultWithSource} from './DeltaBundler';
+import type {TransformOptions} from './DeltaBundler/Worker';
+import type EventEmitter from 'events';
+import type {ConfigT} from 'metro-config';
+
+import Transformer from './DeltaBundler/Transformer';
+import DependencyGraph from './node-haste/DependencyGraph';
+
+export type BundlerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  watch?: boolean;
+}>;
+declare class Bundler {
+  _depGraph: DependencyGraph;
+  _initializedPromise: Promise<void>;
+  _transformer: Transformer;
+  constructor(config: ConfigT, options?: BundlerOptions);
+  getWatcher(): EventEmitter;
+  end(): Promise<void>;
+  getDependencyGraph(): Promise<DependencyGraph>;
+  transformFile(
+    filePath: string,
+    transformOptions: TransformOptions,
+    fileBuffer?: Buffer,
+  ): Promise<TransformResultWithSource>;
+  ready(): Promise<void>;
+}
+export default Bundler;

package/src/DeltaBundler/DeltaCalculator.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<d06b53dd09157df95aeb941035d4ebf0>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/DeltaCalculator.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {DeltaResult, Options} from './types';
+import type {ChangeEvent} from 'metro-file-map';
+
+import {Graph} from './Graph';
+import EventEmitter from 'events';
+/**
+ * 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
+ * traverse the files that have been changed between calls and avoid having to
+ * traverse the whole dependency tree for trivial small changes.
+ */
+declare class DeltaCalculator<T> extends EventEmitter {
+  _changeEventSource: EventEmitter;
+  _options: Options<T>;
+  _currentBuildPromise: null | undefined | Promise<DeltaResult<T>>;
+  _deletedFiles: Set<string>;
+  _modifiedFiles: Set<string>;
+  _addedFiles: Set<string>;
+  _requiresReset: boolean;
+  _graph: Graph<T>;
+  constructor(
+    entryPoints: ReadonlySet<string>,
+    changeEventSource: EventEmitter,
+    options: Options<T>,
+  );
+  /**
+   * Stops listening for file changes and clears all the caches.
+   */
+  end(): void;
+  /**
+   * Main method to calculate the delta of modules. It returns a DeltaResult,
+   * which contain the modified/added modules and the removed modules.
+   */
+  getDelta($$PARAM_0$$: {
+    reset: boolean;
+    shallow: boolean;
+  }): Promise<DeltaResult<T>>;
+  /**
+   * Returns the graph with all the dependencies. Each module contains the
+   * needed information to do the traversing (dependencies, inverseDependencies)
+   * plus some metadata.
+   */
+  getGraph(): Graph<T>;
+  _handleMultipleFileChanges: (changeEvent: ChangeEvent) => void;
+  _getChangedDependencies(
+    modifiedFiles: Set<string>,
+    deletedFiles: Set<string>,
+    addedFiles: Set<string>,
+  ): Promise<DeltaResult<T>>;
+}
+export default DeltaCalculator;

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(