metro 0.82.4 → 0.83.0

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "metro",
-  "version": "0.82.4",
+  "version": "0.83.0",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
   "exports": {
     ".": "./src/index.js",
     "./package.json": "./package.json",
-    "./private/*": "./src/*.js",
-    "./src": "./src/index.js",
-    "./src/*.js": "./src/*.js",
-    "./src/*": "./src/*.js"
+    "./private/*": "./src/*.js"
   },
   "repository": {
     "type": "git",
@@ -36,24 +33,24 @@
     "error-stack-parser": "^2.0.6",
     "flow-enums-runtime": "^0.0.6",
     "graceful-fs": "^4.2.4",
-    "hermes-parser": "0.28.1",
+    "hermes-parser": "0.29.1",
     "image-size": "^1.0.2",
     "invariant": "^2.2.4",
     "jest-worker": "^29.7.0",
     "jsc-safe-url": "^0.2.2",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.82.4",
-    "metro-cache": "0.82.4",
-    "metro-cache-key": "0.82.4",
-    "metro-config": "0.82.4",
-    "metro-core": "0.82.4",
-    "metro-file-map": "0.82.4",
-    "metro-resolver": "0.82.4",
-    "metro-runtime": "0.82.4",
-    "metro-source-map": "0.82.4",
-    "metro-symbolicate": "0.82.4",
-    "metro-transform-plugins": "0.82.4",
-    "metro-transform-worker": "0.82.4",
+    "metro-babel-transformer": "0.83.0",
+    "metro-cache": "0.83.0",
+    "metro-cache-key": "0.83.0",
+    "metro-config": "0.83.0",
+    "metro-core": "0.83.0",
+    "metro-file-map": "0.83.0",
+    "metro-resolver": "0.83.0",
+    "metro-runtime": "0.83.0",
+    "metro-source-map": "0.83.0",
+    "metro-symbolicate": "0.83.0",
+    "metro-transform-plugins": "0.83.0",
+    "metro-transform-worker": "0.83.0",
     "mime-types": "^2.1.27",
     "nullthrows": "^1.1.1",
     "serialize-error": "^2.1.0",
@@ -72,14 +69,14 @@
     "dedent": "^0.7.0",
     "jest-snapshot": "^29.7.0",
     "jest-snapshot-serializer-raw": "^1.2.0",
-    "metro-babel-register": "0.82.4",
-    "metro-memory-fs": "0.82.4",
+    "metro-babel-register": "0.83.0",
+    "metro-memory-fs": "*",
     "mock-req": "^0.2.0",
     "mock-res": "^0.6.0",
     "stack-trace": "^0.0.10"
   },
   "license": "MIT",
   "engines": {
-    "node": ">=18.18"
+    "node": ">=22.14"
   }
 }

package/src/DeltaBundler/DeltaCalculator.js

@@ -3,7 +3,11 @@
 var _Graph = require("./Graph");
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const debug = require("debug")("Metro:DeltaCalculator");
 const { EventEmitter } = require("events");

package/src/DeltaBundler/Graph.js

@@ -6,9 +6,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.Graph = void 0;
 var _contextModule = require("../lib/contextModule");
 var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
+var _isResolvedDependency = require("../lib/isResolvedDependency");
 var _buildSubgraph = require("./buildSubgraph");
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const invariant = require("invariant");
 const nullthrows = require("nullthrows");
