@alexlit/lint-kit 183.1.0 → 183.2.0

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

@@ -1,188 +0,0 @@
-/**
- * @fileoverview Rule to define spacing before/after arrow function's arrow.
- * @author Jxck
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-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: "arrow-spacing",
-						url: "https://eslint.style/rules/arrow-spacing",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce consistent spacing before and after the arrow in arrow functions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/arrow-spacing",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					before: {
-						type: "boolean",
-						default: true,
-					},
-					after: {
-						type: "boolean",
-						default: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			expectedBefore: "Missing space before =>.",
-			unexpectedBefore: "Unexpected space before =>.",
-
-			expectedAfter: "Missing space after =>.",
-			unexpectedAfter: "Unexpected space after =>.",
-		},
-	},
-
-	create(context) {
-		// merge rules with default
-		const rule = Object.assign({}, context.options[0]);
-
-		rule.before = rule.before !== false;
-		rule.after = rule.after !== false;
-
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Get tokens of arrow(`=>`) and before/after arrow.
-		 * @param {ASTNode} node The arrow function node.
-		 * @returns {Object} Tokens of arrow and before/after arrow.
-		 */
-		function getTokens(node) {
-			const arrow = sourceCode.getTokenBefore(
-				node.body,
-				astUtils.isArrowToken,
-			);
-
-			return {
-				before: sourceCode.getTokenBefore(arrow),
-				arrow,
-				after: sourceCode.getTokenAfter(arrow),
-			};
-		}
-
-		/**
-		 * Count spaces before/after arrow(`=>`) token.
-		 * @param {Object} tokens Tokens before/after arrow.
-		 * @returns {Object} count of space before/after arrow.
-		 */
-		function countSpaces(tokens) {
-			const before = tokens.arrow.range[0] - tokens.before.range[1];
-			const after = tokens.after.range[0] - tokens.arrow.range[1];
-
-			return { before, after };
-		}
-
-		/**
-		 * Determines whether space(s) before after arrow(`=>`) is satisfy rule.
-		 * if before/after value is `true`, there should be space(s).
-		 * if before/after value is `false`, there should be no space.
-		 * @param {ASTNode} node The arrow function node.
-		 * @returns {void}
-		 */
-		function spaces(node) {
-			const tokens = getTokens(node);
-			const countSpace = countSpaces(tokens);
-
-			if (rule.before) {
-				// should be space(s) before arrow
-				if (countSpace.before === 0) {
-					context.report({
-						node: tokens.before,
-						messageId: "expectedBefore",
-						fix(fixer) {
-							return fixer.insertTextBefore(tokens.arrow, " ");
-						},
-					});
-				}
-			} else {
-				// should be no space before arrow
-				if (countSpace.before > 0) {
-					context.report({
-						node: tokens.before,
-						messageId: "unexpectedBefore",
-						fix(fixer) {
-							return fixer.removeRange([
-								tokens.before.range[1],
-								tokens.arrow.range[0],
-							]);
-						},
-					});
-				}
-			}
-
-			if (rule.after) {
-				// should be space(s) after arrow
-				if (countSpace.after === 0) {
-					context.report({
-						node: tokens.after,
-						messageId: "expectedAfter",
-						fix(fixer) {
-							return fixer.insertTextAfter(tokens.arrow, " ");
-						},
-					});
-				}
-			} else {
-				// should be no space after arrow
-				if (countSpace.after > 0) {
-					context.report({
-						node: tokens.after,
-						messageId: "unexpectedAfter",
-						fix(fixer) {
-							return fixer.removeRange([
-								tokens.arrow.range[1],
-								tokens.after.range[0],
-							]);
-						},
-					});
-				}
-			}
-		}
-
-		return {
-			ArrowFunctionExpression: spaces,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/block-scoped-var.js

@@ -1,144 +0,0 @@
-/**
- * @fileoverview Rule to check for "block scoped" variables by binding context
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Types
-//------------------------------------------------------------------------------
-
-/** @typedef {import("eslint-scope").Definition} Definition */
-/** @typedef {import("eslint-scope").Reference} Reference */
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Enforce the use of variables within the scope they are defined",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/block-scoped-var",
-		},
-
-		schema: [],
-
-		messages: {
-			outOfScope:
-				"'{{name}}' declared on line {{definitionLine}} column {{definitionColumn}} is used outside of binding context.",
-		},
-	},
-
-	create(context) {
-		let stack = [];
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Makes a block scope.
-		 * @param {ASTNode} node A node of a scope.
-		 * @returns {void}
-		 */
-		function enterScope(node) {
-			stack.push(node.range);
-		}
-
-		/**
-		 * Pops the last block scope.
-		 * @returns {void}
-		 */
-		function exitScope() {
-			stack.pop();
-		}
-
-		/**
-		 * Reports a given reference.
-		 * @param {Reference} reference A reference to report.
-		 * @param {Definition} definition A definition for which to report reference.
-		 * @returns {void}
-		 */
-		function report(reference, definition) {
-			const identifier = reference.identifier;
-			const definitionPosition = definition.name.loc.start;
-
-			context.report({
-				node: identifier,
-				messageId: "outOfScope",
-				data: {
-					name: identifier.name,
-					definitionLine: definitionPosition.line,
-					definitionColumn: definitionPosition.column + 1,
-				},
-			});
-		}
-
-		/**
-		 * Finds and reports references which are outside of valid scopes.
-		 * @param {ASTNode} node A node to get variables.
-		 * @returns {void}
-		 */
-		function checkForVariables(node) {
-			if (node.kind !== "var") {
-				return;
-			}
-
-			// Defines a predicate to check whether or not a given reference is outside of valid scope.
-			const scopeRange = stack.at(-1);
-
-			/**
-			 * Check if a reference is out of scope
-			 * @param {ASTNode} reference node to examine
-			 * @returns {boolean} True is its outside the scope
-			 * @private
-			 */
-			function isOutsideOfScope(reference) {
-				const idRange = reference.identifier.range;
-
-				return idRange[0] < scopeRange[0] || idRange[1] > scopeRange[1];
-			}
-
-			// Gets declared variables, and checks its references.
-			const variables = sourceCode.getDeclaredVariables(node);
-
-			for (let i = 0; i < variables.length; ++i) {
-				// Reports.
-				variables[i].references.filter(isOutsideOfScope).forEach(ref =>
-					report(
-						ref,
-						variables[i].defs.find(def => def.parent === node),
-					),
-				);
-			}
-		}
-
-		return {
-			Program(node) {
-				stack = [node.range];
-			},
-
-			// Manages scopes.
-			BlockStatement: enterScope,
-			"BlockStatement:exit": exitScope,
-			ForStatement: enterScope,
-			"ForStatement:exit": exitScope,
-			ForInStatement: enterScope,
-			"ForInStatement:exit": exitScope,
-			ForOfStatement: enterScope,
-			"ForOfStatement:exit": exitScope,
-			SwitchStatement: enterScope,
-			"SwitchStatement:exit": exitScope,
-			CatchClause: enterScope,
-			"CatchClause:exit": exitScope,
-			StaticBlock: enterScope,
-			"StaticBlock:exit": exitScope,
-
-			// Finds and reports references which are outside of valid scope.
-			VariableDeclaration: checkForVariables,
-		};
-	},
-};

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

