@alexlit/lint-kit 166.0.1 → 167.0.0

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

@@ -1,170 +0,0 @@
-/**
- * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { getStaticValue } = require("@eslint-community/eslint-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow the use of `eval()`-like methods",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-implied-eval",
-		},
-
-		schema: [],
-
-		messages: {
-			impliedEval:
-				"Implied eval. Consider passing a function instead of a string.",
-			execScript: "Implied eval. Do not use execScript().",
-		},
-	},
-
-	create(context) {
-		const GLOBAL_CANDIDATES = Object.freeze([
-			"global",
-			"window",
-			"globalThis",
-		]);
-		const EVAL_LIKE_FUNC_PATTERN =
-			/^(?:set(?:Interval|Timeout)|execScript)$/u;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks whether a node is evaluated as a string or not.
-		 * @param {ASTNode} node A node to check.
-		 * @returns {boolean} True if the node is evaluated as a string.
-		 */
-		function isEvaluatedString(node) {
-			if (
-				(node.type === "Literal" && typeof node.value === "string") ||
-				node.type === "TemplateLiteral"
-			) {
-				return true;
-			}
-			if (node.type === "BinaryExpression" && node.operator === "+") {
-				return (
-					isEvaluatedString(node.left) ||
-					isEvaluatedString(node.right)
-				);
-			}
-			return false;
-		}
-
-		/**
-		 * Reports if the `CallExpression` node has evaluated argument.
-		 * @param {ASTNode} node A CallExpression to check.
-		 * @returns {void}
-		 */
-		function reportImpliedEvalCallExpression(node) {
-			const [firstArgument] = node.arguments;
-
-			if (firstArgument) {
-				const staticValue = getStaticValue(
-					firstArgument,
-					sourceCode.getScope(node),
-				);
-				const isStaticString =
-					staticValue && typeof staticValue.value === "string";
-				const isString =
-					isStaticString || isEvaluatedString(firstArgument);
-
-				if (isString) {
-					const calleeName =
-						node.callee.type === "Identifier"
-							? node.callee.name
-							: astUtils.getStaticPropertyName(node.callee);
-					const isExecScript = calleeName === "execScript";
-					context.report({
-						node,
-						messageId: isExecScript ? "execScript" : "impliedEval",
-					});
-				}
-			}
-		}
-
-		/**
-		 * Reports calls of `implied eval` via the global references.
-		 * @param {Variable} globalVar A global variable to check.
-		 * @returns {void}
-		 */
-		function reportImpliedEvalViaGlobal(globalVar) {
-			const { references, name } = globalVar;
-
-			references.forEach(ref => {
-				const identifier = ref.identifier;
-				let node = identifier.parent;
-
-				while (astUtils.isSpecificMemberAccess(node, null, name)) {
-					node = node.parent;
-				}
-
-				if (
-					astUtils.isSpecificMemberAccess(
-						node,
-						null,
-						EVAL_LIKE_FUNC_PATTERN,
-					)
-				) {
-					const calleeNode =
-						node.parent.type === "ChainExpression"
-							? node.parent
-							: node;
-					const parent = calleeNode.parent;
-
-					if (
-						parent.type === "CallExpression" &&
-						parent.callee === calleeNode
-					) {
-						reportImpliedEvalCallExpression(parent);
-					}
-				}
-			});
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			CallExpression(node) {
-				if (
-					astUtils.isSpecificId(
-						node.callee,
-						EVAL_LIKE_FUNC_PATTERN,
-					) &&
-					sourceCode.isGlobalReference(node.callee)
-				) {
-					reportImpliedEvalCallExpression(node);
-				}
-			},
-			"Program:exit"(node) {
-				const globalScope = sourceCode.getScope(node);
-
-				GLOBAL_CANDIDATES.map(candidate =>
-					astUtils.getVariableByName(globalScope, candidate),
-				)
-					.filter(
-						globalVar => !!globalVar && globalVar.defs.length === 0,
-					)
-					.forEach(reportImpliedEvalViaGlobal);
-			},
-		};
-	},
-};

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

