metro 0.71.3 → 0.72.2

package/src/lib/getPrependedScripts.js.flow

@@ -13,6 +13,7 @@
 import type Bundler from '../Bundler';
 import type DeltaBundler, {Module} from '../DeltaBundler';
 import type {TransformInputOptions} from '../DeltaBundler/types.flow';
+import type {ResolverInputOptions} from '../shared/types.flow';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
 
 import CountingSet from './CountingSet';
@@ -21,7 +22,6 @@ const countLines = require('./countLines');
 const getPreludeCode = require('./getPreludeCode');
 const transformHelpers = require('./transformHelpers');
 const defaults = require('metro-config/src/defaults/defaults');
-const {compile} = require('metro-hermes-compiler');
 
 async function getPrependedScripts(
   config: ConfigT,
@@ -29,6 +29,7 @@ async function getPrependedScripts(
     TransformInputOptions,
     {type: $PropertyType<TransformInputOptions, 'type'>, ...},
   >,
+  resolverOptions: ResolverInputOptions,
   bundler: Bundler,
   deltaBundler: DeltaBundler<>,
 ): Promise<$ReadOnlyArray<Module<>>> {
@@ -51,6 +52,7 @@ async function getPrependedScripts(
       resolve: await transformHelpers.getResolveDependencyFn(
         bundler,
         options.platform,
+        resolverOptions,
       ),
       transform: await transformHelpers.getTransformFn(
         [defaults.moduleSystem, ...polyfillModuleNames],
@@ -58,7 +60,10 @@ async function getPrependedScripts(
         deltaBundler,
         config,
         transformOptions,
+        resolverOptions,
       ),
+      unstable_allowRequireContext:
+        config.transformer.unstable_allowRequireContext,
       transformOptions,
       onProgress: null,
       experimentalImportBundleSupport:
@@ -87,6 +92,8 @@ function _getPrelude({
   requireCycleIgnorePatterns: $ReadOnlyArray<RegExp>,
   ...
 }): Module<> {
+  const {compile} = require('metro-hermes-compiler');
+
   const code = getPreludeCode({
     isDev: dev,
     globalPrefix,

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

@@ -11,23 +11,18 @@
 'use strict';
 
 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');
 const url = require('url');
 
 const getBoolean = (
-  query: {[string]: string},
-  opt:
-    | $TEMPORARY$string<'dev'>
-    | $TEMPORARY$string<'excludeSource'>
-    | $TEMPORARY$string<'inlineSourceMap'>
-    | $TEMPORARY$string<'minify'>
-    | $TEMPORARY$string<'modulesOnly'>
-    | $TEMPORARY$string<'runModule'>
-    | $TEMPORARY$string<'shallow'>,
+  query: $ReadOnly<{[opt: string]: string}>,
+  opt: string,
   defaultValue: boolean,
 ) =>
   query[opt] == null
@@ -35,23 +30,18 @@ const getBoolean = (
     : query[opt] === 'true' || query[opt] === '1';
 
 const getNumber = (
-  query: {[string]: string},
-  opt: $TEMPORARY$string<'runtimeBytecodeVersion'>,
+  query: $ReadOnly<{[opt: string]: string}>,
+  opt: string,
   defaultValue: null,
 ) => {
   const number = parseInt(query[opt], 10);
   return Number.isNaN(number) ? defaultValue : number;
 };
 
-const getBundleType = (bundleType: string | $TEMPORARY$string<'map'>) =>
+const getBundleType = (bundleType: string): 'map' | 'bundle' =>
   bundleType === 'map' ? bundleType : 'bundle';
 
-const getTransformProfile = (
-  transformProfile:
-    | string
-    | $TEMPORARY$string<'hermes-canary'>
-    | $TEMPORARY$string<'hermes-stable'>,
-) =>
+const getTransformProfile = (transformProfile: string): TransformProfile =>
   transformProfile === 'hermes-stable' || transformProfile === 'hermes-canary'
     ? transformProfile
     : 'default';
@@ -79,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

@@ -9,6 +9,8 @@
  */
 "use strict";
 
+var _contextModuleTemplates = require("./contextModuleTemplates");
+
 const path = require("path");
 
 const baseIgnoredInlineRequires = ["React", "react", "react-native"];
@@ -18,7 +20,8 @@ async function calcTransformerOptions(
   bundler,
   deltaBundler,
   config,
-  options
+  options,
+  resolverOptions
 ) {
   const baseOptions = {
     customTransformOptions: options.customTransformOptions,
@@ -40,15 +43,25 @@ 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:
         config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        config.transformer.unstable_allowRequireContext,
       shallow: false,
     });
     return Array.from(dependencies.keys());
@@ -88,24 +101,54 @@ async function getTransformFn(
   bundler,
   deltaBundler,
   config,
-  options
+  options,
+  resolverOptions
 ) {
   const { inlineRequires, ...transformOptions } = await calcTransformerOptions(
     entryFiles,
     bundler,
     deltaBundler,
     config,
-    options
+    options,
+    resolverOptions
   );
-  return async (path) => {
-    return await bundler.transformFile(path, {
-      ...transformOptions,
-      type: getType(transformOptions.type, path, config.resolver.assetExts),
-      inlineRequires: removeInlineRequiresBlockListFromOptions(
-        path,
-        inlineRequires
-      ),
-    });
+  return async (modulePath, requireContext) => {
+    let templateBuffer;
+
+    if (requireContext) {
+      const graph = await bundler.getDependencyGraph(); // TODO: Check delta changes to avoid having to look over all files each time
+      // this is a massive performance boost.
+      // Search against all files, this is very expensive.
+      // TODO: Maybe we could let the user specify which root to check against.
+
+      const files = graph.matchFilesWithContext(requireContext.from, {
+        filter: requireContext.filter,
+        recursive: requireContext.recursive,
+      });
+      const template = (0, _contextModuleTemplates.getContextModuleTemplate)(
+        requireContext.mode,
+        requireContext.from,
+        files
+      );
+      templateBuffer = Buffer.from(template);
+    }
+
+    return await bundler.transformFile(
+      modulePath,
+      {
+        ...transformOptions,
+        type: getType(
+          transformOptions.type,
+          modulePath,
+          config.resolver.assetExts
+        ),
+        inlineRequires: removeInlineRequiresBlockListFromOptions(
+          modulePath,
+          inlineRequires
+        ),
+      },
+      templateBuffer
+    );
   };
 }
 
@@ -121,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

@@ -16,8 +16,12 @@ import type {TransformInputOptions} from '../DeltaBundler/types.flow';
 import type {TransformOptions} from '../DeltaBundler/Worker';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
 import type {Type} from 'metro-transform-worker';
+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;
 
@@ -34,6 +38,7 @@ async function calcTransformerOptions(
   deltaBundler: DeltaBundler<>,
   config: ConfigT,
   options: TransformInputOptions,
+  resolverOptions: ResolverInputOptions,
 ): Promise<TransformOptionsWithRawInlines> {
   const baseOptions = {
     customTransformOptions: options.customTransformOptions,
@@ -59,15 +64,28 @@ 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:
         config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        config.transformer.unstable_allowRequireContext,
       shallow: false,
     });
 
@@ -109,6 +127,7 @@ async function getTransformFn(
   deltaBundler: DeltaBundler<>,
   config: ConfigT,
   options: TransformInputOptions,
+  resolverOptions: ResolverInputOptions,
 ): Promise<TransformFn<>> {
   const {inlineRequires, ...transformOptions} = await calcTransformerOptions(
     entryFiles,
@@ -116,17 +135,50 @@ async function getTransformFn(
     deltaBundler,
     config,
     options,
+    resolverOptions,
   );
 
-  return async (path: string) => {
-    return await bundler.transformFile(path, {
-      ...transformOptions,
-      type: getType(transformOptions.type, path, config.resolver.assetExts),
-      inlineRequires: removeInlineRequiresBlockListFromOptions(
-        path,
-        inlineRequires,
-      ),
-    });
+  return async (modulePath: string, requireContext: ?RequireContext) => {
+    let templateBuffer: Buffer;
+
+    if (requireContext) {
+      const graph = await bundler.getDependencyGraph();
+
+      // TODO: Check delta changes to avoid having to look over all files each time
+      // this is a massive performance boost.
+
+      // Search against all files, this is very expensive.
+      // TODO: Maybe we could let the user specify which root to check against.
+      const files = graph.matchFilesWithContext(requireContext.from, {
+        filter: requireContext.filter,
+        recursive: requireContext.recursive,
+      });
+
+      const template = getContextModuleTemplate(
+        requireContext.mode,
+        requireContext.from,
+        files,
+      );
+
+      templateBuffer = Buffer.from(template);
+    }
+
+    return await bundler.transformFile(
+      modulePath,
+      {
+        ...transformOptions,
+        type: getType(
+          transformOptions.type,
+          modulePath,
+          config.resolver.assetExts,
+        ),
+        inlineRequires: removeInlineRequiresBlockListFromOptions(
+          modulePath,
+          inlineRequires,
+        ),
+      },
+      templateBuffer,
+    );
   };
 }
 
@@ -149,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),
@@ -199,6 +215,7 @@ class ModuleResolver {
         return this._options.moduleCache.getModule(arbitrary);
 
       case "empty":
+        // $FlowFixMe[incompatible-return]
         return this._getEmptyModule();
 
       default:

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;
@@ -94,7 +96,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
     };
   }
 
-  _getEmptyModule() {
+  _getEmptyModule(): TModule | Moduleish {
     let emptyModule = this._cachedEmptyModule;
     if (!emptyModule) {
       emptyModule = this.resolveDependency(
@@ -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),
@@ -252,6 +257,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
         invariant(arbitrary != null, 'invalid asset resolution');
         return this._options.moduleCache.getModule(arbitrary);
       case 'empty':
+        // $FlowFixMe[incompatible-return]
         return this._getEmptyModule();
       default:
         (resolution.type: empty);
@@ -259,7 +265,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
     }
   }
 
-  _removeRoot(candidates: FileCandidates) {
+  _removeRoot(candidates: FileCandidates): FileCandidates {
     if (candidates.filePathPrefix) {
       candidates.filePathPrefix = path.relative(
         this._options.projectRoot,

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

@@ -129,7 +129,13 @@ function createHasteMap(config, options) {
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
-    extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
+    extensions: Array.from(
+      new Set([
+        ...config.resolver.sourceExts,
+        ...config.resolver.assetExts,
+        ...config.watcher.additionalExts,
+      ])
+    ),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
     ignorePattern: getIgnorePattern(config),

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

@@ -69,7 +69,13 @@ function createHasteMap(
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
-    extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
+    extensions: Array.from(
+      new Set([
+        ...config.resolver.sourceExts,
+        ...config.resolver.assetExts,
+        ...config.watcher.additionalExts,
+      ]),
+    ),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
     ignorePattern: getIgnorePattern(config),