@alexlit/lint-kit 183.1.0 → 183.2.0

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

@@ -1,236 +0,0 @@
-/**
- * @fileoverview Rule to disallow empty functions.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const ALLOW_OPTIONS = Object.freeze([
-	"functions",
-	"arrowFunctions",
-	"generatorFunctions",
-	"methods",
-	"generatorMethods",
-	"getters",
-	"setters",
-	"constructors",
-	"asyncFunctions",
-	"asyncMethods",
-	"privateConstructors",
-	"protectedConstructors",
-	"decoratedFunctions",
-	"overrideMethods",
-]);
-
-/**
- * Gets the kind of a given function node.
- * @param {ASTNode} node A function node to get. This is one of
- *      an ArrowFunctionExpression, a FunctionDeclaration, or a
- *      FunctionExpression.
- * @returns {string} The kind of the function. This is one of "functions",
- *      "arrowFunctions", "generatorFunctions", "asyncFunctions", "methods",
- *      "generatorMethods", "asyncMethods", "getters", "setters", and
- *      "constructors".
- */
-function getKind(node) {
-	const parent = node.parent;
-	let kind;
-
-	if (node.type === "ArrowFunctionExpression") {
-		return "arrowFunctions";
-	}
-
-	// Detects main kind.
-	if (parent.type === "Property") {
-		if (parent.kind === "get") {
-			return "getters";
-		}
-		if (parent.kind === "set") {
-			return "setters";
-		}
-		kind = parent.method ? "methods" : "functions";
-	} else if (parent.type === "MethodDefinition") {
-		if (parent.kind === "get") {
-			return "getters";
-		}
-		if (parent.kind === "set") {
-			return "setters";
-		}
-		if (parent.kind === "constructor") {
-			return "constructors";
-		}
-		kind = "methods";
-	} else {
-		kind = "functions";
-	}
-
-	// Detects prefix.
-	let prefix;
-
-	if (node.generator) {
-		prefix = "generator";
-	} else if (node.async) {
-		prefix = "async";
-	} else {
-		return kind;
-	}
-	return prefix + kind[0].toUpperCase() + kind.slice(1);
-}
-
-/**
- * Checks if a constructor function has parameter properties.
- * @param {ASTNode} node The function node to examine.
- * @returns {boolean} True if the constructor has parameter properties, false otherwise.
- */
-function isParameterPropertiesConstructor(node) {
-	return node.params.some(param => param.type === "TSParameterProperty");
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
-		hasSuggestions: true,
-		type: "suggestion",
-
-		defaultOptions: [{ allow: [] }],
-
-		docs: {
-			description: "Disallow empty functions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-empty-function",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allow: {
-						type: "array",
-						items: { enum: ALLOW_OPTIONS },
-						uniqueItems: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpected: "Unexpected empty {{name}}.",
-			suggestComment: "Add comment inside empty {{name}}.",
-		},
-	},
-
-	create(context) {
-		const [{ allow }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks if the given function node is allowed to be empty.
-		 * @param {ASTNode} node The function node to check.
-		 * @returns {boolean} True if the function is allowed to be empty, false otherwise.
-		 */
-		function isAllowedEmptyFunction(node) {
-			const kind = getKind(node);
-
-			if (allow.includes(kind)) {
-				return true;
-			}
-
-			if (kind === "constructors") {
-				if (
-					(node.parent.accessibility === "private" &&
-						allow.includes("privateConstructors")) ||
-					(node.parent.accessibility === "protected" &&
-						allow.includes("protectedConstructors")) ||
-					isParameterPropertiesConstructor(node)
-				) {
-					return true;
-				}
-			}
-
-			if (/(?:g|s)etters|methods$/iu.test(kind)) {
-				if (
-					(node.parent.decorators?.length &&
-						allow.includes("decoratedFunctions")) ||
-					(node.parent.override && allow.includes("overrideMethods"))
-				) {
-					return true;
-				}
-			}
-
-			return false;
-		}
-
-		/**
-		 * Reports a given function node if the node matches the following patterns.
-		 *
-		 * - Not allowed by options.
-		 * - The body is empty.
-		 * - The body doesn't have any comments.
-		 * @param {ASTNode} node A function node to report. This is one of
-		 *      an ArrowFunctionExpression, a FunctionDeclaration, or a
-		 *      FunctionExpression.
-		 * @returns {void}
-		 */
-		function reportIfEmpty(node) {
-			const name = astUtils.getFunctionNameWithKind(node);
-			const innerComments = sourceCode.getTokens(node.body, {
-				includeComments: true,
-				filter: astUtils.isCommentToken,
-			});
-
-			if (
-				!isAllowedEmptyFunction(node) &&
-				node.body.type === "BlockStatement" &&
-				node.body.body.length === 0 &&
-				innerComments.length === 0
-			) {
-				context.report({
-					node,
-					loc: node.body.loc,
-					messageId: "unexpected",
-					data: { name },
-					suggest: [
-						{
-							messageId: "suggestComment",
-							data: { name },
-							fix(fixer) {
-								const range = [
-									node.body.range[0] + 1,
-									node.body.range[1] - 1,
-								];
-
-								return fixer.replaceTextRange(
-									range,
-									" /* empty */ ",
-								);
-							},
-						},
-					],
-				});
-			}
-		}
-
-		return {
-			ArrowFunctionExpression: reportIfEmpty,
-			FunctionDeclaration: reportIfEmpty,
-			FunctionExpression: reportIfEmpty,
-		};
-	},
-};

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

@@ -1,85 +0,0 @@
-/**
- * @fileoverview Rule to disallow an empty pattern
- * @author Alberto Rodríguez
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				allowObjectPatternsAsParameters: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow empty destructuring patterns",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-empty-pattern",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowObjectPatternsAsParameters: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpected: "Unexpected empty {{type}} pattern.",
-		},
-	},
-
-	create(context) {
-		const [{ allowObjectPatternsAsParameters }] = context.options;
-
-		return {
-			ObjectPattern(node) {
-				if (node.properties.length > 0) {
-					return;
-				}
-
-				// Allow {} and {} = {} empty object patterns as parameters when allowObjectPatternsAsParameters is true
-				if (
-					allowObjectPatternsAsParameters &&
-					(astUtils.isFunction(node.parent) ||
-						(node.parent.type === "AssignmentPattern" &&
-							astUtils.isFunction(node.parent.parent) &&
-							node.parent.right.type === "ObjectExpression" &&
-							node.parent.right.properties.length === 0))
-				) {
-					return;
-				}
-
-				context.report({
-					node,
-					messageId: "unexpected",
-					data: { type: "object" },
-				});
-			},
-			ArrayPattern(node) {
-				if (node.elements.length === 0) {
-					context.report({
-						node,
-						messageId: "unexpected",
-						data: { type: "array" },
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-empty-static-block.js

@@ -1,73 +0,0 @@
-/**
- * @fileoverview Rule to disallow empty static blocks.
- * @author Sosuke Suzuki
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		hasSuggestions: true,
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow empty static blocks",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-empty-static-block",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Unexpected empty static block.",
-			suggestComment: "Add comment inside empty static block.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			StaticBlock(node) {
-				if (node.body.length === 0) {
-					const openingBrace = sourceCode.getFirstToken(node, {
-						skip: 1,
-					});
-					const closingBrace = sourceCode.getLastToken(node);
-
-					if (
-						sourceCode.getCommentsBefore(closingBrace).length === 0
-					) {
-						context.report({
-							loc: {
-								start: openingBrace.loc.start,
-								end: closingBrace.loc.end,
-							},
-							messageId: "unexpected",
-							suggest: [
-								{
-									messageId: "suggestComment",
-									fix(fixer) {
-										const range = [
-											openingBrace.range[1],
-											closingBrace.range[0],
-										];
-
-										return fixer.replaceTextRange(
-											range,
-											" /* empty */ ",
-										);
-									},
-								},
-							],
-						});
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,153 +0,0 @@
-/**
- * @fileoverview Rule to flag use of an empty block statement
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		hasSuggestions: true,
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allowEmptyCatch: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow empty block statements",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-empty",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowEmptyCatch: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpected: "Empty {{type}} statement.",
-			suggestComment: "Add comment inside empty {{type}} statement.",
-		},
-	},
-
-	create(context) {
-		const [{ allowEmptyCatch }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		return {
-			BlockStatement(node) {
-				// if the body is not empty, we can just return immediately
-				if (node.body.length !== 0) {
-					return;
-				}
-
-				// a function is generally allowed to be empty
-				if (astUtils.isFunction(node.parent)) {
-					return;
-				}
-
-				if (allowEmptyCatch && node.parent.type === "CatchClause") {
-					return;
-				}
-
-				// any other block is only allowed to be empty, if it contains a comment
-				if (sourceCode.getCommentsInside(node).length > 0) {
-					return;
-				}
-
-				context.report({
-					node,
-					messageId: "unexpected",
-					data: { type: "block" },
-					suggest: [
-						{
-							messageId: "suggestComment",
-							data: { type: "block" },
-							fix(fixer) {
-								const range = [
-									node.range[0] + 1,
-									node.range[1] - 1,
-								];
-
-								return fixer.replaceTextRange(
-									range,
-									" /* empty */ ",
-								);
-							},
-						},
-					],
-				});
-			},
-
-			SwitchStatement(node) {
-				if (
-					typeof node.cases === "undefined" ||
-					node.cases.length === 0
-				) {
-					const openingBrace = sourceCode.getTokenAfter(
-						node.discriminant,
-						astUtils.isOpeningBraceToken,
-					);
-
-					const closingBrace = sourceCode.getLastToken(node);
-
-					if (
-						sourceCode.commentsExistBetween(
-							openingBrace,
-							closingBrace,
-						)
-					) {
-						return;
-					}
-
-					context.report({
-						node,
-						loc: {
-							start: openingBrace.loc.start,
-							end: closingBrace.loc.end,
-						},
-						messageId: "unexpected",
-						data: { type: "switch" },
-						suggest: [
-							{
-								messageId: "suggestComment",
-								data: { type: "switch" },
-								fix(fixer) {
-									const range = [
-										openingBrace.range[1],
-										closingBrace.range[0],
-									];
-
-									return fixer.replaceTextRange(
-										range,
-										" /* empty */ ",
-									);
-								},
-							},
-						],
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,51 +0,0 @@
-/**
- * @fileoverview Rule to flag comparisons to null without a type-checking
- * operator.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow `null` comparisons without type-checking operators",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-eq-null",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Use '===' to compare with null.",
-		},
-	},
-
-	create(context) {
-		return {
-			BinaryExpression(node) {
-				const badOperator =
-					node.operator === "==" || node.operator === "!=";
-
-				if (
-					(node.right.type === "Literal" &&
-						node.right.raw === "null" &&
-						badOperator) ||
-					(node.left.type === "Literal" &&
-						node.left.raw === "null" &&
-						badOperator)
-				) {
-					context.report({ node, messageId: "unexpected" });
-				}
-			},
-		};
-	},
-};