@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/require-unicode-regexp.js

@@ -1,317 +0,0 @@
-/**
- * @fileoverview Rule to enforce the use of `u` or `v` flag on regular expressions.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-	CALL,
-	CONSTRUCT,
-	ReferenceTracker,
-	getStringIfConstant,
-} = require("@eslint-community/eslint-utils");
-const astUtils = require("./utils/ast-utils.js");
-const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
-
-/**
- * Checks whether the flag configuration should be treated as a missing flag.
- * @param {"u"|"v"|undefined} requireFlag A particular flag to require
- * @param {string} flags The regex flags
- * @returns {boolean} Whether the flag configuration results in a missing flag.
- */
-function checkFlags(requireFlag, flags) {
-	let missingFlag;
-
-	if (requireFlag === "v") {
-		missingFlag = !flags.includes("v");
-	} else if (requireFlag === "u") {
-		missingFlag = !flags.includes("u");
-	} else {
-		missingFlag = !flags.includes("u") && !flags.includes("v");
-	}
-
-	return missingFlag;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [{}],
-
-		docs: {
-			description:
-				"Enforce the use of `u` or `v` flag on regular expressions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/require-unicode-regexp",
-		},
-
-		hasSuggestions: true,
-
-		messages: {
-			addUFlag: "Add the 'u' flag.",
-			addVFlag: "Add the 'v' flag.",
-			requireUFlag: "Use the 'u' flag.",
-			requireVFlag: "Use the 'v' flag.",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					requireFlag: {
-						enum: ["u", "v"],
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		const [{ requireFlag }] = context.options;
-
-		return {
-			"Literal[regex]"(node) {
-				const flags = node.regex.flags || "";
-
-				const missingFlag = checkFlags(requireFlag, flags);
-
-				if (missingFlag) {
-					context.report({
-						messageId:
-							requireFlag === "v"
-								? "requireVFlag"
-								: "requireUFlag",
-						node,
-						suggest: isValidWithUnicodeFlag(
-							context.languageOptions.ecmaVersion,
-							node.regex.pattern,
-							requireFlag,
-						)
-							? [
-									{
-										fix(fixer) {
-											const replaceFlag =
-												requireFlag ?? "u";
-											const regex =
-												sourceCode.getText(node);
-											const slashPos =
-												regex.lastIndexOf("/");
-
-											if (requireFlag) {
-												const flag =
-													requireFlag === "u"
-														? "v"
-														: "u";
-
-												if (
-													regex.includes(
-														flag,
-														slashPos,
-													)
-												) {
-													return fixer.replaceText(
-														node,
-														regex.slice(
-															0,
-															slashPos,
-														) +
-															regex
-																.slice(slashPos)
-																.replace(
-																	flag,
-																	requireFlag,
-																),
-													);
-												}
-											}
-
-											return fixer.insertTextAfter(
-												node,
-												replaceFlag,
-											);
-										},
-										messageId:
-											requireFlag === "v"
-												? "addVFlag"
-												: "addUFlag",
-									},
-								]
-							: null,
-					});
-				}
-			},
-
-			Program(node) {
-				const scope = sourceCode.getScope(node);
-				const tracker = new ReferenceTracker(scope);
-				const trackMap = {
-					RegExp: { [CALL]: true, [CONSTRUCT]: true },
-				};
-
-				for (const { node: refNode } of tracker.iterateGlobalReferences(
-					trackMap,
-				)) {
-					const [patternNode, flagsNode] = refNode.arguments;
-
-					if (patternNode && patternNode.type === "SpreadElement") {
-						continue;
-					}
-					const pattern = getStringIfConstant(patternNode, scope);
-					const flags = getStringIfConstant(flagsNode, scope);
-
-					let missingFlag = !flagsNode;
-
-					if (typeof flags === "string") {
-						missingFlag = checkFlags(requireFlag, flags);
-					}
-
-					if (missingFlag) {
-						context.report({
-							messageId:
-								requireFlag === "v"
-									? "requireVFlag"
-									: "requireUFlag",
-							node: refNode,
-							suggest:
-								typeof pattern === "string" &&
-								isValidWithUnicodeFlag(
-									context.languageOptions.ecmaVersion,
-									pattern,
-									requireFlag,
-								)
-									? [
-											{
-												fix(fixer) {
-													const replaceFlag =
-														requireFlag ?? "u";
-
-													if (flagsNode) {
-														if (
-															(flagsNode.type ===
-																"Literal" &&
-																typeof flagsNode.value ===
-																	"string") ||
-															flagsNode.type ===
-																"TemplateLiteral"
-														) {
-															const flagsNodeText =
-																sourceCode.getText(
-																	flagsNode,
-																);
-															const flag =
-																requireFlag ===
-																"u"
-																	? "v"
-																	: "u";
-
-															if (
-																flags.includes(
-																	flag,
-																)
-															) {
-																// Avoid replacing "u" in escapes like `\uXXXX`
-																if (
-																	flagsNode.type ===
-																		"Literal" &&
-																	flagsNode.raw.includes(
-																		"\\",
-																	)
-																) {
-																	return null;
-																}
-
-																// Avoid replacing "u" in expressions like "`${regularFlags}g`"
-																if (
-																	flagsNode.type ===
-																		"TemplateLiteral" &&
-																	(flagsNode
-																		.expressions
-																		.length ||
-																		flagsNode.quasis.some(
-																			({
-																				value: {
-																					raw,
-																				},
-																			}) =>
-																				raw.includes(
-																					"\\",
-																				),
-																		))
-																) {
-																	return null;
-																}
-
-																return fixer.replaceText(
-																	flagsNode,
-																	flagsNodeText.replace(
-																		flag,
-																		replaceFlag,
-																	),
-																);
-															}
-
-															return fixer.replaceText(
-																flagsNode,
-																[
-																	flagsNodeText.slice(
-																		0,
-																		flagsNodeText.length -
-																			1,
-																	),
-																	flagsNodeText.slice(
-																		flagsNodeText.length -
-																			1,
-																	),
-																].join(
-																	replaceFlag,
-																),
-															);
-														}
-
-														// We intentionally don't suggest concatenating + "u" to non-literals
-														return null;
-													}
-
-													const penultimateToken =
-														sourceCode.getLastToken(
-															refNode,
-															{ skip: 1 },
-														); // skip closing parenthesis
-
-													return fixer.insertTextAfter(
-														penultimateToken,
-														astUtils.isCommaToken(
-															penultimateToken,
-														)
-															? ` "${replaceFlag}",`
-															: `, "${replaceFlag}"`,
-													);
-												},
-												messageId:
-													requireFlag === "v"
-														? "addVFlag"
-														: "addUFlag",
-											},
-										]
-									: null,
-						});
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/require-yield.js

@@ -1,76 +0,0 @@
-/**
- * @fileoverview Rule to flag the generator functions that does not have yield.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Require generator functions to contain `yield`",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/require-yield",
-		},
-
-		schema: [],
-
-		messages: {
-			missingYield: "This generator function does not have 'yield'.",
-		},
-	},
-
-	create(context) {
-		const stack = [];
-
-		/**
-		 * If the node is a generator function, start counting `yield` keywords.
-		 * @param {Node} node A function node to check.
-		 * @returns {void}
-		 */
-		function beginChecking(node) {
-			if (node.generator) {
-				stack.push(0);
-			}
-		}
-
-		/**
-		 * If the node is a generator function, end counting `yield` keywords, then
-		 * reports result.
-		 * @param {Node} node A function node to check.
-		 * @returns {void}
-		 */
-		function endChecking(node) {
-			if (!node.generator) {
-				return;
-			}
-
-			const countYield = stack.pop();
-
-			if (countYield === 0 && node.body.body.length > 0) {
-				context.report({ node, messageId: "missingYield" });
-			}
-		}
-
-		return {
-			FunctionDeclaration: beginChecking,
-			"FunctionDeclaration:exit": endChecking,
-			FunctionExpression: beginChecking,
-			"FunctionExpression:exit": endChecking,
-
-			// Increases the count of `yield` keyword.
-			YieldExpression() {
-				if (stack.length > 0) {
-					stack[stack.length - 1] += 1;
-				}
-			},
-		};
-	},
-};

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

@@ -1,153 +0,0 @@
-/**
- * @fileoverview Enforce spacing between rest and spread operators and their expressions.
- * @author Kai Cataldo
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// 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: "rest-spread-spacing",
-						url: "https://eslint.style/rules/rest-spread-spacing",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce spacing between rest and spread operators and their expressions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/rest-spread-spacing",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				enum: ["always", "never"],
-			},
-		],
-
-		messages: {
-			unexpectedWhitespace:
-				"Unexpected whitespace after {{type}} operator.",
-			expectedWhitespace: "Expected whitespace after {{type}} operator.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode,
-			alwaysSpace = context.options[0] === "always";
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Checks whitespace between rest/spread operators and their expressions
-		 * @param {ASTNode} node The node to check
-		 * @returns {void}
-		 */
-		function checkWhiteSpace(node) {
-			const operator = sourceCode.getFirstToken(node),
-				nextToken = sourceCode.getTokenAfter(operator),
-				hasWhitespace = sourceCode.isSpaceBetweenTokens(
-					operator,
-					nextToken,
-				);
-			let type;
-
-			switch (node.type) {
-				case "SpreadElement":
-					type = "spread";
-					if (node.parent.type === "ObjectExpression") {
-						type += " property";
-					}
-					break;
-				case "RestElement":
-					type = "rest";
-					if (node.parent.type === "ObjectPattern") {
-						type += " property";
-					}
-					break;
-				case "ExperimentalSpreadProperty":
-					type = "spread property";
-					break;
-				case "ExperimentalRestProperty":
-					type = "rest property";
-					break;
-				default:
-					return;
-			}
-
-			if (alwaysSpace && !hasWhitespace) {
-				context.report({
-					node,
-					loc: operator.loc,
-					messageId: "expectedWhitespace",
-					data: {
-						type,
-					},
-					fix(fixer) {
-						return fixer.replaceTextRange(
-							[operator.range[1], nextToken.range[0]],
-							" ",
-						);
-					},
-				});
-			} else if (!alwaysSpace && hasWhitespace) {
-				context.report({
-					node,
-					loc: {
-						start: operator.loc.end,
-						end: nextToken.loc.start,
-					},
-					messageId: "unexpectedWhitespace",
-					data: {
-						type,
-					},
-					fix(fixer) {
-						return fixer.removeRange([
-							operator.range[1],
-							nextToken.range[0],
-						]);
-					},
-				});
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			SpreadElement: checkWhiteSpace,
-			RestElement: checkWhiteSpace,
-			ExperimentalSpreadProperty: checkWhiteSpace,
-			ExperimentalRestProperty: checkWhiteSpace,
-		};
-	},
-};