@alexlit/lint-kit 183.0.0 → 183.2.0

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

@@ -1,375 +0,0 @@
-/**
- * @fileoverview Rule to check for the usage of var.
- * @author Jamund Ferguson
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Types
-//------------------------------------------------------------------------------
-
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("eslint-scope").Variable} Variable */
-/** @typedef {import("eslint-scope").Reference} Reference */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Check whether a given variable is a global variable or not.
- * @param {Variable} variable The variable to check.
- * @returns {boolean} `true` if the variable is a global variable.
- */
-function isGlobal(variable) {
-	return Boolean(variable.scope) && variable.scope.type === "global";
-}
-
-/**
- * Finds the nearest function scope or global scope walking up the scope
- * hierarchy.
- * @param {Scope} scope The scope to traverse.
- * @returns {Scope} a function scope or global scope containing the given
- *      scope.
- */
-function getEnclosingFunctionScope(scope) {
-	let currentScope = scope;
-
-	while (currentScope.type !== "function" && currentScope.type !== "global") {
-		currentScope = currentScope.upper;
-	}
-	return currentScope;
-}
-
-/**
- * Checks whether the given variable has any references from a more specific
- * function expression (i.e. a closure).
- * @param {Variable} variable A variable to check.
- * @returns {boolean} `true` if the variable is used from a closure.
- */
-function isReferencedInClosure(variable) {
-	const enclosingFunctionScope = getEnclosingFunctionScope(variable.scope);
-
-	return variable.references.some(
-		reference =>
-			getEnclosingFunctionScope(reference.from) !==
-			enclosingFunctionScope,
-	);
-}
-
-/**
- * Checks whether the given node is the assignee of a loop.
- * @param {ASTNode} node A VariableDeclaration node to check.
- * @returns {boolean} `true` if the declaration is assigned as part of loop
- *      iteration.
- */
-function isLoopAssignee(node) {
-	return (
-		(node.parent.type === "ForOfStatement" ||
-			node.parent.type === "ForInStatement") &&
-		node === node.parent.left
-	);
-}
-
-/**
- * Checks whether the given variable declaration is immediately initialized.
- * @param {ASTNode} node A VariableDeclaration node to check.
- * @returns {boolean} `true` if the declaration has an initializer.
- */
-function isDeclarationInitialized(node) {
-	return node.declarations.every(declarator => declarator.init !== null);
-}
-
-const SCOPE_NODE_TYPE =
-	/^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/u;
-
-/**
- * Gets the scope node which directly contains a given node.
- * @param {ASTNode} node A node to get. This is a `VariableDeclaration` or
- *      an `Identifier`.
- * @returns {ASTNode} A scope node. This is one of `Program`, `BlockStatement`,
- *      `SwitchStatement`, `ForStatement`, `ForInStatement`, and
- *      `ForOfStatement`.
- */
-function getScopeNode(node) {
-	for (
-		let currentNode = node;
-		currentNode;
-		currentNode = currentNode.parent
-	) {
-		if (SCOPE_NODE_TYPE.test(currentNode.type)) {
-			return currentNode;
-		}
-	}
-
-	/* c8 ignore next */
-	return null;
-}
-
-/**
- * Checks whether a given variable is redeclared or not.
- * @param {Variable} variable A variable to check.
- * @returns {boolean} `true` if the variable is redeclared.
- */
-function isRedeclared(variable) {
-	return variable.defs.length >= 2;
-}
-
-/**
- * Checks whether a given variable is used from outside of the specified scope.
- * @param {ASTNode} scopeNode A scope node to check.
- * @returns {Function} The predicate function which checks whether a given
- *      variable is used from outside of the specified scope.
- */
-function isUsedFromOutsideOf(scopeNode) {
-	/**
-	 * Checks whether a given reference is inside of the specified scope or not.
-	 * @param {Reference} reference A reference to check.
-	 * @returns {boolean} `true` if the reference is inside of the specified
-	 *      scope.
-	 */
-	function isOutsideOfScope(reference) {
-		const scope = scopeNode.range;
-		const id = reference.identifier.range;
-
-		return id[0] < scope[0] || id[1] > scope[1];
-	}
-
-	return function (variable) {
-		return variable.references.some(isOutsideOfScope);
-	};
-}
-
-/**
- * Creates the predicate function which checks whether a variable has their references in TDZ.
- *
- * The predicate function would return `true`:
- *
- * - if a reference is before the declarator. E.g. (var a = b, b = 1;)(var {a = b, b} = {};)
- * - if a reference is in the expression of their default value.  E.g. (var {a = a} = {};)
- * - if a reference is in the expression of their initializer.  E.g. (var a = a;)
- * @param {ASTNode} node The initializer node of VariableDeclarator.
- * @returns {Function} The predicate function.
- * @private
- */
-function hasReferenceInTDZ(node) {
-	const initStart = node.range[0];
-	const initEnd = node.range[1];
-
-	return variable => {
-		const id = variable.defs[0].name;
-		const idStart = id.range[0];
-		const defaultValue =
-			id.parent.type === "AssignmentPattern" ? id.parent.right : null;
-		const defaultStart = defaultValue && defaultValue.range[0];
-		const defaultEnd = defaultValue && defaultValue.range[1];
-
-		return variable.references.some(reference => {
-			const start = reference.identifier.range[0];
-			const end = reference.identifier.range[1];
-
-			return (
-				!reference.init &&
-				(start < idStart ||
-					(defaultValue !== null &&
-						start >= defaultStart &&
-						end <= defaultEnd) ||
-					(!astUtils.isFunction(node) &&
-						start >= initStart &&
-						end <= initEnd))
-			);
-		});
-	};
-}
-
-/**
- * Checks whether a given variable has name that is allowed for 'var' declarations,
- * but disallowed for `let` declarations.
- * @param {Variable} variable The variable to check.
- * @returns {boolean} `true` if the variable has a disallowed name.
- */
-function hasNameDisallowedForLetDeclarations(variable) {
-	return variable.name === "let";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-		dialects: ["typescript", "javascript"],
-		language: "javascript",
-
-		docs: {
-			description: "Require `let` or `const` instead of `var`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-var",
-		},
-
-		schema: [],
-		fixable: "code",
-
-		messages: {
-			unexpectedVar: "Unexpected var, use let or const instead.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks whether the variables which are defined by the given declarator node have their references in TDZ.
-		 * @param {ASTNode} declarator The VariableDeclarator node to check.
-		 * @returns {boolean} `true` if one of the variables which are defined by the given declarator node have their references in TDZ.
-		 */
-		function hasSelfReferenceInTDZ(declarator) {
-			if (!declarator.init) {
-				return false;
-			}
-			const variables = sourceCode.getDeclaredVariables(declarator);
-
-			return variables.some(hasReferenceInTDZ(declarator.init));
-		}
-
-		/**
-		 * Checks whether it can fix a given variable declaration or not.
-		 * It cannot fix if the following cases:
-		 *
-		 * - A variable is a global variable.
-		 * - A variable is declared on a SwitchCase node.
-		 * - A variable is redeclared.
-		 * - A variable is used from outside the scope.
-		 * - A variable is used from a closure within a loop.
-		 * - A variable might be used before it is assigned within a loop.
-		 * - A variable might be used in TDZ.
-		 * - A variable is declared in statement position (e.g. a single-line `IfStatement`)
-		 * - A variable has name that is disallowed for `let` declarations.
-		 *
-		 * ## A variable is declared on a SwitchCase node.
-		 *
-		 * If this rule modifies 'var' declarations on a SwitchCase node, it
-		 * would generate the warnings of 'no-case-declarations' rule. And the
-		 * 'eslint:recommended' preset includes 'no-case-declarations' rule, so
-		 * this rule doesn't modify those declarations.
-		 *
-		 * ## A variable is redeclared.
-		 *
-		 * The language spec disallows redeclarations of `let` declarations.
-		 * Those variables would cause syntax errors.
-		 *
-		 * ## A variable is used from outside the scope.
-		 *
-		 * The language spec disallows accesses from outside of the scope for
-		 * `let` declarations. Those variables would cause reference errors.
-		 *
-		 * ## A variable is used from a closure within a loop.
-		 *
-		 * A `var` declaration within a loop shares the same variable instance
-		 * across all loop iterations, while a `let` declaration creates a new
-		 * instance for each iteration. This means if a variable in a loop is
-		 * referenced by any closure, changing it from `var` to `let` would
-		 * change the behavior in a way that is generally unsafe.
-		 *
-		 * ## A variable might be used before it is assigned within a loop.
-		 *
-		 * Within a loop, a `let` declaration without an initializer will be
-		 * initialized to null, while a `var` declaration will retain its value
-		 * from the previous iteration, so it is only safe to change `var` to
-		 * `let` if we can statically determine that the variable is always
-		 * assigned a value before its first access in the loop body. To keep
-		 * the implementation simple, we only convert `var` to `let` within
-		 * loops when the variable is a loop assignee or the declaration has an
-		 * initializer.
-		 * @param {ASTNode} node A variable declaration node to check.
-		 * @returns {boolean} `true` if it can fix the node.
-		 */
-		function canFix(node) {
-			const variables = sourceCode.getDeclaredVariables(node);
-			const scopeNode = getScopeNode(node);
-
-			if (
-				node.parent.type === "SwitchCase" ||
-				node.declarations.some(hasSelfReferenceInTDZ) ||
-				variables.some(isGlobal) ||
-				variables.some(isRedeclared) ||
-				variables.some(isUsedFromOutsideOf(scopeNode)) ||
-				variables.some(hasNameDisallowedForLetDeclarations)
-			) {
-				return false;
-			}
-
-			if (astUtils.isInLoop(node)) {
-				if (variables.some(isReferencedInClosure)) {
-					return false;
-				}
-				if (!isLoopAssignee(node) && !isDeclarationInitialized(node)) {
-					return false;
-				}
-			}
-
-			if (
-				!isLoopAssignee(node) &&
-				!(
-					node.parent.type === "ForStatement" &&
-					node.parent.init === node
-				) &&
-				!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)
-			) {
-				// If the declaration is not in a block, e.g. `if (foo) var bar = 1;`, then it can't be fixed.
-				return false;
-			}
-
-			return true;
-		}
-
-		/**
-		 * Reports a given variable declaration node.
-		 * @param {ASTNode} node A variable declaration node to report.
-		 * @returns {void}
-		 */
-		function report(node) {
-			context.report({
-				node,
-				messageId: "unexpectedVar",
-
-				fix(fixer) {
-					const varToken = sourceCode.getFirstToken(node, {
-						filter: t => t.value === "var",
-					});
-
-					return canFix(node)
-						? fixer.replaceText(varToken, "let")
-						: null;
-				},
-			});
-		}
-
-		return {
-			"VariableDeclaration:exit"(node) {
-				if (node.kind !== "var") {
-					return;
-				}
-
-				if (
-					node.parent.type === "TSModuleBlock" &&
-					node.parent.parent.type === "TSModuleDeclaration" &&
-					node.parent.parent.global
-				) {
-					return;
-				}
-
-				report(node);
-			},
-		};
-	},
-};

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

