diff --git a/CHANGELOG.md b/CHANGELOG.md index 88fd1dbc27..89c752b4ed 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,9 @@ This change log adheres to standards from [Keep a CHANGELOG](https://keepachange ## [Unreleased] +### Added +- [`order`]: allow validating named imports ([#3043], thanks [@manuth]) + ### Fixed - `ExportMap` / flat config: include `languageOptions` in context ([#3052], thanks [@michaelfaith]) @@ -1133,6 +1136,7 @@ for info on changes for earlier releases. [`memo-parser`]: ./memo-parser/README.md [#3052]: https://github.com/import-js/eslint-plugin-import/pull/3052 +[#3043]: https://github.com/import-js/eslint-plugin-import/pull/3043 [#3036]: https://github.com/import-js/eslint-plugin-import/pull/3036 [#3033]: https://github.com/import-js/eslint-plugin-import/pull/3033 [#3018]: https://github.com/import-js/eslint-plugin-import/pull/3018 diff --git a/docs/rules/order.md b/docs/rules/order.md index 67849bb7ed..6762799534 100644 --- a/docs/rules/order.md +++ b/docs/rules/order.md @@ -285,6 +285,78 @@ import index from './'; import sibling from './foo'; ``` +### `named: true|false|{ enabled: true|false, import: true|false, export: true|false, require: true|false, cjsExports: true|false, types: mixed|types-first|types-last }` + +Enforce ordering of names within imports and exports: + + - If set to `true`, named imports must be ordered according to the `alphabetize` options + - If set to `false`, named imports can occur in any order + +`enabled` enables the named ordering for all expressions by default. +Use `import`, `export` and `require` and `cjsExports` to override the enablement for the following kind of expressions: + + - `import`: + + ```ts + import { Readline } from "readline"; + ``` + + - `export`: + + ```ts + export { Readline }; + // and + export { Readline } from "readline"; + ``` + + - `require` + + ```ts + const { Readline } = require("readline"); + ``` + + - `cjsExports` + + ```ts + module.exports.Readline = Readline; + // and + module.exports = { Readline }; + ``` + +The `types` option allows you to specify the order of `import`s and `export`s of `type` specifiers. +Following values are possible: + + - `types-first`: forces `type` specifiers to occur first + - `types-last`: forces value specifiers to occur first + - `mixed`: sorts all specifiers in alphabetical order + +The default value is `false`. + +Example setting: + +```ts +{ + named: true, + alphabetize: { + order: 'asc' + } +} +``` + +This will fail the rule check: + +```ts +/* eslint import/order: ["error", {"named": true, "alphabetize": {"order": "asc"}}] */ +import { compose, apply } from 'xcompose'; +``` + +While this will pass: + +```ts +/* eslint import/order: ["error", {"named": true, "alphabetize": {"order": "asc"}}] */ +import { apply, compose } from 'xcompose'; +``` + ### `alphabetize: {order: asc|desc|ignore, orderImportKind: asc|desc|ignore, caseInsensitive: true|false}` Sort the order within each group in alphabetical manner based on **import path**: diff --git a/package.json b/package.json index 5888c28eaa..eda679b819 100644 --- a/package.json +++ b/package.json @@ -126,6 +126,7 @@ "object.groupby": "^1.0.3", "object.values": "^1.2.0", "semver": "^6.3.1", + "string.prototype.trimend": "^1.0.8", "tsconfig-paths": "^3.15.0" } } diff --git a/src/rules/order.js b/src/rules/order.js index 23821830ff..d6f25ddd33 100644 --- a/src/rules/order.js +++ b/src/rules/order.js @@ -3,20 +3,25 @@ import minimatch from 'minimatch'; import includes from 'array-includes'; import groupBy from 'object.groupby'; -import { getSourceCode } from 'eslint-module-utils/contextCompat'; +import { getScope, getSourceCode } from 'eslint-module-utils/contextCompat'; +import trimEnd from 'string.prototype.trimend'; import importType from '../core/importType'; import isStaticRequire from '../core/staticRequire'; import docsUrl from '../docsUrl'; +const categories = { + named: 'named', + import: 'import', + exports: 'exports', +}; + const defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index']; // REPORTING AND FIXING function reverse(array) { - return array.map(function (v) { - return { ...v, rank: -v.rank }; - }).reverse(); + return array.map((v) => ({ ...v, rank: -v.rank })).reverse(); } function getTokensOrCommentsAfter(sourceCode, node, count) { @@ -131,6 +136,26 @@ function findStartOfLineWithComments(sourceCode, node) { return result; } +function findSpecifierStart(sourceCode, node) { + let token; + + do { + token = sourceCode.getTokenBefore(node); + } while (token.value !== ',' && token.value !== '{'); + + return token.range[1]; +} + +function findSpecifierEnd(sourceCode, node) { + let token; + + do { + token = sourceCode.getTokenAfter(node); + } while (token.value !== ',' && token.value !== '}'); + + return token.range[0]; +} + function isRequireExpression(expr) { return expr != null && expr.type === 'CallExpression' @@ -170,6 +195,49 @@ function isPlainImportEquals(node) { return node.type === 'TSImportEqualsDeclaration' && node.moduleReference.expression; } +function isCJSExports(context, node) { + if ( + node.type === 'MemberExpression' + && node.object.type === 'Identifier' + && node.property.type === 'Identifier' + && node.object.name === 'module' + && node.property.name === 'exports' + ) { + return getScope(context, node).variables.findIndex((variable) => variable.name === 'module') === -1; + } + if ( + node.type === 'Identifier' + && node.name === 'exports' + ) { + return getScope(context, node).variables.findIndex((variable) => variable.name === 'exports') === -1; + } +} + +function getNamedCJSExports(context, node) { + if (node.type !== 'MemberExpression') { + return; + } + const result = []; + let root = node; + let parent = null; + while (root.type === 'MemberExpression') { + if (root.property.type !== 'Identifier') { + return; + } + result.unshift(root.property.name); + parent = root; + root = root.object; + } + + if (isCJSExports(context, root)) { + return result; + } + + if (isCJSExports(context, parent)) { + return result.slice(1); + } +} + function canCrossNodeWhileReorder(node) { return isSupportedRequireModule(node) || isPlainImportModule(node) || isPlainImportEquals(node); } @@ -190,6 +258,12 @@ function canReorderItems(firstNode, secondNode) { } function makeImportDescription(node) { + if (node.type === 'export') { + if (node.node.exportKind === 'type') { + return 'type export'; + } + return 'export'; + } if (node.node.importKind === 'type') { return 'type import'; } @@ -199,58 +273,123 @@ function makeImportDescription(node) { return 'import'; } -function fixOutOfOrder(context, firstNode, secondNode, order) { +function fixOutOfOrder(context, firstNode, secondNode, order, category) { + const isNamed = category === categories.named; + const isExports = category === categories.exports; const sourceCode = getSourceCode(context); - const firstRoot = findRootNode(firstNode.node); - const firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot); - const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot); + const { + firstRoot, + secondRoot, + } = isNamed ? { + firstRoot: firstNode.node, + secondRoot: secondNode.node, + } : { + firstRoot: findRootNode(firstNode.node), + secondRoot: findRootNode(secondNode.node), + }; - const secondRoot = findRootNode(secondNode.node); - const secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot); - const secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot); - const canFix = canReorderItems(firstRoot, secondRoot); + const { + firstRootStart, + firstRootEnd, + secondRootStart, + secondRootEnd, + } = isNamed ? { + firstRootStart: findSpecifierStart(sourceCode, firstRoot), + firstRootEnd: findSpecifierEnd(sourceCode, firstRoot), + secondRootStart: findSpecifierStart(sourceCode, secondRoot), + secondRootEnd: findSpecifierEnd(sourceCode, secondRoot), + } : { + firstRootStart: findStartOfLineWithComments(sourceCode, firstRoot), + firstRootEnd: findEndOfLineWithComments(sourceCode, firstRoot), + secondRootStart: findStartOfLineWithComments(sourceCode, secondRoot), + secondRootEnd: findEndOfLineWithComments(sourceCode, secondRoot), + }; - let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd); - if (newCode[newCode.length - 1] !== '\n') { - newCode = `${newCode}\n`; + if (firstNode.displayName === secondNode.displayName) { + if (firstNode.alias) { + firstNode.displayName = `${firstNode.displayName} as ${firstNode.alias}`; + } + if (secondNode.alias) { + secondNode.displayName = `${secondNode.displayName} as ${secondNode.alias}`; + } } const firstImport = `${makeImportDescription(firstNode)} of \`${firstNode.displayName}\``; const secondImport = `\`${secondNode.displayName}\` ${makeImportDescription(secondNode)}`; const message = `${secondImport} should occur ${order} ${firstImport}`; - if (order === 'before') { - context.report({ - node: secondNode.node, - message, - fix: canFix && ((fixer) => fixer.replaceTextRange( - [firstRootStart, secondRootEnd], - newCode + sourceCode.text.substring(firstRootStart, secondRootStart), - )), - }); - } else if (order === 'after') { - context.report({ - node: secondNode.node, - message, - fix: canFix && ((fixer) => fixer.replaceTextRange( - [secondRootStart, firstRootEnd], - sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode, - )), - }); + if (isNamed) { + const firstCode = sourceCode.text.slice(firstRootStart, firstRoot.range[1]); + const firstTrivia = sourceCode.text.slice(firstRoot.range[1], firstRootEnd); + const secondCode = sourceCode.text.slice(secondRootStart, secondRoot.range[1]); + const secondTrivia = sourceCode.text.slice(secondRoot.range[1], secondRootEnd); + + if (order === 'before') { + const trimmedTrivia = trimEnd(secondTrivia); + const gapCode = sourceCode.text.slice(firstRootEnd, secondRootStart - 1); + const whitespaces = secondTrivia.slice(trimmedTrivia.length); + context.report({ + node: secondNode.node, + message, + fix: (fixer) => fixer.replaceTextRange( + [firstRootStart, secondRootEnd], + `${secondCode},${trimmedTrivia}${firstCode}${firstTrivia}${gapCode}${whitespaces}`, + ), + }); + } else if (order === 'after') { + const trimmedTrivia = trimEnd(firstTrivia); + const gapCode = sourceCode.text.slice(secondRootEnd + 1, firstRootStart); + const whitespaces = firstTrivia.slice(trimmedTrivia.length); + context.report({ + node: secondNode.node, + message, + fix: (fixes) => fixes.replaceTextRange( + [secondRootStart, firstRootEnd], + `${gapCode}${firstCode},${trimmedTrivia}${secondCode}${whitespaces}`, + ), + }); + } + } else { + const canFix = isExports || canReorderItems(firstRoot, secondRoot); + let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd); + + if (newCode[newCode.length - 1] !== '\n') { + newCode = `${newCode}\n`; + } + + if (order === 'before') { + context.report({ + node: secondNode.node, + message, + fix: canFix && ((fixer) => fixer.replaceTextRange( + [firstRootStart, secondRootEnd], + newCode + sourceCode.text.substring(firstRootStart, secondRootStart), + )), + }); + } else if (order === 'after') { + context.report({ + node: secondNode.node, + message, + fix: canFix && ((fixer) => fixer.replaceTextRange( + [secondRootStart, firstRootEnd], + sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode, + )), + }); + } } } -function reportOutOfOrder(context, imported, outOfOrder, order) { +function reportOutOfOrder(context, imported, outOfOrder, order, category) { outOfOrder.forEach(function (imp) { const found = imported.find(function hasHigherRank(importedItem) { return importedItem.rank > imp.rank; }); - fixOutOfOrder(context, found, imp, order); + fixOutOfOrder(context, found, imp, order, category); }); } -function makeOutOfOrderReport(context, imported) { +function makeOutOfOrderReport(context, imported, category) { const outOfOrder = findOutOfOrder(imported); if (!outOfOrder.length) { return; @@ -260,10 +399,10 @@ function makeOutOfOrderReport(context, imported) { const reversedImported = reverse(imported); const reversedOrder = findOutOfOrder(reversedImported); if (reversedOrder.length < outOfOrder.length) { - reportOutOfOrder(context, reversedImported, reversedOrder, 'after'); + reportOutOfOrder(context, reversedImported, reversedOrder, 'after', category); return; } - reportOutOfOrder(context, imported, outOfOrder, 'before'); + reportOutOfOrder(context, imported, outOfOrder, 'before', category); } const compareString = (a, b) => { @@ -642,6 +781,30 @@ module.exports = { 'never', ], }, + named: { + default: false, + oneOf: [{ + type: 'boolean', + }, { + type: 'object', + properties: { + enabled: { type: 'boolean' }, + import: { type: 'boolean' }, + export: { type: 'boolean' }, + require: { type: 'boolean' }, + cjsExports: { type: 'boolean' }, + types: { + type: 'string', + enum: [ + 'mixed', + 'types-first', + 'types-last', + ], + }, + }, + additionalProperties: false, + }], + }, alphabetize: { type: 'object', properties: { @@ -670,10 +833,28 @@ module.exports = { ], }, - create: function importOrderRule(context) { + create(context) { const options = context.options[0] || {}; const newlinesBetweenImports = options['newlines-between'] || 'ignore'; const pathGroupsExcludedImportTypes = new Set(options.pathGroupsExcludedImportTypes || ['builtin', 'external', 'object']); + + const named = { + types: 'mixed', + ...typeof options.named === 'object' ? { + ...options.named, + import: 'import' in options.named ? options.named.import : options.named.enabled, + export: 'export' in options.named ? options.named.export : options.named.enabled, + require: 'require' in options.named ? options.named.require : options.named.enabled, + cjsExports: 'cjsExports' in options.named ? options.named.cjsExports : options.named.enabled, + } : { + import: options.named, + export: options.named, + require: options.named, + cjsExports: options.named, + }, + }; + + const namedGroups = named.types === 'mixed' ? [] : named.types === 'types-last' ? ['value'] : ['type']; const alphabetize = getAlphabetizeConfig(options); const distinctGroup = options.distinctGroup == null ? defaultDistinctGroup : !!options.distinctGroup; let ranks; @@ -696,6 +877,7 @@ module.exports = { }; } const importMap = new Map(); + const exportMap = new Map(); function getBlockImports(node) { if (!importMap.has(node)) { @@ -704,8 +886,38 @@ module.exports = { return importMap.get(node); } + function getBlockExports(node) { + if (!exportMap.has(node)) { + exportMap.set(node, []); + } + return exportMap.get(node); + } + + function makeNamedOrderReport(context, namedImports) { + if (namedImports.length > 1) { + const imports = namedImports.map( + (namedImport) => { + const kind = namedImport.kind || 'value'; + const rank = namedGroups.findIndex((entry) => [].concat(entry).indexOf(kind) > -1); + + return { + displayName: namedImport.value, + rank: rank === -1 ? namedGroups.length : rank, + ...namedImport, + value: `${namedImport.value}:${namedImport.alias || ''}`, + }; + }); + + if (alphabetize.order !== 'ignore') { + mutateRanksToAlphabetize(imports, alphabetize); + } + + makeOutOfOrderReport(context, imports, categories.named); + } + } + return { - ImportDeclaration: function handleImports(node) { + ImportDeclaration(node) { // Ignoring unassigned imports unless warnOnUnassignedImports is set if (node.specifiers.length || options.warnOnUnassignedImports) { const name = node.source.value; @@ -721,9 +933,27 @@ module.exports = { getBlockImports(node.parent), pathGroupsExcludedImportTypes, ); + + if (named.import) { + makeNamedOrderReport( + context, + node.specifiers.filter( + (specifier) => specifier.type === 'ImportSpecifier').map( + (specifier) => ({ + node: specifier, + value: specifier.imported.name, + type: 'import', + kind: specifier.importKind, + ...specifier.local.range[0] !== specifier.imported.range[0] && { + alias: specifier.local.name, + }, + }), + ), + ); + } } }, - TSImportEqualsDeclaration: function handleImports(node) { + TSImportEqualsDeclaration(node) { // skip "export import"s if (node.isExport) { return; @@ -755,7 +985,7 @@ module.exports = { pathGroupsExcludedImportTypes, ); }, - CallExpression: function handleRequires(node) { + CallExpression(node) { if (!isStaticRequire(node)) { return; } @@ -777,7 +1007,90 @@ module.exports = { pathGroupsExcludedImportTypes, ); }, - 'Program:exit': function reportAndReset() { + ...named.require && { + VariableDeclarator(node) { + if (node.id.type === 'ObjectPattern' && isRequireExpression(node.init)) { + for (let i = 0; i < node.id.properties.length; i++) { + if ( + node.id.properties[i].key.type !== 'Identifier' + || node.id.properties[i].value.type !== 'Identifier' + ) { + return; + } + } + makeNamedOrderReport( + context, + node.id.properties.map((prop) => ({ + node: prop, + value: prop.key.name, + type: 'require', + ...prop.key.range[0] !== prop.value.range[0] && { + alias: prop.value.name, + }, + })), + ); + } + }, + }, + ...named.export && { + ExportNamedDeclaration(node) { + makeNamedOrderReport( + context, + node.specifiers.map((specifier) => ({ + node: specifier, + value: specifier.local.name, + type: 'export', + kind: specifier.exportKind, + ...specifier.local.range[0] !== specifier.exported.range[0] && { + alias: specifier.exported.name, + }, + })), + ); + }, + }, + ...named.cjsExports && { + AssignmentExpression(node) { + if (node.parent.type === 'ExpressionStatement') { + if (isCJSExports(context, node.left)) { + if (node.right.type === 'ObjectExpression') { + for (let i = 0; i < node.right.properties.length; i++) { + if ( + node.right.properties[i].key.type !== 'Identifier' + || node.right.properties[i].value.type !== 'Identifier' + ) { + return; + } + } + + makeNamedOrderReport( + context, + node.right.properties.map((prop) => ({ + node: prop, + value: prop.key.name, + type: 'export', + ...prop.key.range[0] !== prop.value.range[0] && { + alias: prop.value.name, + }, + })), + ); + } + } else { + const nameParts = getNamedCJSExports(context, node.left); + if (nameParts && nameParts.length > 0) { + const name = nameParts.join('.'); + getBlockExports(node.parent.parent).push({ + node, + value: name, + displayName: name, + type: 'export', + rank: 0, + }); + } + } + } + }, + }, + 'Program:exit'() { importMap.forEach((imported) => { if (newlinesBetweenImports !== 'ignore') { makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup); @@ -787,10 +1100,18 @@ module.exports = { mutateRanksToAlphabetize(imported, alphabetize); } - makeOutOfOrderReport(context, imported); + makeOutOfOrderReport(context, imported, categories.import); + }); + + exportMap.forEach((exported) => { + if (alphabetize.order !== 'ignore') { + mutateRanksToAlphabetize(exported, alphabetize); + makeOutOfOrderReport(context, exported, categories.exports); + } }); importMap.clear(); + exportMap.clear(); }, }; }, diff --git a/tests/src/rules/order.js b/tests/src/rules/order.js index c2d659f839..978c8e34d0 100644 --- a/tests/src/rules/order.js +++ b/tests/src/rules/order.js @@ -1133,6 +1133,140 @@ ruleTester.run('order', rule, { }, ], }), + // named import order + test({ + code: ` + import { a, B as C, Z } from './Z'; + const { D, n: c, Y } = require('./Z'); + export { C, D }; + export { A, B, C as default } from "./Z"; + + const { ["ignore require-statements with non-identifier imports"]: z, d } = require("./Z"); + exports = { ["ignore exports statements with non-identifiers"]: Z, D }; + `, + options: [{ + named: true, + alphabetize: { order: 'asc', caseInsensitive: true }, + }], + }), + test({ + code: ` + const { b, A } = require('./Z'); + `, + options: [{ + named: true, + alphabetize: { order: 'desc' }, + }], + }), + test({ + code: ` + import { A, B } from "./Z"; + export { Z, A } from "./Z"; + export { N, P } from "./Z"; + const { X, Y } = require("./Z"); + `, + options: [{ + named: { + require: true, + import: true, + export: false, + }, + }], + }), + test({ + code: ` + import { B, A } from "./Z"; + const { D, C } = require("./Z"); + export { B, A } from "./Z"; + `, + options: [{ + named: { + require: false, + import: false, + export: false, + }, + }], + }), + test({ + code: ` + import { B, A, R } from "foo"; + const { D, O, G } = require("tunes"); + export { B, A, Z } from "foo"; + `, + options: [{ + named: { enabled: false }, + }], + }), + test({ + code: ` + import { A as A, A as B, A as C } from "./Z"; + const { a, a: b, a: c } = require("./Z"); + `, + options: [{ + named: true, + }], + }), + test({ + code: ` + import { A, B, C } from "./Z"; + exports = { A, B, C }; + module.exports = { a: A, b: B, c: C }; + `, + options: [{ + named: { + cjsExports: true, + }, + alphabetize: { order: 'asc' }, + }], + }), + test({ + code: ` + module.exports.A = { }; + module.exports.A.B = { }; + module.exports.B = { }; + exports.C = { }; + `, + options: [{ + named: { + cjsExports: true, + }, + alphabetize: { order: 'asc' }, + }], + }), + // ensure other assignments are untouched + test({ + code: ` + var exports = null; + var module = null; + exports = { }; + module = { }; + module.exports = { }; + module.exports.U = { }; + module.exports.N = { }; + module.exports.C = { }; + exports.L = { }; + exports.E = { }; + `, + options: [{ + named: { + cjsExports: true, + }, + alphabetize: { order: 'asc' }, + }], + }), + test({ + code: ` + exports["B"] = { }; + exports["C"] = { }; + exports["A"] = { }; + `, + options: [{ + named: { + cjsExports: true, + }, + alphabetize: { order: 'asc' }, + }], + }), ], invalid: [ // builtin before external module (require) @@ -2742,6 +2876,205 @@ ruleTester.run('order', rule, { message: 'There should be no empty line within import group', }], }), + // named import order + test({ + code: ` + var { B, A: R } = require("./Z"); + import { O as G, D } from "./Z"; + import { K, L, J } from "./Z"; + export { Z, X, Y } from "./Z"; + `, + output: ` + var { A: R, B } = require("./Z"); + import { D, O as G } from "./Z"; + import { J, K, L } from "./Z"; + export { X, Y, Z } from "./Z"; + `, + options: [{ + named: true, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A` import should occur before import of `B`', + }, { + message: '`D` import should occur before import of `O`', + }, { + message: '`J` import should occur before import of `K`', + }, { + message: '`Z` export should occur after export of `Y`', + }], + }), + test({ + code: ` + import { D, C } from "./Z"; + var { B, A } = require("./Z"); + export { B, A }; + `, + output: ` + import { C, D } from "./Z"; + var { B, A } = require("./Z"); + export { A, B }; + `, + options: [{ + named: { + require: false, + import: true, + export: true, + }, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`C` import should occur before import of `D`', + }, { + message: '`A` export should occur before export of `B`', + }], + }), + test({ + code: ` + import { A as B, A as C, A } from "./Z"; + export { A, A as D, A as B, A as C } from "./Z"; + const { a: b, a: c, a } = require("./Z"); + `, + output: ` + import { A, A as B, A as C } from "./Z"; + export { A, A as B, A as C, A as D } from "./Z"; + const { a, a: b, a: c } = require("./Z"); + `, + options: [{ + named: true, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A` import should occur before import of `A as B`', + }, { + message: '`A as D` export should occur after export of `A as C`', + }, { + message: '`a` import should occur before import of `a as b`', + }], + }), + test({ + code: ` + import { A, B, C } from "./Z"; + exports = { B, C, A }; + module.exports = { c: C, a: A, b: B }; + `, + output: ` + import { A, B, C } from "./Z"; + exports = { A, B, C }; + module.exports = { a: A, b: B, c: C }; + `, + options: [{ + named: { + cjsExports: true, + }, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A` export should occur before export of `B`', + }, { + message: '`c` export should occur after export of `b`', + }], + }), + test({ + code: ` + exports.B = { }; + module.exports.A = { }; + module.exports.C = { }; + `, + output: ` + module.exports.A = { }; + exports.B = { }; + module.exports.C = { }; + `, + options: [{ + named: { + cjsExports: true, + }, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A` export should occur before export of `B`', + }], + }), + test({ + code: ` + exports.A.C = { }; + module.exports.A.A = { }; + exports.A.B = { }; + `, + output: ` + module.exports.A.A = { }; + exports.A.B = { }; + exports.A.C = { }; + `, + options: [{ + named: { + cjsExports: true, + }, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A.C` export should occur after export of `A.B`', + }], + }), + // multiline named specifiers & trailing commas + test({ + code: ` + const { + F: O, + O: B, + /* Hello World */ + A: R + } = require("./Z"); + import { + Y, + X, + } from "./Z"; + export { + Z, A, + B + } from "./Z"; + module.exports = { + a: A, o: O, + b: B + }; + `, + output: ` + const { + /* Hello World */ + A: R, + F: O, + O: B + } = require("./Z"); + import { + X, + Y, + } from "./Z"; + export { A, + B, + Z + } from "./Z"; + module.exports = { + a: A, + b: B, o: O + }; + `, + options: [{ + named: { + enabled: true, + }, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A` import should occur before import of `F`', + }, { + message: '`X` import should occur before import of `Y`', + }, { + message: '`Z` export should occur after export of `B`', + }, { + message: '`b` export should occur before export of `o`', + }], + }), // Alphabetize with require ...semver.satisfies(eslintPkg.version, '< 3.0.0') ? [] : [ test({ @@ -2772,6 +3105,9 @@ context('TypeScript', function () { // Type-only imports were added in TypeScript ESTree 2.23.0 .filter((parser) => parser !== parsers.TS_OLD) .forEach((parser) => { + const supportsTypeSpecifiers = semver.satisfies(require('@typescript-eslint/parser/package.json').version, '>= 5'); + const supportsImportTypeSpecifiers = parser !== parsers.TS_NEW || supportsTypeSpecifiers; + const supportsExportTypeSpecifiers = parser === parsers.TS_NEW && supportsTypeSpecifiers; const parserConfig = { parser, settings: { @@ -3238,6 +3574,108 @@ context('TypeScript', function () { }, ], }), + // named import order + test({ + code: ` + import { type Z, A } from "./Z"; + import type N, { E, D } from "./Z"; + import type { L, G } from "./Z"; + `, + output: ` + import { A, type Z } from "./Z"; + import type N, { D, E } from "./Z"; + import type { G, L } from "./Z"; + `, + ...parserConfig, + options: [{ + named: true, + alphabetize: { order: 'asc' }, + }], + errors: [ + { message: `\`A\` import should occur before${supportsImportTypeSpecifiers ? ' type' : ''} import of \`Z\`` }, + { message: '`D` import should occur before import of `E`' }, + { message: '`G` import should occur before import of `L`' }, + ], + }), + test({ + code: ` + const { B, /* Hello World */ A } = require("./Z"); + export { B, A } from "./Z"; + `, + output: ` + const { /* Hello World */ A, B } = require("./Z"); + export { A, B } from "./Z"; + `, + ...parserConfig, + options: [{ + named: true, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A` import should occur before import of `B`', + }, { + message: '`A` export should occur before export of `B`', + }], + }), + + supportsExportTypeSpecifiers ? [ + test({ + code: ` + export { type B, A }; + `, + output: ` + export { A, type B }; + `, + ...parserConfig, + options: [{ + named: { + enabled: true, + types: 'mixed', + }, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`A` export should occur before type export of `B`', + }], + }), + test({ + code: ` + import { type B, A, default as C } from "./Z"; + `, + output: ` + import { A, default as C, type B } from "./Z"; + `, + ...parserConfig, + options: [{ + named: { + import: true, + types: 'types-last', + }, + alphabetize: { order: 'asc' }, + }], + errors: [{ + message: '`B` type import should occur after import of `default`', + }], + }), + test({ + code: ` + export { A, type Z } from "./Z"; + `, + output: ` + export { type Z, A } from "./Z"; + `, + ...parserConfig, + options: [{ + named: { + enabled: true, + types: 'types-first', + }, + }], + errors: [ + { message: '`Z` type export should occur before export of `A`' }, + ], + }), + ] : [], isCoreModule('node:child_process') && isCoreModule('node:fs/promises') ? [ test({