metro 0.63.0 → 0.64.0

package/src/ModuleGraph/worker/collectDependencies.js

@@ -11,6 +11,7 @@
 
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
+
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
     if (enumerableOnly)
@@ -19,12 +20,14 @@ function ownKeys(object, enumerableOnly) {
       });
     keys.push.apply(keys, symbols);
   }
+
   return keys;
 }
 
 function _objectSpread(target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i] != null ? arguments[i] : {};
+
     if (i % 2) {
       ownKeys(Object(source), true).forEach(function(key) {
         _defineProperty(target, key, source[key]);
@@ -41,6 +44,7 @@ function _objectSpread(target) {
       });
     }
   }
+
   return target;
 }
 
@@ -55,55 +59,44 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
+
   return obj;
 }
 
-function _slicedToArray(arr, i) {
-  return (
-    _arrayWithHoles(arr) ||
-    _iterableToArrayLimit(arr, i) ||
-    _unsupportedIterableToArray(arr, i) ||
-    _nonIterableRest()
-  );
-}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
 
-function _nonIterableRest() {
-  throw new TypeError(
-    "Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
-  );
-}
+  var target = _objectWithoutPropertiesLoose(source, excluded);
 
-function _iterableToArrayLimit(arr, i) {
-  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr)))
-    return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _e = undefined;
-  try {
-    for (
-      var _i = arr[Symbol.iterator](), _s;
-      !(_n = (_s = _i.next()).done);
-      _n = true
-    ) {
-      _arr.push(_s.value);
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
     }
   }
