metro 0.71.2 → 0.72.1

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/HmrServer.js

@@ -99,6 +99,8 @@ class HmrServer {
       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

@@ -125,6 +125,8 @@ class HmrServer<TClient: Client> {
       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

@@ -93,6 +93,8 @@ class IncrementalBundler {
       onProgress: otherOptions.onProgress,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
       shallow: otherOptions.shallow,
     });
 
@@ -133,6 +135,8 @@ class IncrementalBundler {
         onProgress: otherOptions.onProgress,
         experimentalImportBundleSupport:
           this._config.transformer.experimentalImportBundleSupport,
+        unstable_allowRequireContext:
+          this._config.transformer.unstable_allowRequireContext,
         shallow: otherOptions.shallow,
       }
     );
@@ -178,6 +182,8 @@ class IncrementalBundler {
       shallow: otherOptions.shallow,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
     });
     const revisionId = createRevisionId();
 

package/src/IncrementalBundler.js.flow

@@ -123,6 +123,8 @@ class IncrementalBundler {
       onProgress: otherOptions.onProgress,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
       shallow: otherOptions.shallow,
     });
 
@@ -164,6 +166,8 @@ class IncrementalBundler {
         onProgress: otherOptions.onProgress,
         experimentalImportBundleSupport:
           this._config.transformer.experimentalImportBundleSupport,
+        unstable_allowRequireContext:
+          this._config.transformer.unstable_allowRequireContext,
         shallow: otherOptions.shallow,
       },
     );
