@alexlit/lint-kit 166.0.1 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-extra-semi.js

@@ -1,167 +0,0 @@
-/**
- * @fileoverview Rule to flag use of unnecessary semicolons
- * @author Nicholas C. Zakas
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const FixTracker = require("./utils/fix-tracker");
-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: "no-extra-semi",
-						url: "https://eslint.style/rules/no-extra-semi",
-					},
-				},
-			],
-		},
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow unnecessary semicolons",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-extra-semi",
-		},
-
-		fixable: "code",
-		schema: [],
-
-		messages: {
-			unexpected: "Unnecessary semicolon.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks if a node or token is fixable.
-		 * A node is fixable if it can be removed without turning a subsequent statement into a directive after fixing other nodes.
-		 * @param {Token} nodeOrToken The node or token to check.
-		 * @returns {boolean} Whether or not the node is fixable.
-		 */
-		function isFixable(nodeOrToken) {
-			const nextToken = sourceCode.getTokenAfter(nodeOrToken);
-
-			if (!nextToken || nextToken.type !== "String") {
-				return true;
-			}
-			const stringNode = sourceCode.getNodeByRangeIndex(
-				nextToken.range[0],
-			);
-
-			return !astUtils.isTopLevelExpressionStatement(stringNode.parent);
-		}
-
-		/**
-		 * Reports an unnecessary semicolon error.
-		 * @param {Node|Token} nodeOrToken A node or a token to be reported.
-		 * @returns {void}
-		 */
-		function report(nodeOrToken) {
-			context.report({
-				node: nodeOrToken,
-				messageId: "unexpected",
-				fix: isFixable(nodeOrToken)
-					? fixer =>
-							/*
-							 * Expand the replacement range to include the surrounding
-							 * tokens to avoid conflicting with semi.
-							 * https://github.com/eslint/eslint/issues/7928
-							 */
-							new FixTracker(fixer, context.sourceCode)
-								.retainSurroundingTokens(nodeOrToken)
-								.remove(nodeOrToken)
-					: null,
-			});
-		}
-
-		/**
-		 * Checks for a part of a class body.
-		 * This checks tokens from a specified token to a next MethodDefinition or the end of class body.
-		 * @param {Token} firstToken The first token to check.
-		 * @returns {void}
-		 */
-		function checkForPartOfClassBody(firstToken) {
-			for (
-				let token = firstToken;
-				token.type === "Punctuator" &&
-				!astUtils.isClosingBraceToken(token);
-				token = sourceCode.getTokenAfter(token)
-			) {
-				if (astUtils.isSemicolonToken(token)) {
-					report(token);
-				}
-			}
-		}
-
-		return {
-			/**
-			 * Reports this empty statement, except if the parent node is a loop.
-			 * @param {Node} node A EmptyStatement node to be reported.
-			 * @returns {void}
-			 */
-			EmptyStatement(node) {
-				const parent = node.parent,
-					allowedParentTypes = [
-						"ForStatement",
-						"ForInStatement",
-						"ForOfStatement",
-						"WhileStatement",
-						"DoWhileStatement",
-						"IfStatement",
-						"LabeledStatement",
-						"WithStatement",
-					];
-
-				if (!allowedParentTypes.includes(parent.type)) {
-					report(node);
-				}
-			},
-
-			/**
-			 * Checks tokens from the head of this class body to the first MethodDefinition or the end of this class body.
-			 * @param {Node} node A ClassBody node to check.
-			 * @returns {void}
-			 */
-			ClassBody(node) {
-				checkForPartOfClassBody(sourceCode.getFirstToken(node, 1)); // 0 is `{`.
-			},
-
-			/**
-			 * Checks tokens from this MethodDefinition to the next MethodDefinition or the end of this class body.
-			 * @param {Node} node A MethodDefinition node of the start point.
-			 * @returns {void}
-			 */
-			"MethodDefinition, PropertyDefinition, StaticBlock"(node) {
-				checkForPartOfClassBody(sourceCode.getTokenAfter(node));
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-fallthrough.js

@@ -1,260 +0,0 @@
-/**
- * @fileoverview Rule to flag fall-through cases in switch statements.
- * @author Matt DuVall <http://mattduvall.com/>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { directivesPattern } = require("../shared/directives");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
-
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive.
- * @param {string} comment The comment string to check.
- * @param {RegExp} fallthroughCommentPattern The regular expression used for checking for fallthrough comments.
- * @returns {boolean} `true` if the comment string is truly a fallthrough comment.
- */
-function isFallThroughComment(comment, fallthroughCommentPattern) {
-	return (
-		fallthroughCommentPattern.test(comment) &&
-		!directivesPattern.test(comment.trim())
-	);
-}
-
-/**
- * Checks whether or not a given case has a fallthrough comment.
- * @param {ASTNode} caseWhichFallsThrough SwitchCase node which falls through.
- * @param {ASTNode} subsequentCase The case after caseWhichFallsThrough.
- * @param {RuleContext} context A rule context which stores comments.
- * @param {RegExp} fallthroughCommentPattern A pattern to match comment to.
- * @returns {null | object} the comment if the case has a valid fallthrough comment, otherwise null
- */
-function getFallthroughComment(
-	caseWhichFallsThrough,
-	subsequentCase,
-	context,
-	fallthroughCommentPattern,
-) {
-	const sourceCode = context.sourceCode;
-
-	if (
-		caseWhichFallsThrough.consequent.length === 1 &&
-		caseWhichFallsThrough.consequent[0].type === "BlockStatement"
-	) {
-		const trailingCloseBrace = sourceCode.getLastToken(
-			caseWhichFallsThrough.consequent[0],
-		);
-		const commentInBlock = sourceCode
-			.getCommentsBefore(trailingCloseBrace)
-			.pop();
-
-		if (
-			commentInBlock &&
-			isFallThroughComment(
-				commentInBlock.value,
-				fallthroughCommentPattern,
-			)
-		) {
-			return commentInBlock;
-		}
-	}
-
-	const comment = sourceCode.getCommentsBefore(subsequentCase).pop();
-
-	if (
-		comment &&
-		isFallThroughComment(comment.value, fallthroughCommentPattern)
-	) {
-		return comment;
-	}
-
-	return null;
-}
-
-/**
- * Checks whether a node and a token are separated by blank lines
- * @param {ASTNode} node The node to check
- * @param {Token} token The token to compare against
- * @returns {boolean} `true` if there are blank lines between node and token
- */
-function hasBlankLinesBetween(node, token) {
-	return token.loc.start.line > node.loc.end.line + 1;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				allowEmptyCase: false,
-				reportUnusedFallthroughComment: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow fallthrough of `case` statements",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-fallthrough",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					commentPattern: {
-						type: "string",
-					},
-					allowEmptyCase: {
-						type: "boolean",
-					},
-					reportUnusedFallthroughComment: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			unusedFallthroughComment:
-				"Found a comment that would permit fallthrough, but case cannot fall through.",
-			case: "Expected a 'break' statement before 'case'.",
-			default: "Expected a 'break' statement before 'default'.",
-		},
-	},
-
-	create(context) {
-		const codePathSegments = [];
-		let currentCodePathSegments = new Set();
-		const sourceCode = context.sourceCode;
-		const [
-			{ allowEmptyCase, commentPattern, reportUnusedFallthroughComment },
-		] = context.options;
-		const fallthroughCommentPattern = commentPattern
-			? new RegExp(commentPattern, "u")
-			: DEFAULT_FALLTHROUGH_COMMENT;
-
-		/*
-		 * We need to use leading comments of the next SwitchCase node because
-		 * trailing comments is wrong if semicolons are omitted.
-		 */
-		let previousCase = null;
-
-		return {
-			onCodePathStart() {
-				codePathSegments.push(currentCodePathSegments);
-				currentCodePathSegments = new Set();
-			},
-
-			onCodePathEnd() {
-				currentCodePathSegments = codePathSegments.pop();
-			},
-
-			onUnreachableCodePathSegmentStart(segment) {
-				currentCodePathSegments.add(segment);
-			},
-
-			onUnreachableCodePathSegmentEnd(segment) {
-				currentCodePathSegments.delete(segment);
-			},
-
-			onCodePathSegmentStart(segment) {
-				currentCodePathSegments.add(segment);
-			},
-
-			onCodePathSegmentEnd(segment) {
-				currentCodePathSegments.delete(segment);
-			},
-
-			SwitchCase(node) {
-				/*
-				 * Checks whether or not there is a fallthrough comment.
-				 * And reports the previous fallthrough node if that does not exist.
-				 */
-
-				if (previousCase && previousCase.node.parent === node.parent) {
-					const previousCaseFallthroughComment =
-						getFallthroughComment(
-							previousCase.node,
-							node,
-							context,
-							fallthroughCommentPattern,
-						);
-
-					if (
-						previousCase.isFallthrough &&
-						!previousCaseFallthroughComment
-					) {
-						context.report({
-							messageId: node.test ? "case" : "default",
-							node,
-						});
-					} else if (
-						reportUnusedFallthroughComment &&
-						!previousCase.isSwitchExitReachable &&
-						previousCaseFallthroughComment
-					) {
-						context.report({
-							messageId: "unusedFallthroughComment",
-							node: previousCaseFallthroughComment,
-						});
-					}
-				}
-				previousCase = null;
-			},
-
-			"SwitchCase:exit"(node) {
-				const nextToken = sourceCode.getTokenAfter(node);
-
-				/*
-				 * `reachable` meant fall through because statements preceded by
-				 * `break`, `return`, or `throw` are unreachable.
-				 * And allows empty cases and the last case.
-				 */
-				const isSwitchExitReachable = isAnySegmentReachable(
-					currentCodePathSegments,
-				);
-				const isFallthrough =
-					isSwitchExitReachable &&
-					(node.consequent.length > 0 ||
-						(!allowEmptyCase &&
-							hasBlankLinesBetween(node, nextToken))) &&
-					node.parent.cases.at(-1) !== node;
-
-				previousCase = {
-					node,
-					isSwitchExitReachable,
-					isFallthrough,
-				};
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-floating-decimal.js

@@ -1,99 +0,0 @@
-/**
- * @fileoverview Rule to flag use of a leading/trailing decimal point in a numeric literal
- * @author James Allardice
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-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: "no-floating-decimal",
-						url: "https://eslint.style/rules/no-floating-decimal",
-					},
-				},
-			],
-		},
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow leading or trailing decimal points in numeric literals",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-floating-decimal",
-		},
-
-		schema: [],
-		fixable: "code",
-		messages: {
-			leading: "A leading decimal point can be confused with a dot.",
-			trailing: "A trailing decimal point can be confused with a dot.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			Literal(node) {
-				if (typeof node.value === "number") {
-					if (node.raw.startsWith(".")) {
-						context.report({
-							node,
-							messageId: "leading",
-							fix(fixer) {
-								const tokenBefore =
-									sourceCode.getTokenBefore(node);
-								const needsSpaceBefore =
-									tokenBefore &&
-									tokenBefore.range[1] === node.range[0] &&
-									!astUtils.canTokensBeAdjacent(
-										tokenBefore,
-										`0${node.raw}`,
-									);
-
-								return fixer.insertTextBefore(
-									node,
-									needsSpaceBefore ? " 0" : "0",
-								);
-							},
-						});
-					}
-					if (node.raw.indexOf(".") === node.raw.length - 1) {
-						context.report({
-							node,
-							messageId: "trailing",
-							fix: fixer => fixer.insertTextAfter(node, "0"),
-						});
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-func-assign.js

@@ -1,77 +0,0 @@
-/**
- * @fileoverview Rule to flag use of function declaration identifiers as variables.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow reassigning `function` declarations",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-func-assign",
-		},
-
-		schema: [],
-
-		messages: {
-			isAFunction: "'{{name}}' is a function.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Reports a reference if is non initializer and writable.
-		 * @param {References} references Collection of reference to check.
-		 * @returns {void}
-		 */
-		function checkReference(references) {
-			astUtils.getModifyingReferences(references).forEach(reference => {
-				context.report({
-					node: reference.identifier,
-					messageId: "isAFunction",
-					data: {
-						name: reference.identifier.name,
-					},
-				});
-			});
-		}
-
-		/**
-		 * Finds and reports references that are non initializer and writable.
-		 * @param {Variable} variable A variable to check.
-		 * @returns {void}
-		 */
-		function checkVariable(variable) {
-			if (variable.defs[0].type === "FunctionName") {
-				checkReference(variable.references);
-			}
-		}
-
-		/**
-		 * Checks parameters of a given function node.
-		 * @param {ASTNode} node A function node to check.
-		 * @returns {void}
-		 */
-		function checkForFunction(node) {
-			sourceCode.getDeclaredVariables(node).forEach(checkVariable);
-		}
-
-		return {
-			FunctionDeclaration: checkForFunction,
-			FunctionExpression: checkForFunction,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-global-assign.js

@@ -1,101 +0,0 @@
-/**
- * @fileoverview Rule to disallow assignments to native objects or read-only global variables
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [{ exceptions: [] }],
-
-		docs: {
-			description:
-				"Disallow assignments to native objects or read-only global variables",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-global-assign",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					exceptions: {
-						type: "array",
-						items: { type: "string" },
-						uniqueItems: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			globalShouldNotBeModified:
-				"Read-only global '{{name}}' should not be modified.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ exceptions }] = context.options;
-
-		/**
-		 * Reports write references.
-		 * @param {Reference} reference A reference to check.
-		 * @param {number} index The index of the reference in the references.
-		 * @param {Reference[]} references The array that the reference belongs to.
-		 * @returns {void}
-		 */
-		function checkReference(reference, index, references) {
-			const identifier = reference.identifier;
-
-			if (
-				reference.init === false &&
-				reference.isWrite() &&
-				/*
-				 * Destructuring assignments can have multiple default value,
-				 * so possibly there are multiple writeable references for the same identifier.
-				 */
-				(index === 0 || references[index - 1].identifier !== identifier)
-			) {
-				context.report({
-					node: identifier,
-					messageId: "globalShouldNotBeModified",
-					data: {
-						name: identifier.name,
-					},
-				});
-			}
-		}
-
-		/**
-		 * Reports write references if a given variable is read-only builtin.
-		 * @param {Variable} variable A variable to check.
-		 * @returns {void}
-		 */
-		function checkVariable(variable) {
-			if (
-				variable.writeable === false &&
-				!exceptions.includes(variable.name)
-			) {
-				variable.references.forEach(checkReference);
-			}
-		}
-
-		return {
-			Program(node) {
-				const globalScope = sourceCode.getScope(node);
-
-				globalScope.variables.forEach(checkVariable);
-			},
-		};
-	},
-};