@alexlit/lint-kit 183.0.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/yield-star-spacing.js

@@ -1,158 +0,0 @@
-/**
- * @fileoverview Rule to check the spacing around the * in yield* expressions.
- * @author Bryan Smith
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Formatting rules are being moved out of ESLint core.",
-			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
-			deprecatedSince: "8.53.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"ESLint Stylistic now maintains deprecated stylistic core rules.",
-					url: "https://eslint.style/guide/migration",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "yield-star-spacing",
-						url: "https://eslint.style/rules/yield-star-spacing",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Require or disallow spacing around the `*` in `yield*` expressions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/yield-star-spacing",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				oneOf: [
-					{
-						enum: ["before", "after", "both", "neither"],
-					},
-					{
-						type: "object",
-						properties: {
-							before: { type: "boolean" },
-							after: { type: "boolean" },
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-		messages: {
-			missingBefore: "Missing space before *.",
-			missingAfter: "Missing space after *.",
-			unexpectedBefore: "Unexpected space before *.",
-			unexpectedAfter: "Unexpected space after *.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		const mode = (function (option) {
-			if (!option || typeof option === "string") {
-				return {
-					before: { before: true, after: false },
-					after: { before: false, after: true },
-					both: { before: true, after: true },
-					neither: { before: false, after: false },
-				}[option || "after"];
-			}
-			return option;
-		})(context.options[0]);
-
-		/**
-		 * Checks the spacing between two tokens before or after the star token.
-		 * @param {string} side Either "before" or "after".
-		 * @param {Token} leftToken `function` keyword token if side is "before", or
-		 *     star token if side is "after".
-		 * @param {Token} rightToken Star token if side is "before", or identifier
-		 *     token if side is "after".
-		 * @returns {void}
-		 */
-		function checkSpacing(side, leftToken, rightToken) {
-			if (
-				sourceCode.isSpaceBetween(leftToken, rightToken) !== mode[side]
-			) {
-				const after = leftToken.value === "*";
-				const spaceRequired = mode[side];
-				const node = after ? leftToken : rightToken;
-				let messageId;
-
-				if (spaceRequired) {
-					messageId =
-						side === "before" ? "missingBefore" : "missingAfter";
-				} else {
-					messageId =
-						side === "before"
-							? "unexpectedBefore"
-							: "unexpectedAfter";
-				}
-
-				context.report({
-					node,
-					messageId,
-					fix(fixer) {
-						if (spaceRequired) {
-							if (after) {
-								return fixer.insertTextAfter(node, " ");
-							}
-							return fixer.insertTextBefore(node, " ");
-						}
-						return fixer.removeRange([
-							leftToken.range[1],
-							rightToken.range[0],
-						]);
-					},
-				});
-			}
-		}
-
-		/**
-		 * Enforces the spacing around the star if node is a yield* expression.
-		 * @param {ASTNode} node A yield expression node.
-		 * @returns {void}
-		 */
-		function checkExpression(node) {
-			if (!node.delegate) {
-				return;
-			}
-
-			const tokens = sourceCode.getFirstTokens(node, 3);
-			const yieldToken = tokens[0];
-			const starToken = tokens[1];
-			const nextToken = tokens[2];
-
-			checkSpacing("before", yieldToken, starToken);
-			checkSpacing("after", starToken, nextToken);
-		}
-
-		return {
-			YieldExpression: checkExpression,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/yoda.js

@@ -1,362 +0,0 @@
-/**
- * @fileoverview Rule to require or disallow yoda comparisons
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//--------------------------------------------------------------------------
-// Requirements
-//--------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//--------------------------------------------------------------------------
-// Helpers
-//--------------------------------------------------------------------------
-
-/**
- * Determines whether an operator is a comparison operator.
- * @param {string} operator The operator to check.
- * @returns {boolean} Whether or not it is a comparison operator.
- */
-function isComparisonOperator(operator) {
-	return /^(?:==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
-}
-
-/**
- * Determines whether an operator is an equality operator.
- * @param {string} operator The operator to check.
- * @returns {boolean} Whether or not it is an equality operator.
- */
-function isEqualityOperator(operator) {
-	return /^(?:==|===)$/u.test(operator);
-}
-
-/**
- * Determines whether an operator is one used in a range test.
- * Allowed operators are `<` and `<=`.
- * @param {string} operator The operator to check.
- * @returns {boolean} Whether the operator is used in range tests.
- */
-function isRangeTestOperator(operator) {
-	return ["<", "<="].includes(operator);
-}
-
-/**
- * Determines whether a non-Literal node is a negative number that should be
- * treated as if it were a single Literal node.
- * @param {ASTNode} node Node to test.
- * @returns {boolean} True if the node is a negative number that looks like a
- *                    real literal and should be treated as such.
- */
-function isNegativeNumericLiteral(node) {
-	return (
-		node.type === "UnaryExpression" &&
-		node.operator === "-" &&
-		node.prefix &&
-		astUtils.isNumericLiteral(node.argument)
-	);
-}
-
-/**
- * Determines whether a non-Literal node should be treated as a single Literal node.
- * @param {ASTNode} node Node to test
- * @returns {boolean} True if the node should be treated as a single Literal node.
- */
-function looksLikeLiteral(node) {
-	return (
-		isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node)
-	);
-}
-
-/**
- * Attempts to derive a Literal node from nodes that are treated like literals.
- * @param {ASTNode} node Node to normalize.
- * @returns {ASTNode} One of the following options.
- *  1. The original node if the node is already a Literal
- *  2. A normalized Literal node with the negative number as the value if the
- *     node represents a negative number literal.
- *  3. A normalized Literal node with the string as the value if the node is
- *     a Template Literal without expression.
- *  4. Otherwise `null`.
- */
-function getNormalizedLiteral(node) {
-	if (node.type === "Literal") {
-		return node;
-	}
-
-	if (isNegativeNumericLiteral(node)) {
-		return {
-			type: "Literal",
-			value: -node.argument.value,
-			raw: `-${node.argument.value}`,
-		};
-	}
-
-	if (astUtils.isStaticTemplateLiteral(node)) {
-		return {
-			type: "Literal",
-			value: node.quasis[0].value.cooked,
-			raw: node.quasis[0].value.raw,
-		};
-	}
-
-	return null;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			"never",
-			{
-				exceptRange: false,
-				onlyEquality: false,
-			},
-		],
-
-		docs: {
-			description: 'Require or disallow "Yoda" conditions',
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/yoda",
-		},
-
-		schema: [
-			{
-				enum: ["always", "never"],
-			},
-			{
-				type: "object",
-				properties: {
-					exceptRange: {
-						type: "boolean",
-					},
-					onlyEquality: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		fixable: "code",
-		messages: {
-			expected:
-				"Expected literal to be on the {{expectedSide}} side of {{operator}}.",
-		},
-	},
-
-	create(context) {
-		const [when, { exceptRange, onlyEquality }] = context.options;
-		const always = when === "always";
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Determines whether node represents a range test.
-		 * A range test is a "between" test like `(0 <= x && x < 1)` or an "outside"
-		 * test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and
-		 * both operators must be `<` or `<=`. Finally, the literal on the left side
-		 * must be less than or equal to the literal on the right side so that the
-		 * test makes any sense.
-		 * @param {ASTNode} node LogicalExpression node to test.
-		 * @returns {boolean} Whether node is a range test.
-		 */
-		function isRangeTest(node) {
-			const left = node.left,
-				right = node.right;
-
-			/**
-			 * Determines whether node is of the form `0 <= x && x < 1`.
-			 * @returns {boolean} Whether node is a "between" range test.
-			 */
-			function isBetweenTest() {
-				if (
-					node.operator === "&&" &&
-					astUtils.isSameReference(left.right, right.left)
-				) {
-					const leftLiteral = getNormalizedLiteral(left.left);
-					const rightLiteral = getNormalizedLiteral(right.right);
-
-					if (leftLiteral === null && rightLiteral === null) {
-						return false;
-					}
-
-					if (rightLiteral === null || leftLiteral === null) {
-						return true;
-					}
-
-					if (leftLiteral.value <= rightLiteral.value) {
-						return true;
-					}
-				}
-				return false;
-			}
-
-			/**
-			 * Determines whether node is of the form `x < 0 || 1 <= x`.
-			 * @returns {boolean} Whether node is an "outside" range test.
-			 */
-			function isOutsideTest() {
-				if (
-					node.operator === "||" &&
-					astUtils.isSameReference(left.left, right.right)
-				) {
-					const leftLiteral = getNormalizedLiteral(left.right);
-					const rightLiteral = getNormalizedLiteral(right.left);
-
-					if (leftLiteral === null && rightLiteral === null) {
-						return false;
-					}
-
-					if (rightLiteral === null || leftLiteral === null) {
-						return true;
-					}
-
-					if (leftLiteral.value <= rightLiteral.value) {
-						return true;
-					}
-				}
-
-				return false;
-			}
-
-			/**
-			 * Determines whether node is wrapped in parentheses.
-			 * @returns {boolean} Whether node is preceded immediately by an open
-			 *                    paren token and followed immediately by a close
-			 *                    paren token.
-			 */
-			function isParenWrapped() {
-				return astUtils.isParenthesised(sourceCode, node);
-			}
-
-			return (
-				node.type === "LogicalExpression" &&
-				left.type === "BinaryExpression" &&
-				right.type === "BinaryExpression" &&
-				isRangeTestOperator(left.operator) &&
-				isRangeTestOperator(right.operator) &&
-				(isBetweenTest() || isOutsideTest()) &&
-				isParenWrapped()
-			);
-		}
-
-		const OPERATOR_FLIP_MAP = {
-			"===": "===",
-			"!==": "!==",
-			"==": "==",
-			"!=": "!=",
-			"<": ">",
-			">": "<",
-			"<=": ">=",
-			">=": "<=",
-		};
-
-		/**
-		 * Returns a string representation of a BinaryExpression node with its sides/operator flipped around.
-		 * @param {ASTNode} node The BinaryExpression node
-		 * @returns {string} A string representation of the node with the sides and operator flipped
-		 */
-		function getFlippedString(node) {
-			const operatorToken = sourceCode.getFirstTokenBetween(
-				node.left,
-				node.right,
-				token => token.value === node.operator,
-			);
-			const lastLeftToken = sourceCode.getTokenBefore(operatorToken);
-			const firstRightToken = sourceCode.getTokenAfter(operatorToken);
-
-			const source = sourceCode.getText();
-
-			const leftText = source.slice(
-				node.range[0],
-				lastLeftToken.range[1],
-			);
-			const textBeforeOperator = source.slice(
-				lastLeftToken.range[1],
-				operatorToken.range[0],
-			);
-			const textAfterOperator = source.slice(
-				operatorToken.range[1],
-				firstRightToken.range[0],
-			);
-			const rightText = source.slice(
-				firstRightToken.range[0],
-				node.range[1],
-			);
-
-			const tokenBefore = sourceCode.getTokenBefore(node);
-			const tokenAfter = sourceCode.getTokenAfter(node);
-			let prefix = "";
-			let suffix = "";
-
-			if (
-				tokenBefore &&
-				tokenBefore.range[1] === node.range[0] &&
-				!astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken)
-			) {
-				prefix = " ";
-			}
-
-			if (
-				tokenAfter &&
-				node.range[1] === tokenAfter.range[0] &&
-				!astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter)
-			) {
-				suffix = " ";
-			}
-
-			return (
-				prefix +
-				rightText +
-				textBeforeOperator +
-				OPERATOR_FLIP_MAP[operatorToken.value] +
-				textAfterOperator +
-				leftText +
-				suffix
-			);
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			BinaryExpression(node) {
-				const expectedLiteral = always ? node.left : node.right;
-				const expectedNonLiteral = always ? node.right : node.left;
-
-				// If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error.
-				if (
-					(expectedNonLiteral.type === "Literal" ||
-						looksLikeLiteral(expectedNonLiteral)) &&
-					!(
-						expectedLiteral.type === "Literal" ||
-						looksLikeLiteral(expectedLiteral)
-					) &&
-					!(!isEqualityOperator(node.operator) && onlyEquality) &&
-					isComparisonOperator(node.operator) &&
-					!(exceptRange && isRangeTest(node.parent))
-				) {
-					context.report({
-						node,
-						messageId: "expected",
-						data: {
-							operator: node.operator,
-							expectedSide: always ? "left" : "right",
-						},
-						fix: fixer =>
-							fixer.replaceText(node, getFlippedString(node)),
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/services/parser-service.js

@@ -1,64 +0,0 @@
-/**
- * @fileoverview ESLint Parser
- * @author Nicholas C. Zakas
- */
-/* eslint class-methods-use-this: off -- Anticipate future constructor arguments. */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Types
-//-----------------------------------------------------------------------------
-
-/** @typedef {import("../linter/vfile.js").VFile} VFile */
-/** @typedef {import("@eslint/core").Language} Language */
-/** @typedef {import("@eslint/core").LanguageOptions} LanguageOptions */
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-/**
- * The parser for ESLint.
- */
-class ParserService {
-	/**
-	 * Parses the given file synchronously.
-	 * @param {VFile} file The file to parse.
-	 * @param {{language:Language,languageOptions:LanguageOptions}} config The configuration to use.
-	 * @returns {Object} An object with the parsed source code or errors.
-	 * @throws {Error} If the parser returns a promise.
-	 */
-	parseSync(file, config) {
-		const { language, languageOptions } = config;
-		const result = language.parse(file, { languageOptions });
-
-		if (typeof result.then === "function") {
-			throw new Error("Unsupported: Language parser returned a promise.");
-		}
-
-		if (result.ok) {
-			return {
-				ok: true,
-				sourceCode: language.createSourceCode(file, result, {
-					languageOptions,
-				}),
-			};
-		}
-
-		// if we made it to here there was an error
-		return {
-			ok: false,
-			errors: result.errors.map(error => ({
-				ruleId: null,
-				fatal: true,
-				severity: 2,
-				message: `Parsing error: ${error.message}`,
-				line: error.line,
-				column: error.column,
-			})),
-		};
-	}
-}
-
-module.exports = { ParserService };

package/packages/config-eslint/node_modules/eslint/lib/services/processor-service.js

@@ -1,100 +0,0 @@
-/**
- * @fileoverview ESLint Processor Service
- * @author Nicholas C. Zakas
- */
-/* eslint class-methods-use-this: off -- Anticipate future constructor arguments. */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const path = require("node:path");
-const { VFile } = require("../linter/vfile.js");
-
-//-----------------------------------------------------------------------------
-// Types
-//-----------------------------------------------------------------------------
-
-/** @typedef {import("../types").Linter.LintMessage} LintMessage */
-/** @typedef {import("../linter/vfile.js").VFile} VFile */
-/** @typedef {import("@eslint/core").Language} Language */
-/** @typedef {import("eslint").Linter.Processor} Processor */
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-/**
- * The service that applies processors to files.
- */
-class ProcessorService {
-	/**
-	 * Preprocesses the given file synchronously.
-	 * @param {VFile} file The file to preprocess.
-	 * @param {{processor:Processor}} config The configuration to use.
-	 * @returns {{ok:boolean, files?: Array<VFile>, errors?: Array<LintMessage>}} An array of preprocessed files or errors.
-	 * @throws {Error} If the preprocessor returns a promise.
-	 */
-	preprocessSync(file, config) {
-		const { processor } = config;
-		let blocks;
-
-		try {
-			blocks = processor.preprocess(file.rawBody, file.path);
-		} catch (ex) {
-			// If the message includes a leading line number, strip it:
-			const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
-
-			return {
-				ok: false,
-				errors: [
-					{
-						ruleId: null,
-						fatal: true,
-						severity: 2,
-						message,
-						line: ex.lineNumber,
-						column: ex.column,
-					},
-				],
-			};
-		}
-
-		if (typeof blocks.then === "function") {
-			throw new Error("Unsupported: Preprocessor returned a promise.");
-		}
-
-		return {
-			ok: true,
-			files: blocks.map((block, i) => {
-				// Legacy behavior: return the block as a string
-				if (typeof block === "string") {
-					return block;
-				}
-
-				const filePath = path.join(file.path, `${i}_${block.filename}`);
-
-				return new VFile(filePath, block.text, {
-					physicalPath: file.physicalPath,
-				});
-			}),
-		};
-	}
-
-	/**
-	 * Postprocesses the given messages synchronously.
-	 * @param {VFile} file The file to postprocess.
-	 * @param {LintMessage[][]} messages The messages to postprocess.
-	 * @param {{processor:Processor}} config The configuration to use.
-	 * @returns {LintMessage[]} The postprocessed messages.
-	 */
-	postprocessSync(file, messages, config) {
-		const { processor } = config;
-
-		return processor.postprocess(messages, file.path);
-	}
-}
-
-module.exports = { ProcessorService };