metro-file-map 0.84.2 → 0.84.4

package/src/lib/FileSystemChangeAggregator.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.FileSystemChangeAggregator = void 0;
+class FileSystemChangeAggregator {
+  #addedDirectories = new Set();
+  #removedDirectories = new Set();
+  #addedFiles = new Map();
+  #modifiedFiles = new Map();
+  #removedFiles = new Map();
+  #initialMetadata = new Map();
+  directoryAdded(canonicalPath) {
+    if (!this.#removedDirectories.delete(canonicalPath)) {
+      this.#addedDirectories.add(canonicalPath);
+    }
+  }
+  directoryRemoved(canonicalPath) {
+    if (!this.#addedDirectories.delete(canonicalPath)) {
+      this.#removedDirectories.add(canonicalPath);
+    }
+  }
+  fileAdded(canonicalPath, data) {
+    if (this.#removedFiles.delete(canonicalPath)) {
+      this.#modifiedFiles.set(canonicalPath, data);
+    } else {
+      this.#addedFiles.set(canonicalPath, data);
+    }
+  }
+  fileModified(canonicalPath, oldData, newData) {
+    if (this.#addedFiles.has(canonicalPath)) {
+      this.#addedFiles.set(canonicalPath, newData);
+    } else {
+      if (!this.#initialMetadata.has(canonicalPath)) {
+        this.#initialMetadata.set(canonicalPath, oldData);
+      }
+      this.#modifiedFiles.set(canonicalPath, newData);
+    }
+  }
+  fileRemoved(canonicalPath, data) {
+    if (!this.#addedFiles.delete(canonicalPath)) {
+      let initialData = this.#initialMetadata.get(canonicalPath);
+      if (!initialData) {
+        initialData = data;
+        this.#initialMetadata.set(canonicalPath, initialData);
+      }
+      this.#modifiedFiles.delete(canonicalPath);
+      this.#removedFiles.set(canonicalPath, initialData);
+    }
+  }
+  getSize() {
+    return (
+      this.#addedDirectories.size +
+      this.#removedDirectories.size +
+      this.#addedFiles.size +
+      this.#modifiedFiles.size +
+      this.#removedFiles.size
+    );
+  }
+  getView() {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: this.#addedFiles,
+      modifiedFiles: this.#modifiedFiles,
+      removedFiles: this.#removedFiles,
+    };
+  }
+  getMappedView(metadataMapFn) {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: mapIterable(this.#addedFiles, metadataMapFn),
+      modifiedFiles: mapIterable(this.#modifiedFiles, metadataMapFn),
+      removedFiles: mapIterable(this.#removedFiles, metadataMapFn),
+    };
+  }
+}
+exports.FileSystemChangeAggregator = FileSystemChangeAggregator;
+function mapIterable(map, metadataMapFn) {
+  return {
+    *[Symbol.iterator]() {
+      for (const [path, metadata] of map) {
+        yield [path, metadataMapFn(metadata)];
+      }
+    },
+  };
+}

package/src/lib/FileSystemChangeAggregator.js.flow

@@ -0,0 +1,143 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import type {
+  CanonicalPath,
+  FileMetadata,
+  FileSystemListener,
+  ReadonlyFileSystemChanges,
+} from '../flow-types';
+
+export class FileSystemChangeAggregator implements FileSystemListener {
+  // Mutually exclusive with removedDirectories
+  +#addedDirectories: Set<CanonicalPath> = new Set();
+  // Mutually exclusive with addedDirectories
+  +#removedDirectories: Set<CanonicalPath> = new Set();
+
+  // Mutually exclusive with modified and removed files
+  +#addedFiles: Map<CanonicalPath, FileMetadata> = new Map();
+  // Mutually exclusive with added and removed files
+  +#modifiedFiles: Map<CanonicalPath, FileMetadata> = new Map();
+  // Mutually exclusive with added and modified files
+  +#removedFiles: Map<CanonicalPath, FileMetadata> = new Map();
+
+  // Removed files must be paired with the file's metadata the last time it was
+  // observable by consumers - ie, immediately *before* this batch. To report
+  // this accurately with minimal overhead, we'll note the current metadata of
+  // a file the first time it is modified or removed within a batch. If it is
+  // re-added, modified and removed again, we still have the initial metadata.
+  // This is particularly important if, say, a regular file is replaced by a
+  // symlink, or vice-versa.
+  +#initialMetadata: Map<CanonicalPath, FileMetadata> = new Map();
+
+  directoryAdded(canonicalPath: CanonicalPath): void {
+    // Only add to newDirectories if this directory wasn't previously removed
+    // (i.e., it's truly new). If it was removed and re-added, the net effect
+    // is no directory change.
+    if (!this.#removedDirectories.delete(canonicalPath)) {
+      this.#addedDirectories.add(canonicalPath);
+    }
+  }
+
+  directoryRemoved(canonicalPath: CanonicalPath): void {
+    if (!this.#addedDirectories.delete(canonicalPath)) {
+      this.#removedDirectories.add(canonicalPath);
+    }
+  }
+
+  fileAdded(canonicalPath: CanonicalPath, data: FileMetadata): void {
+    if (this.#removedFiles.delete(canonicalPath)) {
+      // File was removed then re-added in the same batch - treat as modification
+      this.#modifiedFiles.set(canonicalPath, data);
+    } else {
+      // New file
+      this.#addedFiles.set(canonicalPath, data);
+    }
+  }
+
+  fileModified(
+    canonicalPath: CanonicalPath,
+    oldData: FileMetadata,
+    newData: FileMetadata,
+  ): void {
+    if (this.#addedFiles.has(canonicalPath)) {
+      // File did not exist before this batch. Further modification only
+      // updates metadata
+      this.#addedFiles.set(canonicalPath, newData);
+    } else {
+      if (!this.#initialMetadata.has(canonicalPath)) {
+        this.#initialMetadata.set(canonicalPath, oldData);
+      }
+      this.#modifiedFiles.set(canonicalPath, newData);
+    }
+  }
+
+  fileRemoved(canonicalPath: CanonicalPath, data: FileMetadata): void {
+    // Check if this file was added in the same batch
+    if (!this.#addedFiles.delete(canonicalPath)) {
+      let initialData = this.#initialMetadata.get(canonicalPath);
+      if (!initialData) {
+        initialData = data;
+        this.#initialMetadata.set(canonicalPath, initialData);
+      }
+
+      // File was not added in this batch, so add to removed with last metadata
+      this.#modifiedFiles.delete(canonicalPath);
+      this.#removedFiles.set(canonicalPath, initialData);
+    }
+    // else: File was added then removed in the same batch - no net change
+  }
+
+  getSize(): number {
+    return (
+      this.#addedDirectories.size +
+      this.#removedDirectories.size +
+      this.#addedFiles.size +
+      this.#modifiedFiles.size +
+      this.#removedFiles.size
+    );
+  }
+
+  getView(): ReadonlyFileSystemChanges<FileMetadata> {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: this.#addedFiles,
+      modifiedFiles: this.#modifiedFiles,
+      removedFiles: this.#removedFiles,
+    };
+  }
+
+  getMappedView<T>(
+    metadataMapFn: (metadata: FileMetadata) => T,
+  ): ReadonlyFileSystemChanges<T> {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: mapIterable(this.#addedFiles, metadataMapFn),
+      modifiedFiles: mapIterable(this.#modifiedFiles, metadataMapFn),
+      removedFiles: mapIterable(this.#removedFiles, metadataMapFn),
+    };
+  }
+}
+
+function mapIterable<T>(
+  map: Map<CanonicalPath, FileMetadata>,
+  metadataMapFn: (metadata: FileMetadata) => T,
+): Iterable<Readonly<[CanonicalPath, T]>> {
+  return {
+    *[Symbol.iterator](): Iterator<Readonly<[CanonicalPath, T]>> {
+      for (const [path, metadata] of map) {
+        yield [path, metadataMapFn(metadata)];
+      }
+    },
+  };
+}

package/src/lib/TreeFS.d.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @noformat
- * @generated SignedSource<<1f36861cea798d8cc2a5dc61293ecb1b>>
+ * @generated SignedSource<<65a3c4140d459a56b8c949e52b32ea1b>>
  *
  * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
  * Original file: packages/metro-file-map/src/lib/TreeFS.js
@@ -19,6 +19,7 @@ import type {
   FileData,
   FileMetadata,
   FileStats,
+  FileSystemListener,
   LookupResult,
   MutableFileSystem,
   Path,
@@ -104,10 +105,10 @@ declare class TreeFS implements MutableFileSystem {
   getSerializableSnapshot(): CacheData['fileSystemData'];
   static fromDeserializedSnapshot(args: DeserializedSnapshotInput): TreeFS;
   getSize(mixedPath: Path): null | undefined | number;
-  getDifference(files: FileData): {
-    changedFiles: FileData;
-    removedFiles: Set<string>;
-  };
+  getDifference(
+    files: FileData,
+    options?: Readonly<{subpath?: string}>,
+  ): {changedFiles: FileData; removedFiles: Set<string>};
   getSha1(mixedPath: Path): null | undefined | string;
   getOrComputeSha1(
     mixedPath: Path,
@@ -122,9 +123,16 @@ declare class TreeFS implements MutableFileSystem {
    * for example: `a/b.js` -> `./a/b.js`
    */
   matchFiles(opts: MatchFilesOptions): Iterable<Path>;
-  addOrModify(mixedPath: Path, metadata: FileMetadata): void;
-  bulkAddOrModify(addedOrModifiedFiles: FileData): void;
-  remove(mixedPath: Path): null | undefined | FileMetadata;
+  addOrModify(
+    mixedPath: Path,
+    metadata: FileMetadata,
+    changeListener?: FileSystemListener,
+  ): void;
+  bulkAddOrModify(
+    addedOrModifiedFiles: FileData,
+    changeListener?: FileSystemListener,
+  ): void;
+  remove(mixedPath: Path, changeListener?: FileSystemListener): void;
   /**
    * Given a start path (which need not exist), a subpath and type, and
    * optionally a 'breakOnSegment', performs the following:

package/src/lib/TreeFS.js

@@ -48,13 +48,33 @@ class TreeFS {
     const fileMetadata = this.#getFileData(mixedPath);
     return (fileMetadata && fileMetadata[_constants.default.SIZE]) ?? null;
   }
-  getDifference(files) {
+  getDifference(files, options) {
     const changedFiles = new Map(files);
     const removedFiles = new Set();
-    for (const { canonicalPath, metadata } of this.metadataIterator({
-      includeNodeModules: true,
-      includeSymlinks: true,
-    })) {
+    const subpath = options?.subpath;
+    let rootNode = this.#rootNode;
+    let prefix = "";
+    if (subpath != null && subpath !== "") {
+      const lookupResult = this.#lookupByNormalPath(subpath, {
+        followLeaf: true,
+      });
+      if (!lookupResult.exists || !isDirectory(lookupResult.node)) {
+        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)) {
@@ -253,11 +273,12 @@ class TreeFS {
       }
     }
   }
-  addOrModify(mixedPath, metadata) {
+  addOrModify(mixedPath, metadata, changeListener) {
     const normalPath = this.#normalizePath(mixedPath);
     const parentDirNode = this.#lookupByNormalPath(
       _path.default.dirname(normalPath),
       {
+        changeListener,
         makeDirectories: true,
       },
     );
@@ -271,9 +292,9 @@ class TreeFS {
         _path.default.sep +
         _path.default.basename(normalPath),
     );
-    this.bulkAddOrModify(new Map([[canonicalPath, metadata]]));
+    this.bulkAddOrModify(new Map([[canonicalPath, metadata]]), changeListener);
   }
-  bulkAddOrModify(addedOrModifiedFiles) {
+  bulkAddOrModify(addedOrModifiedFiles, changeListener) {
     let lastDir;
     let directoryNode;
     for (const [normalPath, metadata] of addedOrModifiedFiles) {
@@ -283,6 +304,7 @@ class TreeFS {
         lastSepIdx === -1 ? normalPath : normalPath.slice(lastSepIdx + 1);
       if (directoryNode == null || dirname !== lastDir) {
         const lookup = this.#lookupByNormalPath(dirname, {
+          changeListener,
           followLeaf: false,
           makeDirectories: true,
         });
@@ -301,30 +323,53 @@ class TreeFS {
         lastDir = dirname;
         directoryNode = lookup.node;
       }
+      if (changeListener != null) {
+        const existingNode = directoryNode.get(basename);
+        if (existingNode != null) {
+          (0, _invariant.default)(
+            !isDirectory(existingNode),
+            "Detected addition or modification of file %s, but it is tracked as a non-empty directory",
+            normalPath,
+          );
+          changeListener.fileModified(normalPath, existingNode, metadata);
+        } else {
+          changeListener.fileAdded(normalPath, metadata);
+        }
+      }
       directoryNode.set(basename, metadata);
     }
   }
-  remove(mixedPath) {
+  remove(mixedPath, changeListener) {
     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.default.sep + basename,
+          changeListener,
+        );
+      }
+      return;
     }
     if (parentNode != null) {
+      if (changeListener != null) {
+        if (isDirectory(node)) {
+          changeListener.directoryRemoved(canonicalPath);
+        } else {
+          changeListener.fileRemoved(canonicalPath, node);
+        }
+      }
       parentNode.delete(_path.default.basename(canonicalPath));
       if (parentNode.size === 0 && parentNode !== this.#rootNode) {
-        this.remove(_path.default.dirname(canonicalPath));
+        this.remove(_path.default.dirname(canonicalPath), changeListener);
       }
     }
-    return isDirectory(node) ? null : node;
   }
   #lookupByNormalPath(
     requestedNormalPath,
@@ -338,7 +383,7 @@ class TreeFS {
     let fromIdx = opts.start?.pathIdx ?? 0;
     let parentNode = opts.start?.node ?? this.#rootNode;
     let ancestorOfRootIdx = opts.start?.ancestorOfRootIdx ?? 0;
-    const collectAncestors = opts.collectAncestors;
+    const { collectAncestors, changeListener } = opts;
     let unseenPathFromIdx = 0;
     while (targetNormalPath.length > fromIdx) {
       const nextSepIdx = targetNormalPath.indexOf(_path.default.sep, fromIdx);
@@ -369,6 +414,12 @@ class TreeFS {
         }
         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/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);
         }
       }