-  return _arr;
+
+  return target;
 }
 
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
 }
 
 function _toConsumableArray(arr) {
@@ -142,10 +135,14 @@ function _arrayWithoutHoles(arr) {
 
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
+
   for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
   return arr2;
 }
 
+const invariant = require("invariant");
+
 const nullthrows = require("nullthrows");
 
 const generate = require("@babel/generator").default;
@@ -156,32 +153,7 @@ const traverse = require("@babel/traverse").default;
 
 const types = require("@babel/types");
 
-/**
- * Produces a Babel template that will throw at runtime when the require call
- * is reached. This makes dynamic require errors catchable by libraries that
- * want to use them.
- */
-const dynamicRequireErrorTemplate = template(`
-  (function(line) {
-    throw new Error(
-      'Dynamic require defined at line ' + line + '; not supported by Metro',
-    );
-  })(LINE)
-`);
-/**
- * Produces a Babel template that transforms an "import(...)" call into a
- * "require(...)" call to the asyncRequire specified.
- */
-
-const makeAsyncRequireTemplate = template(`
-  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME)
-`);
-const makeAsyncPrefetchTemplate = template(`
-  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME)
-`);
-const makeJSResourceTemplate = template(`
-  require(ASYNC_REQUIRE_MODULE_PATH).resource(MODULE_ID, MODULE_NAME)
-`);
+const isImport = types.isImport;
 /**
  * Transform all the calls to `require()` and `import()` in a file into ID-
  * independent code, and return the list of dependencies. For example, a call
@@ -193,17 +165,25 @@ const makeJSResourceTemplate = template(`
  */
 
 function collectDependencies(ast, options) {
+  var _options$dependencyRe, _options$dependencyTr;
+
   const visited = new WeakSet();
   const state = {
     asyncRequireModulePathStringLiteral: null,
-    dependency: 0,
     dependencyCalls: new Set(),
-    dependencyData: new Map(),
-    dependencyIndexes: new Map(),
+    dependencyRegistry:
+      (_options$dependencyRe = options.dependencyRegistry) !== null &&
+      _options$dependencyRe !== void 0
+        ? _options$dependencyRe
+        : new DefaultModuleDependencyRegistry(),
+    dependencyTransformer:
+      (_options$dependencyTr = options.dependencyTransformer) !== null &&
+      _options$dependencyTr !== void 0
+        ? _options$dependencyTr
+        : DefaultDependencyTransformer,
     dependencyMapIdentifier: null,
     dynamicRequires: options.dynamicRequires,
     keepRequireNames: options.keepRequireNames,
-    disableRequiresTransform: !!options.disableRequiresTransform,
     allowOptionalDependencies: options.allowOptionalDependencies
   };
   const visitor = {
@@ -212,37 +192,52 @@ function collectDependencies(ast, options) {
         return;
       }
 
-      const callee = path.get("callee");
-      const name = callee.node.name;
+      const callee = path.node.callee;
+      const name = callee.type === "Identifier" ? callee.name : null;
 
-      if (callee.isImport()) {
+      if (isImport(callee)) {
         processImportCall(path, state, {
-          prefetchOnly: false
+          asyncType: "async"
         });
         return;
       }
 
       if (name === "__prefetchImport" && !path.scope.getBinding(name)) {
         processImportCall(path, state, {
-          prefetchOnly: true
+          asyncType: "prefetch"
+        });
+        return;
+      }
+
+      if (name === "__jsResource" && !path.scope.getBinding(name)) {
+        processImportCall(path, state, {
+          asyncType: "async",
+          jsResource: true
         });
         return;
       }
 
       if (
-        (name === "__jsResource" ||
-          name === "__conditionallySplitJSResource") &&
+        name === "__conditionallySplitJSResource" &&
         !path.scope.getBinding(name)
       ) {
+        const args = path.get("arguments");
+        invariant(Array.isArray(args), "Expected arguments to be an array");
         processImportCall(path, state, {
-          prefetchOnly: false,
-          jsResource: true
+          asyncType: "async",
+          jsResource: true,
+          splitCondition: args[1]
         });
         return;
       }
 
-      if (state.dependencyCalls.has(name) && !path.scope.getBinding(name)) {
-        visited.add(processRequireCall(path, state).node);
+      if (
+        name != null &&
+        state.dependencyCalls.has(name) &&
+        !path.scope.getBinding(name)
+      ) {
+        processRequireCall(path, state);
+        visited.add(path.node);
       }
     },
 
@@ -270,18 +265,19 @@ function collectDependencies(ast, options) {
       );
     }
   };
-  traverse(ast, visitor, null, state); // Compute the list of dependencies.
+  traverse(ast, visitor, null, state);
+  const collectedDependencies = state.dependencyRegistry.getDependencies(); // Compute the list of dependencies.
 
-  const dependencies = new Array(state.dependency);
+  const dependencies = new Array(collectedDependencies.length);
 
-  for (const _ref of state.dependencyData) {
-    var _ref2 = _slicedToArray(_ref, 2);
+  for (const _ref of collectedDependencies) {
+    const index = _ref.index,
+      name = _ref.name,
+      dependencyData = _objectWithoutProperties(_ref, ["index", "name"]);
 
-    const name = _ref2[0];
-    const data = _ref2[1];
-    dependencies[nullthrows(state.dependencyIndexes.get(name))] = {
+    dependencies[index] = {
       name,
-      data
+      data: dependencyData
     };
   }
 
@@ -294,168 +290,110 @@ function collectDependencies(ast, options) {
 
 function collectImports(path, state) {
   if (path.node.source) {
-    const dep = getDependency(
+    registerDependency(
       state,
-      path.node.source.value,
       {
-        prefetchOnly: false
+        name: path.node.source.value,
+        asyncType: null,
+        optional: false
       },
       path
     );
-    dep.data.asyncType = null;
   }
 }
 
-function processImportCall(path, state, opts) {
+function processImportCall(path, state, options) {
   const name = getModuleNameFromCallArgs(path);
 
   if (name == null) {
     throw new InvalidRequireCallError(path);
   }
 
-  const options = _objectSpread(
-    _objectSpread({}, opts),
-    {},
+  const dep = registerDependency(
+    state,
     {
-      isOptional: isOptionalDependency(name, path, state)
-    }
-  );
-
-  const dep = getDependency(state, name, options, path);
-
-  if (!options.prefetchOnly && dep.data.asyncType === "prefetch") {
-    dep.data.asyncType = "async";
-  }
-
-  if (state.disableRequiresTransform) {
-    return path;
-  }
-
-  const ASYNC_REQUIRE_MODULE_PATH = state.asyncRequireModulePathStringLiteral;
-  const MODULE_ID = types.memberExpression(
-    state.dependencyMapIdentifier,
-    types.numericLiteral(dep.index),
-    true
+      name,
+      asyncType: options.asyncType,
+      splitCondition: options.splitCondition,
+      optional: isOptionalDependency(name, path, state)
+    },
+    path
   );
-  const MODULE_NAME = types.stringLiteral(name);
+  const transformer = state.dependencyTransformer;
 
   if (options.jsResource) {
-    path.replaceWith(
-      makeJSResourceTemplate({
-        ASYNC_REQUIRE_MODULE_PATH,
-        MODULE_ID,
-        MODULE_NAME
-      })
-    );
-  } else if (!options.prefetchOnly) {
-    path.replaceWith(
-      makeAsyncRequireTemplate({
-        ASYNC_REQUIRE_MODULE_PATH,
-        MODULE_ID,
-        MODULE_NAME
-      })
-    );
+    transformer.transformJSResource(path, dep, state);
+  } else if (options.asyncType === "async") {
+    transformer.transformImportCall(path, dep, state);
   } else {
-    path.replaceWith(
-      makeAsyncPrefetchTemplate({
-        ASYNC_REQUIRE_MODULE_PATH,
-        MODULE_ID,
-        MODULE_NAME
-      })
-    );
+    transformer.transformPrefetch(path, dep, state);
   }
-
-  return path;
 }
 
 function processRequireCall(path, state) {
   const name = getModuleNameFromCallArgs(path);
+  const transformer = state.dependencyTransformer;
 
   if (name == null) {
     if (state.dynamicRequires === "reject") {
       throw new InvalidRequireCallError(path);
     }
 
-    path.replaceWith(
-      dynamicRequireErrorTemplate({
-        LINE: "" + path.node.loc.start.line
-      })
-    );
-    return path;
+    transformer.transformIllegalDynamicRequire(path, state);
+    return;
   }
 
-  const dep = getDependency(
+  const dep = registerDependency(
     state,
-    name,
     {
-      prefetchOnly: false,
-      isOptional: isOptionalDependency(name, path, state)
+      name,
+      asyncType: null,
+      optional: isOptionalDependency(name, path, state)
     },
     path
   );
-  dep.data.asyncType = null;
-
-  if (state.disableRequiresTransform) {
-    return path;
-  }
-
-  const moduleIDExpression = types.memberExpression(
-    state.dependencyMapIdentifier,
-    types.numericLiteral(dep.index),
-    true
-  );
-  path.node.arguments = state.keepRequireNames
-    ? [moduleIDExpression, types.stringLiteral(name)]
-    : [moduleIDExpression];
-  return path;
+  transformer.transformSyncRequire(path, dep, state);
 }
 
 function getNearestLocFromPath(path) {
-  var _path;
+  var _current;
+
+  let current = path;
 
-  while (path && !path.node.loc) {
-    path = path.parentPath;
+  while (current && !current.node.loc) {
+    current = current.parentPath;
   }
 
-  return (_path = path) === null || _path === void 0 ? void 0 : _path.node.loc;
+  return (_current = current) === null || _current === void 0
+    ? void 0
+    : _current.node.loc;
 }
 
-function getDependency(state, name, options, path) {
+function registerDependency(state, qualifier, path) {
+  const dependency = state.dependencyRegistry.registerDependency(qualifier);
   const loc = getNearestLocFromPath(path);
-  let index = state.dependencyIndexes.get(name);
-  let data = state.dependencyData.get(name);
-
-  if (!data) {
-    index = state.dependency++;
-    data = {
-      asyncType: "async",
-      locs: []
-    };
-
-    if (options.prefetchOnly) {
-      data.asyncType = "prefetch";
-    }
-
-    if (options.isOptional) {
-      data.isOptional = true;
-    }
-
-    state.dependencyIndexes.set(name, index);
-    state.dependencyData.set(name, data);
-  }
 
   if (loc != null) {
-    data.locs.push(loc);
+    dependency.locs.push(loc);
   }
 
-  return {
-    index: nullthrows(index),
-    data: nullthrows(data)
-  };
+  return dependency;
 }
 
-const isOptionalDependency = (name, path, state) => {
-  const allowOptionalDependencies = state.allowOptionalDependencies;
+function isOptionalDependency(name, path, state) {
+  var _state$asyncRequireMo;
+
+  const allowOptionalDependencies = state.allowOptionalDependencies; // The async require module is a 'built-in'. Resolving should never fail -> treat it as non-optional.
+
+  if (
+    name ===
+    ((_state$asyncRequireMo = state.asyncRequireModulePathStringLiteral) ===
+      null || _state$asyncRequireMo === void 0
+      ? void 0
+      : _state$asyncRequireMo.value)
+  ) {
+    return false;
+  }
 
   const isExcluded = () =>
     Array.isArray(allowOptionalDependencies.exclude) &&
@@ -473,7 +411,11 @@ const isOptionalDependency = (name, path, state) => {
       if (p.node.type === "BlockStatement") {
         // A single-level should have the tryStatement immediately followed BlockStatement
         // with the key 'block' to distinguish from the finally block, which has key = 'finalizer'
-        return p.parentPath.node.type === "TryStatement" && p.key === "block";
+        return (
+          p.parentPath != null &&
+          p.parentPath.node.type === "TryStatement" &&
+          p.key === "block"
+        );
       }
 
       sCount += 1;
@@ -483,17 +425,18 @@ const isOptionalDependency = (name, path, state) => {
   }
 
   return false;
-};
+}
 
 function getModuleNameFromCallArgs(path) {
   const expectedCount =
     path.node.callee.name === "__conditionallySplitJSResource" ? 2 : 1;
+  const args = path.get("arguments");
 
-  if (path.get("arguments").length !== expectedCount) {
+  if (!Array.isArray(args) || args.length !== expectedCount) {
     throw new InvalidRequireCallError(path);
   }
 
-  const result = path.get("arguments.0").evaluate();
+  const result = args[0].evaluate();
 
   if (result.confident && typeof result.value === "string") {
     return result.value;
@@ -505,8 +448,8 @@ function getModuleNameFromCallArgs(path) {
 collectDependencies.getModuleNameFromCallArgs = getModuleNameFromCallArgs;
 
 class InvalidRequireCallError extends Error {
-  constructor(_ref3) {
-    let node = _ref3.node;
+  constructor(_ref2) {
+    let node = _ref2.node;
     const line = node.loc && node.loc.start && node.loc.start.line;
     super(
       `Invalid call at line ${line || "<unknown>"}: ${generate(node).code}`
@@ -515,4 +458,185 @@ class InvalidRequireCallError extends Error {
 }
 
 collectDependencies.InvalidRequireCallError = InvalidRequireCallError;
+/**
+ * Produces a Babel template that will throw at runtime when the require call
+ * is reached. This makes dynamic require errors catchable by libraries that
+ * want to use them.
+ */
+
+const dynamicRequireErrorTemplate = template.statement(`
+  (function(line) {
+    throw new Error(
+      'Dynamic require defined at line ' + line + '; not supported by Metro',
+    );
+  })(LINE)
+`);
+/**
+ * Produces a Babel template that transforms an "import(...)" call into a
+ * "require(...)" call to the asyncRequire specified.
+ */
+
+const makeAsyncRequireTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME)
+`);
+const makeAsyncPrefetchTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME)
+`);
+const makeJSResourceTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH).resource(MODULE_ID, MODULE_NAME)
+`);
+const DefaultDependencyTransformer = {
+  transformSyncRequire(path, dependency, state) {
+    const moduleIDExpression = createModuleIDExpression(dependency, state);
+    path.node.arguments = state.keepRequireNames
+      ? [moduleIDExpression, types.stringLiteral(dependency.name)]
+      : [moduleIDExpression];
+  },
+
+  transformImportCall(path, dependency, state) {
+    path.replaceWith(
+      makeAsyncRequireTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+          state.asyncRequireModulePathStringLiteral
+        ),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency)
+      })
+    );
+  },
+
+  transformJSResource(path, dependency, state) {
+    path.replaceWith(
+      makeJSResourceTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+          state.asyncRequireModulePathStringLiteral
+        ),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency)
+      })
+    );
+  },
+
+  transformPrefetch(path, dependency, state) {
+    path.replaceWith(
+      makeAsyncPrefetchTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+          state.asyncRequireModulePathStringLiteral
+        ),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency)
+      })
+    );
+  },
+
+  transformIllegalDynamicRequire(path, state) {
+    var _path$node$loc$start$, _path$node$loc;
+
+    path.replaceWith(
+      dynamicRequireErrorTemplate({
+        LINE: types.numericLiteral(
+          (_path$node$loc$start$ =
+            (_path$node$loc = path.node.loc) === null ||
+            _path$node$loc === void 0
+              ? void 0
+              : _path$node$loc.start.line) !== null &&
+            _path$node$loc$start$ !== void 0
+            ? _path$node$loc$start$
+            : 0
+        )
+      })
+    );
+  }
+};
+
+function createModuleIDExpression(dependency, state) {
+  return types.memberExpression(
+    nullthrows(state.dependencyMapIdentifier),
+    types.numericLiteral(dependency.index),
+    true
+  );
+}
+
+function createModuleNameLiteral(dependency) {
+  return types.stringLiteral(dependency.name);
+}
+
+class DefaultModuleDependencyRegistry {
+  constructor() {
+    _defineProperty(this, "_dependencies", new Map());
+  }
+
+  registerDependency(qualifier) {
+    let dependency = this._dependencies.get(qualifier.name);
+
+    if (dependency == null) {
+      const newDependency = {
+        name: qualifier.name,
+        asyncType: qualifier.asyncType,
+        locs: [],
+        index: this._dependencies.size
+      };
+
+      if (qualifier.optional) {
+        newDependency.isOptional = true;
+      }
+
+      dependency = newDependency;
+
+      this._dependencies.set(qualifier.name, dependency);
+    } else {
+      const original = dependency;
+      dependency = collapseDependencies(original, qualifier);
+
+      if (original !== dependency) {
+        this._dependencies.set(qualifier.name, dependency);
+      }
+    }
+
+    return dependency;
+  }
+
+  getDependencies() {
+    return Array.from(this._dependencies.values());
+  }
+}
+
+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 = _objectSpread(
+      _objectSpread({}, 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 = _objectSpread(
+      _objectSpread({}, dependency),
+      {},
+      {
+        asyncType: null
+      }
+    );
+  } // A prefetched dependency was required async in the module. Mark it as async.
+
+  if (collapsed.asyncType === "prefetch" && qualifier.asyncType === "async") {
+    collapsed = _objectSpread(
+      _objectSpread({}, dependency),
+      {},
+      {
+        asyncType: "async"
+      }
+    );
+  }
+
+  return collapsed;
+}
+
 module.exports = collectDependencies;