@alexlit/lint-kit 183.1.0 → 183.2.0

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

@@ -1,253 +0,0 @@
-/**
- * @fileoverview Rule to disallow mixed binary operators.
- * @author Toru Nagashima
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils.js");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const ARITHMETIC_OPERATORS = ["+", "-", "*", "/", "%", "**"];
-const BITWISE_OPERATORS = ["&", "|", "^", "~", "<<", ">>", ">>>"];
-const COMPARISON_OPERATORS = ["==", "!=", "===", "!==", ">", ">=", "<", "<="];
-const LOGICAL_OPERATORS = ["&&", "||"];
-const RELATIONAL_OPERATORS = ["in", "instanceof"];
-const TERNARY_OPERATOR = ["?:"];
-const COALESCE_OPERATOR = ["??"];
-const ALL_OPERATORS = [].concat(
-	ARITHMETIC_OPERATORS,
-	BITWISE_OPERATORS,
-	COMPARISON_OPERATORS,
-	LOGICAL_OPERATORS,
-	RELATIONAL_OPERATORS,
-	TERNARY_OPERATOR,
-	COALESCE_OPERATOR,
-);
-const DEFAULT_GROUPS = [
-	ARITHMETIC_OPERATORS,
-	BITWISE_OPERATORS,
-	COMPARISON_OPERATORS,
-	LOGICAL_OPERATORS,
-	RELATIONAL_OPERATORS,
-];
-const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
-
-/**
- * Normalizes options.
- * @param {Object|undefined} options A options object to normalize.
- * @returns {Object} Normalized option object.
- */
-function normalizeOptions(options = {}) {
-	const hasGroups = options.groups && options.groups.length > 0;
-	const groups = hasGroups ? options.groups : DEFAULT_GROUPS;
-	const allowSamePrecedence = options.allowSamePrecedence !== false;
-
-	return {
-		groups,
-		allowSamePrecedence,
-	};
-}
-
-/**
- * Checks whether any group which includes both given operator exists or not.
- * @param {Array<string[]>} groups A list of groups to check.
- * @param {string} left An operator.
- * @param {string} right Another operator.
- * @returns {boolean} `true` if such group existed.
- */
-function includesBothInAGroup(groups, left, right) {
-	return groups.some(group => group.includes(left) && group.includes(right));
-}
-
-/**
- * Checks whether the given node is a conditional expression and returns the test node else the left node.
- * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node.
- * This parent node can be BinaryExpression, LogicalExpression
- *      , or a ConditionalExpression node
- * @returns {ASTNode} node the appropriate node(left or test).
- */
-function getChildNode(node) {
-	return node.type === "ConditionalExpression" ? node.test : node.left;
-}
-
-//------------------------------------------------------------------------------
-// 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-mixed-operators",
-						url: "https://eslint.style/rules/no-mixed-operators",
-					},
-				},
-			],
-		},
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow mixed binary operators",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-mixed-operators",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					groups: {
-						type: "array",
-						items: {
-							type: "array",
-							items: { enum: ALL_OPERATORS },
-							minItems: 2,
-							uniqueItems: true,
-						},
-						uniqueItems: true,
-					},
-					allowSamePrecedence: {
-						type: "boolean",
-						default: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedMixedOperator:
-				"Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'. Use parentheses to clarify the intended order of operations.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const options = normalizeOptions(context.options[0]);
-
-		/**
-		 * Checks whether a given node should be ignored by options or not.
-		 * @param {ASTNode} node A node to check. This is a BinaryExpression
-		 *      node or a LogicalExpression node. This parent node is one of
-		 *      them, too.
-		 * @returns {boolean} `true` if the node should be ignored.
-		 */
-		function shouldIgnore(node) {
-			const a = node;
-			const b = node.parent;
-
-			return (
-				!includesBothInAGroup(
-					options.groups,
-					a.operator,
-					b.type === "ConditionalExpression" ? "?:" : b.operator,
-				) ||
-				(options.allowSamePrecedence &&
-					astUtils.getPrecedence(a) === astUtils.getPrecedence(b))
-			);
-		}
-
-		/**
-		 * Checks whether the operator of a given node is mixed with parent
-		 * node's operator or not.
-		 * @param {ASTNode} node A node to check. This is a BinaryExpression
-		 *      node or a LogicalExpression node. This parent node is one of
-		 *      them, too.
-		 * @returns {boolean} `true` if the node was mixed.
-		 */
-		function isMixedWithParent(node) {
-			return (
-				node.operator !== node.parent.operator &&
-				!astUtils.isParenthesised(sourceCode, node)
-			);
-		}
-
-		/**
-		 * Gets the operator token of a given node.
-		 * @param {ASTNode} node A node to check. This is a BinaryExpression
-		 *      node or a LogicalExpression node.
-		 * @returns {Token} The operator token of the node.
-		 */
-		function getOperatorToken(node) {
-			return sourceCode.getTokenAfter(
-				getChildNode(node),
-				astUtils.isNotClosingParenToken,
-			);
-		}
-
-		/**
-		 * Reports both the operator of a given node and the operator of the
-		 * parent node.
-		 * @param {ASTNode} node A node to check. This is a BinaryExpression
-		 *      node or a LogicalExpression node. This parent node is one of
-		 *      them, too.
-		 * @returns {void}
-		 */
-		function reportBothOperators(node) {
-			const parent = node.parent;
-			const left = getChildNode(parent) === node ? node : parent;
-			const right = getChildNode(parent) !== node ? node : parent;
-			const data = {
-				leftOperator: left.operator || "?:",
-				rightOperator: right.operator || "?:",
-			};
-
-			context.report({
-				node: left,
-				loc: getOperatorToken(left).loc,
-				messageId: "unexpectedMixedOperator",
-				data,
-			});
-			context.report({
-				node: right,
-				loc: getOperatorToken(right).loc,
-				messageId: "unexpectedMixedOperator",
-				data,
-			});
-		}
-
-		/**
-		 * Checks between the operator of this node and the operator of the
-		 * parent node.
-		 * @param {ASTNode} node A node to check.
-		 * @returns {void}
-		 */
-		function check(node) {
-			if (
-				TARGET_NODE_TYPE.test(node.parent.type) &&
-				isMixedWithParent(node) &&
-				!shouldIgnore(node)
-			) {
-				reportBothOperators(node);
-			}
-		}
-
-		return {
-			BinaryExpression: check,
-			LogicalExpression: check,
-		};
-	},
-};

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

