"ignore_case": true,

- add [`enforce-node-protocol-usage`] rule and `import/node-version` setting ([#3024], thanks [@GoldStrikeArch] and [@sevenc-nanashi])

- [Docs] [`extensions`], [`order`]: improve documentation ([#3106], thanks [@Xunnamius])

[`import/node-version` setting]: ./README.md#importnode-version

[`enforce-node-protocol-usage`]: ./docs/rules/enforce-node-protocol-usage.md

[#3024]: https://github.com/import-js/eslint-plugin-import/pull/3024

[@developer-bandi]: https://github.com/developer-bandi

[@GoldStrikeArch]: https://github.com/GoldStrikeArch

[@liuxingbaoyu]: https://github.com/liuxingbaoyu

[@sevenc-nanashi]: https://github.com/sevenc-nanashi

| Name                        | Description | 💼 | ⚠️ | 🚫 | 🔧 | 💡 | ❌ |

| :----------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------- | :--- | :- | :- | :- | :- | :- |

| [default](docs/rules/default.md) | Ensure a default export is present, given a default import. | ❗ ☑️ | | | | | |

| [enforce-node-protocol-usage](docs/rules/enforce-node-protocol-usage.md) | Enforce either using, or omitting, the `node:` protocol when importing Node.js builtin modules. | | | | 🔧 | | |

| [named](docs/rules/named.md) | Ensure named imports correspond to a named export in the remote file. | ❗ ☑️ | | ⌨️ | | | |

| [namespace](docs/rules/namespace.md) | Ensure imported namespaces contain dereferenced properties as they are dereferenced. | ❗ ☑️ | | | | | |

| [no-absolute-path](docs/rules/no-absolute-path.md) | Forbid import of modules using absolute paths. | | | | 🔧 | | |

| [no-cycle](docs/rules/no-cycle.md) | Forbid a module from importing a module with a dependency path back to itself. | | | | | | |

| [no-dynamic-require](docs/rules/no-dynamic-require.md) | Forbid `require()` calls with expressions. | | | | | | |

| [no-internal-modules](docs/rules/no-internal-modules.md) | Forbid importing the submodules of other modules. | | | | | | |

| [no-relative-packages](docs/rules/no-relative-packages.md) | Forbid importing packages through relative paths. | | | | 🔧 | | |

| [no-relative-parent-imports](docs/rules/no-relative-parent-imports.md) | Forbid importing modules from parent directories. | | | | | | |

| [no-restricted-paths](docs/rules/no-restricted-paths.md) | Enforce which files can be imported in a given folder. | | | | | | |

| [no-self-import](docs/rules/no-self-import.md) | Forbid a module from importing itself. | | | | | | |

| [no-unresolved](docs/rules/no-unresolved.md) | Ensure imports point to a file/module that can be resolved. | ❗ ☑️ | | | | | |

| [no-useless-path-segments](docs/rules/no-useless-path-segments.md) | Forbid unnecessary path segments in import and require statements. | | | | 🔧 | | |

| [no-webpack-loader-syntax](docs/rules/no-webpack-loader-syntax.md) | Forbid webpack loader syntax in imports. | | | | | | |

A string that represents the version of Node.js that you are using.

A falsy value will imply the version of Node.js that you are running ESLint with.

{

"settings": {

"import/node-version": "22.3.4",

},

}

🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).

Enforce either using, or omitting, the `node:` protocol when importing Node.js builtin modules.

This rule enforces that builtins node imports are using, or omitting, the `node:` protocol.

Reasons to prefer using the protocol include:

- the code is more explicitly and clearly referencing a Node.js built-in module

Reasons to prefer omitting the protocol include:

- some tools don't support the `node:` protocol

- the code is more portable, because import maps and automatic polyfilling can be used

The rule requires a single string option which may be one of:

- `'always'` - enforces that builtins node imports are using the `node:` protocol.

- `'never'` - enforces that builtins node imports are not using the `node:` protocol.

❌ Invalid

import fs from 'fs';

export { promises } from 'fs';

const fs = require('fs/promises');

✅ Valid

import fs from 'node:fs';

export { promises } from 'node:fs';

import * as test from 'node:test';

const fs = require('node:fs/promises');

❌ Invalid

import fs from 'node:fs';

export { promises } from 'node:fs';

const fs = require('node:fs/promises');

✅ Valid

import fs from 'fs';

export { promises } from 'fs';

import * as test from 'node:test';

const fs = require('fs/promises');

If you don't want to consistently enforce using, or omitting, the `node:` protocol when importing Node.js builtin modules.

'enforce-node-protocol-usage': require('./rules/enforce-node-protocol-usage'),

const isCoreModule = require('is-core-module');

const { default: docsUrl } = require('../docsUrl');

const DO_PREFER_MESSAGE_ID = 'requireNodeProtocol';

const NEVER_PREFER_MESSAGE_ID = 'forbidNodeProtocol';

const messages = {

[DO_PREFER_MESSAGE_ID]: 'Prefer `node:{{moduleName}}` over `{{moduleName}}`.',

[NEVER_PREFER_MESSAGE_ID]: 'Prefer `{{moduleName}}` over `node:{{moduleName}}`.',

function replaceStringLiteral(

fixer,

node,

text,

relativeRangeStart,

relativeRangeEnd,

) {

const firstCharacterIndex = node.range[0] + 1;

const start = Number.isInteger(relativeRangeEnd)

? relativeRangeStart + firstCharacterIndex

: firstCharacterIndex;

const end = Number.isInteger(relativeRangeEnd)

? relativeRangeEnd + firstCharacterIndex

: node.range[1] - 1;

return fixer.replaceTextRange([start, end], text);

function isStringLiteral(node) {

return node.type === 'Literal' && typeof node.value === 'string';

function isStaticRequireWith1Param(node) {

return !node.optional

&& node.callee.type === 'Identifier'

&& node.callee.name === 'require'

// check for only 1 argument

&& node.arguments.length === 1

&& node.arguments[0]

&& isStringLiteral(node.arguments[0]);

function checkAndReport(src, context) {

// TODO use src.quasis[0].value.raw

if (src.type === 'TemplateLiteral') { return; }

const moduleName = 'value' in src ? src.value : src.name;

if (typeof moduleName !== 'string') { console.log(src, moduleName); }

const { settings } = context;

const nodeVersion = settings && settings['node-version'];

if (

typeof nodeVersion !== 'undefined'

&& (

typeof nodeVersion !== 'string'

|| !(/^[0-9]+\.[0-9]+\.[0-9]+$/).test(nodeVersion)

)

) {

throw new TypeError('`import/node-version` setting must be a string in the format "10.23.45" (a semver version, with no leading zero)');

}

if (context.options[0] === 'never') {

if (!moduleName.startsWith('node:')) { return; }

const actualModuleName = moduleName.slice(5);

if (!isCoreModule(actualModuleName, nodeVersion || undefined)) { return; }

context.report({

node: src,

message: messages[NEVER_PREFER_MESSAGE_ID],

data: { moduleName: actualModuleName },

/** @param {import('eslint').Rule.RuleFixer} fixer */

fix(fixer) {

return replaceStringLiteral(fixer, src, '', 0, 5);

},

});

} else if (context.options[0] === 'always') {

if (

moduleName.startsWith('node:')

|| !isCoreModule(moduleName, nodeVersion || undefined)

|| !isCoreModule(`node:${moduleName}`, nodeVersion || undefined)

) {

return;

}

context.report({

node: src,

message: messages[DO_PREFER_MESSAGE_ID],

data: { moduleName },

/** @param {import('eslint').Rule.RuleFixer} fixer */

fix(fixer) {

return replaceStringLiteral(fixer, src, 'node:', 0, 0);

},

});

} else if (typeof context.options[0] === 'undefined') {

throw new Error('Missing option');

} else {

throw new Error(`Unexpected option: ${context.options[0]}`);

}

module.exports = {

meta: {

type: 'suggestion',

docs: {

description: 'Enforce either using, or omitting, the `node:` protocol when importing Node.js builtin modules.',

recommended: true,

category: 'Static analysis',

url: docsUrl('enforce-node-protocol-usage'),

},

fixable: 'code',

schema: {

type: 'array',

minItems: 1,

maxItems: 1,

items: [

{

enum: ['always', 'never'],

},

],

},

messages,

},

create(context) {

return {

CallExpression(node) {

if (!isStaticRequireWith1Param(node)) { return; }

const arg = node.arguments[0];

return checkAndReport(arg, context);

},

ExportNamedDeclaration(node) {

return checkAndReport(node.source, context);

},

ImportDeclaration(node) {

return checkAndReport(node.source, context);

},

ImportExpression(node) {

if (!isStringLiteral(node.source)) { return; }

return checkAndReport(node.source, context);

},

};

},