metro-file-map 0.83.3 → 0.84.0

package/src/lib/TreeFS.js.flow

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict-local
+ * @format
  */
 
 import type {
@@ -42,6 +42,37 @@ type NormalizedSymlinkTarget = {
   startOfBasenameIdx: number,
 };
 
+type DeserializedSnapshotInput = {
+  rootDir: string,
+  fileSystemData: DirectoryNode,
+  processFile: ProcessFileFunction,
+};
+
+type TreeFSOptions = {
+  rootDir: Path,
+  files?: FileData,
+  processFile: ProcessFileFunction,
+};
+
+type MatchFilesOptions = Readonly<{
+  /* Filter relative paths against a pattern. */
+  filter?: ?RegExp,
+  /* `filter` is applied against absolute paths, vs rootDir-relative. (default: false) */
+  filterCompareAbsolute?: boolean,
+  /* `filter` is applied against posix-delimited paths, even on Windows. (default: false) */
+  filterComparePosix?: boolean,
+  /* Follow symlinks when enumerating paths. (default: false) */
+  follow?: boolean,
+  /* Should search for files recursively. (default: true) */
+  recursive?: boolean,
+  /* Match files under a given root, or null for all files */
+  rootDir?: ?Path,
+}>;
+
+type MetadataIteratorOptions = Readonly<{
+  includeSymlinks: boolean,
+  includeNodeModules: boolean,
+}>;
 /**
  * OVERVIEW:
  *
@@ -94,20 +125,13 @@ type NormalizedSymlinkTarget = {
 export default class TreeFS implements MutableFileSystem {
   +#cachedNormalSymlinkTargets: WeakMap<FileNode, NormalizedSymlinkTarget> =
     new WeakMap();
+  +#pathUtils: RootPathUtils;
+  +#processFile: ProcessFileFunction;
   +#rootDir: Path;
   #rootNode: DirectoryNode = new Map();
-  #pathUtils: RootPathUtils;
-  #processFile: ProcessFileFunction;
-
-  constructor({
-    rootDir,
-    files,
-    processFile,
-  }: {
-    rootDir: Path,
-    files?: FileData,
-    processFile: ProcessFileFunction,
-  }) {
+
+  constructor(opts: TreeFSOptions) {
+    const {rootDir, files, processFile} = opts;
     this.#rootDir = rootDir;
     this.#pathUtils = new RootPathUtils(rootDir);
     this.#processFile = processFile;
@@ -117,45 +141,21 @@ export default class TreeFS implements MutableFileSystem {
   }
 
   getSerializableSnapshot(): CacheData['fileSystemData'] {
-    return this._cloneTree(this.#rootNode);
+    return this.#cloneTree(this.#rootNode);
   }
 
-  static fromDeserializedSnapshot({
-    rootDir,
-    fileSystemData,
-    processFile,
-  }: {
-    rootDir: string,
-    fileSystemData: DirectoryNode,
-    processFile: ProcessFileFunction,
-  }): TreeFS {
-    const tfs = new TreeFS({rootDir, processFile});
+  static fromDeserializedSnapshot(args: DeserializedSnapshotInput): TreeFS {
+    const {rootDir, fileSystemData, processFile} = args;
+    const tfs = new TreeFS({processFile, rootDir});
     tfs.#rootNode = fileSystemData;
     return tfs;
   }
 
-  getModuleName(mixedPath: Path): ?string {
-    const fileMetadata = this._getFileData(mixedPath);
-    return (fileMetadata && fileMetadata[H.ID]) ?? null;
-  }
-
   getSize(mixedPath: Path): ?number {
-    const fileMetadata = this._getFileData(mixedPath);
+    const fileMetadata = this.#getFileData(mixedPath);
     return (fileMetadata && fileMetadata[H.SIZE]) ?? null;
   }
 
-  getDependencies(mixedPath: Path): ?Array<string> {
-    const fileMetadata = this._getFileData(mixedPath);
-
-    if (fileMetadata) {
-      return fileMetadata[H.DEPENDENCIES]
-        ? fileMetadata[H.DEPENDENCIES].split(H.DEPENDENCY_DELIM)
-        : [];
-    } else {
-      return null;
-    }
-  }
-
   getDifference(files: FileData): {
     changedFiles: FileData,
     removedFiles: Set<string>,
@@ -163,8 +163,8 @@ export default class TreeFS implements MutableFileSystem {
     const changedFiles: FileData = new Map(files);
     const removedFiles: Set<string> = new Set();
     for (const {canonicalPath, metadata} of this.metadataIterator({
-      includeSymlinks: true,
       includeNodeModules: true,
+      includeSymlinks: true,
     })) {
       const newMetadata = files.get(canonicalPath);
       if (newMetadata) {
@@ -201,15 +201,15 @@ export default class TreeFS implements MutableFileSystem {
   }
 
   getSha1(mixedPath: Path): ?string {
-    const fileMetadata = this._getFileData(mixedPath);
+    const fileMetadata = this.#getFileData(mixedPath);
     return (fileMetadata && fileMetadata[H.SHA1]) ?? null;
   }
 
   async getOrComputeSha1(
     mixedPath: Path,
   ): Promise<?{sha1: string, content?: Buffer}> {
-    const normalPath = this._normalizePath(mixedPath);
-    const result = this._lookupByNormalPath(normalPath, {
+    const normalPath = this.#normalizePath(mixedPath);
+    const result = this.#lookupByNormalPath(normalPath, {
       followLeaf: true,
     });
     if (!result.exists || isDirectory(result.node)) {
@@ -222,39 +222,38 @@ export default class TreeFS implements MutableFileSystem {
     if (existing != null && existing.length > 0) {
       return {sha1: existing};
     }
-    const absolutePath = this.#pathUtils.normalToAbsolute(canonicalPath);
 
     // Mutate the metadata we first retrieved. This may be orphaned or about
     // to be overwritten if the file changes while we are processing it -
     // by only mutating the original metadata, we don't risk caching a stale
     // SHA-1 after a change event.
-    const maybeContent = await this.#processFile(absolutePath, fileMetadata, {
+    const maybeContent = await this.#processFile(canonicalPath, fileMetadata, {
       computeSha1: true,
     });
     const sha1 = fileMetadata[H.SHA1];
     invariant(
       sha1 != null && sha1.length > 0,
       "File processing didn't populate a SHA-1 hash for %s",
-      absolutePath,
+      canonicalPath,
     );
 
     return maybeContent
       ? {
-          sha1,
           content: maybeContent,
+          sha1,
         }
       : {sha1};
   }
 
   exists(mixedPath: Path): boolean {
-    const result = this._getFileData(mixedPath);
+    const result = this.#getFileData(mixedPath);
     return result != null;
   }
 
   lookup(mixedPath: Path): LookupResult {
-    const normalPath = this._normalizePath(mixedPath);
+    const normalPath = this.#normalizePath(mixedPath);
     const links = new Set<string>();
-    const result = this._lookupByNormalPath(normalPath, {
+    const result = this.#lookupByNormalPath(normalPath, {
       collectLinkPaths: links,
       followLeaf: true,
     });
@@ -267,33 +266,31 @@ export default class TreeFS implements MutableFileSystem {
       };
     }
     const {canonicalPath, node} = result;
-    const type = isDirectory(node) ? 'd' : isRegularFile(node) ? 'f' : 'l';
+    const realPath = this.#pathUtils.normalToAbsolute(canonicalPath);
+    if (isDirectory(node)) {
+      return {exists: true, links, realPath, type: 'd'};
+    }
     invariant(
-      type !== 'l',
+      isRegularFile(node),
       'lookup follows symlinks, so should never return one (%s -> %s)',
       mixedPath,
       canonicalPath,
     );
-    return {
-      exists: true,
-      links,
-      realPath: this.#pathUtils.normalToAbsolute(canonicalPath),
-      type,
-    };
+    return {exists: true, links, realPath, type: 'f', metadata: node};
   }
 
   getAllFiles(): Array<Path> {
     return Array.from(
       this.metadataIterator({
-        includeSymlinks: false,
         includeNodeModules: true,
+        includeSymlinks: false,
       }),
       ({canonicalPath}) => this.#pathUtils.normalToAbsolute(canonicalPath),
     );
   }
 
   linkStats(mixedPath: Path): ?FileStats {
-    const fileMetadata = this._getFileData(mixedPath, {followLeaf: false});
+    const fileMetadata = this.#getFileData(mixedPath, {followLeaf: false});
     if (fileMetadata == null) {
       return null;
     }
@@ -310,29 +307,17 @@ export default class TreeFS implements MutableFileSystem {
    * The query matches against normalized paths which start with `./`,
    * for example: `a/b.js` -> `./a/b.js`
    */
-  *matchFiles({
-    filter = null,
-    filterCompareAbsolute = false,
-    filterComparePosix = false,
-    follow = false,
-    recursive = true,
-    rootDir = null,
-  }: $ReadOnly<{
-    /* Filter relative paths against a pattern. */
-    filter?: ?RegExp,
-    /* `filter` is applied against absolute paths, vs rootDir-relative. (default: false) */
-    filterCompareAbsolute?: boolean,
-    /* `filter` is applied against posix-delimited paths, even on Windows. (default: false) */
-    filterComparePosix?: boolean,
-    /* Follow symlinks when enumerating paths. (default: false) */
-    follow?: boolean,
-    /* Should search for files recursively. (default: true) */
-    recursive?: boolean,
-    /* Match files under a given root, or null for all files */
-    rootDir?: ?Path,
-  }>): Iterable<Path> {
-    const normalRoot = rootDir == null ? '' : this._normalizePath(rootDir);
-    const contextRootResult = this._lookupByNormalPath(normalRoot);
+  *matchFiles(opts: MatchFilesOptions): Iterable<Path> {
+    const {
+      filter = null,
+      filterCompareAbsolute = false,
+      filterComparePosix = false,
+      follow = false,
+      recursive = true,
+      rootDir = null,
+    } = opts;
+    const normalRoot = rootDir == null ? '' : this.#normalizePath(rootDir);
+    const contextRootResult = this.#lookupByNormalPath(normalRoot);
     if (!contextRootResult.exists) {
       return;
     }
@@ -357,7 +342,7 @@ export default class TreeFS implements MutableFileSystem {
         ? contextRootAbsolutePath.replaceAll(path.sep, '/')
         : contextRootAbsolutePath;
 
-    for (const relativePathForComparison of this._pathIterator(
+    for (const relativePathForComparison of this.#pathIterator(
       contextRoot,
       contextRootParent,
       ancestorOfRootIdx,
@@ -394,10 +379,10 @@ export default class TreeFS implements MutableFileSystem {
   }
 
   addOrModify(mixedPath: Path, metadata: FileMetadata): void {
-    const normalPath = this._normalizePath(mixedPath);
+    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), {
+    const parentDirNode = this.#lookupByNormalPath(path.dirname(normalPath), {
       makeDirectories: true,
     });
     if (!parentDirNode.exists) {
@@ -406,7 +391,7 @@ export default class TreeFS implements MutableFileSystem {
       );
     }
     // Normalize the resulting path to account for the parent node being root.
-    const canonicalPath = this._normalizePath(
+    const canonicalPath = this.#normalizePath(
       parentDirNode.canonicalPath + path.sep + path.basename(normalPath),
     );
     this.bulkAddOrModify(new Map([[canonicalPath, metadata]]));
@@ -427,7 +412,7 @@ export default class TreeFS implements MutableFileSystem {
         lastSepIdx === -1 ? normalPath : normalPath.slice(lastSepIdx + 1);
 
       if (directoryNode == null || dirname !== lastDir) {
-        const lookup = this._lookupByNormalPath(dirname, {
+        const lookup = this.#lookupByNormalPath(dirname, {
           followLeaf: false,
           makeDirectories: true,
         });
@@ -453,8 +438,8 @@ export default class TreeFS implements MutableFileSystem {
   }
 
   remove(mixedPath: Path): ?FileMetadata {
-    const normalPath = this._normalizePath(mixedPath);
-    const result = this._lookupByNormalPath(normalPath, {followLeaf: false});
+    const normalPath = this.#normalizePath(mixedPath);
+    const result = this.#lookupByNormalPath(normalPath, {followLeaf: false});
     if (!result.exists) {
       return null;
     }
@@ -494,7 +479,7 @@ export default class TreeFS implements MutableFileSystem {
    * Note that this code is extremely hot during resolution, being the most
    * expensive part of a file existence check. Benchmark any modifications!
    */
-  _lookupByNormalPath(
+  #lookupByNormalPath(
     requestedNormalPath: string,
     opts: {
       collectAncestors?: Array<{
@@ -654,7 +639,7 @@ export default class TreeFS implements MutableFileSystem {
         }
 
         // Symlink in a directory path
-        const normalSymlinkTarget = this._resolveSymlinkTargetToNormalPath(
+        const normalSymlinkTarget = this.#resolveSymlinkTargetToNormalPath(
           segmentNode,
           currentPath,
         );
@@ -801,9 +786,9 @@ export default class TreeFS implements MutableFileSystem {
       normalPath: string,
       segmentName: string,
     }> = [];
-    const normalPath = this._normalizePath(mixedStartPath);
+    const normalPath = this.#normalizePath(mixedStartPath);
     const invalidatedBy = opts.invalidatedBy;
-    const closestLookup = this._lookupByNormalPath(normalPath, {
+    const closestLookup = this.#lookupByNormalPath(normalPath, {
       collectAncestors: ancestorsOfInput,
       collectLinkPaths: invalidatedBy,
     });
@@ -976,7 +961,7 @@ export default class TreeFS implements MutableFileSystem {
       pathIdx: number,
     },
   ): ?string {
-    const lookupResult = this._lookupByNormalPath(
+    const lookupResult = this.#lookupByNormalPath(
       this.#pathUtils.joinNormalToRelative(normalCandidatePath, subpath)
         .normalPath,
       {
@@ -1001,22 +986,17 @@ export default class TreeFS implements MutableFileSystem {
     return null;
   }
 
-  *metadataIterator(
-    opts: $ReadOnly<{
-      includeSymlinks: boolean,
-      includeNodeModules: boolean,
-    }>,
-  ): Iterable<{
+  *metadataIterator(opts: MetadataIteratorOptions): Iterator<{
     baseName: string,
     canonicalPath: string,
     metadata: FileMetadata,
   }> {
-    yield* this._metadataIterator(this.#rootNode, opts);
+    yield* this.#metadataIterator(this.#rootNode, opts);
   }
 
-  *_metadataIterator(
+  *#metadataIterator(
     rootNode: DirectoryNode,
-    opts: $ReadOnly<{includeSymlinks: boolean, includeNodeModules: boolean}>,
+    opts: Readonly<{includeSymlinks: boolean, includeNodeModules: boolean}>,
     prefix: string = '',
   ): Iterable<{
     baseName: string,
@@ -1033,14 +1013,14 @@ export default class TreeFS implements MutableFileSystem {
       }
       const prefixedName = prefix === '' ? name : prefix + path.sep + name;
       if (isDirectory(node)) {
-        yield* this._metadataIterator(node, opts, prefixedName);
+        yield* this.#metadataIterator(node, opts, prefixedName);
       } else if (isRegularFile(node) || opts.includeSymlinks) {
-        yield {canonicalPath: prefixedName, metadata: node, baseName: name};
+        yield {baseName: name, canonicalPath: prefixedName, metadata: node};
       }
     }
   }
 
-  _normalizePath(relativeOrAbsolutePath: Path): string {
+  #normalizePath(relativeOrAbsolutePath: Path): string {
     return path.isAbsolute(relativeOrAbsolutePath)
       ? this.#pathUtils.absoluteToNormal(relativeOrAbsolutePath)
       : this.#pathUtils.relativeToNormal(relativeOrAbsolutePath);
@@ -1052,10 +1032,10 @@ export default class TreeFS implements MutableFileSystem {
     ancestorOfRootIdx: ?number,
   ): Iterator<[string, MixedNode]> {
     if (ancestorOfRootIdx != null && ancestorOfRootIdx > 0 && parent) {
-      yield ([
+      yield [
         this.#pathUtils.getBasenameOfNthAncestor(ancestorOfRootIdx - 1),
         parent,
-      ]: [string, MixedNode]);
+      ] as [string, MixedNode];
     }
     yield* node.entries();
   }
@@ -1064,11 +1044,11 @@ export default class TreeFS implements MutableFileSystem {
    * Enumerate paths under a given node, including symlinks and through
    * symlinks (if `follow` is enabled).
    */
-  *_pathIterator(
+  *#pathIterator(
     iterationRootNode: DirectoryNode,
     iterationRootParentNode: ?DirectoryNode,
     ancestorOfRootIdx: ?number,
-    opts: $ReadOnly<{
+    opts: Readonly<{
       alwaysYieldPosix: boolean,
       canonicalPathOfRoot: string,
       follow: boolean,
@@ -1076,7 +1056,7 @@ export default class TreeFS implements MutableFileSystem {
       subtreeOnly: boolean,
     }>,
     pathPrefix: string = '',
-    followedLinks: $ReadOnlySet<FileMetadata> = new Set(),
+    followedLinks: ReadonlySet<FileMetadata> = new Set(),
   ): Iterable<Path> {
     const pathSep = opts.alwaysYieldPosix ? '/' : path.sep;
     const prefixWithSep = pathPrefix === '' ? pathPrefix : pathPrefix + pathSep;
@@ -1114,7 +1094,7 @@ export default class TreeFS implements MutableFileSystem {
           // are at /foo/bar/baz where baz -> '..' - that should resolve to
           // /foo, not /foo/bar). We *can* use _lookupByNormalPath to walk to
           // the canonical symlink, and then to its target.
-          const resolved = this._lookupByNormalPath(normalPathOfSymlink, {
+          const resolved = this.#lookupByNormalPath(normalPathOfSymlink, {
             followLeaf: true,
           });
           if (!resolved.exists) {
@@ -1132,7 +1112,7 @@ export default class TreeFS implements MutableFileSystem {
           ) {
             // Symlink points to a directory - iterate over its contents using
             // the path where we found the symlink as a prefix.
-            yield* this._pathIterator(
+            yield* this.#pathIterator(
               target,
               resolved.parentNode,
               resolved.ancestorOfRootIdx,
@@ -1143,7 +1123,7 @@ export default class TreeFS implements MutableFileSystem {
           }
         }
       } else if (opts.recursive) {
-        yield* this._pathIterator(
+        yield* this.#pathIterator(
           node,
           iterationRootParentNode,
           ancestorOfRootIdx != null && ancestorOfRootIdx > 0
@@ -1157,7 +1137,7 @@ export default class TreeFS implements MutableFileSystem {
     }
   }
 
-  _resolveSymlinkTargetToNormalPath(
+  #resolveSymlinkTargetToNormalPath(
     symlinkNode: FileMetadata,
     canonicalPathOfSymlink: Path,
   ): NormalizedSymlinkTarget {
@@ -1191,12 +1171,12 @@ export default class TreeFS implements MutableFileSystem {
     return result;
   }
 
-  _getFileData(
+  #getFileData(
     filePath: Path,
     opts: {followLeaf: boolean} = {followLeaf: true},
   ): ?FileMetadata {
-    const normalPath = this._normalizePath(filePath);
-    const result = this._lookupByNormalPath(normalPath, {
+    const normalPath = this.#normalizePath(filePath);
+    const result = this.#lookupByNormalPath(normalPath, {
       followLeaf: opts.followLeaf,
     });
     if (!result.exists || isDirectory(result.node)) {
@@ -1205,11 +1185,11 @@ export default class TreeFS implements MutableFileSystem {
     return result.node;
   }
 
-  _cloneTree(root: DirectoryNode): DirectoryNode {
+  #cloneTree(root: DirectoryNode): DirectoryNode {
     const clone: DirectoryNode = new Map();
     for (const [name, node] of root) {
       if (isDirectory(node)) {
-        clone.set(name, this._cloneTree(node));
+        clone.set(name, this.#cloneTree(node));
       } else {
         clone.set(name, [...node]);
       }

package/src/lib/checkWatchmanCapabilities.js.flow

@@ -4,19 +4,19 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict
+ * @format
  */
 
 import {execFile} from 'child_process';
 import {promisify} from 'util';
 
 export default async function checkWatchmanCapabilities(
-  requiredCapabilities: $ReadOnlyArray<string>,
+  requiredCapabilities: ReadonlyArray<string>,
 ): Promise<{version: string}> {
   const execFilePromise: (
     cmd: string,
-    args: $ReadOnlyArray<string>,
+    args: ReadonlyArray<string>,
   ) => Promise<{stdout: string}> = promisify(execFile);
 
   let rawResponse;
@@ -37,7 +37,7 @@ export default async function checkWatchmanCapabilities(
 
   let parsedResponse;
   try {
-    parsedResponse = (JSON.parse(rawResponse): mixed);
+    parsedResponse = JSON.parse(rawResponse) as unknown;
   } catch {
     throw new Error(
       'Failed to parse response from `watchman list-capabilities`',

package/src/lib/dependencyExtractor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ *
+ * @format
+ */
+
+declare const dependencyExtractor: {
+  extract: (code: string) => Set<string>;
+};
+
+export = dependencyExtractor;

package/src/lib/normalizePathSeparatorsToPosix.js

@@ -5,28 +5,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var path = _interopRequireWildcard(require("path"));
-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]);
+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);
 }
 let normalizePathSeparatorsToPosix;
 if (path.sep === "/") {

package/src/lib/normalizePathSeparatorsToPosix.js.flow

@@ -4,13 +4,13 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict
+ * @format
  */
 
 import * as path from 'path';
 
-let normalizePathSeparatorsToPosix: (string: string) => string;
+let normalizePathSeparatorsToPosix;
 if (path.sep === '/') {
   normalizePathSeparatorsToPosix = (filePath: string): string => filePath;
 } else {
@@ -18,4 +18,4 @@ if (path.sep === '/') {
     filePath.replace(/\\/g, '/');
 }
 
-export default normalizePathSeparatorsToPosix;
+export default normalizePathSeparatorsToPosix as (filePath: string) => string;