metro 0.72.0 → 0.72.1

package/src/DeltaBundler/WorkerFarm.js

@@ -50,13 +50,14 @@ class WorkerFarm {
     }
   }
 
-  async transform(filename, options) {
+  async transform(filename, options, fileBuffer) {
     try {
       const data = await this._worker.transform(
         filename,
         options,
         this._config.projectRoot,
-        this._transformerConfig
+        this._transformerConfig,
+        fileBuffer
       );
       Logger.log(data.transformFileStartLogEntry);
       Logger.log(data.transformFileEndLogEntry);

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -78,6 +78,7 @@ class WorkerFarm {
   async transform(
     filename: string,
     options: TransformOptions,
+    fileBuffer?: Buffer,
   ): Promise<TransformerResult> {
     try {
       const data = await this._worker.transform(
@@ -85,6 +86,7 @@ class WorkerFarm {
         options,
         this._config.projectRoot,
         this._transformerConfig,
+        fileBuffer,
       );
 
       Logger.log(data.transformFileStartLogEntry);
@@ -107,7 +109,7 @@ class WorkerFarm {
     workerPath: string,
     exposedMethods: $ReadOnlyArray<string>,
     numWorkers: number,
-  ) {
+  ): any {
     const env = {
       ...process.env,
       // Force color to print syntax highlighted code frames.

package/src/DeltaBundler/graphOperations.js

@@ -31,6 +31,52 @@
 
 var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
 
+var _contextModule = require("../lib/contextModule");
+
+var path = _interopRequireWildcard(require("path"));
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
 function _interopRequireDefault(obj) {
   return obj && obj.__esModule ? obj : { default: obj };
 }
@@ -45,6 +91,7 @@ function createGraph(options) {
     dependencies: new Map(),
     importBundleNames: new Set(),
     privateState: {
+      resolvedContexts: new Map(),
       gc: {
         color: new Map(),
         possibleCycleRoots: new Set(),
@@ -78,7 +125,7 @@ function getInternalOptions({
  * 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.
@@ -176,12 +223,14 @@ async function traverseDependenciesForSingleFile(path, graph, delta, options) {
 }
 
 async function processModule(path, graph, delta, options) {
-  // Transform the file via the given option.
+  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); // Get the absolute path of all sub-dependencies (some of them could have been
+
+  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
@@ -206,10 +255,7 @@ async function processModule(path, graph, delta, options) {
 
     if (
       !curDependency ||
-      curDependency.absolutePath !== prevDependency.absolutePath ||
-      (options.experimentalImportBundleSupport &&
-        curDependency.data.data.asyncType !==
-          prevDependency.data.data.asyncType)
+      !dependenciesEqual(prevDependency, curDependency, options)
     ) {
       removeDependency(module, key, prevDependency, graph, delta, options);
     }
@@ -222,10 +268,7 @@ async function processModule(path, graph, delta, options) {
 
     if (
       !prevDependency ||
-      prevDependency.absolutePath !== curDependency.absolutePath ||
-      (options.experimentalImportBundleSupport &&
-        prevDependency.data.data.asyncType !==
-          curDependency.data.data.asyncType)
+      !dependenciesEqual(prevDependency, curDependency, options)
     ) {
       promises.push(
         addDependency(module, key, curDependency, graph, delta, options)
@@ -249,6 +292,29 @@ async function processModule(path, graph, delta, options) {
   return module;
 }
 
+function dependenciesEqual(a, b, options) {
+  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, b) {
+  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(
   parentModule,
   key,
@@ -350,23 +416,66 @@ function removeDependency(
     releaseModule(module, graph, delta, options);
   }
 }
+/**
+ * Collect a list of context modules which include a given file.
+ */
 
-function resolveDependencies(parentPath, dependencies, options) {
+function markModifiedContextModules(graph, filePath, modifiedPaths) {
+  for (const [absolutePath, context] of graph.privateState.resolvedContexts) {
+    if (
+      !modifiedPaths.has(absolutePath) &&
+      (0, _contextModule.fileMatchesContext)(filePath, context)
+    ) {
+      modifiedPaths.add(absolutePath);
+    }
+  }
+}
+
+function resolveDependencies(graph, parentPath, dependencies, options) {
   const maybeResolvedDeps = new Map();
 
   for (const dep of dependencies) {
-    let resolvedDep;
+    let resolvedDep; // `require.context`
+
+    const { contextParams } = dep.data;
 
-    try {
+    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 = (0, _contextModule.deriveAbsolutePathFromContext)(
+        from,
+        contextParams
+      );
+      const resolvedContext = {
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
+        filter: new RegExp(
+          contextParams.filter.pattern,
+          contextParams.filter.flags
+        ),
+      };
+      graph.privateState.resolvedContexts.set(absolutePath, resolvedContext);
       resolvedDep = {
-        absolutePath: options.resolve(parentPath, dep.name),
+        absolutePath,
         data: dep,
       };
-    } 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;
+    } 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;
+        }
       }
     }
 
@@ -508,6 +617,7 @@ function freeModule(module, graph, 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
 
 function markAsPossibleCycleRoot(module, graph) {
@@ -634,4 +744,5 @@ module.exports = {
   initialTraverseDependencies,
   traverseDependencies,
   reorderGraph,
+  markModifiedContextModules,
 };

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,
@@ -299,10 +311,7 @@ async function processModule<T>(
     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, key, prevDependency, graph, delta, options);
     }
@@ -314,10 +323,7 @@ async function processModule<T>(
     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, key, curDependency, graph, delta, options),
@@ -345,6 +351,36 @@ 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>,
   key: string,
@@ -447,7 +483,26 @@ 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>,
@@ -455,18 +510,50 @@ function resolveDependencies<T>(
   const maybeResolvedDeps = new Map();
   for (const dep of dependencies) {
     let resolvedDep;
-    try {
+
+    // `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: options.resolve(parentPath, dep.name),
+        absolutePath,
         data: dep,
       };
-    } 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;
+    } 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;
+        }
       }
     }
+
     const key = dep.data.key;
     if (maybeResolvedDeps.has(key)) {
       throw new Error(
@@ -622,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
@@ -740,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';
 
@@ -107,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>,
 };
@@ -123,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

@@ -181,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

@@ -213,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) =>