metro-file-map 0.84.3 → 0.85.0

package/src/lib/RootPathUtils.js.flow

@@ -46,6 +46,9 @@ const SEP_UP_FRAGMENT = path.sep + '..';
 const UP_FRAGMENT_SEP_LENGTH = UP_FRAGMENT_SEP.length;
 const CURRENT_FRAGMENT = '.' + path.sep;
 
+const IS_WIN32 = path.sep === '\\';
+const ROOT_BASE_IDX = IS_WIN32 ? 0 : 1;
+
 export class RootPathUtils {
   #rootDir: string;
   #rootDirnames: ReadonlyArray<string>;
@@ -149,6 +152,12 @@ export class RootPathUtils {
     const right = pos === 0 ? normalPath : normalPath.slice(pos);
     if (right.length === 0) {
       return left;
+    } else if (IS_WIN32 && pos > this.#rootDepth * UP_FRAGMENT_SEP_LENGTH) {
+      // On a real file system, navigating to `..` at the top level (posix `/`
+      // or Windows drive) is a no-op, but we can't respect that on Windows
+      // because Metro uses e.g. `..\..\D:\foo` to represent cross-drive
+      // relative paths.
+      return right;
     }
     // left may already end in a path separator only if it is a filesystem root,
     // '/' or 'X:\'.
@@ -198,7 +207,9 @@ export class RootPathUtils {
     if (relativePath === '') {
       return {collapsedSegments: 0, normalPath};
     }
-    const left = normalPath + path.sep;
+    const left = normalPath.endsWith(path.sep)
+      ? normalPath
+      : normalPath + path.sep;
     const rawPath = left + relativePath;
     if (normalPath === '..' || normalPath.endsWith(SEP_UP_FRAGMENT)) {
       const collapsed = this.#tryCollapseIndirectionsInSuffix(rawPath, 0, 0);
@@ -299,9 +310,10 @@ export class RootPathUtils {
         };
       }
 
-      // Cap the number of indirections at the total number of root segments.
-      // File systems treat '..' at the root as '.'.
-      if (totalUpIndirections < this.#rootParts.length - 1) {
+      // Cap the number of indirections at the total number of root parts.
+      // File systems treat '..' at the root as '.'. For Windows, cross-device
+      // paths need to survive this.
+      if (totalUpIndirections < this.#rootParts.length - ROOT_BASE_IDX) {
         totalUpIndirections++;
       }
 

package/src/lib/TreeFS.js

@@ -341,6 +341,9 @@ class TreeFS {
   }
   remove(mixedPath, changeListener) {
     const normalPath = this.#normalizePath(mixedPath);
+    this.#removeNormalPath(normalPath, changeListener);
+  }
+  #removeNormalPath(normalPath, changeListener) {
     const result = this.#lookupByNormalPath(normalPath, {
       followLeaf: false,
     });
@@ -350,7 +353,7 @@ class TreeFS {
     const { parentNode, canonicalPath, node } = result;
     if (isDirectory(node) && node.size > 0) {
       for (const basename of node.keys()) {
-        this.remove(
+        this.#removeNormalPath(
           canonicalPath + _path.default.sep + basename,
           changeListener,
         );
@@ -367,7 +370,10 @@ class TreeFS {
       }
       parentNode.delete(_path.default.basename(canonicalPath));
       if (parentNode.size === 0 && parentNode !== this.#rootNode) {
-        this.remove(_path.default.dirname(canonicalPath), changeListener);
+        this.#removeNormalPath(
+          _path.default.dirname(canonicalPath),
+          changeListener,
+        );
       }
     }
   }
@@ -831,14 +837,16 @@ class TreeFS {
       typeof literalSymlinkTarget === "string",
       "Expected symlink target to be populated.",
     );
-    const absoluteSymlinkTarget = _path.default.resolve(
+    let absoluteSymlinkTarget = _path.default.resolve(
       this.#rootDir,
       canonicalPathOfSymlink,
       "..",
       literalSymlinkTarget,
     );
-    const normalSymlinkTarget = _path.default.relative(
-      this.#rootDir,
+    if (absoluteSymlinkTarget.endsWith(_path.default.sep)) {
+      absoluteSymlinkTarget = absoluteSymlinkTarget.slice(0, -1);
+    }
+    const normalSymlinkTarget = this.#pathUtils.absoluteToNormal(
       absoluteSymlinkTarget,
     );
     const result = {

package/src/lib/TreeFS.js.flow

@@ -124,11 +124,13 @@ type MetadataIteratorOptions = Readonly<{
  *   a trailing slash
  */
 export default class TreeFS implements MutableFileSystem {
-  +#cachedNormalSymlinkTargets: WeakMap<FileNode, NormalizedSymlinkTarget> =
-    new WeakMap();
-  +#pathUtils: RootPathUtils;
-  +#processFile: ProcessFileFunction;
-  +#rootDir: Path;
+  readonly #cachedNormalSymlinkTargets: WeakMap<
+    FileNode,
+    NormalizedSymlinkTarget,
+  > = new WeakMap();
+  readonly #pathUtils: RootPathUtils;
+  readonly #processFile: ProcessFileFunction;
+  readonly #rootDir: Path;
   #rootNode: DirectoryNode = new Map();
 
   constructor(opts: TreeFSOptions) {
@@ -493,6 +495,13 @@ export default class TreeFS implements MutableFileSystem {
 
   remove(mixedPath: Path, changeListener?: FileSystemListener): void {
     const normalPath = this.#normalizePath(mixedPath);
+    this.#removeNormalPath(normalPath, changeListener);
+  }
+
+  #removeNormalPath(
+    normalPath: string,
+    changeListener?: FileSystemListener,
+  ): void {
     const result = this.#lookupByNormalPath(normalPath, {followLeaf: false});
     if (!result.exists) {
       return;
@@ -501,7 +510,10 @@ export default class TreeFS implements MutableFileSystem {
 
     if (isDirectory(node) && node.size > 0) {
       for (const basename of node.keys()) {
-        this.remove(canonicalPath + path.sep + basename, changeListener);
+        this.#removeNormalPath(
+          canonicalPath + path.sep + basename,
+          changeListener,
+        );
       }
       // Removing the last file will delete this directory
       return;
@@ -521,7 +533,7 @@ 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), changeListener);
+        this.#removeNormalPath(path.dirname(canonicalPath), changeListener);
       }
     }
   }
@@ -1224,16 +1236,19 @@ export default class TreeFS implements MutableFileSystem {
       typeof literalSymlinkTarget === 'string',
       'Expected symlink target to be populated.',
     );
-    const absoluteSymlinkTarget = path.resolve(
+    let absoluteSymlinkTarget = path.resolve(
       this.#rootDir,
       canonicalPathOfSymlink,
       '..', // Symlink target is relative to its containing directory.
       literalSymlinkTarget, // May be absolute, in which case the above are ignored
     );
-    const normalSymlinkTarget = path.relative(
-      this.#rootDir,
+    if (absoluteSymlinkTarget.endsWith(path.sep)) {
+      absoluteSymlinkTarget = absoluteSymlinkTarget.slice(0, -1);
+    }
+    const normalSymlinkTarget = this.#pathUtils.absoluteToNormal(
       absoluteSymlinkTarget,
     );
+
     const result = {
       ancestorOfRootIdx:
         this.#pathUtils.getAncestorOfRootIdx(normalSymlinkTarget),

package/src/lib/rootRelativeCacheKeys.js

@@ -32,7 +32,6 @@ function rootRelativeCacheKeys(buildParameters) {
         case "extensions":
         case "computeSha1":
         case "enableSymlinks":
-        case "forceNodeFilesystemAPI":
         case "retainAllFiles":
           return buildParameters[key] ?? null;
         case "ignorePattern":

package/src/lib/rootRelativeCacheKeys.js.flow

@@ -39,7 +39,6 @@ export default function rootRelativeCacheKeys(
         case 'extensions':
         case 'computeSha1':
         case 'enableSymlinks':
-        case 'forceNodeFilesystemAPI':
         case 'retainAllFiles':
           return buildParameters[key] ?? null;
         case 'ignorePattern':

package/src/plugins/DependencyPlugin.d.ts

@@ -6,7 +6,7 @@
  *
  * @noformat
  * @oncall react_native
- * @generated SignedSource<<e07a9c061b0224fc44191d956461bd6f>>
+ * @generated SignedSource<<344b340710d6da24bcb609058e7ce8d6>>
  *
  * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
  * Original file: packages/metro-file-map/src/plugins/DependencyPlugin.js
@@ -15,38 +15,18 @@
  *   yarn run build-ts-defs (OSS) 
  */
 
-import type {
-  FileMapPlugin,
-  FileMapPluginInitOptions,
-  FileMapPluginWorker,
-  Path,
-} from '../flow-types';
+import type {Path} from '../flow-types';
+
+import FileDataPlugin from './FileDataPlugin';
 
 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';
+declare class DependencyPlugin extends FileDataPlugin<ReadonlyArray<string> | null> {
   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

@@ -4,70 +4,54 @@ Object.defineProperty(exports, "__esModule", {
   value: true,
 });
 exports.default = void 0;
-class DependencyPlugin {
-  name = "dependencies";
-  #dependencyExtractor;
-  #computeDependencies;
-  #getDependencies;
-  #rootDir;
+var _workerExclusionList = _interopRequireDefault(
+  require("../workerExclusionList"),
+);
+var _FileDataPlugin = _interopRequireDefault(require("./FileDataPlugin"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+class DependencyPlugin extends _FileDataPlugin.default {
   constructor(options) {
-    this.#dependencyExtractor = options.dependencyExtractor;
-    this.#computeDependencies = options.computeDependencies;
-    this.#rootDir = options.rootDir;
-  }
-  async initialize(initOptions) {
-    const { files } = initOptions;
-    this.#getDependencies = (mixedPath) => {
-      const result = files.lookup(mixedPath);
-      if (result.exists && result.type === "f") {
-        return result.pluginData ?? [];
+    const { dependencyExtractor, computeDependencies } = options;
+    let cacheKey;
+    if (dependencyExtractor != null) {
+      const mod = require(dependencyExtractor);
+      let getCacheKey = mod?.getCacheKey;
+      if (getCacheKey == null && mod?.__esModule === true) {
+        getCacheKey = mod.default?.getCacheKey;
       }
-      return null;
-    };
-  }
-  getSerializableSnapshot() {
-    return null;
-  }
-  onChanged() {}
-  assertValid() {}
-  getCacheKey() {
-    if (this.#dependencyExtractor != null) {
-      const extractor = require(this.#dependencyExtractor);
-      return JSON.stringify({
-        extractorKey: extractor.getCacheKey?.() ?? null,
-        extractorPath: this.#dependencyExtractor,
-      });
+      cacheKey = getCacheKey?.() ?? dependencyExtractor;
+    } else {
+      cacheKey = "default-dependency-extractor";
     }
-    return "default-dependency-extractor";
-  }
-  getWorker() {
-    const excludedExtensions = require("../workerExclusionList");
-    return {
+    super({
+      name: "dependencies",
+      cacheKey,
       worker: {
         modulePath: require.resolve("./dependencies/worker.js"),
         setupArgs: {
-          dependencyExtractor: this.#dependencyExtractor ?? null,
+          dependencyExtractor: dependencyExtractor ?? null,
         },
       },
       filter: ({ normalPath, isNodeModules }) => {
-        if (!this.#computeDependencies) {
+        if (!computeDependencies) {
           return false;
         }
         if (isNodeModules) {
           return false;
         }
         const ext = normalPath.substr(normalPath.lastIndexOf("."));
-        return !excludedExtensions.has(ext);
+        return !_workerExclusionList.default.has(ext);
       },
-    };
+    });
   }
   getDependencies(mixedPath) {
-    if (this.#getDependencies == null) {
-      throw new Error(
-        "DependencyPlugin has not been initialized before getDependencies",
-      );
+    const result = this.getFileSystem().lookup(mixedPath);
+    if (result.exists && result.type === "f") {
+      return result.pluginData ?? [];
     }
-    return this.#getDependencies(mixedPath);
+    return null;
   }
 }
 exports.default = DependencyPlugin;

package/src/plugins/DependencyPlugin.js.flow

@@ -9,121 +9,63 @@
  * @oncall react_native
  */
 
-import type {
-  FileMapPlugin,
-  FileMapPluginInitOptions,
-  FileMapPluginWorker,
-  Path,
-} from '../flow-types';
+import type {Path} from '../flow-types';
+
+import excludedExtensions from '../workerExclusionList';
+import FileDataPlugin from './FileDataPlugin';
 
 export type DependencyPluginOptions = Readonly<{
   /** Path to custom dependency extractor module */
   dependencyExtractor: ?string,
   /** Whether to compute dependencies (performance optimization) */
   computeDependencies: boolean,
-  rootDir: Path,
 }>;
 
-export default class DependencyPlugin
-  implements FileMapPlugin<null, ReadonlyArray<string> | null>
-{
-  +name: 'dependencies' = 'dependencies';
-
-  #dependencyExtractor: ?string;
-  #computeDependencies: boolean;
-  #getDependencies: Path => ?ReadonlyArray<string>;
-  #rootDir: Path;
-
+export default class DependencyPlugin extends FileDataPlugin<ReadonlyArray<string> | null> {
   constructor(options: DependencyPluginOptions) {
-    this.#dependencyExtractor = options.dependencyExtractor;
-    this.#computeDependencies = options.computeDependencies;
-    this.#rootDir = options.rootDir;
-  }
-
-  async initialize(
-    initOptions: FileMapPluginInitOptions<null, ReadonlyArray<string> | null>,
-  ): Promise<void> {
-    const {files} = initOptions;
-    // Create closure to access dependencies from file metadata plugin data
-    this.#getDependencies = (mixedPath: Path) => {
-      const result = files.lookup(mixedPath);
-      if (result.exists && result.type === 'f') {
-        // Backwards compatibility: distinguish an extant file that we've not
-        // run the worker on (probably because it fails the extension filter)
-        // from a missing file. Non-source files are expected to have empty
-        // dependencies.
-        return result.pluginData ?? [];
-      }
-      return null;
-    };
-  }
-
-  getSerializableSnapshot(): null {
-    // Dependencies stored in plugin data, no separate serialization needed
-    return null;
-  }
+    const {dependencyExtractor, computeDependencies} = options;
 
-  onChanged(): void {
-    // No-op: Worker already populated plugin data
-    // Plugin data is write-only from worker
-  }
-
-  assertValid(): void {
-    // No validation needed
-  }
-
-  getCacheKey(): string {
-    if (this.#dependencyExtractor != null) {
-      // Dynamic require to get extractor's cache key
+    let cacheKey: string;
+    if (dependencyExtractor != null) {
       // $FlowFixMe[unsupported-syntax] - dynamic require
-      const extractor = require(this.#dependencyExtractor);
-      return JSON.stringify({
-        extractorKey: extractor.getCacheKey?.() ?? null,
-        extractorPath: this.#dependencyExtractor,
-      });
+      const mod = require(dependencyExtractor);
+      let getCacheKey = mod?.getCacheKey; // CJS export or ESM named export
+      // Allow for getCacheKey as a prop of an ESM default export
+      if (getCacheKey == null && mod?.__esModule === true) {
+        getCacheKey = mod.default?.getCacheKey;
+      }
+      cacheKey = getCacheKey?.() ?? dependencyExtractor;
+    } else {
+      cacheKey = 'default-dependency-extractor';
     }
-    return 'default-dependency-extractor';
-  }
-
-  getWorker(): FileMapPluginWorker {
-    const excludedExtensions = require('../workerExclusionList');
 
-    return {
+    super({
+      name: 'dependencies',
+      cacheKey,
       worker: {
         modulePath: require.resolve('./dependencies/worker.js'),
         setupArgs: {
-          dependencyExtractor: this.#dependencyExtractor ?? null,
+          dependencyExtractor: dependencyExtractor ?? null,
         },
       },
       filter: ({normalPath, isNodeModules}) => {
-        // Respect computeDependencies flag
-        if (!this.#computeDependencies) {
+        if (!computeDependencies) {
           return false;
         }
-
-        // Never process node_modules
         if (isNodeModules) {
           return false;
         }
-
-        // Skip excluded extensions
         const ext = normalPath.substr(normalPath.lastIndexOf('.'));
         return !excludedExtensions.has(ext);
       },
-    };
+    });
   }
 
-  /**
-   * 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): ?ReadonlyArray<string> {
-    if (this.#getDependencies == null) {
-      throw new Error(
-        'DependencyPlugin has not been initialized before getDependencies',
-      );
+    const result = this.getFileSystem().lookup(mixedPath);
+    if (result.exists && result.type === 'f') {
+      return result.pluginData ?? [];
     }
-    return this.#getDependencies(mixedPath);
+    return null;
   }
 }

package/src/plugins/FileDataPlugin.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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<<8833f226ec9fa3a4c96370862ca4d59f>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/plugins/FileDataPlugin.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  FileMapPlugin,
+  FileMapPluginInitOptions,
+  FileMapPluginWorker,
+  ReadonlyFileSystemChanges,
+  V8Serializable,
+} from '../flow-types';
+
+export type FileDataPluginOptions = Readonly<
+  Omit<FileMapPluginWorker, keyof {name: string; cacheKey: string}> & {
+    name: string;
+    cacheKey: string;
+  }
+>;
+/**
+ * Base class for FileMap plugins that store per-file data via a worker and
+ * have no separate serializable state. Provides default no-op implementations
+ * of lifecycle methods that subclasses can override as needed.
+ */
+declare class FileDataPlugin<
+  PerFileData extends void | V8Serializable = void | V8Serializable,
+> implements FileMapPlugin<null, PerFileData>
+{
+  readonly name: string;
+  constructor($$PARAM_0$$: FileDataPluginOptions);
+  initialize(
+    initOptions: FileMapPluginInitOptions<null, PerFileData>,
+  ): Promise<void>;
+  getFileSystem(): FileMapPluginInitOptions<null, PerFileData>['files'];
+  onChanged(
+    _changes: ReadonlyFileSystemChanges<null | undefined | PerFileData>,
+  ): void;
+  assertValid(): void;
+  getSerializableSnapshot(): null;
+  getCacheKey(): string;
+  getWorker(): FileMapPluginWorker;
+}
+export default FileDataPlugin;

package/src/plugins/FileDataPlugin.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+class FileDataPlugin {
+  #worker;
+  #cacheKey;
+  #files;
+  constructor({ name, worker, filter, cacheKey }) {
+    this.name = name;
+    this.#worker = {
+      worker,
+      filter,
+    };
+    this.#cacheKey = cacheKey;
+  }
+  async initialize(initOptions) {
+    this.#files = initOptions.files;
+  }
+  getFileSystem() {
+    const files = this.#files;
+    if (files == null) {
+      throw new Error(`${this.name} plugin has not been initialized`);
+    }
+    return files;
+  }
+  onChanged(_changes) {}
+  assertValid() {}
+  getSerializableSnapshot() {
+    return null;
+  }
+  getCacheKey() {
+    return this.#cacheKey;
+  }
+  getWorker() {
+    return this.#worker;
+  }
+}
+exports.default = FileDataPlugin;

package/src/plugins/FileDataPlugin.js.flow

@@ -0,0 +1,76 @@
+/**
+ * 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 {
+  FileMapPlugin,
+  FileMapPluginInitOptions,
+  FileMapPluginWorker,
+  ReadonlyFileSystemChanges,
+  V8Serializable,
+} from '../flow-types';
+
+export type FileDataPluginOptions = Readonly<{
+  ...FileMapPluginWorker,
+  name: string,
+  cacheKey: string,
+}>;
+
+/**
+ * Base class for FileMap plugins that store per-file data via a worker and
+ * have no separate serializable state. Provides default no-op implementations
+ * of lifecycle methods that subclasses can override as needed.
+ */
+export default class FileDataPlugin<
+  in PerFileData extends void | V8Serializable = void | V8Serializable,
+> implements FileMapPlugin<null, PerFileData>
+{
+  readonly name: string;
+
+  #worker: FileMapPluginWorker;
+  #cacheKey: string;
+  #files: ?FileMapPluginInitOptions<null, PerFileData>['files'];
+
+  constructor({name, worker, filter, cacheKey}: FileDataPluginOptions) {
+    this.name = name;
+    this.#worker = {worker, filter};
+    this.#cacheKey = cacheKey;
+  }
+
+  async initialize(
+    initOptions: FileMapPluginInitOptions<null, PerFileData>,
+  ): Promise<void> {
+    this.#files = initOptions.files;
+  }
+
+  getFileSystem(): FileMapPluginInitOptions<null, PerFileData>['files'] {
+    const files = this.#files;
+    if (files == null) {
+      throw new Error(`${this.name} plugin has not been initialized`);
+    }
+    return files;
+  }
+
+  onChanged(_changes: ReadonlyFileSystemChanges<?PerFileData>): void {}
+
+  assertValid(): void {}
+
+  getSerializableSnapshot(): null {
+    return null;
+  }
+
+  getCacheKey(): string {
+    return this.#cacheKey;
+  }
+
+  getWorker(): FileMapPluginWorker {
+    return this.#worker;
+  }
+}