metro-runtime 0.70.2 → 0.71.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-runtime",
-  "version": "0.70.2",
+  "version": "0.71.1",
   "description": "🚇 Module required for evaluating Metro bundles.",
   "main": "src",
   "repository": {
@@ -12,6 +12,9 @@
     "cleanup-release": "test ! -e build && mv src build && mv src.real src"
   },
   "license": "MIT",
+  "dependencies": {
+    "@babel/runtime": "^7.0.0"
+  },
   "devDependencies": {
     "@babel/core": "^7.14.0"
   }

package/src/modules/types.flow.js.flow

@@ -13,70 +13,70 @@
 export type ModuleMap = $ReadOnlyArray<[number, string]>;
 export type BytecodeModuleMap = $ReadOnlyArray<[number, Array<Buffer>]>;
 
-export type Bundle = {|
+export type Bundle = {
   +modules: ModuleMap,
   +post: string,
   +pre: string,
-|};
+};
 
-export type BytecodeBundle = {|
+export type BytecodeBundle = {
   +modules: BytecodeModuleMap,
   +post: Array<Buffer>,
   +pre: Array<Buffer>,
-|};
+};
 
-export type DeltaBundle = {|
+export type DeltaBundle = {
   +added: ModuleMap,
   +modified: ModuleMap,
   +deleted: $ReadOnlyArray<number>,
-|};
+};
 
 export type BundleVariant =
-  | {|+base: true, +revisionId: string, ...Bundle|}
-  | {|+base: false, +revisionId: string, ...DeltaBundle|};
+  | {+base: true, +revisionId: string, ...Bundle}
+  | {+base: false, +revisionId: string, ...DeltaBundle};
 
-export type BundleMetadata = {|
+export type BundleMetadata = {
   +pre: number,
   +post: number,
   +modules: $ReadOnlyArray<[number, number]>,
-|};
+};
 
-export type FormattedError = {|
+export type FormattedError = {
   +type: string,
   +message: string,
   +errors: Array<{description: string, ...}>,
-|};
+};
 
-export type HmrModule = {|
+export type HmrModule = {
   +module: [number, string],
   +sourceMappingURL: string,
   +sourceURL: string,
-|};
+};
 
-export type HmrUpdate = {|
+export type HmrUpdate = {
   +added: $ReadOnlyArray<HmrModule>,
   +deleted: $ReadOnlyArray<number>,
   +isInitialUpdate: boolean,
   +modified: $ReadOnlyArray<HmrModule>,
   +revisionId: string,
-|};
+};
 
-export type HmrUpdateMessage = {|
+export type HmrUpdateMessage = {
   +type: 'update',
   +body: HmrUpdate,
-|};
+};
 
-export type HmrErrorMessage = {|
+export type HmrErrorMessage = {
   +type: 'error',
   +body: FormattedError,
-|};
+};
 
 export type HmrClientMessage =
-  | {|
+  | {
       +type: 'register-entrypoints',
       +entryPoints: Array<string>,
-    |}
-  | {|
+    }
+  | {
       +type: 'log',
       +level:
         | 'trace'
@@ -89,23 +89,23 @@ export type HmrClientMessage =
         | 'debug',
       +data: Array<mixed>,
       +mode: 'BRIDGE' | 'NOBRIDGE',
-    |}
-  | {|
+    }
+  | {
       +type: 'log-opt-in',
-    |};
+    };
 
 export type HmrMessage =
-  | {|
+  | {
       +type: 'bundle-registered',
-    |}
-  | {|
+    }
+  | {
       +type: 'update-start',
-      +body: {|
+      +body: {
         +isInitialUpdate: boolean,
-      |},
-    |}
-  | {|
+      },
+    }
+  | {
       +type: 'update-done',
-    |}
+    }
   | HmrUpdateMessage
   | HmrErrorMessage;

package/src/polyfills/require.js

@@ -19,6 +19,7 @@ var modules = clear(); // Don't use a Symbol here, it would pull in an extra pol
 // additional stuff (e.g. Array.from).
 
 const EMPTY = {};
