@alexlit/lint-kit 183.1.0 → 183.3.0

package/packages/config-eslint/node_modules/eslint/lib/rules/multiline-ternary.js

@@ -1,257 +0,0 @@
-/**
- * @fileoverview Enforce newlines between operands of ternary expressions
- * @author Kai Cataldo
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-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: "multiline-ternary",
-						url: "https://eslint.style/rules/multiline-ternary",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce newlines between operands of ternary expressions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/multiline-ternary",
-		},
-
-		schema: [
-			{
-				enum: ["always", "always-multiline", "never"],
-			},
-		],
-
-		messages: {
-			expectedTestCons:
-				"Expected newline between test and consequent of ternary expression.",
-			expectedConsAlt:
-				"Expected newline between consequent and alternate of ternary expression.",
-			unexpectedTestCons:
-				"Unexpected newline between test and consequent of ternary expression.",
-			unexpectedConsAlt:
-				"Unexpected newline between consequent and alternate of ternary expression.",
-		},
-
-		fixable: "whitespace",
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const option = context.options[0];
-		const multiline = option !== "never";
-		const allowSingleLine = option === "always-multiline";
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			ConditionalExpression(node) {
-				const questionToken = sourceCode.getTokenAfter(
-					node.test,
-					astUtils.isNotClosingParenToken,
-				);
-				const colonToken = sourceCode.getTokenAfter(
-					node.consequent,
-					astUtils.isNotClosingParenToken,
-				);
-
-				const firstTokenOfTest = sourceCode.getFirstToken(node);
-				const lastTokenOfTest =
-					sourceCode.getTokenBefore(questionToken);
-				const firstTokenOfConsequent =
-					sourceCode.getTokenAfter(questionToken);
-				const lastTokenOfConsequent =
-					sourceCode.getTokenBefore(colonToken);
-				const firstTokenOfAlternate =
-					sourceCode.getTokenAfter(colonToken);
-
-				const areTestAndConsequentOnSameLine =
-					astUtils.isTokenOnSameLine(
-						lastTokenOfTest,
-						firstTokenOfConsequent,
-					);
-				const areConsequentAndAlternateOnSameLine =
-					astUtils.isTokenOnSameLine(
-						lastTokenOfConsequent,
-						firstTokenOfAlternate,
-					);
-
-				const hasComments = !!sourceCode.getCommentsInside(node).length;
-
-				if (!multiline) {
-					if (!areTestAndConsequentOnSameLine) {
-						context.report({
-							node: node.test,
-							loc: {
-								start: firstTokenOfTest.loc.start,
-								end: lastTokenOfTest.loc.end,
-							},
-							messageId: "unexpectedTestCons",
-							fix(fixer) {
-								if (hasComments) {
-									return null;
-								}
-								const fixers = [];
-								const areTestAndQuestionOnSameLine =
-									astUtils.isTokenOnSameLine(
-										lastTokenOfTest,
-										questionToken,
-									);
-								const areQuestionAndConsOnSameLine =
-									astUtils.isTokenOnSameLine(
-										questionToken,
-										firstTokenOfConsequent,
-									);
-
-								if (!areTestAndQuestionOnSameLine) {
-									fixers.push(
-										fixer.removeRange([
-											lastTokenOfTest.range[1],
-											questionToken.range[0],
-										]),
-									);
-								}
-								if (!areQuestionAndConsOnSameLine) {
-									fixers.push(
-										fixer.removeRange([
-											questionToken.range[1],
-											firstTokenOfConsequent.range[0],
-										]),
-									);
-								}
-
-								return fixers;
-							},
-						});
-					}
-
-					if (!areConsequentAndAlternateOnSameLine) {
-						context.report({
-							node: node.consequent,
-							loc: {
-								start: firstTokenOfConsequent.loc.start,
-								end: lastTokenOfConsequent.loc.end,
-							},
-							messageId: "unexpectedConsAlt",
-							fix(fixer) {
-								if (hasComments) {
-									return null;
-								}
-								const fixers = [];
-								const areConsAndColonOnSameLine =
-									astUtils.isTokenOnSameLine(
-										lastTokenOfConsequent,
-										colonToken,
-									);
-								const areColonAndAltOnSameLine =
-									astUtils.isTokenOnSameLine(
-										colonToken,
-										firstTokenOfAlternate,
-									);
-
-								if (!areConsAndColonOnSameLine) {
-									fixers.push(
-										fixer.removeRange([
-											lastTokenOfConsequent.range[1],
-											colonToken.range[0],
-										]),
-									);
-								}
-								if (!areColonAndAltOnSameLine) {
-									fixers.push(
-										fixer.removeRange([
-											colonToken.range[1],
-											firstTokenOfAlternate.range[0],
-										]),
-									);
-								}
-
-								return fixers;
-							},
-						});
-					}
-				} else {
-					if (
-						allowSingleLine &&
-						node.loc.start.line === node.loc.end.line
-					) {
-						return;
-					}
-
-					if (areTestAndConsequentOnSameLine) {
-						context.report({
-							node: node.test,
-							loc: {
-								start: firstTokenOfTest.loc.start,
-								end: lastTokenOfTest.loc.end,
-							},
-							messageId: "expectedTestCons",
-							fix: fixer =>
-								hasComments
-									? null
-									: fixer.replaceTextRange(
-											[
-												lastTokenOfTest.range[1],
-												questionToken.range[0],
-											],
-											"\n",
-										),
-						});
-					}
-
-					if (areConsequentAndAlternateOnSameLine) {
-						context.report({
-							node: node.consequent,
-							loc: {
-								start: firstTokenOfConsequent.loc.start,
-								end: lastTokenOfConsequent.loc.end,
-							},
-							messageId: "expectedConsAlt",
-							fix: fixer =>
-								hasComments
-									? null
-									: fixer.replaceTextRange(
-											[
-												lastTokenOfConsequent.range[1],
-												colonToken.range[0],
-											],
-											"\n",
-										),
-						});
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/new-cap.js

@@ -1,277 +0,0 @@
-/**
- * @fileoverview Rule to flag use of constructors without capital letters
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const CAPS_ALLOWED = [
-	"Array",
-	"Boolean",
-	"Date",
-	"Error",
-	"Function",
-	"Number",
-	"Object",
-	"RegExp",
-	"String",
-	"Symbol",
-	"BigInt",
-];
-
-/**
- * A reducer function to invert an array to an Object mapping the string form of the key, to `true`.
- * @param {Object} map Accumulator object for the reduce.
- * @param {string} key Object key to set to `true`.
- * @returns {Object} Returns the updated Object for further reduction.
- */
-function invert(map, key) {
-	map[key] = true;
-	return map;
-}
-
-/**
- * Creates an object with the cap is new exceptions as its keys and true as their values.
- * @param {Object} config Rule configuration
- * @returns {Object} Object with cap is new exceptions.
- */
-function calculateCapIsNewExceptions(config) {
-	const capIsNewExceptions = Array.from(
-		new Set([...config.capIsNewExceptions, ...CAPS_ALLOWED]),
-	);
-
-	return capIsNewExceptions.reduce(invert, {});
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Require constructor names to begin with a capital letter",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/new-cap",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					newIsCap: {
-						type: "boolean",
-					},
-					capIsNew: {
-						type: "boolean",
-					},
-					newIsCapExceptions: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-					},
-					newIsCapExceptionPattern: {
-						type: "string",
-					},
-					capIsNewExceptions: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-					},
-					capIsNewExceptionPattern: {
-						type: "string",
-					},
-					properties: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		defaultOptions: [
-			{
-				capIsNew: true,
-				capIsNewExceptions: CAPS_ALLOWED,
-				newIsCap: true,
-				newIsCapExceptions: [],
-				properties: true,
-			},
-		],
-
-		messages: {
-			upper: "A function with a name starting with an uppercase letter should only be used as a constructor.",
-			lower: "A constructor name should not start with a lowercase letter.",
-		},
-	},
-
-	create(context) {
-		const [config] = context.options;
-		const skipProperties = !config.properties;
-
-		const newIsCapExceptions = config.newIsCapExceptions.reduce(invert, {});
-		const newIsCapExceptionPattern = config.newIsCapExceptionPattern
-			? new RegExp(config.newIsCapExceptionPattern, "u")
-			: null;
-
-		const capIsNewExceptions = calculateCapIsNewExceptions(config);
-		const capIsNewExceptionPattern = config.capIsNewExceptionPattern
-			? new RegExp(config.capIsNewExceptionPattern, "u")
-			: null;
-
-		const listeners = {};
-
-		const sourceCode = context.sourceCode;
-
-		//--------------------------------------------------------------------------
-		// Helpers
-		//--------------------------------------------------------------------------
-
-		/**
-		 * Get exact callee name from expression
-		 * @param {ASTNode} node CallExpression or NewExpression node
-		 * @returns {string} name
-		 */
-		function extractNameFromExpression(node) {
-			return node.callee.type === "Identifier"
-				? node.callee.name
-				: astUtils.getStaticPropertyName(node.callee) || "";
-		}
-
-		/**
-		 * Returns the capitalization state of the string -
-		 * Whether the first character is uppercase, lowercase, or non-alphabetic
-		 * @param {string} str String
-		 * @returns {string} capitalization state: "non-alpha", "lower", or "upper"
-		 */
-		function getCap(str) {
-			const firstChar = str.charAt(0);
-
-			const firstCharLower = firstChar.toLowerCase();
-			const firstCharUpper = firstChar.toUpperCase();
-
-			if (firstCharLower === firstCharUpper) {
-				// char has no uppercase variant, so it's non-alphabetic
-				return "non-alpha";
-			}
-			if (firstChar === firstCharLower) {
-				return "lower";
-			}
-			return "upper";
-		}
-
-		/**
-		 * Check if capitalization is allowed for a CallExpression
-		 * @param {Object} allowedMap Object mapping calleeName to a Boolean
-		 * @param {ASTNode} node CallExpression node
-		 * @param {string} calleeName Capitalized callee name from a CallExpression
-		 * @param {Object} pattern RegExp object from options pattern
-		 * @returns {boolean} Returns true if the callee may be capitalized
-		 */
-		function isCapAllowed(allowedMap, node, calleeName, pattern) {
-			const sourceText = sourceCode.getText(node.callee);
-
-			if (allowedMap[calleeName] || allowedMap[sourceText]) {
-				return true;
-			}
-
-			if (pattern && pattern.test(sourceText)) {
-				return true;
-			}
-
-			const callee = astUtils.skipChainExpression(node.callee);
-
-			if (calleeName === "UTC" && callee.type === "MemberExpression") {
-				// allow if callee is Date.UTC
-				return (
-					callee.object.type === "Identifier" &&
-					callee.object.name === "Date"
-				);
-			}
-
-			return skipProperties && callee.type === "MemberExpression";
-		}
-
-		/**
-		 * Reports the given messageId for the given node. The location will be the start of the property or the callee.
-		 * @param {ASTNode} node CallExpression or NewExpression node.
-		 * @param {string} messageId The messageId to report.
-		 * @returns {void}
-		 */
-		function report(node, messageId) {
-			let callee = astUtils.skipChainExpression(node.callee);
-
-			if (callee.type === "MemberExpression") {
-				callee = callee.property;
-			}
-
-			context.report({ node, loc: callee.loc, messageId });
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		if (config.newIsCap) {
-			listeners.NewExpression = function (node) {
-				const constructorName = extractNameFromExpression(node);
-
-				if (constructorName) {
-					const capitalization = getCap(constructorName);
-					const isAllowed =
-						capitalization !== "lower" ||
-						isCapAllowed(
-							newIsCapExceptions,
-							node,
-							constructorName,
-							newIsCapExceptionPattern,
-						);
-
-					if (!isAllowed) {
-						report(node, "lower");
-					}
-				}
-			};
-		}
-
-		if (config.capIsNew) {
-			listeners.CallExpression = function (node) {
-				const calleeName = extractNameFromExpression(node);
-
-				if (calleeName) {
-					const capitalization = getCap(calleeName);
-					const isAllowed =
-						capitalization !== "upper" ||
-						isCapAllowed(
-							capIsNewExceptions,
-							node,
-							calleeName,
-							capIsNewExceptionPattern,
-						);
-
-					if (!isAllowed) {
-						report(node, "upper");
-					}
-				}
-			};
-		}
-
-		return listeners;
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/new-parens.js

@@ -1,120 +0,0 @@
-/**
- * @fileoverview Rule to flag when using constructor without parentheses
- * @author Ilya Volodin
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// 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: "new-parens",
-						url: "https://eslint.style/rules/new-parens",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description:
-				"Enforce or disallow parentheses when invoking a constructor with no arguments",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/new-parens",
-		},
-
-		fixable: "code",
-		schema: [
-			{
-				enum: ["always", "never"],
-			},
-		],
-		messages: {
-			missing: "Missing '()' invoking a constructor.",
-			unnecessary:
-				"Unnecessary '()' invoking a constructor with no arguments.",
-		},
-	},
-
-	create(context) {
-		const options = context.options;
-		const always = options[0] !== "never"; // Default is always
-
-		const sourceCode = context.sourceCode;
-
-		return {
-			NewExpression(node) {
-				if (node.arguments.length !== 0) {
-					return; // if there are arguments, there have to be parens
-				}
-
-				const lastToken = sourceCode.getLastToken(node);
-				const hasLastParen =
-					lastToken && astUtils.isClosingParenToken(lastToken);
-
-				// `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens
-				const hasParens =
-					hasLastParen &&
-					astUtils.isOpeningParenToken(
-						sourceCode.getTokenBefore(lastToken),
-					) &&
-					node.callee.range[1] < node.range[1];
-
-				if (always) {
-					if (!hasParens) {
-						context.report({
-							node,
-							messageId: "missing",
-							fix: fixer => fixer.insertTextAfter(node, "()"),
-						});
-					}
-				} else {
-					if (hasParens) {
-						context.report({
-							node,
-							messageId: "unnecessary",
-							fix: fixer => [
-								fixer.remove(
-									sourceCode.getTokenBefore(lastToken),
-								),
-								fixer.remove(lastToken),
-								fixer.insertTextBefore(node, "("),
-								fixer.insertTextAfter(node, ")"),
-							],
-						});
-					}
-				}
-			},
-		};
-	},
-};