metro-file-map 0.83.3 → 0.84.0

package/src/lib/TreeFS.js

@@ -19,11 +19,12 @@ function isRegularFile(node) {
 }
 class TreeFS {
   #cachedNormalSymlinkTargets = new WeakMap();
-  #rootDir;
-  #rootNode = new Map();
   #pathUtils;
   #processFile;
-  constructor({ rootDir, files, processFile }) {
+  #rootDir;
+  #rootNode = new Map();
+  constructor(opts) {
+    const { rootDir, files, processFile } = opts;
     this.#rootDir = rootDir;
     this.#pathUtils = new _RootPathUtils.RootPathUtils(rootDir);
     this.#processFile = processFile;
@@ -32,42 +33,27 @@ class TreeFS {
     }
   }
   getSerializableSnapshot() {
-    return this._cloneTree(this.#rootNode);
+    return this.#cloneTree(this.#rootNode);
   }
-  static fromDeserializedSnapshot({ rootDir, fileSystemData, processFile }) {
+  static fromDeserializedSnapshot(args) {
+    const { rootDir, fileSystemData, processFile } = args;
     const tfs = new TreeFS({
-      rootDir,
       processFile,
+      rootDir,
     });
     tfs.#rootNode = fileSystemData;
     return tfs;
   }
-  getModuleName(mixedPath) {
-    const fileMetadata = this._getFileData(mixedPath);
-    return (fileMetadata && fileMetadata[_constants.default.ID]) ?? null;
-  }
   getSize(mixedPath) {
-    const fileMetadata = this._getFileData(mixedPath);
+    const fileMetadata = this.#getFileData(mixedPath);
     return (fileMetadata && fileMetadata[_constants.default.SIZE]) ?? null;
   }
-  getDependencies(mixedPath) {
-    const fileMetadata = this._getFileData(mixedPath);
-    if (fileMetadata) {
-      return fileMetadata[_constants.default.DEPENDENCIES]
-        ? fileMetadata[_constants.default.DEPENDENCIES].split(
-            _constants.default.DEPENDENCY_DELIM,
-          )
-        : [];
-    } else {
-      return null;
-    }
-  }
   getDifference(files) {
     const changedFiles = new Map(files);
     const removedFiles = new Set();
     for (const { canonicalPath, metadata } of this.metadataIterator({
-      includeSymlinks: true,
       includeNodeModules: true,
+      includeSymlinks: true,
     })) {
       const newMetadata = files.get(canonicalPath);
       if (newMetadata) {
@@ -102,12 +88,12 @@ class TreeFS {
     };
   }
   getSha1(mixedPath) {
-    const fileMetadata = this._getFileData(mixedPath);
+    const fileMetadata = this.#getFileData(mixedPath);
     return (fileMetadata && fileMetadata[_constants.default.SHA1]) ?? null;
   }
   async getOrComputeSha1(mixedPath) {
-    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)) {
@@ -120,33 +106,32 @@ class TreeFS {
         sha1: existing,
       };
     }
-    const absolutePath = this.#pathUtils.normalToAbsolute(canonicalPath);
-    const maybeContent = await this.#processFile(absolutePath, fileMetadata, {
+    const maybeContent = await this.#processFile(canonicalPath, fileMetadata, {
       computeSha1: true,
     });
     const sha1 = fileMetadata[_constants.default.SHA1];
     (0, _invariant.default)(
       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) {
-    const result = this._getFileData(mixedPath);
+    const result = this.#getFileData(mixedPath);
     return result != null;
   }
   lookup(mixedPath) {
-    const normalPath = this._normalizePath(mixedPath);
+    const normalPath = this.#normalizePath(mixedPath);
     const links = new Set();
-    const result = this._lookupByNormalPath(normalPath, {
+    const result = this.#lookupByNormalPath(normalPath, {
       collectLinkPaths: links,
       followLeaf: true,
     });
@@ -159,9 +144,17 @@ class TreeFS {
       };
     }
     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",
+      };
+    }
     (0, _invariant.default)(
-      type !== "l",
+      isRegularFile(node),
       "lookup follows symlinks, so should never return one (%s -> %s)",
       mixedPath,
       canonicalPath,
@@ -169,21 +162,22 @@ class TreeFS {
     return {
       exists: true,
       links,
-      realPath: this.#pathUtils.normalToAbsolute(canonicalPath),
-      type,
+      realPath,
+      type: "f",
+      metadata: node,
     };
   }
   getAllFiles() {
     return Array.from(
       this.metadataIterator({
-        includeSymlinks: false,
         includeNodeModules: true,
+        includeSymlinks: false,
       }),
       ({ canonicalPath }) => this.#pathUtils.normalToAbsolute(canonicalPath),
     );
   }
   linkStats(mixedPath) {
-    const fileMetadata = this._getFileData(mixedPath, {
+    const fileMetadata = this.#getFileData(mixedPath, {
       followLeaf: false,
     });
     if (fileMetadata == null) {
@@ -196,16 +190,17 @@ class TreeFS {
       size: fileMetadata[_constants.default.SIZE],
     };
   }
-  *matchFiles({
-    filter = null,
-    filterCompareAbsolute = false,
-    filterComparePosix = false,
-    follow = false,
-    recursive = true,
-    rootDir = null,
-  }) {
-    const normalRoot = rootDir == null ? "" : this._normalizePath(rootDir);
-    const contextRootResult = this._lookupByNormalPath(normalRoot);
+  *matchFiles(opts) {
+    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;
     }
@@ -227,7 +222,7 @@ class TreeFS {
       filterComparePosix && _path.default.sep !== "/"
         ? contextRootAbsolutePath.replaceAll(_path.default.sep, "/")
         : contextRootAbsolutePath;
-    for (const relativePathForComparison of this._pathIterator(
+    for (const relativePathForComparison of this.#pathIterator(
       contextRoot,
       contextRootParent,
       ancestorOfRootIdx,
@@ -259,8 +254,8 @@ class TreeFS {
     }
   }
   addOrModify(mixedPath, metadata) {
-    const normalPath = this._normalizePath(mixedPath);
-    const parentDirNode = this._lookupByNormalPath(
+    const normalPath = this.#normalizePath(mixedPath);
+    const parentDirNode = this.#lookupByNormalPath(
       _path.default.dirname(normalPath),
       {
         makeDirectories: true,
@@ -271,7 +266,7 @@ class TreeFS {
         `TreeFS: Failed to make parent directory entry for ${mixedPath}`,
       );
     }
-    const canonicalPath = this._normalizePath(
+    const canonicalPath = this.#normalizePath(
       parentDirNode.canonicalPath +
         _path.default.sep +
         _path.default.basename(normalPath),
@@ -287,7 +282,7 @@ class TreeFS {
       const basename =
         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,
         });
@@ -310,8 +305,8 @@ class TreeFS {
     }
   }
   remove(mixedPath) {
-    const normalPath = this._normalizePath(mixedPath);
-    const result = this._lookupByNormalPath(normalPath, {
+    const normalPath = this.#normalizePath(mixedPath);
+    const result = this.#lookupByNormalPath(normalPath, {
       followLeaf: false,
     });
     if (!result.exists) {
@@ -331,7 +326,7 @@ class TreeFS {
     }
     return isDirectory(node) ? null : node;
   }
-  _lookupByNormalPath(
+  #lookupByNormalPath(
     requestedNormalPath,
     opts = {
       followLeaf: true,
@@ -419,7 +414,7 @@ class TreeFS {
             missingSegmentName: segmentName,
           };
         }
-        const normalSymlinkTarget = this._resolveSymlinkTargetToNormalPath(
+        const normalSymlinkTarget = this.#resolveSymlinkTargetToNormalPath(
           segmentNode,
           currentPath,
         );
@@ -501,9 +496,9 @@ class TreeFS {
   }
   hierarchicalLookup(mixedStartPath, subpath, opts) {
     const ancestorsOfInput = [];
-    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,
     });
@@ -644,7 +639,7 @@ class TreeFS {
     invalidatedBy,
     start,
   ) {
-    const lookupResult = this._lookupByNormalPath(
+    const lookupResult = this.#lookupByNormalPath(
       this.#pathUtils.joinNormalToRelative(normalCandidatePath, subpath)
         .normalPath,
       {
@@ -668,9 +663,9 @@ class TreeFS {
     return null;
   }
   *metadataIterator(opts) {
-    yield* this._metadataIterator(this.#rootNode, opts);
+    yield* this.#metadataIterator(this.#rootNode, opts);
   }
-  *_metadataIterator(rootNode, opts, prefix = "") {
+  *#metadataIterator(rootNode, opts, prefix = "") {
     for (const [name, node] of rootNode) {
       if (
         !opts.includeNodeModules &&
@@ -682,17 +677,17 @@ class TreeFS {
       const prefixedName =
         prefix === "" ? name : prefix + _path.default.sep + name;
       if (isDirectory(node)) {
-        yield* this._metadataIterator(node, opts, prefixedName);
+        yield* this.#metadataIterator(node, opts, prefixedName);
       } else if (isRegularFile(node) || opts.includeSymlinks) {
         yield {
+          baseName: name,
           canonicalPath: prefixedName,
           metadata: node,
-          baseName: name,
         };
       }
     }
   }
-  _normalizePath(relativeOrAbsolutePath) {
+  #normalizePath(relativeOrAbsolutePath) {
     return _path.default.isAbsolute(relativeOrAbsolutePath)
       ? this.#pathUtils.absoluteToNormal(relativeOrAbsolutePath)
       : this.#pathUtils.relativeToNormal(relativeOrAbsolutePath);
@@ -706,7 +701,7 @@ class TreeFS {
     }
     yield* node.entries();
   }
-  *_pathIterator(
+  *#pathIterator(
     iterationRootNode,
     iterationRootParentNode,
     ancestorOfRootIdx,
@@ -737,7 +732,7 @@ class TreeFS {
             opts.canonicalPathOfRoot,
             nodePathWithSystemSeparators,
           );
-          const resolved = this._lookupByNormalPath(normalPathOfSymlink, {
+          const resolved = this.#lookupByNormalPath(normalPathOfSymlink, {
             followLeaf: true,
           });
           if (!resolved.exists) {
@@ -751,7 +746,7 @@ class TreeFS {
             opts.follow &&
             !followedLinks.has(node)
           ) {
-            yield* this._pathIterator(
+            yield* this.#pathIterator(
               target,
               resolved.parentNode,
               resolved.ancestorOfRootIdx,
@@ -762,7 +757,7 @@ class TreeFS {
           }
         }
       } else if (opts.recursive) {
-        yield* this._pathIterator(
+        yield* this.#pathIterator(
           node,
           iterationRootParentNode,
           ancestorOfRootIdx != null && ancestorOfRootIdx > 0
@@ -775,7 +770,7 @@ class TreeFS {
       }
     }
   }
-  _resolveSymlinkTargetToNormalPath(symlinkNode, canonicalPathOfSymlink) {
+  #resolveSymlinkTargetToNormalPath(symlinkNode, canonicalPathOfSymlink) {
     const cachedResult = this.#cachedNormalSymlinkTargets.get(symlinkNode);
     if (cachedResult != null) {
       return cachedResult;
@@ -805,14 +800,14 @@ class TreeFS {
     this.#cachedNormalSymlinkTargets.set(symlinkNode, result);
     return result;
   }
-  _getFileData(
+  #getFileData(
     filePath,
     opts = {
       followLeaf: true,
     },
   ) {
-    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)) {
@@ -820,11 +815,11 @@ class TreeFS {
     }
     return result.node;
   }
-  _cloneTree(root) {
+  #cloneTree(root) {
     const clone = 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]);
       }