metro 0.71.3 → 0.72.2

package/src/DeltaBundler/graphOperations.js.flow

@@ -30,6 +30,8 @@
 
 'use strict';
 
+import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
+import type {RequireContext} from '../lib/contextModule';
 import type {
   Dependency,
   Graph,
@@ -40,7 +42,12 @@ import type {
 } from './types.flow';
 
 import CountingSet from '../lib/CountingSet';
+import {
+  deriveAbsolutePathFromContext,
+  fileMatchesContext,
+} from '../lib/contextModule';
 
+import * as path from 'path';
 const invariant = require('invariant');
 const nullthrows = require('nullthrows');
 
@@ -63,6 +70,8 @@ type NodeColor =
 
 // Private state for the graph that persists between operations.
 export opaque type PrivateState = {
+  /** Resolved context parameters from `require.context`. */
+  +resolvedContexts: Map<string, RequireContext>,
   +gc: {
     // GC state for nodes in the graph (graph.dependencies)
     +color: Map<string, NodeColor>,
@@ -79,6 +88,7 @@ function createGraph<T>(options: GraphInputOptions): Graph<T> {
     dependencies: new Map(),
     importBundleNames: new Set(),
     privateState: {
+      resolvedContexts: new Map(),
       gc: {
         color: new Map(),
         possibleCycleRoots: new Set(),
@@ -144,7 +154,7 @@ function getInternalOptions<T>({
  * dependency graph.
  * Instead of traversing the whole graph each time, it just calculates the
  * difference between runs by only traversing the added/removed dependencies.
- * To do so, it uses the passed passed graph dependencies and it mutates it.
+ * To do so, it uses the passed graph dependencies and it mutates it.
  * The paths parameter contains the absolute paths of the root files that the
  * method should traverse. Normally, these paths should be the modified files
  * since the last traversal.
@@ -266,13 +276,15 @@ async function processModule<T>(
   delta: Delta,
   options: InternalOptions<T>,
 ): Promise<Module<T>> {
+  const resolvedContext = graph.privateState.resolvedContexts.get(path);
   // Transform the file via the given option.
   // TODO: Unbind the transform method from options
-  const result = await options.transform(path);
+  const result = await options.transform(path, resolvedContext);
 
   // Get the absolute path of all sub-dependencies (some of them could have been
   // moved but maintain the same relative path).
   const currentDependencies = resolveDependencies(
+    graph,
     path,
     result.dependencies,
     options,
@@ -295,46 +307,26 @@ async function processModule<T>(
   graph.dependencies.set(module.path, module);
 
   // Diff dependencies (1/2): remove dependencies that have changed or been removed.
-  for (const [relativePath, prevDependency] of previousDependencies) {
-    const curDependency = currentDependencies.get(relativePath);
+  for (const [key, prevDependency] of previousDependencies) {
+    const curDependency = currentDependencies.get(key);
     if (
       !curDependency ||
-      curDependency.absolutePath !== prevDependency.absolutePath ||
-      (options.experimentalImportBundleSupport &&
-        curDependency.data.data.asyncType !==
-          prevDependency.data.data.asyncType)
+      !dependenciesEqual(prevDependency, curDependency, options)
     ) {
-      removeDependency(
-        module,
-        relativePath,
-        prevDependency,
-        graph,
-        delta,
-        options,
-      );
+      removeDependency(module, key, prevDependency, graph, delta, options);
     }
   }
 
   // Diff dependencies (2/2): add dependencies that have changed or been added.
   const promises = [];
-  for (const [relativePath, curDependency] of currentDependencies) {
-    const prevDependency = previousDependencies.get(relativePath);
+  for (const [key, curDependency] of currentDependencies) {
+    const prevDependency = previousDependencies.get(key);
     if (
       !prevDependency ||
-      prevDependency.absolutePath !== curDependency.absolutePath ||
-      (options.experimentalImportBundleSupport &&
-        prevDependency.data.data.asyncType !==
-          curDependency.data.data.asyncType)
+      !dependenciesEqual(prevDependency, curDependency, options)
     ) {
       promises.push(
-        addDependency(
-          module,
-          relativePath,
-          curDependency,
-          graph,
-          delta,
-          options,
-        ),
+        addDependency(module, key, curDependency, graph, delta, options),
       );
     }
   }
@@ -359,9 +351,39 @@ async function processModule<T>(
   return module;
 }
 
+function dependenciesEqual(
+  a: Dependency,
+  b: Dependency,
+  options: $ReadOnly<{experimentalImportBundleSupport: boolean, ...}>,
+): boolean {
+  return (
+    a === b ||
+    (a.absolutePath === b.absolutePath &&
+      (!options.experimentalImportBundleSupport ||
+        a.data.data.asyncType === b.data.data.asyncType) &&
+      contextParamsEqual(a.data.data.contextParams, b.data.data.contextParams))
+  );
+}
+
+function contextParamsEqual(
+  a: ?RequireContextParams,
+  b: ?RequireContextParams,
+): boolean {
+  return (
+    a === b ||
+    (a == null && b == null) ||
+    (a != null &&
+      b != null &&
+      a.recursive === b.recursive &&
+      a.filter.pattern === b.filter.pattern &&
+      a.filter.flags === b.filter.flags &&
+      a.mode === b.mode)
+  );
+}
+
 async function addDependency<T>(
   parentModule: Module<T>,
-  relativePath: string,
+  key: string,
   dependency: Dependency,
   graph: Graph<T>,
   delta: Delta,
@@ -420,18 +442,18 @@ async function addDependency<T>(
   // This means the parent's dependencies can get desynced from
   // inverseDependencies and the other fields in the case of lazy edges.
   // Not an optimal representation :(
-  parentModule.dependencies.set(relativePath, dependency);
+  parentModule.dependencies.set(key, dependency);
 }
 
 function removeDependency<T>(
   parentModule: Module<T>,
-  relativePath: string,
+  key: string,
   dependency: Dependency,
   graph: Graph<T>,
   delta: Delta,
   options: InternalOptions<T>,
 ): void {
-  parentModule.dependencies.delete(relativePath);
+  parentModule.dependencies.delete(key);
 
   const {absolutePath} = dependency;
 
@@ -461,42 +483,98 @@ function removeDependency<T>(
   }
 }
 
+/**
+ * Collect a list of context modules which include a given file.
+ */
+function markModifiedContextModules<T>(
+  graph: Graph<T>,
+  filePath: string,
+  modifiedPaths: Set<string>,
+) {
+  for (const [absolutePath, context] of graph.privateState.resolvedContexts) {
+    if (
+      !modifiedPaths.has(absolutePath) &&
+      fileMatchesContext(filePath, context)
+    ) {
+      modifiedPaths.add(absolutePath);
+    }
+  }
+}
+
 function resolveDependencies<T>(
+  graph: Graph<T>,
   parentPath: string,
   dependencies: $ReadOnlyArray<TransformResultDependency>,
   options: InternalOptions<T>,
 ): Map<string, Dependency> {
-  const resolve = (parentPath: string, result: TransformResultDependency) => {
-    const relativePath = result.name;
-    try {
-      return [
-        relativePath,
-        {
-          absolutePath: options.resolve(parentPath, relativePath),
-          data: result,
-        },
-      ];
-    } catch (error) {
-      // Ignore unavailable optional dependencies. They are guarded
-      // with a try-catch block and will be handled during runtime.
-      if (result.data.isOptional !== true) {
-        throw error;
+  const maybeResolvedDeps = new Map();
+  for (const dep of dependencies) {
+    let resolvedDep;
+
+    // `require.context`
+    const {contextParams} = dep.data;
+    if (contextParams) {
+      // Ensure the filepath has uniqueness applied to ensure multiple `require.context`
+      // statements can be used to target the same file with different properties.
+      const from = path.join(parentPath, '..', dep.name);
+      const absolutePath = deriveAbsolutePathFromContext(from, contextParams);
+
+      const resolvedContext: RequireContext = {
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
+        filter: new RegExp(
+          contextParams.filter.pattern,
+          contextParams.filter.flags,
+        ),
+      };
+
+      graph.privateState.resolvedContexts.set(absolutePath, resolvedContext);
+
+      resolvedDep = {
+        absolutePath,
+        data: dep,
+      };
+    } else {
+      try {
+        resolvedDep = {
+          absolutePath: options.resolve(parentPath, dep.name),
+          data: dep,
+        };
+
+        // This dependency may have existed previously as a require.context -
+        // clean it up.
+        graph.privateState.resolvedContexts.delete(resolvedDep.absolutePath);
+      } catch (error) {
+        // Ignore unavailable optional dependencies. They are guarded
+        // with a try-catch block and will be handled during runtime.
+        if (dep.data.isOptional !== true) {
+          throw error;
+        }
       }
     }
-    return undefined;
-  };
 
-  const resolved = dependencies.reduce(
-    (list: Array<[string, Dependency]>, result: TransformResultDependency) => {
-      const resolvedPath = resolve(parentPath, result);
-      if (resolvedPath) {
-        list.push(resolvedPath);
-      }
-      return list;
-    },
-    [],
-  );
-  return new Map(resolved);
+    const key = dep.data.key;
+    if (maybeResolvedDeps.has(key)) {
+      throw new Error(
+        `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`,
+      );
+    }
+    maybeResolvedDeps.set(key, resolvedDep);
+  }
+
+  const resolvedDeps = new Map();
+  // Return just the dependencies we successfully resolved.
+  // FIXME: This has a bad bug affecting all dependencies *after* an unresolved
+  // optional dependency. We'll need to propagate the nulls all the way to the
+  // serializer and the require() runtime to keep the dependency map from being
+  // desynced from the contents of the module.
+  for (const [key, resolvedDep] of maybeResolvedDeps) {
+    if (resolvedDep) {
+      resolvedDeps.set(key, resolvedDep);
+    }
+  }
+  return resolvedDeps;
 }
 
 /**
@@ -604,8 +682,8 @@ function releaseModule<T>(
   delta: Delta,
   options: InternalOptions<T>,
 ) {
-  for (const [relativePath, dependency] of module.dependencies) {
-    removeDependency(module, relativePath, dependency, graph, delta, options);
+  for (const [key, dependency] of module.dependencies) {
+    removeDependency(module, key, dependency, graph, delta, options);
   }
   graph.privateState.gc.color.set(module.path, 'black');
   if (!graph.privateState.gc.possibleCycleRoots.has(module.path)) {
@@ -631,6 +709,7 @@ function freeModule<T>(module: Module<T>, graph: Graph<T>, delta: Delta) {
   delta.earlyInverseDependencies.delete(module.path);
   graph.privateState.gc.possibleCycleRoots.delete(module.path);
   graph.privateState.gc.color.delete(module.path);
+  graph.privateState.resolvedContexts.delete(module.path);
 }
 
 // Mark a module as a possible cycle root
@@ -749,4 +828,5 @@ module.exports = {
   initialTraverseDependencies,
   traverseDependencies,
   reorderGraph,
+  markModifiedContextModules,
 };

package/src/DeltaBundler/types.flow.js.flow

@@ -11,6 +11,7 @@
 'use strict';
 
 import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
+import type {RequireContext} from '../lib/contextModule';
 import type {PrivateState} from './graphOperations';
 import type {JsTransformOptions} from 'metro-transform-worker';
 
@@ -31,10 +32,13 @@ export type TransformResultDependency = {
   +name: string,
 
   /**
-   * Extra data returned by the dependency extractor. Whatever is added here is
-   * blindly piped by Metro to the serializers.
+   * Extra data returned by the dependency extractor.
    */
   +data: {
+    /**
+     * A locally unique key for this dependency within the current module.
+     */
+    +key: string,
     /**
      * If not null, this dependency is due to a dynamic `import()` or `__prefetchImport()` call.
      */
@@ -104,9 +108,10 @@ export type TransformResultWithSource<T = MixedOutput> = $ReadOnly<{
   getSource: () => Buffer,
 }>;
 
-export type TransformFn<T = MixedOutput> = string => Promise<
-  TransformResultWithSource<T>,
->;
+export type TransformFn<T = MixedOutput> = (
+  string,
+  ?RequireContext,
+) => Promise<TransformResultWithSource<T>>;
 export type AllowOptionalDependenciesWithOptions = {
   +exclude: Array<string>,
 };
@@ -120,6 +125,7 @@ export type Options<T = MixedOutput> = {
   +transformOptions: TransformInputOptions,
   +onProgress: ?(numProcessed: number, total: number) => mixed,
   +experimentalImportBundleSupport: boolean,
+  +unstable_allowRequireContext: boolean,
   +shallow: boolean,
 };
 

package/src/DeltaBundler.js.flow

@@ -112,7 +112,7 @@ class DeltaBundler<T = MixedOutput> {
     return await deltaCalculator.getDelta({reset, shallow});
   }
 
-  listen(graph: Graph<T>, callback: () => mixed): () => void {
+  listen(graph: Graph<T>, callback: () => Promise<void>): () => void {
     const deltaCalculator = this._deltaCalculators.get(graph);
 
     if (!deltaCalculator) {

package/src/HmrServer.js

@@ -31,12 +31,14 @@ const {
   Logger: { createActionStartEntry, createActionEndEntry, log },
 } = require("metro-core");
 
-const { VERSION: BYTECODE_VERSION } = require("metro-hermes-compiler");
-
 const nullthrows = require("nullthrows");
 
 const url = require("url");
 
+function getBytecodeVersion() {
+  return require("metro-hermes-compiler").VERSION;
+}
+
 function send(sendFns, message) {
   const strMessage = JSON.stringify(message);
   sendFns.forEach((sendFn) => sendFn(strMessage));
@@ -75,9 +77,9 @@ class HmrServer {
     const options = parseOptionsFromUrl(
       requestUrl,
       new Set(this._config.resolver.platforms),
-      BYTECODE_VERSION
+      getBytecodeVersion()
     );
-    const { entryFile, transformOptions, graphOptions } =
+    const { entryFile, resolverOptions, transformOptions, graphOptions } =
       splitBundleOptions(options);
     /**
      * `entryFile` is relative to projectRoot, we need to use resolution function
@@ -86,7 +88,8 @@ class HmrServer {
 
     const resolutionFn = await transformHelpers.getResolveDependencyFn(
       this._bundler.getBundler(),
-      transformOptions.platform
+      transformOptions.platform,
+      resolverOptions
     );
     const resolvedEntryFilePath = resolutionFn(
       ((_this$_config$server$ = this._config.server.unstable_serverRoot) !==
@@ -96,9 +99,12 @@ class HmrServer {
       entryFile
     );
     const graphId = getGraphId(resolvedEntryFilePath, transformOptions, {
+      resolverOptions,
       shallow: graphOptions.shallow,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
     });
 
     const revPromise = this._bundler.getRevisionByGraphId(graphId);

package/src/HmrServer.js.flow

@@ -31,14 +31,13 @@ const transformHelpers = require('./lib/transformHelpers');
 const {
   Logger: {createActionStartEntry, createActionEndEntry, log},
 } = require('metro-core');
-const {VERSION: BYTECODE_VERSION} = require('metro-hermes-compiler');
 const nullthrows = require('nullthrows');
 const url = require('url');
 
 type $ReturnType<F> = $Call<<A, R>((...A) => R) => R, F>;
 export type EntryPointURL = $ReturnType<typeof url.parse>;
 
-type Client = {
+export type Client = {
   optedIntoHMR: boolean,
   revisionIds: Array<RevisionId>,
   +sendFn: string => void,
@@ -51,6 +50,10 @@ type ClientGroup = {
   +unlisten: () => void,
 };
 
+function getBytecodeVersion() {
+  return require('metro-hermes-compiler').VERSION;
+}
+
 function send(sendFns: Array<(string) => void>, message: HmrMessage): void {
   const strMessage = JSON.stringify(message);
   sendFns.forEach((sendFn: string => void) => sendFn(strMessage));
@@ -103,9 +106,9 @@ class HmrServer<TClient: Client> {
     const options = parseOptionsFromUrl(
       requestUrl,
       new Set(this._config.resolver.platforms),
-      BYTECODE_VERSION,
+      getBytecodeVersion(),
     );
-    const {entryFile, transformOptions, graphOptions} =
+    const {entryFile, resolverOptions, transformOptions, graphOptions} =
       splitBundleOptions(options);
 
     /**
@@ -115,6 +118,7 @@ class HmrServer<TClient: Client> {
     const resolutionFn = await transformHelpers.getResolveDependencyFn(
       this._bundler.getBundler(),
       transformOptions.platform,
+      resolverOptions,
     );
     const resolvedEntryFilePath = resolutionFn(
       (this._config.server.unstable_serverRoot ?? this._config.projectRoot) +
@@ -122,9 +126,12 @@ class HmrServer<TClient: Client> {
       entryFile,
     );
     const graphId = getGraphId(resolvedEntryFilePath, transformOptions, {
+      resolverOptions,
       shallow: graphOptions.shallow,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
     });
     const revPromise = this._bundler.getRevisionByGraphId(graphId);
     if (!revPromise) {

package/src/IncrementalBundler.js

@@ -71,6 +71,7 @@ class IncrementalBundler {
   async buildGraphForEntries(
     entryFiles,
     transformOptions,
+    resolverOptions,
     otherOptions = {
       onProgress: null,
       shallow: false,
@@ -80,19 +81,23 @@ class IncrementalBundler {
     const graph = await this._deltaBundler.buildGraph(absoluteEntryFiles, {
       resolve: await transformHelpers.getResolveDependencyFn(
         this._bundler,
-        transformOptions.platform
+        transformOptions.platform,
+        resolverOptions
       ),
       transform: await transformHelpers.getTransformFn(
         absoluteEntryFiles,
         this._bundler,
         this._deltaBundler,
         this._config,
-        transformOptions
+        transformOptions,
+        resolverOptions
       ),
       transformOptions,
       onProgress: otherOptions.onProgress,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
       shallow: otherOptions.shallow,
     });
 
@@ -109,6 +114,7 @@ class IncrementalBundler {
   async getDependencies(
     entryFiles,
     transformOptions,
+    resolverOptions,
     otherOptions = {
       onProgress: null,
       shallow: false,
@@ -120,19 +126,23 @@ class IncrementalBundler {
       {
         resolve: await transformHelpers.getResolveDependencyFn(
           this._bundler,
-          transformOptions.platform
+          transformOptions.platform,
+          resolverOptions
         ),
         transform: await transformHelpers.getTransformFn(
           absoluteEntryFiles,
           this._bundler,
           this._deltaBundler,
           this._config,
-          transformOptions
+          transformOptions,
+          resolverOptions
         ),
         transformOptions,
         onProgress: otherOptions.onProgress,
         experimentalImportBundleSupport:
           this._config.transformer.experimentalImportBundleSupport,
+        unstable_allowRequireContext:
+          this._config.transformer.unstable_allowRequireContext,
         shallow: otherOptions.shallow,
       }
     );
@@ -142,6 +152,7 @@ class IncrementalBundler {
   async buildGraph(
     entryFile,
     transformOptions,
+    resolverOptions,
     otherOptions = {
       onProgress: null,
       shallow: false,
@@ -150,12 +161,14 @@ class IncrementalBundler {
     const graph = await this.buildGraphForEntries(
       [entryFile],
       transformOptions,
+      resolverOptions,
       otherOptions
     );
     const { type: _, ...transformOptionsWithoutType } = transformOptions;
     const prepend = await getPrependedScripts(
       this._config,
       transformOptionsWithoutType,
+      resolverOptions,
       this._bundler,
       this._deltaBundler
     );
@@ -169,15 +182,19 @@ class IncrementalBundler {
   async initializeGraph(
     entryFile,
     transformOptions,
+    resolverOptions,
     otherOptions = {
       onProgress: null,
       shallow: false,
     }
   ) {
     const graphId = getGraphId(entryFile, transformOptions, {
+      resolverOptions,
       shallow: otherOptions.shallow,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
     });
     const revisionId = createRevisionId();
 
@@ -185,6 +202,7 @@ class IncrementalBundler {
       const { graph, prepend } = await this.buildGraph(
         entryFile,
         transformOptions,
+        resolverOptions,
         otherOptions
       );
       return {