esm: use import attributes instead of import assertions · nodejs/node@a193be3

parserOptions: {

babelOptions: {

plugins: [

[

Module._findPath('@babel/plugin-syntax-import-attributes'),

{ deprecatedAssertSyntax: true },

],

Module._findPath('@babel/plugin-syntax-import-attributes'),

],

},

requireConfigFile: false,

<!-- YAML

added: v8.5.0

changes:

- version: REPLACEME

pr-url: https://github.com/nodejs/node/pull/50140

description: Add experimental support for import attributes.

- version: v18.19.0

pr-url: https://github.com/nodejs/node/pull/44710

description: Module customization hooks are executed off the main thread.

```js

import 'data:text/javascript,console.log("hello!");';

import _ from 'data:application/json,"world!"' assert { type: 'json' };

import _ from 'data:application/json,"world!"' with { type: 'json' };

```

`data:` URLs only resolve [bare specifiers][Terminology] for builtin modules

- v17.1.0

- v16.14.0

changes:

- version: v18.19.0

- version: REPLACEME

pr-url: https://github.com/nodejs/node/pull/50140

description: Switch from Import Assertions to Import Attributes.

-->

> Stability: 1.1 - Active development

> This feature was previously named "Import assertions", and using the `assert`

> keyword instead of `with`. Because the version of V8 on this release line does

> not support the `with` keyword, you need to keep using `assert` to support

> this version of Node.js.

> keyword instead of `with`. Any uses in code of the prior `assert` keyword

> should be updated to use `with` instead.

The [Import Attributes proposal][] adds an inline syntax for module import

statements to pass on more information alongside the module specifier.

```js

import fooData from './foo.json' assert { type: 'json' };

import fooData from './foo.json' with { type: 'json' };

const { default: barData } =

await import('./bar.json', { assert: { type: 'json' } });

await import('./bar.json', { with: { type: 'json' } });

```

Node.js supports the following `type` values, for which the attribute is

JSON files can be referenced by `import`:

```js

import packageConfig from './package.json' assert { type: 'json' };

import packageConfig from './package.json' with { type: 'json' };

```

The `assert { type: 'json' }` syntax is mandatory; see [Import Attributes][].

The `with { type: 'json' }` syntax is mandatory; see [Import Attributes][].

The imported JSON only exposes a `default` export. There is no support for named

exports. A cache entry is created in the CommonJS cache to avoid duplication.

"--no-harmony-import-assertions") == v8_args.end()) {

v8_args.emplace_back("--harmony-import-assertions");

}

// TODO(aduh95): remove this when the harmony-import-attributes flag

// is removed in V8.

if (std::find(v8_args.begin(),

v8_args.end(),

"--no-harmony-import-attributes") == v8_args.end()) {

v8_args.emplace_back("--harmony-import-attributes");

}

auto env_opts = per_process::cli_options->per_isolate->per_env;

if (std::find(v8_args.begin(), v8_args.end(),

import('../fixtures/experimental.json'),

import(

'../fixtures/experimental.json',

{ assert: { type: 'json' } }

{ with: { type: 'json' } }

),

]);

import('../fixtures/experimental.json?test'),

import(

'../fixtures/experimental.json?test',

{ assert: { type: 'json' } }

{ with: { type: 'json' } }

),

]);

import('../fixtures/experimental.json#test'),

import(

'../fixtures/experimental.json#test',

{ assert: { type: 'json' } }

{ with: { type: 'json' } }

),

]);

import('../fixtures/experimental.json?test2#test'),

import(

'../fixtures/experimental.json?test2#test',

{ assert: { type: 'json' } }

{ with: { type: 'json' } }

),

]);

import('data:application/json,{"ofLife":42}'),

import(

'data:application/json,{"ofLife":42}',

{ assert: { type: 'json' } }

{ with: { type: 'json' } }

),

]);

}

{

const ns = await import('data:application/json;foo="test,"this"',

{ assert: { type: 'json' } });

{ with: { type: 'json' } });

assert.deepStrictEqual(Object.keys(ns), ['default']);

assert.strictEqual(ns.default, 'this');

}

