@alexlit/lint-kit 183.1.0 → 183.2.0

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

@@ -1,149 +0,0 @@
-/**
- * @fileoverview Rule to flag use of alert, confirm, prompt
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-	getStaticPropertyName: getPropertyName,
-	getVariableByName,
-	skipChainExpression,
-} = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks if the given name is a prohibited identifier.
- * @param {string} name The name to check
- * @returns {boolean} Whether or not the name is prohibited.
- */
-function isProhibitedIdentifier(name) {
-	return /^(?:alert|confirm|prompt)$/u.test(name);
-}
-
-/**
- * Finds the eslint-scope reference in the given scope.
- * @param {Object} scope The scope to search.
- * @param {ASTNode} node The identifier node.
- * @returns {Reference|null} Returns the found reference or null if none were found.
- */
-function findReference(scope, node) {
-	const references = scope.references.filter(
-		reference =>
-			reference.identifier.range[0] === node.range[0] &&
-			reference.identifier.range[1] === node.range[1],
-	);
-
-	if (references.length === 1) {
-		return references[0];
-	}
-	return null;
-}
-
-/**
- * Checks if the given identifier node is shadowed in the given scope.
- * @param {Object} scope The current scope.
- * @param {string} node The identifier node to check
- * @returns {boolean} Whether or not the name is shadowed.
- */
-function isShadowed(scope, node) {
-	const reference = findReference(scope, node);
-
-	return (
-		reference && reference.resolved && reference.resolved.defs.length > 0
-	);
-}
-
-/**
- * Checks if the given identifier node is a ThisExpression in the global scope or the global window property.
- * @param {Object} scope The current scope.
- * @param {string} node The identifier node to check
- * @returns {boolean} Whether or not the node is a reference to the global object.
- */
-function isGlobalThisReferenceOrGlobalWindow(scope, node) {
-	if (scope.type === "global" && node.type === "ThisExpression") {
-		return true;
-	}
-	if (
-		node.type === "Identifier" &&
-		(node.name === "window" ||
-			(node.name === "globalThis" &&
-				getVariableByName(scope, "globalThis")))
-	) {
-		return !isShadowed(scope, node);
-	}
-
-	return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow the use of `alert`, `confirm`, and `prompt`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-alert",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Unexpected {{name}}.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			CallExpression(node) {
-				const callee = skipChainExpression(node.callee),
-					currentScope = sourceCode.getScope(node);
-
-				// without window.
-				if (callee.type === "Identifier") {
-					const name = callee.name;
-
-					if (
-						!isShadowed(currentScope, callee) &&
-						isProhibitedIdentifier(callee.name)
-					) {
-						context.report({
-							node,
-							messageId: "unexpected",
-							data: { name },
-						});
-					}
-				} else if (
-					callee.type === "MemberExpression" &&
-					isGlobalThisReferenceOrGlobalWindow(
-						currentScope,
-						callee.object,
-					)
-				) {
-					const name = getPropertyName(callee);
-
-					if (isProhibitedIdentifier(name)) {
-						context.report({
-							node,
-							messageId: "unexpected",
-							data: { name },
-						});
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,195 +0,0 @@
-/**
- * @fileoverview Disallow construction of dense arrays using the Array constructor
- * @author Matt DuVall <http://www.mattduvall.com/>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-	getVariableByName,
-	isClosingParenToken,
-	isOpeningParenToken,
-	isStartOfExpressionStatement,
-	needsPrecedingSemicolon,
-} = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow `Array` constructors",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-array-constructor",
-		},
-
-		fixable: "code",
-
-		hasSuggestions: true,
-
-		schema: [],
-
-		messages: {
-			preferLiteral: "The array literal notation [] is preferable.",
-			useLiteral: "Replace with an array literal.",
-			useLiteralAfterSemicolon:
-				"Replace with an array literal, add preceding semicolon.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks if there are comments in Array constructor expressions.
-		 * @param {ASTNode} node A CallExpression or NewExpression node.
-		 * @returns {boolean} True if there are comments, false otherwise.
-		 */
-		function hasCommentsInArrayConstructor(node) {
-			const firstToken = sourceCode.getFirstToken(node);
-			const lastToken = sourceCode.getLastToken(node);
-
-			let lastRelevantToken = sourceCode.getLastToken(node.callee);
-
-			while (
-				lastRelevantToken !== lastToken &&
-				!isOpeningParenToken(lastRelevantToken)
-			) {
-				lastRelevantToken = sourceCode.getTokenAfter(lastRelevantToken);
-			}
-
-			return sourceCode.commentsExistBetween(
-				firstToken,
-				lastRelevantToken,
-			);
-		}
-
-		/**
-		 * Gets the text between the calling parentheses of a CallExpression or NewExpression.
-		 * @param {ASTNode} node A CallExpression or NewExpression node.
-		 * @returns {string} The text between the calling parentheses, or an empty string if there are none.
-		 */
-		function getArgumentsText(node) {
-			const lastToken = sourceCode.getLastToken(node);
-
-			if (!isClosingParenToken(lastToken)) {
-				return "";
-			}
-
-			let firstToken = node.callee;
-
-			do {
-				firstToken = sourceCode.getTokenAfter(firstToken);
-				if (!firstToken || firstToken === lastToken) {
-					return "";
-				}
-			} while (!isOpeningParenToken(firstToken));
-
-			return sourceCode.text.slice(
-				firstToken.range[1],
-				lastToken.range[0],
-			);
-		}
-
-		/**
-		 * Disallow construction of dense arrays using the Array constructor
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {void}
-		 * @private
-		 */
-		function check(node) {
-			if (
-				node.callee.type !== "Identifier" ||
-				node.callee.name !== "Array" ||
-				node.typeArguments ||
-				(node.arguments.length === 1 &&
-					node.arguments[0].type !== "SpreadElement")
-			) {
-				return;
-			}
-
-			const variable = getVariableByName(
-				sourceCode.getScope(node),
-				"Array",
-			);
-
-			/*
-			 * Check if `Array` is a predefined global variable: predefined globals have no declarations,
-			 * meaning that the `identifiers` list of the variable object is empty.
-			 */
-			if (variable && variable.identifiers.length === 0) {
-				const argsText = getArgumentsText(node);
-				let fixText;
-				let messageId;
-
-				const nonSpreadCount = node.arguments.reduce(
-					(count, arg) =>
-						arg.type !== "SpreadElement" ? count + 1 : count,
-					0,
-				);
-
-				const shouldSuggest =
-					node.optional ||
-					(node.arguments.length > 0 && nonSpreadCount < 2) ||
-					hasCommentsInArrayConstructor(node);
-
-				/*
-				 * Check if the suggested change should include a preceding semicolon or not.
-				 * Due to JavaScript's ASI rules, a missing semicolon may be inserted automatically
-				 * before an expression like `Array()` or `new Array()`, but not when the expression
-				 * is changed into an array literal like `[]`.
-				 */
-				if (
-					isStartOfExpressionStatement(node) &&
-					needsPrecedingSemicolon(sourceCode, node)
-				) {
-					fixText = `;[${argsText}]`;
-					messageId = "useLiteralAfterSemicolon";
-				} else {
-					fixText = `[${argsText}]`;
-					messageId = "useLiteral";
-				}
-
-				context.report({
-					node,
-					messageId: "preferLiteral",
-					fix(fixer) {
-						if (shouldSuggest) {
-							return null;
-						}
-
-						return fixer.replaceText(node, fixText);
-					},
-					suggest: [
-						{
-							messageId,
-							fix(fixer) {
-								if (shouldSuggest) {
-									return fixer.replaceText(node, fixText);
-								}
-
-								return null;
-							},
-						},
-					],
-				});
-			}
-		}
-
-		return {
-			CallExpression: check,
-			NewExpression: check,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-async-promise-executor.js

@@ -1,45 +0,0 @@
-/**
- * @fileoverview disallow using an async function as a Promise executor
- * @author Teddy Katz
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description:
-				"Disallow using an async function as a Promise executor",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-async-promise-executor",
-		},
-
-		fixable: null,
-		schema: [],
-		messages: {
-			async: "Promise executor functions should not be async.",
-		},
-	},
-
-	create(context) {
-		return {
-			"NewExpression[callee.name='Promise'][arguments.0.async=true]"(
-				node,
-			) {
-				context.report({
-					node: context.sourceCode.getFirstToken(
-						node.arguments[0],
-						token => token.value === "async",
-					),
-					messageId: "async",
-				});
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-await-in-loop.js

@@ -1,115 +0,0 @@
-/**
- * @fileoverview Rule to disallow uses of await inside of loops.
- * @author Nat Mote (nmote)
- */
-"use strict";
-
-/**
- * Check whether it should stop traversing ancestors at the given node.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if it should stop traversing.
- */
-function isBoundary(node) {
-	const t = node.type;
-
-	return (
-		t === "FunctionDeclaration" ||
-		t === "FunctionExpression" ||
-		t === "ArrowFunctionExpression" ||
-		/*
-		 * Don't report the await expressions on for-await-of loop since it's
-		 * asynchronous iteration intentionally.
-		 */
-		(t === "ForOfStatement" && node.await === true)
-	);
-}
-
-/**
- * Check whether the given node is in loop.
- * @param {ASTNode} node A node to check.
- * @param {ASTNode} parent A parent node to check.
- * @returns {boolean} `true` if the node is in loop.
- */
-function isLooped(node, parent) {
-	switch (parent.type) {
-		case "ForStatement":
-			return (
-				node === parent.test ||
-				node === parent.update ||
-				node === parent.body
-			);
-
-		case "ForOfStatement":
-		case "ForInStatement":
-			return (
-				node === parent.body ||
-				(node === parent.left && node.kind === "await using")
-			);
-
-		case "WhileStatement":
-		case "DoWhileStatement":
-			return node === parent.test || node === parent.body;
-
-		default:
-			return false;
-	}
-}
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow `await` inside of loops",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-await-in-loop",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpectedAwait: "Unexpected `await` inside a loop.",
-		},
-	},
-	create(context) {
-		/**
-		 * Validate an await expression.
-		 * @param {ASTNode} awaitNode An AwaitExpression or ForOfStatement node to validate.
-		 * @returns {void}
-		 */
-		function validate(awaitNode) {
-			if (
-				awaitNode.type === "VariableDeclaration" &&
-				awaitNode.kind !== "await using"
-			) {
-				return;
-			}
-
-			if (awaitNode.type === "ForOfStatement" && !awaitNode.await) {
-				return;
-			}
-
-			let node = awaitNode;
-			let parent = node.parent;
-
-			while (parent && !isBoundary(parent)) {
-				if (isLooped(node, parent)) {
-					context.report({
-						node: awaitNode,
-						messageId: "unexpectedAwait",
-					});
-					return;
-				}
-				node = parent;
-				parent = parent.parent;
-			}
-		}
-
-		return {
-			AwaitExpression: validate,
-			ForOfStatement: validate,
-			VariableDeclaration: validate,
-		};
-	},
-};

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

@@ -1,145 +0,0 @@
-/**
- * @fileoverview Rule to flag bitwise identifiers
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-/*
- *
- * Set of bitwise operators.
- *
- */
-const BITWISE_OPERATORS = [
-	"^",
-	"|",
-	"&",
-	"<<",
-	">>",
-	">>>",
-	"^=",
-	"|=",
-	"&=",
-	"<<=",
-	">>=",
-	">>>=",
-	"~",
-];
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allow: [],
-				int32Hint: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow bitwise operators",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-bitwise",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allow: {
-						type: "array",
-						items: {
-							enum: BITWISE_OPERATORS,
-						},
-						uniqueItems: true,
-					},
-					int32Hint: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpected: "Unexpected use of '{{operator}}'.",
-		},
-	},
-
-	create(context) {
-		const [{ allow: allowed, int32Hint }] = context.options;
-
-		/**
-		 * Reports an unexpected use of a bitwise operator.
-		 * @param {ASTNode} node Node which contains the bitwise operator.
-		 * @returns {void}
-		 */
-		function report(node) {
-			context.report({
-				node,
-				messageId: "unexpected",
-				data: { operator: node.operator },
-			});
-		}
-
-		/**
-		 * Checks if the given node has a bitwise operator.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {boolean} Whether or not the node has a bitwise operator.
-		 */
-		function hasBitwiseOperator(node) {
-			return BITWISE_OPERATORS.includes(node.operator);
-		}
-
-		/**
-		 * Checks if exceptions were provided, e.g. `{ allow: ['~', '|'] }`.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {boolean} Whether or not the node has a bitwise operator.
-		 */
-		function allowedOperator(node) {
-			return allowed.includes(node.operator);
-		}
-
-		/**
-		 * Checks if the given bitwise operator is used for integer typecasting, i.e. "|0"
-		 * @param {ASTNode} node The node to check.
-		 * @returns {boolean} whether the node is used in integer typecasting.
-		 */
-		function isInt32Hint(node) {
-			return (
-				int32Hint &&
-				node.operator === "|" &&
-				node.right &&
-				node.right.type === "Literal" &&
-				node.right.value === 0
-			);
-		}
-
-		/**
-		 * Report if the given node contains a bitwise operator.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {void}
-		 */
-		function checkNodeForBitwiseOperator(node) {
-			if (
-				hasBitwiseOperator(node) &&
-				!allowedOperator(node) &&
-				!isInt32Hint(node)
-			) {
-				report(node);
-			}
-		}
-
-		return {
-			AssignmentExpression: checkNodeForBitwiseOperator,
-			BinaryExpression: checkNodeForBitwiseOperator,
-			UnaryExpression: checkNodeForBitwiseOperator,
-		};
-	},
-};