@alexlit/lint-kit 166.0.1 → 167.0.0

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

@@ -1,177 +0,0 @@
-/**
- * @fileoverview Rule to flag use constant conditions
- * @author Christian Schulz <http://rndm.de>
- */
-
-"use strict";
-
-const { isConstant } = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [{ checkLoops: "allExceptWhileTrue" }],
-
-		docs: {
-			description: "Disallow constant expressions in conditions",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-constant-condition",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					checkLoops: {
-						enum: [
-							"all",
-							"allExceptWhileTrue",
-							"none",
-							true,
-							false,
-						],
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpected: "Unexpected constant condition.",
-		},
-	},
-
-	create(context) {
-		const loopSetStack = [];
-		const sourceCode = context.sourceCode;
-		let [{ checkLoops }] = context.options;
-
-		if (checkLoops === true) {
-			checkLoops = "all";
-		} else if (checkLoops === false) {
-			checkLoops = "none";
-		}
-
-		let loopsInCurrentScope = new Set();
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Tracks when the given node contains a constant condition.
-		 * @param {ASTNode} node The AST node to check.
-		 * @returns {void}
-		 * @private
-		 */
-		function trackConstantConditionLoop(node) {
-			if (
-				node.test &&
-				isConstant(sourceCode.getScope(node), node.test, true)
-			) {
-				loopsInCurrentScope.add(node);
-			}
-		}
-
-		/**
-		 * Reports when the set contains the given constant condition node
-		 * @param {ASTNode} node The AST node to check.
-		 * @returns {void}
-		 * @private
-		 */
-		function checkConstantConditionLoopInSet(node) {
-			if (loopsInCurrentScope.has(node)) {
-				loopsInCurrentScope.delete(node);
-				context.report({ node: node.test, messageId: "unexpected" });
-			}
-		}
-
-		/**
-		 * Reports when the given node contains a constant condition.
-		 * @param {ASTNode} node The AST node to check.
-		 * @returns {void}
-		 * @private
-		 */
-		function reportIfConstant(node) {
-			if (
-				node.test &&
-				isConstant(sourceCode.getScope(node), node.test, true)
-			) {
-				context.report({ node: node.test, messageId: "unexpected" });
-			}
-		}
-
-		/**
-		 * Stores current set of constant loops in loopSetStack temporarily
-		 * and uses a new set to track constant loops
-		 * @returns {void}
-		 * @private
-		 */
-		function enterFunction() {
-			loopSetStack.push(loopsInCurrentScope);
-			loopsInCurrentScope = new Set();
-		}
-
-		/**
-		 * Reports when the set still contains stored constant conditions
-		 * @returns {void}
-		 * @private
-		 */
-		function exitFunction() {
-			loopsInCurrentScope = loopSetStack.pop();
-		}
-
-		/**
-		 * Checks node when checkLoops option is enabled
-		 * @param {ASTNode} node The AST node to check.
-		 * @returns {void}
-		 * @private
-		 */
-		function checkLoop(node) {
-			if (checkLoops === "all" || checkLoops === "allExceptWhileTrue") {
-				trackConstantConditionLoop(node);
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			ConditionalExpression: reportIfConstant,
-			IfStatement: reportIfConstant,
-			WhileStatement(node) {
-				if (
-					node.test.type === "Literal" &&
-					node.test.value === true &&
-					checkLoops === "allExceptWhileTrue"
-				) {
-					return;
-				}
-
-				checkLoop(node);
-			},
-			"WhileStatement:exit": checkConstantConditionLoopInSet,
-			DoWhileStatement: checkLoop,
-			"DoWhileStatement:exit": checkConstantConditionLoopInSet,
-			ForStatement: checkLoop,
-			"ForStatement > .test": node => checkLoop(node.parent),
-			"ForStatement:exit": checkConstantConditionLoopInSet,
-			FunctionDeclaration: enterFunction,
-			"FunctionDeclaration:exit": exitFunction,
-			FunctionExpression: enterFunction,
-			"FunctionExpression:exit": exitFunction,
-			YieldExpression: () => loopsInCurrentScope.clear(),
-		};
-	},
-};

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

