esm: Implement esm mode flag

.eslintrc.js

@@ -36,7 +36,8 @@ module.exports = {
  files: [
  'doc/api/esm.md',
  '*.mjs',
- 'test/es-module/test-esm-example-loader.js',
+ 'test/es-module/esm-dep.js',
+ 'test/es-module/test-esm-example-loader.js'
  ],
  parserOptions: { sourceType: 'module' },
  },

lib/internal/modules/esm/default_resolve.js

@@ -19,13 +19,13 @@ const { pathToFileURL, fileURLToPath } = require('internal/url');
 
 const realpathCache = new Map();
 
-function search(target, base) {
+function search(target, base, checkPjsonMode) {
  if (base === undefined) {
  // We cannot search without a base.
  throw new ERR_MISSING_MODULE(target);
  }
  try {
- return moduleWrapResolve(target, base);
+ return moduleWrapResolve(target, base, checkPjsonMode);
  } catch (e) {
  e.stack; // cause V8 to generate stack before rethrow
  let error = e;
@@ -43,14 +43,22 @@ function search(target, base) {
  }
 }
 
-const extensionFormatMap = {
+const extensionFormatCjs = {
  '__proto__': null,
  '.mjs': 'esm',
  '.json': 'json',
  '.node': 'addon',
  '.js': 'cjs'
 };
 
+const extensionFormatEsm = {
+ '__proto__': null,
+ '.mjs': 'esm',
+ '.json': 'json',
+ '.node': 'addon',
+ '.js': 'esm'
+};
+
 function resolve(specifier, parentURL) {
  if (NativeModule.nonInternalExists(specifier)) {
  return {
@@ -59,10 +67,14 @@ function resolve(specifier, parentURL) {
  };
  }
 
- let url;
+ let url, esm;
  try {
- url = search(specifier,
- parentURL || pathToFileURL(`${process.cwd()}/`).href);
+ // "esm" indicates if the package boundary is "mode": "esm"
+ // where this is only checked for ambiguous extensions
+ ({ url, esm } =
+ search(specifier,
+ parentURL || pathToFileURL(`${process.cwd()}/`).href,
+ false));
  } catch (e) {
  if (typeof e.message === 'string' &&
  StringStartsWith(e.message, 'Cannot find module'))
@@ -84,9 +96,9 @@ function resolve(specifier, parentURL) {
 
  const ext = extname(url.pathname);
 
- let format = extensionFormatMap[ext];
+ let format = (esm ? extensionFormatEsm : extensionFormatCjs)[ext];
  if (!format) {
- if (isMain)
+ if (!esm && isMain)
  format = 'cjs';
  else
  throw new ERR_UNKNOWN_FILE_EXTENSION(url.pathname);

src/env.h

@@ -70,11 +70,13 @@ struct PackageConfig {
  enum class Exists { Yes, No };
  enum class IsValid { Yes, No };
  enum class HasMain { Yes, No };
+ enum class PackageMode { NONE, CJS, ESM };
 
- Exists exists;
- IsValid is_valid;
- HasMain has_main;
- std::string main;
+ const Exists exists;
+ const IsValid is_valid;
+ const HasMain has_main;
+ const std::string main;
+ const PackageMode mode;
 };
 } // namespace loader
 
@@ -161,6 +163,8 @@ struct PackageConfig {
  V(env_var_settings_string, "envVarSettings") \
  V(errno_string, "errno") \
  V(error_string, "error") \
+ V(esm_string, "esm") \
+ V(exiting_string, "_exiting") \
  V(exit_code_string, "exitCode") \
  V(expire_string, "expire") \
  V(exponent_string, "exponent") \
@@ -202,6 +206,7 @@ struct PackageConfig {
  V(message_port_string, "messagePort") \
  V(message_port_constructor_string, "MessagePort") \
  V(minttl_string, "minttl") \
+ V(mode_string, "mode") \
  V(modulus_string, "modulus") \
  V(name_string, "name") \
  V(netmask_string, "netmask") \

src/module_wrap.cc

@@ -492,6 +492,7 @@ Maybe<uv_file> CheckFile(const std::string& path,
 using Exists = PackageConfig::Exists;
 using IsValid = PackageConfig::IsValid;
 using HasMain = PackageConfig::HasMain;
+using PackageMode = PackageConfig::PackageMode;
 
 const PackageConfig& GetPackageConfig(Environment* env,
  const std::string& path) {
@@ -502,7 +503,8 @@ const PackageConfig& GetPackageConfig(Environment* env,
  Maybe<uv_file> check = CheckFile(path, LEAVE_OPEN_AFTER_CHECK);
  if (check.IsNothing()) {
  auto entry = env->package_json_cache.emplace(path,
- PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "" });
+ PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "",
+ PackageMode::NONE });
  return entry.first->second;
  }
 
@@ -520,7 +522,8 @@ const PackageConfig& GetPackageConfig(Environment* env,
  v8::NewStringType::kNormal,
  pkg_src.length()).ToLocal(&src)) {
  auto entry = env->package_json_cache.emplace(path,
- PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "" });
+ PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "",
+ PackageMode::NONE });
  return entry.first->second;
  }
 
@@ -530,7 +533,8 @@ const PackageConfig& GetPackageConfig(Environment* env,
  if (!JSON::Parse(env->context(), src).ToLocal(&pkg_json_v) ||
  !pkg_json_v->ToObject(env->context()).ToLocal(&pkg_json)) {
  auto entry = env->package_json_cache.emplace(path,
- PackageConfig { Exists::Yes, IsValid::No, HasMain::No, "" });
+ PackageConfig { Exists::Yes, IsValid::No, HasMain::No, "",
+ PackageMode::NONE });
  return entry.first->second;
  }
 
@@ -543,11 +547,49 @@ const PackageConfig& GetPackageConfig(Environment* env,
  main_std.assign(std::string(*main_utf8, main_utf8.length()));
  }
 
+ Local<Value> pkg_mode_v;
+ PackageMode pkg_mode = PackageMode::CJS;
+ if (pkg_json->Get(env->context(), env->mode_string()).ToLocal(&pkg_mode_v) &&
+ pkg_mode_v->StrictEquals(env->esm_string())) {
+ pkg_mode = PackageMode::ESM;
+ }
+
  auto entry = env->package_json_cache.emplace(path,
- PackageConfig { Exists::Yes, IsValid::Yes, has_main, main_std });
+ PackageConfig { Exists::Yes, IsValid::Yes, has_main,
+ main_std, pkg_mode });
  return entry.first->second;
 }
 
+PackageMode GetPackageMode(Environment* env, const URL& search) {
+ URL pjson_path("package.json", &search);
+ while (true) {
+ const PackageConfig& pkg_json =
+ GetPackageConfig(env, pjson_path.ToFilePath());
+ if (pkg_json.exists == Exists::Yes) {
+ return pkg_json.mode;
+ }
+ URL last_pjson_path = pjson_path;
+ pjson_path = URL("../package.json", pjson_path);
+ // Terminates at root where ../package.json equals ../../package.json
+ // (can't just check "/package.json" for Windows support).
+ if (pjson_path.path().length() == last_pjson_path.path().length()) {
+ return PackageMode::CJS;
+ }
+ }
+}
+
+void SetPackageMode(Environment* env, const URL& search,
+ PackageMode pkg_mode) {
+ std::string pjson_path_str = URL("package.json", &search).ToFilePath();
+ const PackageConfig& pkg_json = GetPackageConfig(env, pjson_path_str);
+ if (pkg_json.mode != pkg_mode) {
+ env->package_json_cache.erase(env->package_json_cache.find(pjson_path_str));
+ env->package_json_cache.emplace(pjson_path_str,
+ PackageConfig { pkg_json.exists, pkg_json.is_valid,
+ pkg_json.has_main, pkg_json.main, pkg_mode });
+ }
+}
+
 enum ResolveExtensionsOptions {
  TRY_EXACT_NAME,
  ONLY_VIA_EXTENSIONS
@@ -556,8 +598,8 @@ enum ResolveExtensionsOptions {
 template <ResolveExtensionsOptions options>
 Maybe<URL> ResolveExtensions(const URL& search) {
  if (options == TRY_EXACT_NAME) {
- std::string filePath = search.ToFilePath();
- Maybe<uv_file> check = CheckFile(filePath);
+ std::string file_path = search.ToFilePath();
+ Maybe<uv_file> check = CheckFile(file_path);
  if (!check.IsNothing()) {
  return Just(search);
  }
@@ -670,8 +712,8 @@ Maybe<URL> Resolve(Environment* env,
 void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
 
- // module.resolve(specifier, url)
- CHECK_EQ(args.Length(), 2);
+ // module.resolve(specifier, url, setPackageEsmMode)
+ CHECK_EQ(args.Length(), 3);
 
  CHECK(args[0]->IsString());
  Utf8Value specifier_utf8(env->isolate(), args[0]);
@@ -686,13 +728,50 @@ void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
  env, "second argument is not a URL string");
  }
 
+ if (!args[2]->IsBoolean()) {
+ env->ThrowError("third argument is not a boolean");
+ return;
+ }
+
  Maybe<URL> result = node::loader::Resolve(env, specifier_std, url);
  if (result.IsNothing() || (result.FromJust().flags() & URL_FLAGS_FAILED)) {
  std::string msg = "Cannot find module " + specifier_std;
  return node::THROW_ERR_MISSING_MODULE(env, msg.c_str());
  }
 
- args.GetReturnValue().Set(result.FromJust().ToObject(env));
+ bool esm_package = false;
+ bool set_package_esm_mode = args[2]->IsTrue();
+ if (set_package_esm_mode) {
+ esm_package = true;
+ SetPackageMode(env, result.FromJust(), PackageMode::ESM);
+ } else {
+ // Check the package esm mode for ambiguous extensions.
+ std::string file_path = result.FromJust().ToFilePath();
+ std::string ext;
+ const size_t pos = file_path.rfind('.');
+ if (pos != 0 && pos != std::string::npos) ext = file_path.substr(pos);
+ if (ext != ".mjs" && ext != ".json" && ext != ".node") {
+ if (GetPackageMode(env, result.FromJust()) == PackageMode::ESM) {
+ esm_package = true;
+ }
+ }
+ }
+
+ Local<Object> resolved = Object::New(env->isolate());
+
+ resolved->DefineOwnProperty(
+ env->context(),
+ env->esm_string(),
+ v8::Boolean::New(env->isolate(), esm_package),
+ v8::ReadOnly).FromJust();
+
+ resolved->DefineOwnProperty(
+ env->context(),
+ env->url_string(),
+ result.FromJust().ToObject(env),
+ v8::ReadOnly).FromJust();
+
+ args.GetReturnValue().Set(resolved);
 }
 
 static MaybeLocal<Promise> ImportModuleDynamically(

test/es-module/test-esm-node-modules.mjs

@@ -0,0 +1,6 @@
+// Flags: --experimental-modules
+import '../common';
+import assert from 'assert';
+import { x } from '../fixtures/es-modules/node_lookups/module.mjs';
+
+assert.deepStrictEqual(x, 42);

test/es-module/test-pjson-cjs-esm-nested.mjs

@@ -0,0 +1,6 @@
+// Flags: --experimental-modules
+/* eslint-disable node-core/required-modules */
+import m from '../fixtures/es-modules/esm-cjs-nested/module';
+import assert from 'assert';
+
+assert.strictEqual(m, 'cjs');

test/es-module/test-pjson-esm-mode-invalid.mjs

@@ -0,0 +1,6 @@
+// Flags: --experimental-modules
+/* eslint-disable node-core/required-modules */
+import m from '../fixtures/es-modules/esm-invalid/module';
+import assert from 'assert';
+
+assert.strictEqual(m, 'cjs');

test/es-module/test-pjson-esm-mode-submodule.mjs

@@ -0,0 +1,6 @@
+// Flags: --experimental-modules
+/* eslint-disable node-core/required-modules */
+import m from '../fixtures/es-modules/esm/sub/dir/module';
+import assert from 'assert';
+
+assert.strictEqual(m, 'esm submodule');

test/es-module/test-pjson-esm-mode.mjs

@@ -0,0 +1,6 @@
+// Flags: --experimental-modules
+/* eslint-disable node-core/required-modules */
+import m from '../fixtures/es-modules/esm/module';
+import assert from 'assert';
+
+assert.strictEqual(m, 'esm');

test/fixtures/es-modules/esm-cjs-nested/cjs-nested/module.js

@@ -0,0 +1 @@
+module.exports = 'cjs';

test/fixtures/es-modules/esm-cjs-nested/cjs-nested/package.json

@@ -0,0 +1 @@
+{}

test/fixtures/es-modules/esm-cjs-nested/module.js

@@ -0,0 +1 @@
+export { default } from './cjs-nested/module.js';

test/fixtures/es-modules/esm-cjs-nested/package.json

@@ -0,0 +1,3 @@
+{
+ "mode": "esm"
+}

test/fixtures/es-modules/esm-invalid/module.js

@@ -0,0 +1 @@
+module.exports = 'cjs';

test/fixtures/es-modules/esm-invalid/package.json

@@ -0,0 +1,3 @@
+{
+ "mode": 1
+}

test/fixtures/es-modules/esm/module.js

@@ -0,0 +1 @@
+export default 'esm';

test/fixtures/es-modules/esm/package.json

@@ -0,0 +1,3 @@
+{
+ "mode": "esm"
+}

test/fixtures/es-modules/esm/sub/dir/module.js

@@ -0,0 +1 @@
+export default 'esm submodule';

test/fixtures/es-modules/node_lookups/module.mjs

@@ -0,0 +1 @@
+export { default as x } from 'cjs';