metro 0.71.3 → 0.72.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.71.3",
+  "version": "0.72.0",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -36,22 +36,22 @@
     "invariant": "^2.2.4",
     "jest-worker": "^27.2.0",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.71.3",
-    "metro-cache": "0.71.3",
-    "metro-cache-key": "0.71.3",
-    "metro-config": "0.71.3",
-    "metro-core": "0.71.3",
-    "metro-file-map": "0.71.3",
-    "metro-hermes-compiler": "0.71.3",
-    "metro-inspector-proxy": "0.71.3",
-    "metro-minify-uglify": "0.71.3",
-    "metro-react-native-babel-preset": "0.71.3",
-    "metro-resolver": "0.71.3",
-    "metro-runtime": "0.71.3",
-    "metro-source-map": "0.71.3",
-    "metro-symbolicate": "0.71.3",
-    "metro-transform-plugins": "0.71.3",
-    "metro-transform-worker": "0.71.3",
+    "metro-babel-transformer": "0.72.0",
+    "metro-cache": "0.72.0",
+    "metro-cache-key": "0.72.0",
+    "metro-config": "0.72.0",
+    "metro-core": "0.72.0",
+    "metro-file-map": "0.72.0",
+    "metro-hermes-compiler": "0.72.0",
+    "metro-inspector-proxy": "0.72.0",
+    "metro-minify-uglify": "0.72.0",
+    "metro-react-native-babel-preset": "0.72.0",
+    "metro-resolver": "0.72.0",
+    "metro-runtime": "0.72.0",
+    "metro-source-map": "0.72.0",
+    "metro-symbolicate": "0.72.0",
+    "metro-transform-plugins": "0.72.0",
+    "metro-transform-worker": "0.72.0",
     "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.3",
-    "metro-memory-fs": "0.71.3",
-    "metro-react-native-babel-preset": "0.71.3",
-    "metro-react-native-babel-transformer": "0.71.3",
+    "metro-babel-register": "0.72.0",
+    "metro-memory-fs": "0.72.0",
+    "metro-react-native-babel-preset": "0.72.0",
+    "metro-react-native-babel-transformer": "0.72.0",
     "stack-trace": "^0.0.10"
   },
   "license": "MIT"

package/src/Assets.js

@@ -108,8 +108,9 @@ async function getAbsoluteAssetRecord(assetPath, platform = null) {
 
   if (!record) {
     throw new Error(
-      /* $FlowFixMe: platform can be null */
-      `Asset not found: ${assetPath} for platform: ${platform}`
+      `Asset not found: ${assetPath} for platform: ${
+        platform !== null && platform !== void 0 ? platform : "(unspecified)"
+      }`
     );
   }
 

package/src/Assets.js.flow

@@ -154,8 +154,9 @@ async function getAbsoluteAssetRecord(
 
   if (!record) {
     throw new Error(
-      /* $FlowFixMe: platform can be null */
-      `Asset not found: ${assetPath} for platform: ${platform}`,
+      `Asset not found: ${assetPath} for platform: ${
+        platform ?? '(unspecified)'
+      }`,
     );
   }
 

package/src/DeltaBundler/graphOperations.js

@@ -201,8 +201,8 @@ async function processModule(path, graph, delta, options) {
   };
   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 ||
@@ -211,21 +211,14 @@ async function processModule(path, graph, delta, options) {
         curDependency.data.data.asyncType !==
           prevDependency.data.data.asyncType)
     ) {
-      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 ||
@@ -235,14 +228,7 @@ async function processModule(path, graph, delta, options) {
           curDependency.data.data.asyncType)
     ) {
       promises.push(
-        addDependency(
-          module,
-          relativePath,
-          curDependency,
-          graph,
-          delta,
-          options
-        )
+        addDependency(module, key, curDependency, graph, delta, options)
       );
     }
   }
