metro-file-map 0.83.3 → 0.84.0

package/src/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true,
 });
+Object.defineProperty(exports, "DependencyPlugin", {
+  enumerable: true,
+  get: function () {
+    return _DependencyPlugin.default;
+  },
+});
 Object.defineProperty(exports, "DiskCacheManager", {
   enumerable: true,
   get: function () {
@@ -42,8 +48,6 @@ var _normalizePathSeparatorsToSystem = _interopRequireDefault(
 );
 var _RootPathUtils = require("./lib/RootPathUtils");
 var _TreeFS = _interopRequireDefault(require("./lib/TreeFS"));
-var _HastePlugin = _interopRequireDefault(require("./plugins/HastePlugin"));
-var _MockPlugin = _interopRequireDefault(require("./plugins/MockPlugin"));
 var _Watcher = require("./Watcher");
 var _events = _interopRequireDefault(require("events"));
 var _fs = require("fs");
@@ -51,39 +55,46 @@ var _invariant = _interopRequireDefault(require("invariant"));
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
 var path = _interopRequireWildcard(require("path"));
 var _perf_hooks = require("perf_hooks");
+var _DependencyPlugin = _interopRequireDefault(
+  require("./plugins/DependencyPlugin"),
+);
 var _DuplicateHasteCandidatesError = require("./plugins/haste/DuplicateHasteCandidatesError");
 var _HasteConflictsError = require("./plugins/haste/HasteConflictsError");
-function _getRequireWildcardCache(e) {
-  if ("function" != typeof WeakMap) return null;
-  var r = new WeakMap(),
-    t = new WeakMap();
-  return (_getRequireWildcardCache = function (e) {
-    return e ? t : r;
-  })(e);
-}
-function _interopRequireWildcard(e, r) {
-  if (!r && e && e.__esModule) return e;
-  if (null === e || ("object" != typeof e && "function" != typeof e))
-    return { default: e };
-  var t = _getRequireWildcardCache(r);
-  if (t && t.has(e)) return t.get(e);
-  var n = { __proto__: null },
-    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var u in e)
-    if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
-      var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
-      i && (i.get || i.set) ? Object.defineProperty(n, u, i) : (n[u] = e[u]);
+var _HastePlugin = _interopRequireDefault(require("./plugins/HastePlugin"));
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap)
+    var r = new WeakMap(),
+      n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = { __proto__: null, default: e };
+    if (null === e || ("object" != typeof e && "function" != typeof e))
+      return f;
+    if ((o = t ? n : r)) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
     }
-  return ((n.default = e), t && t.set(e, n), n);
+    for (const t in e)
+      "default" !== t &&
+        {}.hasOwnProperty.call(e, t) &&
+        ((i =
+          (o = Object.defineProperty) &&
+          Object.getOwnPropertyDescriptor(e, t)) &&
+        (i.get || i.set)
+          ? o(f, t, i)
+          : (f[t] = e[t]));
+    return f;
+  })(e, t);
 }
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:FileMap");
-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",
@@ -92,18 +103,29 @@ const WATCHMAN_REQUIRED_CAPABILITIES = [
   "wildmatch",
 ];
 class FileMap extends _events.default {
-  #hastePlugin;
-  #mockPlugin = null;
+  #buildPromise;
+  #cacheManager;
+  #canUseWatchmanPromise;
+  #changeID;
+  #changeInterval;
+  #console;
+  #crawlerAbortController;
+  #fileProcessor;
+  #healthCheckInterval;
+  #options;
+  #pathUtils;
   #plugins;
+  #startupPerfLogger;
+  #watcher;
   static create(options) {
     return new FileMap(options);
   }
   constructor(options) {
     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");
     }
     let ignorePattern;
     if (options.ignorePattern) {
@@ -121,49 +143,35 @@ class FileMap extends _events.default {
     } else {
       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.default({
-      console: this._console,
-      enableHastePackages,
-      perfLogger: this._startupPerfLogger,
-      platforms: new Set(options.platforms),
-      rootDir: options.rootDir,
-      failValidationOnConflicts: throwOnModuleCollision,
-    });
-    const plugins = [this.#hastePlugin];
-    if (options.mocksPattern != null && options.mocksPattern !== "") {
-      this.#mockPlugin = new _MockPlugin.default({
-        console: this._console,
-        mocksPattern: new RegExp(options.mocksPattern),
-        rootDir: options.rootDir,
-        throwOnModuleCollision,
+    this.#console = options.console || global.console;
+    let dataSlot = _constants.default.PLUGINDATA;
+    const indexedPlugins = [];
+    const pluginWorkers = [];
+    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 = {
-      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,
@@ -175,30 +183,28 @@ class FileMap extends _events.default {
     const cacheFactoryOptions = {
       buildParameters,
     };
-    this._cacheManager = options.cacheManagerFactory
+    this.#cacheManager = options.cacheManagerFactory
       ? options.cacheManagerFactory.call(null, cacheFactoryOptions)
       : new _DiskCacheManager.DiskCacheManager(cacheFactoryOptions, {});
-    this._fileProcessor = new _FileProcessor.FileProcessor({
-      dependencyExtractor: buildParameters.dependencyExtractor,
-      enableHastePackages: buildParameters.enableHastePackages,
-      enableWorkerThreads: options.enableWorkerThreads ?? false,
-      hasteImplModulePath: buildParameters.hasteImplModulePath,
+    this.#fileProcessor = new _FileProcessor.FileProcessor({
       maxFilesPerWorker: options.maxFilesPerWorker,
       maxWorkers: options.maxWorkers,
-      perfLogger: this._startupPerfLogger,
+      perfLogger: this.#startupPerfLogger,
+      pluginWorkers,
+      rootDir: options.rootDir,
     });
-    this._buildPromise = null;
-    this._pathUtils = new _RootPathUtils.RootPathUtils(options.rootDir);
-    this._startupPerfLogger?.point("constructor_end");
-    this._crawlerAbortController = new AbortController();
-    this._changeID = 0;
+    this.#buildPromise = null;
+    this.#pathUtils = new _RootPathUtils.RootPathUtils(options.rootDir);
+    this.#startupPerfLogger?.point("constructor_end");
+    this.#crawlerAbortController = new AbortController();
+    this.#changeID = 0;
   }
   build() {
-    this._startupPerfLogger?.point("build_start");
-    if (!this._buildPromise) {
-      this._buildPromise = (async () => {
+    this.#startupPerfLogger?.point("build_start");
+    if (!this.#buildPromise) {
+      this.#buildPromise = (async () => {
         let initialData;
-        if (this._options.resetCache !== true) {
+        if (this.#options.resetCache !== true) {
           initialData = await this.read();
         }
         if (!initialData) {
@@ -206,53 +212,82 @@ class FileMap extends _events.default {
         } else {
           debug("Cache loaded (%d clock(s))", initialData.clocks.size);
         }
-        const rootDir = this._options.rootDir;
-        this._startupPerfLogger?.point("constructFileSystem_start");
-        const processFile = (absolutePath, metadata, opts) => {
-          const result = this._fileProcessor.processRegularFile(
-            absolutePath,
+        const rootDir = this.#options.rootDir;
+        this.#startupPerfLogger?.point("constructFileSystem_start");
+        const processFile = (normalPath, metadata, opts) => {
+          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);
           this.emit("metadata");
           return result?.content;
         };
         const fileSystem =
           initialData != null
             ? _TreeFS.default.fromDeserializedSnapshot({
-                rootDir,
                 fileSystemData: initialData.fileSystemData,
                 processFile,
+                rootDir,
               })
             : new _TreeFS.default({
-                rootDir,
                 processFile,
+                rootDir,
               });
-        this._startupPerfLogger?.point("constructFileSystem_end");
+        this.#startupPerfLogger?.point("constructFileSystem_end");
         const plugins = this.#plugins;
         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),
               }),
             ),
           ),
         ]);
-        await this._applyFileDelta(fileSystem, plugins, fileDelta);
-        plugins.forEach((plugin) => plugin.assertValid());
+        await this.#applyFileDelta(fileSystem, plugins, fileDelta);
+        plugins.forEach(({ plugin }) => plugin.assertValid());
         const watchmanClocks = new Map(fileDelta.clocks ?? []);
-        await this._takeSnapshotAndPersist(
+        await this.#takeSnapshotAndPersist(
           fileSystem,
           watchmanClocks,
           plugins,
@@ -264,40 +299,38 @@ class FileMap extends _events.default {
           fileDelta.changedFiles.size,
           fileDelta.removedFiles.size,
         );
-        await this._watch(fileSystem, watchmanClocks, plugins);
+        await this.#watch(fileSystem, watchmanClocks, plugins);
         return {
           fileSystem,
-          hasteMap: this.#hastePlugin,
-          mockMap: this.#mockPlugin,
         };
       })();
     }
-    return this._buildPromise.then((result) => {
-      this._startupPerfLogger?.point("build_end");
+    return this.#buildPromise.then((result) => {
+      this.#startupPerfLogger?.point("build_end");
       return result;
     });
   }
   async read() {
     let data;
-    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;
   }
-  async _buildFileDelta(previousState) {
-    this._startupPerfLogger?.point("buildFileDelta_start");
+  async #buildFileDelta(previousState) {
+    this.#startupPerfLogger?.point("buildFileDelta_start");
     const {
       computeSha1,
       enableSymlinks,
@@ -309,15 +342,15 @@ class FileMap extends _events.default {
       rootDir,
       watch,
       watchmanDeferStates,
-    } = this._options;
-    this._watcher = new _Watcher.Watcher({
-      abortSignal: this._crawlerAbortController.signal,
+    } = this.#options;
+    this.#watcher = new _Watcher.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,
       ignoreForCrawl: (filePath) => {
         const ignoreMatched = ignorePattern.test(filePath);
         return (
@@ -325,36 +358,38 @@ class FileMap extends _events.default {
         );
       },
       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, fileMetadata) {
+  #maybeReadLink(normalPath, fileMetadata) {
     if (fileMetadata[_constants.default.SYMLINK] === 1) {
-      return _fs.promises.readlink(filePath).then((symlinkTarget) => {
-        fileMetadata[_constants.default.VISITED] = 1;
-        fileMetadata[_constants.default.SYMLINK] = symlinkTarget;
-      });
+      return _fs.promises
+        .readlink(this.#pathUtils.normalToAbsolute(normalPath))
+        .then((symlinkTarget) => {
+          fileMetadata[_constants.default.VISITED] = 1;
+          fileMetadata[_constants.default.SYMLINK] = symlinkTarget;
+        });
     }
     return null;
   }
-  async _applyFileDelta(fileSystem, plugins, delta) {
-    this._startupPerfLogger?.point("applyFileDelta_start");
+  async #applyFileDelta(fileSystem, plugins, delta) {
+    this.#startupPerfLogger?.point("applyFileDelta_start");
     const { changedFiles, removedFiles } = delta;
-    this._startupPerfLogger?.point("applyFileDelta_preprocess_start");
+    this.#startupPerfLogger?.point("applyFileDelta_preprocess_start");
     const missingFiles = new Set();
-    this._startupPerfLogger?.point("applyFileDelta_remove_start");
+    this.#startupPerfLogger?.point("applyFileDelta_remove_start");
     const removed = [];
     for (const relativeFilePath of removedFiles) {
       const metadata = fileSystem.remove(relativeFilePath);
@@ -362,42 +397,23 @@ class FileMap extends _events.default {
         removed.push([relativeFilePath, metadata]);
       }
     }
-    this._startupPerfLogger?.point("applyFileDelta_remove_end");
+    this.#startupPerfLogger?.point("applyFileDelta_remove_end");
     const readLinkPromises = [];
     const readLinkErrors = [];
     const filesToProcess = [];
-    for (const [relativeFilePath, fileData] of changedFiles) {
+    for (const [normalFilePath, fileData] of changedFiles) {
       if (fileData[_constants.default.VISITED] === 1) {
         continue;
       }
-      if (
-        this._options.skipPackageJson &&
-        relativeFilePath.endsWith(PACKAGE_JSON)
-      ) {
-        continue;
-      }
-      if (
-        fileData[_constants.default.SYMLINK] === 0 &&
-        !this._options.computeDependencies &&
-        !this._options.computeSha1 &&
-        this._options.hasteImplModulePath == null &&
-        !(
-          this._options.enableHastePackages &&
-          relativeFilePath.endsWith(PACKAGE_JSON)
-        )
-      ) {
-        continue;
-      }
-      const absolutePath = this._pathUtils.normalToAbsolute(relativeFilePath);
       if (fileData[_constants.default.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,
+                normalFilePath,
                 error,
               }),
             ),
@@ -405,28 +421,27 @@ class FileMap extends _events.default {
         }
       }
     }
-    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_missing_start");
-    for (const { absolutePath, error } of batchResult.errors.concat(
+    this.#startupPerfLogger?.point("applyFileDelta_process_end");
+    this.#startupPerfLogger?.point("applyFileDelta_missing_start");
+    for (const { normalFilePath, error } of batchResult.errors.concat(
       readLinkErrors,
     )) {
       if (["ENOENT", "EACCESS"].includes(error.code)) {
-        missingFiles.add(this._pathUtils.absoluteToNormal(absolutePath));
+        missingFiles.add(normalFilePath);
       } else {
         throw error;
       }
@@ -438,30 +453,34 @@ class FileMap extends _events.default {
         removed.push([relativeFilePath, metadata]);
       }
     }
-    this._startupPerfLogger?.point("applyFileDelta_missing_end");
-    this._startupPerfLogger?.point("applyFileDelta_add_start");
+    this.#startupPerfLogger?.point("applyFileDelta_missing_end");
+    this.#startupPerfLogger?.point("applyFileDelta_add_start");
     fileSystem.bulkAddOrModify(changedFiles);
-    this._startupPerfLogger?.point("applyFileDelta_add_end");
-    this._startupPerfLogger?.point("applyFileDelta_updatePlugins_start");
+    this.#startupPerfLogger?.point("applyFileDelta_add_end");
+    this.#startupPerfLogger?.point("applyFileDelta_updatePlugins_start");
     await Promise.all([
-      plugins.map((plugin) =>
-        plugin.bulkUpdate({
-          addedOrModified: changedFiles,
-          removed,
-        }),
-      ),
+      plugins.map(({ plugin, dataIdx }) => {
+        const mapFn =
+          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");
   }
-  async _takeSnapshotAndPersist(fileSystem, clocks, plugins, changed, removed) {
-    this._startupPerfLogger?.point("persist_start");
-    await this._cacheManager.write(
+  async #takeSnapshotAndPersist(fileSystem, clocks, plugins, changed, removed) {
+    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(),
           ]),
@@ -480,20 +499,20 @@ class FileMap extends _events.default {
           },
         },
         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");
   }
-  async _watch(fileSystem, clocks, plugins) {
-    this._startupPerfLogger?.point("watch_start");
-    if (!this._options.watch) {
-      this._startupPerfLogger?.point("watch_end");
+  async #watch(fileSystem, clocks, plugins) {
+    this.#startupPerfLogger?.point("watch_start");
+    if (!this.#options.watch) {
+      this.#startupPerfLogger?.point("watch_end");
       return;
     }
     const hasWatchedExtension = (filePath) =>
-      this._options.extensions.some((ext) => filePath.endsWith(ext));
+      this.#options.extensions.some((ext) => filePath.endsWith(ext));
     let changeQueue = Promise.resolve();
     let nextEmit = null;
     const emitChange = () => {
@@ -502,8 +521,8 @@ class FileMap extends _events.default {
       }
       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({
@@ -521,8 +540,8 @@ class FileMap extends _events.default {
         hmrPerfLogger.point("fileChange_start");
       }
       const changeEvent = {
-        logger: hmrPerfLogger,
         eventsQueue,
+        logger: hmrPerfLogger,
       };
       this.emit("change", changeEvent);
       nextEmit = null;
@@ -533,7 +552,7 @@ class FileMap extends _events.default {
         (change.metadata.type === "d" ||
           (change.metadata.type === "f" &&
             !hasWatchedExtension(change.relativePath)) ||
-          (!this._options.enableSymlinks && change.metadata?.type === "l"))
+          (!this.#options.enableSymlinks && change.metadata?.type === "l"))
       ) {
         return;
       }
@@ -541,11 +560,11 @@ class FileMap extends _events.default {
         change.root,
         (0, _normalizePathSeparatorsToSystem.default)(change.relativePath),
       );
-      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);
       if (
         change.event === "touch" &&
@@ -592,10 +611,10 @@ class FileMap extends _events.default {
             if (nextEmit == null) {
               nextEmit = {
                 eventsQueue: [event],
-                firstEventTimestamp: onChangeStartTime,
                 firstEnqueuedTimestamp:
                   _perf_hooks.performance.timeOrigin +
                   _perf_hooks.performance.now(),
+                firstEventTimestamp: onChangeStartTime,
               };
             } else {
               nextEmit.eventsQueue.push(event);
@@ -611,29 +630,32 @@ class FileMap extends _events.default {
               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) {
@@ -648,9 +670,11 @@ class FileMap extends _events.default {
             const metadata = (0, _nullthrows.default)(
               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({
               modifiedTime: null,
@@ -665,60 +689,60 @@ class FileMap extends _events.default {
           return null;
         })
         .catch((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);
     (0, _invariant.default)(
-      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);
-    if (this._options.healthCheck.enabled) {
+    await this.#watcher.watch(onChange);
+    if (this.#options.healthCheck.enabled) {
       const performHealthCheck = () => {
-        if (!this._watcher) {
+        if (!this.#watcher) {
           return;
         }
-        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() {
-    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() {
-    if (!this._options.useWatchman) {
+  async #shouldUseWatchman() {
+    if (!this.#options.useWatchman) {
       return false;
     }
-    if (!this._canUseWatchmanPromise) {
-      this._canUseWatchmanPromise = (0, _checkWatchmanCapabilities.default)(
+    if (!this.#canUseWatchmanPromise) {
+      this.#canUseWatchmanPromise = (0, _checkWatchmanCapabilities.default)(
         WATCHMAN_REQUIRED_CAPABILITIES,
       )
         .then(({ version }) => {
-          this._startupPerfLogger?.annotate({
+          this.#startupPerfLogger?.annotate({
             string: {
               watchmanVersion: version,
             },
@@ -726,7 +750,7 @@ class FileMap extends _events.default {
           return true;
         })
         .catch((e) => {
-          this._startupPerfLogger?.annotate({
+          this.#startupPerfLogger?.annotate({
             string: {
               watchmanFailedCapabilityCheck: e?.message ?? "[missing]",
             },
@@ -734,20 +758,20 @@ class FileMap extends _events.default {
           return false;
         });
     }
-    return this._canUseWatchmanPromise;
+    return this.#canUseWatchmanPromise;
   }
-  _getNextChangeID() {
-    if (this._changeID >= Number.MAX_SAFE_INTEGER) {
-      this._changeID = 0;
+  #getNextChangeID() {
+    if (this.#changeID >= Number.MAX_SAFE_INTEGER) {
+      this.#changeID = 0;
     }
-    return ++this._changeID;
+    return ++this.#changeID;
   }
-  _updateClock(clocks, newClock) {
+  #updateClock(clocks, newClock) {
     if (newClock == null) {
       return;
     }
     const [absoluteWatchRoot, clockSpec] = newClock;
-    const relativeFsRoot = this._pathUtils.absoluteToNormal(absoluteWatchRoot);
+    const relativeFsRoot = this.#pathUtils.absoluteToNormal(absoluteWatchRoot);
     clocks.set(
       (0, _normalizePathSeparatorsToPosix.default)(relativeFsRoot),
       clockSpec,
@@ -756,3 +780,11 @@ class FileMap extends _events.default {
   static H = _constants.default;
 }
 exports.default = FileMap;
+const mapIterator = (it, fn) =>
+  "map" in it
+    ? it.map(fn)
+    : (function* mapped() {
+        for (const item of it) {
+          yield fn(item);
+        }
+      })();