metro-file-map 0.83.3 → 0.84.0

package/src/lib/normalizePathSeparatorsToSystem.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 normalizePathSeparatorsToSystem;
 if (path.sep === "/") {

package/src/lib/normalizePathSeparatorsToSystem.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 normalizePathSeparatorsToSystem: (string: string) => string;
+let normalizePathSeparatorsToSystem;
 if (path.sep === '/') {
   normalizePathSeparatorsToSystem = (filePath: string): string => filePath;
 } else {
@@ -18,4 +18,4 @@ if (path.sep === '/') {
     filePath.replace(/\//g, path.sep);
 }
 
-export default normalizePathSeparatorsToSystem;
+export default normalizePathSeparatorsToSystem as (filePath: string) => string;

package/src/lib/rootRelativeCacheKeys.js

@@ -12,20 +12,6 @@ var _crypto = require("crypto");
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
 }
-function moduleCacheKey(modulePath) {
-  if (modulePath == null) {
-    return null;
-  }
-  const moduleExports = require(modulePath);
-  if (typeof moduleExports?.getCacheKey !== "function") {
-    console.warn(
-      `metro-file-map: Expected \`${modulePath}\` to export ` +
-        "`getCacheKey: () => string`",
-    );
-    return null;
-  }
-  return moduleExports.getCacheKey();
-}
 function rootRelativeCacheKeys(buildParameters) {
   const { rootDir, plugins, ...otherParameters } = buildParameters;
   const rootDirHash = (0, _crypto.createHash)("md5")
@@ -44,19 +30,13 @@ function rootRelativeCacheKeys(buildParameters) {
           );
         case "cacheBreaker":
         case "extensions":
-        case "computeDependencies":
         case "computeSha1":
-        case "enableHastePackages":
         case "enableSymlinks":
         case "forceNodeFilesystemAPI":
         case "retainAllFiles":
-        case "skipPackageJson":
           return buildParameters[key] ?? null;
         case "ignorePattern":
           return buildParameters[key].toString();
-        case "hasteImplModulePath":
-        case "dependencyExtractor":
-          return moduleCacheKey(buildParameters[key]);
         default:
           key;
           throw new Error("Unrecognised key in build parameters: " + key);

package/src/lib/rootRelativeCacheKeys.js.flow

@@ -15,22 +15,6 @@ import normalizePathSeparatorsToPosix from './normalizePathSeparatorsToPosix';
 import {RootPathUtils} from './RootPathUtils';
 import {createHash} from 'crypto';
 
-function moduleCacheKey(modulePath: ?string) {
-  if (modulePath == null) {
-    return null;
-  }
-  // $FlowFixMe[unsupported-syntax] - Dynamic require
-  const moduleExports = require(modulePath);
-  if (typeof moduleExports?.getCacheKey !== 'function') {
-    console.warn(
-      `metro-file-map: Expected \`${modulePath}\` to export ` +
-        '`getCacheKey: () => string`',
-    );
-    return null;
-  }
-  return moduleExports.getCacheKey();
-}
-
 export default function rootRelativeCacheKeys(
   buildParameters: BuildParameters,
 ): {
@@ -53,21 +37,15 @@ export default function rootRelativeCacheKeys(
           );
         case 'cacheBreaker':
         case 'extensions':
-        case 'computeDependencies':
         case 'computeSha1':
-        case 'enableHastePackages':
         case 'enableSymlinks':
         case 'forceNodeFilesystemAPI':
         case 'retainAllFiles':
-        case 'skipPackageJson':
           return buildParameters[key] ?? null;
         case 'ignorePattern':
           return buildParameters[key].toString();
-        case 'hasteImplModulePath':
-        case 'dependencyExtractor':
-          return moduleCacheKey(buildParameters[key]);
         default:
-          (key: empty);
+          key as empty;
           throw new Error('Unrecognised key in build parameters: ' + key);
       }
     });

package/src/plugins/DependencyPlugin.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+class DependencyPlugin {
+  name = "dependencies";
+  #dependencyExtractor;
+  #computeDependencies;
+  #getDependencies;
+  #rootDir;
+  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 ?? [];
+      }
+      return null;
+    };
+  }
+  getSerializableSnapshot() {
+    return null;
+  }
+  async bulkUpdate(delta) {}
+  onNewOrModifiedFile(relativeFilePath, pluginData) {}
+  onRemovedFile(relativeFilePath, pluginData) {}
+  assertValid() {}
+  getCacheKey() {
+    if (this.#dependencyExtractor != null) {
+      const extractor = require(this.#dependencyExtractor);
+      return JSON.stringify({
+        extractorKey: extractor.getCacheKey?.() ?? null,
+        extractorPath: this.#dependencyExtractor,
+      });
+    }
+    return "default-dependency-extractor";
+  }
+  getWorker() {
+    const excludedExtensions = require("../workerExclusionList");
+    return {
+      worker: {
+        modulePath: require.resolve("./dependencies/worker.js"),
+        setupArgs: {
+          dependencyExtractor: this.#dependencyExtractor ?? null,
+        },
+      },
+      filter: ({ normalPath, isNodeModules }) => {
+        if (!this.#computeDependencies) {
+          return false;
+        }
+        if (isNodeModules) {
+          return false;
+        }
+        const ext = normalPath.substr(normalPath.lastIndexOf("."));
+        return !excludedExtensions.has(ext);
+      },
+    };
+  }
+  getDependencies(mixedPath) {
+    if (this.#getDependencies == null) {
+      throw new Error(
+        "DependencyPlugin has not been initialized before getDependencies",
+      );
+    }
+    return this.#getDependencies(mixedPath);
+  }
+}
+exports.default = DependencyPlugin;