@@ -265,7 +251,7 @@ async function processModule(path, graph, delta, options) {
 
 async function addDependency(
   parentModule,
-  relativePath,
+  key,
   dependency,
   graph,
   delta,
@@ -323,18 +309,18 @@ async function addDependency(
   // 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(
   parentModule,
-  relativePath,
+  key,
   dependency,
   graph,
   delta,
   options
 ) {
-  parentModule.dependencies.delete(relativePath);
+  parentModule.dependencies.delete(key);
   const { absolutePath } = dependency;
 
   if (
@@ -366,38 +352,48 @@ function removeDependency(
 }
 
 function resolveDependencies(parentPath, dependencies, options) {
-  const resolve = (parentPath, result) => {
-    const relativePath = result.name;
+  const maybeResolvedDeps = new Map();
+
+  for (const dep of dependencies) {
+    let resolvedDep;
 
     try {
-      return [
-        relativePath,
-        {
-          absolutePath: options.resolve(parentPath, relativePath),
-          data: result,
-        },
-      ];
+      resolvedDep = {
+        absolutePath: options.resolve(parentPath, dep.name),
+        data: dep,
+      };
     } 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) {
+      if (dep.data.isOptional !== true) {
         throw error;
       }
     }
 
-    return undefined;
-  };
+    const key = dep.data.key;
 
-  const resolved = dependencies.reduce((list, result) => {
-    const resolvedPath = resolve(parentPath, result);
+    if (maybeResolvedDeps.has(key)) {
+      throw new Error(
+        `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`
+      );
+    }
+
+    maybeResolvedDeps.set(key, resolvedDep);
+  }
 
-    if (resolvedPath) {
-      list.push(resolvedPath);
+  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 list;
-  }, []);
-  return new Map(resolved);
+  return resolvedDeps;
 }
 /**
  * Re-traverse the dependency graph in DFS order to reorder the modules and
@@ -485,8 +481,8 @@ function markModuleInUse(module, graph) {
 // Called when the reference count of a module has reached 0.
 
 function releaseModule(module, graph, delta, options) {
-  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");

package/src/DeltaBundler/graphOperations.js.flow

@@ -295,8 +295,8 @@ 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 ||
@@ -304,21 +304,14 @@ async function processModule<T>(
         curDependency.data.data.asyncType !==
           prevDependency.data.data.asyncType)
     ) {
-      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 ||
@@ -327,14 +320,7 @@ async function processModule<T>(
           curDependency.data.data.asyncType)
     ) {
       promises.push(
-        addDependency(
-          module,
-          relativePath,
-          curDependency,
-          graph,
-          delta,
-          options,
-        ),
+        addDependency(module, key, curDependency, graph, delta, options),
       );
     }
   }
@@ -361,7 +347,7 @@ async function processModule<T>(
 
 async function addDependency<T>(
   parentModule: Module<T>,
-  relativePath: string,
+  key: string,
   dependency: Dependency,
   graph: Graph<T>,
   delta: Delta,
@@ -420,18 +406,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;
 
@@ -466,37 +452,42 @@ function resolveDependencies<T>(
   dependencies: $ReadOnlyArray<TransformResultDependency>,
   options: InternalOptions<T>,
 ): Map<string, Dependency> {
-  const resolve = (parentPath: string, result: TransformResultDependency) => {
-    const relativePath = result.name;
+  const maybeResolvedDeps = new Map();
+  for (const dep of dependencies) {
+    let resolvedDep;
     try {
-      return [
-        relativePath,
-        {
-          absolutePath: options.resolve(parentPath, relativePath),
-          data: result,
-        },
-      ];
+      resolvedDep = {
+        absolutePath: options.resolve(parentPath, dep.name),
+        data: dep,
+      };
     } 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) {
+      if (dep.data.isOptional !== true) {
         throw error;
       }
     }
-    return undefined;
-  };
+    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 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 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 +595,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)) {

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

@@ -31,10 +31,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.
      */

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, ...},
 };
 
@@ -63,12 +74,14 @@ const createModuleMap = ({
   files,
   moduleCache,
   sourceExts,
+  additionalExts,
   platforms,
 }: {
   files: Array<string>,
   moduleCache: ModuleCache,
+  sourceExts: $ReadOnlySet<string>,
+  additionalExts: $ReadOnlySet<string>,
   platforms: void | $ReadOnlyArray<string>,
-  sourceExts: Extensions,
 }): ModuleMapData => {
   const platformSet = new Set(
     (platforms ?? defaults.platforms).concat([NATIVE_PLATFORM]),
@@ -82,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;
     }
@@ -128,6 +143,7 @@ exports.createResolveFn = function (options: ResolveOptions): ResolveFn {
     extraNodeModules,
     transformedFiles,
     sourceExts,
+    additionalExts,
     platform,
     platforms,
   } = options;
@@ -161,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

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

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;
@@ -586,8 +588,9 @@ function createModuleNameLiteral(dependency) {
 }
 /**
  * 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.
+ * 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:
  * ```
@@ -603,6 +606,12 @@ function createModuleNameLiteral(dependency) {
 
 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) {
@@ -616,7 +625,7 @@ function getKeyForDependency(qualifier) {
       String(contextParams.filter.pattern),
       String(contextParams.filter.flags),
       contextParams.mode, // Join together and append to the name:
-    ].join("__");
+    ].join("\0");
   }
 
   return key;
@@ -636,6 +645,7 @@ class DefaultModuleDependencyRegistry {
         asyncType: qualifier.asyncType,
         locs: [],
         index: this._dependencies.size,
+        key: crypto.createHash("sha1").update(key).digest("base64"),
       };
 
       if (qualifier.optional) {
@@ -647,17 +657,16 @@ class DefaultModuleDependencyRegistry {
       }
 
       dependency = newDependency;
-
-      this._dependencies.set(key, dependency);
     } else {
-      const original = dependency;
-      dependency = collapseDependencies(original, qualifier);
-
-      if (original !== dependency) {
-        this._dependencies.set(key, 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;
   }
 
@@ -666,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;