{

const ns = await import(`data:application/json;foo=${

encodeURIComponent('test,')

},0`, { assert: { type: 'json' } });

},0`, { with: { type: 'json' } });

assert.deepStrictEqual(Object.keys(ns), ['default']);

assert.strictEqual(ns.default, 0);

}

{

await assert.rejects(async () =>

import('data:application/json;foo="test,",0',

{ assert: { type: 'json' } }), {

{ with: { type: 'json' } }), {

name: 'SyntaxError',

message: /Unexpected end of JSON input/

});

}

{

const body = '{"x": 1}';

const plainESMURL = createURL('application/json', body);

const ns = await import(plainESMURL, { assert: { type: 'json' } });

const ns = await import(plainESMURL, { with: { type: 'json' } });

assert.deepStrictEqual(Object.keys(ns), ['default']);

assert.strictEqual(ns.default.x, 1);

}

{

const body = '{"default": 2}';

const plainESMURL = createURL('application/json', body);

const ns = await import(plainESMURL, { assert: { type: 'json' } });

const ns = await import(plainESMURL, { with: { type: 'json' } });

assert.deepStrictEqual(Object.keys(ns), ['default']);

assert.strictEqual(ns.default.default, 2);

}

async function test() {

{

const results = await Promise.allSettled([

import('../fixtures/empty.js', { assert: { type: 'json' } }),

import('../fixtures/empty.js', { with: { type: 'json' } }),

import('../fixtures/empty.js'),

]);

{

const results = await Promise.allSettled([

import('../fixtures/empty.js'),

import('../fixtures/empty.js', { assert: { type: 'json' } }),

import('../fixtures/empty.js', { with: { type: 'json' } }),

]);

strictEqual(results[0].status, 'fulfilled');

{

const results = await Promise.allSettled([

import('../fixtures/empty.json', { assert: { type: 'json' } }),

import('../fixtures/empty.json', { with: { type: 'json' } }),

import('../fixtures/empty.json'),

]);

{

const results = await Promise.allSettled([

import('../fixtures/empty.json'),

import('../fixtures/empty.json', { assert: { type: 'json' } }),

import('../fixtures/empty.json', { with: { type: 'json' } }),

]);

strictEqual(results[0].status, 'rejected');

{

const results = await Promise.allSettled([

import('../fixtures/empty.js', { assert: { type: 'json' } }),

import('../fixtures/empty.js', { with: { type: 'json' } }),

import('../fixtures/empty.js'),

]);

{

const results = await Promise.allSettled([

import('../fixtures/empty.js'),

import('../fixtures/empty.js', { assert: { type: 'json' } }),

import('../fixtures/empty.js', { with: { type: 'json' } }),

]);

strictEqual(results[0].status, 'fulfilled');

{

const results = await Promise.allSettled([

import('../fixtures/empty.json', { assert: { type: 'json' } }),

import('../fixtures/empty.json', { with: { type: 'json' } }),

import('../fixtures/empty.json'),

]);

{

const results = await Promise.allSettled([

import('../fixtures/empty.json'),

import('../fixtures/empty.json', { assert: { type: 'json' } }),

import('../fixtures/empty.json', { with: { type: 'json' } }),

]);

strictEqual(results[0].status, 'rejected');

import '../common/index.mjs';

import { strictEqual } from 'assert';

import secret from '../fixtures/experimental.json' assert { type: 'json' };

import secret from '../fixtures/experimental.json' with { type: 'json' };

strictEqual(secret.ofLife, 42);

import '../common/index.mjs';

import { strictEqual } from 'assert';

import secret0 from '../fixtures/experimental.json' assert { type: 'json' };

import secret0 from '../fixtures/experimental.json' with { type: 'json' };

const secret1 = await import('../fixtures/experimental.json', {

assert: { type: 'json' },

with: { type: 'json' },

});

strictEqual(secret0.ofLife, 42);

import '../common/index.mjs';

import { strictEqual } from 'assert';

import secret0 from '../fixtures/experimental.json' assert { type: 'json' };

import secret0 from '../fixtures/experimental.json' with { type: 'json' };

const secret1 = await import('../fixtures/experimental.json',

{ assert: { type: 'json' } });

{ with: { type: 'json' } });

strictEqual(secret0.ofLife, 42);

strictEqual(secret1.default.ofLife, 42);