metro 0.66.2 → 0.69.0

package/src/node-haste/DependencyGraph/createHasteMap.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var _jestHasteMap = _interopRequireDefault(require("jest-haste-map"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+// $FlowFixMe: Types for `jest-haste-map`
+const ci = require("ci-info");
+
+const path = require("path");
+
+const JEST_HASTE_MAP_CACHE_BREAKER = 5;
+
+function getIgnorePattern(config) {
+  // For now we support both options
+  const { blockList, blacklistRE } = config.resolver;
+  const ignorePattern = blacklistRE || blockList; // If neither option has been set, use default pattern
+
+  if (!ignorePattern) {
+    return / ^/;
+  }
+
+  const combine = (regexes) =>
+    new RegExp(
+      regexes
+        .map((regex) => "(" + regex.source.replace(/\//g, path.sep) + ")")
+        .join("|")
+    ); // If ignorePattern is an array, merge it into one
+
+  if (Array.isArray(ignorePattern)) {
+    return combine(ignorePattern);
+  }
+
+  return ignorePattern;
+}
+
+function createHasteMap(config, options) {
+  var _options$name, _options$throwOnModul;
+
+  const dependencyExtractor =
+    (options === null || options === void 0
+      ? void 0
+      : options.extractDependencies) === false
+      ? null
+      : config.resolver.dependencyExtractor;
+  const computeDependencies = dependencyExtractor != null;
+  const hasteConfig = {
+    cacheDirectory: config.hasteMapCacheDirectory,
+    computeDependencies,
+    computeSha1: true,
+    dependencyExtractor: config.resolver.dependencyExtractor,
+    extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
+    forceNodeFilesystemAPI: !config.resolver.useWatchman,
+    hasteImplModulePath: config.resolver.hasteImplModulePath,
+    hasteMapModulePath: config.resolver.unstable_hasteMapModulePath,
+    ignorePattern: getIgnorePattern(config),
+    maxWorkers: config.maxWorkers,
+    mocksPattern: "",
+    name: `${
+      (_options$name =
+        options === null || options === void 0 ? void 0 : options.name) !==
+        null && _options$name !== void 0
+        ? _options$name
+        : "metro"
+    }-${JEST_HASTE_MAP_CACHE_BREAKER}`,
+    platforms: config.resolver.platforms,
+    retainAllFiles: true,
+    resetCache: config.resetCache,
+    rootDir: config.projectRoot,
+    roots: config.watchFolders,
+    throwOnModuleCollision:
+      (_options$throwOnModul =
+        options === null || options === void 0
+          ? void 0
+          : options.throwOnModuleCollision) !== null &&
+      _options$throwOnModul !== void 0
+        ? _options$throwOnModul
+        : true,
+    useWatchman: config.resolver.useWatchman,
+    watch:
+      (options === null || options === void 0 ? void 0 : options.watch) == null
+        ? !ci.isCI
+        : options.watch,
+  };
+  return _jestHasteMap.default.create(hasteConfig);
+}
+
+module.exports = createHasteMap;

package/src/node-haste/DependencyGraph/createHasteMap.js.flow

@@ -0,0 +1,88 @@
+/**
+ * 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
+ */
+
+import type {HasteConfig, HasteMap} from './types';
+import type {ConfigT} from 'metro-config/src/configTypes.flow';
+
+// $FlowFixMe: Types for `jest-haste-map`
+import JestHasteMap from 'jest-haste-map';
+
+const ci = require('ci-info');
+const path = require('path');
+
+const JEST_HASTE_MAP_CACHE_BREAKER = 5;
+
+function getIgnorePattern(config: ConfigT): RegExp {
+  // For now we support both options
+  const {blockList, blacklistRE} = config.resolver;
+  const ignorePattern = blacklistRE || blockList;
+
+  // If neither option has been set, use default pattern
+  if (!ignorePattern) {
+    return / ^/;
+  }
+
+  const combine = regexes =>
+    new RegExp(
+      regexes
+        .map(regex => '(' + regex.source.replace(/\//g, path.sep) + ')')
+        .join('|'),
+    );
+
+  // If ignorePattern is an array, merge it into one
+  if (Array.isArray(ignorePattern)) {
+    return combine(ignorePattern);
+  }
+
+  return ignorePattern;
+}
+
+function createHasteMap(
+  config: ConfigT,
+  options?: $ReadOnly<{
+    extractDependencies?: boolean,
+    watch?: boolean,
+    throwOnModuleCollision?: boolean,
+    name?: string,
+  }>,
+): HasteMap {
+  const dependencyExtractor =
+    options?.extractDependencies === false
+      ? null
+      : config.resolver.dependencyExtractor;
+  const computeDependencies = dependencyExtractor != null;
+
+  const hasteConfig: HasteConfig = {
+    cacheDirectory: config.hasteMapCacheDirectory,
+    computeDependencies,
+    computeSha1: true,
+    dependencyExtractor: config.resolver.dependencyExtractor,
+    extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
+    forceNodeFilesystemAPI: !config.resolver.useWatchman,
+    hasteImplModulePath: config.resolver.hasteImplModulePath,
+    hasteMapModulePath: config.resolver.unstable_hasteMapModulePath,
+    ignorePattern: getIgnorePattern(config),
+    maxWorkers: config.maxWorkers,
+    mocksPattern: '',
+    name: `${options?.name ?? 'metro'}-${JEST_HASTE_MAP_CACHE_BREAKER}`,
+    platforms: config.resolver.platforms,
+    retainAllFiles: true,
+    resetCache: config.resetCache,
+    rootDir: config.projectRoot,
+    roots: config.watchFolders,
+    throwOnModuleCollision: options?.throwOnModuleCollision ?? true,
+    useWatchman: config.resolver.useWatchman,
+    watch: options?.watch == null ? !ci.isCI : options.watch,
+  };
+
+  return JestHasteMap.create(hasteConfig);
+}
+
+module.exports = createHasteMap;

package/src/node-haste/DependencyGraph/{assets/empty-module.js → types.js}

@@ -1,10 +1,10 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
  *
- * @format
  *
+ * @format
  */
 "use strict";

package/src/node-haste/DependencyGraph/types.js.flow

@@ -0,0 +1,88 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict';
+
+import type EventEmitter from 'events';
+
+// TODO(cpojer): Create a jest-types repo.
+export type HasteFS = {
+  exists(filePath: string): boolean,
+  getAllFiles(): Array<string>,
+  getDependencies(filePath: string): Array<string>,
+  getFileIterator(): Iterator<string>,
+  getModuleName(filePath: string): ?string,
+  getSha1(string): ?string,
+  matchFiles(pattern: RegExp | string): Array<string>,
+  ...
+};
+
+export type HasteConfig = $ReadOnly<{
+  cacheDirectory?: ?string,
+  computeDependencies?: ?boolean,
+  computeSha1?: ?boolean,
+  dependencyExtractor?: ?string | null,
+  enableSymlinks?: ?boolean,
+  extensions: $ReadOnlyArray<string>,
+  forceNodeFilesystemAPI?: ?boolean,
+  hasteImplModulePath?: ?string,
+  hasteMapModulePath?: ?string,
+  ignorePattern?: ?RegExp | ((str: string) => boolean),
+  maxWorkers: number,
+  mocksPattern?: ?string,
+  name: string,
+  platforms: $ReadOnlyArray<string>,
+  resetCache?: ?boolean,
+  retainAllFiles: boolean,
+  rootDir: string,
+  roots: $ReadOnlyArray<string>,
+  skipPackageJson?: ?boolean,
+  throwOnModuleCollision?: ?boolean,
+  useWatchman?: ?boolean,
+  watch?: ?boolean,
+  ...
+}>;
+
+type ModuleMapItem = {[platform: string]: ModuleMetaData};
+type ModuleMetaData = [string, number];
+type MockData = Map<string, string>;
+type ModuleMapData = Map<string, ModuleMapItem>;
+type DuplicatesSet = Map<string, number>;
+type DuplicatesIndex = Map<string, Map<string, DuplicatesSet>>;
+
+type RawModuleMap = {
+  rootDir: string,
+  duplicates: DuplicatesIndex,
+  map: ModuleMapData,
+  mocks: MockData,
+};
+
+// `jest-haste-map`'s interface for ModuleMap.
+export type ModuleMap = {
+  getModule(
+    name: string,
+    platform: string | null,
+    supportsNativePlatform: ?boolean,
+  ): ?string,
+  getPackage(
+    name: string,
+    platform: string | null,
+    supportsNativePlatform: ?boolean,
+  ): ?string,
+  getRawModuleMap(): RawModuleMap,
+  ...
+};
+
+// Interface as used by node-haste / internal tools, satisfied by JestHasteMap
+export interface HasteMap extends EventEmitter {
+  build: () => Promise<{hasteFS: HasteFS, moduleMap: ModuleMap}>;
+  end: () => void;
+  getCacheFilePath: () => string;
+}

package/src/node-haste/DependencyGraph.js

@@ -1,5 +1,9 @@
+"use strict";
+
+var _jestHasteMap = require("jest-haste-map");
+
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -7,37 +11,31 @@
  *
  * @format
  */
-"use strict";
-
-const { AmbiguousModuleResolutionError } = require("metro-core");
-
-const { DuplicateHasteCandidatesError } = require("jest-haste-map").ModuleMap;
+const createHasteMap = require("./DependencyGraph/createHasteMap");
 
-const { InvalidPackageError } = require("metro-resolver");
-
-const { PackageResolutionError } = require("metro-core");
-
-const JestHasteMap = require("jest-haste-map");
+const { ModuleResolver } = require("./DependencyGraph/ModuleResolution");
 
 const Module = require("./Module");
 
 const ModuleCache = require("./ModuleCache");
 
-const ci = require("ci-info");
+const { EventEmitter } = require("events");
 
 const fs = require("fs");
 
-const path = require("path");
+const {
+  AmbiguousModuleResolutionError,
+  Logger: { createActionStartEntry, createActionEndEntry, log },
+  PackageResolutionError,
+} = require("metro-core");
 
-const { ModuleResolver } = require("./DependencyGraph/ModuleResolution");
+const { InvalidPackageError } = require("metro-resolver");
 
-const { EventEmitter } = require("events");
+const nullthrows = require("nullthrows");
 
-const {
-  Logger: { createActionStartEntry, createActionEndEntry, log }
-} = require("metro-core");
+const path = require("path");
 
-const JEST_HASTE_MAP_CACHE_BREAKER = 5;
+const { DuplicateHasteCandidatesError } = _jestHasteMap.ModuleMap;
 
 function getOrCreate(map, field) {
   let subMap = map.get(field);
@@ -51,7 +49,6 @@ function getOrCreate(map, field) {
 }
 
 class DependencyGraph extends EventEmitter {
-  // $FlowFixMe[value-as-type]
   constructor({ config, haste, initialHasteFS, initialModuleMap }) {
     super();
     this._config = config;
@@ -59,7 +56,7 @@ class DependencyGraph extends EventEmitter {
     this._hasteFS = initialHasteFS;
     this._moduleMap = initialModuleMap;
     this._assetExtensions = new Set(
-      config.resolver.assetExts.map(asset => "." + asset)
+      config.resolver.assetExts.map((asset) => "." + asset)
     ); // $FlowFixMe[method-unbinding] added when improving typing for this parameters
 
     this._haste.on("change", this._onHasteChange.bind(this));
@@ -70,86 +67,32 @@ class DependencyGraph extends EventEmitter {
     this._createModuleResolver();
   }
 
-  static _getIgnorePattern(config) {
-    /*
-      For now we support both blockList and blacklistRE options
-    */
-    const { blockList, blacklistRE } = config.resolver;
-
-    const combine = regexes =>
-      new RegExp(
-        regexes
-          .map(regex => "(" + regex.source.replace(/\//g, path.sep) + ")")
-          .join("|")
-      ); // If `blacklistRE` is set - use it,
-    // if `blockList` is set - use it
-
-    const ignorePattern = blacklistRE || blockList; // If neither option has been set, use default pattern
-
-    if (!ignorePattern) {
-      return / ^/;
-    } // If ignorePattern is an array, merge it into one
-
-    if (Array.isArray(ignorePattern)) {
-      return combine(ignorePattern);
-    }
-
-    return ignorePattern;
-  } // $FlowFixMe[value-as-type]
-
-  static _createHaste(config, watch) {
-    const haste = new JestHasteMap({
-      cacheDirectory: config.hasteMapCacheDirectory,
-      dependencyExtractor: config.resolver.dependencyExtractor,
-      computeSha1: true,
-      extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
-      forceNodeFilesystemAPI: !config.resolver.useWatchman,
-      hasteImplModulePath: config.resolver.hasteImplModulePath,
-      ignorePattern: this._getIgnorePattern(config),
-      maxWorkers: config.maxWorkers,
-      mocksPattern: "",
-      name: "metro-" + JEST_HASTE_MAP_CACHE_BREAKER,
-      platforms: config.resolver.platforms,
-      retainAllFiles: true,
-      resetCache: config.resetCache,
-      rootDir: config.projectRoot,
-      roots: config.watchFolders,
-      throwOnModuleCollision: true,
-      useWatchman: config.resolver.useWatchman,
-      watch: watch == null ? !ci.isCI : watch
-    }); // We can have a lot of graphs listening to Haste for changes.
-    // Bump this up to silence the max listeners EventEmitter warning.
-
-    haste.setMaxListeners(1000);
-    return haste;
-  }
-
   static async load(config, options) {
+    const { hasReducedPerformance, watch } =
+      options !== null && options !== void 0 ? options : {};
     const initializingMetroLogEntry = log(
       createActionStartEntry("Initializing Metro")
     );
     config.reporter.update({
       type: "dep_graph_loading",
-      hasReducedPerformance: options
-        ? Boolean(options.hasReducedPerformance)
-        : false
+      hasReducedPerformance: !!hasReducedPerformance,
     });
+    const haste = createHasteMap(config, {
+      watch,
+    }); // We can have a lot of graphs listening to Haste for changes.
+    // Bump this up to silence the max listeners EventEmitter warning.
 
-    const haste = DependencyGraph._createHaste(
-      config,
-      options && options.watch
-    );
-
+    haste.setMaxListeners(1000);
     const { hasteFS, moduleMap } = await haste.build();
     log(createActionEndEntry(initializingMetroLogEntry));
     config.reporter.update({
-      type: "dep_graph_loaded"
+      type: "dep_graph_loaded",
     });
     return new DependencyGraph({
       haste,
       initialHasteFS: hasteFS,
       initialModuleMap: moduleMap,
-      config
+      config,
     });
   }
 
@@ -186,16 +129,19 @@ class DependencyGraph extends EventEmitter {
 
   _createModuleResolver() {
     this._moduleResolver = new ModuleResolver({
-      dirExists: filePath => {
+      dirExists: (filePath) => {
         try {
           return fs.lstatSync(filePath).isDirectory();
         } catch (e) {}
 
         return false;
       },
+      disableHierarchicalLookup:
+        this._config.resolver.disableHierarchicalLookup,
       doesFileExist: this._doesFileExist,
+      emptyModulePath: this._config.resolver.emptyModulePath,
       extraNodeModules: this._config.resolver.extraNodeModules,
-      isAssetFile: file => this._assetExtensions.has(path.extname(file)),
+      isAssetFile: (file) => this._assetExtensions.has(path.extname(file)),
       mainFields: this._config.resolver.resolverMainFields,
       moduleCache: this._moduleCache,
       moduleMap: this._moduleMap,
@@ -207,20 +153,20 @@ class DependencyGraph extends EventEmitter {
         const assets = [
           basePath + extension,
           ...this._config.resolver.assetResolutions.map(
-            resolution => basePath + "@" + resolution + "x" + extension
-          )
-        ].filter(candidate => this._hasteFS.exists(candidate));
+            (resolution) => basePath + "@" + resolution + "x" + extension
+          ),
+        ].filter((candidate) => this._hasteFS.exists(candidate));
         return assets.length ? assets : null;
       },
       resolveRequest: this._config.resolver.resolveRequest,
-      sourceExts: this._config.resolver.sourceExts
+      sourceExts: this._config.resolver.sourceExts,
     });
   }
 
   _createModuleCache() {
     return new ModuleCache({
       // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-      getClosestPackage: this._getClosestPackage.bind(this)
+      getClosestPackage: this._getClosestPackage.bind(this),
     });
   }
 
@@ -249,7 +195,7 @@ class DependencyGraph extends EventEmitter {
     }
 
     return sha1;
-  } // $FlowFixMe[value-as-type]
+  }
 
   getWatcher() {
     return this._haste;
@@ -264,25 +210,22 @@ class DependencyGraph extends EventEmitter {
     to,
     platform,
     { assumeFlatNodeModules } = {
-      assumeFlatNodeModules: false
+      assumeFlatNodeModules: false,
     }
   ) {
-    const isPath =
+    const isSensitiveToOriginFolder = // Resolution is always relative to the origin folder unless we assume a flat node_modules
+      !assumeFlatNodeModules || // Path requests are resolved relative to the origin folder
       to.includes("/") ||
       to === "." ||
-      to === ".." ||
+      to === ".." || // Preserve standard assumptions under node_modules
       from.includes(path.sep + "node_modules" + path.sep);
     const mapByDirectory = getOrCreate(
       this._resolutionCache,
-      isPath ? path.dirname(from) : ""
+      isSensitiveToOriginFolder ? path.dirname(from) : ""
     );
-    let mapByPlatform = getOrCreate(mapByDirectory, to);
+    const mapByPlatform = getOrCreate(mapByDirectory, to);
     let modulePath = mapByPlatform.get(platform);
 
-    if (!modulePath) {
-      modulePath = this._moduleMap.getModule(to, platform, true);
-    }
-
     if (!modulePath) {
       try {
         modulePath = this._moduleResolver.resolveDependency(
@@ -290,18 +233,7 @@ class DependencyGraph extends EventEmitter {
           to,
           true,
           platform
-        ).path; // If we cannot assume that only one node_modules folder exists in the project,
-        // we need to cache packages by directory instead of globally.
-
-        if (
-          !assumeFlatNodeModules &&
-          modulePath.includes(path.sep + "node_modules" + path.sep)
-        ) {
-          mapByPlatform = getOrCreate(
-            getOrCreate(this._resolutionCache, path.dirname(from)),
-            to
-          );
-        }
+        ).path;
       } catch (error) {
         if (error instanceof DuplicateHasteCandidatesError) {
           throw new AmbiguousModuleResolutionError(from, error);
@@ -311,7 +243,7 @@ class DependencyGraph extends EventEmitter {
           throw new PackageResolutionError({
             packageError: error,
             originModulePath: from,
-            targetModuleName: to
+            targetModuleName: to,
           });
         }
 
@@ -323,7 +255,7 @@ class DependencyGraph extends EventEmitter {
     return modulePath;
   }
 
-  _doesFileExist = filePath => {
+  _doesFileExist = (filePath) => {
     return this._hasteFS.exists(filePath);
   };
 
@@ -338,7 +270,7 @@ class DependencyGraph extends EventEmitter {
   }
 
   getDependencies(filePath) {
-    return this._hasteFS.getDependencies(filePath);
+    return nullthrows(this._hasteFS.getDependencies(filePath));
   }
 }