metro 0.72.1 → 0.72.2

package/src/lib/parseCustomResolverOptions.js

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ * @emails oncall+metro_bundler
+ * @format
+ *
+ */
+"use strict";
+
+const nullthrows = require("nullthrows");
+
+const PREFIX = "resolver.";
+
+module.exports = function parseCustomResolverOptions(urlObj) {
+  const customResolverOptions = Object.create(null);
+  const query = nullthrows(urlObj.query);
+  Object.keys(query).forEach((key) => {
+    if (key.startsWith(PREFIX)) {
+      customResolverOptions[key.substr(PREFIX.length)] = query[key];
+    }
+  });
+  return customResolverOptions;
+};

package/src/lib/parseCustomResolverOptions.js.flow

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ *
+ * @emails oncall+metro_bundler
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {CustomResolverOptions} from '../../../metro-resolver/src/types';
+
+const nullthrows = require('nullthrows');
+
+const PREFIX = 'resolver.';
+
+module.exports = function parseCustomResolverOptions(urlObj: {
+  +query?: {[string]: string, ...},
+  ...
+}): CustomResolverOptions {
+  const customResolverOptions: {
+    __proto__: null,
+    [string]: mixed,
+    ...
+  } = Object.create(null);
+  const query = nullthrows(urlObj.query);
+
+  Object.keys(query).forEach((key: string) => {
+    if (key.startsWith(PREFIX)) {
+      customResolverOptions[key.substr(PREFIX.length)] = query[key];
+    }
+  });
+
+  return customResolverOptions;
+};

package/src/lib/parseOptionsFromUrl.js

@@ -11,6 +11,8 @@
 
 const parsePlatformFilePath = require("../node-haste/lib/parsePlatformFilePath");
 
+const parseCustomResolverOptions = require("./parseCustomResolverOptions");
+
 const parseCustomTransformOptions = require("./parseCustomTransformOptions");
 
 const nullthrows = require("nullthrows");
