bahlint 28.58.6934-dev-001

package/lib/rules/sort-imports.js

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview Rule to enforce sorted `import` declarations within modules
+ * @author Christian Schuller
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				allowSeparatedGroups: false,
+				ignoreCase: false,
+				ignoreDeclarationSort: false,
+				ignoreMemberSort: false,
+				memberSyntaxSortOrder: ["none", "all", "multiple", "single"],
+			},
+		],
+
+		docs: {
+			description: "Enforce sorted `import` declarations within modules",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/sort-imports",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					ignoreCase: {
+						type: "boolean",
+					},
+					memberSyntaxSortOrder: {
+						type: "array",
+						items: {
+							enum: ["none", "all", "multiple", "single"],
+						},
+						uniqueItems: true,
+						minItems: 4,
+						maxItems: 4,
+					},
+					ignoreDeclarationSort: {
+						type: "boolean",
+					},
+					ignoreMemberSort: {
+						type: "boolean",
+					},
+					allowSeparatedGroups: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "code",
+
+		messages: {
+			sortImportsAlphabetically:
+				"Imports should be sorted alphabetically.",
+			sortMembersAlphabetically:
+				"Member '{{memberName}}' of the import declaration should be sorted alphabetically.",
+			unexpectedSyntaxOrder:
+				"Expected '{{syntaxA}}' syntax before '{{syntaxB}}' syntax.",
+		},
+	},
+
+	create(context) {
+		const [
+			{
+				ignoreCase,
+				ignoreDeclarationSort,
+				ignoreMemberSort,
+				memberSyntaxSortOrder,
+				allowSeparatedGroups,
+			},
+		] = context.options;
+		const sourceCode = context.sourceCode;
+		let previousDeclaration = null;
+
+		/**
+		 * Gets the used member syntax style.
+		 *
+		 * import "my-module.js" --> none
+		 * import * as myModule from "my-module.js" --> all
+		 * import {myMember} from "my-module.js" --> single
+		 * import {foo, bar} from  "my-module.js" --> multiple
+		 * @param {ASTNode} node the ImportDeclaration node.
+		 * @returns {string} used member parameter style, ["all", "multiple", "single"]
+		 */
+		function usedMemberSyntax(node) {
+			if (node.specifiers.length === 0) {
+				return "none";
+			}
+			if (node.specifiers[0].type === "ImportNamespaceSpecifier") {
+				return "all";
+			}
+			if (node.specifiers.length === 1) {
+				return "single";
+			}
+			return "multiple";
+		}
+
+		/**
+		 * Gets the group by member parameter index for given declaration.
+		 * @param {ASTNode} node the ImportDeclaration node.
+		 * @returns {number} the declaration group by member index.
+		 */
+		function getMemberParameterGroupIndex(node) {
+			return memberSyntaxSortOrder.indexOf(usedMemberSyntax(node));
+		}
+
+		/**
+		 * Gets the local name of the first imported module.
+		 * @param {ASTNode} node the ImportDeclaration node.
+		 * @returns {?string} the local name of the first imported module.
+		 */
+		function getFirstLocalMemberName(node) {
+			if (node.specifiers[0]) {
+				return node.specifiers[0].local.name;
+			}
+			return null;
+		}
+
+		/**
+		 * Calculates number of lines between two nodes. It is assumed that the given `left` node appears before
+		 * the given `right` node in the source code. Lines are counted from the end of the `left` node till the
+		 * start of the `right` node. If the given nodes are on the same line, it returns `0`, same as if they were
+		 * on two consecutive lines.
+		 * @param {ASTNode} left node that appears before the given `right` node.
+		 * @param {ASTNode} right node that appears after the given `left` node.
+		 * @returns {number} number of lines between nodes.
+		 */
+		function getNumberOfLinesBetween(left, right) {
+			return Math.max(right.loc.start.line - left.loc.end.line - 1, 0);
+		}
+
+		return {
+			ImportDeclaration(node) {
+				if (!ignoreDeclarationSort) {
+					if (
+						previousDeclaration &&
+						allowSeparatedGroups &&
+						getNumberOfLinesBetween(previousDeclaration, node) > 0
+					) {
+						// reset declaration sort
+						previousDeclaration = null;
+					}
+
+					if (previousDeclaration) {
+						const currentMemberSyntaxGroupIndex =
+								getMemberParameterGroupIndex(node),
+							previousMemberSyntaxGroupIndex =
+								getMemberParameterGroupIndex(
+									previousDeclaration,
+								);
+						let currentLocalMemberName =
+								getFirstLocalMemberName(node),
+							previousLocalMemberName =
+								getFirstLocalMemberName(previousDeclaration);
+
+						if (ignoreCase) {
+							previousLocalMemberName =
+								previousLocalMemberName &&
+								previousLocalMemberName.toLowerCase();
+							currentLocalMemberName =
+								currentLocalMemberName &&
+								currentLocalMemberName.toLowerCase();
+						}
+
+						/*
+						 * When the current declaration uses a different member syntax,
+						 * then check if the ordering is correct.
+						 * Otherwise, make a default string compare (like rule sort-vars to be consistent) of the first used local member name.
+						 */
+						if (
+							currentMemberSyntaxGroupIndex !==
+							previousMemberSyntaxGroupIndex
+						) {
+							if (
+								currentMemberSyntaxGroupIndex <
+								previousMemberSyntaxGroupIndex
+							) {
+								context.report({
+									node,
+									messageId: "unexpectedSyntaxOrder",
+									data: {
+										syntaxA:
+											memberSyntaxSortOrder[
+												currentMemberSyntaxGroupIndex
+											],
+										syntaxB:
+											memberSyntaxSortOrder[
+												previousMemberSyntaxGroupIndex
+											],
+									},
+								});
+							}
+						} else {
+							if (
+								previousLocalMemberName &&
+								currentLocalMemberName &&
+								currentLocalMemberName < previousLocalMemberName
+							) {
+								context.report({
+									node,
+									messageId: "sortImportsAlphabetically",
+								});
+							}
+						}
+					}
+
+					previousDeclaration = node;
+				}
+
+				if (!ignoreMemberSort) {
+					const importSpecifiers = node.specifiers.filter(
+						specifier => specifier.type === "ImportSpecifier",
+					);
+					const getSortableName = ignoreCase
+						? specifier => specifier.local.name.toLowerCase()
+						: specifier => specifier.local.name;
+					const firstUnsortedIndex = importSpecifiers
+						.map(getSortableName)
+						.findIndex(
+							(name, index, array) => array[index - 1] > name,
+						);
+
+					if (firstUnsortedIndex !== -1) {
+						context.report({
+							node: importSpecifiers[firstUnsortedIndex],
+							messageId: "sortMembersAlphabetically",
+							data: {
+								memberName:
+									importSpecifiers[firstUnsortedIndex].local
+										.name,
+							},
+							fix(fixer) {
+								if (
+									importSpecifiers.some(
+										specifier =>
+											sourceCode.getCommentsBefore(
+												specifier,
+											).length ||
+											sourceCode.getCommentsAfter(
+												specifier,
+											).length,
+									)
+								) {
+									// If there are comments in the ImportSpecifier list, don't rearrange the specifiers.
+									return null;
+								}
+
+								return fixer.replaceTextRange(
+									[
+										importSpecifiers[0].range[0],
+										importSpecifiers.at(-1).range[1],
+									],
+									importSpecifiers
+
+										// Clone the importSpecifiers array to avoid mutating it
+										.slice()
+
+										// Sort the array into the desired order
+										.sort((specifierA, specifierB) => {
+											const aName =
+												getSortableName(specifierA);
+											const bName =
+												getSortableName(specifierB);
+
+											return aName > bName ? 1 : -1;
+										})
+
+										// Build a string out of the sorted list of import specifiers and the text between the originals
+										.reduce(
+											(sourceText, specifier, index) => {
+												const textAfterSpecifier =
+													index ===
+													importSpecifiers.length - 1
+														? ""
+														: sourceCode
+																.getText()
+																.slice(
+																	importSpecifiers[
+																		index
+																	].range[1],
+																	importSpecifiers[
+																		index +
+																			1
+																	].range[0],
+																);
+
+												return (
+													sourceText +
+													sourceCode.getText(
+														specifier,
+													) +
+													textAfterSpecifier
+												);
+											},
+											"",
+										),
+								);
+							},
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/sort-keys.js

@@ -0,0 +1,268 @@
+/**
+ * @fileoverview Rule to require object keys to be sorted
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils"),
+	naturalCompare = require("natural-compare");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Gets the property name of the given `Property` node.
+ *
+ * - If the property's key is an `Identifier` node, this returns the key's name
+ *   whether it's a computed property or not.
+ * - If the property has a static name, this returns the static name.
+ * - Otherwise, this returns null.
+ * @param {ASTNode} node The `Property` node to get.
+ * @returns {string|null} The property name or null.
+ * @private
+ */
+function getPropertyName(node) {
+	const staticName = astUtils.getStaticPropertyName(node);
+
+	if (staticName !== null) {
+		return staticName;
+	}
+
+	return node.key.name || null;
+}
+
+/**
+ * Functions which check that the given 2 names are in specific order.
+ *
+ * Postfix `I` is meant insensitive.
+ * Postfix `N` is meant natural.
+ * @private
+ */
+const isValidOrders = {
+	asc(a, b) {
+		return a <= b;
+	},
+	ascI(a, b) {
+		return a.toLowerCase() <= b.toLowerCase();
+	},
+	ascN(a, b) {
+		return naturalCompare(a, b) <= 0;
+	},
+	ascIN(a, b) {
+		return naturalCompare(a.toLowerCase(), b.toLowerCase()) <= 0;
+	},
+	desc(a, b) {
+		return isValidOrders.asc(b, a);
+	},
+	descI(a, b) {
+		return isValidOrders.ascI(b, a);
+	},
+	descN(a, b) {
+		return isValidOrders.ascN(b, a);
+	},
+	descIN(a, b) {
+		return isValidOrders.ascIN(b, a);
+	},
+};
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			"asc",
+			{
+				allowLineSeparatedGroups: false,
+				caseSensitive: true,
+				ignoreComputedKeys: false,
+				minKeys: 2,
+				natural: false,
+			},
+		],
+
+		docs: {
+			description: "Require object keys to be sorted",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/sort-keys",
+		},
+
+		schema: [
+			{
+				enum: ["asc", "desc"],
+			},
+			{
+				type: "object",
+				properties: {
+					caseSensitive: {
+						type: "boolean",
+					},
+					natural: {
+						type: "boolean",
+					},
+					minKeys: {
+						type: "integer",
+						minimum: 2,
+					},
+					allowLineSeparatedGroups: {
+						type: "boolean",
+					},
+					ignoreComputedKeys: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			sortKeys:
+				"Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'.",
+		},
+	},
+
+	create(context) {
+		const [
+			order,
+			{
+				caseSensitive,
+				natural,
+				minKeys,
+				allowLineSeparatedGroups,
+				ignoreComputedKeys,
+			},
+		] = context.options;
+		const insensitive = !caseSensitive;
+		const isValidOrder =
+			isValidOrders[
+				order + (insensitive ? "I" : "") + (natural ? "N" : "")
+			];
+
+		// The stack to save the previous property's name for each object literals.
+		let stack = null;
+		const sourceCode = context.sourceCode;
+
+		return {
+			ObjectExpression(node) {
+				stack = {
+					upper: stack,
+					prevNode: null,
+					prevBlankLine: false,
+					prevName: null,
+					numKeys: node.properties.length,
+				};
+			},
+
+			"ObjectExpression:exit"() {
+				stack = stack.upper;
+			},
+
+			SpreadElement(node) {
+				if (node.parent.type === "ObjectExpression") {
+					stack.prevName = null;
+				}
+			},
+
+			Property(node) {
+				if (node.parent.type === "ObjectPattern") {
+					return;
+				}
+
+				if (ignoreComputedKeys && node.computed) {
+					stack.prevName = null; // reset sort
+					return;
+				}
+
+				const prevName = stack.prevName;
+				const numKeys = stack.numKeys;
+				const thisName = getPropertyName(node);
+
+				// Get tokens between current node and previous node
+				const tokens =
+					stack.prevNode &&
+					sourceCode.getTokensBetween(stack.prevNode, node, {
+						includeComments: true,
+					});
+
+				let isBlankLineBetweenNodes = stack.prevBlankLine;
+
+				if (tokens) {
+					// check blank line between tokens
+					tokens.forEach((token, index) => {
+						const previousToken = tokens[index - 1];
+
+						if (
+							previousToken &&
+							token.loc.start.line - previousToken.loc.end.line >
+								1
+						) {
+							isBlankLineBetweenNodes = true;
+						}
+					});
+
+					// check blank line between the current node and the last token
+					if (
+						!isBlankLineBetweenNodes &&
+						node.loc.start.line - tokens.at(-1).loc.end.line > 1
+					) {
+						isBlankLineBetweenNodes = true;
+					}
+
+					// check blank line between the first token and the previous node
+					if (
+						!isBlankLineBetweenNodes &&
+						tokens[0].loc.start.line - stack.prevNode.loc.end.line >
+							1
+					) {
+						isBlankLineBetweenNodes = true;
+					}
+				}
+
+				stack.prevNode = node;
+
+				if (thisName !== null) {
+					stack.prevName = thisName;
+				}
+
+				if (allowLineSeparatedGroups && isBlankLineBetweenNodes) {
+					stack.prevBlankLine = thisName === null;
+					return;
+				}
+
+				if (
+					prevName === null ||
+					thisName === null ||
+					numKeys < minKeys
+				) {
+					return;
+				}
+
+				if (!isValidOrder(prevName, thisName)) {
+					context.report({
+						node,
+						loc: node.key.loc,
+						messageId: "sortKeys",
+						data: {
+							thisName,
+							prevName,
+							order,
+							insensitive: insensitive ? "insensitive " : "",
+							natural: natural ? "natural " : "",
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/sort-vars.js

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview Rule to require sorting of variables within a single Variable Declaration block
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				ignoreCase: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Require variables within the same declaration block to be sorted",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/sort-vars",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					ignoreCase: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "code",
+
+		messages: {
+			sortVars:
+				"Variables within the same declaration block should be sorted alphabetically.",
+		},
+	},
+
+	create(context) {
+		const [{ ignoreCase }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		return {
+			VariableDeclaration(node) {
+				const idDeclarations = node.declarations.filter(
+					decl => decl.id.type === "Identifier",
+				);
+				const getSortableName = ignoreCase
+					? decl => decl.id.name.toLowerCase()
+					: decl => decl.id.name;
+				const unfixable = idDeclarations.some(
+					decl => decl.init !== null && decl.init.type !== "Literal",
+				);
+				let fixed = false;
+
+				idDeclarations.slice(1).reduce((memo, decl) => {
+					const lastVariableName = getSortableName(memo),
+						currentVariableName = getSortableName(decl);
+
+					if (currentVariableName < lastVariableName) {
+						context.report({
+							node: decl,
+							messageId: "sortVars",
+							fix(fixer) {
+								if (unfixable || fixed) {
+									return null;
+								}
+								return fixer.replaceTextRange(
+									[
+										idDeclarations[0].range[0],
+										idDeclarations.at(-1).range[1],
+									],
+									idDeclarations
+
+										// Clone the idDeclarations array to avoid mutating it
+										.slice()
+
+										// Sort the array into the desired order
+										.sort((declA, declB) => {
+											const aName =
+												getSortableName(declA);
+											const bName =
+												getSortableName(declB);
+
+											return aName > bName ? 1 : -1;
+										})
+
+										// Build a string out of the sorted list of identifier declarations and the text between the originals
+										.reduce(
+											(sourceText, identifier, index) => {
+												const textAfterIdentifier =
+													index ===
+													idDeclarations.length - 1
+														? ""
+														: sourceCode
+																.getText()
+																.slice(
+																	idDeclarations[
+																		index
+																	].range[1],
+																	idDeclarations[
+																		index +
+																			1
+																	].range[0],
+																);
+
+												return (
+													sourceText +
+													sourceCode.getText(
+														identifier,
+													) +
+													textAfterIdentifier
+												);
+											},
+											"",
+										),
+								);
+							},
+						});
+						fixed = true;
+						return memo;
+					}
+					return decl;
+				}, idDeclarations[0]);
+			},
+		};
+	},
+};