@@ -1,267 +0,0 @@
-/**
- * @fileoverview Rule to enforce grouped require statements for Node.JS
- * @author Raphael Pigulla
- * @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-mixed-requires",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-mixed-requires.md",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow `require` calls to be mixed with regular variable declarations",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-mixed-requires",
-		},
-
-		schema: [
-			{
-				oneOf: [
-					{
-						type: "boolean",
-					},
-					{
-						type: "object",
-						properties: {
-							grouping: {
-								type: "boolean",
-							},
-							allowCall: {
-								type: "boolean",
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-
-		messages: {
-			noMixRequire: "Do not mix 'require' and other declarations.",
-			noMixCoreModuleFileComputed:
-				"Do not mix core, module, file and computed requires.",
-		},
-	},
-
-	create(context) {
-		const options = context.options[0];
-		let grouping = false,
-			allowCall = false;
-
-		if (typeof options === "object") {
-			grouping = options.grouping;
-			allowCall = options.allowCall;
-		} else {
-			grouping = !!options;
-		}
-
-		/**
-		 * Returns the list of built-in modules.
-		 * @returns {string[]} An array of built-in Node.js modules.
-		 */
-		function getBuiltinModules() {
-			/*
-			 * This list is generated using:
-			 * `require("repl")._builtinLibs.concat('repl').sort()`
-			 * This particular list is as per nodejs v0.12.2 and iojs v0.7.1
-			 */
-			return [
-				"assert",
-				"buffer",
-				"child_process",
-				"cluster",
-				"crypto",
-				"dgram",
-				"dns",
-				"domain",
-				"events",
-				"fs",
-				"http",
-				"https",
-				"net",
-				"os",
-				"path",
-				"punycode",
-				"querystring",
-				"readline",
-				"repl",
-				"smalloc",
-				"stream",
-				"string_decoder",
-				"tls",
-				"tty",
-				"url",
-				"util",
-				"v8",
-				"vm",
-				"zlib",
-			];
-		}
-
-		const BUILTIN_MODULES = getBuiltinModules();
-
-		const DECL_REQUIRE = "require",
-			DECL_UNINITIALIZED = "uninitialized",
-			DECL_OTHER = "other";
-
-		const REQ_CORE = "core",
-			REQ_FILE = "file",
-			REQ_MODULE = "module",
-			REQ_COMPUTED = "computed";
-
-		/**
-		 * Determines the type of a declaration statement.
-		 * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-		 * @returns {string} The type of declaration represented by the expression.
-		 */
-		function getDeclarationType(initExpression) {
-			if (!initExpression) {
-				// "var x;"
-				return DECL_UNINITIALIZED;
-			}
-
-			if (
-				initExpression.type === "CallExpression" &&
-				initExpression.callee.type === "Identifier" &&
-				initExpression.callee.name === "require"
-			) {
-				// "var x = require('util');"
-				return DECL_REQUIRE;
-			}
-			if (
-				allowCall &&
-				initExpression.type === "CallExpression" &&
-				initExpression.callee.type === "CallExpression"
-			) {
-				// "var x = require('diagnose')('sub-module');"
-				return getDeclarationType(initExpression.callee);
-			}
-			if (initExpression.type === "MemberExpression") {
-				// "var x = require('glob').Glob;"
-				return getDeclarationType(initExpression.object);
-			}
-
-			// "var x = 42;"
-			return DECL_OTHER;
-		}
-
-		/**
-		 * Determines the type of module that is loaded via require.
-		 * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-		 * @returns {string} The module type.
-		 */
-		function inferModuleType(initExpression) {
-			if (initExpression.type === "MemberExpression") {
-				// "var x = require('glob').Glob;"
-				return inferModuleType(initExpression.object);
-			}
-			if (initExpression.arguments.length === 0) {
-				// "var x = require();"
-				return REQ_COMPUTED;
-			}
-
-			const arg = initExpression.arguments[0];
-
-			if (arg.type !== "Literal" || typeof arg.value !== "string") {
-				// "var x = require(42);"
-				return REQ_COMPUTED;
-			}
-
-			if (BUILTIN_MODULES.includes(arg.value)) {
-				// "var fs = require('fs');"
-				return REQ_CORE;
-			}
-			if (/^\.{0,2}\//u.test(arg.value)) {
-				// "var utils = require('./utils');"
-				return REQ_FILE;
-			}
-
-			// "var async = require('async');"
-			return REQ_MODULE;
-		}
-
-		/**
-		 * Check if the list of variable declarations is mixed, i.e. whether it
-		 * contains both require and other declarations.
-		 * @param {ASTNode} declarations The list of VariableDeclarators.
-		 * @returns {boolean} True if the declarations are mixed, false if not.
-		 */
-		function isMixed(declarations) {
-			const contains = {};
-
-			declarations.forEach(declaration => {
-				const type = getDeclarationType(declaration.init);
-
-				contains[type] = true;
-			});
-
-			return !!(
-				contains[DECL_REQUIRE] &&
-				(contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])
-			);
-		}
-
-		/**
-		 * Check if all require declarations in the given list are of the same
-		 * type.
-		 * @param {ASTNode} declarations The list of VariableDeclarators.
-		 * @returns {boolean} True if the declarations are grouped, false if not.
-		 */
-		function isGrouped(declarations) {
-			const found = {};
-
-			declarations.forEach(declaration => {
-				if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
-					found[inferModuleType(declaration.init)] = true;
-				}
-			});
-
-			return Object.keys(found).length <= 1;
-		}
-
-		return {
-			VariableDeclaration(node) {
-				if (isMixed(node.declarations)) {
-					context.report({
-						node,
-						messageId: "noMixRequire",
-					});
-				} else if (grouping && !isGrouped(node.declarations)) {
-					context.report({
-						node,
-						messageId: "noMixCoreModuleFileComputed",
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js

@@ -1,148 +0,0 @@
-/**
- * @fileoverview Disallow mixed spaces and tabs for indentation
- * @author Jary Niebur
- * @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: "no-mixed-spaces-and-tabs",
-						url: "https://eslint.style/rules/no-mixed-spaces-and-tabs",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Disallow mixed spaces and tabs for indentation",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs",
-		},
-
-		schema: [
-			{
-				enum: ["smart-tabs", true, false],
-			},
-		],
-
-		messages: {
-			mixedSpacesAndTabs: "Mixed spaces and tabs.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		let smartTabs;
-
-		switch (context.options[0]) {
-			case true: // Support old syntax, maybe add deprecation warning here
-			case "smart-tabs":
-				smartTabs = true;
-				break;
-			default:
-				smartTabs = false;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			"Program:exit"(node) {
-				const lines = sourceCode.lines,
-					comments = sourceCode.getAllComments(),
-					ignoredCommentLines = new Set();
-
-				// Add all lines except the first ones.
-				comments.forEach(comment => {
-					for (
-						let i = comment.loc.start.line + 1;
-						i <= comment.loc.end.line;
-						i++
-					) {
-						ignoredCommentLines.add(i);
-					}
-				});
-
-				/*
-				 * At least one space followed by a tab
-				 * or the reverse before non-tab/-space
-				 * characters begin.
-				 */
-				let regex = /^(?=( +|\t+))\1(?:\t| )/u;
-
-				if (smartTabs) {
-					/*
-					 * At least one space followed by a tab
-					 * before non-tab/-space characters begin.
-					 */
-					// eslint-disable-next-line regexp/no-empty-lookarounds-assertion -- False positive
-					regex = /^(?=(\t*))\1(?=( +))\2\t/u;
-				}
-
-				lines.forEach((line, i) => {
-					const match = regex.exec(line);
-
-					if (match) {
-						const lineNumber = i + 1;
-						const loc = {
-							start: {
-								line: lineNumber,
-								column: match[0].length - 2,
-							},
-							end: {
-								line: lineNumber,
-								column: match[0].length,
-							},
-						};
-
-						if (!ignoredCommentLines.has(lineNumber)) {
-							const containingNode =
-								sourceCode.getNodeByRangeIndex(
-									sourceCode.getIndexFromLoc(loc.start),
-								);
-
-							if (
-								!(
-									containingNode &&
-									["Literal", "TemplateElement"].includes(
-										containingNode.type,
-									)
-								)
-							) {
-								context.report({
-									node,
-									loc,
-									messageId: "mixedSpacesAndTabs",
-								});
-							}
-						}
-					}
-				});
-			},
-		};
-	},
-};