metro 0.71.1 → 0.72.0

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/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(),

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: '',
     }),

package/src/ModuleGraph/output/util.js

@@ -181,6 +181,7 @@ function inlineModuleIds(
       ? parseSync(code, babelConfig)
       : HermesParser.parse(code, {
           babel: true,
+          // $FlowFixMe[prop-missing]
           sourceType: babelConfig.sourceType,
         });
   const ast = nullthrows(

package/src/ModuleGraph/output/util.js.flow

@@ -62,11 +62,11 @@ type InlineModuleIdsOptions = $ReadOnly<{
 }>;
 
 // TS detection conditions copied from metro-react-native-babel-preset
-function isTypeScriptSource(fileName) {
+function isTypeScriptSource(fileName: string) {
   return !!fileName && fileName.endsWith('.ts');
 }
 
-function isTSXSource(fileName) {
+function isTSXSource(fileName: string) {
   return !!fileName && fileName.endsWith('.tsx');
 }
 
@@ -181,6 +181,7 @@ function inlineModuleIds(
       ? parseSync(code, babelConfig)
       : HermesParser.parse(code, {
           babel: true,
+          // $FlowFixMe[prop-missing]
           sourceType: babelConfig.sourceType,
         });
 

package/src/ModuleGraph/silent-console.js

@@ -12,11 +12,12 @@
 const { Console } = require("console");
 
 const { Writable } = require("stream");
-/* $FlowFixMe(>=0.97.0 site=react_native_fb) This comment suppresses an error
- * found when Flow v0.97 was deployed. To see the error delete this comment and
- * run Flow. */
 
-const write = (_, __, callback) => callback();
+const write = (_, __, callback) =>
+  /* $FlowFixMe(>=0.97.0 site=react_native_fb) This comment suppresses an error
+   * found when Flow v0.97 was deployed. To see the error delete this comment and
+   * run Flow. */
+  callback();
 
 module.exports = new Console(
   new Writable({

package/src/ModuleGraph/silent-console.js.flow

@@ -13,8 +13,12 @@
 const {Console} = require('console');
 const {Writable} = require('stream');
 
-/* $FlowFixMe(>=0.97.0 site=react_native_fb) This comment suppresses an error
- * found when Flow v0.97 was deployed. To see the error delete this comment and
- * run Flow. */
-const write = (_, __, callback) => callback();
+const write = (
+  _: Buffer | string | Array<{chunk: Buffer | string, encoding: string, ...}>,
+  __: string | ((error?: Error) => void),
+  callback: void | ((error?: Error) => void),
+  /* $FlowFixMe(>=0.97.0 site=react_native_fb) This comment suppresses an error
+   * found when Flow v0.97 was deployed. To see the error delete this comment and
+   * run Flow. */
+) => callback();
 module.exports = (new Console(new Writable({write, writev: write})): Console);

package/src/ModuleGraph/worker/collectDependencies.js

@@ -9,6 +9,8 @@
  */
 "use strict";
 
+const crypto = require("crypto");
+
 const generate = require("@babel/generator").default;
 
 const template = require("@babel/template").default;
@@ -53,6 +55,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 +100,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 +167,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 +468,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 +512,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 +586,58 @@ 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 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 { asyncType } = qualifier;
+
+  if (asyncType) {
+    key += ["", asyncType].join("\0");
+  }
+
+  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("\0");
+  }
+
+  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 = {
@@ -433,24 +645,28 @@ class DefaultModuleDependencyRegistry {
         asyncType: qualifier.asyncType,
         locs: [],
         index: this._dependencies.size,
+        key: crypto.createHash("sha1").update(key).digest("base64"),
       };
 
       if (qualifier.optional) {
         newDependency.isOptional = true;
       }
 
-      dependency = newDependency;
+      if (qualifier.contextParams) {
+        newDependency.contextParams = qualifier.contextParams;
+      }
 
-      this._dependencies.set(qualifier.name, dependency);
+      dependency = newDependency;
     } else {
-      const original = dependency;
-      dependency = collapseDependencies(original, qualifier);
-
-      if (original !== dependency) {
-        this._dependencies.set(qualifier.name, 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;
   }
 
@@ -459,24 +675,4 @@ class DefaultModuleDependencyRegistry {
   }
 }
 
-function collapseDependencies(dependency, qualifier) {
-  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;