metro 0.71.1 → 0.71.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.71.1",
+  "version": "0.71.2",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -31,27 +31,27 @@
     "error-stack-parser": "^2.0.6",
     "fs-extra": "^1.0.0",
     "graceful-fs": "^4.2.4",
-    "hermes-parser": "0.6.0",
+    "hermes-parser": "0.8.0",
     "image-size": "^0.6.0",
     "invariant": "^2.2.4",
     "jest-worker": "^27.2.0",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.71.1",
-    "metro-cache": "0.71.1",
-    "metro-cache-key": "0.71.1",
-    "metro-config": "0.71.1",
-    "metro-core": "0.71.1",
-    "metro-file-map": "0.71.1",
-    "metro-hermes-compiler": "0.71.1",
-    "metro-inspector-proxy": "0.71.1",
-    "metro-minify-uglify": "0.71.1",
-    "metro-react-native-babel-preset": "0.71.1",
-    "metro-resolver": "0.71.1",
-    "metro-runtime": "0.71.1",
-    "metro-source-map": "0.71.1",
-    "metro-symbolicate": "0.71.1",
-    "metro-transform-plugins": "0.71.1",
-    "metro-transform-worker": "0.71.1",
+    "metro-babel-transformer": "0.71.2",
+    "metro-cache": "0.71.2",
+    "metro-cache-key": "0.71.2",
+    "metro-config": "0.71.2",
+    "metro-core": "0.71.2",
+    "metro-file-map": "0.71.2",
+    "metro-hermes-compiler": "0.71.2",
+    "metro-inspector-proxy": "0.71.2",
+    "metro-minify-uglify": "0.71.2",
+    "metro-react-native-babel-preset": "0.71.2",
+    "metro-resolver": "0.71.2",
+    "metro-runtime": "0.71.2",
+    "metro-source-map": "0.71.2",
+    "metro-symbolicate": "0.71.2",
+    "metro-transform-plugins": "0.71.2",
+    "metro-transform-worker": "0.71.2",
     "mime-types": "^2.1.27",
     "node-fetch": "^2.2.0",
     "nullthrows": "^1.1.1",
@@ -70,10 +70,10 @@
     "babel-jest": "^26.6.3",
     "dedent": "^0.7.0",
     "jest-snapshot": "^26.5.2",
-    "metro-babel-register": "0.71.1",
-    "metro-memory-fs": "0.71.1",
-    "metro-react-native-babel-preset": "0.71.1",
-    "metro-react-native-babel-transformer": "0.71.1",
+    "metro-babel-register": "0.71.2",
+    "metro-memory-fs": "0.71.2",
+    "metro-react-native-babel-preset": "0.71.2",
+    "metro-react-native-babel-transformer": "0.71.2",
     "stack-trace": "^0.0.10"
   },
   "license": "MIT"

package/src/Bundler.js

@@ -13,8 +13,6 @@ const Transformer = require("./DeltaBundler/Transformer");
 
 const DependencyGraph = require("./node-haste/DependencyGraph");
 
