@so1ve/eslint-plugin-sort-imports 3.3.2 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@so1ve/eslint-plugin-sort-imports",
-  "version": "3.3.2",
+  "version": "3.5.0",
   "author": "Simon Lydell",
   "contributors": [
     "Ray <i@mk1.io> (https://github.com/so1ve)"

package/src/exports.js

@@ -10,9 +10,9 @@ const getSpecifiers = (exportNode) => exportNode.specifiers || [];
 // export * from "A"
 // export * as A from "A"
 const isExportFrom = (node) =>
-	(node.type === "ExportNamedDeclaration" ||
-		node.type === "ExportAllDeclaration") &&
-	node.source != null;
+	(node.type === "ExportNamedDeclaration"
+		|| node.type === "ExportAllDeclaration")
+	&& node.source != null;
 
 function isPartOfChunk(node, lastNode, sourceCode) {
 	if (!isExportFrom(node)) {
@@ -23,8 +23,8 @@ function isPartOfChunk(node, lastNode, sourceCode) {
 		.getCommentsBefore(node)
 		.some(
 			(comment) =>
-				(lastNode == null || comment.loc.start.line > lastNode.loc.end.line) &&
-				comment.loc.end.line < node.loc.start.line,
+				(lastNode == null || comment.loc.start.line > lastNode.loc.end.line)
+				&& comment.loc.end.line < node.loc.start.line,
 		);
 
 	return hasGroupingComment ? "PartOfNewChunk" : "PartOfChunk";

package/src/imports.js

@@ -33,9 +33,12 @@ const isImport = (node) => node.type === "ImportDeclaration";
 // But not: import {} from "setup"
 // And not: import type {} from "setup"
 const isSideEffectImport = (importNode, sourceCode) =>
-	importNode.specifiers.length === 0 &&
-	(!importNode.importKind || importNode.importKind === "value") &&
-	!shared.isPunctuator(sourceCode.getFirstToken(importNode, { skip: 1 }), "{");
+	importNode.specifiers.length === 0
+	&& (!importNode.importKind || importNode.importKind === "value")
+	&& !shared.isPunctuator(
+		sourceCode.getFirstToken(importNode, { skip: 1 }),
+		"{",
+	);
 
 module.exports = {
 	meta: {
@@ -128,8 +131,9 @@ function makeSortedItems(items, outerGroups) {
 			)
 			.reduce(
 				([group, longestMatch], [nextGroup, nextMatch]) =>
-					nextMatch != null &&
-					(longestMatch == null || nextMatch[0].length > longestMatch[0].length)
+					nextMatch != null
+					&& (longestMatch == null
+						|| nextMatch[0].length > longestMatch[0].length)
 						? [nextGroup, nextMatch]
 						: [group, longestMatch],
 				[undefined, undefined],

package/src/shared.js

@@ -190,8 +190,10 @@ function printCommentsBefore(node, comments, sourceCode) {
 			const next = index === lastIndex ? node : comments[index + 1];
 
 			return (
-				sourceCode.getText(comment) +
-				removeBlankLines(sourceCode.text.slice(comment.range[1], next.range[0]))
+				sourceCode.getText(comment)
+				+ removeBlankLines(
+					sourceCode.text.slice(comment.range[1], next.range[0]),
+				)
 			);
 		})
 		.join("");
@@ -255,16 +257,19 @@ const sortImportExportItems = (items) =>
 				: itemB.isSideEffectImport
 					? 1
 					: // Compare the `from` part.
-						compare(itemA.source.source, itemB.source.source) ||
+						compare(itemA.source.source, itemB.source.source)
 						// The `.source` has been slightly tweaked. To stay fully deterministic,
 						// also sort on the original value.
-						compare(itemA.source.originalSource, itemB.source.originalSource) ||
+						|| compare(
+							itemA.source.originalSource,
+							itemB.source.originalSource,
+						)
 						// Then put type imports/exports before regular ones.
-						compare(itemA.source.kind, itemB.source.kind) ||
+						|| compare(itemA.source.kind, itemB.source.kind)
 						// Keep the original order if the sources are the same. It’s not worth
 						// trying to compare anything else, and you can use `import/no-duplicates`
 						// to get rid of the problem anyway.
-						itemA.index - itemB.index,
+						|| itemA.index - itemB.index,
 	);
 
 const sortSpecifierItems = (items) =>
@@ -278,23 +283,23 @@ const sortSpecifierItems = (items) =>
 			compare(
 				(itemA.node.imported || itemA.node.exported).name,
 				(itemB.node.imported || itemB.node.exported).name,
-			) ||
+			)
 			// Then compare by the file-local name.
 			// import { a as b } from "a"
 			//               ^
 			// export { b as a }
 			//          ^
-			compare(itemA.node.local.name, itemB.node.local.name) ||
+			|| compare(itemA.node.local.name, itemB.node.local.name)
 			// Then put type specifiers before regular ones.
-			compare(
+			|| compare(
 				getImportExportKind(itemA.node),
 				getImportExportKind(itemB.node),
-			) ||
+			)
 			// Keep the original order if the names are the same. It’s not worth
 			// trying to compare anything else, `import {a, a} from "mod"` is a syntax
 			// error anyway (but @babel/eslint-parser kind of supports it).
 			// istanbul ignore next
-			itemA.index - itemB.index,
+			|| itemA.index - itemB.index,
 	);
 
 // A “chunk” is a sequence of statements of a certain type with only comments
@@ -380,16 +385,16 @@ function printSortedItems(sortedItems, originalItems, sourceCode) {
 		? sourceCode.getTokenAfter(lastOriginalItem.node, {
 				includeComments: true,
 				filter: (token) =>
-					!isLineComment(token) &&
-					!(
-						isBlockComment(token) &&
-						token.loc.end.line === lastOriginalItem.node.loc.end.line
+					!isLineComment(token)
+					&& !(
+						isBlockComment(token)
+						&& token.loc.end.line === lastOriginalItem.node.loc.end.line
 					),
 			})
 		: undefined;
 	const maybeNewline =
-		nextToken != null &&
-		nextToken.loc.start.line === lastOriginalItem.node.loc.end.line
+		nextToken != null
+		&& nextToken.loc.start.line === lastOriginalItem.node.loc.end.line
 			? newline
 			: "";
 
@@ -425,9 +430,9 @@ function getImportExportItems(
 			.getCommentsBefore(node)
 			.filter(
 				(comment) =>
-					comment.loc.start.line <= node.loc.start.line &&
-					comment.loc.end.line > lastLine &&
-					(nodeIndex > 0 || comment.loc.start.line > lastLine),
+					comment.loc.start.line <= node.loc.start.line
+					&& comment.loc.end.line > lastLine
+					&& (nodeIndex > 0 || comment.loc.start.line > lastLine),
 			);
 
 		// Get all comments after the import/export that are on the same line.
@@ -456,11 +461,11 @@ function getImportExportItems(
 		);
 
 		const code =
-			indentation +
-			before +
-			printWithSortedSpecifiers(node, sourceCode, getSpecifiers) +
-			after +
-			trailingSpaces;
+			indentation
+			+ before
+			+ printWithSortedSpecifiers(node, sourceCode, getSpecifiers)
+			+ after
+			+ trailingSpaces;
 
 		const all = [...commentsBefore, node, ...commentsAfter];
 		const [start] = all[0].range;
@@ -477,8 +482,8 @@ function getImportExportItems(
 			source,
 			index: nodeIndex,
 			needsNewline:
-				commentsAfter.length > 0 &&
-				isLineComment(commentsAfter[commentsAfter.length - 1]),
+				commentsAfter.length > 0
+				&& isLineComment(commentsAfter[commentsAfter.length - 1]),
 		};
 	});
 }
@@ -507,10 +512,10 @@ function handleLastSemicolon(chunk, sourceCode) {
 	}
 
 	const semicolonBelongsToNode =
-		nextToLastToken.loc.end.line === lastToken.loc.start.line ||
+		nextToLastToken.loc.end.line === lastToken.loc.start.line
 		// If there’s no more code after the last import/export the semicolon has to
 		// belong to the import/export, even if it is not on the same line.
-		sourceCode.getTokenAfter(lastToken) == null;
+		|| sourceCode.getTokenAfter(lastToken) == null;
 
 	if (semicolonBelongsToNode) {
 		return chunk;
@@ -541,9 +546,9 @@ function printWithSortedSpecifiers(node, sourceCode, getSpecifiers) {
 	const specifiers = getSpecifiers(node);
 
 	if (
-		openBraceIndex === -1 ||
-		closeBraceIndex === -1 ||
-		specifiers.length <= 1
+		openBraceIndex === -1
+		|| closeBraceIndex === -1
+		|| specifiers.length <= 1
 	) {
 		return printTokens(allTokens);
 	}
@@ -574,11 +579,11 @@ function printWithSortedSpecifiers(node, sourceCode, getSpecifiers) {
 		// Add a newline if the item needs one, unless the previous item (if any)
 		// already ends with a newline.
 		const maybeNewline =
-			previous != null &&
-			needsStartingNewline(item.before) &&
-			!(
-				previous.after.length > 0 &&
-				isNewline(previous.after[previous.after.length - 1])
+			previous != null
+			&& needsStartingNewline(item.before)
+			&& !(
+				previous.after.length > 0
+				&& isNewline(previous.after[previous.after.length - 1])
 			)
 				? [{ type: "Newline", code: newline }]
 				: [];
@@ -610,8 +615,8 @@ function printWithSortedSpecifiers(node, sourceCode, getSpecifiers) {
 	});
 
 	const maybeNewline =
-		needsStartingNewline(itemsResult.after) &&
-		!isNewline(sorted[sorted.length - 1])
+		needsStartingNewline(itemsResult.after)
+		&& !isNewline(sorted[sorted.length - 1])
 			? [{ type: "Newline", code: newline }]
 			: [];
 
@@ -864,8 +869,8 @@ function needsStartingNewline(tokens) {
 	const firstToken = before[0];
 
 	return (
-		isLineComment(firstToken) ||
-		(isBlockComment(firstToken) && !hasNewline(firstToken.code))
+		isLineComment(firstToken)
+		|| (isBlockComment(firstToken) && !hasNewline(firstToken.code))
 	);
 }