metro 0.65.2 → 0.67.0

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

@@ -1,5 +1,5 @@
 /**
- * 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.
@@ -9,23 +9,53 @@
  */
 "use strict";
 
-const Resolver = require("metro-resolver");
+const { codeFrameColumns } = require("@babel/code-frame");
 
 const fs = require("fs");
 
 const invariant = require("invariant");
 
+const Resolver = require("metro-resolver");
+
 const path = require("path");
 
 const util = require("util");
 
-const { codeFrameColumns } = require("@babel/code-frame");
-
 class ModuleResolver {
-  static EMPTY_MODULE = require.resolve("./assets/empty-module.js");
-
+  // A module representing the project root, used as the origin when resolving `emptyModulePath`.
+  // An empty module, the result of resolving `emptyModulePath` from the project root.
   constructor(options) {
     this._options = options;
+    const { projectRoot, moduleCache } = this._options;
+    this._projectRootFakeModule = {
+      path: path.join(projectRoot, "_"),
+      getPackage: () =>
+        moduleCache.getPackageOf(this._projectRootFakeModule.path),
+
+      isHaste() {
+        throw new Error("not implemented");
+      },
+
+      getName() {
+        throw new Error("not implemented");
+      },
+    };
+  }
+
+  _getEmptyModule() {
+    let emptyModule = this._cachedEmptyModule;
+
+    if (!emptyModule) {
+      emptyModule = this.resolveDependency(
+        this._projectRootFakeModule,
+        this._options.emptyModulePath,
+        false,
+        null
+      );
+      this._cachedEmptyModule = emptyModule;
+    }
+
+    return emptyModule;
   }
 
   _redirectRequire(fromModule, modulePath) {
@@ -51,7 +81,6 @@ class ModuleResolver {
           ); // Since the redirected path is still relative to the package root,
           // we have to transform it back to be module-relative (as it
           // originally was)
-          // $FlowFixMe[incompatible-type]
 
           if (redirectedPath !== false) {
             redirectedPath =
@@ -66,7 +95,7 @@ class ModuleResolver {
         }
       } else {
         const pck = path.isAbsolute(modulePath)
-          ? moduleCache.getModule(modulePath).getPackage()
+          ? moduleCache.getPackageOf(modulePath)
           : fromModule.getPackage();
 
         if (pck) {
@@ -87,15 +116,15 @@ class ModuleResolver {
         {
           ...this._options,
           originModulePath: fromModule.path,
-          redirectModulePath: modulePath =>
+          redirectModulePath: (modulePath) =>
             this._redirectRequire(fromModule, modulePath),
           allowHaste,
           platform,
-          resolveHasteModule: name =>
+          resolveHasteModule: (name) =>
             this._options.moduleMap.getModule(name, platform, true),
-          resolveHastePackage: name =>
+          resolveHastePackage: (name) =>
             this._options.moduleMap.getPackage(name, platform, true),
-          getPackageMainPath: this._getPackageMainPath
+          getPackageMainPath: this._getPackageMainPath,
         },
         moduleName,
         platform
@@ -114,7 +143,7 @@ class ModuleResolver {
             )}`,
             `  * ${Resolver.formatFileCandidates(
               this._removeRoot(candidates.dir)
-            )}`
+            )}`,
           ].join("\n")
         );
       }
@@ -122,8 +151,8 @@ class ModuleResolver {
       if (error instanceof Resolver.FailedToResolveNameError) {
         const { dirPaths, extraPaths } = error;
         const displayDirPaths = dirPaths
-          .filter(dirPath => this._options.dirExists(dirPath))
-          .map(dirPath => path.relative(this._options.projectRoot, dirPath))
+          .filter((dirPath) => this._options.dirExists(dirPath))
+          .map((dirPath) => path.relative(this._options.projectRoot, dirPath))
           .concat(extraPaths);
         const hint = displayDirPaths.length ? " or in these directories:" : "";
         throw new UnableToResolveError(
@@ -131,12 +160,7 @@ class ModuleResolver {
           moduleName,
           [
             `${moduleName} could not be found within the project${hint || "."}`,
-            ...displayDirPaths.map(dirPath => `  ${dirPath}`),
-            "\nIf you are sure the module exists, try these steps:",
-            " 1. Clear watchman watches: watchman watch-del-all",
-            " 2. Delete node_modules and run yarn install",
-            " 3. Reset Metro's cache: yarn start --reset-cache",
-            " 4. Remove the cache: rm -rf /tmp/metro-*"
+            ...displayDirPaths.map((dirPath) => `  ${dirPath}`),
           ].join("\n")
         );
       }
@@ -145,7 +169,7 @@ class ModuleResolver {
     }
   }
 
-  _getPackageMainPath = packageJsonPath => {
+  _getPackageMainPath = (packageJsonPath) => {
     const package_ = this._options.moduleCache.getPackage(packageJsonPath);
 
     return package_.getMain(this._options.mainFields);
@@ -168,10 +192,7 @@ class ModuleResolver {
         return this._options.moduleCache.getModule(arbitrary);
 
       case "empty":
-        const { moduleCache } = this._options;
-        const module_ = moduleCache.getModule(ModuleResolver.EMPTY_MODULE);
-        invariant(module_ != null, "empty module is not available");
-        return module_;
+        return this._getEmptyModule();
 
       default:
         resolution.type;
@@ -266,11 +287,11 @@ class UnableToResolveError extends Error {
       {
         start: {
           column: column + 1,
-          line: lineNumber + 1
-        }
+          line: lineNumber + 1,
+        },
       },
       {
-        forceColor: process.env.NODE_ENV !== "test"
+        forceColor: process.env.NODE_ENV !== "test",
       }
     );
   }
@@ -278,5 +299,5 @@ class UnableToResolveError extends Error {
 
 module.exports = {
   ModuleResolver,
-  UnableToResolveError
+  UnableToResolveError,
 };

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

@@ -1,5 +1,5 @@
 /**
- * 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.
@@ -10,15 +10,7 @@
 
 'use strict';
 
-const Resolver = require('metro-resolver');
-
-const fs = require('fs');
-const invariant = require('invariant');
-const path = require('path');
-const util = require('util');
-
-const {codeFrameColumns} = require('@babel/code-frame');
-
+import type {ModuleMap} from './types';
 import type {
   CustomResolver,
   DoesFileExist,
@@ -28,54 +20,44 @@ import type {
   ResolveAsset,
 } from 'metro-resolver';
 
+const {codeFrameColumns} = require('@babel/code-frame');
+const fs = require('fs');
+const invariant = require('invariant');
+const Resolver = require('metro-resolver');
+const path = require('path');
+const util = require('util');
+
 export type DirExistsFn = (filePath: string) => boolean;
 
-export type Packageish = {
+export type Packageish = interface {
   path: string,
   redirectRequire(
     toModuleName: string,
     mainFields: $ReadOnlyArray<string>,
   ): string | false,
   getMain(mainFields: $ReadOnlyArray<string>): string,
-  ...
 };
 
-export type Moduleish = {
+export type Moduleish = interface {
   +path: string,
   getPackage(): ?Packageish,
-  ...
 };
 
-/**
- * `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,
-  ...
-};
-
-export type ModuleishCache<TModule, TPackage> = {
+export type ModuleishCache<TModule, TPackage> = interface {
   getPackage(
     name: string,
     platform?: string,
     supportsNativePlatform?: boolean,
   ): TPackage,
   getModule(path: string): TModule,
-  ...
+  getPackageOf(modulePath: string): ?TPackage,
 };
 
 type Options<TModule, TPackage> = {|
   +dirExists: DirExistsFn,
+  +disableHierarchicalLookup: boolean,
   +doesFileExist: DoesFileExist,
+  +emptyModulePath: string,
   +extraNodeModules: ?Object,
   +isAssetFile: IsAssetFile,
   +mainFields: $ReadOnlyArray<string>,
@@ -91,14 +73,42 @@ type Options<TModule, TPackage> = {|
 
 class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
   _options: Options<TModule, TPackage>;
-
-  static EMPTY_MODULE: string = require.resolve('./assets/empty-module.js');
+  // A module representing the project root, used as the origin when resolving `emptyModulePath`.
+  _projectRootFakeModule: Moduleish;
+  // An empty module, the result of resolving `emptyModulePath` from the project root.
+  _cachedEmptyModule: ?TModule;
 
   constructor(options: Options<TModule, TPackage>) {
     this._options = options;
+    const {projectRoot, moduleCache} = this._options;
+    this._projectRootFakeModule = {
+      path: path.join(projectRoot, '_'),
+      getPackage: () =>
+        moduleCache.getPackageOf(this._projectRootFakeModule.path),
+      isHaste() {
+        throw new Error('not implemented');
+      },
+      getName() {
+        throw new Error('not implemented');
+      },
+    };
+  }
+
+  _getEmptyModule() {
+    let emptyModule = this._cachedEmptyModule;
+    if (!emptyModule) {
+      emptyModule = this.resolveDependency(
+        this._projectRootFakeModule,
+        this._options.emptyModulePath,
+        false,
+        null,
+      );
+      this._cachedEmptyModule = emptyModule;
+    }
+    return emptyModule;
   }
 
-  _redirectRequire(fromModule: TModule, modulePath: string): string | false {
+  _redirectRequire(fromModule: Moduleish, modulePath: string): string | false {
     const moduleCache = this._options.moduleCache;
     try {
       if (modulePath.startsWith('.')) {
@@ -123,7 +133,6 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
           // Since the redirected path is still relative to the package root,
           // we have to transform it back to be module-relative (as it
           // originally was)
-          // $FlowFixMe[incompatible-type]
           if (redirectedPath !== false) {
             redirectedPath =
               './' +
@@ -137,7 +146,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
         }
       } else {
         const pck = path.isAbsolute(modulePath)
-          ? moduleCache.getModule(modulePath).getPackage()
+          ? moduleCache.getPackageOf(modulePath)
           : fromModule.getPackage();
 
         if (pck) {
@@ -153,7 +162,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
   }
 
   resolveDependency(
-    fromModule: TModule,
+    fromModule: Moduleish,
     moduleName: string,
     allowHaste: boolean,
     platform: string | null,
@@ -217,11 +226,6 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
           [
             `${moduleName} could not be found within the project${hint || '.'}`,
             ...displayDirPaths.map((dirPath: string) => `  ${dirPath}`),
-            '\nIf you are sure the module exists, try these steps:',
-            ' 1. Clear watchman watches: watchman watch-del-all',
-            ' 2. Delete node_modules and run yarn install',
-            " 3. Reset Metro's cache: yarn start --reset-cache",
-            ' 4. Remove the cache: rm -rf /tmp/metro-*',
           ].join('\n'),
         );
       }
@@ -249,10 +253,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
         invariant(arbitrary != null, 'invalid asset resolution');
         return this._options.moduleCache.getModule(arbitrary);
       case 'empty':
-        const {moduleCache} = this._options;
-        const module_ = moduleCache.getModule(ModuleResolver.EMPTY_MODULE);
-        invariant(module_ != null, 'empty module is not available');
-        return module_;
+        return this._getEmptyModule();
       default:
         (resolution.type: empty);
         throw new Error('invalid type');

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;
+}