@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/dot-location.js

@@ -1,138 +0,0 @@
-/**
- * @fileoverview Validates newlines before and after dots
- * @author Greg Cochard
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// 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: "dot-location",
-						url: "https://eslint.style/rules/dot-location",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Enforce consistent newlines before and after dots",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/dot-location",
-		},
-
-		schema: [
-			{
-				enum: ["object", "property"],
-			},
-		],
-
-		fixable: "code",
-
-		messages: {
-			expectedDotAfterObject:
-				"Expected dot to be on same line as object.",
-			expectedDotBeforeProperty:
-				"Expected dot to be on same line as property.",
-		},
-	},
-
-	create(context) {
-		const config = context.options[0];
-
-		// default to onObject if no preference is passed
-		const onObject = config === "object" || !config;
-
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Reports if the dot between object and property is on the correct location.
-		 * @param {ASTNode} node The `MemberExpression` node.
-		 * @returns {void}
-		 */
-		function checkDotLocation(node) {
-			const property = node.property;
-			const dotToken = sourceCode.getTokenBefore(property);
-
-			if (onObject) {
-				// `obj` expression can be parenthesized, but those paren tokens are not a part of the `obj` node.
-				const tokenBeforeDot = sourceCode.getTokenBefore(dotToken);
-
-				if (!astUtils.isTokenOnSameLine(tokenBeforeDot, dotToken)) {
-					context.report({
-						node,
-						loc: dotToken.loc,
-						messageId: "expectedDotAfterObject",
-						*fix(fixer) {
-							if (
-								dotToken.value.startsWith(".") &&
-								astUtils.isDecimalIntegerNumericToken(
-									tokenBeforeDot,
-								)
-							) {
-								yield fixer.insertTextAfter(
-									tokenBeforeDot,
-									` ${dotToken.value}`,
-								);
-							} else {
-								yield fixer.insertTextAfter(
-									tokenBeforeDot,
-									dotToken.value,
-								);
-							}
-							yield fixer.remove(dotToken);
-						},
-					});
-				}
-			} else if (!astUtils.isTokenOnSameLine(dotToken, property)) {
-				context.report({
-					node,
-					loc: dotToken.loc,
-					messageId: "expectedDotBeforeProperty",
-					*fix(fixer) {
-						yield fixer.remove(dotToken);
-						yield fixer.insertTextBefore(property, dotToken.value);
-					},
-				});
-			}
-		}
-
-		/**
-		 * Checks the spacing of the dot within a member expression.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {void}
-		 */
-		function checkNode(node) {
-			if (!node.computed) {
-				checkDotLocation(node);
-			}
-		}
-
-		return {
-			MemberExpression: checkNode,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/dot-notation.js

@@ -1,216 +0,0 @@
-/**
- * @fileoverview Rule to warn about using dot notation instead of square bracket notation when possible.
- * @author Josh Perez
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const keywords = require("./utils/keywords");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const validIdentifier = /^[a-zA-Z_$][\w$]*$/u;
-
-// `null` literal must be handled separately.
-const literalTypesToCheck = new Set(["string", "boolean"]);
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allowKeywords: true,
-				allowPattern: "",
-			},
-		],
-
-		docs: {
-			description: "Enforce dot notation whenever possible",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/dot-notation",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowKeywords: {
-						type: "boolean",
-					},
-					allowPattern: {
-						type: "string",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		fixable: "code",
-
-		messages: {
-			useDot: "[{{key}}] is better written in dot notation.",
-			useBrackets: ".{{key}} is a syntax error.",
-		},
-	},
-
-	create(context) {
-		const [options] = context.options;
-		const allowKeywords = options.allowKeywords;
-		const sourceCode = context.sourceCode;
-
-		let allowPattern;
-
-		if (options.allowPattern) {
-			allowPattern = new RegExp(options.allowPattern, "u");
-		}
-
-		/**
-		 * Check if the property is valid dot notation
-		 * @param {ASTNode} node The dot notation node
-		 * @param {string} value Value which is to be checked
-		 * @returns {void}
-		 */
-		function checkComputedProperty(node, value) {
-			if (
-				validIdentifier.test(value) &&
-				(allowKeywords || !keywords.includes(String(value))) &&
-				!(allowPattern && allowPattern.test(value))
-			) {
-				const formattedValue =
-					node.property.type === "Literal"
-						? JSON.stringify(value)
-						: `\`${value}\``;
-
-				context.report({
-					node: node.property,
-					messageId: "useDot",
-					data: {
-						key: formattedValue,
-					},
-					*fix(fixer) {
-						const leftBracket = sourceCode.getTokenAfter(
-							node.object,
-							astUtils.isOpeningBracketToken,
-						);
-						const rightBracket = sourceCode.getLastToken(node);
-						const nextToken = sourceCode.getTokenAfter(node);
-
-						// Don't perform any fixes if there are comments inside the brackets.
-						if (
-							sourceCode.commentsExistBetween(
-								leftBracket,
-								rightBracket,
-							)
-						) {
-							return;
-						}
-
-						// Replace the brackets by an identifier.
-						if (!node.optional) {
-							yield fixer.insertTextBefore(
-								leftBracket,
-								astUtils.isDecimalInteger(node.object)
-									? " ."
-									: ".",
-							);
-						}
-						yield fixer.replaceTextRange(
-							[leftBracket.range[0], rightBracket.range[1]],
-							value,
-						);
-
-						// Insert a space after the property if it will be connected to the next token.
-						if (
-							nextToken &&
-							rightBracket.range[1] === nextToken.range[0] &&
-							!astUtils.canTokensBeAdjacent(
-								String(value),
-								nextToken,
-							)
-						) {
-							yield fixer.insertTextAfter(node, " ");
-						}
-					},
-				});
-			}
-		}
-
-		return {
-			MemberExpression(node) {
-				if (
-					node.computed &&
-					node.property.type === "Literal" &&
-					(literalTypesToCheck.has(typeof node.property.value) ||
-						astUtils.isNullLiteral(node.property))
-				) {
-					checkComputedProperty(node, node.property.value);
-				}
-				if (
-					node.computed &&
-					astUtils.isStaticTemplateLiteral(node.property)
-				) {
-					checkComputedProperty(
-						node,
-						node.property.quasis[0].value.cooked,
-					);
-				}
-				if (
-					!allowKeywords &&
-					!node.computed &&
-					node.property.type === "Identifier" &&
-					keywords.includes(String(node.property.name))
-				) {
-					context.report({
-						node: node.property,
-						messageId: "useBrackets",
-						data: {
-							key: node.property.name,
-						},
-						*fix(fixer) {
-							const dotToken = sourceCode.getTokenBefore(
-								node.property,
-							);
-
-							// A statement that starts with `let[` is parsed as a destructuring variable declaration, not a MemberExpression.
-							if (
-								node.object.type === "Identifier" &&
-								node.object.name === "let" &&
-								!node.optional
-							) {
-								return;
-							}
-
-							// Don't perform any fixes if there are comments between the dot and the property name.
-							if (
-								sourceCode.commentsExistBetween(
-									dotToken,
-									node.property,
-								)
-							) {
-								return;
-							}
-
-							// Replace the identifier to brackets.
-							if (!node.optional) {
-								yield fixer.remove(dotToken);
-							}
-							yield fixer.replaceText(
-								node.property,
-								`["${node.property.name}"]`,
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/eol-last.js

@@ -1,135 +0,0 @@
-/**
- * @fileoverview Require or disallow newline at the end of files
- * @author Nodeca Team <https://github.com/nodeca>
- * @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: "eol-last",
-						url: "https://eslint.style/rules/eol-last",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Require or disallow newline at the end of files",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/eol-last",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				enum: ["always", "never", "unix", "windows"],
-			},
-		],
-
-		messages: {
-			missing: "Newline required at end of file but not found.",
-			unexpected: "Newline not allowed at end of file.",
-		},
-	},
-	create(context) {
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			Program: function checkBadEOF(node) {
-				const sourceCode = context.sourceCode,
-					src = sourceCode.getText(),
-					lastLine = sourceCode.lines.at(-1),
-					location = {
-						column: lastLine.length,
-						line: sourceCode.lines.length,
-					},
-					LF = "\n",
-					CRLF = `\r${LF}`,
-					endsWithNewline = src.endsWith(LF);
-
-				/*
-				 * Empty source is always valid: No content in file so we don't
-				 * need to lint for a newline on the last line of content.
-				 */
-				if (!src.length) {
-					return;
-				}
-
-				let mode = context.options[0] || "always",
-					appendCRLF = false;
-
-				if (mode === "unix") {
-					// `"unix"` should behave exactly as `"always"`
-					mode = "always";
-				}
-				if (mode === "windows") {
-					// `"windows"` should behave exactly as `"always"`, but append CRLF in the fixer for backwards compatibility
-					mode = "always";
-					appendCRLF = true;
-				}
-				if (mode === "always" && !endsWithNewline) {
-					// File is not newline-terminated, but should be
-					context.report({
-						node,
-						loc: location,
-						messageId: "missing",
-						fix(fixer) {
-							return fixer.insertTextAfterRange(
-								[0, src.length],
-								appendCRLF ? CRLF : LF,
-							);
-						},
-					});
-				} else if (mode === "never" && endsWithNewline) {
-					const secondLastLine = sourceCode.lines.at(-2);
-
-					// File is newline-terminated, but shouldn't be
-					context.report({
-						node,
-						loc: {
-							start: {
-								line: sourceCode.lines.length - 1,
-								column: secondLastLine.length,
-							},
-							end: { line: sourceCode.lines.length, column: 0 },
-						},
-						messageId: "unexpected",
-						fix(fixer) {
-							const finalEOLs = /(?:\r?\n)+$/u,
-								match = finalEOLs.exec(sourceCode.text),
-								start = match.index,
-								end = sourceCode.text.length;
-
-							return fixer.replaceTextRange([start, end], "");
-						},
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,210 +0,0 @@
-/**
- * @fileoverview Rule to flag statements that use != and == instead of !== and ===
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-		hasSuggestions: true,
-
-		docs: {
-			description: "Require the use of `===` and `!==`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/eqeqeq",
-		},
-
-		schema: {
-			anyOf: [
-				{
-					type: "array",
-					items: [
-						{
-							enum: ["always"],
-						},
-						{
-							type: "object",
-							properties: {
-								null: {
-									enum: ["always", "never", "ignore"],
-								},
-							},
-							additionalProperties: false,
-						},
-					],
-					additionalItems: false,
-				},
-				{
-					type: "array",
-					items: [
-						{
-							enum: ["smart", "allow-null"],
-						},
-					],
-					additionalItems: false,
-				},
-			],
-		},
-
-		fixable: "code",
-
-		messages: {
-			unexpected:
-				"Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'.",
-			replaceOperator:
-				"Use '{{expectedOperator}}' instead of '{{actualOperator}}'.",
-		},
-	},
-
-	create(context) {
-		const config = context.options[0] || "always";
-		const options = context.options[1] || {};
-		const sourceCode = context.sourceCode;
-
-		const nullOption =
-			config === "always" ? options.null || "always" : "ignore";
-		const enforceRuleForNull = nullOption === "always";
-		const enforceInverseRuleForNull = nullOption === "never";
-
-		/**
-		 * Checks if an expression is a typeof expression
-		 * @param {ASTNode} node The node to check
-		 * @returns {boolean} if the node is a typeof expression
-		 */
-		function isTypeOf(node) {
-			return (
-				node.type === "UnaryExpression" && node.operator === "typeof"
-			);
-		}
-
-		/**
-		 * Checks if either operand of a binary expression is a typeof operation
-		 * @param {ASTNode} node The node to check
-		 * @returns {boolean} if one of the operands is typeof
-		 * @private
-		 */
-		function isTypeOfBinary(node) {
-			return isTypeOf(node.left) || isTypeOf(node.right);
-		}
-
-		/**
-		 * Checks if operands are literals of the same type (via typeof)
-		 * @param {ASTNode} node The node to check
-		 * @returns {boolean} if operands are of same type
-		 * @private
-		 */
-		function areLiteralsAndSameType(node) {
-			return (
-				node.left.type === "Literal" &&
-				node.right.type === "Literal" &&
-				typeof node.left.value === typeof node.right.value
-			);
-		}
-
-		/**
-		 * Checks if one of the operands is a literal null
-		 * @param {ASTNode} node The node to check
-		 * @returns {boolean} if operands are null
-		 * @private
-		 */
-		function isNullCheck(node) {
-			return (
-				astUtils.isNullLiteral(node.right) ||
-				astUtils.isNullLiteral(node.left)
-			);
-		}
-
-		/**
-		 * Reports a message for this rule.
-		 * @param {ASTNode} node The binary expression node that was checked
-		 * @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==')
-		 * @returns {void}
-		 * @private
-		 */
-		function report(node, expectedOperator) {
-			const operatorToken = sourceCode.getFirstTokenBetween(
-				node.left,
-				node.right,
-				token => token.value === node.operator,
-			);
-
-			const commonReportParams = {
-				node,
-				loc: operatorToken.loc,
-				messageId: "unexpected",
-				data: { expectedOperator, actualOperator: node.operator },
-			};
-
-			if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
-				context.report({
-					...commonReportParams,
-					fix(fixer) {
-						return fixer.replaceText(
-							operatorToken,
-							expectedOperator,
-						);
-					},
-				});
-			} else {
-				context.report({
-					...commonReportParams,
-					suggest: [
-						{
-							messageId: "replaceOperator",
-							data: {
-								expectedOperator,
-								actualOperator: node.operator,
-							},
-							fix: fixer =>
-								fixer.replaceText(
-									operatorToken,
-									expectedOperator,
-								),
-						},
-					],
-				});
-			}
-		}
-
-		return {
-			BinaryExpression(node) {
-				const isNull = isNullCheck(node);
-
-				if (node.operator !== "==" && node.operator !== "!=") {
-					if (enforceInverseRuleForNull && isNull) {
-						report(node, node.operator.slice(0, -1));
-					}
-					return;
-				}
-
-				if (
-					config === "smart" &&
-					(isTypeOfBinary(node) ||
-						areLiteralsAndSameType(node) ||
-						isNull)
-				) {
-					return;
-				}
-
-				if (!enforceRuleForNull && isNull) {
-					return;
-				}
-
-				report(node, `${node.operator}=`);
-			},
-		};
-	},
-};