metro 0.83.2 → 0.83.4

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

@@ -56,8 +56,8 @@ export type PackageishCache<TPackage> = interface {
   },
 };
 
-type Options<TPackage> = $ReadOnly<{
-  assetExts: $ReadOnlySet<string>,
+type Options<TPackage> = Readonly<{
+  assetExts: ReadonlySet<string>,
   dirExists: DirExistsFn,
   disableHierarchicalLookup: boolean,
   doesFileExist: DoesFileExist,
@@ -66,20 +66,21 @@ type Options<TPackage> = $ReadOnly<{
   fileSystemLookup: FileSystemLookup,
   getHasteModulePath: (name: string, platform: ?string) => ?string,
   getHastePackagePath: (name: string, platform: ?string) => ?string,
-  mainFields: $ReadOnlyArray<string>,
+  mainFields: ReadonlyArray<string>,
   packageCache: PackageishCache<TPackage>,
-  nodeModulesPaths: $ReadOnlyArray<string>,
+  nodeModulesPaths: ReadonlyArray<string>,
   preferNativePlatform: boolean,
   projectRoot: string,
   reporter: Reporter,
   resolveAsset: ResolveAsset,
   resolveRequest: ?CustomResolver,
-  sourceExts: $ReadOnlyArray<string>,
-  unstable_conditionNames: $ReadOnlyArray<string>,
-  unstable_conditionsByPlatform: $ReadOnly<{
-    [platform: string]: $ReadOnlyArray<string>,
+  sourceExts: ReadonlyArray<string>,
+  unstable_conditionNames: ReadonlyArray<string>,
+  unstable_conditionsByPlatform: Readonly<{
+    [platform: string]: ReadonlyArray<string>,
   }>,
   unstable_enablePackageExports: boolean,
+  unstable_incrementalResolution: boolean,
 }>;
 
 export class ModuleResolver<TPackage: Packageish> {
@@ -101,13 +102,13 @@ export class ModuleResolver<TPackage: Packageish> {
       emptyModule = this.resolveDependency(
         this._projectRootFakeModulePath,
         {
-          name: this._options.emptyModulePath,
           data: {
-            key: this._options.emptyModulePath,
             asyncType: null,
             isESMImport: false,
+            key: this._options.emptyModulePath,
             locs: [],
           },
+          name: this._options.emptyModulePath,
         },
         false,
         null,
@@ -140,6 +141,7 @@ export class ModuleResolver<TPackage: Packageish> {
       unstable_conditionNames,
       unstable_conditionsByPlatform,
       unstable_enablePackageExports,
+      unstable_incrementalResolution,
     } = this._options;
 
     try {
@@ -148,31 +150,32 @@ export class ModuleResolver<TPackage: Packageish> {
           {
             allowHaste,
             assetExts,
+            customResolverOptions: resolverOptions.customResolverOptions ?? {},
             dev: resolverOptions.dev,
             disableHierarchicalLookup,
             doesFileExist,
             extraNodeModules,
             fileSystemLookup,
+            getPackage: this._getPackage,
+            getPackageForModule: (absoluteModulePath: string) =>
+              this._getPackageForModule(absoluteModulePath),
             isESMImport: dependency.data.isESMImport,
             mainFields,
             nodeModulesPaths,
+            originModulePath,
             preferNativePlatform,
             resolveAsset,
+            resolveHasteModule: (name: string) =>
+              this._options.getHasteModulePath(name, platform),
+            resolveHastePackage: (name: string) =>
+              this._options.getHastePackagePath(name, platform),
             resolveRequest,
             sourceExts,
             unstable_conditionNames,
             unstable_conditionsByPlatform,
             unstable_enablePackageExports,
+            unstable_incrementalResolution,
             unstable_logWarning: this._logWarning,
-            customResolverOptions: resolverOptions.customResolverOptions ?? {},
-            originModulePath,
-            resolveHasteModule: (name: string) =>
-              this._options.getHasteModulePath(name, platform),
-            resolveHastePackage: (name: string) =>
-              this._options.getHastePackagePath(name, platform),
-            getPackage: this._getPackage,
-            getPackageForModule: (absoluteModulePath: string) =>
-              this._getPackageForModule(absoluteModulePath),
           },
           dependency,
         ),
@@ -260,9 +263,9 @@ export class ModuleResolver<TPackage: Packageish> {
 
     return result != null
       ? {
-          rootPath: path.dirname(result.pkg.path),
           packageJson: result.pkg.read(),
           packageRelativePath: result.packageRelativePath,
+          rootPath: path.dirname(result.pkg.path),
         }
       : null;
   };
@@ -279,19 +282,19 @@ export class ModuleResolver<TPackage: Packageish> {
         // not just an arbitrary item!
         const arbitrary = getArrayLowestItem(resolution.filePaths);
         invariant(arbitrary != null, 'invalid asset resolution');
-        return {type: 'sourceFile', filePath: arbitrary};
+        return {filePath: arbitrary, type: 'sourceFile'};
       case 'empty':
         return this._getEmptyModule();
       default:
-        (resolution.type: empty);
+        resolution.type as empty;
         throw new Error('invalid type');
     }
   }
 
   _logWarning = (message: string): void => {
     this._options.reporter.update({
-      type: 'resolver_warning',
       message,
+      type: 'resolver_warning',
     });
   };
 
@@ -306,7 +309,7 @@ export class ModuleResolver<TPackage: Packageish> {
   }
 }
 
-function getArrayLowestItem(a: $ReadOnlyArray<string>): string | void {
+function getArrayLowestItem(a: ReadonlyArray<string>): string | void {
   if (a.length === 0) {
     return undefined;
   }
@@ -343,7 +346,7 @@ export class UnableToResolveError extends Error {
     originModulePath: string,
     targetModuleName: string,
     message: string,
-    options?: $ReadOnly<{
+    options?: Readonly<{
       dependency?: ?TransformResultDependency,
       cause?: Error,
     }>,
@@ -429,8 +432,8 @@ function refineDependencyLocation(
       if (isQuote(maybeQuoteBefore) && maybeQuoteBefore === maybeQuoteAfter) {
         return {
           start: {
-            line: line + 1,
             column: minColumn + offset + 1,
+            line: line + 1,
           },
         };
       }
@@ -439,13 +442,13 @@ function refineDependencyLocation(
   // Otherwise, if this is a single-line loc, return it exactly, as a range.
   if (loc.start.line === loc.end.line) {
     return {
-      start: {
-        line: loc.start.line,
-        column: loc.start.column + 1,
-      },
       end: {
-        line: loc.end.line,
         column: loc.end.column + 1,
+        line: loc.end.line,
+      },
+      start: {
+        column: loc.start.column + 1,
+        line: loc.start.line,
       },
     };
   }
@@ -453,8 +456,8 @@ function refineDependencyLocation(
   // much unnecessary context.
   return {
     start: {
-      line: loc.start.line,
       column: loc.start.column + 1,
+      line: loc.start.line,
     },
   };
 }

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

@@ -6,31 +6,42 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = createFileMap;
 var _ciInfo = _interopRequireDefault(require("ci-info"));
 var _metroFileMap = _interopRequireWildcard(require("metro-file-map"));
-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);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 function getIgnorePattern(config) {
   const { blockList, blacklistRE } = config.resolver;
@@ -63,16 +74,35 @@ function getIgnorePattern(config) {
   return ignorePattern;
 }
 function createFileMap(config, options) {
-  const dependencyExtractor =
-    options?.extractDependencies === false
-      ? null
-      : config.resolver.dependencyExtractor;
-  const computeDependencies = dependencyExtractor != null;
   const watch = options?.watch == null ? !_ciInfo.default.isCI : options.watch;
   const { enabled: autoSaveEnabled, ...autoSaveOpts } =
     config.watcher.unstable_autoSaveCache ?? {};
   const autoSave = watch && autoSaveEnabled ? autoSaveOpts : false;
-  return _metroFileMap.default.create({
+  const plugins = [];
+  let dependencyPlugin = null;
+  if (
+    config.resolver.dependencyExtractor != null &&
+    options?.extractDependencies !== false
+  ) {
+    dependencyPlugin = new _metroFileMap.DependencyPlugin({
+      dependencyExtractor: config.resolver.dependencyExtractor,
+      computeDependencies: true,
+      rootDir: config.projectRoot,
+    });
+    plugins.push(dependencyPlugin);
+  }
+  const hasteMap = new _metroFileMap.HastePlugin({
+    platforms: new Set([
+      ...config.resolver.platforms,
+      _metroFileMap.default.H.NATIVE_PLATFORM,
+    ]),
+    hasteImplModulePath: config.resolver.hasteImplModulePath,
+    enableHastePackages: config.resolver.enableGlobalPackages,
+    rootDir: config.projectRoot,
+    failValidationOnConflicts: options?.throwOnModuleCollision ?? true,
+  });
+  plugins.push(hasteMap);
+  const fileMap = new _metroFileMap.default({
     cacheManagerFactory:
       config?.unstable_fileMapCacheManagerFactory ??
       ((factoryParams) =>
@@ -83,12 +113,8 @@ function createFileMap(config, options) {
           autoSave,
         })),
     perfLoggerFactory: config.unstable_perfLoggerFactory,
-    computeDependencies,
     computeSha1: !config.watcher.unstable_lazySha1,
-    dependencyExtractor: config.resolver.dependencyExtractor,
-    enableHastePackages: config?.resolver.enableGlobalPackages,
     enableSymlinks: true,
-    enableWorkerThreads: config.watcher.unstable_workerThreads,
     extensions: Array.from(
       new Set([
         ...config.resolver.sourceExts,
@@ -97,22 +123,21 @@ function createFileMap(config, options) {
       ]),
     ),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
-    hasteImplModulePath: config.resolver.hasteImplModulePath,
     healthCheck: config.watcher.healthCheck,
     ignorePattern: getIgnorePattern(config),
     maxWorkers: config.maxWorkers,
-    mocksPattern: "",
-    platforms: [
-      ...config.resolver.platforms,
-      _metroFileMap.default.H.NATIVE_PLATFORM,
-    ],
+    plugins,
     retainAllFiles: true,
     resetCache: config.resetCache,
     rootDir: config.projectRoot,
     roots: config.watchFolders,
-    throwOnModuleCollision: options?.throwOnModuleCollision ?? true,
     useWatchman: config.resolver.useWatchman,
     watch,
     watchmanDeferStates: config.watcher.watchman.deferStates,
   });
+  return {
+    fileMap,
+    hasteMap,
+    dependencyPlugin,
+  };
 }

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

@@ -10,9 +10,14 @@
  */
 
 import type {ConfigT} from 'metro-config';
+import type {HasteMap} from 'metro-file-map';
 
 import ci from 'ci-info';
-import MetroFileMap, {DiskCacheManager} from 'metro-file-map';
+import MetroFileMap, {
+  DependencyPlugin,
+  DiskCacheManager,
+  HastePlugin,
+} from 'metro-file-map';
 
 function getIgnorePattern(config: ConfigT): RegExp {
   // For now we support both options
@@ -54,25 +59,52 @@ function getIgnorePattern(config: ConfigT): RegExp {
 
 export default function createFileMap(
   config: ConfigT,
-  options?: $ReadOnly<{
+  options?: Readonly<{
     extractDependencies?: boolean,
     watch?: boolean,
     throwOnModuleCollision?: boolean,
     cacheFilePrefix?: string,
   }>,
-): MetroFileMap {
-  const dependencyExtractor =
-    options?.extractDependencies === false
-      ? null
-      : config.resolver.dependencyExtractor;
-  const computeDependencies = dependencyExtractor != null;
-
+): {
+  fileMap: MetroFileMap,
+  hasteMap: HasteMap,
+  dependencyPlugin: ?DependencyPlugin,
+} {
   const watch = options?.watch == null ? !ci.isCI : options.watch;
   const {enabled: autoSaveEnabled, ...autoSaveOpts} =
     config.watcher.unstable_autoSaveCache ?? {};
   const autoSave = watch && autoSaveEnabled ? autoSaveOpts : false;
 
-  return MetroFileMap.create({
+  const plugins: Array<DependencyPlugin | HastePlugin> = [];
+
+  let dependencyPlugin = null;
+  // Add DependencyPlugin if dependencies should be extracted
+  if (
+    config.resolver.dependencyExtractor != null &&
+    options?.extractDependencies !== false
+  ) {
+    dependencyPlugin = new DependencyPlugin({
+      dependencyExtractor: config.resolver.dependencyExtractor,
+      computeDependencies: true,
+      rootDir: config.projectRoot,
+    });
+    plugins.push(dependencyPlugin);
+  }
+
+  const hasteMap = new HastePlugin({
+    platforms: new Set([
+      ...config.resolver.platforms,
+      MetroFileMap.H.NATIVE_PLATFORM,
+    ]),
+    hasteImplModulePath: config.resolver.hasteImplModulePath,
+    enableHastePackages: config.resolver.enableGlobalPackages,
+    rootDir: config.projectRoot,
+    failValidationOnConflicts: options?.throwOnModuleCollision ?? true,
+  });
+
+  plugins.push(hasteMap);
+
+  const fileMap = new MetroFileMap({
     cacheManagerFactory:
       config?.unstable_fileMapCacheManagerFactory ??
       (factoryParams =>
@@ -83,12 +115,8 @@ export default function createFileMap(
           autoSave,
         })),
     perfLoggerFactory: config.unstable_perfLoggerFactory,
-    computeDependencies,
     computeSha1: !config.watcher.unstable_lazySha1,
-    dependencyExtractor: config.resolver.dependencyExtractor,
-    enableHastePackages: config?.resolver.enableGlobalPackages,
     enableSymlinks: true,
-    enableWorkerThreads: config.watcher.unstable_workerThreads,
     extensions: Array.from(
       new Set([
         ...config.resolver.sourceExts,
@@ -97,19 +125,17 @@ export default function createFileMap(
       ]),
     ),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
-    hasteImplModulePath: config.resolver.hasteImplModulePath,
     healthCheck: config.watcher.healthCheck,
     ignorePattern: getIgnorePattern(config),
     maxWorkers: config.maxWorkers,
-    mocksPattern: '',
-    platforms: [...config.resolver.platforms, MetroFileMap.H.NATIVE_PLATFORM],
+    plugins,
     retainAllFiles: true,
     resetCache: config.resetCache,
     rootDir: config.projectRoot,
     roots: config.watchFolders,
-    throwOnModuleCollision: options?.throwOnModuleCollision ?? true,
     useWatchman: config.resolver.useWatchman,
     watch,
     watchmanDeferStates: config.watcher.watchman.deferStates,
   });
+  return {fileMap, hasteMap, dependencyPlugin};
 }

package/src/node-haste/DependencyGraph.js

@@ -20,7 +20,11 @@ var _metroResolver = require("metro-resolver");
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const { createActionStartEntry, createActionEndEntry, log } = _metroCore.Logger;
 const NULL_PLATFORM = Symbol();
@@ -34,6 +38,7 @@ function getOrCreateMap(map, field) {
 }
 class DependencyGraph extends _events.default {
   #packageCache;
+  #dependencyPlugin;
   constructor(config, options) {
     super();
     this._config = config;
@@ -45,32 +50,34 @@ class DependencyGraph extends _events.default {
       type: "dep_graph_loading",
       hasReducedPerformance: !!hasReducedPerformance,
     });
-    const fileMap = (0, _createFileMap.default)(config, {
-      throwOnModuleCollision: false,
-      watch,
-    });
+    const { fileMap, hasteMap, dependencyPlugin } = (0, _createFileMap.default)(
+      config,
+      {
+        throwOnModuleCollision: false,
+        watch,
+      },
+    );
     fileMap.setMaxListeners(1000);
     this._haste = fileMap;
     this._haste.on("status", (status) => this._onWatcherStatus(status));
-    this._initializedPromise = fileMap
-      .build()
-      .then(({ fileSystem, hasteMap }) => {
-        log(createActionEndEntry(initializingMetroLogEntry));
-        config.reporter.update({
-          type: "dep_graph_loaded",
-        });
-        this._fileSystem = fileSystem;
-        this._hasteMap = hasteMap;
-        this._haste.on("change", (changeEvent) =>
-          this._onHasteChange(changeEvent),
-        );
-        this._haste.on("healthCheck", (result) =>
-          this._onWatcherHealthCheck(result),
-        );
-        this._resolutionCache = new Map();
-        this.#packageCache = this._createPackageCache();
-        this._createModuleResolver();
+    this._initializedPromise = fileMap.build().then(({ fileSystem }) => {
+      log(createActionEndEntry(initializingMetroLogEntry));
+      config.reporter.update({
+        type: "dep_graph_loaded",
       });
+      this._fileSystem = fileSystem;
+      this._hasteMap = hasteMap;
+      this.#dependencyPlugin = dependencyPlugin;
+      this._haste.on("change", (changeEvent) =>
+        this._onHasteChange(changeEvent),
+      );
+      this._haste.on("healthCheck", (result) =>
+        this._onWatcherHealthCheck(result),
+      );
+      this._resolutionCache = new Map();
+      this.#packageCache = this._createPackageCache();
+      this._createModuleResolver();
+    });
   }
   _onWatcherHealthCheck(result) {
     this._config.reporter.update({
@@ -87,11 +94,6 @@ class DependencyGraph extends _events.default {
   async ready() {
     await this._initializedPromise;
   }
-  static async load(config, options) {
-    const self = new DependencyGraph(config, options);
-    await self.ready();
-    return self;
-  }
   _onHasteChange({ eventsQueue }) {
     this._resolutionCache = new Map();
     eventsQueue.forEach(({ filePath }) =>
@@ -124,7 +126,7 @@ class DependencyGraph extends _events.default {
       },
       disableHierarchicalLookup:
         this._config.resolver.disableHierarchicalLookup,
-      doesFileExist: this._doesFileExist,
+      doesFileExist: this.doesFileExist,
       emptyModulePath: this._config.resolver.emptyModulePath,
       extraNodeModules: this._config.resolver.extraNodeModules,
       fileSystemLookup,
@@ -157,6 +159,8 @@ class DependencyGraph extends _events.default {
         this._config.resolver.unstable_conditionsByPlatform,
       unstable_enablePackageExports:
         this._config.resolver.unstable_enablePackageExports,
+      unstable_incrementalResolution:
+        this._config.resolver.unstable_incrementalResolution,
     });
   }
   _getClosestPackage(absoluteModulePath) {
@@ -276,18 +280,27 @@ class DependencyGraph extends _events.default {
     mapByPlatform.set(platformKey, resolution);
     return resolution;
   }
-  _doesFileExist = (filePath) => {
+  doesFileExist = (filePath) => {
     return this._fileSystem.exists(filePath);
   };
   getHasteName(filePath) {
-    const hasteName = this._fileSystem.getModuleName(filePath);
+    const hasteName = this._hasteMap.getModuleNameByPath(filePath);
     if (hasteName) {
       return hasteName;
     }
     return _path.default.relative(this._config.projectRoot, filePath);
   }
   getDependencies(filePath) {
-    return (0, _nullthrows.default)(this._fileSystem.getDependencies(filePath));
+    if (!this.#dependencyPlugin) {
+      throw new Error(
+        "getDependencies called but extractDependencies is false",
+      );
+    }
+    return Array.from(
+      (0, _nullthrows.default)(
+        this.#dependencyPlugin.getDependencies(filePath),
+      ),
+    );
   }
 }
 exports.default = DependencyGraph;