@@ -60,6 +62,7 @@ module.exports = function parseOptionsFromUrl(
     bundleType,
     runtimeBytecodeVersion:
       bytecodeVersion === runtimeBytecodeVersion ? bytecodeVersion : null,
+    customResolverOptions: parseCustomResolverOptions(parsedURL),
     customTransformOptions: parseCustomTransformOptions(parsedURL),
     dev: getBoolean(query, "dev", true),
     entryFile: pathname.replace(/^(?:\.?\/)?/, "./").replace(/\.[^/.]+$/, ""),

package/src/lib/parseOptionsFromUrl.js.flow

@@ -14,6 +14,7 @@ import type {BundleOptions} from '../shared/types.flow';
 import type {TransformProfile} from 'metro-babel-transformer';
 
 const parsePlatformFilePath = require('../node-haste/lib/parsePlatformFilePath');
+const parseCustomResolverOptions = require('./parseCustomResolverOptions');
 const parseCustomTransformOptions = require('./parseCustomTransformOptions');
 const nullthrows = require('nullthrows');
 const path = require('path');
@@ -68,6 +69,7 @@ module.exports = function parseOptionsFromUrl(
     bundleType,
     runtimeBytecodeVersion:
       bytecodeVersion === runtimeBytecodeVersion ? bytecodeVersion : null,
+    customResolverOptions: parseCustomResolverOptions(parsedURL),
     customTransformOptions: parseCustomTransformOptions(parsedURL),
     dev: getBoolean(query, 'dev', true),
     entryFile: pathname.replace(/^(?:\.?\/)?/, './').replace(/\.[^/.]+$/, ''),

package/src/lib/splitBundleOptions.js

@@ -15,6 +15,9 @@
 function splitBundleOptions(options) {
   return {
     entryFile: options.entryFile,
+    resolverOptions: {
+      customResolverOptions: options.customResolverOptions,
+    },
     transformOptions: {
       customTransformOptions: options.customTransformOptions,
       dev: options.dev,

package/src/lib/splitBundleOptions.js.flow

@@ -18,6 +18,9 @@ import type {BundleOptions, SplitBundleOptions} from '../shared/types.flow';
 function splitBundleOptions(options: BundleOptions): SplitBundleOptions {
   return {
     entryFile: options.entryFile,
+    resolverOptions: {
+      customResolverOptions: options.customResolverOptions,
+    },
     transformOptions: {
       customTransformOptions: options.customTransformOptions,
       dev: options.dev,

package/src/lib/transformHelpers.js

@@ -20,7 +20,8 @@ async function calcTransformerOptions(
   bundler,
   deltaBundler,
   config,
-  options
+  options,
+  resolverOptions
 ) {
   const baseOptions = {
     customTransformOptions: options.customTransformOptions,
@@ -42,11 +43,19 @@ async function calcTransformerOptions(
 
   const getDependencies = async (path) => {
     const dependencies = await deltaBundler.getDependencies([path], {
-      resolve: await getResolveDependencyFn(bundler, options.platform),
-      transform: await getTransformFn([path], bundler, deltaBundler, config, {
-        ...options,
-        minify: false,
-      }),
+      resolve: await getResolveDependencyFn(
+        bundler,
+        options.platform,
+        resolverOptions
+      ),
+      transform: await getTransformFn(
+        [path],
+        bundler,
+        deltaBundler,
+        config,
+        { ...options, minify: false },
+        resolverOptions
+      ),
       transformOptions: options,
       onProgress: null,
       experimentalImportBundleSupport:
@@ -92,14 +101,16 @@ async function getTransformFn(
   bundler,
   deltaBundler,
   config,
-  options
+  options,
+  resolverOptions
 ) {
   const { inlineRequires, ...transformOptions } = await calcTransformerOptions(
     entryFiles,
     bundler,
     deltaBundler,
     config,
-    options
+    options,
+    resolverOptions
   );
   return async (modulePath, requireContext) => {
     let templateBuffer;
@@ -153,12 +164,15 @@ function getType(type, filePath, assetExts) {
   return "module";
 }
 
-async function getResolveDependencyFn(bundler, platform) {
+async function getResolveDependencyFn(bundler, platform, resolverOptions) {
   const dependencyGraph = await await bundler.getDependencyGraph();
-  return (
-    from,
-    to // $FlowFixMe[incompatible-call]
-  ) => dependencyGraph.resolveDependency(from, to, platform);
+  return (from, to) =>
+    dependencyGraph.resolveDependency(
+      from,
+      to,
+      platform !== null && platform !== void 0 ? platform : null,
+      resolverOptions
+    );
 }
 
 module.exports = {

package/src/lib/transformHelpers.js.flow

@@ -21,6 +21,7 @@ import type {RequireContext} from './contextModule';
 import {getContextModuleTemplate} from './contextModuleTemplates';
 
 const path = require('path');
+import type {ResolverInputOptions} from '../shared/types.flow';
 
 type InlineRequiresRaw = {+blockList: {[string]: true, ...}, ...} | boolean;
 
@@ -37,6 +38,7 @@ async function calcTransformerOptions(
   deltaBundler: DeltaBundler<>,
   config: ConfigT,
   options: TransformInputOptions,
+  resolverOptions: ResolverInputOptions,
 ): Promise<TransformOptionsWithRawInlines> {
   const baseOptions = {
     customTransformOptions: options.customTransformOptions,
@@ -62,11 +64,22 @@ async function calcTransformerOptions(
 
   const getDependencies = async (path: string) => {
     const dependencies = await deltaBundler.getDependencies([path], {
-      resolve: await getResolveDependencyFn(bundler, options.platform),
-      transform: await getTransformFn([path], bundler, deltaBundler, config, {
-        ...options,
-        minify: false,
-      }),
+      resolve: await getResolveDependencyFn(
+        bundler,
+        options.platform,
+        resolverOptions,
+      ),
+      transform: await getTransformFn(
+        [path],
+        bundler,
+        deltaBundler,
+        config,
+        {
+          ...options,
+          minify: false,
+        },
+        resolverOptions,
+      ),
       transformOptions: options,
       onProgress: null,
       experimentalImportBundleSupport:
@@ -114,6 +127,7 @@ async function getTransformFn(
   deltaBundler: DeltaBundler<>,
   config: ConfigT,
   options: TransformInputOptions,
+  resolverOptions: ResolverInputOptions,
 ): Promise<TransformFn<>> {
   const {inlineRequires, ...transformOptions} = await calcTransformerOptions(
     entryFiles,
@@ -121,6 +135,7 @@ async function getTransformFn(
     deltaBundler,
     config,
     options,
+    resolverOptions,
   );
 
   return async (modulePath: string, requireContext: ?RequireContext) => {
@@ -186,12 +201,17 @@ function getType(
 async function getResolveDependencyFn(
   bundler: Bundler,
   platform: ?string,
+  resolverOptions: ResolverInputOptions,
 ): Promise<(from: string, to: string) => string> {
   const dependencyGraph = await await bundler.getDependencyGraph();
 
   return (from: string, to: string) =>
-    // $FlowFixMe[incompatible-call]
-    dependencyGraph.resolveDependency(from, to, platform);
+    dependencyGraph.resolveDependency(
+      from,
+      to,
+      platform ?? null,
+      resolverOptions,
+    );
 }
 
 module.exports = {

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

@@ -24,6 +24,7 @@ const util = require("util");
 class ModuleResolver {
   // 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.
+  // $FlowFixMe[missing-local-annot]
   constructor(options) {
     this._options = options;
     const { projectRoot, moduleCache } = this._options;
@@ -50,7 +51,9 @@ class ModuleResolver {
         this._projectRootFakeModule,
         this._options.emptyModulePath,
         false,
-        null
+        null,
+        /* resolverOptions */
+        {}
       );
       this._cachedEmptyModule = emptyModule;
     }
@@ -110,11 +113,24 @@ class ModuleResolver {
     return modulePath;
   }
 
-  resolveDependency(fromModule, moduleName, allowHaste, platform) {
+  resolveDependency(
+    fromModule,
+    moduleName,
+    allowHaste,
+    platform,
+    resolverOptions
+  ) {
     try {
+      var _resolverOptions$cust;
+
       const result = Resolver.resolve(
         {
           ...this._options,
+          customResolverOptions:
+            (_resolverOptions$cust = resolverOptions.customResolverOptions) !==
+              null && _resolverOptions$cust !== void 0
+              ? _resolverOptions$cust
+              : {},
           originModulePath: fromModule.path,
           redirectModulePath: (modulePath) =>
             this._redirectRequire(fromModule, modulePath),

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

@@ -26,6 +26,7 @@ const invariant = require('invariant');
 const Resolver = require('metro-resolver');
 const path = require('path');
 const util = require('util');
+import type {ResolverInputOptions} from '../../shared/types.flow';
 
 export type DirExistsFn = (filePath: string) => boolean;
 
@@ -78,6 +79,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
   // An empty module, the result of resolving `emptyModulePath` from the project root.
   _cachedEmptyModule: ?TModule;
 
+  // $FlowFixMe[missing-local-annot]
   constructor(options: Options<TModule, TPackage>) {
     this._options = options;
     const {projectRoot, moduleCache} = this._options;
@@ -102,6 +104,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
         this._options.emptyModulePath,
         false,
         null,
+        /* resolverOptions */ {},
       );
       this._cachedEmptyModule = emptyModule;
     }
@@ -166,11 +169,13 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
     moduleName: string,
     allowHaste: boolean,
     platform: string | null,
+    resolverOptions: ResolverInputOptions,
   ): TModule {
     try {
       const result = Resolver.resolve(
         {
           ...this._options,
+          customResolverOptions: resolverOptions.customResolverOptions ?? {},
           originModulePath: fromModule.path,
           redirectModulePath: (modulePath: string) =>
             this._redirectRequire(fromModule, modulePath),

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) {
@@ -218,22 +221,43 @@ class DependencyGraph extends EventEmitter {
     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 {
@@ -241,7 +265,8 @@ class DependencyGraph extends EventEmitter {
           this._moduleCache.getModule(from),
           to,
           true,
-          platform
+          platform,
+          resolverOptions
         ).path;
       } catch (error) {
         if (error instanceof DuplicateHasteCandidatesError) {
@@ -260,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(
@@ -241,7 +261,10 @@ class DependencyGraph extends EventEmitter {
   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,
     },
@@ -255,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 {
@@ -269,6 +306,7 @@ class DependencyGraph extends EventEmitter {
           to,
           true,
           platform,
+          resolverOptions,
         ).path;
       } catch (error) {
         if (error instanceof DuplicateHasteCandidatesError) {
@@ -285,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/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,