metro 0.75.0 → 0.76.0

package/src/ModuleGraph/worker/collectDependencies.js

@@ -15,7 +15,6 @@ const generate = require("@babel/generator").default;
 const template = require("@babel/template").default;
 const traverse = require("@babel/traverse").default;
 const types = require("@babel/types");
-const invariant = require("invariant");
 const nullthrows = require("nullthrows");
 const { isImport } = types;
 /**
@@ -28,21 +27,14 @@ const { isImport } = types;
  * The second argument is only provided for debugging purposes.
  */
 function collectDependencies(ast, options) {
-  var _options$dependencyRe, _options$dependencyTr;
   const visited = new WeakSet();
   const state = {
     asyncRequireModulePathStringLiteral: null,
     dependencyCalls: new Set(),
     dependencyRegistry:
-      (_options$dependencyRe = options.dependencyRegistry) !== null &&
-      _options$dependencyRe !== void 0
-        ? _options$dependencyRe
-        : new DefaultModuleDependencyRegistry(),
+      options.dependencyRegistry ?? new DefaultModuleDependencyRegistry(),
     dependencyTransformer:
-      (_options$dependencyTr = options.dependencyTransformer) !== null &&
-      _options$dependencyTr !== void 0
-        ? _options$dependencyTr
-        : DefaultDependencyTransformer,
+      options.dependencyTransformer ?? DefaultDependencyTransformer,
     dependencyMapIdentifier: null,
     dynamicRequires: options.dynamicRequires,
     keepRequireNames: options.keepRequireNames,
@@ -68,26 +60,6 @@ function collectDependencies(ast, options) {
         });
         return;
       }
