379 lines
57 KiB
JavaScript
379 lines
57 KiB
JavaScript
'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();var _contextCompat = require('eslint-module-utils/contextCompat');
|
||
var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);
|
||
var _semver = require('semver');var _semver2 = _interopRequireDefault(_semver);
|
||
var _arrayPrototype = require('array.prototype.flatmap');var _arrayPrototype2 = _interopRequireDefault(_arrayPrototype);
|
||
|
||
var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _toArray(arr) {return Array.isArray(arr) ? arr : Array.from(arr);}
|
||
|
||
var typescriptPkg = void 0;
|
||
try {
|
||
typescriptPkg = require('typescript/package.json'); // eslint-disable-line import/no-extraneous-dependencies
|
||
} catch (e) {/**/}
|
||
|
||
function isPunctuator(node, value) {
|
||
return node.type === 'Punctuator' && node.value === value;
|
||
}
|
||
|
||
// Get the name of the default import of `node`, if any.
|
||
function getDefaultImportName(node) {
|
||
var defaultSpecifier = node.specifiers.
|
||
find(function (specifier) {return specifier.type === 'ImportDefaultSpecifier';});
|
||
return defaultSpecifier != null ? defaultSpecifier.local.name : undefined;
|
||
}
|
||
|
||
// Checks whether `node` has a namespace import.
|
||
function hasNamespace(node) {
|
||
var specifiers = node.specifiers.
|
||
filter(function (specifier) {return specifier.type === 'ImportNamespaceSpecifier';});
|
||
return specifiers.length > 0;
|
||
}
|
||
|
||
// Checks whether `node` has any non-default specifiers.
|
||
function hasSpecifiers(node) {
|
||
var specifiers = node.specifiers.
|
||
filter(function (specifier) {return specifier.type === 'ImportSpecifier';});
|
||
return specifiers.length > 0;
|
||
}
|
||
|
||
// Checks whether `node` has a comment (that ends) on the previous line or on
|
||
// the same line as `node` (starts).
|
||
function hasCommentBefore(node, sourceCode) {
|
||
return sourceCode.getCommentsBefore(node).
|
||
some(function (comment) {return comment.loc.end.line >= node.loc.start.line - 1;});
|
||
}
|
||
|
||
// Checks whether `node` has a comment (that starts) on the same line as `node`
|
||
// (ends).
|
||
function hasCommentAfter(node, sourceCode) {
|
||
return sourceCode.getCommentsAfter(node).
|
||
some(function (comment) {return comment.loc.start.line === node.loc.end.line;});
|
||
}
|
||
|
||
// Checks whether `node` has any comments _inside,_ except inside the `{...}`
|
||
// part (if any).
|
||
function hasCommentInsideNonSpecifiers(node, sourceCode) {
|
||
var tokens = sourceCode.getTokens(node);
|
||
var openBraceIndex = tokens.findIndex(function (token) {return isPunctuator(token, '{');});
|
||
var closeBraceIndex = tokens.findIndex(function (token) {return isPunctuator(token, '}');});
|
||
// Slice away the first token, since we're no looking for comments _before_
|
||
// `node` (only inside). If there's a `{...}` part, look for comments before
|
||
// the `{`, but not before the `}` (hence the `+1`s).
|
||
var someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0 ?
|
||
tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1)) :
|
||
tokens.slice(1);
|
||
return someTokens.some(function (token) {return sourceCode.getCommentsBefore(token).length > 0;});
|
||
}
|
||
|
||
// It's not obvious what the user wants to do with comments associated with
|
||
// duplicate imports, so skip imports with comments when autofixing.
|
||
function hasProblematicComments(node, sourceCode) {
|
||
return (
|
||
hasCommentBefore(node, sourceCode) ||
|
||
hasCommentAfter(node, sourceCode) ||
|
||
hasCommentInsideNonSpecifiers(node, sourceCode));
|
||
|
||
}
|
||
|
||
/** @type {(first: import('estree').ImportDeclaration, rest: import('estree').ImportDeclaration[], sourceCode: import('eslint').SourceCode.SourceCode, context: import('eslint').Rule.RuleContext) => import('eslint').Rule.ReportFixer | undefined} */
|
||
function getFix(first, rest, sourceCode, context) {
|
||
// Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports
|
||
// requires multiple `fixer.whatever()` calls in the `fix`: We both need to
|
||
// update the first one, and remove the rest. Support for multiple
|
||
// `fixer.whatever()` in a single `fix` was added in ESLint 4.1.
|
||
// `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to
|
||
// check for.
|
||
if (typeof sourceCode.getCommentsBefore !== 'function') {
|
||
return undefined;
|
||
}
|
||
|
||
// Adjusting the first import might make it multiline, which could break
|
||
// `eslint-disable-next-line` comments and similar, so bail if the first
|
||
// import has comments. Also, if the first import is `import * as ns from
|
||
// './foo'` there's nothing we can do.
|
||
if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) {
|
||
return undefined;
|
||
}
|
||
|
||
var defaultImportNames = new Set(
|
||
(0, _arrayPrototype2['default'])([].concat(first, rest || []), function (x) {return getDefaultImportName(x) || [];}));
|
||
|
||
|
||
// Bail if there are multiple different default import names – it's up to the
|
||
// user to choose which one to keep.
|
||
if (defaultImportNames.size > 1) {
|
||
return undefined;
|
||
}
|
||
|
||
// Leave it to the user to handle comments. Also skip `import * as ns from
|
||
// './foo'` imports, since they cannot be merged into another import.
|
||
var restWithoutComments = rest.filter(function (node) {return !hasProblematicComments(node, sourceCode) && !hasNamespace(node);});
|
||
|
||
var specifiers = restWithoutComments.
|
||
map(function (node) {
|
||
var tokens = sourceCode.getTokens(node);
|
||
var openBrace = tokens.find(function (token) {return isPunctuator(token, '{');});
|
||
var closeBrace = tokens.find(function (token) {return isPunctuator(token, '}');});
|
||
|
||
if (openBrace == null || closeBrace == null) {
|
||
return undefined;
|
||
}
|
||
|
||
return {
|
||
importNode: node,
|
||
identifiers: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(','), // Split the text into separate identifiers (retaining any whitespace before or after)
|
||
isEmpty: !hasSpecifiers(node) };
|
||
|
||
}).
|
||
filter(function (x) {return !!x;});
|
||
|
||
var unnecessaryImports = restWithoutComments.filter(function (node) {return !hasSpecifiers(node) &&
|
||
!hasNamespace(node) &&
|
||
!specifiers.some(function (specifier) {return specifier.importNode === node;});});
|
||
|
||
|
||
var shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;
|
||
var shouldAddSpecifiers = specifiers.length > 0;
|
||
var shouldRemoveUnnecessary = unnecessaryImports.length > 0;
|
||
var preferInline = context.options[0] && context.options[0]['prefer-inline'];
|
||
|
||
if (!(shouldAddDefault || shouldAddSpecifiers || shouldRemoveUnnecessary)) {
|
||
return undefined;
|
||
}
|
||
|
||
/** @type {import('eslint').Rule.ReportFixer} */
|
||
return function (fixer) {
|
||
var tokens = sourceCode.getTokens(first);
|
||
var openBrace = tokens.find(function (token) {return isPunctuator(token, '{');});
|
||
var closeBrace = tokens.find(function (token) {return isPunctuator(token, '}');});
|
||
var firstToken = sourceCode.getFirstToken(first);var _defaultImportNames = _slicedToArray(
|
||
defaultImportNames, 1),defaultImportName = _defaultImportNames[0];
|
||
|
||
var firstHasTrailingComma = closeBrace != null && isPunctuator(sourceCode.getTokenBefore(closeBrace), ',');
|
||
var firstIsEmpty = !hasSpecifiers(first);
|
||
var firstExistingIdentifiers = firstIsEmpty ?
|
||
new Set() :
|
||
new Set(sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).
|
||
split(',').
|
||
map(function (x) {return x.trim();}));var _specifiers$reduce =
|
||
|
||
|
||
specifiers.reduce(
|
||
function (_ref, specifier) {var _ref2 = _slicedToArray(_ref, 3),result = _ref2[0],needsComma = _ref2[1],existingIdentifiers = _ref2[2];
|
||
var isTypeSpecifier = specifier.importNode.importKind === 'type';
|
||
|
||
// a user might set prefer-inline but not have a supporting TypeScript version. Flow does not support inline types so this should fail in that case as well.
|
||
if (preferInline && (!typescriptPkg || !_semver2['default'].satisfies(typescriptPkg.version, '>= 4.5'))) {
|
||
throw new Error('Your version of TypeScript does not support inline type imports.');
|
||
}
|
||
|
||
// Add *only* the new identifiers that don't already exist, and track any new identifiers so we don't add them again in the next loop
|
||
var _specifier$identifier = specifier.identifiers.reduce(function (_ref3, cur) {var _ref4 = _slicedToArray(_ref3, 2),text = _ref4[0],set = _ref4[1];
|
||
var trimmed = cur.trim(); // Trim whitespace before/after to compare to our set of existing identifiers
|
||
var curWithType = trimmed.length > 0 && preferInline && isTypeSpecifier ? 'type ' + String(cur) : cur;
|
||
if (existingIdentifiers.has(trimmed)) {
|
||
return [text, set];
|
||
}
|
||
return [text.length > 0 ? String(text) + ',' + String(curWithType) : curWithType, set.add(trimmed)];
|
||
}, ['', existingIdentifiers]),_specifier$identifier2 = _slicedToArray(_specifier$identifier, 2),specifierText = _specifier$identifier2[0],updatedExistingIdentifiers = _specifier$identifier2[1];
|
||
|
||
return [
|
||
needsComma && !specifier.isEmpty && specifierText.length > 0 ? String(
|
||
result) + ',' + String(specifierText) : '' + String(
|
||
result) + String(specifierText),
|
||
specifier.isEmpty ? needsComma : true,
|
||
updatedExistingIdentifiers];
|
||
|
||
},
|
||
['', !firstHasTrailingComma && !firstIsEmpty, firstExistingIdentifiers]),_specifiers$reduce2 = _slicedToArray(_specifiers$reduce, 1),specifiersText = _specifiers$reduce2[0];
|
||
|
||
|
||
/** @type {import('eslint').Rule.Fix[]} */
|
||
var fixes = [];
|
||
|
||
if (shouldAddSpecifiers && preferInline && first.importKind === 'type') {
|
||
// `import type {a} from './foo'` → `import {type a} from './foo'`
|
||
var typeIdentifierToken = tokens.find(function (token) {return token.type === 'Identifier' && token.value === 'type';});
|
||
fixes.push(fixer.removeRange([typeIdentifierToken.range[0], typeIdentifierToken.range[1] + 1]));
|
||
|
||
tokens.
|
||
filter(function (token) {return firstExistingIdentifiers.has(token.value);}).
|
||
forEach(function (identifier) {
|
||
fixes.push(fixer.replaceTextRange([identifier.range[0], identifier.range[1]], 'type ' + String(identifier.value)));
|
||
});
|
||
}
|
||
|
||
if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) {
|
||
// `import './foo'` → `import def, {...} from './foo'`
|
||
fixes.push(
|
||
fixer.insertTextAfter(firstToken, ' ' + String(defaultImportName) + ', {' + String(specifiersText) + '} from'));
|
||
|
||
} else if (shouldAddDefault && openBrace == null && !shouldAddSpecifiers) {
|
||
// `import './foo'` → `import def from './foo'`
|
||
fixes.push(fixer.insertTextAfter(firstToken, ' ' + String(defaultImportName) + ' from'));
|
||
} else if (shouldAddDefault && openBrace != null && closeBrace != null) {
|
||
// `import {...} from './foo'` → `import def, {...} from './foo'`
|
||
fixes.push(fixer.insertTextAfter(firstToken, ' ' + String(defaultImportName) + ','));
|
||
if (shouldAddSpecifiers) {
|
||
// `import def, {...} from './foo'` → `import def, {..., ...} from './foo'`
|
||
fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
|
||
}
|
||
} else if (!shouldAddDefault && openBrace == null && shouldAddSpecifiers) {
|
||
if (first.specifiers.length === 0) {
|
||
// `import './foo'` → `import {...} from './foo'`
|
||
fixes.push(fixer.insertTextAfter(firstToken, ' {' + String(specifiersText) + '} from'));
|
||
} else {
|
||
// `import def from './foo'` → `import def, {...} from './foo'`
|
||
fixes.push(fixer.insertTextAfter(first.specifiers[0], ', {' + String(specifiersText) + '}'));
|
||
}
|
||
} else if (!shouldAddDefault && openBrace != null && closeBrace != null) {
|
||
// `import {...} './foo'` → `import {..., ...} from './foo'`
|
||
fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
|
||
}
|
||
|
||
// Remove imports whose specifiers have been moved into the first import.
|
||
specifiers.forEach(function (specifier) {
|
||
var importNode = specifier.importNode;
|
||
fixes.push(fixer.remove(importNode));
|
||
|
||
var charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];
|
||
var charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);
|
||
if (charAfterImport === '\n') {
|
||
fixes.push(fixer.removeRange(charAfterImportRange));
|
||
}
|
||
});
|
||
|
||
// Remove imports whose default import has been moved to the first import,
|
||
// and side-effect-only imports that are unnecessary due to the first
|
||
// import.
|
||
unnecessaryImports.forEach(function (node) {
|
||
fixes.push(fixer.remove(node));
|
||
|
||
var charAfterImportRange = [node.range[1], node.range[1] + 1];
|
||
var charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);
|
||
if (charAfterImport === '\n') {
|
||
fixes.push(fixer.removeRange(charAfterImportRange));
|
||
}
|
||
});
|
||
|
||
return fixes;
|
||
};
|
||
}
|
||
|
||
/** @type {(imported: Map<string, import('estree').ImportDeclaration[]>, context: import('eslint').Rule.RuleContext) => void} */
|
||
function checkImports(imported, context) {var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {
|
||
for (var _iterator = imported.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var _ref5 = _step.value;var _ref6 = _slicedToArray(_ref5, 2);var _module = _ref6[0];var nodes = _ref6[1];
|
||
if (nodes.length > 1) {(function () {
|
||
var message = '\'' + String(_module) + '\' imported multiple times.';var _nodes = _toArray(
|
||
nodes),first = _nodes[0],rest = _nodes.slice(1);
|
||
var sourceCode = (0, _contextCompat.getSourceCode)(context);
|
||
var fix = getFix(first, rest, sourceCode, context);
|
||
|
||
context.report({
|
||
node: first.source,
|
||
message: message,
|
||
fix: fix // Attach the autofix (if any) to the first import.
|
||
});
|
||
|
||
rest.forEach(function (node) {
|
||
context.report({
|
||
node: node.source,
|
||
message: message });
|
||
|
||
});})();
|
||
}
|
||
}} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}
|
||
}
|
||
|
||
/** @type {import('eslint').Rule.RuleModule} */
|
||
module.exports = {
|
||
meta: {
|
||
type: 'problem',
|
||
docs: {
|
||
category: 'Style guide',
|
||
description: 'Forbid repeated import of the same module in multiple places.',
|
||
url: (0, _docsUrl2['default'])('no-duplicates') },
|
||
|
||
fixable: 'code',
|
||
schema: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
considerQueryString: {
|
||
type: 'boolean' },
|
||
|
||
'prefer-inline': {
|
||
type: 'boolean' } },
|
||
|
||
|
||
additionalProperties: false }] },
|
||
|
||
|
||
|
||
|
||
/** @param {import('eslint').Rule.RuleContext} context */
|
||
create: function () {function create(context) {
|
||
/** @type {boolean} */
|
||
// Prepare the resolver from options.
|
||
var considerQueryStringOption = context.options[0] && context.options[0].considerQueryString;
|
||
/** @type {boolean} */
|
||
var preferInline = context.options[0] && context.options[0]['prefer-inline'];
|
||
var defaultResolver = function () {function defaultResolver(sourcePath) {return (0, _resolve2['default'])(sourcePath, context) || sourcePath;}return defaultResolver;}();
|
||
var resolver = considerQueryStringOption ? function (sourcePath) {
|
||
var parts = sourcePath.match(/^([^?]*)\?(.*)$/);
|
||
if (!parts) {
|
||
return defaultResolver(sourcePath);
|
||
}
|
||
return String(defaultResolver(parts[1])) + '?' + String(parts[2]);
|
||
} : defaultResolver;
|
||
|
||
/** @type {Map<unknown, { imported: Map<string, import('estree').ImportDeclaration[]>, nsImported: Map<string, import('estree').ImportDeclaration[]>, defaultTypesImported: Map<string, import('estree').ImportDeclaration[]>, namedTypesImported: Map<string, import('estree').ImportDeclaration[]>}>} */
|
||
var moduleMaps = new Map();
|
||
|
||
/** @param {import('estree').ImportDeclaration} n */
|
||
/** @returns {typeof moduleMaps[keyof typeof moduleMaps]} */
|
||
function getImportMap(n) {
|
||
if (!moduleMaps.has(n.parent)) {
|
||
moduleMaps.set(n.parent, /** @type {typeof moduleMaps} */{
|
||
imported: new Map(),
|
||
nsImported: new Map(),
|
||
defaultTypesImported: new Map(),
|
||
namedTypesImported: new Map() });
|
||
|
||
}
|
||
var map = moduleMaps.get(n.parent);
|
||
if (!preferInline && n.importKind === 'type') {
|
||
return n.specifiers.length > 0 && n.specifiers[0].type === 'ImportDefaultSpecifier' ? map.defaultTypesImported : map.namedTypesImported;
|
||
}
|
||
if (!preferInline && n.specifiers.some(function (spec) {return spec.importKind === 'type';})) {
|
||
return map.namedTypesImported;
|
||
}
|
||
|
||
return hasNamespace(n) ? map.nsImported : map.imported;
|
||
}
|
||
|
||
return {
|
||
/** @param {import('estree').ImportDeclaration} n */
|
||
ImportDeclaration: function () {function ImportDeclaration(n) {
|
||
/** @type {string} */
|
||
// resolved path will cover aliased duplicates
|
||
var resolvedPath = resolver(n.source.value);
|
||
var importMap = getImportMap(n);
|
||
|
||
if (importMap.has(resolvedPath)) {
|
||
importMap.get(resolvedPath).push(n);
|
||
} else {
|
||
importMap.set(resolvedPath, [n]);
|
||
}
|
||
}return ImportDeclaration;}(),
|
||
|
||
'Program:exit': function () {function ProgramExit() {var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try {
|
||
for (var _iterator2 = moduleMaps.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var map = _step2.value;
|
||
checkImports(map.imported, context);
|
||
checkImports(map.nsImported, context);
|
||
checkImports(map.defaultTypesImported, context);
|
||
checkImports(map.namedTypesImported, context);
|
||
}} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}}
|
||
}return ProgramExit;}() };
|
||
|
||
}return create;}() };
|
||
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-duplicates.js"],"names":["typescriptPkg","require","e","isPunctuator","node","value","type","getDefaultImportName","defaultSpecifier","specifiers","find","specifier","local","name","undefined","hasNamespace","filter","length","hasSpecifiers","hasCommentBefore","sourceCode","getCommentsBefore","some","comment","loc","end","line","start","hasCommentAfter","getCommentsAfter","hasCommentInsideNonSpecifiers","tokens","getTokens","openBraceIndex","findIndex","token","closeBraceIndex","someTokens","slice","concat","hasProblematicComments","getFix","first","rest","context","defaultImportNames","Set","x","size","restWithoutComments","map","openBrace","closeBrace","importNode","identifiers","text","range","split","isEmpty","unnecessaryImports","shouldAddDefault","shouldAddSpecifiers","shouldRemoveUnnecessary","preferInline","options","fixer","firstToken","getFirstToken","defaultImportName","firstHasTrailingComma","getTokenBefore","firstIsEmpty","firstExistingIdentifiers","trim","reduce","result","needsComma","existingIdentifiers","isTypeSpecifier","importKind","semver","satisfies","version","Error","cur","set","trimmed","curWithType","has","add","specifierText","updatedExistingIdentifiers","specifiersText","fixes","typeIdentifierToken","push","removeRange","forEach","identifier","replaceTextRange","insertTextAfter","insertTextBefore","remove","charAfterImportRange","charAfterImport","substring","checkImports","imported","entries","module","nodes","message","fix","report","source","exports","meta","docs","category","description","url","fixable","schema","properties","considerQueryString","additionalProperties","create","considerQueryStringOption","defaultResolver","sourcePath","resolver","parts","match","moduleMaps","Map","getImportMap","n","parent","nsImported","defaultTypesImported","namedTypesImported","get","spec","ImportDeclaration","resolvedPath","importMap","values"],"mappings":"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","file":"no-duplicates.js","sourcesContent":["import { getSourceCode } from 'eslint-module-utils/contextCompat';\nimport resolve from 'eslint-module-utils/resolve';\nimport semver from 'semver';\nimport flatMap from 'array.prototype.flatmap';\n\nimport docsUrl from '../docsUrl';\n\nlet typescriptPkg;\ntry {\n  typescriptPkg = require('typescript/package.json'); // eslint-disable-line import/no-extraneous-dependencies\n} catch (e) { /**/ }\n\nfunction isPunctuator(node, value) {\n  return node.type === 'Punctuator' && node.value === value;\n}\n\n// Get the name of the default import of `node`, if any.\nfunction getDefaultImportName(node) {\n  const defaultSpecifier = node.specifiers\n    .find((specifier) => specifier.type === 'ImportDefaultSpecifier');\n  return defaultSpecifier != null ? defaultSpecifier.local.name : undefined;\n}\n\n// Checks whether `node` has a namespace import.\nfunction hasNamespace(node) {\n  const specifiers = node.specifiers\n    .filter((specifier) => specifier.type === 'ImportNamespaceSpecifier');\n  return specifiers.length > 0;\n}\n\n// Checks whether `node` has any non-default specifiers.\nfunction hasSpecifiers(node) {\n  const specifiers = node.specifiers\n    .filter((specifier) => specifier.type === 'ImportSpecifier');\n  return specifiers.length > 0;\n}\n\n// Checks whether `node` has a comment (that ends) on the previous line or on\n// the same line as `node` (starts).\nfunction hasCommentBefore(node, sourceCode) {\n  return sourceCode.getCommentsBefore(node)\n    .some((comment) => comment.loc.end.line >= node.loc.start.line - 1);\n}\n\n// Checks whether `node` has a comment (that starts) on the same line as `node`\n// (ends).\nfunction hasCommentAfter(node, sourceCode) {\n  return sourceCode.getCommentsAfter(node)\n    .some((comment) => comment.loc.start.line === node.loc.end.line);\n}\n\n// Checks whether `node` has any comments _inside,_ except inside the `{...}`\n// part (if any).\nfunction hasCommentInsideNonSpecifiers(node, sourceCode) {\n  const tokens = sourceCode.getTokens(node);\n  const openBraceIndex = tokens.findIndex((token) => isPunctuator(token, '{'));\n  const closeBraceIndex = tokens.findIndex((token) => isPunctuator(token, '}'));\n  // Slice away the first token, since we're no looking for comments _before_\n  // `node` (only inside). If there's a `{...}` part, look for comments before\n  // the `{`, but not before the `}` (hence the `+1`s).\n  const someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0\n    ? tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1))\n    : tokens.slice(1);\n  return someTokens.some((token) => sourceCode.getCommentsBefore(token).length > 0);\n}\n\n// It's not obvious what the user wants to do with comments associated with\n// duplicate imports, so skip imports with comments when autofixing.\nfunction hasProblematicComments(node, sourceCode) {\n  return (\n    hasCommentBefore(node, sourceCode)\n    || hasCommentAfter(node, sourceCode)\n    || hasCommentInsideNonSpecifiers(node, sourceCode)\n  );\n}\n\n/** @type {(first: import('estree').ImportDeclaration, rest: import('estree').ImportDeclaration[], sourceCode: import('eslint').SourceCode.SourceCode, context: import('eslint').Rule.RuleContext) => import('eslint').Rule.ReportFixer | undefined} */\nfunction getFix(first, rest, sourceCode, context) {\n  // Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports\n  // requires multiple `fixer.whatever()` calls in the `fix`: We both need to\n  // update the first one, and remove the rest. Support for multiple\n  // `fixer.whatever()` in a single `fix` was added in ESLint 4.1.\n  // `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to\n  // check for.\n  if (typeof sourceCode.getCommentsBefore !== 'function') {\n    return undefined;\n  }\n\n  // Adjusting the first import might make it multiline, which could break\n  // `eslint-disable-next-line` comments and similar, so bail if the first\n  // import has comments. Also, if the first import is `import * as ns from\n  // './foo'` there's nothing we can do.\n  if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) {\n    return undefined;\n  }\n\n  const defaultImportNames = new Set(\n    flatMap([].concat(first, rest || []), (x) => getDefaultImportName(x) || []),\n  );\n\n  // Bail if there are multiple different default import names – it's up to the\n  // user to choose which one to keep.\n  if (defaultImportNames.size > 1) {\n    return undefined;\n  }\n\n  // Leave it to the user to handle comments. Also skip `import * as ns from\n  // './foo'` imports, since they cannot be merged into another import.\n  const restWithoutComments = rest.filter((node) => !hasProblematicComments(node, sourceCode) && !hasNamespace(node));\n\n  const specifiers = restWithoutComments\n    .map((node) => {\n      const tokens = sourceCode.getTokens(node);\n      const openBrace = tokens.find((token) => isPunctuator(token, '{'));\n      const closeBrace = tokens.find((token) => isPunctuator(token, '}'));\n\n      if (openBrace == null || closeBrace == null) {\n        return undefined;\n      }\n\n      return {\n        importNode: node,\n        identifiers: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(','), // Split the text into separate identifiers (retaining any whitespace before or after)\n        isEmpty: !hasSpecifiers(node),\n      };\n    })\n    .filter((x) => !!x);\n\n  const unnecessaryImports = restWithoutComments.filter((node) => !hasSpecifiers(node)\n    && !hasNamespace(node)\n    && !specifiers.some((specifier) => specifier.importNode === node),\n  );\n\n  const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;\n  const shouldAddSpecifiers = specifiers.length > 0;\n  const shouldRemoveUnnecessary = unnecessaryImports.length > 0;\n  const preferInline = context.options[0] && context.options[0]['prefer-inline'];\n\n  if (!(shouldAddDefault || shouldAddSpecifiers || shouldRemoveUnnecessary)) {\n    return undefined;\n  }\n\n  /** @type {import('eslint').Rule.ReportFixer} */\n  return (fixer) => {\n    const tokens = sourceCode.getTokens(first);\n    const openBrace = tokens.find((token) => isPunctuator(token, '{'));\n    const closeBrace = tokens.find((token) => isPunctuator(token, '}'));\n    const firstToken = sourceCode.getFirstToken(first);\n    const [defaultImportName] = defaultImportNames;\n\n    const firstHasTrailingComma = closeBrace != null && isPunctuator(sourceCode.getTokenBefore(closeBrace), ',');\n    const firstIsEmpty = !hasSpecifiers(first);\n    const firstExistingIdentifiers = firstIsEmpty\n      ? new Set()\n      : new Set(sourceCode.text.slice(openBrace.range[1], closeBrace.range[0])\n        .split(',')\n        .map((x) => x.trim()),\n      );\n\n    const [specifiersText] = specifiers.reduce(\n      ([result, needsComma, existingIdentifiers], specifier) => {\n        const isTypeSpecifier = specifier.importNode.importKind === 'type';\n\n        // a user might set prefer-inline but not have a supporting TypeScript version. Flow does not support inline types so this should fail in that case as well.\n        if (preferInline && (!typescriptPkg || !semver.satisfies(typescriptPkg.version, '>= 4.5'))) {\n          throw new Error('Your version of TypeScript does not support inline type imports.');\n        }\n\n        // Add *only* the new identifiers that don't already exist, and track any new identifiers so we don't add them again in the next loop\n        const [specifierText, updatedExistingIdentifiers] = specifier.identifiers.reduce(([text, set], cur) => {\n          const trimmed = cur.trim(); // Trim whitespace before/after to compare to our set of existing identifiers\n          const curWithType = trimmed.length > 0 && preferInline && isTypeSpecifier ? `type ${cur}` : cur;\n          if (existingIdentifiers.has(trimmed)) {\n            return [text, set];\n          }\n          return [text.length > 0 ? `${text},${curWithType}` : curWithType, set.add(trimmed)];\n        }, ['', existingIdentifiers]);\n\n        return [\n          needsComma && !specifier.isEmpty && specifierText.length > 0\n            ? `${result},${specifierText}`\n            : `${result}${specifierText}`,\n          specifier.isEmpty ? needsComma : true,\n          updatedExistingIdentifiers,\n        ];\n      },\n      ['', !firstHasTrailingComma && !firstIsEmpty, firstExistingIdentifiers],\n    );\n\n    /** @type {import('eslint').Rule.Fix[]} */\n    const fixes = [];\n\n    if (shouldAddSpecifiers && preferInline && first.importKind === 'type') {\n      // `import type {a} from './foo'` → `import {type a} from './foo'`\n      const typeIdentifierToken = tokens.find((token) => token.type === 'Identifier' && token.value === 'type');\n      fixes.push(fixer.removeRange([typeIdentifierToken.range[0], typeIdentifierToken.range[1] + 1]));\n\n      tokens\n        .filter((token) => firstExistingIdentifiers.has(token.value))\n        .forEach((identifier) => {\n          fixes.push(fixer.replaceTextRange([identifier.range[0], identifier.range[1]], `type ${identifier.value}`));\n        });\n    }\n\n    if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) {\n      // `import './foo'` → `import def, {...} from './foo'`\n      fixes.push(\n        fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`),\n      );\n    } else if (shouldAddDefault && openBrace == null && !shouldAddSpecifiers) {\n      // `import './foo'` → `import def from './foo'`\n      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));\n    } else if (shouldAddDefault && openBrace != null && closeBrace != null) {\n      // `import {...} from './foo'` → `import def, {...} from './foo'`\n      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));\n      if (shouldAddSpecifiers) {\n        // `import def, {...} from './foo'` → `import def, {..., ...} from './foo'`\n        fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));\n      }\n    } else if (!shouldAddDefault && openBrace == null && shouldAddSpecifiers) {\n      if (first.specifiers.length === 0) {\n        // `import './foo'` → `import {...} from './foo'`\n        fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));\n      } else {\n        // `import def from './foo'` → `import def, {...} from './foo'`\n        fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));\n      }\n    } else if (!shouldAddDefault && openBrace != null && closeBrace != null) {\n      // `import {...} './foo'` → `import {..., ...} from './foo'`\n      fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));\n    }\n\n    // Remove imports whose specifiers have been moved into the first import.\n    specifiers.forEach((specifier) => {\n      const importNode = specifier.importNode;\n      fixes.push(fixer.remove(importNode));\n\n      const charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];\n      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);\n      if (charAfterImport === '\\n') {\n        fixes.push(fixer.removeRange(charAfterImportRange));\n      }\n    });\n\n    // Remove imports whose default import has been moved to the first import,\n    // and side-effect-only imports that are unnecessary due to the first\n    // import.\n    unnecessaryImports.forEach((node) => {\n      fixes.push(fixer.remove(node));\n\n      const charAfterImportRange = [node.range[1], node.range[1] + 1];\n      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);\n      if (charAfterImport === '\\n') {\n        fixes.push(fixer.removeRange(charAfterImportRange));\n      }\n    });\n\n    return fixes;\n  };\n}\n\n/** @type {(imported: Map<string, import('estree').ImportDeclaration[]>, context: import('eslint').Rule.RuleContext) => void} */\nfunction checkImports(imported, context) {\n  for (const [module, nodes] of imported.entries()) {\n    if (nodes.length > 1) {\n      const message = `'${module}' imported multiple times.`;\n      const [first, ...rest] = nodes;\n      const sourceCode = getSourceCode(context);\n      const fix = getFix(first, rest, sourceCode, context);\n\n      context.report({\n        node: first.source,\n        message,\n        fix, // Attach the autofix (if any) to the first import.\n      });\n\n      rest.forEach((node) => {\n        context.report({\n          node: node.source,\n          message,\n        });\n      });\n    }\n  }\n}\n\n/** @type {import('eslint').Rule.RuleModule} */\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Style guide',\n      description: 'Forbid repeated import of the same module in multiple places.',\n      url: docsUrl('no-duplicates'),\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          considerQueryString: {\n            type: 'boolean',\n          },\n          'prefer-inline': {\n            type: 'boolean',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  /** @param {import('eslint').Rule.RuleContext} context */\n  create(context) {\n    /** @type {boolean} */\n    // Prepare the resolver from options.\n    const considerQueryStringOption = context.options[0] && context.options[0].considerQueryString;\n    /** @type {boolean} */\n    const preferInline = context.options[0] && context.options[0]['prefer-inline'];\n    const defaultResolver = (sourcePath) => resolve(sourcePath, context) || sourcePath;\n    const resolver = considerQueryStringOption ? (sourcePath) => {\n      const parts = sourcePath.match(/^([^?]*)\\?(.*)$/);\n      if (!parts) {\n        return defaultResolver(sourcePath);\n      }\n      return `${defaultResolver(parts[1])}?${parts[2]}`;\n    } : defaultResolver;\n\n    /** @type {Map<unknown, { imported: Map<string, import('estree').ImportDeclaration[]>, nsImported: Map<string, import('estree').ImportDeclaration[]>, defaultTypesImported: Map<string, import('estree').ImportDeclaration[]>, namedTypesImported: Map<string, import('estree').ImportDeclaration[]>}>} */\n    const moduleMaps = new Map();\n\n    /** @param {import('estree').ImportDeclaration} n */\n    /** @returns {typeof moduleMaps[keyof typeof moduleMaps]} */\n    function getImportMap(n) {\n      if (!moduleMaps.has(n.parent)) {\n        moduleMaps.set(n.parent, /** @type {typeof moduleMaps} */ {\n          imported: new Map(),\n          nsImported: new Map(),\n          defaultTypesImported: new Map(),\n          namedTypesImported: new Map(),\n        });\n      }\n      const map = moduleMaps.get(n.parent);\n      if (!preferInline && n.importKind === 'type') {\n        return n.specifiers.length > 0 && n.specifiers[0].type === 'ImportDefaultSpecifier' ? map.defaultTypesImported : map.namedTypesImported;\n      }\n      if (!preferInline && n.specifiers.some((spec) => spec.importKind === 'type')) {\n        return map.namedTypesImported;\n      }\n\n      return hasNamespace(n) ? map.nsImported : map.imported;\n    }\n\n    return {\n      /** @param {import('estree').ImportDeclaration} n */\n      ImportDeclaration(n) {\n        /** @type {string} */\n        // resolved path will cover aliased duplicates\n        const resolvedPath = resolver(n.source.value);\n        const importMap = getImportMap(n);\n\n        if (importMap.has(resolvedPath)) {\n          importMap.get(resolvedPath).push(n);\n        } else {\n          importMap.set(resolvedPath, [n]);\n        }\n      },\n\n      'Program:exit'() {\n        for (const map of moduleMaps.values()) {\n          checkImports(map.imported, context);\n          checkImports(map.nsImported, context);\n          checkImports(map.defaultTypesImported, context);\n          checkImports(map.namedTypesImported, context);\n        }\n      },\n    };\n  },\n};\n"]}
|