@alexlit/lint-kit 175.0.0 → 176.0.1

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

@@ -1,406 +0,0 @@
-/**
- * @fileoverview Look for useless escapes in strings and regexes
- * @author Onur Temizkan
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
-
-/**
- * @typedef {import('@eslint-community/regexpp').AST.CharacterClass} CharacterClass
- * @typedef {import('@eslint-community/regexpp').AST.ExpressionCharacterClass} ExpressionCharacterClass
- */
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * Returns the union of two sets.
- * @param {Set} setA The first set
- * @param {Set} setB The second set
- * @returns {Set} The union of the two sets
- */
-function union(setA, setB) {
-	return new Set(
-		(function* () {
-			yield* setA;
-			yield* setB;
-		})(),
-	);
-}
-
-const VALID_STRING_ESCAPES = union(new Set("\\nrvtbfux"), astUtils.LINEBREAKS);
-const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnpPrsStvwWxu0123456789]");
-const REGEX_NON_CHARCLASS_ESCAPES = union(
-	REGEX_GENERAL_ESCAPES,
-	new Set("^/.$*+?[{}|()Bk"),
-);
-
-/*
- * Set of characters that require escaping in character classes in `unicodeSets` mode.
- * ( ) [ ] { } / - \ | are ClassSetSyntaxCharacter
- */
-const REGEX_CLASSSET_CHARACTER_ESCAPES = union(
-	REGEX_GENERAL_ESCAPES,
-	new Set("q/[{}|()-"),
-);
-
-/*
- * A single character set of ClassSetReservedDoublePunctuator.
- * && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ are ClassSetReservedDoublePunctuator
- */
-const REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR = new Set(
-	"!#$%&*+,.:;<=>?@^`~",
-);
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allowRegexCharacters: [],
-			},
-		],
-
-		docs: {
-			description: "Disallow unnecessary escape characters",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-useless-escape",
-		},
-
-		hasSuggestions: true,
-
-		messages: {
-			unnecessaryEscape: "Unnecessary escape character: \\{{character}}.",
-			removeEscape:
-				"Remove the `\\`. This maintains the current functionality.",
-			removeEscapeDoNotKeepSemantics:
-				"Remove the `\\` if it was inserted by mistake.",
-			escapeBackslash:
-				"Replace the `\\` with `\\\\` to include the actual backslash character.",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowRegexCharacters: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-						uniqueItems: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ allowRegexCharacters }] = context.options;
-		const parser = new RegExpParser();
-
-		/**
-		 * Reports a node
-		 * @param {ASTNode} node The node to report
-		 * @param {number} startOffset The backslash's offset from the start of the node
-		 * @param {string} character The uselessly escaped character (not including the backslash)
-		 * @param {boolean} [disableEscapeBackslashSuggest] `true` if escapeBackslash suggestion should be turned off.
-		 * @returns {void}
-		 */
-		function report(
-			node,
-			startOffset,
-			character,
-			disableEscapeBackslashSuggest,
-		) {
-			const rangeStart = node.range[0] + startOffset;
-			const range = [rangeStart, rangeStart + 1];
-			const start = sourceCode.getLocFromIndex(rangeStart);
-
-			context.report({
-				node,
-				loc: {
-					start,
-					end: { line: start.line, column: start.column + 1 },
-				},
-				messageId: "unnecessaryEscape",
-				data: { character },
-				suggest: [
-					{
-						// Removing unnecessary `\` characters in a directive is not guaranteed to maintain functionality.
-						messageId: astUtils.isDirective(node.parent)
-							? "removeEscapeDoNotKeepSemantics"
-							: "removeEscape",
-						fix(fixer) {
-							return fixer.removeRange(range);
-						},
-					},
-					...(disableEscapeBackslashSuggest
-						? []
-						: [
-								{
-									messageId: "escapeBackslash",
-									fix(fixer) {
-										return fixer.insertTextBeforeRange(
-											range,
-											"\\",
-										);
-									},
-								},
-							]),
-				],
-			});
-		}
-
-		/**
-		 * Checks if the escape character in given string slice is unnecessary.
-		 * @private
-		 * @param {ASTNode} node node to validate.
-		 * @param {string} match string slice to validate.
-		 * @returns {void}
-		 */
-		function validateString(node, match) {
-			const isTemplateElement = node.type === "TemplateElement";
-			const escapedChar = match[0][1];
-			let isUnnecessaryEscape = !VALID_STRING_ESCAPES.has(escapedChar);
-			let isQuoteEscape;
-
-			if (isTemplateElement) {
-				isQuoteEscape = escapedChar === "`";
-
-				if (escapedChar === "$") {
-					// Warn if `\$` is not followed by `{`
-					isUnnecessaryEscape = match.input[match.index + 2] !== "{";
-				} else if (escapedChar === "{") {
-					/*
-					 * Warn if `\{` is not preceded by `$`. If preceded by `$`, escaping
-					 * is necessary and the rule should not warn. If preceded by `/$`, the rule
-					 * will warn for the `/$` instead, as it is the first unnecessarily escaped character.
-					 */
-					isUnnecessaryEscape = match.input[match.index - 1] !== "$";
-				}
-			} else {
-				isQuoteEscape = escapedChar === node.raw[0];
-			}
-
-			if (isUnnecessaryEscape && !isQuoteEscape) {
-				report(node, match.index, match[0].slice(1));
-			}
-		}
-
-		/**
-		 * Checks if the escape character in given regexp is unnecessary.
-		 * @private
-		 * @param {ASTNode} node node to validate.
-		 * @returns {void}
-		 */
-		function validateRegExp(node) {
-			const { pattern, flags } = node.regex;
-			let patternNode;
-			const unicode = flags.includes("u");
-			const unicodeSets = flags.includes("v");
-
-			try {
-				patternNode = parser.parsePattern(pattern, 0, pattern.length, {
-					unicode,
-					unicodeSets,
-				});
-			} catch {
-				// Ignore regular expressions with syntax errors
-				return;
-			}
-
-			/** @type {(CharacterClass | ExpressionCharacterClass)[]} */
-			const characterClassStack = [];
-
-			visitRegExpAST(patternNode, {
-				onCharacterClassEnter: characterClassNode =>
-					characterClassStack.unshift(characterClassNode),
-				onCharacterClassLeave: () => characterClassStack.shift(),
-				onExpressionCharacterClassEnter: characterClassNode =>
-					characterClassStack.unshift(characterClassNode),
-				onExpressionCharacterClassLeave: () =>
-					characterClassStack.shift(),
-				onCharacterEnter(characterNode) {
-					if (!characterNode.raw.startsWith("\\")) {
-						// It's not an escaped character.
-						return;
-					}
-
-					const escapedChar = characterNode.raw.slice(1);
-
-					if (
-						escapedChar !==
-							String.fromCodePoint(characterNode.value) ||
-						allowRegexCharacters.includes(escapedChar)
-					) {
-						// It's a valid escape.
-						return;
-					}
-					let allowedEscapes;
-
-					if (characterClassStack.length) {
-						allowedEscapes = unicodeSets
-							? REGEX_CLASSSET_CHARACTER_ESCAPES
-							: REGEX_GENERAL_ESCAPES;
-					} else {
-						allowedEscapes = REGEX_NON_CHARCLASS_ESCAPES;
-					}
-					if (allowedEscapes.has(escapedChar)) {
-						return;
-					}
-
-					const reportedIndex = characterNode.start + 1;
-					let disableEscapeBackslashSuggest = false;
-
-					if (characterClassStack.length) {
-						const characterClassNode = characterClassStack[0];
-
-						if (escapedChar === "^") {
-							/*
-							 * The '^' character is also a special case; it must always be escaped outside of character classes, but
-							 * it only needs to be escaped in character classes if it's at the beginning of the character class. To
-							 * account for this, consider it to be a valid escape character outside of character classes, and filter
-							 * out '^' characters that appear at the start of a character class.
-							 */
-							if (
-								characterClassNode.start + 1 ===
-								characterNode.start
-							) {
-								return;
-							}
-						}
-						if (!unicodeSets) {
-							if (escapedChar === "-") {
-								/*
-								 * The '-' character is a special case, because it's only valid to escape it if it's in a character
-								 * class, and is not at either edge of the character class. To account for this, don't consider '-'
-								 * characters to be valid in general, and filter out '-' characters that appear in the middle of a
-								 * character class.
-								 */
-								if (
-									characterClassNode.start + 1 !==
-										characterNode.start &&
-									characterNode.end !==
-										characterClassNode.end - 1
-								) {
-									return;
-								}
-							}
-						} else {
-							// unicodeSets mode
-							if (
-								REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR.has(
-									escapedChar,
-								)
-							) {
-								// Escaping is valid if it is a ClassSetReservedDoublePunctuator.
-								if (
-									pattern[characterNode.end] === escapedChar
-								) {
-									return;
-								}
-								if (
-									pattern[characterNode.start - 1] ===
-									escapedChar
-								) {
-									if (escapedChar !== "^") {
-										return;
-									}
-
-									// If the previous character is a `negate` caret(`^`), escape to caret is unnecessary.
-
-									if (!characterClassNode.negate) {
-										return;
-									}
-									const negateCaretIndex =
-										characterClassNode.start + 1;
-
-									if (
-										negateCaretIndex <
-										characterNode.start - 1
-									) {
-										return;
-									}
-								}
-							}
-
-							if (
-								characterNode.parent.type ===
-									"ClassIntersection" ||
-								characterNode.parent.type === "ClassSubtraction"
-							) {
-								disableEscapeBackslashSuggest = true;
-							}
-						}
-					}
-
-					report(
-						node,
-						reportedIndex,
-						escapedChar,
-						disableEscapeBackslashSuggest,
-					);
-				},
-			});
-		}
-
-		/**
-		 * Checks if a node has an escape.
-		 * @param {ASTNode} node node to check.
-		 * @returns {void}
-		 */
-		function check(node) {
-			const isTemplateElement = node.type === "TemplateElement";
-
-			if (
-				isTemplateElement &&
-				node.parent &&
-				node.parent.parent &&
-				node.parent.parent.type === "TaggedTemplateExpression" &&
-				node.parent === node.parent.parent.quasi
-			) {
-				// Don't report tagged template literals, because the backslash character is accessible to the tag function.
-				return;
-			}
-
-			if (typeof node.value === "string" || isTemplateElement) {
-				/*
-				 * JSXAttribute doesn't have any escape sequence: https://facebook.github.io/jsx/.
-				 * In addition, backticks are not supported by JSX yet: https://github.com/facebook/jsx/issues/25.
-				 */
-				if (
-					node.parent.type === "JSXAttribute" ||
-					node.parent.type === "JSXElement" ||
-					node.parent.type === "JSXFragment"
-				) {
-					return;
-				}
-
-				const value = isTemplateElement
-					? sourceCode.getText(node)
-					: node.raw;
-				const pattern = /\\\D/gu;
-				let match;
-
-				while ((match = pattern.exec(value))) {
-					validateString(node, match);
-				}
-			} else if (node.regex) {
-				validateRegExp(node);
-			}
-		}
-
-		return {
-			Literal: check,
-			TemplateElement: check,
-		};
-	},
-};

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