@@ -1,69 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of void operator.
- * @author Mike Sidorov
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allowAsStatement: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow `void` operators",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-void",
-		},
-
-		messages: {
-			noVoid: "Expected 'undefined' and instead saw 'void'.",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowAsStatement: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-	},
-
-	create(context) {
-		const [{ allowAsStatement }] = context.options;
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			'UnaryExpression[operator="void"]'(node) {
-				if (
-					allowAsStatement &&
-					node.parent &&
-					node.parent.type === "ExpressionStatement"
-				) {
-					return;
-				}
-				context.report({
-					node,
-					messageId: "noVoid",
-				});
-			},
-		};
-	},
-};

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

@@ -1,209 +0,0 @@
-/**
- * @fileoverview Rule that warns about used warning comments
- * @author Alexander Schmidt <https://github.com/lxanders>
- */
-
-"use strict";
-
-const escapeRegExp = require("escape-string-regexp");
-const astUtils = require("./utils/ast-utils");
-
-const CHAR_LIMIT = 40;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				location: "start",
-				terms: ["todo", "fixme", "xxx"],
-			},
-		],
-
-		docs: {
-			description: "Disallow specified warning terms in comments",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-warning-comments",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					terms: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-					},
-					location: {
-						enum: ["start", "anywhere"],
-					},
-					decoration: {
-						type: "array",
-						items: {
-							type: "string",
-							pattern: "^\\S$",
-						},
-						minItems: 1,
-						uniqueItems: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedComment:
-				"Unexpected '{{matchedTerm}}' comment: '{{comment}}'.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ decoration, location, terms: warningTerms }] = context.options;
-		const escapedDecoration = escapeRegExp(
-			decoration ? decoration.join("") : "",
-		);
-		const selfConfigRegEx = /\bno-warning-comments\b/u;
-
-		/**
-		 * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
-		 * location ("start" or "anywhere"). If the term starts or ends with non word characters, then the match will not
-		 * require word boundaries on that side.
-		 * @param {string} term A term to convert to a RegExp
-		 * @returns {RegExp} The term converted to a RegExp
-		 */
-		function convertToRegExp(term) {
-			const escaped = escapeRegExp(term);
-
-			/*
-			 * When matching at the start, ignore leading whitespace, and
-			 * there's no need to worry about word boundaries.
-			 *
-			 * These expressions for the prefix and suffix are designed as follows:
-			 * ^   handles any terms at the beginning of a comment.
-			 *     e.g. terms ["TODO"] matches `//TODO something`
-			 * $   handles any terms at the end of a comment
-			 *     e.g. terms ["TODO"] matches `// something TODO`
-			 * \b  handles terms preceded/followed by word boundary
-			 *     e.g. terms: ["!FIX", "FIX!"] matches `// FIX!something` or `// something!FIX`
-			 *          terms: ["FIX"] matches `// FIX!` or `// !FIX`, but not `// fixed or affix`
-			 *
-			 * For location start:
-			 * [\s]* handles optional leading spaces
-			 *     e.g. terms ["TODO"] matches `//    TODO something`
-			 * [\s\*]* (where "\*" is the escaped string of decoration)
-			 *     handles optional leading spaces or decoration characters (for "start" location only)
-			 *     e.g. terms ["TODO"] matches `/**** TODO something ... `
-			 */
-			const wordBoundary = "\\b";
-
-			let prefix = "";
-
-			if (location === "start") {
-				prefix = `^[\\s${escapedDecoration}]*`;
-			} else if (/^\w/u.test(term)) {
-				prefix = wordBoundary;
-			}
-
-			const suffix = /\w$/u.test(term) ? wordBoundary : "";
-			const flags = "iu"; // Case-insensitive with Unicode case folding.
-
-			/*
-			 * For location "start", the typical regex is:
-			 *   /^[\s]*ESCAPED_TERM\b/iu.
-			 * Or if decoration characters are specified (e.g. "*"), then any of
-			 * those characters may appear in any order at the start:
-			 *   /^[\s\*]*ESCAPED_TERM\b/iu.
-			 *
-			 * For location "anywhere" the typical regex is
-			 *   /\bESCAPED_TERM\b/iu
-			 *
-			 * If it starts or ends with non-word character, the prefix and suffix are empty, respectively.
-			 */
-			return new RegExp(`${prefix}${escaped}${suffix}`, flags);
-		}
-
-		const warningRegExps = warningTerms.map(convertToRegExp);
-
-		/**
-		 * Checks the specified comment for matches of the configured warning terms and returns the matches.
-		 * @param {string} comment The comment which is checked.
-		 * @returns {Array} All matched warning terms for this comment.
-		 */
-		function commentContainsWarningTerm(comment) {
-			const matches = [];
-
-			warningRegExps.forEach((regex, index) => {
-				if (regex.test(comment)) {
-					matches.push(warningTerms[index]);
-				}
-			});
-
-			return matches;
-		}
-
-		/**
-		 * Checks the specified node for matching warning comments and reports them.
-		 * @param {ASTNode} node The AST node being checked.
-		 * @returns {void} undefined.
-		 */
-		function checkComment(node) {
-			const comment = node.value;
-
-			if (
-				astUtils.isDirectiveComment(node) &&
-				selfConfigRegEx.test(comment)
-			) {
-				return;
-			}
-
-			const matches = commentContainsWarningTerm(comment);
-
-			matches.forEach(matchedTerm => {
-				let commentToDisplay = "";
-				let truncated = false;
-
-				for (const c of comment.trim().split(/\s+/u)) {
-					const tmp = commentToDisplay
-						? `${commentToDisplay} ${c}`
-						: c;
-
-					if (tmp.length <= CHAR_LIMIT) {
-						commentToDisplay = tmp;
-					} else {
-						truncated = true;
-						break;
-					}
-				}
-
-				context.report({
-					node,
-					messageId: "unexpectedComment",
-					data: {
-						matchedTerm,
-						comment: `${commentToDisplay}${truncated ? "..." : ""}`,
-					},
-				});
-			});
-		}
-
-		return {
-			Program() {
-				const comments = sourceCode.getAllComments();
-
-				comments
-					.filter(token => token.type !== "Shebang")
-					.forEach(checkComment);
-			},
-		};
-	},
-};