package/src/plugins/DependencyPlugin.js.flow

@@ -0,0 +1,144 @@
+/**
+ * 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 {
+  FileMapDelta,
+  FileMapPlugin,
+  FileMapPluginInitOptions,
+  FileMapPluginWorker,
+  Path,
+} from '../flow-types';
+
+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;
+
+  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;
+  }
+
+  async bulkUpdate(delta: FileMapDelta<?ReadonlyArray<string>>): Promise<void> {
+    // No-op: Worker already populated plugin data
+    // Plugin data is write-only from worker
+  }
+
+  onNewOrModifiedFile(
+    relativeFilePath: string,
+    pluginData: ?ReadonlyArray<string>,
+  ): void {
+    // No-op: Dependencies already in plugin data
+  }
+
+  onRemovedFile(
+    relativeFilePath: string,
+    pluginData: ?ReadonlyArray<string>,
+  ): void {
+    // No-op
+  }
+
+  assertValid(): void {
+    // No validation needed
+  }
+
+  getCacheKey(): string {
+    if (this.#dependencyExtractor != null) {
+      // Dynamic require to get extractor's cache key
+      // $FlowFixMe[unsupported-syntax] - dynamic require
+      const extractor = require(this.#dependencyExtractor);
+      return JSON.stringify({
+        extractorKey: extractor.getCacheKey?.() ?? null,
+        extractorPath: this.#dependencyExtractor,
+      });
+    }
+    return 'default-dependency-extractor';
+  }
+
+  getWorker(): FileMapPluginWorker {
+    const excludedExtensions = require('../workerExclusionList');
+
+    return {
+      worker: {
+        modulePath: require.resolve('./dependencies/worker.js'),
+        setupArgs: {
+          dependencyExtractor: this.#dependencyExtractor ?? null,
+        },
+      },
+      filter: ({normalPath, isNodeModules}) => {
+        // Respect computeDependencies flag
+        if (!this.#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',
+      );
+    }
+    return this.#getDependencies(mixedPath);
+  }
+}

package/src/plugins/HastePlugin.js

@@ -18,21 +18,25 @@ function _interopRequireDefault(e) {
 }
 const EMPTY_OBJ = {};
 const EMPTY_MAP = new Map();
+const PACKAGE_JSON = /(?:[/\\]|^)package\.json$/;
 const YIELD_EVERY_NUM_HASTE_FILES = 10000;
 class HastePlugin {
   name = "haste";
-  #rootDir;
-  #map = new Map();
-  #duplicates = new Map();
   #console;
+  #duplicates = new Map();
   #enableHastePackages;
-  #perfLogger;
+  #failValidationOnConflicts;
+  #getModuleNameByPath;
+  #hasteImplModulePath;
+  #map = new Map();
   #pathUtils;
+  #perfLogger;
   #platforms;
-  #failValidationOnConflicts;
+  #rootDir;
   constructor(options) {
-    this.#console = options.console ?? null;
+    this.#console = options.console ?? global.console;
     this.#enableHastePackages = options.enableHastePackages;
+    this.#hasteImplModulePath = options.hasteImplModulePath;
     this.#perfLogger = options.perfLogger;
     this.#platforms = options.platforms;
     this.#rootDir = options.rootDir;
@@ -42,22 +46,35 @@ class HastePlugin {
   async initialize({ files }) {
     this.#perfLogger?.point("constructHasteMap_start");
     let hasteFiles = 0;
-    for (const { baseName, canonicalPath, metadata } of files.metadataIterator({
+    for (const {
+      baseName,
+      canonicalPath,
+      pluginData: hasteId,
+    } of files.fileIterator({
       includeNodeModules: false,
       includeSymlinks: false,
     })) {
-      if (metadata[_constants.default.ID]) {
-        this.setModule(metadata[_constants.default.ID], [
-          canonicalPath,
-          this.#enableHastePackages && baseName === "package.json"
-            ? _constants.default.PACKAGE
-            : _constants.default.MODULE,
-        ]);
-        if (++hasteFiles % YIELD_EVERY_NUM_HASTE_FILES === 0) {
-          await new Promise(setImmediate);
-        }
+      if (hasteId == null) {
+        continue;
+      }
+      this.setModule(hasteId, [
+        canonicalPath,
+        this.#enableHastePackages && baseName === "package.json"
+          ? _constants.default.PACKAGE
+          : _constants.default.MODULE,
+      ]);
+      if (++hasteFiles % YIELD_EVERY_NUM_HASTE_FILES === 0) {
+        await new Promise(setImmediate);
       }
     }
+    this.#getModuleNameByPath = (mixedPath) => {
+      const result = files.lookup(mixedPath);
+      return result.exists &&
+        result.type === "f" &&
+        typeof result.pluginData === "string"
+        ? result.pluginData
+        : null;
+    };
     this.#perfLogger?.point("constructHasteMap_end");
     this.#perfLogger?.annotate({
       int: {
@@ -69,7 +86,7 @@ class HastePlugin {
     return null;
   }
   getModule(name, platform, supportsNativePlatform, type) {
-    const module = this._getModuleMetadata(
+    const module = this.#getModuleMetadata(
       name,
       platform,
       !!supportsNativePlatform,
@@ -83,14 +100,22 @@ class HastePlugin {
     }
     return null;
   }
+  getModuleNameByPath(mixedPath) {
+    if (this.#getModuleNameByPath == null) {
+      throw new Error(
+        "HastePlugin has not been initialized before getModuleNameByPath",
+      );
+    }
+    return this.#getModuleNameByPath(mixedPath) ?? null;
+  }
   getPackage(name, platform, _supportsNativePlatform) {
     return this.getModule(name, platform, null, _constants.default.PACKAGE);
   }
-  _getModuleMetadata(name, platform, supportsNativePlatform) {
+  #getModuleMetadata(name, platform, supportsNativePlatform) {
     const map = this.#map.get(name) || EMPTY_OBJ;
     const dupMap = this.#duplicates.get(name) || EMPTY_MAP;
     if (platform != null) {
-      this._assertNoDuplicates(
+      this.#assertNoDuplicates(
         name,
         platform,
         supportsNativePlatform,
@@ -101,7 +126,7 @@ class HastePlugin {
       }
     }
     if (supportsNativePlatform) {
-      this._assertNoDuplicates(
+      this.#assertNoDuplicates(
         name,
         _constants.default.NATIVE_PLATFORM,
         supportsNativePlatform,
@@ -111,7 +136,7 @@ class HastePlugin {
         return map[_constants.default.NATIVE_PLATFORM];
       }
     }
-    this._assertNoDuplicates(
+    this.#assertNoDuplicates(
       name,
       _constants.default.GENERIC_PLATFORM,
       supportsNativePlatform,
@@ -122,7 +147,7 @@ class HastePlugin {
     }
     return null;
   }
-  _assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) {
+  #assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) {
     if (relativePathSet == null) {
       return;
     }
@@ -139,15 +164,14 @@ class HastePlugin {
     );
   }
   async bulkUpdate(delta) {
-    for (const [normalPath, metadata] of delta.removed) {
-      this.onRemovedFile(normalPath, metadata);
+    for (const [normalPath, maybeHasteId] of delta.removed) {
+      this.onRemovedFile(normalPath, maybeHasteId);
     }
-    for (const [normalPath, metadata] of delta.addedOrModified) {
-      this.onNewOrModifiedFile(normalPath, metadata);
+    for (const [normalPath, maybeHasteId] of delta.addedOrModified) {
+      this.onNewOrModifiedFile(normalPath, maybeHasteId);
     }
   }
-  onNewOrModifiedFile(relativeFilePath, fileMetadata) {
-    const id = fileMetadata[_constants.default.ID] || null;
+  onNewOrModifiedFile(relativeFilePath, id) {
     if (id == null) {
       return;
     }
@@ -224,8 +248,7 @@ class HastePlugin {
     }
     hasteMapItem[platform] = module;
   }
-  onRemovedFile(relativeFilePath, fileMetadata) {
-    const moduleName = fileMetadata[_constants.default.ID] || null;
+  onRemovedFile(relativeFilePath, moduleName) {
     if (moduleName == null) {
       return;
     }
@@ -241,7 +264,7 @@ class HastePlugin {
         this.#map.set(moduleName, hasteMapItem);
       }
     }
-    this._recoverDuplicates(moduleName, relativeFilePath);
+    this.#recoverDuplicates(moduleName, relativeFilePath);
   }
   assertValid() {
     if (!this.#failValidationOnConflicts) {
@@ -252,7 +275,7 @@ class HastePlugin {
       throw new _HasteConflictsError.HasteConflictsError(conflicts);
     }
   }
-  _recoverDuplicates(moduleName, relativeFilePath) {
+  #recoverDuplicates(moduleName, relativeFilePath) {
     let dupsByPlatform = this.#duplicates.get(moduleName);
     if (dupsByPlatform == null) {
       return;
@@ -292,12 +315,12 @@ class HastePlugin {
     for (const [id, dupsByPlatform] of this.#duplicates.entries()) {
       for (const [platform, conflictingModules] of dupsByPlatform) {
         conflicts.push({
-          id,
-          platform:
-            platform === _constants.default.GENERIC_PLATFORM ? null : platform,
           absolutePaths: [...conflictingModules.keys()]
             .map((modulePath) => this.#pathUtils.normalToAbsolute(modulePath))
             .sort(),
+          id,
+          platform:
+            platform === _constants.default.GENERIC_PLATFORM ? null : platform,
           type: "duplicate",
         });
       }
@@ -330,11 +353,11 @@ class HastePlugin {
       }
       if (conflictPaths.size) {
         conflicts.push({
-          id,
-          platform: null,
           absolutePaths: [...new Set([...conflictPaths, ...basePaths])]
             .map((modulePath) => this.#pathUtils.normalToAbsolute(modulePath))
             .sort(),
+          id,
+          platform: null,
           type: "shadowing",
         });
       }
@@ -351,8 +374,30 @@ class HastePlugin {
   getCacheKey() {
     return JSON.stringify([
       this.#enableHastePackages,
+      this.#hasteImplModulePath != null
+        ? require(this.#hasteImplModulePath).getCacheKey()
+        : null,
       [...this.#platforms].sort(),
     ]);
   }
+  getWorker() {
+    return {
+      worker: {
+        modulePath: require.resolve("./haste/worker.js"),
+        setupArgs: {
+          hasteImplModulePath: this.#hasteImplModulePath ?? null,
+        },
+      },
+      filter: ({ isNodeModules, normalPath }) => {
+        if (isNodeModules) {
+          return false;
+        }
+        if (PACKAGE_JSON.test(normalPath)) {
+          return this.#enableHastePackages;
+        }
+        return this.#hasteImplModulePath != null;
+      },
+    };
+  }
 }
 exports.default = HastePlugin;