@expo/metro-file-map 56.0.0-0 → 56.0.0-2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present 650 Industries, Inc. (aka Expo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/crawlers/node/fallback.d.ts

@@ -6,6 +6,13 @@ type FallbackFilesystemOptions = {
     ignore: IgnoreMatcher;
     includeSymlinks: boolean;
 };
+/**
+ * Whether a directory node was created or populated by the fallback filesystem.
+ * Used by TreeFS to determine if a directory outside the fallback boundary was
+ * reached legitimately (e.g., via symlink traversal) and should allow further
+ * fallback lookups.
+ */
+export declare function isFallbackDir(dirNode: any): boolean;
 /**
  * Create a FallbackFilesystem that synchronously queries the real filesystem.
  *

package/build/crawlers/node/fallback.js

@@ -3,17 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFallbackDir = isFallbackDir;
 exports.default = createFallbackFilesystem;
 exports.shouldFallbackCrawlDir = shouldFallbackCrawlDir;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const normalizePathSeparatorsToPosix_1 = __importDefault(require("../../lib/normalizePathSeparatorsToPosix"));
-const readdirMarker = Symbol.for('fallbackDir');
-function markDir(dirNode) {
-    dirNode[readdirMarker] = true;
+const FALLBACK_DIR = Symbol.for('fallbackDir');
+var FallbackFlag;
+(function (FallbackFlag) {
+    FallbackFlag[FallbackFlag["VISITED"] = 0] = "VISITED";
+    FallbackFlag[FallbackFlag["CRAWLED"] = 1] = "CRAWLED";
+})(FallbackFlag || (FallbackFlag = {}));
+function markDir(dirNode, flag) {
+    dirNode[FALLBACK_DIR] = flag;
 }
-function isMarkedDir(dirNode) {
-    return !!dirNode[readdirMarker];
+function getDirFlag(dirNode) {
+    return dirNode[FALLBACK_DIR];
+}
+/**
+ * Whether a directory node was created or populated by the fallback filesystem.
+ * Used by TreeFS to determine if a directory outside the fallback boundary was
+ * reached legitimately (e.g., via symlink traversal) and should allow further
+ * fallback lookups.
+ */
+function isFallbackDir(dirNode) {
+    return dirNode[FALLBACK_DIR] != null;
 }
 function isDirectory(node) {
     return node instanceof Map;
@@ -34,7 +49,7 @@ function createFallbackFilesystem(opts) {
         return acc;
     }, {});
     function readdir(_normalPath, absolutePath, dirNode) {
-        if (dirNode != null && isMarkedDir(dirNode)) {
+        if (dirNode != null && getDirFlag(dirNode) === FallbackFlag.CRAWLED) {
             return dirNode;
         }
         let dirEntries;
@@ -53,7 +68,9 @@ function createFallbackFilesystem(opts) {
             }
             if (entry.isDirectory()) {
                 if (!result.has(name)) {
-                    result.set(name, new Map());
+                    const childDir = new Map();
+                    markDir(childDir, FallbackFlag.VISITED);
+                    result.set(name, childDir);
                 }
             }
             else if (entry.isSymbolicLink()) {
@@ -69,7 +86,7 @@ function createFallbackFilesystem(opts) {
                 }
             }
         }
-        markDir(result);
+        markDir(result, FallbackFlag.CRAWLED);
         return result;
     }
     return {
@@ -87,9 +104,15 @@ function createFallbackFilesystem(opts) {
             }
             if (stat.isDirectory()) {
                 const dirNode = isDirectory(prevNode) ? prevNode : null;
-                return shouldFallbackCrawlDir(absolutePath)
-                    ? readdir(normalPath, absolutePath, dirNode)
-                    : (dirNode ?? new Map());
+                if (shouldFallbackCrawlDir(absolutePath)) {
+                    return readdir(normalPath, absolutePath, dirNode);
+                }
+                if (dirNode != null) {
+                    return dirNode;
+                }
+                const newDir = new Map();
+                markDir(newDir, FallbackFlag.VISITED);
+                return newDir;
             }
             else if (stat.isSymbolicLink()) {
                 if (!includeSymlinks) {

package/build/crawlers/node/index.js

@@ -78,7 +78,11 @@ function find(roots, extensions, ignore, includeSymlinks, rootDir, console, prev
                             ? name
                             : dirNormal + path.sep + name;
                     if (entry.isDirectory()) {
-                        search(file, childNormal, isWithinRoot || childNormal === '');
+                        // NOTE(@kitten): We'd like to be able to apply excludes to directories selectively based
+                        // on their normal paths, so we can exclude using `^...`
+                        if (!ignore(childNormal)) {
+                            search(file, childNormal, isWithinRoot || childNormal === '');
+                        }
                         continue;
                     }
                     const ext = path.extname(file).substr(1);

package/build/lib/TreeFS.js

@@ -79,6 +79,7 @@ class TreeFS {
     #processFile;
     #rootDir;
     #rootPattern;
+    #roots;
     #rootNode = new Map();
     constructor(opts) {
         const { rootDir, files, processFile, fallbackFilesystem, roots, serverRoot } = opts;
@@ -92,13 +93,15 @@ class TreeFS {
         else {
             this.#fallbackBoundaryDepth = null;
         }
+        const normalRoots = (roots ?? []).map((r) => this.#pathUtils.absoluteToNormal(r));
+        this.#roots = normalRoots;
         this.#rootPattern = (0, RootPathUtils_1.pathsToPattern)(roots ?? [], this.#pathUtils);
         if (files != null) {
             this.bulkAddOrModify(files);
         }
     }
     getSerializableSnapshot() {
-        return this.#cloneTree(this.#rootNode, '');
+        return this.#cloneTree(this.#rootNode);
     }
     static fromDeserializedSnapshot(args) {
         const { rootDir, fileSystemData, processFile, fallbackFilesystem, roots, serverRoot } = args;
@@ -428,6 +431,9 @@ class TreeFS {
         let targetNormalPath = requestedNormalPath;
         // Lazy-initialised set of seen target paths, to detect symlink cycles.
         let seen;
+        // Set when a symlink is followed, to allow fallback population outside
+        // the boundary for paths reachable transitively through symlinks.
+        let followedSymlink = false;
         // Pointer to the first character of the current path segment in
         // targetNormalPath.
         let fromIdx = opts.start?.pathIdx ?? 0;
@@ -470,7 +476,7 @@ class TreeFS {
                             ? fromIdx - segmentName.length - 1
                             : fromIdx - segmentName.length - 2;
                         const parentCanonicalPath = parentEnd > 0 ? targetNormalPath.slice(0, parentEnd) : '';
-                        segmentNode = this.#populateFromFilesystem(parentNode, segmentName, parentCanonicalPath);
+                        segmentNode = this.#populateFromFilesystem(parentNode, segmentName, parentCanonicalPath, followedSymlink);
                         if (segmentNode != null) {
                             ancestorOfRootIdx = null;
                         }
@@ -496,8 +502,7 @@ class TreeFS {
                         }
                         parentNode.set(segmentName, segmentNode);
                     }
-                    else if (!opts.skipFallback &&
-                        this.#fallbackFilesystem != null) {
+                    else if (!opts.skipFallback && this.#fallbackFilesystem != null) {
                         parentNode.set(segmentName, segmentNode);
                     }
                 }
@@ -617,6 +622,7 @@ class TreeFS {
                     };
                 }
                 seen.add(targetNormalPath);
+                followedSymlink = true;
                 fromIdx = 0;
                 parentNode = this.#rootNode;
                 ancestorOfRootIdx = 0;
@@ -827,7 +833,7 @@ class TreeFS {
             !pathPrefix.endsWith(pathSep + '..')) {
             const canonicalRoot = opts.canonicalPathOfRoot;
             const rootCanonical = pathPrefix === '' ? canonicalRoot : canonicalRoot + path_1.default.sep + pathPrefix;
-            this.#populateDirFromFilesystem(iterationRootNode, rootCanonical, false);
+            this.#populateDirFromFilesystem(iterationRootNode, rootCanonical, false, false);
         }
         for (const [name, node] of this.#directoryNodeIterator(iterationRootNode, iterationRootParentNode, ancestorOfRootIdx)) {
             if (node == null) {
@@ -881,7 +887,7 @@ class TreeFS {
                     const canonicalPath = opts.canonicalPathOfRoot === ''
                         ? nodePathWithSystemSeparators
                         : opts.canonicalPathOfRoot + path_1.default.sep + nodePathWithSystemSeparators;
-                    this.#populateDirFromFilesystem(node, canonicalPath, false);
+                    this.#populateDirFromFilesystem(node, canonicalPath, false, false);
                 }
                 yield* this.#pathIterator(node, iterationRootParentNode, ancestorOfRootIdx != null && ancestorOfRootIdx > 0 ? ancestorOfRootIdx - 1 : null, opts, nodePath, followedLinks);
             }
@@ -924,25 +930,70 @@ class TreeFS {
         }
         return result.node;
     }
-    #cloneTree(root, prefix) {
-        const clone = new Map();
-        for (const [name, node] of root) {
-            if (node == null) {
-                continue;
+    /**
+     * Return a filtered view of the tree containing only content under watched
+     * roots. Walk each root path from #rootNode, creating intermediate directory
+     * nodes as needed, and reference the subtree at each root endpoint directly.
+     * Since roots are non-overlapping, each contributes independently.
+     */
+    #cloneTree(rootNode) {
+        // NOTE(@kitten): The upstream version deeply clones this structure, but this
+        // isn't necessary since it's serialized right away by the DiskCacheManager.
+        // Even if it isn't, the intention is to store it faithfully, so we're okay
+        // with more modifications
+        function copyRootInto(normalRoot, source, clone) {
+            let currentSource = source;
+            let currentClone = clone;
+            let fromIdx = 0;
+            while (fromIdx < normalRoot.length) {
+                const nextSepIdx = normalRoot.indexOf(path_1.default.sep, fromIdx);
+                const isLastSegment = nextSepIdx === -1;
+                const seg = isLastSegment
+                    ? normalRoot.slice(fromIdx)
+                    : normalRoot.slice(fromIdx, nextSepIdx);
+                fromIdx = isLastSegment ? normalRoot.length : nextSepIdx + 1;
+                const sourceChild = currentSource.get(seg);
+                if (sourceChild == null || !isDirectory(sourceChild)) {
+                    return;
+                }
+                else if (isLastSegment || fromIdx >= normalRoot.length) {
+                    currentClone.set(seg, sourceChild);
+                }
+                else {
+                    let cloneChild = currentClone.get(seg);
+                    if (cloneChild == null || !isDirectory(cloneChild)) {
+                        cloneChild = new Map();
+                        currentClone.set(seg, cloneChild);
+                    }
+                    currentSource = sourceChild;
+                    currentClone = cloneChild;
+                }
             }
-            else if (isDirectory(node)) {
-                const childPath = prefix === '' ? name : prefix + path_1.default.sep + name;
-                if (this.#rootPattern == null || this.#rootPattern.test(childPath + path_1.default.sep)) {
-                    clone.set(name, this.#cloneTree(node, childPath));
+        }
+        if (this.#roots.length === 0) {
+            return rootNode;
+        }
+        const clone = new Map();
+        for (const normalRoot of this.#roots) {
+            if (normalRoot === '') {
+                // Root is rootDir itself — include everything except '..'
+                for (const [name, node] of rootNode) {
+                    if (node != null && name !== '..') {
+                        clone.set(name, node);
+                    }
                 }
             }
             else {
-                clone.set(name, [...node]);
+                copyRootInto(normalRoot, rootNode, clone);
             }
         }
         return clone;
     }
-    #isOutsideFallbackBoundary(canonicalPath) {
+    #isOutsideFallbackBoundary(canonicalPath, dirNode) {
+        // We allow any directory that's already been crawled
+        if ((0, fallback_1.isFallbackDir)(dirNode)) {
+            return false;
+        }
         const maxDepth = this.#fallbackBoundaryDepth;
         return maxDepth != null && (0, RootPathUtils_1.getAncestorOfRootIdx)(canonicalPath) > maxDepth;
     }
@@ -951,20 +1002,26 @@ class TreeFS {
      * fallback filesystem. The fallback returns tree-compatible nodes
      * (FileMetadata tuples or directory Maps) that are inserted directly.
      *
+     * Accepts `wasFollowing` to allow traversal on symlinks that were followed.
+     * If we're resolving a symlink target, we allow the lookup to escape the
+     * fallback scope.
+     *
      * Returns the newly created node, or null if the path doesn't exist on disk.
      */
-    #populateFromFilesystem(parentNode, segmentName, parentCanonicalPath) {
+    #populateFromFilesystem(parentNode, segmentName, parentCanonicalPath, wasFollowing) {
         const fallback = this.#fallbackFilesystem;
         if (fallback == null) {
             return null;
         }
+        // A symlink traversal (wasFollowing) or a parent created by the fallback
+        // (isFallbackDir) lets us skip the boundary check.
         const childCanonicalPath = parentCanonicalPath === '' ? segmentName : parentCanonicalPath + path_1.default.sep + segmentName;
         if (this.#rootPattern?.test(childCanonicalPath + path_1.default.sep) ||
-            this.#isOutsideFallbackBoundary(childCanonicalPath)) {
+            (!wasFollowing && this.#isOutsideFallbackBoundary(childCanonicalPath, parentNode))) {
             return null;
         }
         else if (parentCanonicalPath !== '' && (0, fallback_1.shouldFallbackCrawlDir)(parentCanonicalPath)) {
-            this.#populateDirFromFilesystem(parentNode, parentCanonicalPath, true);
+            this.#populateDirFromFilesystem(parentNode, parentCanonicalPath, true, wasFollowing);
             return parentNode.get(segmentName) ?? null;
         }
         else if (parentNode.has(segmentName)) {
@@ -984,12 +1041,12 @@ class TreeFS {
      * iteration, and by #populateFromFilesystem for optimistic parent
      * population.
      */
-    #populateDirFromFilesystem(dirNode, canonicalPath, skipCheck) {
+    #populateDirFromFilesystem(dirNode, canonicalPath, skipCheck, wasFollowed) {
         const fallback = this.#fallbackFilesystem;
         if (fallback == null ||
             (!skipCheck &&
                 (this.#rootPattern?.test(canonicalPath + path_1.default.sep) ||
-                    this.#isOutsideFallbackBoundary(canonicalPath)))) {
+                    (!wasFollowed && this.#isOutsideFallbackBoundary(canonicalPath, dirNode))))) {
             return;
         }
         const absolutePath = this.#pathUtils.normalToAbsolute(canonicalPath);

package/package.json

@@ -1,18 +1,9 @@
 {
   "name": "@expo/metro-file-map",
-  "version": "56.0.0-0",
+  "version": "56.0.0-2",
   "description": "A metro-file-map fork for Expo used with the Metro bundler",
   "main": "build/index.js",
   "types": "build/index.d.ts",
-  "scripts": {
-    "build": "expo-module tsc",
-    "clean": "expo-module clean",
-    "lint": "expo-module lint",
-    "prepublishOnly": "pnpm run clean && pnpm run build",
-    "test": "expo-module test",
-    "typecheck": "expo-module typecheck",
-    "watch": "expo-module tsc --watch --preserveWatchOutput"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/expo/expo.git",
@@ -45,11 +36,19 @@
     "@types/invariant": "^2.2.37",
     "@types/micromatch": "^4.0.10",
     "@types/node": "^22.14.0",
-    "expo-module-scripts": "56.0.0",
-    "memfs": "^3.6.0"
+    "memfs": "^3.6.0",
+    "expo-module-scripts": "56.0.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6dcd9ce9d615d25df78597f60520492e35e02efb"
-}
+  "gitHead": "a8ab3da510a34b7bdb2262aa9887d4f78b102280",
+  "scripts": {
+    "build": "expo-module tsc",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "typecheck": "expo-module typecheck",
+    "watch": "expo-module tsc --watch --preserveWatchOutput"
+  }
+}