-const { EventEmitter } = require("events");
-
 class Bundler {
   constructor(config, options) {
     this._depGraph = new DependencyGraph(config, options);

package/src/Bundler.js.flow

@@ -13,10 +13,10 @@
 import type {TransformResultWithSource} from './DeltaBundler';
 import type {TransformOptions} from './DeltaBundler/Worker';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
+import type EventEmitter from 'events';
 
 const Transformer = require('./DeltaBundler/Transformer');
 const DependencyGraph = require('./node-haste/DependencyGraph');
-const {EventEmitter} = require('events');
 
 export type BundlerOptions = $ReadOnly<{
   hasReducedPerformance?: boolean,

package/src/DeltaBundler/graphOperations.js

@@ -29,6 +29,12 @@
  */
 "use strict";
 
+var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+
 const invariant = require("invariant");
 
 const nullthrows = require("nullthrows"); // TODO: Convert to a Flow enum
@@ -181,7 +187,8 @@ async function processModule(path, graph, delta, options) {
     options
   );
   const previousModule = graph.dependencies.get(path) || {
-    inverseDependencies: delta.earlyInverseDependencies.get(path) || new Set(),
+    inverseDependencies:
+      delta.earlyInverseDependencies.get(path) || new _CountingSet.default(),
     path,
   };
   const previousDependencies = previousModule.dependencies || new Map(); // Update the module information.
@@ -298,7 +305,7 @@ async function addDependency(
           delta.modified.delete(path);
         }
 
-        delta.earlyInverseDependencies.set(path, new Set([parentModule.path]));
+        delta.earlyInverseDependencies.set(path, new _CountingSet.default());
         options.onDependencyAdd();
         module = await processModule(path, graph, delta, options);
         options.onDependencyAdded();

package/src/DeltaBundler/graphOperations.js.flow

@@ -39,6 +39,8 @@ import type {
   TransformResultDependency,
 } from './types.flow';
 
+import CountingSet from '../lib/CountingSet';
+
 const invariant = require('invariant');
 const nullthrows = require('nullthrows');
 
@@ -104,7 +106,7 @@ type Delta = $ReadOnly<{
 
   // A place to temporarily track inverse dependencies for a module while it is
   // being processed but has not been added to `graph.dependencies` yet.
-  earlyInverseDependencies: Map<string, Set<string>>,
+  earlyInverseDependencies: Map<string, CountingSet<string>>,
 }>;
 
 type InternalOptions<T> = $ReadOnly<{
@@ -277,7 +279,8 @@ async function processModule<T>(
   );
 
   const previousModule = graph.dependencies.get(path) || {
-    inverseDependencies: delta.earlyInverseDependencies.get(path) || new Set(),
+    inverseDependencies:
+      delta.earlyInverseDependencies.get(path) || new CountingSet(),
     path,
   };
   const previousDependencies = previousModule.dependencies || new Map();
@@ -397,7 +400,7 @@ async function addDependency<T>(
           delta.added.add(path);
           delta.modified.delete(path);
         }
-        delta.earlyInverseDependencies.set(path, new Set([parentModule.path]));
+        delta.earlyInverseDependencies.set(path, new CountingSet());
 
         options.onDependencyAdd();
         module = await processModule(path, graph, delta, options);

package/src/DeltaBundler/types.flow.js

@@ -8,3 +8,9 @@
  * @format
  */
 "use strict";
+
+var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}

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

@@ -10,9 +10,12 @@
 
 'use strict';
 
+import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
 import type {PrivateState} from './graphOperations';
 import type {JsTransformOptions} from 'metro-transform-worker';
 
+import CountingSet from '../lib/CountingSet';
+
 export type MixedOutput = {
   +data: mixed,
   +type: string,
@@ -48,6 +51,9 @@ export type TransformResultDependency = {
     +isOptional?: boolean,
 
     +locs: $ReadOnlyArray<BabelSourceLocation>,
+
+    /** Context for requiring a collection of modules. */
+    +contextParams?: RequireContextParams,
   },
 };
 
@@ -58,7 +64,7 @@ export type Dependency = {
 
 export type Module<T = MixedOutput> = {
   +dependencies: Map<string, Dependency>,
-  +inverseDependencies: Set<string>,
+  +inverseDependencies: CountingSet<string>,
   +output: $ReadOnlyArray<T>,
   +path: string,
   +getSource: () => Buffer,

package/src/DeltaBundler.js

@@ -11,8 +11,6 @@
 
 const DeltaCalculator = require("./DeltaBundler/DeltaCalculator");
 
-const { EventEmitter } = require("events");
-
 /**
  * `DeltaBundler` uses the `DeltaTransformer` to build bundle deltas. This
  * module handles all the transformer instances so it can support multiple

package/src/DeltaBundler.js.flow

@@ -18,9 +18,9 @@ import type {
   MixedOutput,
   Options,
 } from './DeltaBundler/types.flow';
+import type EventEmitter from 'events';
 
 const DeltaCalculator = require('./DeltaBundler/DeltaCalculator');
-const {EventEmitter} = require('events');
 
 export type {
   DeltaResult,

package/src/HmrServer.js

@@ -11,8 +11,6 @@
 
 const hmrJSBundle = require("./DeltaBundler/Serializers/hmrJSBundle");
 
-const IncrementalBundler = require("./IncrementalBundler");
-
 const GraphNotFoundError = require("./IncrementalBundler/GraphNotFoundError");
 
 const RevisionNotFoundError = require("./IncrementalBundler/RevisionNotFoundError");

package/src/HmrServer.js.flow

@@ -10,7 +10,7 @@
 
 'use strict';
 
-import type {RevisionId} from './IncrementalBundler';
+import type IncrementalBundler, {RevisionId} from './IncrementalBundler';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
 import type {
   HmrClientMessage,
@@ -20,7 +20,6 @@ import type {
 } from 'metro-runtime/src/modules/types.flow';
 
 const hmrJSBundle = require('./DeltaBundler/Serializers/hmrJSBundle');
-const IncrementalBundler = require('./IncrementalBundler');
 const GraphNotFoundError = require('./IncrementalBundler/GraphNotFoundError');
 const RevisionNotFoundError = require('./IncrementalBundler/RevisionNotFoundError');
 const debounceAsyncQueue = require('./lib/debounceAsyncQueue');

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

@@ -8,4 +8,3 @@
  * @format
  */
 "use strict";
-"use strict";

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

@@ -10,8 +10,6 @@
 
 'use strict';
 
-'use strict';
-
 type ModuleID = string;
 export type Path = string;
 type Platform = string;
@@ -63,6 +61,7 @@ type HasteMapOptions = {
   preferNativePlatform: true,
 };
 
+// eslint-disable-next-line no-unused-vars
 declare class HasteMap {
   // node-haste/DependencyGraph/HasteMap.js
   build(): Promise<Object>;

package/src/ModuleGraph/worker/collectDependencies.js

@@ -53,6 +53,7 @@ function collectDependencies(ast, options) {
     dynamicRequires: options.dynamicRequires,
     keepRequireNames: options.keepRequireNames,
     allowOptionalDependencies: options.allowOptionalDependencies,
+    unstable_allowRequireContext: options.unstable_allowRequireContext,
   };
   const visitor = {
     CallExpression(path, state) {
@@ -97,6 +98,22 @@ function collectDependencies(ast, options) {
           splitCondition: args[1],
         });
         return;
+      } // Match `require.context`
+
+      if (
+        // Feature gate, defaults to `false`.
+        state.unstable_allowRequireContext &&
+        callee.type === "MemberExpression" && // `require`
+        callee.object.type === "Identifier" &&
+        callee.object.name === "require" && // `context`
+        callee.property.type === "Identifier" &&
+        callee.property.name === "context" &&
+        !callee.computed && // Ensure `require` refers to the global and not something else.
+        !path.scope.getBinding("require")
+      ) {
+        processRequireContextCall(path, state);
+        visited.add(path.node);
+        return;
       }
 
       if (
@@ -148,6 +165,146 @@ function collectDependencies(ast, options) {
     dependencyMapName: nullthrows(state.dependencyMapIdentifier).name,
   };
 }
+/** Extract args passed to the `require.context` method. */
+
+function getRequireContextArgs(path) {
+  const args = path.get("arguments");
+  let directory;
+
+  if (!Array.isArray(args) || args.length < 1) {
+    throw new InvalidRequireCallError(path);
+  } else {
+    const result = args[0].evaluate();
+
+    if (result.confident && typeof result.value === "string") {
+      directory = result.value;
+    } else {
+      var _result$deopt;
+
+      throw new InvalidRequireCallError(
+        (_result$deopt = result.deopt) !== null && _result$deopt !== void 0
+          ? _result$deopt
+          : args[0],
+        "First argument of `require.context` should be a string denoting the directory to require."
+      );
+    }
+  } // Default to requiring through all directories.
+
+  let recursive = true;
+
+  if (args.length > 1) {
+    const result = args[1].evaluate();
+
+    if (result.confident && typeof result.value === "boolean") {
+      recursive = result.value;
+    } else if (!(result.confident && typeof result.value === "undefined")) {
+      var _result$deopt2;
+
+      throw new InvalidRequireCallError(
+        (_result$deopt2 = result.deopt) !== null && _result$deopt2 !== void 0
+          ? _result$deopt2
+          : args[1],
+        "Second argument of `require.context` should be an optional boolean indicating if files should be imported recursively or not."
+      );
+    }
+  } // Default to all files.
+
+  let filter = {
+    pattern: ".*",
+    flags: "",
+  };
+
+  if (args.length > 2) {
+    // evaluate() to check for undefined (because it's technically a scope lookup)
+    // but check the AST for the regex literal, since evaluate() doesn't do regex.
+    const result = args[2].evaluate();
+    const argNode = args[2].node;
+
+    if (argNode.type === "RegExpLiteral") {
+      // TODO: Handle `new RegExp(...)` -- `argNode.type === 'NewExpression'`
+      filter = {
+        pattern: argNode.pattern,
+        flags: argNode.flags || "",
+      };
+    } else if (!(result.confident && typeof result.value === "undefined")) {
+      throw new InvalidRequireCallError(
+        args[2],
+        `Third argument of \`require.context\` should be an optional RegExp pattern matching all of the files to import, instead found node of type: ${argNode.type}.`
+      );
+    }
+  } // Default to `sync`.
+
+  let mode = "sync";
+
+  if (args.length > 3) {
+    const result = args[3].evaluate();
+
+    if (result.confident && typeof result.value === "string") {
+      mode = getContextMode(args[3], result.value);
+    } else if (!(result.confident && typeof result.value === "undefined")) {
+      var _result$deopt3;
+
+      throw new InvalidRequireCallError(
+        (_result$deopt3 = result.deopt) !== null && _result$deopt3 !== void 0
+          ? _result$deopt3
+          : args[3],
+        'Fourth argument of `require.context` should be an optional string "mode" denoting how the modules will be resolved.'
+      );
+    }
+  }
+
+  if (args.length > 4) {
+    throw new InvalidRequireCallError(
+      path,
+      `Too many arguments provided to \`require.context\` call. Expected 4, got: ${args.length}`
+    );
+  }
+
+  return [
+    directory,
+    {
+      recursive,
+      filter,
+      mode,
+    },
+  ];
+}
+
+function getContextMode(path, mode) {
+  if (
+    mode === "sync" ||
+    mode === "eager" ||
+    mode === "lazy" ||
+    mode === "lazy-once"
+  ) {
+    return mode;
+  }
+
+  throw new InvalidRequireCallError(
+    path,
+    `require.context "${mode}" mode is not supported. Expected one of: sync, eager, lazy, lazy-once`
+  );
+}
+
+function processRequireContextCall(path, state) {
+  const [directory, contextParams] = getRequireContextArgs(path);
+  const transformer = state.dependencyTransformer;
+  const dep = registerDependency(
+    state,
+    {
+      // We basically want to "import" every file in a folder and then filter them out with the given `filter` RegExp.
+      name: directory,
+      // Capture the matching context
+      contextParams,
+      asyncType: null,
+      optional: isOptionalDependency(directory, path, state),
+    },
+    path
+  ); // require() the generated module representing this context
+
+  path.get("callee").replaceWith(types.identifier("require"));
+  transformer.transformSyncRequire(path, dep, state);
+}
 
 function collectImports(path, state) {
   if (path.node.source) {
@@ -309,10 +466,15 @@ function getModuleNameFromCallArgs(path) {
 collectDependencies.getModuleNameFromCallArgs = getModuleNameFromCallArgs;
 
 class InvalidRequireCallError extends Error {
-  constructor({ node }) {
+  constructor({ node }, message) {
     const line = node.loc && node.loc.start && node.loc.start.line;
     super(
-      `Invalid call at line ${line || "<unknown>"}: ${generate(node).code}`
+      [
+        `Invalid call at line ${line || "<unknown>"}: ${generate(node).code}`,
+        message,
+      ]
+        .filter(Boolean)
+        .join("\n")
     );
   }
 }
@@ -348,9 +510,11 @@ const makeJSResourceTemplate = template.statement(`
 const DefaultDependencyTransformer = {
   transformSyncRequire(path, dependency, state) {
     const moduleIDExpression = createModuleIDExpression(dependency, state);
-    path.node.arguments = state.keepRequireNames
-      ? [moduleIDExpression, types.stringLiteral(dependency.name)]
-      : [moduleIDExpression];
+    path.node.arguments = [moduleIDExpression]; // Always add the debug name argument last
+
+    if (state.keepRequireNames) {
+      path.node.arguments.push(types.stringLiteral(dependency.name));
+    }
   },
 
   transformImportCall(path, dependency, state) {
@@ -420,12 +584,51 @@ function createModuleIDExpression(dependency, state) {
 function createModuleNameLiteral(dependency) {
   return types.stringLiteral(dependency.name);
 }
+/**
+ * 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.
+ *
+ * For example, the following case would have collision issues if they all utilized the `name` property:
+ * ```
+ * require('./foo');
+ * require.context('./foo');
+ * require.context('./foo', true, /something/);
+ * require.context('./foo', false, /something/);
+ * require.context('./foo', false, /something/, 'lazy');
+ * ```
+ *
+ * This method should be utilized by `registerDependency`.
+ */
+
+function getKeyForDependency(qualifier) {
+  let key = qualifier.name;
+  const { contextParams } = qualifier; // Add extra qualifiers when using `require.context` to prevent collisions.
+
+  if (contextParams) {
+    // NOTE(EvanBacon): Keep this synchronized with `RequireContextParams`, if any other properties are added
+    // then this key algorithm should be updated to account for those properties.
+    // Example: `./directory__true__/foobar/m__lazy`
+    key += [
+      "",
+      "context",
+      String(contextParams.recursive),
+      String(contextParams.filter.pattern),
+      String(contextParams.filter.flags),
+      contextParams.mode, // Join together and append to the name:
+    ].join("__");
+  }
+
+  return key;
+}
 
 class DefaultModuleDependencyRegistry {
   _dependencies = new Map();
 
   registerDependency(qualifier) {
-    let dependency = this._dependencies.get(qualifier.name);
+    const key = getKeyForDependency(qualifier);
+
+    let dependency = this._dependencies.get(key);
 
     if (dependency == null) {
       const newDependency = {
@@ -439,15 +642,19 @@ class DefaultModuleDependencyRegistry {
         newDependency.isOptional = true;
       }
 
+      if (qualifier.contextParams) {
+        newDependency.contextParams = qualifier.contextParams;
+      }
+
       dependency = newDependency;
 
-      this._dependencies.set(qualifier.name, dependency);
+      this._dependencies.set(key, dependency);
     } else {
       const original = dependency;
       dependency = collapseDependencies(original, qualifier);
 
       if (original !== dependency) {
-        this._dependencies.set(qualifier.name, dependency);
+        this._dependencies.set(key, dependency);
       }
     }