@alexlit/lint-kit 183.1.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/sort-imports.js

@@ -1,319 +0,0 @@
-/**
- * @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/packages/config-eslint/node_modules/eslint/lib/rules/sort-keys.js

@@ -1,268 +0,0 @@
-/**
- * @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/packages/config-eslint/node_modules/eslint/lib/rules/sort-vars.js

@@ -1,140 +0,0 @@
-/**
- * @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]);
-			},
-		};
-	},
-};