@@ -1,202 +0,0 @@
-/**
- * @fileoverview A rule to disallow or enforce spaces inside of single line blocks.
- * @author Toru Nagashima
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-const util = 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: "block-spacing",
-						url: "https://eslint.style/rules/block-spacing",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Disallow or enforce spaces inside of blocks after opening block and before closing block",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/block-spacing",
-		},
-
-		fixable: "whitespace",
-
-		schema: [{ enum: ["always", "never"] }],
-
-		messages: {
-			missing: "Requires a space {{location}} '{{token}}'.",
-			extra: "Unexpected space(s) {{location}} '{{token}}'.",
-		},
-	},
-
-	create(context) {
-		const always = context.options[0] !== "never",
-			messageId = always ? "missing" : "extra",
-			sourceCode = context.sourceCode;
-
-		/**
-		 * Gets the open brace token from a given node.
-		 * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to get.
-		 * @returns {Token} The token of the open brace.
-		 */
-		function getOpenBrace(node) {
-			if (node.type === "SwitchStatement") {
-				if (node.cases.length > 0) {
-					return sourceCode.getTokenBefore(node.cases[0]);
-				}
-				return sourceCode.getLastToken(node, 1);
-			}
-
-			if (node.type === "StaticBlock") {
-				return sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
-			}
-
-			// "BlockStatement"
-			return sourceCode.getFirstToken(node);
-		}
-
-		/**
-		 * Checks whether or not:
-		 *   - given tokens are on same line.
-		 *   - there is/isn't a space between given tokens.
-		 * @param {Token} left A token to check.
-		 * @param {Token} right The token which is next to `left`.
-		 * @returns {boolean}
-		 *    When the option is `"always"`, `true` if there are one or more spaces between given tokens.
-		 *    When the option is `"never"`, `true` if there are not any spaces between given tokens.
-		 *    If given tokens are not on same line, it's always `true`.
-		 */
-		function isValid(left, right) {
-			return (
-				!util.isTokenOnSameLine(left, right) ||
-				sourceCode.isSpaceBetween(left, right) === always
-			);
-		}
-
-		/**
-		 * Checks and reports invalid spacing style inside braces.
-		 * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to check.
-		 * @returns {void}
-		 */
-		function checkSpacingInsideBraces(node) {
-			// Gets braces and the first/last token of content.
-			const openBrace = getOpenBrace(node);
-			const closeBrace = sourceCode.getLastToken(node);
-			const firstToken = sourceCode.getTokenAfter(openBrace, {
-				includeComments: true,
-			});
-			const lastToken = sourceCode.getTokenBefore(closeBrace, {
-				includeComments: true,
-			});
-
-			// Skip if the node is invalid or empty.
-			if (
-				openBrace.type !== "Punctuator" ||
-				openBrace.value !== "{" ||
-				closeBrace.type !== "Punctuator" ||
-				closeBrace.value !== "}" ||
-				firstToken === closeBrace
-			) {
-				return;
-			}
-
-			// Skip line comments for option never
-			if (!always && firstToken.type === "Line") {
-				return;
-			}
-
-			// Check.
-			if (!isValid(openBrace, firstToken)) {
-				let loc = openBrace.loc;
-
-				if (messageId === "extra") {
-					loc = {
-						start: openBrace.loc.end,
-						end: firstToken.loc.start,
-					};
-				}
-
-				context.report({
-					node,
-					loc,
-					messageId,
-					data: {
-						location: "after",
-						token: openBrace.value,
-					},
-					fix(fixer) {
-						if (always) {
-							return fixer.insertTextBefore(firstToken, " ");
-						}
-
-						return fixer.removeRange([
-							openBrace.range[1],
-							firstToken.range[0],
-						]);
-					},
-				});
-			}
-			if (!isValid(lastToken, closeBrace)) {
-				let loc = closeBrace.loc;
-
-				if (messageId === "extra") {
-					loc = {
-						start: lastToken.loc.end,
-						end: closeBrace.loc.start,
-					};
-				}
-				context.report({
-					node,
-					loc,
-					messageId,
-					data: {
-						location: "before",
-						token: closeBrace.value,
-					},
-					fix(fixer) {
-						if (always) {
-							return fixer.insertTextAfter(lastToken, " ");
-						}
-
-						return fixer.removeRange([
-							lastToken.range[1],
-							closeBrace.range[0],
-						]);
-					},
-				});
-			}
-		}
-
-		return {
-			BlockStatement: checkSpacingInsideBraces,
-			StaticBlock: checkSpacingInsideBraces,
-			SwitchStatement: checkSpacingInsideBraces,
-		};
-	},
-};