+const CYCLE_DETECTED = {};
 const { hasOwnProperty } = {};
 
 if (__DEV__) {
@@ -473,63 +474,76 @@ if (__DEV__) {
     // have side effects and lead to confusing and meaningless crashes.
 
     let didBailOut = false;
-    const updatedModuleIDs = topologicalSort(
-      [id], // Start with the changed module and go upwards
-      (pendingID) => {
-        const pendingModule = modules[pendingID];
-
-        if (pendingModule == null) {
-          // Nothing to do.
-          return [];
-        }
+    let updatedModuleIDs;
 
-        const pendingHot = pendingModule.hot;
+    try {
+      updatedModuleIDs = topologicalSort(
+        [id], // Start with the changed module and go upwards
+        (pendingID) => {
+          const pendingModule = modules[pendingID];
+
+          if (pendingModule == null) {
+            // Nothing to do.
+            return [];
+          }
 
-        if (pendingHot == null) {
-          throw new Error(
-            "[Refresh] Expected module.hot to always exist in DEV."
-          );
-        } // A module can be accepted manually from within itself.
+          const pendingHot = pendingModule.hot;
 
-        let canAccept = pendingHot._didAccept;
+          if (pendingHot == null) {
+            throw new Error(
+              "[Refresh] Expected module.hot to always exist in DEV."
+            );
+          } // A module can be accepted manually from within itself.
 
-        if (!canAccept && Refresh != null) {
-          // Or React Refresh may mark it accepted based on exports.
-          const isBoundary = isReactRefreshBoundary(
-            Refresh,
-            pendingModule.publicModule.exports
-          );
+          let canAccept = pendingHot._didAccept;
+
+          if (!canAccept && Refresh != null) {
+            // Or React Refresh may mark it accepted based on exports.
+            const isBoundary = isReactRefreshBoundary(
+              Refresh,
+              pendingModule.publicModule.exports
+            );
 
-          if (isBoundary) {
-            canAccept = true;
-            refreshBoundaryIDs.add(pendingID);
+            if (isBoundary) {
+              canAccept = true;
+              refreshBoundaryIDs.add(pendingID);
+            }
           }
-        }
 
-        if (canAccept) {
-          // Don't look at parents.
-          return [];
-        } // If we bubble through the roof, there is no way to do a hot update.
-        // Bail out altogether. This is the failure case.
-
-        const parentIDs = inverseDependencies[pendingID];
-
-        if (parentIDs.length === 0) {
-          // Reload the app because the hot reload can't succeed.
-          // This should work both on web and React Native.
-          performFullRefresh("No root boundary", {
-            source: mod,
-            failed: pendingModule,
-          });
-          didBailOut = true;
-          return [];
-        } // This module can't handle the update but maybe all its parents can?
-        // Put them all in the queue to run the same set of checks.
-
-        return parentIDs;
-      },
-      () => didBailOut // Should we stop?
-    ).reverse();
+          if (canAccept) {
+            // Don't look at parents.
+            return [];
+          } // If we bubble through the roof, there is no way to do a hot update.
+          // Bail out altogether. This is the failure case.
+
+          const parentIDs = inverseDependencies[pendingID];
+
+          if (parentIDs.length === 0) {
+            // Reload the app because the hot reload can't succeed.
+            // This should work both on web and React Native.
+            performFullRefresh("No root boundary", {
+              source: mod,
+              failed: pendingModule,
+            });
+            didBailOut = true;
+            return [];
+          } // This module can't handle the update but maybe all its parents can?
+          // Put them all in the queue to run the same set of checks.
+
+          return parentIDs;
+        },
+        () => didBailOut // Should we stop?
+      ).reverse();
+    } catch (e) {
+      if (e === CYCLE_DETECTED) {
+        performFullRefresh("Dependency cycle", {
+          source: mod,
+        });
+        return;
+      }
+
+      throw e;
+    }
 
     if (didBailOut) {
       return;
@@ -539,7 +553,6 @@ if (__DEV__) {
     const seenModuleIDs = new Set();
 
     for (let i = 0; i < updatedModuleIDs.length; i++) {
-      // Don't process twice if we have a cycle.
       const updatedID = updatedModuleIDs[i];
 
       if (seenModuleIDs.has(updatedID)) {
@@ -651,29 +664,35 @@ if (__DEV__) {
   const topologicalSort = function (roots, getEdges, earlyStop) {
     const result = [];
     const visited = new Set();
+    const stack = new Set();
 
     function traverseDependentNodes(node) {
+      if (stack.has(node)) {
+        throw CYCLE_DETECTED;
+      }
+
+      if (visited.has(node)) {
+        return;
+      }
+
       visited.add(node);
+      stack.add(node);
       const dependentNodes = getEdges(node);
 
       if (earlyStop(node)) {
+        stack.delete(node);
         return;
       }
 
       dependentNodes.forEach((dependent) => {
-        if (visited.has(dependent)) {
-          return;
-        }
-
         traverseDependentNodes(dependent);
       });
+      stack.delete(node);
       result.push(node);
     }
 
     roots.forEach((root) => {
-      if (!visited.has(root)) {
-        traverseDependentNodes(root);
-      }
+      traverseDependentNodes(root);
     });
     return result;
   };

package/src/polyfills/require.js.flow

@@ -28,13 +28,13 @@ type FactoryFn = (
   dependencyMap: ?DependencyMap,
 ) => void;
 type HotModuleReloadingCallback = () => void;
-type HotModuleReloadingData = {|
+type HotModuleReloadingData = {
   _acceptCallback: ?HotModuleReloadingCallback,
   _disposeCallback: ?HotModuleReloadingCallback,
   _didAccept: boolean,
   accept: (callback?: HotModuleReloadingCallback) => void,
   dispose: (callback?: HotModuleReloadingCallback) => void,
-|};
+};
 type ModuleID = number;
 type Module = {
   id?: ModuleID,
@@ -42,7 +42,7 @@ type Module = {
   hot?: HotModuleReloadingData,
   ...
 };
-type ModuleDefinition = {|
+type ModuleDefinition = {
   dependencyMap: ?DependencyMap,
   error?: any,
   factory: FactoryFn,
@@ -54,7 +54,7 @@ type ModuleDefinition = {|
   path?: string,
   publicModule: Module,
   verboseName?: string,
-|};
+};
 type ModuleList = {
   [number]: ?ModuleDefinition,
   __proto__: null,
@@ -74,6 +74,7 @@ var modules = clear();
 // Don't use a Symbol here, it would pull in an extra polyfill with all sorts of
 // additional stuff (e.g. Array.from).
 const EMPTY = {};
+const CYCLE_DETECTED = {};
 const {hasOwnProperty} = {};
 
 if (__DEV__) {
@@ -240,7 +241,7 @@ function metroImportAll(moduleId: ModuleID | VerboseModuleNameForDev | number) {
   if (exports && exports.__esModule) {
     importedAll = exports;
   } else {
-    importedAll = {};
+    importedAll = ({}: {[string]: any});
 
     // Refrain from using Object.assign, it has to work in ES3 environments.
     if (exports) {
@@ -542,56 +543,67 @@ if (__DEV__) {
     // have side effects and lead to confusing and meaningless crashes.
 
     let didBailOut = false;
-    const updatedModuleIDs = topologicalSort(
-      [id], // Start with the changed module and go upwards
-      pendingID => {
-        const pendingModule = modules[pendingID];
-        if (pendingModule == null) {
-          // Nothing to do.
-          return [];
-        }
-        const pendingHot = pendingModule.hot;
-        if (pendingHot == null) {
-          throw new Error(
-            '[Refresh] Expected module.hot to always exist in DEV.',
-          );
-        }
-        // A module can be accepted manually from within itself.
-        let canAccept = pendingHot._didAccept;
-        if (!canAccept && Refresh != null) {
-          // Or React Refresh may mark it accepted based on exports.
-          const isBoundary = isReactRefreshBoundary(
-            Refresh,
-            pendingModule.publicModule.exports,
-          );
-          if (isBoundary) {
-            canAccept = true;
-            refreshBoundaryIDs.add(pendingID);
+    let updatedModuleIDs;
+    try {
+      updatedModuleIDs = topologicalSort(
+        [id], // Start with the changed module and go upwards
+        pendingID => {
+          const pendingModule = modules[pendingID];
+          if (pendingModule == null) {
+            // Nothing to do.
+            return [];
           }
-        }
-        if (canAccept) {
-          // Don't look at parents.
-          return [];
-        }
-        // If we bubble through the roof, there is no way to do a hot update.
-        // Bail out altogether. This is the failure case.
-        const parentIDs = inverseDependencies[pendingID];
-        if (parentIDs.length === 0) {
-          // Reload the app because the hot reload can't succeed.
-          // This should work both on web and React Native.
-          performFullRefresh('No root boundary', {
-            source: mod,
-            failed: pendingModule,
-          });
-          didBailOut = true;
-          return [];
-        }
-        // This module can't handle the update but maybe all its parents can?
-        // Put them all in the queue to run the same set of checks.
-        return parentIDs;
-      },
-      () => didBailOut, // Should we stop?
-    ).reverse();
+          const pendingHot = pendingModule.hot;
+          if (pendingHot == null) {
+            throw new Error(
+              '[Refresh] Expected module.hot to always exist in DEV.',
+            );
+          }
+          // A module can be accepted manually from within itself.
+          let canAccept = pendingHot._didAccept;
+          if (!canAccept && Refresh != null) {
+            // Or React Refresh may mark it accepted based on exports.
+            const isBoundary = isReactRefreshBoundary(
+              Refresh,
+              pendingModule.publicModule.exports,
+            );
+            if (isBoundary) {
+              canAccept = true;
+              refreshBoundaryIDs.add(pendingID);
+            }
+          }
+          if (canAccept) {
+            // Don't look at parents.
+            return [];
+          }
+          // If we bubble through the roof, there is no way to do a hot update.
+          // Bail out altogether. This is the failure case.
+          const parentIDs = inverseDependencies[pendingID];
+          if (parentIDs.length === 0) {
+            // Reload the app because the hot reload can't succeed.
+            // This should work both on web and React Native.
+            performFullRefresh('No root boundary', {
+              source: mod,
+              failed: pendingModule,
+            });
+            didBailOut = true;
+            return [];
+          }
+          // This module can't handle the update but maybe all its parents can?
+          // Put them all in the queue to run the same set of checks.
+          return parentIDs;
+        },
+        () => didBailOut, // Should we stop?
+      ).reverse();
+    } catch (e) {
+      if (e === CYCLE_DETECTED) {
+        performFullRefresh('Dependency cycle', {
+          source: mod,
+        });
+        return;
+      }
+      throw e;
+    }
 
     if (didBailOut) {
       return;
@@ -601,7 +613,6 @@ if (__DEV__) {
     // Run the actual factories.
     const seenModuleIDs = new Set();
     for (let i = 0; i < updatedModuleIDs.length; i++) {
-      // Don't process twice if we have a cycle.
       const updatedID = updatedModuleIDs[i];
       if (seenModuleIDs.has(updatedID)) {
         continue;
@@ -709,24 +720,29 @@ if (__DEV__) {
   ): Array<T> {
     const result = [];
     const visited = new Set();
+    const stack = new Set();
     function traverseDependentNodes(node: T) {
+      if (stack.has(node)) {
+        throw CYCLE_DETECTED;
+      }
+      if (visited.has(node)) {
+        return;
+      }
       visited.add(node);
+      stack.add(node);
       const dependentNodes = getEdges(node);
       if (earlyStop(node)) {
+        stack.delete(node);
         return;
       }
       dependentNodes.forEach(dependent => {
-        if (visited.has(dependent)) {
-          return;
-        }
         traverseDependentNodes(dependent);
       });
+      stack.delete(node);
       result.push(node);
     }
     roots.forEach(root => {
-      if (!visited.has(root)) {
-        traverseDependentNodes(root);
-      }
+      traverseDependentNodes(root);
     });
     return result;
   };
@@ -806,7 +822,10 @@ if (__DEV__) {
 
   const performFullRefresh = (
     reason: string,
-    modules: $ReadOnly<{source: ModuleDefinition, failed: ModuleDefinition}>,
+    modules: $ReadOnly<{
+      source?: ModuleDefinition,
+      failed?: ModuleDefinition,
+    }>,
   ) => {
     /* global window */
     if (