@@ -1,62 +0,0 @@
-/**
- * @fileoverview Rule to disallow returning value from constructor.
- * @author Pig Fang <https://github.com/g-plane>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow returning value from constructor",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-constructor-return",
-		},
-
-		schema: [],
-
-		fixable: null,
-
-		messages: {
-			unexpected: "Unexpected return statement in constructor.",
-		},
-	},
-
-	create(context) {
-		const stack = [];
-
-		return {
-			onCodePathStart(_, node) {
-				stack.push(node);
-			},
-			onCodePathEnd() {
-				stack.pop();
-			},
-			ReturnStatement(node) {
-				const last = stack.at(-1);
-
-				if (!last.parent) {
-					return;
-				}
-
-				if (
-					last.parent.type === "MethodDefinition" &&
-					last.parent.kind === "constructor" &&
-					node.argument
-				) {
-					context.report({
-						node,
-						messageId: "unexpected",
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,38 +0,0 @@
-/**
- * @fileoverview Rule to flag use of continue statement
- * @author Borislav Zhivkov
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow `continue` statements",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-continue",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Unexpected use of continue statement.",
-		},
-	},
-
-	create(context) {
-		return {
-			ContinueStatement(node) {
-				context.report({ node, messageId: "unexpected" });
-			},
-		};
-	},
-};

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

@@ -1,142 +0,0 @@
-/**
- * @fileoverview Rule to forbid control characters from regular expressions.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
-const collector = new (class {
-	constructor() {
-		this._source = "";
-		this._controlChars = [];
-		this._validator = new RegExpValidator(this);
-	}
-
-	onPatternEnter() {
-		/*
-		 * `RegExpValidator` may parse the pattern twice in one `validatePattern`.
-		 * So `this._controlChars` should be cleared here as well.
-		 *
-		 * For example, the `/(?<a>\x1f)/` regex will parse the pattern twice.
-		 * This is based on the content described in Annex B.
-		 * If the regex contains a `GroupName` and the `u` flag is not used, `ParseText` will be called twice.
-		 * See https://tc39.es/ecma262/2023/multipage/additional-ecmascript-features-for-web-browsers.html#sec-parsepattern-annexb
-		 */
-		this._controlChars = [];
-	}
-
-	onCharacter(start, end, cp) {
-		if (
-			cp >= 0x00 &&
-			cp <= 0x1f &&
-			(this._source.codePointAt(start) === cp ||
-				this._source.slice(start, end).startsWith("\\x") ||
-				this._source.slice(start, end).startsWith("\\u"))
-		) {
-			this._controlChars.push(`\\x${`0${cp.toString(16)}`.slice(-2)}`);
-		}
-	}
-
-	collectControlChars(regexpStr, flags) {
-		const uFlag = typeof flags === "string" && flags.includes("u");
-		const vFlag = typeof flags === "string" && flags.includes("v");
-
-		this._controlChars = [];
-		this._source = regexpStr;
-
-		try {
-			this._validator.validatePattern(regexpStr, void 0, void 0, {
-				unicode: uFlag,
-				unicodeSets: vFlag,
-			}); // Call onCharacter hook
-		} catch {
-			// Ignore syntax errors in RegExp.
-		}
-		return this._controlChars;
-	}
-})();
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow control characters in regular expressions",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-control-regex",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected:
-				"Unexpected control character(s) in regular expression: {{controlChars}}.",
-		},
-	},
-
-	create(context) {
-		/**
-		 * Get the regex expression
-		 * @param {ASTNode} node `Literal` node to evaluate
-		 * @returns {{ pattern: string, flags: string | null } | null} Regex if found (the given node is either a regex literal
-		 * or a string literal that is the pattern argument of a RegExp constructor call). Otherwise `null`. If flags cannot be determined,
-		 * the `flags` property will be `null`.
-		 * @private
-		 */
-		function getRegExp(node) {
-			if (node.regex) {
-				return node.regex;
-			}
-			if (
-				typeof node.value === "string" &&
-				(node.parent.type === "NewExpression" ||
-					node.parent.type === "CallExpression") &&
-				node.parent.callee.type === "Identifier" &&
-				node.parent.callee.name === "RegExp" &&
-				node.parent.arguments[0] === node
-			) {
-				const pattern = node.value;
-				const flags =
-					node.parent.arguments.length > 1 &&
-					node.parent.arguments[1].type === "Literal" &&
-					typeof node.parent.arguments[1].value === "string"
-						? node.parent.arguments[1].value
-						: null;
-
-				return { pattern, flags };
-			}
-
-			return null;
-		}
-
-		return {
-			Literal(node) {
-				const regExp = getRegExp(node);
-
-				if (regExp) {
-					const { pattern, flags } = regExp;
-					const controlCharacters = collector.collectControlChars(
-						pattern,
-						flags,
-					);
-
-					if (controlCharacters.length > 0) {
-						context.report({
-							node,
-							messageId: "unexpected",
-							data: {
-								controlChars: controlCharacters.join(", "),
-							},
-						});
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,41 +0,0 @@
-/**
- * @fileoverview Rule to flag use of a debugger statement
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow the use of `debugger`",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-debugger",
-		},
-
-		fixable: null,
-		schema: [],
-
-		messages: {
-			unexpected: "Unexpected 'debugger' statement.",
-		},
-	},
-
-	create(context) {
-		return {
-			DebuggerStatement(node) {
-				context.report({
-					node,
-					messageId: "unexpected",
-				});
-			},
-		};
-	},
-};

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

@@ -1,42 +0,0 @@
-/**
- * @fileoverview Rule to flag when deleting variables
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow deleting variables",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-delete-var",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Variables should not be deleted.",
-		},
-	},
-
-	create(context) {
-		return {
-			UnaryExpression(node) {
-				if (
-					node.operator === "delete" &&
-					node.argument.type === "Identifier"
-				) {
-					context.report({ node, messageId: "unexpected" });
-				}
-			},
-		};
-	},
-};

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

@@ -1,60 +0,0 @@
-/**
- * @fileoverview Rule to check for ambiguous div operator in regexes
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow equal signs explicitly at the beginning of regular expressions",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-div-regex",
-		},
-
-		fixable: "code",
-
-		schema: [],
-
-		messages: {
-			unexpected:
-				"A regular expression literal can be confused with '/='.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			Literal(node) {
-				const token = sourceCode.getFirstToken(node);
-
-				if (
-					token.type === "RegularExpression" &&
-					token.value[1] === "="
-				) {
-					context.report({
-						node,
-						messageId: "unexpected",
-						fix(fixer) {
-							return fixer.replaceTextRange(
-								[token.range[0] + 1, token.range[0] + 2],
-								"[=]",
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,92 +0,0 @@
-/**
- * @fileoverview Rule to flag duplicate arguments
- * @author Jamund Ferguson
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description:
-				"Disallow duplicate arguments in `function` definitions",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-dupe-args",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Duplicate param '{{name}}'.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Checks whether or not a given definition is a parameter's.
-		 * @param {eslint-scope.DefEntry} def A definition to check.
-		 * @returns {boolean} `true` if the definition is a parameter's.
-		 */
-		function isParameter(def) {
-			return def.type === "Parameter";
-		}
-
-		/**
-		 * Determines if a given node has duplicate parameters.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {void}
-		 * @private
-		 */
-		function checkParams(node) {
-			const variables = sourceCode.getDeclaredVariables(node);
-
-			for (let i = 0; i < variables.length; ++i) {
-				const variable = variables[i];
-
-				// Checks and reports duplications.
-				const defs = variable.defs.filter(isParameter);
-				const loc = {
-					start: astUtils.getOpeningParenOfParams(node, sourceCode)
-						.loc.start,
-					end: sourceCode.getTokenBefore(node.body).loc.end,
-				};
-
-				if (defs.length >= 2) {
-					context.report({
-						loc,
-						messageId: "unexpected",
-						data: { name: variable.name },
-					});
-				}
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			FunctionDeclaration: checkParams,
-			FunctionExpression: checkParams,
-		};
-	},
-};