metro 0.71.3 → 0.72.2

package/src/ModuleGraph/worker/collectDependencies.js.flow

@@ -17,6 +17,7 @@ import type {
   AsyncDependencyType,
 } from 'metro/src/DeltaBundler/types.flow.js';
 
+const crypto = require('crypto');
 const generate = require('@babel/generator').default;
 const template = require('@babel/template').default;
 const traverse = require('@babel/traverse').default;
@@ -38,7 +39,7 @@ export type Dependency<TSplitCondition> = $ReadOnly<{
 }>;
 
 // TODO: Convert to a Flow enum
-type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
+export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
 
 type ContextFilter = {pattern: string, flags: string};
 
@@ -52,6 +53,8 @@ export type RequireContextParams = $ReadOnly<{
 }>;
 
 type DependencyData<TSplitCondition> = $ReadOnly<{
+  // A locally unique key for this dependency within the current module.
+  key: string,
   // If null, then the dependency is synchronous.
   // (ex. `require('foo')`)
   asyncType: AsyncDependencyType | null,
@@ -726,8 +729,9 @@ function createModuleNameLiteral(dependency: InternalDependency<mixed>) {
 
 /**
  * Given an import qualifier, return a key used to register the dependency.
- * Generally this return the `ImportQualifier.name` property, but in the case
- * of `require.context` more attributes can be appended to distinguish various combinations that would otherwise conflict.
+ * Generally this return the `ImportQualifier.name` property, but more
+ * attributes can be appended to distinguish various combinations that would
+ * otherwise conflict.
  *
  * For example, the following case would have collision issues if they all utilized the `name` property:
  * ```
@@ -743,6 +747,11 @@ function createModuleNameLiteral(dependency: InternalDependency<mixed>) {
 function getKeyForDependency(qualifier: ImportQualifier): string {
   let key = qualifier.name;
 
+  const {asyncType} = qualifier;
+  if (asyncType) {
+    key += ['', asyncType].join('\0');
+  }
+
   const {contextParams} = qualifier;
   // Add extra qualifiers when using `require.context` to prevent collisions.
   if (contextParams) {
@@ -757,7 +766,7 @@ function getKeyForDependency(qualifier: ImportQualifier): string {
       String(contextParams.filter.flags),
       contextParams.mode,
       // Join together and append to the name:
-    ].join('__');
+    ].join('\0');
   }
   return key;
 }
@@ -780,6 +789,7 @@ class DefaultModuleDependencyRegistry<TSplitCondition = void>
         asyncType: qualifier.asyncType,
         locs: [],
         index: this._dependencies.size,
+        key: crypto.createHash('sha1').update(key).digest('base64'),
       };
 
       if (qualifier.optional) {
@@ -790,15 +800,19 @@ class DefaultModuleDependencyRegistry<TSplitCondition = void>
       }
 
       dependency = newDependency;
-      this._dependencies.set(key, dependency);
     } else {
-      const original = dependency;
-      dependency = collapseDependencies(original, qualifier);
-      if (original !== dependency) {
-        this._dependencies.set(key, dependency);
+      if (dependency.isOptional && !qualifier.optional) {
+        // A previously optionally required dependency was required non-optionally.
+        // Mark it non optional for the whole module
+        dependency = {
+          ...dependency,
+          isOptional: false,
+        };
       }
     }
 
+    this._dependencies.set(key, dependency);
+
     return dependency;
   }
 
@@ -807,36 +821,4 @@ class DefaultModuleDependencyRegistry<TSplitCondition = void>
   }
 }
 
-function collapseDependencies<TSplitCondition>(
-  dependency: InternalDependency<TSplitCondition>,
-  qualifier: ImportQualifier,
-): InternalDependency<TSplitCondition> {
-  let collapsed = dependency;
-
-  // A previously optionally required dependency was required non-optionaly.
-  // Mark it non optional for the whole module
-  if (collapsed.isOptional && !qualifier.optional) {
-    collapsed = {
-      ...dependency,
-      isOptional: false,
-    };
-  }
-
-  // A previously asynchronously (or prefetch) required module was required synchronously.
-  // Make the dependency sync.
-  if (collapsed.asyncType != null && qualifier.asyncType == null) {
-    collapsed = {...dependency, asyncType: null};
-  }
-
-  // A prefetched dependency was required async in the module. Mark it as async.
-  if (collapsed.asyncType === 'prefetch' && qualifier.asyncType === 'async') {
-    collapsed = {
-      ...dependency,
-      asyncType: 'async',
-    };
-  }
-
-  return collapsed;
-}
-
 module.exports = collectDependencies;

package/src/Server.js

@@ -62,8 +62,6 @@ const {
   Logger: { createActionStartEntry, createActionEndEntry, log },
 } = require("metro-core");
 
-const { VERSION: BYTECODE_VERSION } = require("metro-hermes-compiler");
-
 const mime = require("mime-types");
 
 const nullthrows = require("nullthrows");
@@ -77,6 +75,10 @@ const url = require("url");
 const DELTA_ID_HEADER = "X-Metro-Delta-ID";
 const FILES_CHANGED_COUNT_HEADER = "X-Metro-Files-Changed-Count";
 
+function getBytecodeVersion() {
+  return require("metro-hermes-compiler").VERSION;
+}
+
 class Server {
   constructor(config, options) {
     this._config = config;
@@ -129,12 +131,14 @@ class Server {
       entryFile,
       graphOptions,
       onProgress,
+      resolverOptions,
       serializerOptions,
       transformOptions,
     } = splitBundleOptions(options);
     const { prepend, graph } = await this._bundler.buildGraph(
       entryFile,
       transformOptions,
+      resolverOptions,
       {
         onProgress,
         shallow: graphOptions.shallow,
@@ -147,8 +151,9 @@ class Server {
       asyncRequireModulePath: await this._resolveRelativePath(
         this._config.transformer.asyncRequireModulePath,
         {
-          transformOptions,
           relativeTo: "project",
+          resolverOptions,
+          transformOptions,
         }
       ),
       processModuleFilter: this._config.serializer.processModuleFilter,
@@ -217,12 +222,14 @@ class Server {
       entryFile,
       graphOptions,
       onProgress,
+      resolverOptions,
       serializerOptions,
       transformOptions,
     } = splitBundleOptions(options);
     const { prepend, graph } = await this._bundler.buildGraph(
       entryFile,
       transformOptions,
+      resolverOptions,
       {
         onProgress,
         shallow: graphOptions.shallow,
@@ -235,8 +242,9 @@ class Server {
       asyncRequireModulePath: await this._resolveRelativePath(
         this._config.transformer.asyncRequireModulePath,
         {
-          transformOptions,
           relativeTo: "project",
+          resolverOptions,
+          transformOptions,
         }
       ),
       processModuleFilter: this._config.serializer.processModuleFilter,
@@ -265,11 +273,12 @@ class Server {
   }
 
   async getAssets(options) {
-    const { entryFile, transformOptions, onProgress } =
+    const { entryFile, onProgress, resolverOptions, transformOptions } =
       splitBundleOptions(options);
     const dependencies = await this._bundler.getDependencies(
       [entryFile],
       transformOptions,
+      resolverOptions,
       {
         onProgress,
         shallow: false,
@@ -285,10 +294,15 @@ class Server {
   }
 
   async getOrderedDependencyPaths(options) {
-    /* $FlowFixMe(>=0.122.0 site=react_native_fb) This comment suppresses an
-     * error found when Flow v0.122.0 was deployed. To see the error, delete
-     * this comment and run Flow. */
-    const { entryFile, transformOptions, onProgress } = splitBundleOptions({
+    const {
+      entryFile,
+      onProgress,
+      resolverOptions,
+      transformOptions,
+      /* $FlowFixMe(>=0.122.0 site=react_native_fb) This comment suppresses an
+       * error found when Flow v0.122.0 was deployed. To see the error, delete
+       * this comment and run Flow. */
+    } = splitBundleOptions({
       ...Server.DEFAULT_BUNDLE_OPTIONS,
       ...options,
       bundleType: "bundle",
@@ -296,6 +310,7 @@ class Server {
     const { prepend, graph } = await this._bundler.buildGraph(
       entryFile,
       transformOptions,
+      resolverOptions,
       {
         onProgress,
         shallow: false,
@@ -395,7 +410,7 @@ class Server {
     return parseOptionsFromUrl(
       url,
       new Set(this._config.resolver.platforms),
-      BYTECODE_VERSION
+      getBytecodeVersion()
     );
   }
 
@@ -454,21 +469,30 @@ class Server {
     finish,
   }) {
     return async function requestProcessor(req, res, bundleOptions) {
-      const { entryFile, graphOptions, transformOptions, serializerOptions } =
-        splitBundleOptions(bundleOptions);
+      const {
+        entryFile,
+        graphOptions,
+        resolverOptions,
+        serializerOptions,
+        transformOptions,
+      } = splitBundleOptions(bundleOptions);
       /**
        * `entryFile` is relative to projectRoot, we need to use resolution function
        * to find the appropriate file with supported extensions.
        */
 
       const resolvedEntryFilePath = await this._resolveRelativePath(entryFile, {
-        transformOptions,
         relativeTo: "server",
+        resolverOptions,
+        transformOptions,
       });
       const graphId = getGraphId(resolvedEntryFilePath, transformOptions, {
-        shallow: graphOptions.shallow,
         experimentalImportBundleSupport:
           this._config.transformer.experimentalImportBundleSupport,
+        unstable_allowRequireContext:
+          this._config.transformer.unstable_allowRequireContext,
+        resolverOptions,
+        shallow: graphOptions.shallow,
       }); // For resources that support deletion, handle the DELETE method.
 
       if (deleteFn && req.method === "DELETE") {
@@ -562,6 +586,7 @@ class Server {
         mres,
         onProgress,
         req,
+        resolverOptions,
         serializerOptions,
         transformOptions,
       };
@@ -644,6 +669,7 @@ class Server {
       graphId,
       graphOptions,
       onProgress,
+      resolverOptions,
       serializerOptions,
       transformOptions,
     }) => {
@@ -653,10 +679,15 @@ class Server {
 
       const { delta, revision } = await (revPromise != null
         ? this._bundler.updateGraph(await revPromise, false)
-        : this._bundler.initializeGraph(entryFile, transformOptions, {
-            onProgress,
-            shallow: graphOptions.shallow,
-          }));
+        : this._bundler.initializeGraph(
+            entryFile,
+            transformOptions,
+            resolverOptions,
+            {
+              onProgress,
+              shallow: graphOptions.shallow,
+            }
+          ));
 
       const serializer =
         this._config.serializer.customSerializer ||
@@ -672,8 +703,9 @@ class Server {
           asyncRequireModulePath: await this._resolveRelativePath(
             this._config.transformer.asyncRequireModulePath,
             {
-              transformOptions,
               relativeTo: "project",
+              resolverOptions,
+              transformOptions,
             }
           ),
           processModuleFilter: this._config.serializer.processModuleFilter,
@@ -766,6 +798,7 @@ class Server {
       graphId,
       graphOptions,
       onProgress,
+      resolverOptions,
       serializerOptions,
       transformOptions,
     }) => {
@@ -775,17 +808,23 @@ class Server {
 
       const { delta, revision } = await (revPromise != null
         ? this._bundler.updateGraph(await revPromise, false)
-        : this._bundler.initializeGraph(entryFile, transformOptions, {
-            onProgress,
-            shallow: graphOptions.shallow,
-          }));
+        : this._bundler.initializeGraph(
+            entryFile,
+            transformOptions,
+            resolverOptions,
+            {
+              onProgress,
+              shallow: graphOptions.shallow,
+            }
+          ));
       const bundle = bundleToBytecode(
         baseBytecodeBundle(entryFile, revision.prepend, revision.graph, {
           asyncRequireModulePath: await this._resolveRelativePath(
             this._config.transformer.asyncRequireModulePath,
             {
-              transformOptions,
               relativeTo: "project",
+              resolverOptions,
+              transformOptions,
             }
           ),
           processModuleFilter: this._config.serializer.processModuleFilter,
@@ -882,6 +921,7 @@ class Server {
       graphId,
       graphOptions,
       onProgress,
+      resolverOptions,
       serializerOptions,
       transformOptions,
     }) => {
@@ -893,6 +933,7 @@ class Server {
         ({ revision } = await this._bundler.initializeGraph(
           entryFile,
           transformOptions,
+          resolverOptions,
           {
             onProgress,
             shallow: graphOptions.shallow,
@@ -938,10 +979,16 @@ class Server {
       };
     },
 
-    build: async ({ entryFile, transformOptions, onProgress }) => {
+    build: async ({
+      entryFile,
+      onProgress,
+      resolverOptions,
+      transformOptions,
+    }) => {
       const dependencies = await this._bundler.getDependencies(
         [entryFile],
         transformOptions,
+        resolverOptions,
         {
           onProgress,
           shallow: false,
@@ -1073,14 +1120,15 @@ class Server {
     const options = parseOptionsFromUrl(
       reqUrl,
       new Set(this._config.resolver.platforms),
-      BYTECODE_VERSION
+      getBytecodeVersion()
     );
     const {
       entryFile,
-      transformOptions,
-      serializerOptions,
       graphOptions,
       onProgress,
+      resolverOptions,
+      serializerOptions,
+      transformOptions,
     } = splitBundleOptions(options);
     /**
      * `entryFile` is relative to projectRoot, we need to use resolution function
@@ -1088,13 +1136,17 @@ class Server {
      */
 
     const resolvedEntryFilePath = await this._resolveRelativePath(entryFile, {
-      transformOptions,
       relativeTo: "server",
+      resolverOptions,
+      transformOptions,
     });
     const graphId = getGraphId(resolvedEntryFilePath, transformOptions, {
-      shallow: graphOptions.shallow,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
+      resolverOptions,
+      shallow: graphOptions.shallow,
     });
     let revision;
 
@@ -1104,6 +1156,7 @@ class Server {
       ({ revision } = await this._bundler.initializeGraph(
         resolvedEntryFilePath,
         transformOptions,
+        resolverOptions,
         {
           onProgress,
           shallow: graphOptions.shallow,
@@ -1127,10 +1180,14 @@ class Server {
     );
   }
 
-  async _resolveRelativePath(filePath, { transformOptions, relativeTo }) {
+  async _resolveRelativePath(
+    filePath,
+    { relativeTo, resolverOptions, transformOptions }
+  ) {
     const resolutionFn = await transformHelpers.getResolveDependencyFn(
       this._bundler.getBundler(),
-      transformOptions.platform
+      transformOptions.platform,
+      resolverOptions
     );
     const rootDir =
       relativeTo === "server"
@@ -1152,6 +1209,7 @@ class Server {
   }
 
   static DEFAULT_GRAPH_OPTIONS = {
+    customResolverOptions: Object.create(null),
     customTransformOptions: Object.create(null),
     dev: true,
     hot: false,