@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/valid-typeof.js

@@ -1,171 +0,0 @@
-/**
- * @fileoverview Ensures that the results of typeof are compared against a valid string
- * @author Ian Christian Myers
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				requireStringLiterals: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Enforce comparing `typeof` expressions against valid strings",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/valid-typeof",
-		},
-
-		hasSuggestions: true,
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					requireStringLiterals: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			invalidValue: "Invalid typeof comparison value.",
-			notString: "Typeof comparisons should be to string literals.",
-			suggestString: 'Use `"{{type}}"` instead of `{{type}}`.',
-		},
-	},
-
-	create(context) {
-		const VALID_TYPES = new Set([
-				"symbol",
-				"undefined",
-				"object",
-				"boolean",
-				"number",
-				"string",
-				"function",
-				"bigint",
-			]),
-			OPERATORS = new Set(["==", "===", "!=", "!=="]);
-		const sourceCode = context.sourceCode;
-		const [{ requireStringLiterals }] = context.options;
-
-		let globalScope;
-
-		/**
-		 * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
-		 * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
-		 * @param {ASTNode} node `Identifier` node to check.
-		 * @returns {boolean} `true` if the node is a reference to a global variable.
-		 */
-		function isReferenceToGlobalVariable(node) {
-			const variable = globalScope.set.get(node.name);
-
-			return (
-				variable &&
-				variable.defs.length === 0 &&
-				variable.references.some(ref => ref.identifier === node)
-			);
-		}
-
-		/**
-		 * Determines whether a node is a typeof expression.
-		 * @param {ASTNode} node The node
-		 * @returns {boolean} `true` if the node is a typeof expression
-		 */
-		function isTypeofExpression(node) {
-			return (
-				node.type === "UnaryExpression" && node.operator === "typeof"
-			);
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			Program(node) {
-				globalScope = sourceCode.getScope(node);
-			},
-
-			UnaryExpression(node) {
-				if (isTypeofExpression(node)) {
-					const { parent } = node;
-
-					if (
-						parent.type === "BinaryExpression" &&
-						OPERATORS.has(parent.operator)
-					) {
-						const sibling =
-							parent.left === node ? parent.right : parent.left;
-
-						if (
-							sibling.type === "Literal" ||
-							astUtils.isStaticTemplateLiteral(sibling)
-						) {
-							const value =
-								sibling.type === "Literal"
-									? sibling.value
-									: sibling.quasis[0].value.cooked;
-
-							if (!VALID_TYPES.has(value)) {
-								context.report({
-									node: sibling,
-									messageId: "invalidValue",
-								});
-							}
-						} else if (
-							sibling.type === "Identifier" &&
-							sibling.name === "undefined" &&
-							isReferenceToGlobalVariable(sibling)
-						) {
-							context.report({
-								node: sibling,
-								messageId: requireStringLiterals
-									? "notString"
-									: "invalidValue",
-								suggest: [
-									{
-										messageId: "suggestString",
-										data: { type: "undefined" },
-										fix(fixer) {
-											return fixer.replaceText(
-												sibling,
-												'"undefined"',
-											);
-										},
-									},
-								],
-							});
-						} else if (
-							requireStringLiterals &&
-							!isTypeofExpression(sibling)
-						) {
-							context.report({
-								node: sibling,
-								messageId: "notString",
-							});
-						}
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/vars-on-top.js

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Rule to enforce var declarations are only at the top of a function.
- * @author Danny Fritz
- * @author Gyandeep Singh
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Require `var` declarations be placed at the top of their containing scope",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/vars-on-top",
-		},
-
-		schema: [],
-		messages: {
-			top: "All 'var' declarations must be at the top of the function scope.",
-		},
-	},
-
-	create(context) {
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Has AST suggesting a directive.
-		 * @param {ASTNode} node any node
-		 * @returns {boolean} whether the given node structurally represents a directive
-		 */
-		function looksLikeDirective(node) {
-			return (
-				node.type === "ExpressionStatement" &&
-				node.expression.type === "Literal" &&
-				typeof node.expression.value === "string"
-			);
-		}
-
-		/**
-		 * Check to see if its a ES6 import declaration
-		 * @param {ASTNode} node any node
-		 * @returns {boolean} whether the given node represents a import declaration
-		 */
-		function looksLikeImport(node) {
-			return (
-				node.type === "ImportDeclaration" ||
-				node.type === "ImportSpecifier" ||
-				node.type === "ImportDefaultSpecifier" ||
-				node.type === "ImportNamespaceSpecifier"
-			);
-		}
-
-		/**
-		 * Checks whether a given node is a variable declaration or not.
-		 * @param {ASTNode} node any node
-		 * @returns {boolean} `true` if the node is a variable declaration.
-		 */
-		function isVariableDeclaration(node) {
-			return (
-				node.type === "VariableDeclaration" ||
-				(node.type === "ExportNamedDeclaration" &&
-					node.declaration &&
-					node.declaration.type === "VariableDeclaration")
-			);
-		}
-
-		/**
-		 * Checks whether this variable is on top of the block body
-		 * @param {ASTNode} node The node to check
-		 * @param {ASTNode[]} statements collection of ASTNodes for the parent node block
-		 * @returns {boolean} True if var is on top otherwise false
-		 */
-		function isVarOnTop(node, statements) {
-			const l = statements.length;
-			let i = 0;
-
-			// Skip over directives and imports. Static blocks don't have either.
-			if (node.parent.type !== "StaticBlock") {
-				for (; i < l; ++i) {
-					if (
-						!looksLikeDirective(statements[i]) &&
-						!looksLikeImport(statements[i])
-					) {
-						break;
-					}
-				}
-			}
-
-			for (; i < l; ++i) {
-				if (!isVariableDeclaration(statements[i])) {
-					return false;
-				}
-				if (statements[i] === node) {
-					return true;
-				}
-			}
-
-			return false;
-		}
-
-		/**
-		 * Checks whether variable is on top at the global level
-		 * @param {ASTNode} node The node to check
-		 * @param {ASTNode} parent Parent of the node
-		 * @returns {void}
-		 */
-		function globalVarCheck(node, parent) {
-			if (!isVarOnTop(node, parent.body)) {
-				context.report({ node, messageId: "top" });
-			}
-		}
-
-		/**
-		 * Checks whether variable is on top at functional block scope level
-		 * @param {ASTNode} node The node to check
-		 * @returns {void}
-		 */
-		function blockScopeVarCheck(node) {
-			const { parent } = node;
-
-			if (
-				parent.type === "BlockStatement" &&
-				/Function/u.test(parent.parent.type) &&
-				isVarOnTop(node, parent.body)
-			) {
-				return;
-			}
-
-			if (
-				parent.type === "StaticBlock" &&
-				isVarOnTop(node, parent.body)
-			) {
-				return;
-			}
-
-			context.report({ node, messageId: "top" });
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			"VariableDeclaration[kind='var']"(node) {
-				if (node.parent.type === "ExportNamedDeclaration") {
-					globalVarCheck(node.parent, node.parent.parent);
-				} else if (node.parent.type === "Program") {
-					globalVarCheck(node, node.parent);
-				} else {
-					blockScopeVarCheck(node);
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/wrap-iife.js

@@ -1,238 +0,0 @@
-/**
- * @fileoverview Rule to flag when IIFE is not wrapped in parens
- * @author Ilya Volodin
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const eslintUtils = require("@eslint-community/eslint-utils");
-
-//----------------------------------------------------------------------
-// Helpers
-//----------------------------------------------------------------------
-
-/**
- * Check if the given node is callee of a `NewExpression` node
- * @param {ASTNode} node node to check
- * @returns {boolean} True if the node is callee of a `NewExpression` node
- * @private
- */
-function isCalleeOfNewExpression(node) {
-	const maybeCallee =
-		node.parent.type === "ChainExpression" ? node.parent : node;
-
-	return (
-		maybeCallee.parent.type === "NewExpression" &&
-		maybeCallee.parent.callee === maybeCallee
-	);
-}
-
-//------------------------------------------------------------------------------
-// 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: "wrap-iife",
-						url: "https://eslint.style/rules/wrap-iife",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Require parentheses around immediate `function` invocations",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/wrap-iife",
-		},
-
-		schema: [
-			{
-				enum: ["outside", "inside", "any"],
-			},
-			{
-				type: "object",
-				properties: {
-					functionPrototypeMethods: {
-						type: "boolean",
-						default: false,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		fixable: "code",
-		messages: {
-			wrapInvocation:
-				"Wrap an immediate function invocation in parentheses.",
-			wrapExpression: "Wrap only the function expression in parens.",
-			moveInvocation:
-				"Move the invocation into the parens that contain the function.",
-		},
-	},
-
-	create(context) {
-		const style = context.options[0] || "outside";
-		const includeFunctionPrototypeMethods =
-			context.options[1] && context.options[1].functionPrototypeMethods;
-
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {boolean} True if it is wrapped in any parens
-		 * @private
-		 */
-		function isWrappedInAnyParens(node) {
-			return astUtils.isParenthesised(sourceCode, node);
-		}
-
-		/**
-		 * Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {boolean} True if it is wrapped in grouping parens
-		 * @private
-		 */
-		function isWrappedInGroupingParens(node) {
-			return eslintUtils.isParenthesized(1, node, sourceCode);
-		}
-
-		/**
-		 * Get the function node from an IIFE
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {ASTNode} node that is the function expression of the given IIFE, or null if none exist
-		 */
-		function getFunctionNodeFromIIFE(node) {
-			const callee = astUtils.skipChainExpression(node.callee);
-
-			if (callee.type === "FunctionExpression") {
-				return callee;
-			}
-
-			if (
-				includeFunctionPrototypeMethods &&
-				callee.type === "MemberExpression" &&
-				callee.object.type === "FunctionExpression" &&
-				(astUtils.getStaticPropertyName(callee) === "call" ||
-					astUtils.getStaticPropertyName(callee) === "apply")
-			) {
-				return callee.object;
-			}
-
-			return null;
-		}
-
-		return {
-			CallExpression(node) {
-				const innerNode = getFunctionNodeFromIIFE(node);
-
-				if (!innerNode) {
-					return;
-				}
-
-				const isCallExpressionWrapped = isWrappedInAnyParens(node),
-					isFunctionExpressionWrapped =
-						isWrappedInAnyParens(innerNode);
-
-				if (!isCallExpressionWrapped && !isFunctionExpressionWrapped) {
-					context.report({
-						node,
-						messageId: "wrapInvocation",
-						fix(fixer) {
-							const nodeToSurround =
-								style === "inside" ? innerNode : node;
-
-							return fixer.replaceText(
-								nodeToSurround,
-								`(${sourceCode.getText(nodeToSurround)})`,
-							);
-						},
-					});
-				} else if (style === "inside" && !isFunctionExpressionWrapped) {
-					context.report({
-						node,
-						messageId: "wrapExpression",
-						fix(fixer) {
-							// The outer call expression will always be wrapped at this point.
-
-							if (
-								isWrappedInGroupingParens(node) &&
-								!isCalleeOfNewExpression(node)
-							) {
-								/*
-								 * Parenthesize the function expression and remove unnecessary grouping parens around the call expression.
-								 * Replace the range between the end of the function expression and the end of the call expression.
-								 * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
-								 */
-
-								const parenAfter =
-									sourceCode.getTokenAfter(node);
-
-								return fixer.replaceTextRange(
-									[innerNode.range[1], parenAfter.range[1]],
-									`)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`,
-								);
-							}
-
-							/*
-							 * Call expression is wrapped in mandatory parens such as if(), or in necessary grouping parens.
-							 * These parens cannot be removed, so just parenthesize the function expression.
-							 */
-
-							return fixer.replaceText(
-								innerNode,
-								`(${sourceCode.getText(innerNode)})`,
-							);
-						},
-					});
-				} else if (style === "outside" && !isCallExpressionWrapped) {
-					context.report({
-						node,
-						messageId: "moveInvocation",
-						fix(fixer) {
-							/*
-							 * The inner function expression will always be wrapped at this point.
-							 * It's only necessary to replace the range between the end of the function expression
-							 * and the call expression. For example, in `(function(foo) {})(bar)`, the range `)(bar)`
-							 * should get replaced with `(bar))`.
-							 */
-							const parenAfter =
-								sourceCode.getTokenAfter(innerNode);
-
-							return fixer.replaceTextRange(
-								[parenAfter.range[0], node.range[1]],
-								`${sourceCode.getText().slice(parenAfter.range[1], node.range[1])})`,
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/wrap-regex.js

@@ -1,91 +0,0 @@
-/**
- * @fileoverview Rule to flag when regex literals are not wrapped in parens
- * @author Matt DuVall <http://www.mattduvall.com>
- * @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: "wrap-regex",
-						url: "https://eslint.style/rules/wrap-regex",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Require parenthesis around regex literals",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/wrap-regex",
-		},
-
-		schema: [],
-		fixable: "code",
-
-		messages: {
-			requireParens:
-				"Wrap the regexp literal in parens to disambiguate the slash.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			Literal(node) {
-				const token = sourceCode.getFirstToken(node),
-					nodeType = token.type;
-
-				if (nodeType === "RegularExpression") {
-					const beforeToken = sourceCode.getTokenBefore(node);
-					const afterToken = sourceCode.getTokenAfter(node);
-					const { parent } = node;
-
-					if (
-						parent.type === "MemberExpression" &&
-						parent.object === node &&
-						!(
-							beforeToken &&
-							beforeToken.value === "(" &&
-							afterToken &&
-							afterToken.value === ")"
-						)
-					) {
-						context.report({
-							node,
-							messageId: "requireParens",
-							fix: fixer =>
-								fixer.replaceText(
-									node,
-									`(${sourceCode.getText(node)})`,
-								),
-						});
-					}
-				}
-			},
-		};
-	},
-};