@@ -1,227 +0,0 @@
-/**
- * @fileoverview Rule to flag updates of imported bindings.
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const { findVariable } = require("@eslint-community/eslint-utils");
-const astUtils = require("./utils/ast-utils");
-
-const WellKnownMutationFunctions = {
-	Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u,
-	Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u,
-};
-
-/**
- * Check if a given node is LHS of an assignment node.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is LHS.
- */
-function isAssignmentLeft(node) {
-	const { parent } = node;
-
-	return (
-		(parent.type === "AssignmentExpression" && parent.left === node) ||
-		// Destructuring assignments
-		parent.type === "ArrayPattern" ||
-		(parent.type === "Property" &&
-			parent.value === node &&
-			parent.parent.type === "ObjectPattern") ||
-		parent.type === "RestElement" ||
-		(parent.type === "AssignmentPattern" && parent.left === node)
-	);
-}
-
-/**
- * Check if a given node is the operand of mutation unary operator.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is the operand of mutation unary operator.
- */
-function isOperandOfMutationUnaryOperator(node) {
-	const argumentNode =
-		node.parent.type === "ChainExpression" ? node.parent : node;
-	const { parent } = argumentNode;
-
-	return (
-		(parent.type === "UpdateExpression" &&
-			parent.argument === argumentNode) ||
-		(parent.type === "UnaryExpression" &&
-			parent.operator === "delete" &&
-			parent.argument === argumentNode)
-	);
-}
-
-/**
- * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is the iteration variable.
- */
-function isIterationVariable(node) {
-	const { parent } = node;
-
-	return (
-		(parent.type === "ForInStatement" && parent.left === node) ||
-		(parent.type === "ForOfStatement" && parent.left === node)
-	);
-}
-
-/**
- * Check if a given node is at the first argument of a well-known mutation function.
- * - `Object.assign`
- * - `Object.defineProperty`
- * - `Object.defineProperties`
- * - `Object.freeze`
- * - `Object.setPrototypeOf`
- * - `Reflect.defineProperty`
- * - `Reflect.deleteProperty`
- * - `Reflect.set`
- * - `Reflect.setPrototypeOf`
- * @param {ASTNode} node The node to check.
- * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
- * @returns {boolean} `true` if the node is at the first argument of a well-known mutation function.
- */
-function isArgumentOfWellKnownMutationFunction(node, scope) {
-	const { parent } = node;
-
-	if (parent.type !== "CallExpression" || parent.arguments[0] !== node) {
-		return false;
-	}
-	const callee = astUtils.skipChainExpression(parent.callee);
-
-	if (
-		!astUtils.isSpecificMemberAccess(
-			callee,
-			"Object",
-			WellKnownMutationFunctions.Object,
-		) &&
-		!astUtils.isSpecificMemberAccess(
-			callee,
-			"Reflect",
-			WellKnownMutationFunctions.Reflect,
-		)
-	) {
-		return false;
-	}
-	const variable = findVariable(scope, callee.object);
-
-	return variable !== null && variable.scope.type === "global";
-}
-
-/**
- * Check if the identifier node is placed at to update members.
- * @param {ASTNode} id The Identifier node to check.
- * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
- * @returns {boolean} `true` if the member of `id` was updated.
- */
-function isMemberWrite(id, scope) {
-	const { parent } = id;
-
-	return (
-		(parent.type === "MemberExpression" &&
-			parent.object === id &&
-			(isAssignmentLeft(parent) ||
-				isOperandOfMutationUnaryOperator(parent) ||
-				isIterationVariable(parent))) ||
-		isArgumentOfWellKnownMutationFunction(id, scope)
-	);
-}
-
-/**
- * Get the mutation node.
- * @param {ASTNode} id The Identifier node to get.
- * @returns {ASTNode} The mutation node.
- */
-function getWriteNode(id) {
-	let node = id.parent;
-
-	while (
-		node &&
-		node.type !== "AssignmentExpression" &&
-		node.type !== "UpdateExpression" &&
-		node.type !== "UnaryExpression" &&
-		node.type !== "CallExpression" &&
-		node.type !== "ForInStatement" &&
-		node.type !== "ForOfStatement"
-	) {
-		node = node.parent;
-	}
-
-	return node || id;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow assigning to imported bindings",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-import-assign",
-		},
-
-		schema: [],
-
-		messages: {
-			readonly: "'{{name}}' is read-only.",
-			readonlyMember: "The members of '{{name}}' are read-only.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			ImportDeclaration(node) {
-				const scope = sourceCode.getScope(node);
-
-				for (const variable of sourceCode.getDeclaredVariables(node)) {
-					const shouldCheckMembers = variable.defs.some(
-						d => d.node.type === "ImportNamespaceSpecifier",
-					);
-					let prevIdNode = null;
-
-					for (const reference of variable.references) {
-						const idNode = reference.identifier;
-
-						/*
-						 * AssignmentPattern (e.g. `[a = 0] = b`) makes two write
-						 * references for the same identifier. This should skip
-						 * the one of the two in order to prevent redundant reports.
-						 */
-						if (idNode === prevIdNode) {
-							continue;
-						}
-						prevIdNode = idNode;
-
-						if (reference.isWrite()) {
-							context.report({
-								node: getWriteNode(idNode),
-								messageId: "readonly",
-								data: { name: idNode.name },
-							});
-						} else if (
-							shouldCheckMembers &&
-							isMemberWrite(idNode, scope)
-						) {
-							context.report({
-								node: getWriteNode(idNode),
-								messageId: "readonlyMember",
-								data: { name: idNode.name },
-							});
-						}
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,115 +0,0 @@
-/**
- * @fileoverview Enforces or disallows inline comments.
- * @author Greg Cochard
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [{}],
-
-		docs: {
-			description: "Disallow inline comments after code",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-inline-comments",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					ignorePattern: {
-						type: "string",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedInlineComment: "Unexpected comment inline with code.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ ignorePattern }] = context.options;
-		const customIgnoreRegExp =
-			ignorePattern && new RegExp(ignorePattern, "u");
-
-		/**
-		 * Will check that comments are not on lines starting with or ending with code
-		 * @param {ASTNode} node The comment node to check
-		 * @private
-		 * @returns {void}
-		 */
-		function testCodeAroundComment(node) {
-			const startLine = String(sourceCode.lines[node.loc.start.line - 1]),
-				endLine = String(sourceCode.lines[node.loc.end.line - 1]),
-				preamble = startLine.slice(0, node.loc.start.column).trim(),
-				postamble = endLine.slice(node.loc.end.column).trim(),
-				isPreambleEmpty = !preamble,
-				isPostambleEmpty = !postamble;
-
-			// Nothing on both sides
-			if (isPreambleEmpty && isPostambleEmpty) {
-				return;
-			}
-
-			// Matches the ignore pattern
-			if (customIgnoreRegExp && customIgnoreRegExp.test(node.value)) {
-				return;
-			}
-
-			// JSX Exception
-			if (
-				(isPreambleEmpty || preamble === "{") &&
-				(isPostambleEmpty || postamble === "}")
-			) {
-				const enclosingNode = sourceCode.getNodeByRangeIndex(
-					node.range[0],
-				);
-
-				if (
-					enclosingNode &&
-					enclosingNode.type === "JSXEmptyExpression"
-				) {
-					return;
-				}
-			}
-
-			// Don't report ESLint directive comments
-			if (astUtils.isDirectiveComment(node)) {
-				return;
-			}
-
-			context.report({
-				node,
-				messageId: "unexpectedInlineComment",
-			});
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			Program() {
-				sourceCode
-					.getAllComments()
-					.filter(token => token.type !== "Shebang")
-					.forEach(testCodeAroundComment);
-			},
-		};
-	},
-};

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

@@ -1,147 +0,0 @@
-/**
- * @fileoverview Rule to enforce declarations in program or function body root.
- * @author Brandon Mills
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const validParent = new Set([
-	"Program",
-	"StaticBlock",
-	"ExportNamedDeclaration",
-	"ExportDefaultDeclaration",
-]);
-const validBlockStatementParent = new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression",
-]);
-
-/**
- * Finds the nearest enclosing context where this rule allows declarations and returns its description.
- * @param {ASTNode} node Node to search from.
- * @returns {string} Description. One of "program", "function body", "class static block body".
- */
-function getAllowedBodyDescription(node) {
-	let { parent } = node;
-
-	while (parent) {
-		if (parent.type === "StaticBlock") {
-			return "class static block body";
-		}
-
-		if (astUtils.isFunction(parent)) {
-			return "function body";
-		}
-
-		({ parent } = parent);
-	}
-
-	return "program";
-}
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: ["functions", { blockScopedFunctions: "allow" }],
-
-		docs: {
-			description:
-				"Disallow variable or `function` declarations in nested blocks",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-inner-declarations",
-		},
-
-		schema: [
-			{
-				enum: ["functions", "both"],
-			},
-			{
-				type: "object",
-				properties: {
-					blockScopedFunctions: {
-						enum: ["allow", "disallow"],
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			moveDeclToRoot: "Move {{type}} declaration to {{body}} root.",
-		},
-	},
-
-	create(context) {
-		const both = context.options[0] === "both";
-		const { blockScopedFunctions } = context.options[1];
-
-		const sourceCode = context.sourceCode;
-		const ecmaVersion = context.languageOptions.ecmaVersion;
-
-		/**
-		 * Ensure that a given node is at a program or function body's root.
-		 * @param {ASTNode} node Declaration node to check.
-		 * @returns {void}
-		 */
-		function check(node) {
-			const parent = node.parent;
-
-			if (
-				parent.type === "BlockStatement" &&
-				validBlockStatementParent.has(parent.parent.type)
-			) {
-				return;
-			}
-
-			if (validParent.has(parent.type)) {
-				return;
-			}
-
-			context.report({
-				node,
-				messageId: "moveDeclToRoot",
-				data: {
-					type:
-						node.type === "FunctionDeclaration"
-							? "function"
-							: "variable",
-					body: getAllowedBodyDescription(node),
-				},
-			});
-		}
-
-		return {
-			FunctionDeclaration(node) {
-				const isInStrictCode = sourceCode.getScope(node).upper.isStrict;
-
-				if (
-					blockScopedFunctions === "allow" &&
-					ecmaVersion >= 2015 &&
-					isInStrictCode
-				) {
-					return;
-				}
-
-				check(node);
-			},
-			VariableDeclaration(node) {
-				if (both && node.kind === "var") {
-					check(node);
-				}
-			},
-		};
-	},
-};