metro-file-map 0.83.3 → 0.84.0

package/src/index.js.flow

@@ -25,6 +25,7 @@ import type {
   EventsQueue,
   FileData,
   FileMapPlugin,
+  FileMapPluginWorker,
   FileMetadata,
   FileSystem,
   HasteMapData,
@@ -47,8 +48,6 @@ import normalizePathSeparatorsToPosix from './lib/normalizePathSeparatorsToPosix
 import normalizePathSeparatorsToSystem from './lib/normalizePathSeparatorsToSystem';
 import {RootPathUtils} from './lib/RootPathUtils';
 import TreeFS from './lib/TreeFS';
-import HastePlugin from './plugins/HastePlugin';
-import MockPlugin from './plugins/MockPlugin';
 import {Watcher} from './Watcher';
 import EventEmitter from 'events';
 import {promises as fsPromises} from 'fs';
@@ -72,26 +71,16 @@ export type {
   HasteMapItem,
 };
 
-export type InputOptions = $ReadOnly<{
-  computeDependencies?: ?boolean,
+export type InputOptions = Readonly<{
   computeSha1?: ?boolean,
-  enableHastePackages?: boolean,
   enableSymlinks?: ?boolean,
-  enableWorkerThreads?: ?boolean,
-  extensions: $ReadOnlyArray<string>,
+  extensions: ReadonlyArray<string>,
   forceNodeFilesystemAPI?: ?boolean,
   ignorePattern?: ?RegExp,
-  mocksPattern?: ?string,
-  platforms: $ReadOnlyArray<string>,
-  plugins?: $ReadOnlyArray<FileMapPlugin<>>,
+  plugins?: ReadonlyArray<AnyFileMapPlugin>,
   retainAllFiles: boolean,
   rootDir: string,
-  roots: $ReadOnlyArray<string>,
-  skipPackageJson?: ?boolean,
-
-  // Module paths that should export a 'getCacheKey' method
-  dependencyExtractor?: ?string,
-  hasteImplModulePath?: ?string,
+  roots: ReadonlyArray<string>,
 
   cacheManagerFactory?: ?CacheManagerFactory,
   console?: Console,
@@ -100,30 +89,38 @@ export type InputOptions = $ReadOnly<{
   maxWorkers: number,
   perfLoggerFactory?: ?PerfLoggerFactory,
   resetCache?: ?boolean,
-  throwOnModuleCollision?: ?boolean,
   useWatchman?: ?boolean,
   watch?: ?boolean,
-  watchmanDeferStates?: $ReadOnlyArray<string>,
+  watchmanDeferStates?: ReadonlyArray<string>,
 }>;
 
-type HealthCheckOptions = $ReadOnly<{
+type HealthCheckOptions = Readonly<{
   enabled: boolean,
   interval: number,
   timeout: number,
   filePrefix: string,
 }>;
 
-type InternalOptions = $ReadOnly<{
+type InternalOptions = Readonly<{
   ...BuildParameters,
   healthCheck: HealthCheckOptions,
   perfLoggerFactory: ?PerfLoggerFactory,
   resetCache: ?boolean,
   useWatchman: boolean,
   watch: boolean,
-  watchmanDeferStates: $ReadOnlyArray<string>,
+  watchmanDeferStates: ReadonlyArray<string>,
+}>;
+
+// $FlowFixMe[unclear-type] Plugin types cannot be known statically
+type AnyFileMapPlugin = FileMapPlugin<any, any>;
+type IndexedPlugin = Readonly<{
+  plugin: AnyFileMapPlugin,
+  dataIdx: ?number,
 }>;
 
 export {DiskCacheManager} from './cache/DiskCacheManager';
+export {default as DependencyPlugin} from './plugins/DependencyPlugin';
+export type {DependencyPluginOptions} from './plugins/DependencyPlugin';
 export {DuplicateHasteCandidatesError} from './plugins/haste/DuplicateHasteCandidatesError';
 export {HasteConflictsError} from './plugins/haste/HasteConflictsError';
 export {default as HastePlugin} from './plugins/HastePlugin';
@@ -143,12 +140,11 @@ export type {
 // This should be bumped whenever a code change to `metro-file-map` itself
 // would cause a change to the cache data structure and/or content (for a given
 // filesystem state and build parameters).
-const CACHE_BREAKER = '10';
+const CACHE_BREAKER = '11';
 
 const CHANGE_INTERVAL = 30;
 
 const NODE_MODULES = path.sep + 'node_modules' + path.sep;
-const PACKAGE_JSON = path.sep + 'package.json';
 const VCS_DIRECTORIES = /[/\\]\.(git|hg)[/\\]/.source;
 const WATCHMAN_REQUIRED_CAPABILITIES = [
   'field-content.sha1hex',
@@ -165,7 +161,7 @@ const WATCHMAN_REQUIRED_CAPABILITIES = [
  * hundreds of thousands of files. This implementation is scalable and provides
  * predictable performance.
  *
- * Because the haste map creation and synchronization is critical to startup
+ * Because the file map creation and synchronization is critical to startup
  * performance and most tasks are blocked by I/O this class makes heavy use of
  * synchronous operations. It uses worker processes for parallelizing file
  * access and metadata extraction.
@@ -214,7 +210,7 @@ const WATCHMAN_REQUIRED_CAPABILITIES = [
  * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space
  * and reduce parse and write time of a big JSON blob.
  *
- * The HasteMap is created as follows:
+ * The FileMap is created as follows:
  *  1. read data from the cache or create an empty structure.
  *
  *  2. crawl the file system.
@@ -223,36 +219,34 @@ const WATCHMAN_REQUIRED_CAPABILITIES = [
  *       * if watchman is available: get file system delta changes.
  *       * if watchman is unavailable: crawl the entire file system.
  *     * build metadata objects for every file. This builds the `files` part of
- *       the `HasteMap`.
+ *       the `FileMap`.
  *
- *  3. parse and extract metadata from changed files.
+ *  3. visit and extract metadata from changed files, including sha1,
+ *     depedendencies, and any plugins.
  *     * this is done in parallel over worker processes to improve performance.
- *     * the worst case is to parse all files.
+ *     * the worst case is to visit all files.
  *     * the best case is no file system access and retrieving all data from
  *       the cache.
  *     * the average case is a small number of changed files.
  *
- *  4. serialize the new `HasteMap` in a cache file.
+ *  4. serialize the new `FileMap` in a cache file.
  *
  */
 export default class FileMap extends EventEmitter {
-  _buildPromise: ?Promise<BuildResult>;
-  _canUseWatchmanPromise: Promise<boolean>;
-  _changeID: number;
-  _changeInterval: ?IntervalID;
-  _fileProcessor: FileProcessor;
-  _console: Console;
-  _options: InternalOptions;
-  _pathUtils: RootPathUtils;
-  _watcher: ?Watcher;
-  _cacheManager: CacheManager;
-  _crawlerAbortController: AbortController;
-  _healthCheckInterval: ?IntervalID;
-  _startupPerfLogger: ?PerfLogger;
-
-  #hastePlugin: HastePlugin;
-  #mockPlugin: ?MockPlugin = null;
-  #plugins: $ReadOnlyArray<FileMapPlugin<>>;
+  #buildPromise: ?Promise<BuildResult>;
+  +#cacheManager: CacheManager;
+  #canUseWatchmanPromise: Promise<boolean>;
+  #changeID: number;
+  #changeInterval: ?IntervalID;
+  +#console: Console;
+  +#crawlerAbortController: AbortController;
+  +#fileProcessor: FileProcessor;
+  #healthCheckInterval: ?IntervalID;
+  +#options: InternalOptions;
+  +#pathUtils: RootPathUtils;
+  +#plugins: ReadonlyArray<IndexedPlugin>;
+  +#startupPerfLogger: ?PerfLogger;
+  #watcher: ?Watcher;
 
   static create(options: InputOptions): FileMap {
     return new FileMap(options);
@@ -262,9 +256,9 @@ export default class FileMap extends EventEmitter {
     super();
 
     if (options.perfLoggerFactory) {
-      this._startupPerfLogger =
+      this.#startupPerfLogger =
         options.perfLoggerFactory?.('START_UP').subSpan('fileMap') ?? null;
-      this._startupPerfLogger?.point('constructor_start');
+      this.#startupPerfLogger?.point('constructor_start');
     }
 
     // Add VCS_DIRECTORIES to provided ignorePattern
@@ -285,56 +279,39 @@ export default class FileMap extends EventEmitter {
       ignorePattern = new RegExp(VCS_DIRECTORIES);
     }
 
-    this._console = options.console || global.console;
-    const throwOnModuleCollision = Boolean(options.throwOnModuleCollision);
-
-    const enableHastePackages = options.enableHastePackages ?? true;
-
-    this.#hastePlugin = new HastePlugin({
-      console: this._console,
-      enableHastePackages,
-      perfLogger: this._startupPerfLogger,
-      platforms: new Set(options.platforms),
-      rootDir: options.rootDir,
-      failValidationOnConflicts: throwOnModuleCollision,
-    });
+    this.#console = options.console || global.console;
 
-    const plugins: Array<FileMapPlugin<$FlowFixMe>> = [this.#hastePlugin];
+    let dataSlot: number = H.PLUGINDATA;
 
-    if (options.mocksPattern != null && options.mocksPattern !== '') {
-      this.#mockPlugin = new MockPlugin({
-        console: this._console,
-        mocksPattern: new RegExp(options.mocksPattern),
-        rootDir: options.rootDir,
-        throwOnModuleCollision,
+    const indexedPlugins: Array<IndexedPlugin> = [];
+    const pluginWorkers: Array<FileMapPluginWorker> = [];
+    const plugins = options.plugins ?? [];
+    for (const plugin of plugins) {
+      const maybeWorker = plugin.getWorker();
+      indexedPlugins.push({
+        plugin,
+        dataIdx: maybeWorker != null ? dataSlot++ : null,
       });
-      plugins.push(this.#mockPlugin);
+      if (maybeWorker != null) {
+        pluginWorkers.push(maybeWorker);
+      }
     }
-
-    this.#plugins = plugins;
+    this.#plugins = indexedPlugins;
 
     const buildParameters: BuildParameters = {
-      computeDependencies:
-        options.computeDependencies == null
-          ? true
-          : options.computeDependencies,
+      cacheBreaker: CACHE_BREAKER,
       computeSha1: options.computeSha1 || false,
-      dependencyExtractor: options.dependencyExtractor ?? null,
-      enableHastePackages,
       enableSymlinks: options.enableSymlinks || false,
       extensions: options.extensions,
       forceNodeFilesystemAPI: !!options.forceNodeFilesystemAPI,
-      hasteImplModulePath: options.hasteImplModulePath,
       ignorePattern,
-      plugins: options.plugins ?? [],
+      plugins,
       retainAllFiles: options.retainAllFiles,
       rootDir: options.rootDir,
       roots: Array.from(new Set(options.roots)),
-      skipPackageJson: !!options.skipPackageJson,
-      cacheBreaker: CACHE_BREAKER,
     };
 
-    this._options = {
+    this.#options = {
       ...buildParameters,
       healthCheck: options.healthCheck,
       perfLoggerFactory: options.perfLoggerFactory,
@@ -347,33 +324,31 @@ export default class FileMap extends EventEmitter {
     const cacheFactoryOptions: CacheManagerFactoryOptions = {
       buildParameters,
     };
-    this._cacheManager = options.cacheManagerFactory
+    this.#cacheManager = options.cacheManagerFactory
       ? options.cacheManagerFactory.call(null, cacheFactoryOptions)
       : new DiskCacheManager(cacheFactoryOptions, {});
 
-    this._fileProcessor = new FileProcessor({
-      dependencyExtractor: buildParameters.dependencyExtractor,
-      enableHastePackages: buildParameters.enableHastePackages,
-      enableWorkerThreads: options.enableWorkerThreads ?? false,
-      hasteImplModulePath: buildParameters.hasteImplModulePath,
+    this.#fileProcessor = new FileProcessor({
       maxFilesPerWorker: options.maxFilesPerWorker,
       maxWorkers: options.maxWorkers,
-      perfLogger: this._startupPerfLogger,
+      perfLogger: this.#startupPerfLogger,
+      pluginWorkers,
+      rootDir: options.rootDir,
     });
 
-    this._buildPromise = null;
-    this._pathUtils = new RootPathUtils(options.rootDir);
-    this._startupPerfLogger?.point('constructor_end');
-    this._crawlerAbortController = new AbortController();
-    this._changeID = 0;
+    this.#buildPromise = null;
+    this.#pathUtils = new RootPathUtils(options.rootDir);
+    this.#startupPerfLogger?.point('constructor_end');
+    this.#crawlerAbortController = new AbortController();
+    this.#changeID = 0;
   }
 
   build(): Promise<BuildResult> {
-    this._startupPerfLogger?.point('build_start');
-    if (!this._buildPromise) {
-      this._buildPromise = (async () => {
+    this.#startupPerfLogger?.point('build_start');
+    if (!this.#buildPromise) {
+      this.#buildPromise = (async () => {
         let initialData: ?CacheData;
-        if (this._options.resetCache !== true) {
+        if (this.#options.resetCache !== true) {
           initialData = await this.read();
         }
         if (!initialData) {
@@ -382,23 +357,22 @@ export default class FileMap extends EventEmitter {
           debug('Cache loaded (%d clock(s))', initialData.clocks.size);
         }
 
-        const rootDir = this._options.rootDir;
-        this._startupPerfLogger?.point('constructFileSystem_start');
+        const rootDir = this.#options.rootDir;
+        this.#startupPerfLogger?.point('constructFileSystem_start');
         const processFile: ProcessFileFunction = (
-          absolutePath,
+          normalPath,
           metadata,
           opts,
         ) => {
-          const result = this._fileProcessor.processRegularFile(
-            absolutePath,
+          const result = this.#fileProcessor.processRegularFile(
+            normalPath,
             metadata,
             {
               computeSha1: opts.computeSha1,
-              computeDependencies: false,
               maybeReturnContent: true,
             },
           );
-          debug('Lazily processed file: %s', absolutePath);
+          debug('Lazily processed file: %s', normalPath);
           // Emit an event to inform caches that there is new data to save.
           this.emit('metadata');
           return result?.content;
@@ -406,16 +380,16 @@ export default class FileMap extends EventEmitter {
         const fileSystem =
           initialData != null
             ? TreeFS.fromDeserializedSnapshot({
-                rootDir,
                 // Typed `mixed` because we've read this from an external
                 // source. It'd be too expensive to validate at runtime, so
                 // trust our cache manager that this is correct.
                 // $FlowFixMe[incompatible-type]
                 fileSystemData: initialData.fileSystemData,
                 processFile,
+                rootDir,
               })
-            : new TreeFS({rootDir, processFile});
-        this._startupPerfLogger?.point('constructFileSystem_end');
+            : new TreeFS({processFile, rootDir});
+        this.#startupPerfLogger?.point('constructFileSystem_end');
 
         const plugins = this.#plugins;
 
@@ -423,28 +397,53 @@ export default class FileMap extends EventEmitter {
         // crawling to build a diff of current state vs cached. `fileSystem`
         // is not mutated during either operation.
         const [fileDelta] = await Promise.all([
-          this._buildFileDelta({
-            fileSystem,
+          this.#buildFileDelta({
             clocks: initialData?.clocks ?? new Map(),
+            fileSystem,
           }),
           Promise.all(
-            plugins.map(plugin =>
+            plugins.map(({plugin, dataIdx}) =>
               plugin.initialize({
-                files: fileSystem,
+                files: {
+                  lookup: mixedPath => {
+                    const result = fileSystem.lookup(mixedPath);
+                    if (!result.exists) {
+                      return {exists: false};
+                    }
+                    if (result.type === 'd') {
+                      return {exists: true, type: 'd'};
+                    }
+                    return {
+                      exists: true,
+                      type: 'f',
+                      pluginData:
+                        dataIdx != null ? result.metadata[dataIdx] : null,
+                    };
+                  },
+                  fileIterator: opts =>
+                    mapIterator(
+                      fileSystem.metadataIterator(opts),
+                      ({baseName, canonicalPath, metadata}) => ({
+                        baseName,
+                        canonicalPath,
+                        pluginData: dataIdx != null ? metadata[dataIdx] : null,
+                      }),
+                    ),
+                },
                 pluginState: initialData?.plugins.get(plugin.name),
               }),
             ),
           ),
         ]);
 
-        // Update `fileSystem`, `hasteMap` and `mocks` based on the file delta.
-        await this._applyFileDelta(fileSystem, plugins, fileDelta);
+        // Update `fileSystem` and plugins based on the file delta.
+        await this.#applyFileDelta(fileSystem, plugins, fileDelta);
 
-        // Validate the mock and Haste maps before persisting them.
-        plugins.forEach(plugin => plugin.assertValid());
+        // Validate plugins before persisting them.
+        plugins.forEach(({plugin}) => plugin.assertValid());
 
         const watchmanClocks = new Map(fileDelta.clocks ?? []);
-        await this._takeSnapshotAndPersist(
+        await this.#takeSnapshotAndPersist(
           fileSystem,
           watchmanClocks,
           plugins,
@@ -457,16 +456,12 @@ export default class FileMap extends EventEmitter {
           fileDelta.removedFiles.size,
         );
 
-        await this._watch(fileSystem, watchmanClocks, plugins);
-        return {
-          fileSystem,
-          hasteMap: this.#hastePlugin,
-          mockMap: this.#mockPlugin,
-        };
+        await this.#watch(fileSystem, watchmanClocks, plugins);
+        return {fileSystem};
       })();
     }
-    return this._buildPromise.then(result => {
-      this._startupPerfLogger?.point('build_end');
+    return this.#buildPromise.then(result => {
+      this.#startupPerfLogger?.point('build_end');
       return result;
     });
   }
@@ -476,33 +471,33 @@ export default class FileMap extends EventEmitter {
    */
   async read(): Promise<?CacheData> {
     let data: ?CacheData;
-    this._startupPerfLogger?.point('read_start');
+    this.#startupPerfLogger?.point('read_start');
     try {
-      data = await this._cacheManager.read();
+      data = await this.#cacheManager.read();
     } catch (e) {
-      this._console.warn(
+      this.#console.warn(
         'Error while reading cache, falling back to a full crawl:\n',
         e,
       );
-      this._startupPerfLogger?.annotate({
+      this.#startupPerfLogger?.annotate({
         string: {cacheReadError: e.toString()},
       });
     }
-    this._startupPerfLogger?.point('read_end');
+    this.#startupPerfLogger?.point('read_end');
     return data;
   }
 
   /**
    * 2. crawl the file system.
    */
-  async _buildFileDelta(
+  async #buildFileDelta(
     previousState: CrawlerOptions['previousState'],
   ): Promise<{
     removedFiles: Set<CanonicalPath>,
     changedFiles: FileData,
     clocks?: WatchmanClocks,
   }> {
-    this._startupPerfLogger?.point('buildFileDelta_start');
+    this.#startupPerfLogger?.point('buildFileDelta_start');
 
     const {
       computeSha1,
@@ -515,16 +510,16 @@ export default class FileMap extends EventEmitter {
       rootDir,
       watch,
       watchmanDeferStates,
-    } = this._options;
+    } = this.#options;
 
-    this._watcher = new Watcher({
-      abortSignal: this._crawlerAbortController.signal,
+    this.#watcher = new Watcher({
+      abortSignal: this.#crawlerAbortController.signal,
       computeSha1,
-      console: this._console,
+      console: this.#console,
       enableSymlinks,
       extensions,
       forceNodeFilesystemAPI,
-      healthCheckFilePrefix: this._options.healthCheck.filePrefix,
+      healthCheckFilePrefix: this.#options.healthCheck.filePrefix,
       // TODO: Refactor out the two different ignore strategies here.
       ignoreForCrawl: filePath => {
         const ignoreMatched = ignorePattern.test(filePath);
@@ -533,53 +528,55 @@ export default class FileMap extends EventEmitter {
         );
       },
       ignorePatternForWatch: ignorePattern,
-      perfLogger: this._startupPerfLogger,
+      perfLogger: this.#startupPerfLogger,
       previousState,
-      roots,
       rootDir,
-      useWatchman: await this._shouldUseWatchman(),
+      roots,
+      useWatchman: await this.#shouldUseWatchman(),
       watch,
       watchmanDeferStates,
     });
-    const watcher = this._watcher;
+    const watcher = this.#watcher;
 
     watcher.on('status', status => this.emit('status', status));
 
     return watcher.crawl().then(result => {
-      this._startupPerfLogger?.point('buildFileDelta_end');
+      this.#startupPerfLogger?.point('buildFileDelta_end');
       return result;
     });
   }
 
-  _maybeReadLink(filePath: Path, fileMetadata: FileMetadata): ?Promise<void> {
+  #maybeReadLink(normalPath: Path, fileMetadata: FileMetadata): ?Promise<void> {
     // If we only need to read a link, it's more efficient to do it in-band
     // (with async file IO) than to have the overhead of worker IO.
     if (fileMetadata[H.SYMLINK] === 1) {
-      return fsPromises.readlink(filePath).then(symlinkTarget => {
-        fileMetadata[H.VISITED] = 1;
-        fileMetadata[H.SYMLINK] = symlinkTarget;
-      });
+      return fsPromises
+        .readlink(this.#pathUtils.normalToAbsolute(normalPath))
+        .then(symlinkTarget => {
+          fileMetadata[H.VISITED] = 1;
+          fileMetadata[H.SYMLINK] = symlinkTarget;
+        });
     }
     return null;
   }
 
-  async _applyFileDelta(
+  async #applyFileDelta(
     fileSystem: MutableFileSystem,
-    plugins: $ReadOnlyArray<FileMapPlugin<>>,
-    delta: $ReadOnly<{
+    plugins: ReadonlyArray<IndexedPlugin>,
+    delta: Readonly<{
       changedFiles: FileData,
-      removedFiles: $ReadOnlySet<CanonicalPath>,
+      removedFiles: ReadonlySet<CanonicalPath>,
       clocks?: WatchmanClocks,
     }>,
   ): Promise<void> {
-    this._startupPerfLogger?.point('applyFileDelta_start');
+    this.#startupPerfLogger?.point('applyFileDelta_start');
     const {changedFiles, removedFiles} = delta;
-    this._startupPerfLogger?.point('applyFileDelta_preprocess_start');
+    this.#startupPerfLogger?.point('applyFileDelta_preprocess_start');
     const missingFiles: Set<string> = new Set();
 
-    // Remove files first so that we don't mistake moved mocks or Haste
+    // Remove files first so that we don't mistake moved modules
     // modules as duplicates.
-    this._startupPerfLogger?.point('applyFileDelta_remove_start');
+    this.#startupPerfLogger?.point('applyFileDelta_remove_start');
     const removed: Array<[string, FileMetadata]> = [];
     for (const relativeFilePath of removedFiles) {
       const metadata = fileSystem.remove(relativeFilePath);
@@ -587,77 +584,52 @@ export default class FileMap extends EventEmitter {
         removed.push([relativeFilePath, metadata]);
       }
     }
-    this._startupPerfLogger?.point('applyFileDelta_remove_end');
+    this.#startupPerfLogger?.point('applyFileDelta_remove_end');
 
     const readLinkPromises = [];
     const readLinkErrors: Array<{
-      absolutePath: string,
+      normalFilePath: string,
       error: Error & {code?: string},
     }> = [];
     const filesToProcess: Array<[string, FileMetadata]> = [];
 
-    for (const [relativeFilePath, fileData] of changedFiles) {
+    for (const [normalFilePath, fileData] of changedFiles) {
       // A crawler may preserve the H.VISITED flag to indicate that the file
       // contents are unchaged and it doesn't need visiting again.
       if (fileData[H.VISITED] === 1) {
         continue;
       }
 
-      if (
-        this._options.skipPackageJson &&
-        relativeFilePath.endsWith(PACKAGE_JSON)
-      ) {
-        continue;
-      }
-
-      if (
-        fileData[H.SYMLINK] === 0 &&
-        !this._options.computeDependencies &&
-        !this._options.computeSha1 &&
-        this._options.hasteImplModulePath == null &&
-        !(
-          this._options.enableHastePackages &&
-          relativeFilePath.endsWith(PACKAGE_JSON)
-        )
-      ) {
-        // Nothing to process
-        continue;
-      }
-
-      // SHA-1, if requested, should already be present thanks to the crawler.
-      const absolutePath = this._pathUtils.normalToAbsolute(relativeFilePath);
-
       if (fileData[H.SYMLINK] === 0) {
-        filesToProcess.push([absolutePath, fileData]);
+        filesToProcess.push([normalFilePath, fileData]);
       } else {
-        const maybeReadLink = this._maybeReadLink(absolutePath, fileData);
+        const maybeReadLink = this.#maybeReadLink(normalFilePath, fileData);
         if (maybeReadLink) {
           readLinkPromises.push(
             maybeReadLink.catch(error =>
-              readLinkErrors.push({absolutePath, error}),
+              readLinkErrors.push({normalFilePath, error}),
             ),
           );
         }
       }
     }
-    this._startupPerfLogger?.point('applyFileDelta_preprocess_end');
+    this.#startupPerfLogger?.point('applyFileDelta_preprocess_end');
 
     debug(
-      'Visiting %d added/modified files and %d symlinks.',
+      'Found %d added/modified files and %d symlinks.',
       filesToProcess.length,
       readLinkPromises.length,
     );
 
-    this._startupPerfLogger?.point('applyFileDelta_process_start');
+    this.#startupPerfLogger?.point('applyFileDelta_process_start');
     const [batchResult] = await Promise.all([
-      this._fileProcessor.processBatch(filesToProcess, {
-        computeSha1: this._options.computeSha1,
-        computeDependencies: this._options.computeDependencies,
+      this.#fileProcessor.processBatch(filesToProcess, {
+        computeSha1: this.#options.computeSha1,
         maybeReturnContent: false,
       }),
       Promise.all(readLinkPromises),
     ]);
-    this._startupPerfLogger?.point('applyFileDelta_process_end');
+    this.#startupPerfLogger?.point('applyFileDelta_process_end');
 
     // It's possible that a file could be deleted between being seen by the
     // crawler and our attempt to process it. For our purposes, this is
@@ -668,14 +640,14 @@ export default class FileMap extends EventEmitter {
     // Treat the file accordingly - don't add it to `FileSystem`, and remove
     // it if it already exists. We're not emitting events at this point in
     // startup, so there's nothing more to do.
-    this._startupPerfLogger?.point('applyFileDelta_missing_start');
-    for (const {absolutePath, error} of batchResult.errors.concat(
+    this.#startupPerfLogger?.point('applyFileDelta_missing_start');
+    for (const {normalFilePath, error} of batchResult.errors.concat(
       readLinkErrors,
     )) {
       /* $FlowFixMe[incompatible-type] Error exposed after improved typing of
        * Array.{includes,indexOf,lastIndexOf} */
       if (['ENOENT', 'EACCESS'].includes(error.code)) {
-        missingFiles.add(this._pathUtils.absoluteToNormal(absolutePath));
+        missingFiles.add(normalFilePath);
       } else {
         // Anything else is fatal.
         throw error;
@@ -688,42 +660,49 @@ export default class FileMap extends EventEmitter {
         removed.push([relativeFilePath, metadata]);
       }
     }
-    this._startupPerfLogger?.point('applyFileDelta_missing_end');
+    this.#startupPerfLogger?.point('applyFileDelta_missing_end');
 
-    this._startupPerfLogger?.point('applyFileDelta_add_start');
+    this.#startupPerfLogger?.point('applyFileDelta_add_start');
     fileSystem.bulkAddOrModify(changedFiles);
-    this._startupPerfLogger?.point('applyFileDelta_add_end');
+    this.#startupPerfLogger?.point('applyFileDelta_add_end');
+
+    this.#startupPerfLogger?.point('applyFileDelta_updatePlugins_start');
 
-    this._startupPerfLogger?.point('applyFileDelta_updatePlugins_start');
     await Promise.all([
-      plugins.map(plugin =>
-        plugin.bulkUpdate({
-          addedOrModified: changedFiles,
-          removed,
-        }),
-      ),
+      plugins.map(({plugin, dataIdx}) => {
+        const mapFn: (
+          [CanonicalPath, FileMetadata],
+        ) => [CanonicalPath, unknown] =
+          dataIdx != null
+            ? ([relativePath, fileData]) => [relativePath, fileData[dataIdx]]
+            : ([relativePath, fileData]) => [relativePath, null];
+        return plugin.bulkUpdate({
+          addedOrModified: mapIterator(changedFiles.entries(), mapFn),
+          removed: mapIterator(removed.values(), mapFn),
+        });
+      }),
     ]);
-    this._startupPerfLogger?.point('applyFileDelta_updatePlugins_end');
-    this._startupPerfLogger?.point('applyFileDelta_end');
+    this.#startupPerfLogger?.point('applyFileDelta_updatePlugins_end');
+    this.#startupPerfLogger?.point('applyFileDelta_end');
   }
 
   /**
    * 4. Serialize a snapshot of our raw data via the configured cache manager
    */
-  async _takeSnapshotAndPersist(
+  async #takeSnapshotAndPersist(
     fileSystem: FileSystem,
     clocks: WatchmanClocks,
-    plugins: $ReadOnlyArray<FileMapPlugin<>>,
+    plugins: ReadonlyArray<IndexedPlugin>,
     changed: FileData,
     removed: Set<CanonicalPath>,
   ) {
-    this._startupPerfLogger?.point('persist_start');
-    await this._cacheManager.write(
+    this.#startupPerfLogger?.point('persist_start');
+    await this.#cacheManager.write(
       () => ({
-        fileSystemData: fileSystem.getSerializableSnapshot(),
         clocks: new Map(clocks),
+        fileSystemData: fileSystem.getSerializableSnapshot(),
         plugins: new Map(
-          plugins.map(plugin => [
+          plugins.map(({plugin}) => [
             plugin.name,
             plugin.getSerializableSnapshot(),
           ]),
@@ -745,29 +724,29 @@ export default class FileMap extends EventEmitter {
           },
         },
         onWriteError: error => {
-          this._console.warn('[metro-file-map] Cache write error\n:', error);
+          this.#console.warn('[metro-file-map] Cache write error\n:', error);
         },
       },
     );
-    this._startupPerfLogger?.point('persist_end');
+    this.#startupPerfLogger?.point('persist_end');
   }
 
   /**
    * Watch mode
    */
-  async _watch(
+  async #watch(
     fileSystem: MutableFileSystem,
     clocks: WatchmanClocks,
-    plugins: $ReadOnlyArray<FileMapPlugin<>>,
+    plugins: ReadonlyArray<IndexedPlugin>,
   ): Promise<void> {
-    this._startupPerfLogger?.point('watch_start');
-    if (!this._options.watch) {
-      this._startupPerfLogger?.point('watch_end');
+    this.#startupPerfLogger?.point('watch_start');
+    if (!this.#options.watch) {
+      this.#startupPerfLogger?.point('watch_end');
       return;
     }
 
     const hasWatchedExtension = (filePath: string) =>
-      this._options.extensions.some(ext => filePath.endsWith(ext));
+      this.#options.extensions.some(ext => filePath.endsWith(ext));
 
     let changeQueue: Promise<null | void> = Promise.resolve();
     let nextEmit: ?{
@@ -783,8 +762,8 @@ export default class FileMap extends EventEmitter {
       }
       const {eventsQueue, firstEventTimestamp, firstEnqueuedTimestamp} =
         nextEmit;
-      const hmrPerfLogger = this._options.perfLoggerFactory?.('HMR', {
-        key: this._getNextChangeID(),
+      const hmrPerfLogger = this.#options.perfLoggerFactory?.('HMR', {
+        key: this.#getNextChangeID(),
       });
       if (hmrPerfLogger != null) {
         hmrPerfLogger.start({timestamp: firstEventTimestamp});
@@ -798,8 +777,8 @@ export default class FileMap extends EventEmitter {
         hmrPerfLogger.point('fileChange_start');
       }
       const changeEvent: ChangeEvent = {
-        logger: hmrPerfLogger,
         eventsQueue,
+        logger: hmrPerfLogger,
       };
       this.emit('change', changeEvent);
       nextEmit = null;
@@ -814,7 +793,7 @@ export default class FileMap extends EventEmitter {
           (change.metadata.type === 'f' &&
             !hasWatchedExtension(change.relativePath)) ||
           // Don't emit events relating to symlinks if enableSymlinks: false
-          (!this._options.enableSymlinks && change.metadata?.type === 'l'))
+          (!this.#options.enableSymlinks && change.metadata?.type === 'l'))
       ) {
         return;
       }
@@ -826,12 +805,12 @@ export default class FileMap extends EventEmitter {
 
       // Ignore files (including symlinks) whose path matches ignorePattern
       // (we don't ignore node_modules in watch mode)
-      if (this._options.ignorePattern.test(absoluteFilePath)) {
+      if (this.#options.ignorePattern.test(absoluteFilePath)) {
         return;
       }
 
       const relativeFilePath =
-        this._pathUtils.absoluteToNormal(absoluteFilePath);
+        this.#pathUtils.absoluteToNormal(absoluteFilePath);
       const linkStats = fileSystem.linkStats(relativeFilePath);
 
       // The file has been accessed, not modified. If the modified time is
@@ -889,9 +868,9 @@ export default class FileMap extends EventEmitter {
             if (nextEmit == null) {
               nextEmit = {
                 eventsQueue: [event],
-                firstEventTimestamp: onChangeStartTime,
                 firstEnqueuedTimestamp:
                   performance.timeOrigin + performance.now(),
+                firstEventTimestamp: onChangeStartTime,
               };
             } else {
               nextEmit.eventsQueue.push(event);
@@ -900,7 +879,7 @@ export default class FileMap extends EventEmitter {
           };
 
           // If the file was added or modified,
-          // parse it and update the haste map.
+          // parse it and update the file map.
           if (change.event === 'touch') {
             invariant(
               change.metadata.size != null,
@@ -910,30 +889,33 @@ export default class FileMap extends EventEmitter {
               change.metadata.modifiedTime,
               change.metadata.size,
               0,
-              '',
               null,
               change.metadata.type === 'l' ? 1 : 0,
-              '',
+              null,
             ];
 
             try {
               if (change.metadata.type === 'l') {
-                await this._maybeReadLink(absoluteFilePath, fileMetadata);
+                await this.#maybeReadLink(relativeFilePath, fileMetadata);
               } else {
-                await this._fileProcessor.processRegularFile(
-                  absoluteFilePath,
+                await this.#fileProcessor.processRegularFile(
+                  relativeFilePath,
                   fileMetadata,
                   {
-                    computeSha1: this._options.computeSha1,
-                    computeDependencies: this._options.computeDependencies,
+                    computeSha1: this.#options.computeSha1,
                     maybeReturnContent: false,
                   },
                 );
               }
               fileSystem.addOrModify(relativeFilePath, fileMetadata);
-              this._updateClock(clocks, change.clock);
-              plugins.forEach(plugin =>
-                plugin.onNewOrModifiedFile(relativeFilePath, fileMetadata),
+              this.#updateClock(clocks, change.clock);
+              plugins.forEach(({plugin, dataIdx}) =>
+                dataIdx != null
+                  ? plugin.onNewOrModifiedFile(
+                      relativeFilePath,
+                      fileMetadata[dataIdx],
+                    )
+                  : plugin.onNewOrModifiedFile(relativeFilePath),
               );
               enqueueEvent(change.metadata);
             } catch (e) {
@@ -956,9 +938,11 @@ export default class FileMap extends EventEmitter {
             // We've already checked linkStats != null above, so the file
             // exists in the file map and remove should always return metadata.
             const metadata = nullthrows(fileSystem.remove(relativeFilePath));
-            this._updateClock(clocks, change.clock);
-            plugins.forEach(plugin =>
-              plugin.onRemovedFile(relativeFilePath, metadata),
+            this.#updateClock(clocks, change.clock);
+            plugins.forEach(({plugin, dataIdx}) =>
+              dataIdx != null
+                ? plugin.onRemovedFile(relativeFilePath, metadata[dataIdx])
+                : plugin.onRemovedFile(relativeFilePath),
             );
 
             enqueueEvent({
@@ -974,68 +958,68 @@ export default class FileMap extends EventEmitter {
           return null;
         })
         .catch((error: Error) => {
-          this._console.error(
+          this.#console.error(
             `metro-file-map: watch error:\n  ${error.stack}\n`,
           );
         });
     };
 
-    this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL);
+    this.#changeInterval = setInterval(emitChange, CHANGE_INTERVAL);
 
     invariant(
-      this._watcher != null,
-      'Expected _watcher to have been initialised by build()',
+      this.#watcher != null,
+      'Expected #watcher to have been initialised by build()',
     );
-    await this._watcher.watch(onChange);
+    await this.#watcher.watch(onChange);
 
-    if (this._options.healthCheck.enabled) {
+    if (this.#options.healthCheck.enabled) {
       const performHealthCheck = () => {
-        if (!this._watcher) {
+        if (!this.#watcher) {
           return;
         }
         // $FlowFixMe[unused-promise]
-        this._watcher
-          .checkHealth(this._options.healthCheck.timeout)
+        this.#watcher
+          .checkHealth(this.#options.healthCheck.timeout)
           .then(result => {
             this.emit('healthCheck', result);
           });
       };
       performHealthCheck();
-      this._healthCheckInterval = setInterval(
+      this.#healthCheckInterval = setInterval(
         performHealthCheck,
-        this._options.healthCheck.interval,
+        this.#options.healthCheck.interval,
       );
     }
-    this._startupPerfLogger?.point('watch_end');
+    this.#startupPerfLogger?.point('watch_end');
   }
 
   async end(): Promise<void> {
-    if (this._changeInterval) {
-      clearInterval(this._changeInterval);
+    if (this.#changeInterval) {
+      clearInterval(this.#changeInterval);
     }
-    if (this._healthCheckInterval) {
-      clearInterval(this._healthCheckInterval);
+    if (this.#healthCheckInterval) {
+      clearInterval(this.#healthCheckInterval);
     }
 
-    this._crawlerAbortController.abort();
+    this.#crawlerAbortController.abort();
 
     await Promise.all([
-      this._fileProcessor.end(),
-      this._watcher?.close(),
-      this._cacheManager.end(),
+      this.#fileProcessor.end(),
+      this.#watcher?.close(),
+      this.#cacheManager.end(),
     ]);
   }
 
-  async _shouldUseWatchman(): Promise<boolean> {
-    if (!this._options.useWatchman) {
+  async #shouldUseWatchman(): Promise<boolean> {
+    if (!this.#options.useWatchman) {
       return false;
     }
-    if (!this._canUseWatchmanPromise) {
-      this._canUseWatchmanPromise = checkWatchmanCapabilities(
+    if (!this.#canUseWatchmanPromise) {
+      this.#canUseWatchmanPromise = checkWatchmanCapabilities(
         WATCHMAN_REQUIRED_CAPABILITIES,
       )
         .then(({version}) => {
-          this._startupPerfLogger?.annotate({
+          this.#startupPerfLogger?.annotate({
             string: {
               watchmanVersion: version,
             },
@@ -1045,7 +1029,7 @@ export default class FileMap extends EventEmitter {
         .catch(e => {
           // TODO: Advise people to either install Watchman or set
           // `useWatchman: false` here?
-          this._startupPerfLogger?.annotate({
+          this.#startupPerfLogger?.annotate({
             string: {
               watchmanFailedCapabilityCheck: e?.message ?? '[missing]',
             },
@@ -1053,24 +1037,34 @@ export default class FileMap extends EventEmitter {
           return false;
         });
     }
-    return this._canUseWatchmanPromise;
+    return this.#canUseWatchmanPromise;
   }
 
-  _getNextChangeID(): number {
-    if (this._changeID >= Number.MAX_SAFE_INTEGER) {
-      this._changeID = 0;
+  #getNextChangeID(): number {
+    if (this.#changeID >= Number.MAX_SAFE_INTEGER) {
+      this.#changeID = 0;
     }
-    return ++this._changeID;
+    return ++this.#changeID;
   }
 
-  _updateClock(clocks: WatchmanClocks, newClock?: ?ChangeEventClock): void {
+  #updateClock(clocks: WatchmanClocks, newClock?: ?ChangeEventClock): void {
     if (newClock == null) {
       return;
     }
     const [absoluteWatchRoot, clockSpec] = newClock;
-    const relativeFsRoot = this._pathUtils.absoluteToNormal(absoluteWatchRoot);
+    const relativeFsRoot = this.#pathUtils.absoluteToNormal(absoluteWatchRoot);
     clocks.set(normalizePathSeparatorsToPosix(relativeFsRoot), clockSpec);
   }
 
   static H: HType = H;
 }
+
+// TODO: Replace with it.map() from Node 22+
+const mapIterator: <T, S>(Iterator<T>, (T) => S) => Iterable<S> = (it, fn) =>
+  'map' in it
+    ? it.map(fn)
+    : (function* mapped() {
+        for (const item of it) {
+          yield fn(item);
+        }
+      })();