@alexlit/lint-kit 166.1.0 → 167.1.0

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

@@ -1,48 +0,0 @@
-/**
- * @fileoverview Rule to flag usage of __iterator__ property
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { getStaticPropertyName } = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow the use of the `__iterator__` property",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-iterator",
-		},
-
-		schema: [],
-
-		messages: {
-			noIterator: "Reserved name '__iterator__'.",
-		},
-	},
-
-	create(context) {
-		return {
-			MemberExpression(node) {
-				if (getStaticPropertyName(node) === "__iterator__") {
-					context.report({
-						node,
-						messageId: "noIterator",
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,78 +0,0 @@
-/**
- * @fileoverview Rule to flag labels that are the same as an identifier
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow labels that share a name with a variable",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-label-var",
-		},
-
-		schema: [],
-
-		messages: {
-			identifierClashWithLabel:
-				"Found identifier with same name as label.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Check if the identifier is present inside current scope
-		 * @param {Object} scope current scope
-		 * @param {string} name To evaluate
-		 * @returns {boolean} True if its present
-		 * @private
-		 */
-		function findIdentifier(scope, name) {
-			return astUtils.getVariableByName(scope, name) !== null;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			LabeledStatement(node) {
-				// Fetch the innermost scope.
-				const scope = sourceCode.getScope(node);
-
-				/*
-				 * Recursively find the identifier walking up the scope, starting
-				 * with the innermost scope.
-				 */
-				if (findIdentifier(scope, node.label.name)) {
-					context.report({
-						node,
-						messageId: "identifierClashWithLabel",
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,156 +0,0 @@
-/**
- * @fileoverview Disallow Labeled Statements
- * @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",
-
-		defaultOptions: [
-			{
-				allowLoop: false,
-				allowSwitch: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow labeled statements",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-labels",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowLoop: {
-						type: "boolean",
-					},
-					allowSwitch: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedLabel: "Unexpected labeled statement.",
-			unexpectedLabelInBreak: "Unexpected label in break statement.",
-			unexpectedLabelInContinue:
-				"Unexpected label in continue statement.",
-		},
-	},
-
-	create(context) {
-		const [{ allowLoop, allowSwitch }] = context.options;
-		let scopeInfo = null;
-
-		/**
-		 * Gets the kind of a given node.
-		 * @param {ASTNode} node A node to get.
-		 * @returns {string} The kind of the node.
-		 */
-		function getBodyKind(node) {
-			if (astUtils.isLoop(node)) {
-				return "loop";
-			}
-			if (node.type === "SwitchStatement") {
-				return "switch";
-			}
-			return "other";
-		}
-
-		/**
-		 * Checks whether the label of a given kind is allowed or not.
-		 * @param {string} kind A kind to check.
-		 * @returns {boolean} `true` if the kind is allowed.
-		 */
-		function isAllowed(kind) {
-			switch (kind) {
-				case "loop":
-					return allowLoop;
-				case "switch":
-					return allowSwitch;
-				default:
-					return false;
-			}
-		}
-
-		/**
-		 * Checks whether a given name is a label of a loop or not.
-		 * @param {string} label A name of a label to check.
-		 * @returns {boolean} `true` if the name is a label of a loop.
-		 */
-		function getKind(label) {
-			let info = scopeInfo;
-
-			while (info) {
-				if (info.label === label) {
-					return info.kind;
-				}
-				info = info.upper;
-			}
-
-			/* c8 ignore next */
-			return "other";
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			LabeledStatement(node) {
-				scopeInfo = {
-					label: node.label.name,
-					kind: getBodyKind(node.body),
-					upper: scopeInfo,
-				};
-			},
-
-			"LabeledStatement:exit"(node) {
-				if (!isAllowed(scopeInfo.kind)) {
-					context.report({
-						node,
-						messageId: "unexpectedLabel",
-					});
-				}
-
-				scopeInfo = scopeInfo.upper;
-			},
-
-			BreakStatement(node) {
-				if (node.label && !isAllowed(getKind(node.label.name))) {
-					context.report({
-						node,
-						messageId: "unexpectedLabelInBreak",
-					});
-				}
-			},
-
-			ContinueStatement(node) {
-				if (node.label && !isAllowed(getKind(node.label.name))) {
-					context.report({
-						node,
-						messageId: "unexpectedLabelInContinue",
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,140 +0,0 @@
-/**
- * @fileoverview Rule to flag blocks with no reason to exist
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow unnecessary nested blocks",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-lone-blocks",
-		},
-
-		schema: [],
-
-		messages: {
-			redundantBlock: "Block is redundant.",
-			redundantNestedBlock: "Nested block is redundant.",
-		},
-	},
-
-	create(context) {
-		// A stack of lone blocks to be checked for block-level bindings
-		const loneBlocks = [];
-		let ruleDef;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Reports a node as invalid.
-		 * @param {ASTNode} node The node to be reported.
-		 * @returns {void}
-		 */
-		function report(node) {
-			const messageId =
-				node.parent.type === "BlockStatement" ||
-				node.parent.type === "StaticBlock"
-					? "redundantNestedBlock"
-					: "redundantBlock";
-
-			context.report({
-				node,
-				messageId,
-			});
-		}
-
-		/**
-		 * Checks for any occurrence of a BlockStatement in a place where lists of statements can appear
-		 * @param {ASTNode} node The node to check
-		 * @returns {boolean} True if the node is a lone block.
-		 */
-		function isLoneBlock(node) {
-			return (
-				node.parent.type === "BlockStatement" ||
-				node.parent.type === "StaticBlock" ||
-				node.parent.type === "Program" ||
-				// Don't report blocks in switch cases if the block is the only statement of the case.
-				(node.parent.type === "SwitchCase" &&
-					!(
-						node.parent.consequent[0] === node &&
-						node.parent.consequent.length === 1
-					))
-			);
-		}
-
-		/**
-		 * Checks the enclosing block of the current node for block-level bindings,
-		 * and "marks it" as valid if any.
-		 * @param {ASTNode} node The current node to check.
-		 * @returns {void}
-		 */
-		function markLoneBlock(node) {
-			if (loneBlocks.length === 0) {
-				return;
-			}
-
-			const block = node.parent;
-
-			if (loneBlocks.at(-1) === block) {
-				loneBlocks.pop();
-			}
-		}
-
-		// Default rule definition: report all lone blocks
-		ruleDef = {
-			BlockStatement(node) {
-				if (isLoneBlock(node)) {
-					report(node);
-				}
-			},
-		};
-
-		// ES6: report blocks without block-level bindings, or that's only child of another block
-		if (context.languageOptions.ecmaVersion >= 2015) {
-			ruleDef = {
-				BlockStatement(node) {
-					if (isLoneBlock(node)) {
-						loneBlocks.push(node);
-					}
-				},
-				"BlockStatement:exit"(node) {
-					if (loneBlocks.length > 0 && loneBlocks.at(-1) === node) {
-						loneBlocks.pop();
-						report(node);
-					} else if (
-						(node.parent.type === "BlockStatement" ||
-							node.parent.type === "StaticBlock") &&
-						node.parent.body.length === 1
-					) {
-						report(node);
-					}
-				},
-			};
-
-			ruleDef.VariableDeclaration = function (node) {
-				if (node.kind !== "var") {
-					markLoneBlock(node);
-				}
-			};
-
-			ruleDef.FunctionDeclaration = function (node) {
-				if (sourceCode.getScope(node).isStrict) {
-					markLoneBlock(node);
-				}
-			};
-
-			ruleDef.ClassDeclaration = markLoneBlock;
-		}
-
-		return ruleDef;
-	},
-};

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

@@ -1,126 +0,0 @@
-/**
- * @fileoverview Rule to disallow if as the only statement in an else block
- * @author Brandon Mills
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow `if` statements as the only statement in `else` blocks",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-lonely-if",
-		},
-
-		schema: [],
-		fixable: "code",
-
-		messages: {
-			unexpectedLonelyIf:
-				"Unexpected if as the only statement in an else block.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			IfStatement(node) {
-				const parent = node.parent,
-					grandparent = parent.parent;
-
-				if (
-					parent &&
-					parent.type === "BlockStatement" &&
-					parent.body.length === 1 &&
-					!astUtils.areBracesNecessary(parent, sourceCode) &&
-					grandparent &&
-					grandparent.type === "IfStatement" &&
-					parent === grandparent.alternate
-				) {
-					context.report({
-						node,
-						messageId: "unexpectedLonelyIf",
-						fix(fixer) {
-							const openingElseCurly =
-								sourceCode.getFirstToken(parent);
-							const closingElseCurly =
-								sourceCode.getLastToken(parent);
-							const elseKeyword =
-								sourceCode.getTokenBefore(openingElseCurly);
-							const tokenAfterElseBlock =
-								sourceCode.getTokenAfter(closingElseCurly);
-							const lastIfToken = sourceCode.getLastToken(
-								node.consequent,
-							);
-							const sourceText = sourceCode.getText();
-
-							if (
-								sourceText
-									.slice(
-										openingElseCurly.range[1],
-										node.range[0],
-									)
-									.trim() ||
-								sourceText
-									.slice(
-										node.range[1],
-										closingElseCurly.range[0],
-									)
-									.trim()
-							) {
-								// Don't fix if there are any non-whitespace characters interfering (e.g. comments)
-								return null;
-							}
-
-							if (
-								node.consequent.type !== "BlockStatement" &&
-								lastIfToken.value !== ";" &&
-								tokenAfterElseBlock &&
-								(node.consequent.loc.end.line ===
-									tokenAfterElseBlock.loc.start.line ||
-									/^[([/+`-]/u.test(
-										tokenAfterElseBlock.value,
-									) ||
-									lastIfToken.value === "++" ||
-									lastIfToken.value === "--")
-							) {
-								/*
-								 * If the `if` statement has no block, and is not followed by a semicolon, make sure that fixing
-								 * the issue would not change semantics due to ASI. If this would happen, don't do a fix.
-								 */
-								return null;
-							}
-
-							return fixer.replaceTextRange(
-								[
-									openingElseCurly.range[0],
-									closingElseCurly.range[1],
-								],
-								(elseKeyword.range[1] ===
-								openingElseCurly.range[0]
-									? " "
-									: "") + sourceCode.getText(node),
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};