@@ -218,6 +222,8 @@ class IncrementalBundler {
       shallow: otherOptions.shallow,
       experimentalImportBundleSupport:
         this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        this._config.transformer.unstable_allowRequireContext,
     });
     const revisionId = createRevisionId();
     const revisionPromise = (async () => {

package/src/ModuleGraph/node-haste/HasteFS.js.flow

@@ -58,7 +58,7 @@ module.exports = class HasteFS {
     return Array.from<string>(this.files.keys());
   }
 
-  matchFiles() {
+  matchFiles(): $FlowFixMeEmpty {
     throw new Error('HasteFS.matchFiles is not implemented yet.');
   }
 

package/src/ModuleGraph/node-haste/node-haste.js

@@ -47,7 +47,13 @@ const NODE_MODULES = path.sep + "node_modules" + path.sep;
 
 const isNodeModules = (file) => file.includes(NODE_MODULES); // This function maps the ModuleGraph data structure to metro-file-map's ModuleMap
 
-const createModuleMap = ({ files, moduleCache, sourceExts, platforms }) => {
+const createModuleMap = ({
+  files,
+  moduleCache,
+  sourceExts,
+  additionalExts,
+  platforms,
+}) => {
   const platformSet = new Set(
     (platforms !== null && platforms !== void 0
       ? platforms
@@ -62,11 +68,12 @@ const createModuleMap = ({ files, moduleCache, sourceExts, platforms }) => {
 
     let id;
     let module;
+    const fileExt = path.extname(filePath).substr(1);
 
     if (filePath.endsWith(PACKAGE_JSON)) {
       module = moduleCache.getPackage(filePath);
       id = module.data.name;
-    } else if (sourceExts.indexOf(path.extname(filePath).substr(1)) !== -1) {
+    } else if (sourceExts.has(fileExt) || additionalExts.has(fileExt)) {
       module = moduleCache.getModule(filePath);
       id = module.name;
     }
@@ -107,6 +114,7 @@ exports.createResolveFn = function (options) {
     extraNodeModules,
     transformedFiles,
     sourceExts,
+    additionalExts,
     platform,
     platforms,
   } = options;
@@ -146,7 +154,8 @@ exports.createResolveFn = function (options) {
       map: createModuleMap({
         files,
         moduleCache,
-        sourceExts,
+        sourceExts: new Set(sourceExts),
+        additionalExts: new Set(additionalExts),
         platforms,
       }),
       mocks: new Map(),
@@ -172,10 +181,8 @@ exports.createResolveFn = function (options) {
     const from =
       sourcePath != null
         ? new Module(sourcePath, moduleCache, getTransformedFile(sourcePath))
-        : NULL_MODULE;
-    const allowHaste = !isNodeModules(from.path); // $FlowFixMe -- error revealed by types-first codemod
+        : NULL_MODULE; // $FlowFixMe -- error revealed by types-first codemod
 
-    return moduleResolver.resolveDependency(from, id, allowHaste, platform)
-      .path;
+    return moduleResolver.resolveDependency(from, id, true, platform).path;
   };
 };

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

@@ -10,7 +10,7 @@
 
 import type {Moduleish} from '../../node-haste/DependencyGraph/ModuleResolution';
 import type {ResolveFn, TransformedCodeFile} from '../types.flow';
-import type {Extensions, Path} from './node-haste.flow';
+import type {Path} from './node-haste.flow';
 import type {ModuleMapData, ModuleMapItem} from 'metro-file-map';
 import type {CustomResolver} from 'metro-resolver';
 
@@ -27,7 +27,19 @@ const defaults = require('metro-config/src/defaults/defaults');
 const path = require('path');
 
 type ResolveOptions = {
-  assetExts: Extensions,
+  /**
+   * (Used by the resolver) The extensions tried (in order) to implicitly
+   * locate a source file.
+   */
+  sourceExts: $ReadOnlyArray<string>,
+
+  /**
+   * The additional extensions to include in the file map as source files that
+   * can be explicitly imported.
+   */
+  additionalExts: $ReadOnlyArray<string>,
+
+  assetExts: $ReadOnlyArray<string>,
   assetResolutions: $ReadOnlyArray<string>,
   +disableHierarchicalLookup: boolean,
   +emptyModulePath: string,
@@ -37,7 +49,6 @@ type ResolveOptions = {
   +platform: string,
   platforms?: $ReadOnlyArray<string>,
   resolveRequest?: ?CustomResolver,
-  +sourceExts: Extensions,
   transformedFiles: {[path: Path]: TransformedCodeFile, ...},
 };
 
@@ -56,14 +67,21 @@ const NULL_MODULE: Moduleish = {
 };
 
 const NODE_MODULES = path.sep + 'node_modules' + path.sep;
-const isNodeModules = file => file.includes(NODE_MODULES);
+const isNodeModules = (file: string) => file.includes(NODE_MODULES);
 
 // This function maps the ModuleGraph data structure to metro-file-map's ModuleMap
 const createModuleMap = ({
   files,
   moduleCache,
   sourceExts,
+  additionalExts,
   platforms,
+}: {
+  files: Array<string>,
+  moduleCache: ModuleCache,
+  sourceExts: $ReadOnlySet<string>,
+  additionalExts: $ReadOnlySet<string>,
+  platforms: void | $ReadOnlyArray<string>,
 }): ModuleMapData => {
   const platformSet = new Set(
     (platforms ?? defaults.platforms).concat([NATIVE_PLATFORM]),
@@ -77,10 +95,12 @@ const createModuleMap = ({
     }
     let id;
     let module;
+    const fileExt = path.extname(filePath).substr(1);
+
     if (filePath.endsWith(PACKAGE_JSON)) {
       module = moduleCache.getPackage(filePath);
       id = module.data.name;
-    } else if (sourceExts.indexOf(path.extname(filePath).substr(1)) !== -1) {
+    } else if (sourceExts.has(fileExt) || additionalExts.has(fileExt)) {
       module = moduleCache.getModule(filePath);
       id = module.name;
     }
@@ -123,6 +143,7 @@ exports.createResolveFn = function (options: ResolveOptions): ResolveFn {
     extraNodeModules,
     transformedFiles,
     sourceExts,
+    additionalExts,
     platform,
     platforms,
   } = options;
@@ -142,7 +163,7 @@ exports.createResolveFn = function (options: ResolveOptions): ResolveFn {
   );
 
   const assetExtensions = new Set(assetExts.map(asset => '.' + asset));
-  const isAssetFile = file => assetExtensions.has(path.extname(file));
+  const isAssetFile = (file: string) => assetExtensions.has(path.extname(file));
 
   const moduleResolver = new ModuleResolver({
     dirExists: (filePath: string): boolean => hasteFS.dirExists(filePath),
@@ -156,7 +177,13 @@ exports.createResolveFn = function (options: ResolveOptions): ResolveFn {
     moduleCache,
     moduleMap: new ModuleMap({
       duplicates: new Map(),
-      map: createModuleMap({files, moduleCache, sourceExts, platforms}),
+      map: createModuleMap({
+        files,
+        moduleCache,
+        sourceExts: new Set(sourceExts),
+        additionalExts: new Set(additionalExts),
+        platforms,
+      }),
       mocks: new Map(),
       rootDir: '',
     }),
@@ -186,9 +213,7 @@ exports.createResolveFn = function (options: ResolveOptions): ResolveFn {
       sourcePath != null
         ? new Module(sourcePath, moduleCache, getTransformedFile(sourcePath))
         : NULL_MODULE;
-    const allowHaste = !isNodeModules(from.path);
     // $FlowFixMe -- error revealed by types-first codemod
-    return moduleResolver.resolveDependency(from, id, allowHaste, platform)
-      .path;
+    return moduleResolver.resolveDependency(from, id, true, platform).path;
   };
 };

package/src/ModuleGraph/output/indexed-ram-bundle.js.flow

@@ -9,7 +9,7 @@
  */
 
 'use strict';
-import type {IdsForPathFn, Dependency} from '../types.flow';
+import type {Dependency} from '../types.flow';
 import type {BasicSourceMap} from '../../../../metro-source-map/src/source-map';
 
 import type {Module, OutputFn, OutputFnArg} from '../types.flow';
@@ -33,18 +33,10 @@ function asIndexedRamBundle({
   preloadedModules,
   ramGroupHeads,
   requireCalls,
-}: $TEMPORARY$object<{
-  dependencyMapReservedName?: ?string,
-  enableIDInlining: boolean,
-  filename: string,
-  globalPrefix: string,
-  idsForPath: IdsForPathFn,
-  modules: Iterable<Module>,
-  preloadedModules: Set<string>,
+}: $ReadOnly<{
+  ...OutputFnArg,
+  preloadedModules: $ReadOnlySet<string>,
   ramGroupHeads: ?$ReadOnlyArray<string>,
-  requireCalls: Iterable<Module>,
-  segmentID: number,
-  sourceMapPath?: ?string,
 }>): {
   code: string | Buffer,
   extraFiles?: Iterable<[string, string | Buffer]>,
@@ -137,7 +129,7 @@ function* subtree(
 }
 
 function createBuilder(
-  preloadedModules: Set<string>,
+  preloadedModules: $ReadOnlySet<string>,
   ramGroupHeads: ?$ReadOnlyArray<string>,
 ): OutputFn<IndexMap> {
   return (x: OutputFnArg) =>