metro 0.71.1 → 0.72.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.71.1",
+  "version": "0.72.0",
   "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.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.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.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/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/DeltaCalculator.js

@@ -130,6 +130,8 @@ class DeltaCalculator extends EventEmitter {
   getGraph() {
     return this._graph;
   }
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
 
   _handleMultipleFileChanges = ({ eventsQueue }) => {
     eventsQueue.forEach(this._handleFileChange);

package/src/DeltaBundler/DeltaCalculator.js.flow

@@ -158,6 +158,8 @@ class DeltaCalculator<T> extends EventEmitter {
     return this._graph;
   }
 
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
   _handleMultipleFileChanges = ({eventsQueue}) => {
     eventsQueue.forEach(this._handleFileChange);
   };

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -136,7 +136,7 @@ class WorkerFarm {
     return null;
   }
 
-  _formatGenericError(err, filename: string): TransformError {
+  _formatGenericError(err: any, filename: string): TransformError {
     const error = new TransformError(`${filename}: ${err.message}`);
 
     return Object.assign(error, {
@@ -145,7 +145,7 @@ class WorkerFarm {
     });
   }
 
-  _formatBabelError(err, filename: string): TransformError {
+  _formatBabelError(err: any, filename: string): TransformError {
     const error = new TransformError(
       `${err.type || 'Error'}${
         err.message.includes(filename) ? '' : ' in ' + filename

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.
@@ -194,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 ||
@@ -204,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 ||
@@ -228,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)
       );
     }
   }
@@ -258,7 +251,7 @@ async function processModule(path, graph, delta, options) {
 
 async function addDependency(
   parentModule,
-  relativePath,
+  key,
   dependency,
   graph,
   delta,
@@ -298,7 +291,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();
@@ -316,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 (
@@ -359,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}`
+      );
+    }
 
-    if (resolvedPath) {
-      list.push(resolvedPath);
+    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 list;
-  }, []);
-  return new Map(resolved);
+  return resolvedDeps;
 }
 /**
  * Re-traverse the dependency graph in DFS order to reorder the modules and
@@ -478,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

@@ -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();
@@ -292,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 ||
@@ -301,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 ||
@@ -324,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),
       );
     }
   }
@@ -358,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,
@@ -397,7 +386,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);
@@ -417,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;
 
@@ -463,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;
 }
 
 /**
@@ -601,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

@@ -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,
@@ -28,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.
      */
@@ -48,6 +54,9 @@ export type TransformResultDependency = {
     +isOptional?: boolean,
 
     +locs: $ReadOnlyArray<BabelSourceLocation>,
+
+    /** Context for requiring a collection of modules. */
+    +contextParams?: RequireContextParams,
   },
 };
 
@@ -58,7 +67,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";