@alexlit/lint-kit 175.0.0 → 176.0.1

package/packages/config-eslint/node_modules/eslint/lib/rules/lines-around-directive.js

@@ -1,249 +0,0 @@
-/**
- * @fileoverview Require or disallow newlines around directives.
- * @author Kai Cataldo
- * @deprecated in ESLint v4.0.0
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "layout",
-
-		docs: {
-			description: "Require or disallow newlines around directives",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/lines-around-directive",
-		},
-
-		schema: [
-			{
-				oneOf: [
-					{
-						enum: ["always", "never"],
-					},
-					{
-						type: "object",
-						properties: {
-							before: {
-								enum: ["always", "never"],
-							},
-							after: {
-								enum: ["always", "never"],
-							},
-						},
-						additionalProperties: false,
-						minProperties: 2,
-					},
-				],
-			},
-		],
-
-		fixable: "whitespace",
-		messages: {
-			expected: 'Expected newline {{location}} "{{value}}" directive.',
-			unexpected:
-				'Unexpected newline {{location}} "{{value}}" directive.',
-		},
-		deprecated: {
-			message: "The rule was replaced with a more general rule.",
-			url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/",
-			deprecatedSince: "4.0.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message: "The new rule moved to a plugin.",
-					url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "padding-line-between-statements",
-						url: "https://eslint.style/rules/padding-line-between-statements",
-					},
-				},
-			],
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const config = context.options[0] || "always";
-		const expectLineBefore =
-			typeof config === "string" ? config : config.before;
-		const expectLineAfter =
-			typeof config === "string" ? config : config.after;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Check if node is preceded by a blank newline.
-		 * @param {ASTNode} node Node to check.
-		 * @returns {boolean} Whether or not the passed in node is preceded by a blank newline.
-		 */
-		function hasNewlineBefore(node) {
-			const tokenBefore = sourceCode.getTokenBefore(node, {
-				includeComments: true,
-			});
-			const tokenLineBefore = tokenBefore ? tokenBefore.loc.end.line : 0;
-
-			return node.loc.start.line - tokenLineBefore >= 2;
-		}
-
-		/**
-		 * Gets the last token of a node that is on the same line as the rest of the node.
-		 * This will usually be the last token of the node, but it will be the second-to-last token if the node has a trailing
-		 * semicolon on a different line.
-		 * @param {ASTNode} node A directive node
-		 * @returns {Token} The last token of the node on the line
-		 */
-		function getLastTokenOnLine(node) {
-			const lastToken = sourceCode.getLastToken(node);
-			const secondToLastToken = sourceCode.getTokenBefore(lastToken);
-
-			return astUtils.isSemicolonToken(lastToken) &&
-				lastToken.loc.start.line > secondToLastToken.loc.end.line
-				? secondToLastToken
-				: lastToken;
-		}
-
-		/**
-		 * Check if node is followed by a blank newline.
-		 * @param {ASTNode} node Node to check.
-		 * @returns {boolean} Whether or not the passed in node is followed by a blank newline.
-		 */
-		function hasNewlineAfter(node) {
-			const lastToken = getLastTokenOnLine(node);
-			const tokenAfter = sourceCode.getTokenAfter(lastToken, {
-				includeComments: true,
-			});
-
-			return tokenAfter.loc.start.line - lastToken.loc.end.line >= 2;
-		}
-
-		/**
-		 * Report errors for newlines around directives.
-		 * @param {ASTNode} node Node to check.
-		 * @param {string} location Whether the error was found before or after the directive.
-		 * @param {boolean} expected Whether or not a newline was expected or unexpected.
-		 * @returns {void}
-		 */
-		function reportError(node, location, expected) {
-			context.report({
-				node,
-				messageId: expected ? "expected" : "unexpected",
-				data: {
-					value: node.expression.value,
-					location,
-				},
-				fix(fixer) {
-					const lastToken = getLastTokenOnLine(node);
-
-					if (expected) {
-						return location === "before"
-							? fixer.insertTextBefore(node, "\n")
-							: fixer.insertTextAfter(lastToken, "\n");
-					}
-					return fixer.removeRange(
-						location === "before"
-							? [node.range[0] - 1, node.range[0]]
-							: [lastToken.range[1], lastToken.range[1] + 1],
-					);
-				},
-			});
-		}
-
-		/**
-		 * Check lines around directives in node
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function checkDirectives(node) {
-			const directives = astUtils.getDirectivePrologue(node);
-
-			if (!directives.length) {
-				return;
-			}
-
-			const firstDirective = directives[0];
-			const leadingComments =
-				sourceCode.getCommentsBefore(firstDirective);
-
-			/*
-			 * Only check before the first directive if it is preceded by a comment or if it is at the top of
-			 * the file and expectLineBefore is set to "never". This is to not force a newline at the top of
-			 * the file if there are no comments as well as for compatibility with padded-blocks.
-			 */
-			if (leadingComments.length) {
-				if (
-					expectLineBefore === "always" &&
-					!hasNewlineBefore(firstDirective)
-				) {
-					reportError(firstDirective, "before", true);
-				}
-
-				if (
-					expectLineBefore === "never" &&
-					hasNewlineBefore(firstDirective)
-				) {
-					reportError(firstDirective, "before", false);
-				}
-			} else if (
-				node.type === "Program" &&
-				expectLineBefore === "never" &&
-				!leadingComments.length &&
-				hasNewlineBefore(firstDirective)
-			) {
-				reportError(firstDirective, "before", false);
-			}
-
-			const lastDirective = directives.at(-1);
-			const statements =
-				node.type === "Program" ? node.body : node.body.body;
-
-			/*
-			 * Do not check after the last directive if the body only
-			 * contains a directive prologue and isn't followed by a comment to ensure
-			 * this rule behaves well with padded-blocks.
-			 */
-			if (
-				lastDirective === statements.at(-1) &&
-				!lastDirective.trailingComments
-			) {
-				return;
-			}
-
-			if (
-				expectLineAfter === "always" &&
-				!hasNewlineAfter(lastDirective)
-			) {
-				reportError(lastDirective, "after", true);
-			}
-
-			if (expectLineAfter === "never" && hasNewlineAfter(lastDirective)) {
-				reportError(lastDirective, "after", false);
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			Program: checkDirectives,
-			FunctionDeclaration: checkDirectives,
-			FunctionExpression: checkDirectives,
-			ArrowFunctionExpression: checkDirectives,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/lines-between-class-members.js

@@ -1,358 +0,0 @@
-/**
- * @fileoverview Rule to check empty newline between class members
- * @author 薛定谔的猫<hh_2013@foxmail.com>
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Types of class members.
- * Those have `test` method to check it matches to the given class member.
- * @private
- */
-const ClassMemberTypes = {
-	"*": { test: () => true },
-	field: { test: node => node.type === "PropertyDefinition" },
-	method: { test: node => node.type === "MethodDefinition" },
-};
-
-//------------------------------------------------------------------------------
-// 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: "lines-between-class-members",
-						url: "https://eslint.style/rules/lines-between-class-members",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Require or disallow an empty line between class members",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/lines-between-class-members",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				anyOf: [
-					{
-						type: "object",
-						properties: {
-							enforce: {
-								type: "array",
-								items: {
-									type: "object",
-									properties: {
-										blankLine: {
-											enum: ["always", "never"],
-										},
-										prev: {
-											enum: ["method", "field", "*"],
-										},
-										next: {
-											enum: ["method", "field", "*"],
-										},
-									},
-									additionalProperties: false,
-									required: ["blankLine", "prev", "next"],
-								},
-								minItems: 1,
-							},
-						},
-						additionalProperties: false,
-						required: ["enforce"],
-					},
-					{
-						enum: ["always", "never"],
-					},
-				],
-			},
-			{
-				type: "object",
-				properties: {
-					exceptAfterSingleLine: {
-						type: "boolean",
-						default: false,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-		messages: {
-			never: "Unexpected blank line between class members.",
-			always: "Expected blank line between class members.",
-		},
-	},
-
-	create(context) {
-		const options = [];
-
-		options[0] = context.options[0] || "always";
-		options[1] = context.options[1] || { exceptAfterSingleLine: false };
-
-		const configureList =
-			typeof options[0] === "object"
-				? options[0].enforce
-				: [{ blankLine: options[0], prev: "*", next: "*" }];
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Gets a pair of tokens that should be used to check lines between two class member nodes.
-		 *
-		 * In most cases, this returns the very last token of the current node and
-		 * the very first token of the next node.
-		 * For example:
-		 *
-		 *     class C {
-		 *         x = 1;   // curLast: `;` nextFirst: `in`
-		 *         in = 2
-		 *     }
-		 *
-		 * There is only one exception. If the given node ends with a semicolon, and it looks like
-		 * a semicolon-less style's semicolon - one that is not on the same line as the preceding
-		 * token, but is on the line where the next class member starts - this returns the preceding
-		 * token and the semicolon as boundary tokens.
-		 * For example:
-		 *
-		 *     class C {
-		 *         x = 1    // curLast: `1` nextFirst: `;`
-		 *         ;in = 2
-		 *     }
-		 * When determining the desired layout of the code, we should treat this semicolon as
-		 * a part of the next class member node instead of the one it technically belongs to.
-		 * @param {ASTNode} curNode Current class member node.
-		 * @param {ASTNode} nextNode Next class member node.
-		 * @returns {Token} The actual last token of `node`.
-		 * @private
-		 */
-		function getBoundaryTokens(curNode, nextNode) {
-			const lastToken = sourceCode.getLastToken(curNode);
-			const prevToken = sourceCode.getTokenBefore(lastToken);
-			const nextToken = sourceCode.getFirstToken(nextNode); // skip possible lone `;` between nodes
-
-			const isSemicolonLessStyle =
-				astUtils.isSemicolonToken(lastToken) &&
-				!astUtils.isTokenOnSameLine(prevToken, lastToken) &&
-				astUtils.isTokenOnSameLine(lastToken, nextToken);
-
-			return isSemicolonLessStyle
-				? { curLast: prevToken, nextFirst: lastToken }
-				: { curLast: lastToken, nextFirst: nextToken };
-		}
-
-		/**
-		 * Return the last token among the consecutive tokens that have no exceed max line difference in between, before the first token in the next member.
-		 * @param {Token} prevLastToken The last token in the previous member node.
-		 * @param {Token} nextFirstToken The first token in the next member node.
-		 * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
-		 * @returns {Token} The last token among the consecutive tokens.
-		 */
-		function findLastConsecutiveTokenAfter(
-			prevLastToken,
-			nextFirstToken,
-			maxLine,
-		) {
-			const after = sourceCode.getTokenAfter(prevLastToken, {
-				includeComments: true,
-			});
-
-			if (
-				after !== nextFirstToken &&
-				after.loc.start.line - prevLastToken.loc.end.line <= maxLine
-			) {
-				return findLastConsecutiveTokenAfter(
-					after,
-					nextFirstToken,
-					maxLine,
-				);
-			}
-			return prevLastToken;
-		}
-
-		/**
-		 * Return the first token among the consecutive tokens that have no exceed max line difference in between, after the last token in the previous member.
-		 * @param {Token} nextFirstToken The first token in the next member node.
-		 * @param {Token} prevLastToken The last token in the previous member node.
-		 * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
-		 * @returns {Token} The first token among the consecutive tokens.
-		 */
-		function findFirstConsecutiveTokenBefore(
-			nextFirstToken,
-			prevLastToken,
-			maxLine,
-		) {
-			const before = sourceCode.getTokenBefore(nextFirstToken, {
-				includeComments: true,
-			});
-
-			if (
-				before !== prevLastToken &&
-				nextFirstToken.loc.start.line - before.loc.end.line <= maxLine
-			) {
-				return findFirstConsecutiveTokenBefore(
-					before,
-					prevLastToken,
-					maxLine,
-				);
-			}
-			return nextFirstToken;
-		}
-
-		/**
-		 * Checks if there is a token or comment between two tokens.
-		 * @param {Token} before The token before.
-		 * @param {Token} after The token after.
-		 * @returns {boolean} True if there is a token or comment between two tokens.
-		 */
-		function hasTokenOrCommentBetween(before, after) {
-			return (
-				sourceCode.getTokensBetween(before, after, {
-					includeComments: true,
-				}).length !== 0
-			);
-		}
-
-		/**
-		 * Checks whether the given node matches the given type.
-		 * @param {ASTNode} node The class member node to check.
-		 * @param {string} type The class member type to check.
-		 * @returns {boolean} `true` if the class member node matched the type.
-		 * @private
-		 */
-		function match(node, type) {
-			return ClassMemberTypes[type].test(node);
-		}
-
-		/**
-		 * Finds the last matched configuration from the configureList.
-		 * @param {ASTNode} prevNode The previous node to match.
-		 * @param {ASTNode} nextNode The current node to match.
-		 * @returns {string|null} Padding type or `null` if no matches were found.
-		 * @private
-		 */
-		function getPaddingType(prevNode, nextNode) {
-			for (let i = configureList.length - 1; i >= 0; --i) {
-				const configure = configureList[i];
-				const matched =
-					match(prevNode, configure.prev) &&
-					match(nextNode, configure.next);
-
-				if (matched) {
-					return configure.blankLine;
-				}
-			}
-			return null;
-		}
-
-		return {
-			ClassBody(node) {
-				const body = node.body;
-
-				for (let i = 0; i < body.length - 1; i++) {
-					const curFirst = sourceCode.getFirstToken(body[i]);
-					const { curLast, nextFirst } = getBoundaryTokens(
-						body[i],
-						body[i + 1],
-					);
-					const isMulti = !astUtils.isTokenOnSameLine(
-						curFirst,
-						curLast,
-					);
-					const skip = !isMulti && options[1].exceptAfterSingleLine;
-					const beforePadding = findLastConsecutiveTokenAfter(
-						curLast,
-						nextFirst,
-						1,
-					);
-					const afterPadding = findFirstConsecutiveTokenBefore(
-						nextFirst,
-						curLast,
-						1,
-					);
-					const isPadded =
-						afterPadding.loc.start.line -
-							beforePadding.loc.end.line >
-						1;
-					const hasTokenInPadding = hasTokenOrCommentBetween(
-						beforePadding,
-						afterPadding,
-					);
-					const curLineLastToken = findLastConsecutiveTokenAfter(
-						curLast,
-						nextFirst,
-						0,
-					);
-					const paddingType = getPaddingType(body[i], body[i + 1]);
-
-					if (paddingType === "never" && isPadded) {
-						context.report({
-							node: body[i + 1],
-							messageId: "never",
-
-							fix(fixer) {
-								if (hasTokenInPadding) {
-									return null;
-								}
-								return fixer.replaceTextRange(
-									[
-										beforePadding.range[1],
-										afterPadding.range[0],
-									],
-									"\n",
-								);
-							},
-						});
-					} else if (paddingType === "always" && !skip && !isPadded) {
-						context.report({
-							node: body[i + 1],
-							messageId: "always",
-
-							fix(fixer) {
-								if (hasTokenInPadding) {
-									return null;
-								}
-								return fixer.insertTextAfter(
-									curLineLastToken,
-									"\n",
-								);
-							},
-						});
-					}
-				}
-			},
-		};
-	},
-};