module: expose exports conditions to loaders

doc/api/esm.md

@@ -1050,11 +1050,22 @@ and parent URL. The module specifier is the string in an `import` statement or
 `import()` expression, and the parent URL is the URL of the module that imported
 this one, or `undefined` if this is the main entry point for the application.
 
+The `conditions` property on the `context` is an array of conditions for
+[Conditional Exports][] that apply to this resolution request. They can be used
+for looking up conditional mappings elsewhere or to modify the list when calling
+the default resolution logic.
+
+The [current set of Node.js default conditions][Conditional Exports] will always
+be in the `context.conditions` list passed to the hook. If the hook wants to
+ensure Node.js-compatible resolution logic, all items from this default
+condition list **must** be passed through to the `defaultResolve` function.
+
 ```js
 /**
  * @param {string} specifier
  * @param {object} context
  * @param {string} context.parentURL
+ * @param {string[]} context.conditions
  * @param {function} defaultResolve
  * @returns {object} response
  * @returns {string} response.url
@@ -1069,6 +1080,14 @@ export async function resolve(specifier, context, defaultResolve) {
         new URL(specifier, parentURL).href : new URL(specifier).href
     };
   }
+  if (anotherCondition) {
+    // When calling the defaultResolve, the arguments can be modified. In this
+    // case it's adding another value for matching conditional exports.
+    return defaultResolve(specifier, {
+      ...context,
+      conditions: [...context.conditions, 'another-condition'],
+    });
+  }
   // Defer to Node.js for all other specifiers.
   return defaultResolve(specifier, context, defaultResolve);
 }

lib/internal/modules/esm/loader.js

@@ -19,7 +19,10 @@ const { validateString } = require('internal/validators');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
 
-const { defaultResolve } = require('internal/modules/esm/resolve');
+const {
+  defaultResolve,
+  DEFAULT_CONDITIONS,
+} = require('internal/modules/esm/resolve');
 const { defaultGetFormat } = require('internal/modules/esm/get_format');
 const { defaultGetSource } = require(
   'internal/modules/esm/get_source');
@@ -92,7 +95,7 @@ class Loader {
       validateString(parentURL, 'parentURL');
 
     const resolveResponse = await this._resolve(
-      specifier, { parentURL }, defaultResolve);
+      specifier, { parentURL, conditions: DEFAULT_CONDITIONS }, defaultResolve);
     if (typeof resolveResponse !== 'object') {
       throw new ERR_INVALID_RETURN_VALUE(
         'object', 'loader resolve', resolveResponse);

lib/internal/modules/esm/resolve.js

@@ -4,9 +4,11 @@ const {
   ArrayIsArray,
   JSONParse,
   JSONStringify,
+  ObjectFreeze,
   ObjectGetOwnPropertyNames,
   ObjectPrototypeHasOwnProperty,
   SafeMap,
+  SafeSet,
   StringPrototypeEndsWith,
   StringPrototypeIncludes,
   StringPrototypeIndexOf,
@@ -35,6 +37,7 @@ const typeFlag = getOptionValue('--input-type');
 const { URL, pathToFileURL, fileURLToPath } = require('internal/url');
 const {
   ERR_INPUT_TYPE_NOT_ALLOWED,
+  ERR_INVALID_ARG_VALUE,
   ERR_INVALID_MODULE_SPECIFIER,
   ERR_INVALID_PACKAGE_CONFIG,
   ERR_INVALID_PACKAGE_TARGET,
@@ -43,6 +46,20 @@ const {
   ERR_UNSUPPORTED_ESM_URL_SCHEME,
 } = require('internal/errors').codes;
 
+const DEFAULT_CONDITIONS = ObjectFreeze(['node', 'import']);
+const DEFAULT_CONDITIONS_SET = new SafeSet(DEFAULT_CONDITIONS);
+
+function getConditionsSet(conditions) {
+  if (conditions !== undefined && conditions !== DEFAULT_CONDITIONS) {
+    if (!ArrayIsArray(conditions)) {
+      throw new ERR_INVALID_ARG_VALUE('conditions', conditions,
+                                      'expected an array');
+    }
+    return new SafeSet(conditions);
+  }
+  return DEFAULT_CONDITIONS_SET;
+}
+
 const realpathCache = new SafeMap();
 const packageJSONCache = new SafeMap();  /* string -> PackageConfig */
 
@@ -310,14 +327,18 @@ function resolveExportsTargetString(
   return subpathResolved;
 }
 
-function isArrayIndex(key /* string */) { /* -> boolean */
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isArrayIndex(key) {
   const keyNum = +key;
   if (`${keyNum}` !== key) return false;
   return keyNum >= 0 && keyNum < 0xFFFF_FFFF;
 }
 
 function resolveExportsTarget(
-  packageJSONUrl, target, subpath, packageSubpath, base) {
+  packageJSONUrl, target, subpath, packageSubpath, base, conditions) {
   if (typeof target === 'string') {
     const resolved = resolveExportsTargetString(
       target, subpath, packageSubpath, packageJSONUrl, base);
@@ -332,7 +353,8 @@ function resolveExportsTarget(
       let resolved;
       try {
         resolved = resolveExportsTarget(
-          packageJSONUrl, targetItem, subpath, packageSubpath, base);
+          packageJSONUrl, targetItem, subpath, packageSubpath, base,
+          conditions);
       } catch (e) {
         lastException = e;
         if (e.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED' ||
@@ -357,11 +379,12 @@ function resolveExportsTarget(
     }
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
-      if (key === 'node' || key === 'import' || key === 'default') {
+      if (key === 'default' || conditions.has(key)) {
         const conditionalTarget = target[key];
         try {
           return resolveExportsTarget(
-            packageJSONUrl, conditionalTarget, subpath, packageSubpath, base);
+            packageJSONUrl, conditionalTarget, subpath, packageSubpath, base,
+            conditions);
         } catch (e) {
           if (e.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') continue;
           throw e;
@@ -397,16 +420,18 @@ function isConditionalExportsMainSugar(exports, packageJSONUrl, base) {
 }
 
 
-function packageMainResolve(packageJSONUrl, packageConfig, base) {
+function packageMainResolve(packageJSONUrl, packageConfig, base, conditions) {
   if (packageConfig.exists) {
     const exports = packageConfig.exports;
     if (exports !== undefined) {
       if (isConditionalExportsMainSugar(exports, packageJSONUrl, base)) {
-        return resolveExportsTarget(packageJSONUrl, exports, '', '', base);
+        return resolveExportsTarget(packageJSONUrl, exports, '', '', base,
+                                    conditions);
       } else if (typeof exports === 'object' && exports !== null) {
         const target = exports['.'];
         if (target !== undefined)
-          return resolveExportsTarget(packageJSONUrl, target, '', '', base);
+          return resolveExportsTarget(packageJSONUrl, target, '', '', base,
+                                      conditions);
       }
 
       throw new ERR_PACKAGE_PATH_NOT_EXPORTED(packageJSONUrl, '.');
@@ -434,9 +459,16 @@ function packageMainResolve(packageJSONUrl, packageConfig, base) {
     fileURLToPath(new URL('.', packageJSONUrl)), fileURLToPath(base));
 }
 
-
+/**
+ * @param {URL} packageJSONUrl
+ * @param {string} packageSubpath
+ * @param {object} packageConfig
+ * @param {string} base
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
 function packageExportsResolve(
-  packageJSONUrl, packageSubpath, packageConfig, base) /* -> URL */ {
+  packageJSONUrl, packageSubpath, packageConfig, base, conditions) {
   const exports = packageConfig.exports;
   if (exports === undefined ||
       isConditionalExportsMainSugar(exports, packageJSONUrl, base)) {
@@ -447,7 +479,7 @@ function packageExportsResolve(
   if (ObjectPrototypeHasOwnProperty(exports, packageSubpath)) {
     const target = exports[packageSubpath];
     const resolved = resolveExportsTarget(
-      packageJSONUrl, target, '', packageSubpath, base);
+      packageJSONUrl, target, '', packageSubpath, base, conditions);
     return finalizeResolution(resolved, base);
   }
 
@@ -466,7 +498,7 @@ function packageExportsResolve(
     const target = exports[bestMatch];
     const subpath = StringPrototypeSubstr(packageSubpath, bestMatch.length);
     const resolved = resolveExportsTarget(
-      packageJSONUrl, target, subpath, packageSubpath, base);
+      packageJSONUrl, target, subpath, packageSubpath, base, conditions);
     return finalizeResolution(resolved, base);
   }
 
@@ -478,7 +510,13 @@ function getPackageType(url) {
   return packageConfig.type;
 }
 
-function packageResolve(specifier /* string */, base /* URL */) { /* -> URL */
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function packageResolve(specifier, base, conditions) {
   let separatorIndex = StringPrototypeIndexOf(specifier, '/');
   let validPackageName = true;
   let isScoped = false;
@@ -530,10 +568,11 @@ function packageResolve(specifier /* string */, base /* URL */) { /* -> URL */
       if (packageSubpath === './') {
         return new URL('./', packageJSONUrl);
       } else if (packageSubpath === '') {
-        return packageMainResolve(packageJSONUrl, packageConfig, base);
+        return packageMainResolve(packageJSONUrl, packageConfig, base,
+                                  conditions);
       } else {
         return packageExportsResolve(
-          packageJSONUrl, packageSubpath, packageConfig, base);
+          packageJSONUrl, packageSubpath, packageConfig, base, conditions);
       }
     }
   }
@@ -559,10 +598,11 @@ function packageResolve(specifier /* string */, base /* URL */) { /* -> URL */
     if (packageSubpath === './') {
       return new URL('./', packageJSONUrl);
     } else if (packageSubpath === '') {
-      return packageMainResolve(packageJSONUrl, packageConfig, base);
+      return packageMainResolve(packageJSONUrl, packageConfig, base,
+                                conditions);
     } else if (packageConfig.exports !== undefined) {
       return packageExportsResolve(
-        packageJSONUrl, packageSubpath, packageConfig, base);
+        packageJSONUrl, packageSubpath, packageConfig, base, conditions);
     } else {
       return finalizeResolution(
         new URL(packageSubpath, packageJSONUrl), base);
@@ -587,7 +627,13 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
   return false;
 }
 
-function moduleResolve(specifier /* string */, base /* URL */) { /* -> URL */
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function moduleResolve(specifier, base, conditions) {
   // Order swapped from spec for minor perf gain.
   // Ok since relative URLs cannot parse as URLs.
   let resolved;
@@ -597,13 +643,14 @@ function moduleResolve(specifier /* string */, base /* URL */) { /* -> URL */
     try {
       resolved = new URL(specifier);
     } catch {
-      return packageResolve(specifier, base);
+      return packageResolve(specifier, base, conditions);
     }
   }
   return finalizeResolution(resolved, base);
 }
 
-function defaultResolve(specifier, { parentURL } = {}, defaultResolveUnused) {
+function defaultResolve(specifier, context = {}, defaultResolveUnused) {
+  let { parentURL, conditions } = context;
   let parsed;
   try {
     parsed = new URL(specifier);
@@ -641,7 +688,8 @@ function defaultResolve(specifier, { parentURL } = {}, defaultResolveUnused) {
       throw new ERR_INPUT_TYPE_NOT_ALLOWED();
   }
 
-  let url = moduleResolve(specifier, new URL(parentURL));
+  conditions = getConditionsSet(conditions);
+  let url = moduleResolve(specifier, parentURL, conditions);
 
   if (isMain ? !preserveSymlinksMain : !preserveSymlinks) {
     const urlPath = fileURLToPath(url);
@@ -658,6 +706,7 @@ function defaultResolve(specifier, { parentURL } = {}, defaultResolveUnused) {
 }
 
 module.exports = {
+  DEFAULT_CONDITIONS,
   defaultResolve,
   getPackageType
 };

test/es-module/test-esm-loader-custom-condition.mjs

@@ -0,0 +1,7 @@
+// Flags: --experimental-loader ./test/fixtures/es-module-loaders/loader-with-custom-condition.mjs
+import '../common/index.mjs';
+import assert from 'assert';
+
+import * as ns from '../fixtures/es-modules/conditional-exports.mjs';
+
+assert.deepStrictEqual({ ...ns }, { default: 'from custom condition' });

test/fixtures/es-module-loaders/loader-with-custom-condition.mjs

@@ -0,0 +1,10 @@
+import {ok, deepStrictEqual} from 'assert';
+
+export async function resolve(specifier, context, defaultResolve) {
+  ok(Array.isArray(context.conditions), 'loader receives conditions array');
+  deepStrictEqual([...context.conditions].sort(), ['import', 'node']);
+  return defaultResolve(specifier, {
+    ...context,
+    conditions: ['custom-condition', ...context.conditions],
+  });
+}

test/fixtures/es-modules/conditional-exports.mjs

@@ -0,0 +1 @@
+export { default } from 'pkgexports/condition';