@alexlit/lint-kit 183.1.0 → 183.3.0

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

@@ -1,74 +0,0 @@
-/**
- * @fileoverview disallow use of the Buffer() constructor
- * @author Teddy Katz
- * @deprecated in ESLint v7.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Node.js rules were moved out of ESLint core.",
-			url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
-			deprecatedSince: "7.0.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"eslint-plugin-n now maintains deprecated Node.js-related rules.",
-					plugin: {
-						name: "eslint-plugin-n",
-						url: "https://github.com/eslint-community/eslint-plugin-n",
-					},
-					rule: {
-						name: "no-deprecated-api",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-deprecated-api.md",
-					},
-				},
-			],
-		},
-
-		type: "problem",
-
-		docs: {
-			description: "Disallow use of the `Buffer()` constructor",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-buffer-constructor",
-		},
-
-		schema: [],
-
-		messages: {
-			deprecated:
-				"{{expr}} is deprecated. Use Buffer.from(), Buffer.alloc(), or Buffer.allocUnsafe() instead.",
-		},
-	},
-
-	create(context) {
-		//----------------------------------------------------------------------
-		// Public
-		//----------------------------------------------------------------------
-
-		return {
-			"CallExpression[callee.name='Buffer'], NewExpression[callee.name='Buffer']"(
-				node,
-			) {
-				context.report({
-					node,
-					messageId: "deprecated",
-					data: {
-						expr:
-							node.type === "CallExpression"
-								? "Buffer()"
-								: "new Buffer()",
-					},
-				});
-			},
-		};
-	},
-};

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

@@ -1,52 +0,0 @@
-/**
- * @fileoverview Rule to flag use of arguments.callee and arguments.caller.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow the use of `arguments.caller` or `arguments.callee`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-caller",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Avoid arguments.{{prop}}.",
-		},
-	},
-
-	create(context) {
-		return {
-			MemberExpression(node) {
-				const objectName = node.object.name,
-					propertyName = node.property.name;
-
-				if (
-					objectName === "arguments" &&
-					!node.computed &&
-					propertyName &&
-					propertyName.match(/^calle[er]$/u)
-				) {
-					context.report({
-						node,
-						messageId: "unexpected",
-						data: { prop: propertyName },
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,80 +0,0 @@
-/**
- * @fileoverview Rule to flag use of an lexical declarations inside a case clause
- * @author Erik Arvidsson
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow lexical declarations in case clauses",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-case-declarations",
-		},
-
-		hasSuggestions: true,
-
-		schema: [],
-
-		messages: {
-			addBrackets: "Add {} brackets around the case block.",
-			unexpected: "Unexpected lexical declaration in case block.",
-		},
-	},
-
-	create(context) {
-		/**
-		 * Checks whether or not a node is a lexical declaration.
-		 * @param {ASTNode} node A direct child statement of a switch case.
-		 * @returns {boolean} Whether or not the node is a lexical declaration.
-		 */
-		function isLexicalDeclaration(node) {
-			switch (node.type) {
-				case "FunctionDeclaration":
-				case "ClassDeclaration":
-					return true;
-				case "VariableDeclaration":
-					return node.kind !== "var";
-				default:
-					return false;
-			}
-		}
-
-		return {
-			SwitchCase(node) {
-				for (let i = 0; i < node.consequent.length; i++) {
-					const statement = node.consequent[i];
-
-					if (isLexicalDeclaration(statement)) {
-						context.report({
-							node: statement,
-							messageId: "unexpected",
-							suggest: [
-								{
-									messageId: "addBrackets",
-									fix: fixer => [
-										fixer.insertTextBefore(
-											node.consequent[0],
-											"{ ",
-										),
-										fixer.insertTextAfter(
-											node.consequent.at(-1),
-											" }",
-										),
-									],
-								},
-							],
-						});
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,96 +0,0 @@
-/**
- * @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier
- * @author Ian Christian Myers
- * @deprecated in ESLint v5.1.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow `catch` clause parameters from shadowing variables in the outer scope",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-catch-shadow",
-		},
-
-		deprecated: {
-			message: "This rule was renamed.",
-			url: "https://eslint.org/blog/2018/07/eslint-v5.1.0-released/",
-			deprecatedSince: "5.1.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					rule: {
-						name: "no-shadow",
-						url: "https://eslint.org/docs/rules/no-shadow",
-					},
-				},
-			],
-		},
-		schema: [],
-
-		messages: {
-			mutable:
-				"Value of '{{name}}' may be overwritten in IE 8 and earlier.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Check if the parameters are been shadowed
-		 * @param {Object} scope current scope
-		 * @param {string} name parameter name
-		 * @returns {boolean} True is its been shadowed
-		 */
-		function paramIsShadowing(scope, name) {
-			return astUtils.getVariableByName(scope, name) !== null;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			"CatchClause[param!=null]"(node) {
-				let scope = sourceCode.getScope(node);
-
-				/*
-				 * When ecmaVersion >= 6, CatchClause creates its own scope
-				 * so start from one upper scope to exclude the current node
-				 */
-				if (scope.block === node) {
-					scope = scope.upper;
-				}
-
-				if (paramIsShadowing(scope, node.param.name)) {
-					context.report({
-						node,
-						messageId: "mutable",
-						data: { name: node.param.name },
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,66 +0,0 @@
-/**
- * @fileoverview A rule to disallow modifying variables of class declarations
- * @author Toru Nagashima
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow reassigning class members",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-class-assign",
-		},
-
-		schema: [],
-
-		messages: {
-			class: "'{{name}}' is a class.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Finds and reports references that are non initializer and writable.
-		 * @param {Variable} variable A variable to check.
-		 * @returns {void}
-		 */
-		function checkVariable(variable) {
-			astUtils
-				.getModifyingReferences(variable.references)
-				.forEach(reference => {
-					context.report({
-						node: reference.identifier,
-						messageId: "class",
-						data: { name: reference.identifier.name },
-					});
-				});
-		}
-
-		/**
-		 * Finds and reports references that are non initializer and writable.
-		 * @param {ASTNode} node A ClassDeclaration/ClassExpression node to check.
-		 * @returns {void}
-		 */
-		function checkForClass(node) {
-			sourceCode.getDeclaredVariables(node).forEach(checkVariable);
-		}
-
-		return {
-			ClassDeclaration: checkForClass,
-			ClassExpression: checkForClass,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-compare-neg-zero.js

@@ -1,74 +0,0 @@
-/**
- * @fileoverview The rule should warn against code that tries to compare against -0.
- * @author Aladdin-ADD <hh_2013@foxmail.com>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow comparing against `-0`",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-compare-neg-zero",
-		},
-
-		fixable: null,
-		schema: [],
-
-		messages: {
-			unexpected:
-				"Do not use the '{{operator}}' operator to compare against -0.",
-		},
-	},
-
-	create(context) {
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Checks a given node is -0
-		 * @param {ASTNode} node A node to check.
-		 * @returns {boolean} `true` if the node is -0.
-		 */
-		function isNegZero(node) {
-			return (
-				node.type === "UnaryExpression" &&
-				node.operator === "-" &&
-				node.argument.type === "Literal" &&
-				node.argument.value === 0
-			);
-		}
-		const OPERATORS_TO_CHECK = new Set([
-			">",
-			">=",
-			"<",
-			"<=",
-			"==",
-			"===",
-			"!=",
-			"!==",
-		]);
-
-		return {
-			BinaryExpression(node) {
-				if (OPERATORS_TO_CHECK.has(node.operator)) {
-					if (isNegZero(node.left) || isNegZero(node.right)) {
-						context.report({
-							node,
-							messageId: "unexpected",
-							data: { operator: node.operator },
-						});
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,175 +0,0 @@
-/**
- * @fileoverview Rule to flag assignment in a conditional statement's test expression
- * @author Stephen Murray <spmurrayzzz>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const TEST_CONDITION_PARENT_TYPES = new Set([
-	"IfStatement",
-	"WhileStatement",
-	"DoWhileStatement",
-	"ForStatement",
-	"ConditionalExpression",
-]);
-
-const NODE_DESCRIPTIONS = {
-	DoWhileStatement: "a 'do...while' statement",
-	ForStatement: "a 'for' statement",
-	IfStatement: "an 'if' statement",
-	WhileStatement: "a 'while' statement",
-};
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: ["except-parens"],
-
-		docs: {
-			description:
-				"Disallow assignment operators in conditional expressions",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-cond-assign",
-		},
-
-		schema: [
-			{
-				enum: ["except-parens", "always"],
-			},
-		],
-
-		messages: {
-			unexpected: "Unexpected assignment within {{type}}.",
-
-			// must match JSHint's error message
-			missing:
-				"Expected a conditional expression and instead saw an assignment.",
-		},
-	},
-
-	create(context) {
-		const [prohibitAssign] = context.options;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Check whether an AST node is the test expression for a conditional statement.
-		 * @param {!Object} node The node to test.
-		 * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
-		 */
-		function isConditionalTestExpression(node) {
-			return (
-				node.parent &&
-				TEST_CONDITION_PARENT_TYPES.has(node.parent.type) &&
-				node === node.parent.test
-			);
-		}
-
-		/**
-		 * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
-		 * @param {!Object} node The node to use at the start of the search.
-		 * @returns {?Object} The closest ancestor node that represents a conditional statement.
-		 */
-		function findConditionalAncestor(node) {
-			let currentAncestor = node;
-
-			do {
-				if (isConditionalTestExpression(currentAncestor)) {
-					return currentAncestor.parent;
-				}
-			} while (
-				(currentAncestor = currentAncestor.parent) &&
-				!astUtils.isFunction(currentAncestor)
-			);
-
-			return null;
-		}
-
-		/**
-		 * Check whether the code represented by an AST node is enclosed in two sets of parentheses.
-		 * @param {!Object} node The node to test.
-		 * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
-		 */
-		function isParenthesisedTwice(node) {
-			const previousToken = sourceCode.getTokenBefore(node, 1),
-				nextToken = sourceCode.getTokenAfter(node, 1);
-
-			return (
-				astUtils.isParenthesised(sourceCode, node) &&
-				previousToken &&
-				astUtils.isOpeningParenToken(previousToken) &&
-				previousToken.range[1] <= node.range[0] &&
-				astUtils.isClosingParenToken(nextToken) &&
-				nextToken.range[0] >= node.range[1]
-			);
-		}
-
-		/**
-		 * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
-		 * @param {!Object} node The node for the conditional statement.
-		 * @returns {void}
-		 */
-		function testForAssign(node) {
-			if (
-				node.test &&
-				node.test.type === "AssignmentExpression" &&
-				(node.type === "ForStatement"
-					? !astUtils.isParenthesised(sourceCode, node.test)
-					: !isParenthesisedTwice(node.test))
-			) {
-				context.report({
-					node: node.test,
-					messageId: "missing",
-				});
-			}
-		}
-
-		/**
-		 * Check whether an assignment expression is descended from a conditional statement's test expression.
-		 * @param {!Object} node The node for the assignment expression.
-		 * @returns {void}
-		 */
-		function testForConditionalAncestor(node) {
-			const ancestor = findConditionalAncestor(node);
-
-			if (ancestor) {
-				context.report({
-					node,
-					messageId: "unexpected",
-					data: {
-						type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type,
-					},
-				});
-			}
-		}
-
-		if (prohibitAssign === "always") {
-			return {
-				AssignmentExpression: testForConditionalAncestor,
-			};
-		}
-
-		return {
-			DoWhileStatement: testForAssign,
-			ForStatement: testForAssign,
-			IfStatement: testForAssign,
-			WhileStatement: testForAssign,
-			ConditionalExpression: testForAssign,
-		};
-	},
-};