@alexlit/lint-kit 166.0.1 → 167.0.0

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

@@ -1,264 +0,0 @@
-/**
- * @fileoverview Rule to disallow returning values from Promise executor functions
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const functionTypesToCheck = new Set([
-	"ArrowFunctionExpression",
-	"FunctionExpression",
-]);
-
-/**
- * Determines whether the given function node is used as a Promise executor.
- * @param {ASTNode} node The node to check.
- * @param {SourceCode} sourceCode Source code to which the node belongs.
- * @returns {boolean} `true` if the node is a Promise executor.
- */
-function isPromiseExecutor(node, sourceCode) {
-	const parent = node.parent;
-
-	return (
-		parent.type === "NewExpression" &&
-		parent.arguments[0] === node &&
-		parent.callee.type === "Identifier" &&
-		parent.callee.name === "Promise" &&
-		sourceCode.isGlobalReference(parent.callee)
-	);
-}
-
-/**
- * Checks if the given node is a void expression.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} - `true` if the node is a void expression
- */
-function expressionIsVoid(node) {
-	return node.type === "UnaryExpression" && node.operator === "void";
-}
-
-/**
- * Fixes the linting error by prepending "void " to the given node
- * @param {Object} sourceCode context given by context.sourceCode
- * @param {ASTNode} node The node to fix.
- * @param {Object} fixer The fixer object provided by ESLint.
- * @returns {Array<Object>} - An array of fix objects to apply to the node.
- */
-function voidPrependFixer(sourceCode, node, fixer) {
-	const requiresParens =
-		// prepending `void ` will fail if the node has a lower precedence than void
-		astUtils.getPrecedence(node) <
-			astUtils.getPrecedence({
-				type: "UnaryExpression",
-				operator: "void",
-			}) &&
-		// check if there are parentheses around the node to avoid redundant parentheses
-		!astUtils.isParenthesised(sourceCode, node);
-
-	// avoid parentheses issues
-	const returnOrArrowToken = sourceCode.getTokenBefore(
-		node,
-		node.parent.type === "ArrowFunctionExpression"
-			? astUtils.isArrowToken
-			: // isReturnToken
-				token => token.type === "Keyword" && token.value === "return",
-	);
-
-	const firstToken = sourceCode.getTokenAfter(returnOrArrowToken);
-
-	const prependSpace =
-		// is return token, as => allows void to be adjacent
-		returnOrArrowToken.value === "return" &&
-		// If two tokens (return and "(") are adjacent
-		returnOrArrowToken.range[1] === firstToken.range[0];
-
-	return [
-		fixer.insertTextBefore(
-			firstToken,
-			`${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`,
-		),
-		fixer.insertTextAfter(node, requiresParens ? ")" : ""),
-	];
-}
-
-/**
- * Fixes the linting error by `wrapping {}` around the given node's body.
- * @param {Object} sourceCode context given by context.sourceCode
- * @param {ASTNode} node The node to fix.
- * @param {Object} fixer The fixer object provided by ESLint.
- * @returns {Array<Object>} - An array of fix objects to apply to the node.
- */
-function curlyWrapFixer(sourceCode, node, fixer) {
-	// https://github.com/eslint/eslint/pull/17282#issuecomment-1592795923
-	const arrowToken = sourceCode.getTokenBefore(
-		node.body,
-		astUtils.isArrowToken,
-	);
-	const firstToken = sourceCode.getTokenAfter(arrowToken);
-	const lastToken = sourceCode.getLastToken(node);
-
-	return [
-		fixer.insertTextBefore(firstToken, "{"),
-		fixer.insertTextAfter(lastToken, "}"),
-	];
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				allowVoid: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Disallow returning values from Promise executor functions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-promise-executor-return",
-		},
-
-		hasSuggestions: true,
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowVoid: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			returnsValue:
-				"Return values from promise executor functions cannot be read.",
-
-			// arrow and function suggestions
-			prependVoid: "Prepend `void` to the expression.",
-
-			// only arrow suggestions
-			wrapBraces: "Wrap the expression in `{}`.",
-		},
-	},
-
-	create(context) {
-		let funcInfo = null;
-		const sourceCode = context.sourceCode;
-		const [{ allowVoid }] = context.options;
-
-		return {
-			onCodePathStart(_, node) {
-				funcInfo = {
-					upper: funcInfo,
-					shouldCheck:
-						functionTypesToCheck.has(node.type) &&
-						isPromiseExecutor(node, sourceCode),
-				};
-
-				if (
-					// Is a Promise executor
-					funcInfo.shouldCheck &&
-					node.type === "ArrowFunctionExpression" &&
-					node.expression &&
-					// Except void
-					!(allowVoid && expressionIsVoid(node.body))
-				) {
-					const suggest = [];
-
-					// prevent useless refactors
-					if (allowVoid) {
-						suggest.push({
-							messageId: "prependVoid",
-							fix(fixer) {
-								return voidPrependFixer(
-									sourceCode,
-									node.body,
-									fixer,
-								);
-							},
-						});
-					}
-
-					// Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
-					if (
-						!(
-							node.body.type === "FunctionExpression" &&
-							!node.body.id
-						)
-					) {
-						suggest.push({
-							messageId: "wrapBraces",
-							fix(fixer) {
-								return curlyWrapFixer(sourceCode, node, fixer);
-							},
-						});
-					}
-
-					context.report({
-						node: node.body,
-						messageId: "returnsValue",
-						suggest,
-					});
-				}
-			},
-
-			onCodePathEnd() {
-				funcInfo = funcInfo.upper;
-			},
-
-			ReturnStatement(node) {
-				if (!(funcInfo.shouldCheck && node.argument)) {
-					return;
-				}
-
-				// node is `return <expression>`
-				if (!allowVoid) {
-					context.report({ node, messageId: "returnsValue" });
-					return;
-				}
-
-				if (expressionIsVoid(node.argument)) {
-					return;
-				}
-
-				// allowVoid && !expressionIsVoid
-				context.report({
-					node,
-					messageId: "returnsValue",
-					suggest: [
-						{
-							messageId: "prependVoid",
-							fix(fixer) {
-								return voidPrependFixer(
-									sourceCode,
-									node.argument,
-									fixer,
-								);
-							},
-						},
-					],
-				});
-			},
-		};
-	},
-};

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

