metro-file-map 0.83.4 → 0.83.6

package/src/lib/TreeFS.js.flow

@@ -13,6 +13,7 @@ import type {
   FileData,
   FileMetadata,
   FileStats,
+  FileSystemListener,
   LookupResult,
   MutableFileSystem,
   Path,
@@ -156,16 +157,45 @@ export default class TreeFS implements MutableFileSystem {
     return (fileMetadata && fileMetadata[H.SIZE]) ?? null;
   }
 
-  getDifference(files: FileData): {
+  getDifference(
+    files: FileData,
+    options?: Readonly<{
+      // Only consider files under this normal subdirectory when computing
+      // removedFiles. If not provided, all files in the file system are
+      // considered.
+      subpath?: string,
+    }>,
+  ): {
     changedFiles: FileData,
     removedFiles: Set<string>,
   } {
     const changedFiles: FileData = new Map(files);
     const removedFiles: Set<string> = new Set();
-    for (const {canonicalPath, metadata} of this.metadataIterator({
-      includeNodeModules: true,
-      includeSymlinks: true,
-    })) {
+    const subpath = options?.subpath;
+
+    // If a subpath is specified, start iteration from that node
+    let rootNode: DirectoryNode = this.#rootNode;
+    let prefix: string = '';
+    if (subpath != null && subpath !== '') {
+      const lookupResult = this.#lookupByNormalPath(subpath, {
+        followLeaf: true,
+      });
+      if (!lookupResult.exists || !isDirectory(lookupResult.node)) {
+        // Directory doesn't exist, nothing to compare - all files are new
+        return {changedFiles, removedFiles};
+      }
+      rootNode = lookupResult.node;
+      prefix = lookupResult.canonicalPath;
+    }
+
+    for (const {canonicalPath, metadata} of this.#metadataIterator(
+      rootNode,
+      {
+        includeNodeModules: true,
+        includeSymlinks: true,
+      },
+      prefix,
+    )) {
       const newMetadata = files.get(canonicalPath);
       if (newMetadata) {
         if (isRegularFile(newMetadata) !== isRegularFile(metadata)) {
@@ -378,11 +408,16 @@ export default class TreeFS implements MutableFileSystem {
     }
   }
 
-  addOrModify(mixedPath: Path, metadata: FileMetadata): void {
+  addOrModify(
+    mixedPath: Path,
+    metadata: FileMetadata,
+    changeListener?: FileSystemListener,
+  ): void {
     const normalPath = this.#normalizePath(mixedPath);
     // Walk the tree to find the *real* path of the parent node, creating
     // directories as we need.
     const parentDirNode = this.#lookupByNormalPath(path.dirname(normalPath), {
+      changeListener,
       makeDirectories: true,
     });
     if (!parentDirNode.exists) {
@@ -394,10 +429,13 @@ export default class TreeFS implements MutableFileSystem {
     const canonicalPath = this.#normalizePath(
       parentDirNode.canonicalPath + path.sep + path.basename(normalPath),
     );
-    this.bulkAddOrModify(new Map([[canonicalPath, metadata]]));
+    this.bulkAddOrModify(new Map([[canonicalPath, metadata]]), changeListener);
   }
 
-  bulkAddOrModify(addedOrModifiedFiles: FileData): void {
+  bulkAddOrModify(
+    addedOrModifiedFiles: FileData,
+    changeListener?: FileSystemListener,
+  ): void {
     // Optimisation: Bulk FileData are typically clustered by directory, so we
     // optimise for that case by remembering the last directory we looked up.
     // Experiments with large result sets show this to be significantly (~30%)
@@ -413,6 +451,7 @@ export default class TreeFS implements MutableFileSystem {
 
       if (directoryNode == null || dirname !== lastDir) {
         const lookup = this.#lookupByNormalPath(dirname, {
+          changeListener,
           followLeaf: false,
           makeDirectories: true,
         });
@@ -433,24 +472,48 @@ export default class TreeFS implements MutableFileSystem {
         lastDir = dirname;
         directoryNode = lookup.node;
       }
+      if (changeListener != null) {
+        const existingNode = directoryNode.get(basename);
+        if (existingNode != null) {
+          invariant(
+            !isDirectory(existingNode),
+            'Detected addition or modification of file %s, but it is tracked as a non-empty directory',
+            normalPath,
+          );
+          // File already exists - this is a modification
+          changeListener.fileModified(normalPath, existingNode, metadata);
+        } else {
+          // New file
+          changeListener.fileAdded(normalPath, metadata);
+        }
+      }
       directoryNode.set(basename, metadata);
     }
   }
 
-  remove(mixedPath: Path): ?FileMetadata {
+  remove(mixedPath: Path, changeListener?: FileSystemListener): void {
     const normalPath = this.#normalizePath(mixedPath);
     const result = this.#lookupByNormalPath(normalPath, {followLeaf: false});
     if (!result.exists) {
-      return null;
+      return;
     }
     const {parentNode, canonicalPath, node} = result;
 
     if (isDirectory(node) && node.size > 0) {
-      throw new Error(
-        `TreeFS: remove called on a non-empty directory: ${mixedPath}`,
-      );
+      for (const basename of node.keys()) {
+        this.remove(canonicalPath + path.sep + basename, changeListener);
+      }
+      // Removing the last file will delete this directory
+      return;
     }
     if (parentNode != null) {
+      if (changeListener != null) {
+        if (isDirectory(node)) {
+          changeListener.directoryRemoved(canonicalPath);
+        } else {
+          changeListener.fileRemoved(canonicalPath, node);
+        }
+      }
       parentNode.delete(path.basename(canonicalPath));
       if (parentNode.size === 0 && parentNode !== this.#rootNode) {
         // NB: This isn't the most efficient algorithm - in the case of
@@ -458,10 +521,9 @@ export default class TreeFS implements MutableFileSystem {
         // that's not expected to be a case common enough to justify
         // implementation complexity, or slowing down more common uses of
         // _lookupByNormalPath.
-        this.remove(path.dirname(canonicalPath));
+        this.remove(path.dirname(canonicalPath), changeListener);
       }
     }
-    return isDirectory(node) ? null : node;
   }
 
   /**
@@ -492,6 +554,10 @@ export default class TreeFS implements MutableFileSystem {
       // be added. Omit for performance if not needed.
       collectLinkPaths?: ?Set<string>,
 
+      // Low-level callbacks called on mutations of TreeFS data.
+      // Omit for performance if not needed.
+      changeListener?: FileSystemListener,
+
       // Like lstat vs stat, whether to follow a symlink at the basename of
       // the given path, or return the details of the symlink itself.
       followLeaf?: boolean,
@@ -541,7 +607,8 @@ export default class TreeFS implements MutableFileSystem {
     // null.
     let ancestorOfRootIdx: ?number = opts.start?.ancestorOfRootIdx ?? 0;
 
-    const collectAncestors = opts.collectAncestors;
+    const {collectAncestors, changeListener} = opts;
+
     // Used only when collecting ancestors, to avoid double-counting nodes and
     // paths when traversing a symlink takes us back to rootNode and out again.
     // This tracks the first character of the first segment not already
@@ -583,6 +650,12 @@ export default class TreeFS implements MutableFileSystem {
         }
         segmentNode = new Map();
         if (opts.makeDirectories === true) {
+          if (changeListener != null) {
+            const canonicalPath = isLastSegment
+              ? targetNormalPath
+              : targetNormalPath.slice(0, fromIdx - 1);
+            changeListener.directoryAdded(canonicalPath);
+          }
           parentNode.set(segmentName, segmentNode);
         }
       }

package/src/lib/checkWatchmanCapabilities.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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
+ * @generated SignedSource<<f72d8f0c4d8f513383584a02f36795ef>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/checkWatchmanCapabilities.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare function checkWatchmanCapabilities(
+  requiredCapabilities: ReadonlyArray<string>,
+): Promise<{version: string}>;
+export default checkWatchmanCapabilities;

package/src/lib/normalizePathSeparatorsToPosix.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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
+ * @generated SignedSource<<30b5e6d2308dde108c136f95a59e3740>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/normalizePathSeparatorsToPosix.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: (filePath: string) => string;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/lib/normalizePathSeparatorsToPosix.js

@@ -13,10 +13,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {

package/src/lib/normalizePathSeparatorsToSystem.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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
+ * @generated SignedSource<<719a82b7670f09ecb97e007293fddfc6>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/normalizePathSeparatorsToSystem.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: (filePath: string) => string;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/lib/normalizePathSeparatorsToSystem.js

@@ -13,10 +13,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {

package/src/lib/rootRelativeCacheKeys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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<<f82cf1eeac38c409c5bf891686c2e828>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/rootRelativeCacheKeys.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {BuildParameters} from '../flow-types';
+
+declare function rootRelativeCacheKeys(buildParameters: BuildParameters): {
+  rootDirHash: string;
+  relativeConfigHash: string;
+};
+export default rootRelativeCacheKeys;

package/src/lib/rootRelativeCacheKeys.js

@@ -10,11 +10,7 @@ var _normalizePathSeparatorsToPosix = _interopRequireDefault(
 var _RootPathUtils = require("./RootPathUtils");
 var _crypto = require("crypto");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function rootRelativeCacheKeys(buildParameters) {
   const { rootDir, plugins, ...otherParameters } = buildParameters;

package/src/lib/sorting.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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
+ * @generated SignedSource<<8805bc71542c6b43e940f8c5761ff187>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/sorting.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+export declare function compareStrings(
+  a: null | string,
+  b: null | string,
+): number;
+export declare function chainComparators<T>(
+  ...comparators: Array<(a: T, b: T) => number>
+): (a: T, b: T) => number;

package/src/plugins/DependencyPlugin.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 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<<e07a9c061b0224fc44191d956461bd6f>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/plugins/DependencyPlugin.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  FileMapPlugin,
+  FileMapPluginInitOptions,
+  FileMapPluginWorker,
+  Path,
+} from '../flow-types';
+
+export type DependencyPluginOptions = Readonly<{
+  /** Path to custom dependency extractor module */
+  dependencyExtractor: null | undefined | string;
+  /** Whether to compute dependencies (performance optimization) */
+  computeDependencies: boolean;
+  rootDir: Path;
+}>;
+declare class DependencyPlugin
+  implements FileMapPlugin<null, ReadonlyArray<string> | null>
+{
+  readonly name: 'dependencies';
+  constructor(options: DependencyPluginOptions);
+  initialize(
+    initOptions: FileMapPluginInitOptions<null, ReadonlyArray<string> | null>,
+  ): Promise<void>;
+  getSerializableSnapshot(): null;
+  onChanged(): void;
+  assertValid(): void;
+  getCacheKey(): string;
+  getWorker(): FileMapPluginWorker;
+  /**
+   * Get the list of dependencies for a given file.
+   * @param mixedPath Absolute or project-relative path to the file
+   * @returns Array of dependency module names, or null if the file doesn't exist
+   */
+  getDependencies(mixedPath: Path): null | undefined | ReadonlyArray<string>;
+}
+export default DependencyPlugin;

package/src/plugins/DependencyPlugin.js

@@ -28,9 +28,7 @@ class DependencyPlugin {
   getSerializableSnapshot() {
     return null;
   }
-  async bulkUpdate(delta) {}
-  onNewOrModifiedFile(relativeFilePath, pluginData) {}
-  onRemovedFile(relativeFilePath, pluginData) {}
+  onChanged() {}
   assertValid() {}
   getCacheKey() {
     if (this.#dependencyExtractor != null) {

package/src/plugins/DependencyPlugin.js.flow

@@ -10,7 +10,6 @@
  */
 
 import type {
-  FileMapDelta,
   FileMapPlugin,
   FileMapPluginInitOptions,
   FileMapPluginWorker,
@@ -64,25 +63,11 @@ export default class DependencyPlugin
     return null;
   }
 
-  async bulkUpdate(delta: FileMapDelta<?ReadonlyArray<string>>): Promise<void> {
+  onChanged(): void {
     // No-op: Worker already populated plugin data
     // Plugin data is write-only from worker
   }
 
-  onNewOrModifiedFile(
-    relativeFilePath: string,
-    pluginData: ?ReadonlyArray<string>,
-  ): void {
-    // No-op: Dependencies already in plugin data
-  }
-
-  onRemovedFile(
-    relativeFilePath: string,
-    pluginData: ?ReadonlyArray<string>,
-  ): void {
-    // No-op
-  }
-
   assertValid(): void {
     // No validation needed
   }

package/src/plugins/HastePlugin.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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<<3d1462ab2325a09553e02b69b5de84eb>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/plugins/HastePlugin.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  Console,
+  FileMapPlugin,
+  FileMapPluginInitOptions,
+  FileMapPluginWorker,
+  HasteConflict,
+  HasteMap,
+  HasteMapItemMetadata,
+  HTypeValue,
+  Path,
+  PerfLogger,
+  ReadonlyFileSystemChanges,
+} from '../flow-types';
+
+export type HasteMapOptions = Readonly<{
+  console?: null | undefined | Console;
+  enableHastePackages: boolean;
+  hasteImplModulePath: null | undefined | string;
+  perfLogger?: null | undefined | PerfLogger;
+  platforms: ReadonlySet<string>;
+  rootDir: Path;
+  failValidationOnConflicts: boolean;
+}>;
+declare class HastePlugin
+  implements HasteMap, FileMapPlugin<null, string | null>
+{
+  readonly name: 'haste';
+  constructor(options: HasteMapOptions);
+  initialize(
+    $$PARAM_0$$: FileMapPluginInitOptions<null, string | null>,
+  ): Promise<void>;
+  getSerializableSnapshot(): null;
+  getModule(
+    name: string,
+    platform?: null | undefined | string,
+    supportsNativePlatform?: null | undefined | boolean,
+    type?: null | undefined | HTypeValue,
+  ): null | undefined | Path;
+  getModuleNameByPath(mixedPath: Path): null | undefined | string;
+  getPackage(
+    name: string,
+    platform: null | undefined | string,
+    _supportsNativePlatform?: null | undefined | boolean,
+  ): null | undefined | Path;
+  onChanged(delta: ReadonlyFileSystemChanges<null | undefined | string>): void;
+  setModule(id: string, module: HasteMapItemMetadata): void;
+  assertValid(): void;
+  computeConflicts(): Array<HasteConflict>;
+  getCacheKey(): string;
+  getWorker(): FileMapPluginWorker;
+}
+export default HastePlugin;

package/src/plugins/HastePlugin.js

@@ -14,11 +14,7 @@ var _getPlatformExtension = _interopRequireDefault(
 var _HasteConflictsError = require("./haste/HasteConflictsError");
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const EMPTY_OBJ = {};
 const EMPTY_MAP = new Map();
@@ -167,22 +163,22 @@ class HastePlugin {
       duplicates,
     );
   }
-  async bulkUpdate(delta) {
-    for (const [normalPath, maybeHasteId] of delta.removed) {
-      this.onRemovedFile(normalPath, maybeHasteId);
+  onChanged(delta) {
+    for (const [canonicalPath, maybeHasteId] of delta.removedFiles) {
+      this.#onRemovedFile(canonicalPath, maybeHasteId);
     }
-    for (const [normalPath, maybeHasteId] of delta.addedOrModified) {
-      this.onNewOrModifiedFile(normalPath, maybeHasteId);
+    for (const [canonicalPath, maybeHasteId] of delta.addedFiles) {
+      this.#onNewFile(canonicalPath, maybeHasteId);
     }
   }
-  onNewOrModifiedFile(relativeFilePath, id) {
+  #onNewFile(canonicalPath, id) {
     if (id == null) {
       return;
     }
     const module = [
-      relativeFilePath,
+      canonicalPath,
       this.#enableHastePackages &&
-      _path.default.basename(relativeFilePath) === "package.json"
+      _path.default.basename(canonicalPath) === "package.json"
         ? _constants.default.PACKAGE
         : _constants.default.MODULE,
     ];
@@ -252,12 +248,12 @@ class HastePlugin {
     }
     hasteMapItem[platform] = module;
   }
-  onRemovedFile(relativeFilePath, moduleName) {
+  #onRemovedFile(canonicalPath, moduleName) {
     if (moduleName == null) {
       return;
     }
     const platform =
-      (0, _getPlatformExtension.default)(relativeFilePath, this.#platforms) ||
+      (0, _getPlatformExtension.default)(canonicalPath, this.#platforms) ||
       _constants.default.GENERIC_PLATFORM;
     const hasteMapItem = this.#map.get(moduleName);
     if (hasteMapItem != null) {
@@ -268,7 +264,7 @@ class HastePlugin {
         this.#map.set(moduleName, hasteMapItem);
       }
     }
-    this.#recoverDuplicates(moduleName, relativeFilePath);
+    this.#recoverDuplicates(moduleName, canonicalPath);
   }
   assertValid() {
     if (!this.#failValidationOnConflicts) {

package/src/plugins/HastePlugin.js.flow

@@ -13,7 +13,6 @@ import type {
   Console,
   DuplicatesIndex,
   DuplicatesSet,
-  FileMapDelta,
   FileMapPlugin,
   FileMapPluginInitOptions,
   FileMapPluginWorker,
@@ -24,6 +23,7 @@ import type {
   HTypeValue,
   Path,
   PerfLogger,
+  ReadonlyFileSystemChanges,
 } from '../flow-types';
 
 import H from '../constants';
@@ -237,26 +237,26 @@ export default class HastePlugin
     );
   }
 
-  async bulkUpdate(delta: FileMapDelta<?string>): Promise<void> {
+  onChanged(delta: ReadonlyFileSystemChanges<?string>): void {
     // Process removals first so that moves aren't treated as duplicates.
-    for (const [normalPath, maybeHasteId] of delta.removed) {
-      this.onRemovedFile(normalPath, maybeHasteId);
+    for (const [canonicalPath, maybeHasteId] of delta.removedFiles) {
+      this.#onRemovedFile(canonicalPath, maybeHasteId);
     }
-    for (const [normalPath, maybeHasteId] of delta.addedOrModified) {
-      this.onNewOrModifiedFile(normalPath, maybeHasteId);
+    for (const [canonicalPath, maybeHasteId] of delta.addedFiles) {
+      this.#onNewFile(canonicalPath, maybeHasteId);
     }
   }
 
-  onNewOrModifiedFile(relativeFilePath: string, id: ?string) {
+  #onNewFile(canonicalPath: string, id: ?string) {
     if (id == null) {
       // Not a Haste module or package
       return;
     }
 
     const module: HasteMapItemMetadata = [
-      relativeFilePath,
+      canonicalPath,
       this.#enableHastePackages &&
-      path.basename(relativeFilePath) === 'package.json'
+      path.basename(canonicalPath) === 'package.json'
         ? H.PACKAGE
         : H.MODULE,
     ];
@@ -324,14 +324,14 @@ export default class HastePlugin
     hasteMapItem[platform] = module;
   }
 
-  onRemovedFile(relativeFilePath: string, moduleName: ?string) {
+  #onRemovedFile(canonicalPath: string, moduleName: ?string) {
     if (moduleName == null) {
       // Not a Haste module or package
       return;
     }
 
     const platform =
-      getPlatformExtension(relativeFilePath, this.#platforms) ||
+      getPlatformExtension(canonicalPath, this.#platforms) ||
       H.GENERIC_PLATFORM;
 
     const hasteMapItem = this.#map.get(moduleName);
@@ -344,7 +344,7 @@ export default class HastePlugin
       }
     }
 
-    this.#recoverDuplicates(moduleName, relativeFilePath);
+    this.#recoverDuplicates(moduleName, canonicalPath);
   }
 
   assertValid(): void {