@@ -285,13 +290,14 @@ class Graph {
     delta,
     options
   ) {
-    const path = dependency.absolutePath;
-    let module = this.dependencies.get(path);
     if (options.shallow) {
+    } else if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
     } else if (dependency.data.data.asyncType === "weak") {
     } else if (options.lazy && dependency.data.data.asyncType != null) {
       this._incrementImportBundleReference(dependency, parentModule);
     } else {
+      const path = dependency.absolutePath;
+      let module = this.dependencies.get(path);
       if (!module) {
         try {
           module = this._recursivelyCommitModule(path, delta, options);
@@ -310,19 +316,25 @@ class Graph {
       module.inverseDependencies.add(parentModule.path);
       this._markModuleInUse(module);
     }
-    if (requireContext) {
-      this.#resolvedContexts.set(path, requireContext);
-    } else {
-      this.#resolvedContexts.delete(path);
+    if ((0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+      const path = dependency.absolutePath;
+      if (requireContext) {
+        this.#resolvedContexts.set(path, requireContext);
+      } else {
+        this.#resolvedContexts.delete(path);
+      }
     }
     parentModule.dependencies.set(key, dependency);
   }
   _removeDependency(parentModule, key, dependency, delta, options) {
     parentModule.dependencies.delete(key);
-    const { absolutePath } = dependency;
-    if (dependency.data.data.asyncType === "weak") {
+    if (
+      !(0, _isResolvedDependency.isResolvedDependency)(dependency) ||
+      dependency.data.data.asyncType === "weak"
+    ) {
       return;
     }
+    const { absolutePath } = dependency;
     const module = this.dependencies.get(absolutePath);
     if (options.lazy && dependency.data.data.asyncType != null) {
       this._decrementImportBundleReference(dependency, parentModule);
@@ -380,6 +392,9 @@ class Graph {
     }
     module.dependencies.forEach((dependency) => {
       const path = dependency.absolutePath;
+      if (path == null) {
+        return;
+      }
       const childModule = this.dependencies.get(path);
       if (!childModule) {
         if (dependency.data.data.asyncType != null || options.shallow) {
@@ -418,7 +433,10 @@ class Graph {
   }
   *_children(module, options) {
     for (const dependency of module.dependencies.values()) {
-      if (isWeakOrLazy(dependency, options)) {
+      if (
+        !(0, _isResolvedDependency.isResolvedDependency)(dependency) ||
+        isWeakOrLazy(dependency, options)
+      ) {
         continue;
       }
       yield nullthrows(this.dependencies.get(dependency.absolutePath));
@@ -429,6 +447,9 @@ class Graph {
       module;
     const resolvedContexts = new Map();
     for (const [key, dependency] of dependencies) {
+      if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+        continue;
+      }
       const resolvedContext = this.#resolvedContexts.get(
         dependency.absolutePath
       );
@@ -452,6 +473,9 @@ class Graph {
       delta.baseModuleData.set(module.path, this._moduleSnapshot(module));
     }
     for (const [key, dependency] of module.dependencies) {
+      if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+        continue;
+      }
       this._removeDependency(module, key, dependency, delta, options);
     }
     this.#gc.color.set(module.path, "black");
@@ -542,6 +566,9 @@ class Graph {
     if (color === "white" && !this.#gc.possibleCycleRoots.has(module.path)) {
       this.#gc.color.set(module.path, "black");
       for (const dependency of module.dependencies.values()) {
+        if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+          continue;
+        }
         const childModule = this.dependencies.get(dependency.absolutePath);
         if (childModule) {
           this._collectWhite(childModule, delta);

package/src/DeltaBundler/Graph.js.flow

@@ -39,11 +39,13 @@ import type {
   Module,
   ModuleData,
   Options,
+  ResolvedDependency,
   TransformInputOptions,
 } from './types.flow';
 
 import {fileMatchesContext} from '../lib/contextModule';
 import CountingSet from '../lib/CountingSet';
+import {isResolvedDependency} from '../lib/isResolvedDependency';
 import {buildSubgraph} from './buildSubgraph';
 
 const invariant = require('invariant');
@@ -121,7 +123,7 @@ function getInternalOptions<T>({
 }
 
 function isWeakOrLazy<T>(
-  dependency: Dependency,
+  dependency: ResolvedDependency,
   options: InternalOptions<T>,
 ): boolean {
   const asyncType = dependency.data.data.asyncType;
@@ -355,7 +357,7 @@ export class Graph<T = MixedOutput> {
         options.onDependencyAdded();
         return result;
       },
-      shouldTraverse: (dependency: Dependency) => {
+      shouldTraverse: (dependency: ResolvedDependency) => {
         if (options.shallow || isWeakOrLazy(dependency, options)) {
           return false;
         }
@@ -510,14 +512,11 @@ export class Graph<T = MixedOutput> {
     delta: Delta<T>,
     options: InternalOptions<T>,
   ): void {
-    const path = dependency.absolutePath;
-
-    // The module may already exist, in which case we just need to update some
-    // bookkeeping instead of adding a new node to the graph.
-    let module = this.dependencies.get(path);
-
     if (options.shallow) {
       // Don't add a node for the module if the graph is shallow (single-module).
+    } else if (!isResolvedDependency(dependency)) {
+      // If the dependency is a missing optional dependency, it has no node of
+      // its own. We just need to add it to the parent's dependency map.
     } else if (dependency.data.data.asyncType === 'weak') {
       // Exclude weak dependencies from the bundle.
     } else if (options.lazy && dependency.data.data.asyncType != null) {
@@ -526,6 +525,11 @@ export class Graph<T = MixedOutput> {
       // importBundleNodes.
       this._incrementImportBundleReference(dependency, parentModule);
     } else {
+      // The module may already exist, in which case we just need to update some
+      // bookkeeping instead of adding a new node to the graph.
+      const path = dependency.absolutePath;
+      let module = this.dependencies.get(path);
+
       if (!module) {
         try {
           module = this._recursivelyCommitModule(path, delta, options);
@@ -550,12 +554,15 @@ export class Graph<T = MixedOutput> {
       this._markModuleInUse(module);
     }
 
-    if (requireContext) {
-      this.#resolvedContexts.set(path, requireContext);
-    } else {
-      // This dependency may have existed previously as a require.context -
-      // clean it up.
-      this.#resolvedContexts.delete(path);
+    if (isResolvedDependency(dependency)) {
+      const path = dependency.absolutePath;
+      if (requireContext) {
+        this.#resolvedContexts.set(path, requireContext);
+      } else {
+        // This dependency may have existed previously as a require.context -
+        // clean it up.
+        this.#resolvedContexts.delete(path);
+      }
     }
 
     // Update the parent's dependency map unless we failed to add a dependency.
@@ -574,13 +581,16 @@ export class Graph<T = MixedOutput> {
   ): void {
     parentModule.dependencies.delete(key);
 
-    const {absolutePath} = dependency;
-
-    if (dependency.data.data.asyncType === 'weak') {
-      // Weak dependencies are excluded from the bundle.
+    if (
+      !isResolvedDependency(dependency) ||
+      dependency.data.data.asyncType === 'weak'
+    ) {
+      // Weak and unresolved dependencies are excluded from the bundle.
       return;
     }
 
+    const {absolutePath} = dependency;
+
     const module = this.dependencies.get(absolutePath);
 
     if (options.lazy && dependency.data.data.asyncType != null) {
@@ -671,8 +681,12 @@ export class Graph<T = MixedOutput> {
       orderedDependencies.set(module.path, module);
     }
 
-    module.dependencies.forEach((dependency: Dependency) => {
+    module.dependencies.forEach(dependency => {
       const path = dependency.absolutePath;
+      if (path == null) {
+        // If the dependency is not a missing optional dependency, it has no children to reorder.
+        return;
+      }
       const childModule = this.dependencies.get(path);
 
       if (!childModule) {
@@ -691,7 +705,7 @@ export class Graph<T = MixedOutput> {
 
   // Add an entry to importBundleNodes (or record an inverse dependency of an existing one)
   _incrementImportBundleReference(
-    dependency: Dependency,
+    dependency: ResolvedDependency,
     parentModule: Module<T>,
   ) {
     const {absolutePath} = dependency;
@@ -704,7 +718,7 @@ export class Graph<T = MixedOutput> {
 
   // Decrease the reference count of an entry in importBundleNodes (and delete it if necessary)
   _decrementImportBundleReference(
-    dependency: Dependency,
+    dependency: ResolvedDependency,
     parentModule: Module<T>,
   ) {
     const {absolutePath} = dependency;
@@ -734,7 +748,10 @@ export class Graph<T = MixedOutput> {
     options: InternalOptions<T>,
   ): Iterator<Module<T>> {
     for (const dependency of module.dependencies.values()) {
-      if (isWeakOrLazy(dependency, options)) {
+      if (
+        !isResolvedDependency(dependency) ||
+        isWeakOrLazy(dependency, options)
+      ) {
         continue;
       }
       yield nullthrows(this.dependencies.get(dependency.absolutePath));
@@ -747,6 +764,9 @@ export class Graph<T = MixedOutput> {
 
     const resolvedContexts: Map<string, RequireContext> = new Map();
     for (const [key, dependency] of dependencies) {
+      if (!isResolvedDependency(dependency)) {
+        continue;
+      }
       const resolvedContext = this.#resolvedContexts.get(
         dependency.absolutePath,
       );
@@ -783,6 +803,10 @@ export class Graph<T = MixedOutput> {
     }
 
     for (const [key, dependency] of module.dependencies) {
+      if (!isResolvedDependency(dependency)) {
+        // If the dependency is not a missing optional dependency, it has no children to remove.
+        continue;
+      }
       this._removeDependency(module, key, dependency, delta, options);
     }
     this.#gc.color.set(module.path, 'black');
@@ -894,6 +918,9 @@ export class Graph<T = MixedOutput> {
     if (color === 'white' && !this.#gc.possibleCycleRoots.has(module.path)) {
       this.#gc.color.set(module.path, 'black');
       for (const dependency of module.dependencies.values()) {
+        if (!isResolvedDependency(dependency)) {
+          continue;
+        }
         const childModule = this.dependencies.get(dependency.absolutePath);
         // The child may already have been collected.
         if (childModule) {

package/src/DeltaBundler/Serializers/getRamBundleInfo.js.flow

@@ -169,6 +169,7 @@ async function _getRamOptions(
   );
 
   return {
+    // $FlowFixMe[sketchy-null-bool]
     preloadedModules: preloadedModules || {},
     ramGroups: ramGroups || [],
   };

package/src/DeltaBundler/Serializers/helpers/getTransitiveDependencies.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var _isResolvedDependency = require("../../../lib/isResolvedDependency");
 function getTransitiveDependencies(path, graph) {
   const dependencies = _getDeps(path, graph, new Set());
   dependencies.delete(path);
@@ -15,7 +16,9 @@ function _getDeps(path, graph, deps) {
   }
   deps.add(path);
   for (const dependency of module.dependencies.values()) {
-    _getDeps(dependency.absolutePath, graph, deps);
+    if ((0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+      _getDeps(dependency.absolutePath, graph, deps);
+    }
   }
   return deps;
 }

package/src/DeltaBundler/Serializers/helpers/getTransitiveDependencies.js.flow

@@ -13,6 +13,8 @@
 
 import type {ReadOnlyGraph} from '../../types.flow';
 
+import {isResolvedDependency} from '../../../lib/isResolvedDependency';
+
 function getTransitiveDependencies<T>(
   path: string,
   graph: ReadOnlyGraph<T>,
@@ -44,7 +46,9 @@ function _getDeps<T>(
   deps.add(path);
 
   for (const dependency of module.dependencies.values()) {
-    _getDeps(dependency.absolutePath, graph, deps);
+    if (isResolvedDependency(dependency)) {
+      _getDeps(dependency.absolutePath, graph, deps);
+    }
   }
 
   return deps;

package/src/DeltaBundler/Serializers/helpers/js.js

@@ -1,5 +1,6 @@
 "use strict";
 
+const { isResolvedDependency } = require("../../../lib/isResolvedDependency");
 const invariant = require("invariant");
 const jscSafeUrl = require("jsc-safe-url");
 const { addParamsToDefineCall } = require("metro-transform-plugins");
@@ -18,6 +19,9 @@ function getModuleParams(module, options) {
   let hasPaths = false;
   const dependencyMapArray = Array.from(module.dependencies.values()).map(
     (dependency) => {
+      if (!isResolvedDependency(dependency)) {
+        return null;
+      }
       const id = options.createModuleId(dependency.absolutePath);
       if (options.includeAsyncPaths && dependency.data.data.asyncType != null) {
         hasPaths = true;

package/src/DeltaBundler/Serializers/helpers/js.js.flow

@@ -14,6 +14,7 @@
 import type {MixedOutput, Module} from '../../types.flow';
 import type {JsOutput} from 'metro-transform-worker';
 
+const {isResolvedDependency} = require('../../../lib/isResolvedDependency');
 const invariant = require('invariant');
 const jscSafeUrl = require('jsc-safe-url');
 const {addParamsToDefineCall} = require('metro-transform-plugins');
@@ -47,6 +48,11 @@ function getModuleParams(module: Module<>, options: Options): Array<mixed> {
   let hasPaths = false;
   const dependencyMapArray = Array.from(module.dependencies.values()).map(
     dependency => {
+      if (!isResolvedDependency(dependency)) {
+        // An unresolved dependency, which should cause a runtime error
+        // when required.
+        return null;
+      }
       const id = options.createModuleId(dependency.absolutePath);
       if (options.includeAsyncPaths && dependency.data.data.asyncType != null) {
         hasPaths = true;

package/src/DeltaBundler/Transformer.js

@@ -2,7 +2,11 @@
 
 var _crypto = _interopRequireDefault(require("crypto"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const getTransformCacheKey = require("./getTransformCacheKey");
 const WorkerFarm = require("./WorkerFarm");
@@ -20,7 +24,6 @@ class Transformer {
     const {
       getTransformOptions: _getTransformOptions,
       transformVariants: _transformVariants,
-      workerPath: _workerPath,
       unstable_workerThreads: _workerThreads,
       ...transformerConfig
     } = this._config.transformer;

package/src/DeltaBundler/Transformer.js.flow

@@ -25,7 +25,9 @@ const fs = require('fs');
 const {Cache, stableHash} = require('metro-cache');
 const path = require('path');
 
-type GetOrComputeSha1Fn = string => Promise<{content?: Buffer, sha1: string}>;
+type GetOrComputeSha1Fn = string => Promise<
+  $ReadOnly<{content?: Buffer, sha1: string}>,
+>;
 
 class Transformer {
   _config: ConfigT;
@@ -50,7 +52,6 @@ class Transformer {
     const {
       getTransformOptions: _getTransformOptions,
       transformVariants: _transformVariants,
-      workerPath: _workerPath,
       unstable_workerThreads: _workerThreads,
       ...transformerConfig
     } = this._config.transformer;

package/src/DeltaBundler/Worker.d.ts

@@ -18,16 +18,14 @@ type LogEntry = unknown;
 
 export type TransformOptions = JsTransformOptions;
 
-declare function transform(
-  filename: string,
-  transformOptions: JsTransformOptions,
-  projectRoot: string,
-  transformerConfig: TransformerConfig,
-  fileBuffer?: Buffer,
-): Promise<Data>;
-
 export interface Worker {
-  readonly transform: typeof transform;
+  readonly transform: (
+    filename: string,
+    transformOptions: JsTransformOptions,
+    projectRoot: string,
+    transformerConfig: TransformerConfig,
+    fileBuffer?: Buffer,
+  ) => Promise<Data>;
 }
 
 export interface TransformerConfig {

package/src/DeltaBundler/Worker.flow.js.flow

@@ -12,7 +12,7 @@
 'use strict';
 
 import type {TransformResult} from './types.flow';
-import type {LogEntry} from 'metro-core/src/Logger';
+import type {LogEntry} from 'metro-core/private/Logger';
 import type {
   JsTransformerConfig,
   JsTransformOptions,
@@ -109,7 +109,7 @@ async function transformFile(
     transformerConfig.transformerPath,
   );
 
-  const transformFileStartLogEntry = {
+  const transformFileStartLogEntry: LogEntry = {
     action_name: 'Transforming file',
     action_phase: 'start',
     file_name: filename,

package/src/DeltaBundler/WorkerFarm.js

@@ -6,7 +6,7 @@ class WorkerFarm {
   constructor(config, transformerConfig) {
     this._config = config;
     this._transformerConfig = transformerConfig;
-    const absoluteWorkerPath = require.resolve(config.transformer.workerPath);
+    const absoluteWorkerPath = require.resolve("./Worker.js");
     if (this._config.maxWorkers > 1) {
       const worker = this._makeFarm(
         absoluteWorkerPath,
@@ -27,7 +27,7 @@ class WorkerFarm {
       });
       this._worker = worker;
     } else {
-      this._worker = require.call(null, this._config.transformer.workerPath);
+      this._worker = require("./Worker");
     }
   }
   async kill() {

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -39,7 +39,7 @@ class WorkerFarm {
   constructor(config: ConfigT, transformerConfig: TransformerConfig) {
     this._config = config;
     this._transformerConfig = transformerConfig;
-    const absoluteWorkerPath = require.resolve(config.transformer.workerPath);
+    const absoluteWorkerPath = require.resolve('./Worker.js');
 
     if (this._config.maxWorkers > 1) {
       const worker = this._makeFarm(
@@ -63,11 +63,7 @@ class WorkerFarm {
 
       this._worker = worker;
     } else {
-      // eslint-disable-next-line no-useless-call
-      this._worker = (require.call(
-        null,
-        this._config.transformer.workerPath,
-      ): Worker);
+      this._worker = (require('./Worker'): Worker);
     }
   }
 

package/src/DeltaBundler/buildSubgraph.js

@@ -5,15 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildSubgraph = buildSubgraph;
 var _contextModule = require("../lib/contextModule");
+var _isResolvedDependency = require("../lib/isResolvedDependency");
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 function resolveDependencies(parentPath, dependencies, resolve) {
   const maybeResolvedDeps = new Map();
   const resolvedContexts = new Map();
   for (const dep of dependencies) {
-    let resolvedDep;
+    let maybeResolvedDep;
     const key = dep.data.key;
     const { contextParams } = dep.data;
     if (contextParams) {
@@ -32,13 +37,13 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         ),
       };
       resolvedContexts.set(key, resolvedContext);
-      resolvedDep = {
+      maybeResolvedDep = {
         absolutePath,
         data: dep,
       };
     } else {
       try {
-        resolvedDep = {
+        maybeResolvedDep = {
           absolutePath: resolve(parentPath, dep).filePath,
           data: dep,
         };
@@ -46,6 +51,9 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         if (dep.data.isOptional !== true) {
           throw error;
         }
+        maybeResolvedDep = {
+          data: dep,
+        };
       }
     }
     if (maybeResolvedDeps.has(key)) {
@@ -53,16 +61,10 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`
       );
     }
-    maybeResolvedDeps.set(key, resolvedDep);
-  }
-  const resolvedDeps = new Map();
-  for (const [key, resolvedDep] of maybeResolvedDeps) {
-    if (resolvedDep) {
-      resolvedDeps.set(key, resolvedDep);
-    }
+    maybeResolvedDeps.set(key, maybeResolvedDep);
   }
   return {
-    dependencies: resolvedDeps,
+    dependencies: maybeResolvedDeps,
     resolvedContexts,
   };
 }
@@ -90,9 +92,13 @@ async function buildSubgraph(
       ...resolutionResult,
     });
     await Promise.all(
-      [...resolutionResult.dependencies]
-        .filter(([key, dependency]) => shouldTraverse(dependency))
-        .map(([key, dependency]) =>
+      [...resolutionResult.dependencies.values()]
+        .filter(
+          (dependency) =>
+            (0, _isResolvedDependency.isResolvedDependency)(dependency) &&
+            shouldTraverse(dependency)
+        )
+        .map((dependency) =>
           visit(
             dependency.absolutePath,
             resolutionResult.resolvedContexts.get(dependency.data.data.key)