@alexlit/lint-kit 183.1.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/prefer-named-capture-group.js

@@ -1,197 +0,0 @@
-/**
- * @fileoverview Rule to enforce requiring named capture groups in regular expression.
- * @author Pig Fang <https://github.com/g-plane>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-	CALL,
-	CONSTRUCT,
-	ReferenceTracker,
-	getStringIfConstant,
-} = require("@eslint-community/eslint-utils");
-const regexpp = require("@eslint-community/regexpp");
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/** @import { SuggestedEdit } from "@eslint/core"; */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const parser = new regexpp.RegExpParser();
-
-/**
- * Creates fixer suggestions for the regex, if statically determinable.
- * @param {number} groupStart Starting index of the regex group.
- * @param {string} pattern The regular expression pattern to be checked.
- * @param {string} rawText Source text of the regexNode.
- * @param {ASTNode} regexNode AST node which contains the regular expression.
- * @returns {Array<SuggestedEdit>} Fixer suggestions for the regex, if statically determinable.
- */
-function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
-	switch (regexNode.type) {
-		case "Literal":
-			if (typeof regexNode.value === "string" && rawText.includes("\\")) {
-				return null;
-			}
-			break;
-		case "TemplateLiteral":
-			if (
-				regexNode.expressions.length ||
-				rawText.slice(1, -1) !== pattern
-			) {
-				return null;
-			}
-			break;
-		default:
-			return null;
-	}
-
-	const start = regexNode.range[0] + groupStart + 2;
-
-	return [
-		{
-			fix(fixer) {
-				const existingTemps = pattern.match(/temp\d+/gu) || [];
-				const highestTempCount = existingTemps.reduce(
-					(previous, next) =>
-						Math.max(previous, Number(next.slice("temp".length))),
-					0,
-				);
-
-				return fixer.insertTextBeforeRange(
-					[start, start],
-					`?<temp${highestTempCount + 1}>`,
-				);
-			},
-			messageId: "addGroupName",
-		},
-		{
-			fix(fixer) {
-				return fixer.insertTextBeforeRange([start, start], "?:");
-			},
-			messageId: "addNonCapture",
-		},
-	];
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Enforce using named capture group in regular expression",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/prefer-named-capture-group",
-		},
-
-		hasSuggestions: true,
-
-		schema: [],
-
-		messages: {
-			addGroupName: "Add name to capture group.",
-			addNonCapture: "Convert group to non-capturing.",
-			required:
-				"Capture group '{{group}}' should be converted to a named or non-capturing group.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Function to check regular expression.
-		 * @param {string} pattern The regular expression pattern to be checked.
-		 * @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
-		 * @param {ASTNode} regexNode AST node which contains the regular expression.
-		 * @param {string|null} flags The regular expression flags to be checked.
-		 * @returns {void}
-		 */
-		function checkRegex(pattern, node, regexNode, flags) {
-			let ast;
-
-			try {
-				ast = parser.parsePattern(pattern, 0, pattern.length, {
-					unicode: Boolean(flags && flags.includes("u")),
-					unicodeSets: Boolean(flags && flags.includes("v")),
-				});
-			} catch {
-				// ignore regex syntax errors
-				return;
-			}
-
-			regexpp.visitRegExpAST(ast, {
-				onCapturingGroupEnter(group) {
-					if (!group.name) {
-						const rawText = sourceCode.getText(regexNode);
-						const suggest = suggestIfPossible(
-							group.start,
-							pattern,
-							rawText,
-							regexNode,
-						);
-
-						context.report({
-							node,
-							messageId: "required",
-							data: {
-								group: group.raw,
-							},
-							suggest,
-						});
-					}
-				},
-			});
-		}
-
-		return {
-			Literal(node) {
-				if (node.regex) {
-					checkRegex(
-						node.regex.pattern,
-						node,
-						node,
-						node.regex.flags,
-					);
-				}
-			},
-			Program(node) {
-				const scope = sourceCode.getScope(node);
-				const tracker = new ReferenceTracker(scope);
-				const traceMap = {
-					RegExp: {
-						[CALL]: true,
-						[CONSTRUCT]: true,
-					},
-				};
-
-				for (const { node: refNode } of tracker.iterateGlobalReferences(
-					traceMap,
-				)) {
-					const regex = getStringIfConstant(refNode.arguments[0]);
-					const flags = getStringIfConstant(refNode.arguments[1]);
-
-					if (regex) {
-						checkRegex(regex, refNode, refNode.arguments[0], flags);
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/prefer-numeric-literals.js

@@ -1,157 +0,0 @@
-/**
- * @fileoverview Rule to disallow `parseInt()` in favor of binary, octal, and hexadecimal literals
- * @author Annie Zhang, Henry Zhu
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const radixMap = new Map([
-	[2, { system: "binary", literalPrefix: "0b" }],
-	[8, { system: "octal", literalPrefix: "0o" }],
-	[16, { system: "hexadecimal", literalPrefix: "0x" }],
-]);
-
-/**
- * Checks to see if a CallExpression's callee node is `parseInt` or
- * `Number.parseInt`.
- * @param {ASTNode} calleeNode The callee node to evaluate.
- * @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`,
- * false otherwise.
- */
-function isParseInt(calleeNode) {
-	return (
-		astUtils.isSpecificId(calleeNode, "parseInt") ||
-		astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
-	);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/prefer-numeric-literals",
-		},
-
-		schema: [],
-
-		messages: {
-			useLiteral:
-				"Use {{system}} literals instead of {{functionName}}().",
-		},
-
-		fixable: "code",
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		//----------------------------------------------------------------------
-		// Public
-		//----------------------------------------------------------------------
-
-		return {
-			"CallExpression[arguments.length=2]"(node) {
-				const [strNode, radixNode] = node.arguments,
-					str = astUtils.getStaticStringValue(strNode),
-					radix = radixNode.value;
-
-				if (
-					str !== null &&
-					astUtils.isStringLiteral(strNode) &&
-					radixNode.type === "Literal" &&
-					typeof radix === "number" &&
-					radixMap.has(radix) &&
-					isParseInt(node.callee)
-				) {
-					const { system, literalPrefix } = radixMap.get(radix);
-
-					context.report({
-						node,
-						messageId: "useLiteral",
-						data: {
-							system,
-							functionName: sourceCode.getText(node.callee),
-						},
-						fix(fixer) {
-							if (sourceCode.getCommentsInside(node).length) {
-								return null;
-							}
-
-							const replacement = `${literalPrefix}${str}`;
-
-							if (+replacement !== parseInt(str, radix)) {
-								/*
-								 * If the newly-produced literal would be invalid, (e.g. 0b1234),
-								 * or it would yield an incorrect parseInt result for some other reason, don't make a fix.
-								 *
-								 * If `str` had numeric separators, `+replacement` will evaluate to `NaN` because unary `+`
-								 * per the specification doesn't support numeric separators. Thus, the above condition will be `true`
-								 * (`NaN !== anything` is always `true`) regardless of the `parseInt(str, radix)` value.
-								 * Consequently, no autofixes will be made. This is correct behavior because `parseInt` also
-								 * doesn't support numeric separators, but it does parse part of the string before the first `_`,
-								 * so the autofix would be invalid:
-								 *
-								 *   parseInt("1_1", 2) // === 1
-								 *   0b1_1 // === 3
-								 */
-								return null;
-							}
-
-							const tokenBefore = sourceCode.getTokenBefore(node),
-								tokenAfter = sourceCode.getTokenAfter(node);
-							let prefix = "",
-								suffix = "";
-
-							if (
-								tokenBefore &&
-								tokenBefore.range[1] === node.range[0] &&
-								!astUtils.canTokensBeAdjacent(
-									tokenBefore,
-									replacement,
-								)
-							) {
-								prefix = " ";
-							}
-
-							if (
-								tokenAfter &&
-								node.range[1] === tokenAfter.range[0] &&
-								!astUtils.canTokensBeAdjacent(
-									replacement,
-									tokenAfter,
-								)
-							) {
-								suffix = " ";
-							}
-
-							return fixer.replaceText(
-								node,
-								`${prefix}${replacement}${suffix}`,
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/prefer-object-has-own.js

@@ -1,148 +0,0 @@
-/**
- * @fileoverview Prefers Object.hasOwn() instead of Object.prototype.hasOwnProperty.call()
- * @author Nitin Kumar
- * @author Gautam Arora
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks if the given node is considered to be an access to a property of `Object.prototype`.
- * @param {ASTNode} node `MemberExpression` node to evaluate.
- * @returns {boolean} `true` if `node.object` is `Object`, `Object.prototype`, or `{}` (empty 'ObjectExpression' node).
- */
-function hasLeftHandObject(node) {
-	/*
-	 * ({}).hasOwnProperty.call(obj, prop) - `true`
-	 * ({ foo }.hasOwnProperty.call(obj, prop)) - `false`, object literal should be empty
-	 */
-	if (
-		node.object.type === "ObjectExpression" &&
-		node.object.properties.length === 0
-	) {
-		return true;
-	}
-
-	const objectNodeToCheck =
-		node.object.type === "MemberExpression" &&
-		astUtils.getStaticPropertyName(node.object) === "prototype"
-			? node.object.object
-			: node.object;
-
-	if (
-		objectNodeToCheck.type === "Identifier" &&
-		objectNodeToCheck.name === "Object"
-	) {
-		return true;
-	}
-
-	return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/prefer-object-has-own",
-		},
-		schema: [],
-		messages: {
-			useHasOwn:
-				"Use 'Object.hasOwn()' instead of 'Object.prototype.hasOwnProperty.call()'.",
-		},
-		fixable: "code",
-	},
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			CallExpression(node) {
-				if (
-					!(
-						node.callee.type === "MemberExpression" &&
-						node.callee.object.type === "MemberExpression"
-					)
-				) {
-					return;
-				}
-
-				const calleePropertyName = astUtils.getStaticPropertyName(
-					node.callee,
-				);
-				const objectPropertyName = astUtils.getStaticPropertyName(
-					node.callee.object,
-				);
-				const isObject = hasLeftHandObject(node.callee.object);
-
-				// check `Object` scope
-				const scope = sourceCode.getScope(node);
-				const variable = astUtils.getVariableByName(scope, "Object");
-
-				if (
-					calleePropertyName === "call" &&
-					objectPropertyName === "hasOwnProperty" &&
-					isObject &&
-					variable &&
-					variable.scope.type === "global"
-				) {
-					context.report({
-						node,
-						messageId: "useHasOwn",
-						fix(fixer) {
-							if (
-								sourceCode.getCommentsInside(node.callee)
-									.length > 0
-							) {
-								return null;
-							}
-
-							const tokenJustBeforeNode =
-								sourceCode.getTokenBefore(node.callee, {
-									includeComments: true,
-								});
-
-							// for https://github.com/eslint/eslint/pull/15346#issuecomment-991417335
-							if (
-								tokenJustBeforeNode &&
-								tokenJustBeforeNode.range[1] ===
-									node.callee.range[0] &&
-								!astUtils.canTokensBeAdjacent(
-									tokenJustBeforeNode,
-									"Object.hasOwn",
-								)
-							) {
-								return fixer.replaceText(
-									node.callee,
-									" Object.hasOwn",
-								);
-							}
-
-							return fixer.replaceText(
-								node.callee,
-								"Object.hasOwn",
-							);
-						},
-					});
-				}
-			},
-		};
-	},
-};