@@ -1,45 +0,0 @@
-/**
- * @fileoverview Rule to flag usage of __proto__ property
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { getStaticPropertyName } = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow the use of the `__proto__` property",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-proto",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpectedProto: "The '__proto__' property is deprecated.",
-		},
-	},
-
-	create(context) {
-		return {
-			MemberExpression(node) {
-				if (getStaticPropertyName(node) === "__proto__") {
-					context.report({ node, messageId: "unexpectedProto" });
-				}
-			},
-		};
-	},
-};

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

@@ -1,181 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of Object.prototype builtins on objects
- * @author Andrew Levine
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Returns true if the node or any of the objects
- * to the left of it in the member/call chain is optional.
- *
- * e.g. `a?.b`, `a?.b.c`, `a?.()`, `a()?.()`
- * @param {ASTNode} node The expression to check
- * @returns {boolean} `true` if there is a short-circuiting optional `?.`
- * in the same option chain to the left of this call or member expression,
- * or the node itself is an optional call or member `?.`.
- */
-function isAfterOptional(node) {
-	let leftNode;
-
-	if (node.type === "MemberExpression") {
-		leftNode = node.object;
-	} else if (node.type === "CallExpression") {
-		leftNode = node.callee;
-	} else {
-		return false;
-	}
-	if (node.optional) {
-		return true;
-	}
-	return isAfterOptional(leftNode);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description:
-				"Disallow calling some `Object.prototype` methods directly on objects",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-prototype-builtins",
-		},
-
-		hasSuggestions: true,
-
-		schema: [],
-
-		messages: {
-			prototypeBuildIn:
-				"Do not access Object.prototype method '{{prop}}' from target object.",
-			callObjectPrototype: "Call Object.prototype.{{prop}} explicitly.",
-		},
-	},
-
-	create(context) {
-		const DISALLOWED_PROPS = new Set([
-			"hasOwnProperty",
-			"isPrototypeOf",
-			"propertyIsEnumerable",
-		]);
-
-		/**
-		 * Reports if a disallowed property is used in a CallExpression
-		 * @param {ASTNode} node The CallExpression node.
-		 * @returns {void}
-		 */
-		function disallowBuiltIns(node) {
-			const callee = astUtils.skipChainExpression(node.callee);
-
-			if (callee.type !== "MemberExpression") {
-				return;
-			}
-
-			const propName = astUtils.getStaticPropertyName(callee);
-
-			if (propName !== null && DISALLOWED_PROPS.has(propName)) {
-				context.report({
-					messageId: "prototypeBuildIn",
-					loc: callee.property.loc,
-					data: { prop: propName },
-					node,
-					suggest: [
-						{
-							messageId: "callObjectPrototype",
-							data: { prop: propName },
-							fix(fixer) {
-								const sourceCode = context.sourceCode;
-
-								/*
-								 * A call after an optional chain (e.g. a?.b.hasOwnProperty(c))
-								 * must be fixed manually because the call can be short-circuited
-								 */
-								if (isAfterOptional(node)) {
-									return null;
-								}
-
-								/*
-								 * A call on a ChainExpression (e.g. (a?.hasOwnProperty)(c)) will trigger
-								 * no-unsafe-optional-chaining which should be fixed before this suggestion
-								 */
-								if (node.callee.type === "ChainExpression") {
-									return null;
-								}
-
-								const objectVariable =
-									astUtils.getVariableByName(
-										sourceCode.getScope(node),
-										"Object",
-									);
-
-								/*
-								 * We can't use Object if the global Object was shadowed,
-								 * or Object does not exist in the global scope for some reason
-								 */
-								if (
-									!objectVariable ||
-									objectVariable.scope.type !== "global" ||
-									objectVariable.defs.length > 0
-								) {
-									return null;
-								}
-
-								let objectText = sourceCode.getText(
-									callee.object,
-								);
-
-								if (
-									astUtils.getPrecedence(callee.object) <=
-									astUtils.getPrecedence({
-										type: "SequenceExpression",
-									})
-								) {
-									objectText = `(${objectText})`;
-								}
-
-								const openParenToken = sourceCode.getTokenAfter(
-									node.callee,
-									astUtils.isOpeningParenToken,
-								);
-								const isEmptyParameters =
-									node.arguments.length === 0;
-								const delim = isEmptyParameters ? "" : ", ";
-								const fixes = [
-									fixer.replaceText(
-										callee,
-										`Object.prototype.${propName}.call`,
-									),
-									fixer.insertTextAfter(
-										openParenToken,
-										objectText + delim,
-									),
-								];
-
-								return fixes;
-							},
-						},
-					],
-				});
-			}
-		}
-
-		return {
-			CallExpression: disallowBuiltIns,
-		};
-	},
-};

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