@@ -1,202 +0,0 @@
-/**
- * @fileoverview Disallow renaming import, export, and destructured assignments to the same name.
- * @author Kai Cataldo
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				ignoreDestructuring: false,
-				ignoreImport: false,
-				ignoreExport: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Disallow renaming import, export, and destructured assignments to the same name",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-useless-rename",
-		},
-
-		fixable: "code",
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					ignoreDestructuring: { type: "boolean" },
-					ignoreImport: { type: "boolean" },
-					ignoreExport: { type: "boolean" },
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unnecessarilyRenamed: "{{type}} {{name}} unnecessarily renamed.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const [{ ignoreDestructuring, ignoreImport, ignoreExport }] =
-			context.options;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Reports error for unnecessarily renamed assignments
-		 * @param {ASTNode} node node to report
-		 * @param {ASTNode} initial node with initial name value
-		 * @param {string} type the type of the offending node
-		 * @returns {void}
-		 */
-		function reportError(node, initial, type) {
-			const name =
-				initial.type === "Identifier" ? initial.name : initial.value;
-
-			return context.report({
-				node,
-				messageId: "unnecessarilyRenamed",
-				data: {
-					name,
-					type,
-				},
-				fix(fixer) {
-					const replacementNode =
-						node.type === "Property" ? node.value : node.local;
-
-					if (
-						sourceCode.getCommentsInside(node).length >
-						sourceCode.getCommentsInside(replacementNode).length
-					) {
-						return null;
-					}
-
-					// Don't autofix code such as `({foo: (foo) = a} = obj);`, parens are not allowed in shorthand properties.
-					if (
-						replacementNode.type === "AssignmentPattern" &&
-						astUtils.isParenthesised(
-							sourceCode,
-							replacementNode.left,
-						)
-					) {
-						return null;
-					}
-
-					return fixer.replaceText(
-						node,
-						sourceCode.getText(replacementNode),
-					);
-				},
-			});
-		}
-
-		/**
-		 * Checks whether a destructured assignment is unnecessarily renamed
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function checkDestructured(node) {
-			if (ignoreDestructuring) {
-				return;
-			}
-
-			for (const property of node.properties) {
-				/**
-				 * Properties using shorthand syntax and rest elements can not be renamed.
-				 * If the property is computed, we have no idea if a rename is useless or not.
-				 */
-				if (
-					property.type !== "Property" ||
-					property.shorthand ||
-					property.computed
-				) {
-					continue;
-				}
-
-				const key =
-					(property.key.type === "Identifier" && property.key.name) ||
-					(property.key.type === "Literal" && property.key.value);
-				const renamedKey =
-					property.value.type === "AssignmentPattern"
-						? property.value.left.name
-						: property.value.name;
-
-				if (key === renamedKey) {
-					reportError(
-						property,
-						property.key,
-						"Destructuring assignment",
-					);
-				}
-			}
-		}
-
-		/**
-		 * Checks whether an import is unnecessarily renamed
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function checkImport(node) {
-			if (ignoreImport) {
-				return;
-			}
-
-			if (
-				node.imported.range[0] !== node.local.range[0] &&
-				astUtils.getModuleExportName(node.imported) === node.local.name
-			) {
-				reportError(node, node.imported, "Import");
-			}
-		}
-
-		/**
-		 * Checks whether an export is unnecessarily renamed
-		 * @param {ASTNode} node node to check
-		 * @returns {void}
-		 */
-		function checkExport(node) {
-			if (ignoreExport) {
-				return;
-			}
-
-			if (
-				node.local.range[0] !== node.exported.range[0] &&
-				astUtils.getModuleExportName(node.local) ===
-					astUtils.getModuleExportName(node.exported)
-			) {
-				reportError(node, node.local, "Export");
-			}
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			ObjectPattern: checkDestructured,
-			ImportSpecifier: checkImport,
-			ExportSpecifier: checkExport,
-		};
-	},
-};