metro 0.71.3 → 0.72.2

package/src/node-haste/DependencyGraph.js

@@ -11,6 +11,8 @@ var _metroFileMap = require("metro-file-map");
  *
  * @format
  */
+const canonicalize = require("metro-core/src/canonicalize");
+
 const createHasteMap = require("./DependencyGraph/createHasteMap");
 
 const { ModuleResolver } = require("./DependencyGraph/ModuleResolution");
@@ -34,8 +36,9 @@ const nullthrows = require("nullthrows");
 const path = require("path");
 
 const { DuplicateHasteCandidatesError } = _metroFileMap.ModuleMap;
+const NULL_PLATFORM = Symbol();
 
-function getOrCreate(map, field) {
+function getOrCreateMap(map, field) {
   let subMap = map.get(field);
 
   if (!subMap) {
@@ -208,27 +211,53 @@ class DependencyGraph extends EventEmitter {
   end() {
     this._haste.end();
   }
+  /** Given a search context, return a list of file paths matching the query. */
+
+  matchFilesWithContext(from, context) {
+    return this._hasteFS.matchFilesWithContext(from, context);
+  }
 
   resolveDependency(
     from,
     to,
     platform,
+    resolverOptions, // TODO: Fold assumeFlatNodeModules into resolverOptions and add to graphId
     { assumeFlatNodeModules } = {
       assumeFlatNodeModules: false,
     }
   ) {
+    var _JSON$stringify, _resolverOptions$cust;
+
     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 === ".." || // Preserve standard assumptions under node_modules
-      from.includes(path.sep + "node_modules" + path.sep);
-    const mapByDirectory = getOrCreate(
-      this._resolutionCache,
-      isSensitiveToOriginFolder ? path.dirname(from) : ""
+      from.includes(path.sep + "node_modules" + path.sep); // Compound key for the resolver cache
+
+    const resolverOptionsKey =
+      (_JSON$stringify = JSON.stringify(
+        (_resolverOptions$cust = resolverOptions.customResolverOptions) !==
+          null && _resolverOptions$cust !== void 0
+          ? _resolverOptions$cust
+          : {},
+        canonicalize
+      )) !== null && _JSON$stringify !== void 0
+        ? _JSON$stringify
+        : "";
+    const originKey = isSensitiveToOriginFolder ? path.dirname(from) : "";
+    const targetKey = to;
+    const platformKey =
+      platform !== null && platform !== void 0 ? platform : NULL_PLATFORM; // Traverse the resolver cache, which is a tree of maps
+
+    const mapByResolverOptions = this._resolutionCache;
+    const mapByOrigin = getOrCreateMap(
+      mapByResolverOptions,
+      resolverOptionsKey
     );
-    const mapByPlatform = getOrCreate(mapByDirectory, to);
-    let modulePath = mapByPlatform.get(platform);
+    const mapByTarget = getOrCreateMap(mapByOrigin, originKey);
+    const mapByPlatform = getOrCreateMap(mapByTarget, targetKey);
+    let modulePath = mapByPlatform.get(platformKey);
 
     if (!modulePath) {
       try {
@@ -236,7 +265,8 @@ class DependencyGraph extends EventEmitter {
           this._moduleCache.getModule(from),
           to,
           true,
-          platform
+          platform,
+          resolverOptions
         ).path;
       } catch (error) {
         if (error instanceof DuplicateHasteCandidatesError) {
@@ -255,7 +285,7 @@ class DependencyGraph extends EventEmitter {
       }
     }
 
-    mapByPlatform.set(platform, modulePath);
+    mapByPlatform.set(platformKey, modulePath);
     return modulePath;
   }
 

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

@@ -15,6 +15,7 @@ import type Module from './Module';
 
 import {ModuleMap as MetroFileMapModuleMap} from 'metro-file-map';
 
+const canonicalize = require('metro-core/src/canonicalize');
 const createHasteMap = require('./DependencyGraph/createHasteMap');
 const {ModuleResolver} = require('./DependencyGraph/ModuleResolution');
 const ModuleCache = require('./ModuleCache');
@@ -28,13 +29,16 @@ const {
 const {InvalidPackageError} = require('metro-resolver');
 const nullthrows = require('nullthrows');
 const path = require('path');
+import type {ResolverInputOptions} from '../shared/types.flow';
 
 const {DuplicateHasteCandidatesError} = MetroFileMapModuleMap;
 
-function getOrCreate<T>(
-  map: Map<string, Map<string, T>>,
+const NULL_PLATFORM = Symbol();
+
+function getOrCreateMap<T>(
+  map: Map<string | symbol, Map<string | symbol, T>>,
   field: string,
-): Map<string, T> {
+): Map<string | symbol, T> {
   let subMap = map.get(field);
   if (!subMap) {
     subMap = new Map();
@@ -51,7 +55,23 @@ class DependencyGraph extends EventEmitter {
   _moduleCache: ModuleCache;
   _moduleMap: MetroFileMapModuleMap;
   _moduleResolver: ModuleResolver<Module, Package>;
-  _resolutionCache: Map<string, Map<string, Map<string, string>>>;
+  _resolutionCache: Map<
+    // Custom resolver options
+    string | symbol,
+    Map<
+      // Origin folder
+      string | symbol,
+      Map<
+        // Dependency name
+        string | symbol,
+        Map<
+          // Platform
+          string | symbol,
+          string,
+        >,
+      >,
+    >,
+  >;
   _readyPromise: Promise<void>;
 
   constructor(
@@ -179,7 +199,7 @@ class DependencyGraph extends EventEmitter {
     });
   }
 
-  _createModuleCache() {
+  _createModuleCache(): ModuleCache {
     return new ModuleCache({
       // $FlowFixMe[method-unbinding] added when improving typing for this parameters
       getClosestPackage: this._getClosestPackage.bind(this),
@@ -225,10 +245,26 @@ class DependencyGraph extends EventEmitter {
     this._haste.end();
   }
 
+  /** Given a search context, return a list of file paths matching the query. */
+  matchFilesWithContext(
+    from: string,
+    context: $ReadOnly<{
+      /* Should search for files recursively. */
+      recursive: boolean,
+      /* Filter relative paths against a pattern. */
+      filter: RegExp,
+    }>,
+  ): string[] {
+    return this._hasteFS.matchFilesWithContext(from, context);
+  }
+
   resolveDependency(
     from: string,
     to: string,
-    platform: string,
+    platform: string | null,
+    resolverOptions: ResolverInputOptions,
+
+    // TODO: Fold assumeFlatNodeModules into resolverOptions and add to graphId
     {assumeFlatNodeModules}: {assumeFlatNodeModules: boolean} = {
       assumeFlatNodeModules: false,
     },
@@ -242,12 +278,26 @@ class DependencyGraph extends EventEmitter {
       to === '..' ||
       // Preserve standard assumptions under node_modules
       from.includes(path.sep + 'node_modules' + path.sep);
-    const mapByDirectory = getOrCreate(
-      this._resolutionCache,
-      isSensitiveToOriginFolder ? path.dirname(from) : '',
+
+    // Compound key for the resolver cache
+    const resolverOptionsKey =
+      JSON.stringify(
+        resolverOptions.customResolverOptions ?? {},
+        canonicalize,
+      ) ?? '';
+    const originKey = isSensitiveToOriginFolder ? path.dirname(from) : '';
+    const targetKey = to;
+    const platformKey = platform ?? NULL_PLATFORM;
+
+    // Traverse the resolver cache, which is a tree of maps
+    const mapByResolverOptions = this._resolutionCache;
+    const mapByOrigin = getOrCreateMap(
+      mapByResolverOptions,
+      resolverOptionsKey,
     );
-    const mapByPlatform = getOrCreate(mapByDirectory, to);
-    let modulePath = mapByPlatform.get(platform);
+    const mapByTarget = getOrCreateMap(mapByOrigin, originKey);
+    const mapByPlatform = getOrCreateMap(mapByTarget, targetKey);
+    let modulePath = mapByPlatform.get(platformKey);
 
     if (!modulePath) {
       try {
@@ -256,6 +306,7 @@ class DependencyGraph extends EventEmitter {
           to,
           true,
           platform,
+          resolverOptions,
         ).path;
       } catch (error) {
         if (error instanceof DuplicateHasteCandidatesError) {
@@ -272,7 +323,7 @@ class DependencyGraph extends EventEmitter {
       }
     }
 
-    mapByPlatform.set(platform, modulePath);
+    mapByPlatform.set(platformKey, modulePath);
     return modulePath;
   }
 

package/src/node-haste/Module.js

@@ -12,6 +12,7 @@
 const isAbsolutePath = require("absolute-path");
 
 class Module {
+  // $FlowFixMe[missing-local-annot]
   constructor(file, moduleCache) {
     if (!isAbsolutePath(file)) {
       throw new Error("Expected file to be absolute path but got " + file);

package/src/node-haste/Module.js.flow

@@ -21,6 +21,7 @@ class Module {
   _moduleCache: ModuleCache;
   _sourceCode: ?string;
 
+  // $FlowFixMe[missing-local-annot]
   constructor(file: string, moduleCache: ModuleCache) {
     if (!isAbsolutePath(file)) {
       throw new Error('Expected file to be absolute path but got ' + file);

package/src/shared/output/bundle.flow.js

@@ -0,0 +1,67 @@
+/**
+ * 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
+ */
+"use strict";
+
+const relativizeSourceMapInline = require("../../lib/relativizeSourceMap");
+
+const Server = require("../../Server");
+
+const writeFile = require("./writeFile");
+
+function buildBundle(packagerClient, requestOptions) {
+  return packagerClient.build({
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: "bundle",
+  });
+}
+
+function relativateSerializedMap(map, sourceMapSourcesRoot) {
+  const sourceMap = JSON.parse(map);
+  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
+  return JSON.stringify(sourceMap);
+}
+
+async function saveBundleAndMap(bundle, options, log) {
+  const {
+    bundleOutput,
+    bundleEncoding: encoding,
+    sourcemapOutput,
+    sourcemapSourcesRoot,
+  } = options;
+  const writeFns = [];
+  writeFns.push(async () => {
+    log("Writing bundle output to:", bundleOutput);
+    await writeFile(bundleOutput, bundle.code, encoding);
+    log("Done writing bundle output");
+  });
+
+  if (sourcemapOutput) {
+    let { map } = bundle;
+
+    if (sourcemapSourcesRoot !== undefined) {
+      log("start relativating source map");
+      map = relativateSerializedMap(map, sourcemapSourcesRoot);
+      log("finished relativating");
+    }
+
+    writeFns.push(async () => {
+      log("Writing sourcemap output to:", sourcemapOutput);
+      await writeFile(sourcemapOutput, map, null);
+      log("Done writing sourcemap output");
+    });
+  } // Wait until everything is written to disk.
+
+  await Promise.all(writeFns.map((cb) => cb()));
+}
+
+exports.build = buildBundle;
+exports.save = saveBundleAndMap;
+exports.formatName = "bundle";

package/src/shared/output/bundle.flow.js.flow

@@ -0,0 +1,89 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict';
+
+import type {OutputOptions, RequestOptions} from '../types.flow';
+import type {MixedSourceMap} from 'metro-source-map';
+
+const relativizeSourceMapInline = require('../../lib/relativizeSourceMap');
+const Server = require('../../Server');
+const writeFile = require('./writeFile');
+
+function buildBundle(
+  packagerClient: Server,
+  requestOptions: RequestOptions,
+): Promise<{
+  code: string,
+  map: string,
+  ...
+}> {
+  return packagerClient.build({
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: 'bundle',
+  });
+}
+
+function relativateSerializedMap(
+  map: string,
+  sourceMapSourcesRoot: string,
+): string {
+  const sourceMap = (JSON.parse(map): MixedSourceMap);
+  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
+  return JSON.stringify(sourceMap);
+}
+
+async function saveBundleAndMap(
+  bundle: {
+    code: string,
+    map: string,
+    ...
+  },
+  options: OutputOptions,
+  log: (...args: Array<string>) => void,
+): Promise<mixed> {
+  const {
+    bundleOutput,
+    bundleEncoding: encoding,
+    sourcemapOutput,
+    sourcemapSourcesRoot,
+  } = options;
+
+  const writeFns = [];
+
+  writeFns.push(async () => {
+    log('Writing bundle output to:', bundleOutput);
+    await writeFile(bundleOutput, bundle.code, encoding);
+    log('Done writing bundle output');
+  });
+
+  if (sourcemapOutput) {
+    let {map} = bundle;
+    if (sourcemapSourcesRoot !== undefined) {
+      log('start relativating source map');
+      map = relativateSerializedMap(map, sourcemapSourcesRoot);
+      log('finished relativating');
+    }
+
+    writeFns.push(async () => {
+      log('Writing sourcemap output to:', sourcemapOutput);
+      await writeFile(sourcemapOutput, map, null);
+      log('Done writing sourcemap output');
+    });
+  }
+
+  // Wait until everything is written to disk.
+  await Promise.all(writeFns.map((cb: void => mixed) => cb()));
+}
+
+exports.build = buildBundle;
+exports.save = saveBundleAndMap;
+exports.formatName = 'bundle';

package/src/shared/output/bundle.js

@@ -8,60 +8,13 @@
  * @format
  */
 "use strict";
+/*::
+export type * from './bundle.flow';
+*/
 
-const relativizeSourceMapInline = require("../../lib/relativizeSourceMap");
+try {
+  // $FlowFixMe[untyped-import]
+  require("metro-babel-register").unstable_registerForMetroMonorepo();
+} catch {}
 
-const Server = require("../../Server");
-
-const writeFile = require("./writeFile");
-
-function buildBundle(packagerClient, requestOptions) {
-  return packagerClient.build({
-    ...Server.DEFAULT_BUNDLE_OPTIONS,
-    ...requestOptions,
-    bundleType: "bundle",
-  });
-}
-
-function relativateSerializedMap(map, sourceMapSourcesRoot) {
-  const sourceMap = JSON.parse(map);
-  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
-  return JSON.stringify(sourceMap);
-}
-
-async function saveBundleAndMap(bundle, options, log) {
-  const {
-    bundleOutput,
-    bundleEncoding: encoding,
-    sourcemapOutput,
-    sourcemapSourcesRoot,
-  } = options;
-  const writeFns = [];
-  writeFns.push(async () => {
-    log("Writing bundle output to:", bundleOutput);
-    await writeFile(bundleOutput, bundle.code, encoding);
-    log("Done writing bundle output");
-  });
-
-  if (sourcemapOutput) {
-    let { map } = bundle;
-
-    if (sourcemapSourcesRoot !== undefined) {
-      log("start relativating source map");
-      map = relativateSerializedMap(map, sourcemapSourcesRoot);
-      log("finished relativating");
-    }
-
-    writeFns.push(async () => {
-      log("Writing sourcemap output to:", sourcemapOutput);
-      await writeFile(sourcemapOutput, map, null);
-      log("Done writing sourcemap output");
-    });
-  } // Wait until everything is written to disk.
-
-  await Promise.all(writeFns.map((cb) => cb()));
-}
-
-exports.build = buildBundle;
-exports.save = saveBundleAndMap;
-exports.formatName = "bundle";
+module.exports = require("./bundle.flow");

package/src/shared/output/bundle.js.flow

@@ -10,80 +10,13 @@
 
 'use strict';
 
-import type {OutputOptions, RequestOptions} from '../types.flow';
-import type {MixedSourceMap} from 'metro-source-map';
+/*::
+export type * from './bundle.flow';
+*/
 
-const relativizeSourceMapInline = require('../../lib/relativizeSourceMap');
-const Server = require('../../Server');
-const writeFile = require('./writeFile');
+try {
+  // $FlowFixMe[untyped-import]
+  require('metro-babel-register').unstable_registerForMetroMonorepo();
+} catch {}
 
-function buildBundle(
-  packagerClient: Server,
-  requestOptions: RequestOptions,
-): Promise<{
-  code: string,
-  map: string,
-  ...
-}> {
-  return packagerClient.build({
-    ...Server.DEFAULT_BUNDLE_OPTIONS,
-    ...requestOptions,
-    bundleType: 'bundle',
-  });
-}
-
-function relativateSerializedMap(
-  map: string,
-  sourceMapSourcesRoot: string,
-): string {
-  const sourceMap = (JSON.parse(map): MixedSourceMap);
-  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
-  return JSON.stringify(sourceMap);
-}
-
-async function saveBundleAndMap(
-  bundle: {
-    code: string,
-    map: string,
-    ...
-  },
-  options: OutputOptions,
-  log: (...args: Array<string>) => void,
-): Promise<mixed> {
-  const {
-    bundleOutput,
-    bundleEncoding: encoding,
-    sourcemapOutput,
-    sourcemapSourcesRoot,
-  } = options;
-
-  const writeFns = [];
-
-  writeFns.push(async () => {
-    log('Writing bundle output to:', bundleOutput);
-    await writeFile(bundleOutput, bundle.code, encoding);
-    log('Done writing bundle output');
-  });
-
-  if (sourcemapOutput) {
-    let {map} = bundle;
-    if (sourcemapSourcesRoot !== undefined) {
-      log('start relativating source map');
-      map = relativateSerializedMap(map, sourcemapSourcesRoot);
-      log('finished relativating');
-    }
-
-    writeFns.push(async () => {
-      log('Writing sourcemap output to:', sourcemapOutput);
-      await writeFile(sourcemapOutput, map, null);
-      log('Done writing sourcemap output');
-    });
-  }
-
-  // Wait until everything is written to disk.
-  await Promise.all(writeFns.map((cb: void => mixed) => cb()));
-}
-
-exports.build = buildBundle;
-exports.save = saveBundleAndMap;
-exports.formatName = 'bundle';
+module.exports = require('./bundle.flow');

package/src/shared/types.flow.js.flow

@@ -23,6 +23,7 @@ import type {
   CustomTransformOptions,
   MinifierOptions,
 } from 'metro-transform-worker';
+import type {CustomResolverOptions} from 'metro-resolver';
 
 type BundleType =
   | 'bundle'
@@ -41,6 +42,7 @@ type MetroSourceMapOrMappings =
 
 export type BundleOptions = {
   bundleType: BundleType,
+  +customResolverOptions: CustomResolverOptions,
   customTransformOptions: CustomTransformOptions,
   dev: boolean,
   entryFile: string,
@@ -61,6 +63,10 @@ export type BundleOptions = {
   ...
 };
 
+export type ResolverInputOptions = $ReadOnly<{
+  customResolverOptions?: CustomResolverOptions,
+}>;
+
 export type SerializerOptions = {
   +sourceMapUrl: ?string,
   +sourceUrl: ?string,
@@ -77,6 +83,7 @@ export type GraphOptions = {
 // Stricter representation of BundleOptions.
 export type SplitBundleOptions = {
   +entryFile: string,
+  +resolverOptions: ResolverInputOptions,
   +transformOptions: TransformInputOptions,
   +serializerOptions: SerializerOptions,
   +graphOptions: GraphOptions,