@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/computed-property-spacing.js

@@ -1,251 +0,0 @@
-/**
- * @fileoverview Disallows or enforces spaces inside computed properties.
- * @author Jamund Ferguson
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Formatting rules are being moved out of ESLint core.",
-			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
-			deprecatedSince: "8.53.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"ESLint Stylistic now maintains deprecated stylistic core rules.",
-					url: "https://eslint.style/guide/migration",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "computed-property-spacing",
-						url: "https://eslint.style/rules/computed-property-spacing",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce consistent spacing inside computed property brackets",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/computed-property-spacing",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				enum: ["always", "never"],
-			},
-			{
-				type: "object",
-				properties: {
-					enforceForClassMembers: {
-						type: "boolean",
-						default: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedSpaceBefore:
-				"There should be no space before '{{tokenValue}}'.",
-			unexpectedSpaceAfter:
-				"There should be no space after '{{tokenValue}}'.",
-
-			missingSpaceBefore: "A space is required before '{{tokenValue}}'.",
-			missingSpaceAfter: "A space is required after '{{tokenValue}}'.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const propertyNameMustBeSpaced = context.options[0] === "always"; // default is "never"
-		const enforceForClassMembers =
-			!context.options[1] || context.options[1].enforceForClassMembers;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Reports that there shouldn't be a space after the first token
-		 * @param {ASTNode} node The node to report in the event of an error.
-		 * @param {Token} token The token to use for the report.
-		 * @param {Token} tokenAfter The token after `token`.
-		 * @returns {void}
-		 */
-		function reportNoBeginningSpace(node, token, tokenAfter) {
-			context.report({
-				node,
-				loc: { start: token.loc.end, end: tokenAfter.loc.start },
-				messageId: "unexpectedSpaceAfter",
-				data: {
-					tokenValue: token.value,
-				},
-				fix(fixer) {
-					return fixer.removeRange([
-						token.range[1],
-						tokenAfter.range[0],
-					]);
-				},
-			});
-		}
-
-		/**
-		 * Reports that there shouldn't be a space before the last token
-		 * @param {ASTNode} node The node to report in the event of an error.
-		 * @param {Token} token The token to use for the report.
-		 * @param {Token} tokenBefore The token before `token`.
-		 * @returns {void}
-		 */
-		function reportNoEndingSpace(node, token, tokenBefore) {
-			context.report({
-				node,
-				loc: { start: tokenBefore.loc.end, end: token.loc.start },
-				messageId: "unexpectedSpaceBefore",
-				data: {
-					tokenValue: token.value,
-				},
-				fix(fixer) {
-					return fixer.removeRange([
-						tokenBefore.range[1],
-						token.range[0],
-					]);
-				},
-			});
-		}
-
-		/**
-		 * Reports that there should be a space after the first token
-		 * @param {ASTNode} node The node to report in the event of an error.
-		 * @param {Token} token The token to use for the report.
-		 * @returns {void}
-		 */
-		function reportRequiredBeginningSpace(node, token) {
-			context.report({
-				node,
-				loc: token.loc,
-				messageId: "missingSpaceAfter",
-				data: {
-					tokenValue: token.value,
-				},
-				fix(fixer) {
-					return fixer.insertTextAfter(token, " ");
-				},
-			});
-		}
-
-		/**
-		 * Reports that there should be a space before the last token
-		 * @param {ASTNode} node The node to report in the event of an error.
-		 * @param {Token} token The token to use for the report.
-		 * @returns {void}
-		 */
-		function reportRequiredEndingSpace(node, token) {
-			context.report({
-				node,
-				loc: token.loc,
-				messageId: "missingSpaceBefore",
-				data: {
-					tokenValue: token.value,
-				},
-				fix(fixer) {
-					return fixer.insertTextBefore(token, " ");
-				},
-			});
-		}
-
-		/**
-		 * Returns a function that checks the spacing of a node on the property name
-		 * that was passed in.
-		 * @param {string} propertyName The property on the node to check for spacing
-		 * @returns {Function} A function that will check spacing on a node
-		 */
-		function checkSpacing(propertyName) {
-			return function (node) {
-				if (!node.computed) {
-					return;
-				}
-
-				const property = node[propertyName];
-
-				const before = sourceCode.getTokenBefore(
-						property,
-						astUtils.isOpeningBracketToken,
-					),
-					first = sourceCode.getTokenAfter(before, {
-						includeComments: true,
-					}),
-					after = sourceCode.getTokenAfter(
-						property,
-						astUtils.isClosingBracketToken,
-					),
-					last = sourceCode.getTokenBefore(after, {
-						includeComments: true,
-					});
-
-				if (astUtils.isTokenOnSameLine(before, first)) {
-					if (propertyNameMustBeSpaced) {
-						if (
-							!sourceCode.isSpaceBetweenTokens(before, first) &&
-							astUtils.isTokenOnSameLine(before, first)
-						) {
-							reportRequiredBeginningSpace(node, before);
-						}
-					} else {
-						if (sourceCode.isSpaceBetweenTokens(before, first)) {
-							reportNoBeginningSpace(node, before, first);
-						}
-					}
-				}
-
-				if (astUtils.isTokenOnSameLine(last, after)) {
-					if (propertyNameMustBeSpaced) {
-						if (
-							!sourceCode.isSpaceBetweenTokens(last, after) &&
-							astUtils.isTokenOnSameLine(last, after)
-						) {
-							reportRequiredEndingSpace(node, after);
-						}
-					} else {
-						if (sourceCode.isSpaceBetweenTokens(last, after)) {
-							reportNoEndingSpace(node, after, last);
-						}
-					}
-				}
-			};
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		const listeners = {
-			Property: checkSpacing("key"),
-			MemberExpression: checkSpacing("property"),
-		};
-
-		if (enforceForClassMembers) {
-			listeners.MethodDefinition = listeners.PropertyDefinition =
-				listeners.Property;
-		}
-
-		return listeners;
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/consistent-return.js

@@ -1,221 +0,0 @@
-/**
- * @fileoverview Rule to flag consistent return values
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const { upperCaseFirst } = require("../shared/string-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks all segments in a set and returns true if all are unreachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if all segments are unreachable; false otherwise.
- */
-function areAllSegmentsUnreachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
- * Checks whether a given node is a `constructor` method in an ES6 class
- * @param {ASTNode} node A node to check
- * @returns {boolean} `true` if the node is a `constructor` method
- */
-function isClassConstructor(node) {
-	return (
-		node.type === "FunctionExpression" &&
-		node.parent &&
-		node.parent.type === "MethodDefinition" &&
-		node.parent.kind === "constructor"
-	);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Require `return` statements to either always or never specify values",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/consistent-return",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					treatUndefinedAsUnspecified: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		defaultOptions: [{ treatUndefinedAsUnspecified: false }],
-
-		messages: {
-			missingReturn: "Expected to return a value at the end of {{name}}.",
-			missingReturnValue: "{{name}} expected a return value.",
-			unexpectedReturnValue: "{{name}} expected no return value.",
-		},
-	},
-
-	create(context) {
-		const [{ treatUndefinedAsUnspecified }] = context.options;
-		let funcInfo = null;
-
-		/**
-		 * Checks whether of not the implicit returning is consistent if the last
-		 * code path segment is reachable.
-		 * @param {ASTNode} node A program/function node to check.
-		 * @returns {void}
-		 */
-		function checkLastSegment(node) {
-			let loc, name;
-
-			/*
-			 * Skip if it expected no return value or unreachable.
-			 * When unreachable, all paths are returned or thrown.
-			 */
-			if (
-				!funcInfo.hasReturnValue ||
-				areAllSegmentsUnreachable(funcInfo.currentSegments) ||
-				astUtils.isES5Constructor(node) ||
-				isClassConstructor(node)
-			) {
-				return;
-			}
-
-			// Adjust a location and a message.
-			if (node.type === "Program") {
-				// The head of program.
-				loc = { line: 1, column: 0 };
-				name = "program";
-			} else if (node.type === "ArrowFunctionExpression") {
-				// `=>` token
-				loc = context.sourceCode.getTokenBefore(
-					node.body,
-					astUtils.isArrowToken,
-				).loc;
-			} else if (
-				node.parent.type === "MethodDefinition" ||
-				(node.parent.type === "Property" && node.parent.method)
-			) {
-				// Method name.
-				loc = node.parent.key.loc;
-			} else {
-				// Function name or `function` keyword.
-				loc = (node.id || context.sourceCode.getFirstToken(node)).loc;
-			}
-
-			if (!name) {
-				name = astUtils.getFunctionNameWithKind(node);
-			}
-
-			// Reports.
-			context.report({
-				node,
-				loc,
-				messageId: "missingReturn",
-				data: { name },
-			});
-		}
-
-		return {
-			// Initializes/Disposes state of each code path.
-			onCodePathStart(codePath, node) {
-				funcInfo = {
-					upper: funcInfo,
-					codePath,
-					hasReturn: false,
-					hasReturnValue: false,
-					messageId: "",
-					node,
-					currentSegments: new Set(),
-				};
-			},
-			onCodePathEnd() {
-				funcInfo = funcInfo.upper;
-			},
-
-			onUnreachableCodePathSegmentStart(segment) {
-				funcInfo.currentSegments.add(segment);
-			},
-
-			onUnreachableCodePathSegmentEnd(segment) {
-				funcInfo.currentSegments.delete(segment);
-			},
-
-			onCodePathSegmentStart(segment) {
-				funcInfo.currentSegments.add(segment);
-			},
-
-			onCodePathSegmentEnd(segment) {
-				funcInfo.currentSegments.delete(segment);
-			},
-
-			// Reports a given return statement if it's inconsistent.
-			ReturnStatement(node) {
-				const argument = node.argument;
-				let hasReturnValue = Boolean(argument);
-
-				if (treatUndefinedAsUnspecified && hasReturnValue) {
-					hasReturnValue =
-						!astUtils.isSpecificId(argument, "undefined") &&
-						argument.operator !== "void";
-				}
-
-				if (!funcInfo.hasReturn) {
-					funcInfo.hasReturn = true;
-					funcInfo.hasReturnValue = hasReturnValue;
-					funcInfo.messageId = hasReturnValue
-						? "missingReturnValue"
-						: "unexpectedReturnValue";
-					funcInfo.data = {
-						name:
-							funcInfo.node.type === "Program"
-								? "Program"
-								: upperCaseFirst(
-										astUtils.getFunctionNameWithKind(
-											funcInfo.node,
-										),
-									),
-					};
-				} else if (funcInfo.hasReturnValue !== hasReturnValue) {
-					context.report({
-						node,
-						messageId: funcInfo.messageId,
-						data: funcInfo.data,
-					});
-				}
-			},
-
-			// Reports a given program/function if the implicit returning is not consistent.
-			"Program:exit": checkLastSegment,
-			"FunctionDeclaration:exit": checkLastSegment,
-			"FunctionExpression:exit": checkLastSegment,
-			"ArrowFunctionExpression:exit": checkLastSegment,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/consistent-this.js

@@ -1,179 +0,0 @@
-/**
- * @fileoverview Rule to enforce consistent naming of "this" context variables
- * @author Raphael Pigulla
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Enforce consistent naming when capturing the current execution context",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/consistent-this",
-		},
-
-		schema: {
-			type: "array",
-			items: {
-				type: "string",
-				minLength: 1,
-			},
-			uniqueItems: true,
-		},
-
-		defaultOptions: ["that"],
-
-		messages: {
-			aliasNotAssignedToThis:
-				"Designated alias '{{name}}' is not assigned to 'this'.",
-			unexpectedAlias: "Unexpected alias '{{name}}' for 'this'.",
-		},
-	},
-
-	create(context) {
-		const aliases = context.options;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Reports that a variable declarator or assignment expression is assigning
-		 * a non-'this' value to the specified alias.
-		 * @param {ASTNode} node The assigning node.
-		 * @param {string} name the name of the alias that was incorrectly used.
-		 * @returns {void}
-		 */
-		function reportBadAssignment(node, name) {
-			context.report({
-				node,
-				messageId: "aliasNotAssignedToThis",
-				data: { name },
-			});
-		}
-
-		/**
-		 * Checks that an assignment to an identifier only assigns 'this' to the
-		 * appropriate alias, and the alias is only assigned to 'this'.
-		 * @param {ASTNode} node The assigning node.
-		 * @param {Identifier} name The name of the variable assigned to.
-		 * @param {Expression} value The value of the assignment.
-		 * @returns {void}
-		 */
-		function checkAssignment(node, name, value) {
-			const isThis = value.type === "ThisExpression";
-
-			if (aliases.includes(name)) {
-				if (!isThis || (node.operator && node.operator !== "=")) {
-					reportBadAssignment(node, name);
-				}
-			} else if (isThis) {
-				context.report({
-					node,
-					messageId: "unexpectedAlias",
-					data: { name },
-				});
-			}
-		}
-
-		/**
-		 * Ensures that a variable declaration of the alias in a program or function
-		 * is assigned to the correct value.
-		 * @param {string} alias alias the check the assignment of.
-		 * @param {Object} scope scope of the current code we are checking.
-		 * @private
-		 * @returns {void}
-		 */
-		function checkWasAssigned(alias, scope) {
-			const variable = scope.set.get(alias);
-
-			if (!variable) {
-				return;
-			}
-
-			if (
-				variable.defs.some(
-					def =>
-						def.node.type === "VariableDeclarator" &&
-						def.node.init !== null,
-				)
-			) {
-				return;
-			}
-
-			/*
-			 * The alias has been declared and not assigned: check it was
-			 * assigned later in the same scope.
-			 */
-			if (
-				!variable.references.some(reference => {
-					const write = reference.writeExpr;
-
-					return (
-						reference.from === scope &&
-						write &&
-						write.type === "ThisExpression" &&
-						write.parent.operator === "="
-					);
-				})
-			) {
-				variable.defs
-					.map(def => def.node)
-					.forEach(node => {
-						reportBadAssignment(node, alias);
-					});
-			}
-		}
-
-		/**
-		 * Check each alias to ensure that is was assigned to the correct value.
-		 * @param {ASTNode} node The node that represents the scope to check.
-		 * @returns {void}
-		 */
-		function ensureWasAssigned(node) {
-			const scope = sourceCode.getScope(node);
-
-			// if this is program scope we also need to check module scope
-			const extraScope =
-				node.type === "Program" && node.sourceType === "module"
-					? scope.childScopes[0]
-					: null;
-
-			aliases.forEach(alias => {
-				checkWasAssigned(alias, scope);
-
-				if (extraScope) {
-					checkWasAssigned(alias, extraScope);
-				}
-			});
-		}
-
-		return {
-			"Program:exit": ensureWasAssigned,
-			"FunctionExpression:exit": ensureWasAssigned,
-			"FunctionDeclaration:exit": ensureWasAssigned,
-
-			VariableDeclarator(node) {
-				const id = node.id;
-				const isDestructuring =
-					id.type === "ArrayPattern" || id.type === "ObjectPattern";
-
-				if (node.init !== null && !isDestructuring) {
-					checkAssignment(node, id.name, node.init);
-				}
-			},
-
-			AssignmentExpression(node) {
-				if (node.left.type === "Identifier") {
-					checkAssignment(node, node.left.name, node.right);
-				}
-			},
-		};
-	},
-};