@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/template-tag-spacing.js

@@ -1,121 +0,0 @@
-/**
- * @fileoverview Rule to check spacing between template tags and their literals
- * @author Jonathan Wilsson
- * @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: "template-tag-spacing",
-						url: "https://eslint.style/rules/template-tag-spacing",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Require or disallow spacing between template tags and their literals",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/template-tag-spacing",
-		},
-
-		fixable: "whitespace",
-
-		schema: [{ enum: ["always", "never"] }],
-		messages: {
-			unexpected:
-				"Unexpected space between template tag and template literal.",
-			missing: "Missing space between template tag and template literal.",
-		},
-	},
-
-	create(context) {
-		const never = context.options[0] !== "always";
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Check if a space is present between a template tag and its literal
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function checkSpacing(node) {
-			const tagToken = sourceCode.getTokenBefore(node.quasi);
-			const literalToken = sourceCode.getFirstToken(node.quasi);
-			const hasWhitespace = sourceCode.isSpaceBetweenTokens(
-				tagToken,
-				literalToken,
-			);
-
-			if (never && hasWhitespace) {
-				context.report({
-					node,
-					loc: {
-						start: tagToken.loc.end,
-						end: literalToken.loc.start,
-					},
-					messageId: "unexpected",
-					fix(fixer) {
-						const comments = sourceCode.getCommentsBefore(
-							node.quasi,
-						);
-
-						// Don't fix anything if there's a single line comment after the template tag
-						if (comments.some(comment => comment.type === "Line")) {
-							return null;
-						}
-
-						return fixer.replaceTextRange(
-							[tagToken.range[1], literalToken.range[0]],
-							comments.reduce(
-								(text, comment) =>
-									text + sourceCode.getText(comment),
-								"",
-							),
-						);
-					},
-				});
-			} else if (!never && !hasWhitespace) {
-				context.report({
-					node,
-					loc: {
-						start: node.loc.start,
-						end: literalToken.loc.start,
-					},
-					messageId: "missing",
-					fix(fixer) {
-						return fixer.insertTextAfter(tagToken, " ");
-					},
-				});
-			}
-		}
-
-		return {
-			TaggedTemplateExpression: checkSpacing,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/unicode-bom.js

@@ -1,73 +0,0 @@
-/**
- * @fileoverview Require or disallow Unicode BOM
- * @author Andrew Johnston <https://github.com/ehjay>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "layout",
-
-		defaultOptions: ["never"],
-
-		docs: {
-			description: "Require or disallow Unicode byte order mark (BOM)",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/unicode-bom",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				enum: ["always", "never"],
-			},
-		],
-		messages: {
-			expected: "Expected Unicode BOM (Byte Order Mark).",
-			unexpected: "Unexpected Unicode BOM (Byte Order Mark).",
-		},
-	},
-
-	create(context) {
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			Program: function checkUnicodeBOM(node) {
-				const sourceCode = context.sourceCode,
-					location = { column: 0, line: 1 };
-				const [requireBOM] = context.options;
-
-				if (!sourceCode.hasBOM && requireBOM === "always") {
-					context.report({
-						node,
-						loc: location,
-						messageId: "expected",
-						fix(fixer) {
-							return fixer.insertTextBeforeRange(
-								[0, 1],
-								"\uFEFF",
-							);
-						},
-					});
-				} else if (sourceCode.hasBOM && requireBOM === "never") {
-					context.report({
-						node,
-						loc: location,
-						messageId: "unexpected",
-						fix(fixer) {
-							return fixer.removeRange([-1, 0]);
-						},
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/use-isnan.js

@@ -1,268 +0,0 @@
-/**
- * @fileoverview Rule to flag comparisons to the value NaN
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines if the given node is a NaN `Identifier` node.
- * @param {ASTNode|null} node The node to check.
- * @returns {boolean} `true` if the node is 'NaN' identifier.
- */
-function isNaNIdentifier(node) {
-	if (!node) {
-		return false;
-	}
-
-	const nodeToCheck =
-		node.type === "SequenceExpression" ? node.expressions.at(-1) : node;
-
-	return (
-		astUtils.isSpecificId(nodeToCheck, "NaN") ||
-		astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN")
-	);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		hasSuggestions: true,
-		type: "problem",
-
-		docs: {
-			description: "Require calls to `isNaN()` when checking for `NaN`",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/use-isnan",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					enforceForSwitchCase: {
-						type: "boolean",
-					},
-					enforceForIndexOf: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		defaultOptions: [
-			{
-				enforceForIndexOf: false,
-				enforceForSwitchCase: true,
-			},
-		],
-
-		messages: {
-			comparisonWithNaN: "Use the isNaN function to compare with NaN.",
-			switchNaN:
-				"'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",
-			caseNaN:
-				"'case NaN' can never match. Use Number.isNaN before the switch.",
-			indexOfNaN:
-				"Array prototype method '{{ methodName }}' cannot find NaN.",
-			replaceWithIsNaN: "Replace with Number.isNaN.",
-			replaceWithCastingAndIsNaN:
-				"Replace with Number.isNaN and cast to a Number.",
-			replaceWithFindIndex:
-				"Replace with Array.prototype.{{ methodName }}.",
-		},
-	},
-
-	create(context) {
-		const [{ enforceForIndexOf, enforceForSwitchCase }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		const fixableOperators = new Set(["==", "===", "!=", "!=="]);
-		const castableOperators = new Set(["==", "!="]);
-
-		/**
-		 * Get a fixer for a binary expression that compares to NaN.
-		 * @param  {ASTNode} node The node to fix.
-		 * @param {function(string): string} wrapValue A function that wraps the compared value with a fix.
-		 * @returns {function(Fixer): Fix} The fixer function.
-		 */
-		function getBinaryExpressionFixer(node, wrapValue) {
-			return fixer => {
-				const comparedValue = isNaNIdentifier(node.left)
-					? node.right
-					: node.left;
-				const shouldWrap = comparedValue.type === "SequenceExpression";
-				const shouldNegate = node.operator[0] === "!";
-
-				const negation = shouldNegate ? "!" : "";
-				let comparedValueText = sourceCode.getText(comparedValue);
-
-				if (shouldWrap) {
-					comparedValueText = `(${comparedValueText})`;
-				}
-
-				const fixedValue = wrapValue(comparedValueText);
-
-				return fixer.replaceText(node, `${negation}${fixedValue}`);
-			};
-		}
-
-		/**
-		 * Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {void}
-		 */
-		function checkBinaryExpression(node) {
-			if (
-				/^(?:[<>]|[!=]=)=?$/u.test(node.operator) &&
-				(isNaNIdentifier(node.left) || isNaNIdentifier(node.right))
-			) {
-				const suggestedFixes = [];
-				const NaNNode = isNaNIdentifier(node.left)
-					? node.left
-					: node.right;
-
-				const isSequenceExpression =
-					NaNNode.type === "SequenceExpression";
-				const isSuggestable =
-					fixableOperators.has(node.operator) &&
-					!isSequenceExpression;
-				const isCastable = castableOperators.has(node.operator);
-
-				if (isSuggestable) {
-					suggestedFixes.push({
-						messageId: "replaceWithIsNaN",
-						fix: getBinaryExpressionFixer(
-							node,
-							value => `Number.isNaN(${value})`,
-						),
-					});
-
-					if (isCastable) {
-						suggestedFixes.push({
-							messageId: "replaceWithCastingAndIsNaN",
-							fix: getBinaryExpressionFixer(
-								node,
-								value => `Number.isNaN(Number(${value}))`,
-							),
-						});
-					}
-				}
-
-				context.report({
-					node,
-					messageId: "comparisonWithNaN",
-					suggest: suggestedFixes,
-				});
-			}
-		}
-
-		/**
-		 * Checks the discriminant and all case clauses of the given `SwitchStatement` node for `switch(NaN)` and `case NaN:`
-		 * @param {ASTNode} node The node to check.
-		 * @returns {void}
-		 */
-		function checkSwitchStatement(node) {
-			if (isNaNIdentifier(node.discriminant)) {
-				context.report({ node, messageId: "switchNaN" });
-			}
-
-			for (const switchCase of node.cases) {
-				if (isNaNIdentifier(switchCase.test)) {
-					context.report({ node: switchCase, messageId: "caseNaN" });
-				}
-			}
-		}
-
-		/**
-		 * Checks the given `CallExpression` node for `.indexOf(NaN)` and `.lastIndexOf(NaN)`.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {void}
-		 */
-		function checkCallExpression(node) {
-			const callee = astUtils.skipChainExpression(node.callee);
-
-			if (callee.type === "MemberExpression") {
-				const methodName = astUtils.getStaticPropertyName(callee);
-
-				if (
-					(methodName === "indexOf" ||
-						methodName === "lastIndexOf") &&
-					node.arguments.length <= 2 &&
-					isNaNIdentifier(node.arguments[0])
-				) {
-					/*
-					 * To retain side effects, it's essential to address `NaN` beforehand, which
-					 * is not possible with fixes like `arr.findIndex(Number.isNaN)`.
-					 */
-					const isSuggestable =
-						node.arguments[0].type !== "SequenceExpression" &&
-						!node.arguments[1];
-					const suggestedFixes = [];
-
-					if (isSuggestable) {
-						const shouldWrap = callee.computed;
-						const findIndexMethod =
-							methodName === "indexOf"
-								? "findIndex"
-								: "findLastIndex";
-						const propertyName = shouldWrap
-							? `"${findIndexMethod}"`
-							: findIndexMethod;
-
-						suggestedFixes.push({
-							messageId: "replaceWithFindIndex",
-							data: { methodName: findIndexMethod },
-							fix: fixer => [
-								fixer.replaceText(
-									callee.property,
-									propertyName,
-								),
-								fixer.replaceText(
-									node.arguments[0],
-									"Number.isNaN",
-								),
-							],
-						});
-					}
-
-					context.report({
-						node,
-						messageId: "indexOfNaN",
-						data: { methodName },
-						suggest: suggestedFixes,
-					});
-				}
-			}
-		}
-
-		const listeners = {
-			BinaryExpression: checkBinaryExpression,
-		};
-
-		if (enforceForSwitchCase) {
-			listeners.SwitchStatement = checkSwitchStatement;
-		}
-
-		if (enforceForIndexOf) {
-			listeners.CallExpression = checkCallExpression;
-		}
-
-		return listeners;
-	},
-};