@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/handle-callback-err.js

@@ -1,122 +0,0 @@
-/**
- * @fileoverview Ensure handling of errors when we know they exist.
- * @author Jamund Ferguson
- * @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: "handle-callback-err",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/handle-callback-err.md",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description: "Require error handling in callbacks",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/handle-callback-err",
-		},
-
-		schema: [
-			{
-				type: "string",
-			},
-		],
-		messages: {
-			expected: "Expected error to be handled.",
-		},
-	},
-
-	create(context) {
-		const errorArgument = context.options[0] || "err";
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks if the given argument should be interpreted as a regexp pattern.
-		 * @param {string} stringToCheck The string which should be checked.
-		 * @returns {boolean} Whether or not the string should be interpreted as a pattern.
-		 */
-		function isPattern(stringToCheck) {
-			const firstChar = stringToCheck[0];
-
-			return firstChar === "^";
-		}
-
-		/**
-		 * Checks if the given name matches the configured error argument.
-		 * @param {string} name The name which should be compared.
-		 * @returns {boolean} Whether or not the given name matches the configured error variable name.
-		 */
-		function matchesConfiguredErrorName(name) {
-			if (isPattern(errorArgument)) {
-				const regexp = new RegExp(errorArgument, "u");
-
-				return regexp.test(name);
-			}
-			return name === errorArgument;
-		}
-
-		/**
-		 * Get the parameters of a given function scope.
-		 * @param {Object} scope The function scope.
-		 * @returns {Array} All parameters of the given scope.
-		 */
-		function getParameters(scope) {
-			return scope.variables.filter(
-				variable =>
-					variable.defs[0] && variable.defs[0].type === "Parameter",
-			);
-		}
-
-		/**
-		 * Check to see if we're handling the error object properly.
-		 * @param {ASTNode} node The AST node to check.
-		 * @returns {void}
-		 */
-		function checkForError(node) {
-			const scope = sourceCode.getScope(node),
-				parameters = getParameters(scope),
-				firstParameter = parameters[0];
-
-			if (
-				firstParameter &&
-				matchesConfiguredErrorName(firstParameter.name)
-			) {
-				if (firstParameter.references.length === 0) {
-					context.report({ node, messageId: "expected" });
-				}
-			}
-		}
-
-		return {
-			FunctionDeclaration: checkForError,
-			FunctionExpression: checkForError,
-			ArrowFunctionExpression: checkForError,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/id-blacklist.js

@@ -1,241 +0,0 @@
-/**
- * @fileoverview Rule that warns when identifier names that are
- * specified in the configuration are used.
- * @author Keith Cirkel (http://keithcirkel.co.uk)
- * @deprecated in ESLint v7.5.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether the given node represents assignment target in a normal assignment or destructuring.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is assignment target.
- */
-function isAssignmentTarget(node) {
-	const parent = node.parent;
-
-	return (
-		// normal assignment
-		(parent.type === "AssignmentExpression" && parent.left === node) ||
-		// destructuring
-		parent.type === "ArrayPattern" ||
-		parent.type === "RestElement" ||
-		(parent.type === "Property" &&
-			parent.value === node &&
-			parent.parent.type === "ObjectPattern") ||
-		(parent.type === "AssignmentPattern" && parent.left === node)
-	);
-}
-
-/**
- * Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
- *
- * Examples:
- * import { a as b } from 'mod'; // node `a` is renamed import
- * export { a as b } from 'mod'; // node `a` is renamed import
- * @param {ASTNode} node `Identifier` node to check.
- * @returns {boolean} `true` if the node is a renamed import.
- */
-function isRenamedImport(node) {
-	const parent = node.parent;
-
-	return (
-		(parent.type === "ImportSpecifier" &&
-			parent.imported !== parent.local &&
-			parent.imported === node) ||
-		(parent.type === "ExportSpecifier" &&
-			parent.parent.source && // re-export
-			parent.local !== parent.exported &&
-			parent.local === node)
-	);
-}
-
-/**
- * Checks whether the given node is a renamed identifier node in an ObjectPattern destructuring.
- *
- * Examples:
- * const { a : b } = foo; // node `a` is renamed node.
- * @param {ASTNode} node `Identifier` node to check.
- * @returns {boolean} `true` if the node is a renamed node in an ObjectPattern destructuring.
- */
-function isRenamedInDestructuring(node) {
-	const parent = node.parent;
-
-	return (
-		!parent.computed &&
-		parent.type === "Property" &&
-		parent.parent.type === "ObjectPattern" &&
-		parent.value !== node &&
-		parent.key === node
-	);
-}
-
-/**
- * Checks whether the given node represents shorthand definition of a property in an object literal.
- * @param {ASTNode} node `Identifier` node to check.
- * @returns {boolean} `true` if the node is a shorthand property definition.
- */
-function isShorthandPropertyDefinition(node) {
-	const parent = node.parent;
-
-	return (
-		parent.type === "Property" &&
-		parent.parent.type === "ObjectExpression" &&
-		parent.shorthand
-	);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "The rule was renamed.",
-			url: "https://eslint.org/blog/2020/07/eslint-v7.5.0-released/#deprecating-id-blacklist",
-			deprecatedSince: "7.5.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					rule: {
-						name: "id-denylist",
-						url: "https://eslint.org/docs/rules/id-denylist",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow specified identifiers",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/id-blacklist",
-		},
-
-		schema: {
-			type: "array",
-			items: {
-				type: "string",
-			},
-			uniqueItems: true,
-		},
-		messages: {
-			restricted: "Identifier '{{name}}' is restricted.",
-		},
-	},
-
-	create(context) {
-		const denyList = new Set(context.options);
-		const reportedNodes = new Set();
-		const sourceCode = context.sourceCode;
-
-		let globalScope;
-
-		/**
-		 * Checks whether the given name is restricted.
-		 * @param {string} name The name to check.
-		 * @returns {boolean} `true` if the name is restricted.
-		 * @private
-		 */
-		function isRestricted(name) {
-			return denyList.has(name);
-		}
-
-		/**
-		 * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
-		 * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
-		 * @param {ASTNode} node `Identifier` node to check.
-		 * @returns {boolean} `true` if the node is a reference to a global variable.
-		 */
-		function isReferenceToGlobalVariable(node) {
-			const variable = globalScope.set.get(node.name);
-
-			return (
-				variable &&
-				variable.defs.length === 0 &&
-				variable.references.some(ref => ref.identifier === node)
-			);
-		}
-
-		/**
-		 * Determines whether the given node should be checked.
-		 * @param {ASTNode} node `Identifier` node.
-		 * @returns {boolean} `true` if the node should be checked.
-		 */
-		function shouldCheck(node) {
-			const parent = node.parent;
-
-			/*
-			 * Member access has special rules for checking property names.
-			 * Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over.
-			 * Write access isn't allowed, because it potentially creates a new property with a restricted name.
-			 */
-			if (
-				parent.type === "MemberExpression" &&
-				parent.property === node &&
-				!parent.computed
-			) {
-				return isAssignmentTarget(parent);
-			}
-
-			return (
-				parent.type !== "CallExpression" &&
-				parent.type !== "NewExpression" &&
-				!isRenamedImport(node) &&
-				!isRenamedInDestructuring(node) &&
-				!(
-					isReferenceToGlobalVariable(node) &&
-					!isShorthandPropertyDefinition(node)
-				)
-			);
-		}
-
-		/**
-		 * Reports an AST node as a rule violation.
-		 * @param {ASTNode} node The node to report.
-		 * @returns {void}
-		 * @private
-		 */
-		function report(node) {
-			/*
-			 * We used the range instead of the node because it's possible
-			 * for the same identifier to be represented by two different
-			 * nodes, with the most clear example being shorthand properties:
-			 * { foo }
-			 * In this case, "foo" is represented by one node for the name
-			 * and one for the value. The only way to know they are the same
-			 * is to look at the range.
-			 */
-			if (!reportedNodes.has(node.range.toString())) {
-				context.report({
-					node,
-					messageId: "restricted",
-					data: {
-						name: node.name,
-					},
-				});
-				reportedNodes.add(node.range.toString());
-			}
-		}
-
-		return {
-			Program(node) {
-				globalScope = sourceCode.getScope(node);
-			},
-
-			Identifier(node) {
-				if (isRestricted(node.name) && shouldCheck(node)) {
-					report(node);
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/id-denylist.js

@@ -1,223 +0,0 @@
-/**
- * @fileoverview Rule that warns when identifier names that are
- * specified in the configuration are used.
- * @author Keith Cirkel (http://keithcirkel.co.uk)
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether the given node represents assignment target in a normal assignment or destructuring.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is assignment target.
- */
-function isAssignmentTarget(node) {
-	const parent = node.parent;
-
-	return (
-		// normal assignment
-		(parent.type === "AssignmentExpression" && parent.left === node) ||
-		// destructuring
-		parent.type === "ArrayPattern" ||
-		parent.type === "RestElement" ||
-		(parent.type === "Property" &&
-			parent.value === node &&
-			parent.parent.type === "ObjectPattern") ||
-		(parent.type === "AssignmentPattern" && parent.left === node)
-	);
-}
-
-/**
- * Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
- *
- * Examples:
- * import { a as b } from 'mod'; // node `a` is renamed import
- * export { a as b } from 'mod'; // node `a` is renamed import
- * @param {ASTNode} node `Identifier` node to check.
- * @returns {boolean} `true` if the node is a renamed import.
- */
-function isRenamedImport(node) {
-	const parent = node.parent;
-
-	return (
-		(parent.type === "ImportSpecifier" &&
-			parent.imported !== parent.local &&
-			parent.imported === node) ||
-		(parent.type === "ExportSpecifier" &&
-			parent.parent.source && // re-export
-			parent.local !== parent.exported &&
-			parent.local === node)
-	);
-}
-
-/**
- * Checks whether the given node is an ObjectPattern destructuring.
- *
- * Examples:
- * const { a : b } = foo;
- * @param {ASTNode} node `Identifier` node to check.
- * @returns {boolean} `true` if the node is in an ObjectPattern destructuring.
- */
-function isPropertyNameInDestructuring(node) {
-	const parent = node.parent;
-
-	return (
-		!parent.computed &&
-		parent.type === "Property" &&
-		parent.parent.type === "ObjectPattern" &&
-		parent.key === node
-	);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [],
-
-		docs: {
-			description: "Disallow specified identifiers",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/id-denylist",
-		},
-
-		schema: {
-			type: "array",
-			items: {
-				type: "string",
-			},
-			uniqueItems: true,
-		},
-		messages: {
-			restricted: "Identifier '{{name}}' is restricted.",
-			restrictedPrivate: "Identifier '#{{name}}' is restricted.",
-		},
-	},
-
-	create(context) {
-		const denyList = new Set(context.options);
-		const reportedNodes = new Set();
-		const sourceCode = context.sourceCode;
-
-		let globalScope;
-
-		/**
-		 * Checks whether the given name is restricted.
-		 * @param {string} name The name to check.
-		 * @returns {boolean} `true` if the name is restricted.
-		 * @private
-		 */
-		function isRestricted(name) {
-			return denyList.has(name);
-		}
-
-		/**
-		 * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
-		 * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
-		 * @param {ASTNode} node `Identifier` node to check.
-		 * @returns {boolean} `true` if the node is a reference to a global variable.
-		 */
-		function isReferenceToGlobalVariable(node) {
-			const variable = globalScope.set.get(node.name);
-
-			return (
-				variable &&
-				variable.defs.length === 0 &&
-				variable.references.some(ref => ref.identifier === node)
-			);
-		}
-
-		/**
-		 * Determines whether the given node should be checked.
-		 * @param {ASTNode} node `Identifier` node.
-		 * @returns {boolean} `true` if the node should be checked.
-		 */
-		function shouldCheck(node) {
-			// Import attributes are defined by environments, so naming conventions shouldn't apply to them
-			if (astUtils.isImportAttributeKey(node)) {
-				return false;
-			}
-
-			const parent = node.parent;
-
-			/*
-			 * Member access has special rules for checking property names.
-			 * Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over.
-			 * Write access isn't allowed, because it potentially creates a new property with a restricted name.
-			 */
-			if (
-				parent.type === "MemberExpression" &&
-				parent.property === node &&
-				!parent.computed
-			) {
-				return isAssignmentTarget(parent);
-			}
-
-			return (
-				parent.type !== "CallExpression" &&
-				parent.type !== "NewExpression" &&
-				!isRenamedImport(node) &&
-				!isPropertyNameInDestructuring(node) &&
-				!isReferenceToGlobalVariable(node)
-			);
-		}
-
-		/**
-		 * Reports an AST node as a rule violation.
-		 * @param {ASTNode} node The node to report.
-		 * @returns {void}
-		 * @private
-		 */
-		function report(node) {
-			/*
-			 * We used the range instead of the node because it's possible
-			 * for the same identifier to be represented by two different
-			 * nodes, with the most clear example being shorthand properties:
-			 * { foo }
-			 * In this case, "foo" is represented by one node for the name
-			 * and one for the value. The only way to know they are the same
-			 * is to look at the range.
-			 */
-			if (!reportedNodes.has(node.range.toString())) {
-				const isPrivate = node.type === "PrivateIdentifier";
-
-				context.report({
-					node,
-					messageId: isPrivate ? "restrictedPrivate" : "restricted",
-					data: {
-						name: node.name,
-					},
-				});
-				reportedNodes.add(node.range.toString());
-			}
-		}
-
-		return {
-			Program(node) {
-				globalScope = sourceCode.getScope(node);
-			},
-
-			[["Identifier", "PrivateIdentifier"]](node) {
-				if (isRestricted(node.name) && shouldCheck(node)) {
-					report(node);
-				}
-			},
-		};
-	},
-};