-      if (name === "__jsResource" && !path.scope.getBinding(name)) {
-        processImportCall(path, state, {
-          asyncType: "async",
-          jsResource: true,
-        });
-        return;
-      }
-      if (
-        name === "__conditionallySplitJSResource" &&
-        !path.scope.getBinding(name)
-      ) {
-        const args = path.get("arguments");
-        invariant(Array.isArray(args), "Expected arguments to be an array");
-        processImportCall(path, state, {
-          asyncType: "async",
-          jsResource: true,
-          splitCondition: args[1],
-        });
-        return;
-      }
 
       // Match `require.context`
       if (
@@ -108,6 +80,24 @@ function collectDependencies(ast, options) {
         visited.add(path.node);
         return;
       }
+
+      // Match `require.resolveWeak`
+      if (
+        callee.type === "MemberExpression" &&
+        // `require`
+        callee.object.type === "Identifier" &&
+        callee.object.name === "require" &&
+        // `resolveWeak`
+        callee.property.type === "Identifier" &&
+        callee.property.name === "resolveWeak" &&
+        !callee.computed &&
+        // Ensure `require` refers to the global and not something else.
+        !path.scope.getBinding("require")
+      ) {
+        processResolveWeakCall(path, state);
+        visited.add(path.node);
+        return;
+      }
       if (
         name != null &&
         state.dependencyCalls.has(name) &&
@@ -163,11 +153,8 @@ function getRequireContextArgs(path) {
     if (result.confident && typeof result.value === "string") {
       directory = result.value;
     } else {
-      var _result$deopt;
       throw new InvalidRequireCallError(
-        (_result$deopt = result.deopt) !== null && _result$deopt !== void 0
-          ? _result$deopt
-          : args[0],
+        result.deopt ?? args[0],
         "First argument of `require.context` should be a string denoting the directory to require."
       );
     }
@@ -180,11 +167,8 @@ function getRequireContextArgs(path) {
     if (result.confident && typeof result.value === "boolean") {
       recursive = result.value;
     } else if (!(result.confident && typeof result.value === "undefined")) {
-      var _result$deopt2;
       throw new InvalidRequireCallError(
-        (_result$deopt2 = result.deopt) !== null && _result$deopt2 !== void 0
-          ? _result$deopt2
-          : args[1],
+        result.deopt ?? args[1],
         "Second argument of `require.context` should be an optional boolean indicating if files should be imported recursively or not."
       );
     }
@@ -221,11 +205,8 @@ function getRequireContextArgs(path) {
     if (result.confident && typeof result.value === "string") {
       mode = getContextMode(args[3], result.value);
     } else if (!(result.confident && typeof result.value === "undefined")) {
-      var _result$deopt3;
       throw new InvalidRequireCallError(
-        (_result$deopt3 = result.deopt) !== null && _result$deopt3 !== void 0
-          ? _result$deopt3
-          : args[3],
+        result.deopt ?? args[3],
         'Fourth argument of `require.context` should be an optional string "mode" denoting how the modules will be resolved.'
       );
     }
@@ -279,6 +260,26 @@ function processRequireContextCall(path, state) {
   path.get("callee").replaceWith(types.identifier("require"));
   transformer.transformSyncRequire(path, dep, state);
 }
+function processResolveWeakCall(path, state) {
+  const name = getModuleNameFromCallArgs(path);
+  if (name == null) {
+    throw new InvalidRequireCallError(path);
+  }
+  const dependency = registerDependency(
+    state,
+    {
+      name,
+      asyncType: "weak",
+      optional: isOptionalDependency(name, path, state),
+    },
+    path
+  );
+  path.replaceWith(
+    makeResolveWeakTemplate({
+      MODULE_ID: createModuleIDExpression(dependency, state),
+    })
+  );
+}
 function collectImports(path, state) {
   if (path.node.source) {
     registerDependency(
@@ -302,15 +303,12 @@ function processImportCall(path, state, options) {
     {
       name,
       asyncType: options.asyncType,
-      splitCondition: options.splitCondition,
       optional: isOptionalDependency(name, path, state),
     },
     path
   );
   const transformer = state.dependencyTransformer;
-  if (options.jsResource) {
-    transformer.transformJSResource(path, dep, state);
-  } else if (options.asyncType === "async") {
+  if (options.asyncType === "async") {
     transformer.transformImportCall(path, dep, state);
   } else {
     transformer.transformPrefetch(path, dep, state);
@@ -338,14 +336,11 @@ function processRequireCall(path, state) {
   transformer.transformSyncRequire(path, dep, state);
 }
 function getNearestLocFromPath(path) {
-  var _current;
   let current = path;
   while (current && !current.node.loc) {
     current = current.parentPath;
   }
-  return (_current = current) === null || _current === void 0
-    ? void 0
-    : _current.node.loc;
+  return current?.node.loc;
 }
 function registerDependency(state, qualifier, path) {
   const dependency = state.dependencyRegistry.registerDependency(qualifier);
@@ -356,17 +351,10 @@ function registerDependency(state, qualifier, path) {
   return dependency;
 }
 function isOptionalDependency(name, path, state) {
-  var _state$asyncRequireMo;
   const { allowOptionalDependencies } = state;
 
   // 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)
-  ) {
+  if (name === state.asyncRequireModulePathStringLiteral?.value) {
     return false;
   }
   const isExcluded = () =>
@@ -397,10 +385,8 @@ function isOptionalDependency(name, path, state) {
   return false;
 }
 function getModuleNameFromCallArgs(path) {
-  const expectedCount =
-    path.node.callee.name === "__conditionallySplitJSResource" ? 2 : 1;
   const args = path.get("arguments");
-  if (!Array.isArray(args) || args.length !== expectedCount) {
+  if (!Array.isArray(args) || args.length !== 1) {
     throw new InvalidRequireCallError(path);
   }
   const result = args[0].evaluate();
@@ -430,7 +416,7 @@ collectDependencies.InvalidRequireCallError = InvalidRequireCallError;
  * is reached. This makes dynamic require errors catchable by libraries that
  * want to use them.
  */
-const dynamicRequireErrorTemplate = template.statement(`
+const dynamicRequireErrorTemplate = template.expression(`
   (function(line) {
     throw new Error(
       'Dynamic require defined at line ' + line + '; not supported by Metro',
@@ -442,14 +428,14 @@ const dynamicRequireErrorTemplate = template.statement(`
  * Produces a Babel template that transforms an "import(...)" call into a
  * "require(...)" call to the asyncRequire specified.
  */
-const makeAsyncRequireTemplate = template.statement(`
+const makeAsyncRequireTemplate = template.expression(`
   require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
 `);
-const makeAsyncPrefetchTemplate = template.statement(`
+const makeAsyncPrefetchTemplate = template.expression(`
   require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
 `);
-const makeJSResourceTemplate = template.statement(`
-  require(ASYNC_REQUIRE_MODULE_PATH).resource(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
+const makeResolveWeakTemplate = template.expression(`
+  MODULE_ID
 `);
 const DefaultDependencyTransformer = {
   transformSyncRequire(path, dependency, state) {
@@ -472,18 +458,6 @@ const DefaultDependencyTransformer = {
       })
     );
   },
-  transformJSResource(path, dependency, state) {
-    path.replaceWith(
-      makeJSResourceTemplate({
-        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
-          state.asyncRequireModulePathStringLiteral
-        ),
-        MODULE_ID: createModuleIDExpression(dependency, state),
-        MODULE_NAME: createModuleNameLiteral(dependency),
-        DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
-      })
-    );
-  },
   transformPrefetch(path, dependency, state) {
     path.replaceWith(
       makeAsyncPrefetchTemplate({
@@ -497,19 +471,9 @@ const DefaultDependencyTransformer = {
     );
   },
   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
-        ),
+        LINE: types.numericLiteral(path.node.loc?.start.line ?? 0),
       })
     );
   },