@@ -1,173 +0,0 @@
-/**
- * @fileoverview Rule to flag when the same variable is declared more then once.
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [{ builtinGlobals: true }],
-
-		docs: {
-			description: "Disallow variable redeclaration",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-redeclare",
-		},
-
-		messages: {
-			redeclared: "'{{id}}' is already defined.",
-			redeclaredAsBuiltin:
-				"'{{id}}' is already defined as a built-in global variable.",
-			redeclaredBySyntax:
-				"'{{id}}' is already defined by a variable declaration.",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					builtinGlobals: { type: "boolean" },
-				},
-				additionalProperties: false,
-			},
-		],
-	},
-
-	create(context) {
-		const [{ builtinGlobals }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Iterate declarations of a given variable.
-		 * @param {escope.variable} variable The variable object to iterate declarations.
-		 * @returns {IterableIterator<{type:string,node:ASTNode,loc:SourceLocation}>} The declarations.
-		 */
-		function* iterateDeclarations(variable) {
-			if (
-				builtinGlobals &&
-				(variable.eslintImplicitGlobalSetting === "readonly" ||
-					variable.eslintImplicitGlobalSetting === "writable")
-			) {
-				yield { type: "builtin" };
-			}
-
-			for (const id of variable.identifiers) {
-				yield { type: "syntax", node: id, loc: id.loc };
-			}
-
-			if (variable.eslintExplicitGlobalComments) {
-				for (const comment of variable.eslintExplicitGlobalComments) {
-					yield {
-						type: "comment",
-						node: comment,
-						loc: astUtils.getNameLocationInGlobalDirectiveComment(
-							sourceCode,
-							comment,
-							variable.name,
-						),
-					};
-				}
-			}
-		}
-
-		/**
-		 * Find variables in a given scope and flag redeclared ones.
-		 * @param {Scope} scope An eslint-scope scope object.
-		 * @returns {void}
-		 * @private
-		 */
-		function findVariablesInScope(scope) {
-			for (const variable of scope.variables) {
-				const [declaration, ...extraDeclarations] =
-					iterateDeclarations(variable);
-
-				if (extraDeclarations.length === 0) {
-					continue;
-				}
-
-				/*
-				 * If the type of a declaration is different from the type of
-				 * the first declaration, it shows the location of the first
-				 * declaration.
-				 */
-				const detailMessageId =
-					declaration.type === "builtin"
-						? "redeclaredAsBuiltin"
-						: "redeclaredBySyntax";
-				const data = { id: variable.name };
-
-				// Report extra declarations.
-				for (const { type, node, loc } of extraDeclarations) {
-					const messageId =
-						type === declaration.type
-							? "redeclared"
-							: detailMessageId;
-
-					context.report({ node, loc, messageId, data });
-				}
-			}
-		}
-
-		/**
-		 * Find variables in the current scope.
-		 * @param {ASTNode} node The node of the current scope.
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForBlock(node) {
-			const scope = sourceCode.getScope(node);
-
-			/*
-			 * In ES5, some node type such as `BlockStatement` doesn't have that scope.
-			 * `scope.block` is a different node in such a case.
-			 */
-			if (scope.block === node) {
-				findVariablesInScope(scope);
-			}
-		}
-
-		return {
-			Program(node) {
-				const scope = sourceCode.getScope(node);
-
-				findVariablesInScope(scope);
-
-				// Node.js or ES modules has a special scope.
-				if (
-					scope.type === "global" &&
-					scope.childScopes[0] &&
-					// The special scope's block is the Program node.
-					scope.block === scope.childScopes[0].block
-				) {
-					findVariablesInScope(scope.childScopes[0]);
-				}
-			},
-
-			FunctionDeclaration: checkForBlock,
-			FunctionExpression: checkForBlock,
-			ArrowFunctionExpression: checkForBlock,
-
-			StaticBlock: checkForBlock,
-
-			BlockStatement: checkForBlock,
-			ForStatement: checkForBlock,
-			ForInStatement: checkForBlock,
-			ForOfStatement: checkForBlock,
-			SwitchStatement: checkForBlock,
-		};
-	},
-};