@alexlit/lint-kit 166.1.0 → 167.0.0

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

@@ -1,319 +0,0 @@
-/**
- * @fileoverview Rule to disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead
- * @author Sharmila Jesupaul
- */
-
-"use strict";
-
-const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils");
-const {
-	isCommaToken,
-	isOpeningParenToken,
-	isClosingParenToken,
-	isParenthesised,
-} = require("./utils/ast-utils");
-
-const ANY_SPACE = /\s/u;
-
-/**
- * Helper that checks if the Object.assign call has array spread
- * @param {ASTNode} node The node that the rule warns on
- * @returns {boolean} - Returns true if the Object.assign call has array spread
- */
-function hasArraySpread(node) {
-	return node.arguments.some(arg => arg.type === "SpreadElement");
-}
-
-/**
- * Determines whether the given node is an accessor property (getter/setter).
- * @param {ASTNode} node Node to check.
- * @returns {boolean} `true` if the node is a getter or a setter.
- */
-function isAccessorProperty(node) {
-	return (
-		node.type === "Property" && (node.kind === "get" || node.kind === "set")
-	);
-}
-
-/**
- * Determines whether the given object expression node has accessor properties (getters/setters).
- * @param {ASTNode} node `ObjectExpression` node to check.
- * @returns {boolean} `true` if the node has at least one getter/setter.
- */
-function hasAccessors(node) {
-	return node.properties.some(isAccessorProperty);
-}
-
-/**
- * Determines whether the given call expression node has object expression arguments with accessor properties (getters/setters).
- * @param {ASTNode} node `CallExpression` node to check.
- * @returns {boolean} `true` if the node has at least one argument that is an object expression with at least one getter/setter.
- */
-function hasArgumentsWithAccessors(node) {
-	return node.arguments
-		.filter(arg => arg.type === "ObjectExpression")
-		.some(hasAccessors);
-}
-
-/**
- * Helper that checks if the node needs parentheses to be valid JS.
- * The default is to wrap the node in parentheses to avoid parsing errors.
- * @param {ASTNode} node The node that the rule warns on
- * @param {Object} sourceCode in context sourcecode object
- * @returns {boolean} - Returns true if the node needs parentheses
- */
-function needsParens(node, sourceCode) {
-	const parent = node.parent;
-
-	switch (parent.type) {
-		case "VariableDeclarator":
-		case "ArrayExpression":
-		case "ReturnStatement":
-		case "CallExpression":
-		case "Property":
-			return false;
-		case "AssignmentExpression":
-			return parent.left === node && !isParenthesised(sourceCode, node);
-		default:
-			return !isParenthesised(sourceCode, node);
-	}
-}
-
-/**
- * Determines if an argument needs parentheses. The default is to not add parens.
- * @param {ASTNode} node The node to be checked.
- * @param {Object} sourceCode in context sourcecode object
- * @returns {boolean} True if the node needs parentheses
- */
-function argNeedsParens(node, sourceCode) {
-	switch (node.type) {
-		case "AssignmentExpression":
-		case "ArrowFunctionExpression":
-		case "ConditionalExpression":
-			return !isParenthesised(sourceCode, node);
-		default:
-			return false;
-	}
-}
-
-/**
- * Get the parenthesis tokens of a given ObjectExpression node.
- * This includes the braces of the object literal and enclosing parentheses.
- * @param {ASTNode} node The node to get.
- * @param {Token} leftArgumentListParen The opening paren token of the argument list.
- * @param {SourceCode} sourceCode The source code object to get tokens.
- * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.
- */
-function getParenTokens(node, leftArgumentListParen, sourceCode) {
-	const parens = [
-		sourceCode.getFirstToken(node),
-		sourceCode.getLastToken(node),
-	];
-	let leftNext = sourceCode.getTokenBefore(node);
-	let rightNext = sourceCode.getTokenAfter(node);
-
-	// Note: don't include the parens of the argument list.
-	while (
-		leftNext &&
-		rightNext &&
-		leftNext.range[0] > leftArgumentListParen.range[0] &&
-		isOpeningParenToken(leftNext) &&
-		isClosingParenToken(rightNext)
-	) {
-		parens.push(leftNext, rightNext);
-		leftNext = sourceCode.getTokenBefore(leftNext);
-		rightNext = sourceCode.getTokenAfter(rightNext);
-	}
-
-	return parens.sort((a, b) => a.range[0] - b.range[0]);
-}
-
-/**
- * Get the range of a given token and around whitespaces.
- * @param {Token} token The token to get range.
- * @param {SourceCode} sourceCode The source code object to get tokens.
- * @returns {number} The end of the range of the token and around whitespaces.
- */
-function getStartWithSpaces(token, sourceCode) {
-	const text = sourceCode.text;
-	let start = token.range[0];
-
-	// If the previous token is a line comment then skip this step to avoid commenting this token out.
-	{
-		const prevToken = sourceCode.getTokenBefore(token, {
-			includeComments: true,
-		});
-
-		if (prevToken && prevToken.type === "Line") {
-			return start;
-		}
-	}
-
-	// Detect spaces before the token.
-	while (ANY_SPACE.test(text[start - 1] || "")) {
-		start -= 1;
-	}
-
-	return start;
-}
-
-/**
- * Get the range of a given token and around whitespaces.
- * @param {Token} token The token to get range.
- * @param {SourceCode} sourceCode The source code object to get tokens.
- * @returns {number} The start of the range of the token and around whitespaces.
- */
-function getEndWithSpaces(token, sourceCode) {
-	const text = sourceCode.text;
-	let end = token.range[1];
-
-	// Detect spaces after the token.
-	while (ANY_SPACE.test(text[end] || "")) {
-		end += 1;
-	}
-
-	return end;
-}
-
-/**
- * Autofixes the Object.assign call to use an object spread instead.
- * @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call
- * @param {string} sourceCode sourceCode of the Object.assign call
- * @returns {Function} autofixer - replaces the Object.assign with a spread object.
- */
-function defineFixer(node, sourceCode) {
-	return function* (fixer) {
-		const leftParen = sourceCode.getTokenAfter(
-			node.callee,
-			isOpeningParenToken,
-		);
-		const rightParen = sourceCode.getLastToken(node);
-
-		// Remove everything before the opening paren: callee `Object.assign`, type arguments, and whitespace between the callee and the paren.
-		yield fixer.removeRange([node.range[0], leftParen.range[0]]);
-
-		// Replace the parens of argument list to braces.
-		if (needsParens(node, sourceCode)) {
-			yield fixer.replaceText(leftParen, "({");
-			yield fixer.replaceText(rightParen, "})");
-		} else {
-			yield fixer.replaceText(leftParen, "{");
-			yield fixer.replaceText(rightParen, "}");
-		}
-
-		// Process arguments.
-		for (const argNode of node.arguments) {
-			const innerParens = getParenTokens(argNode, leftParen, sourceCode);
-			const left = innerParens.shift();
-			const right = innerParens.pop();
-
-			if (argNode.type === "ObjectExpression") {
-				const maybeTrailingComma = sourceCode.getLastToken(argNode, 1);
-				const maybeArgumentComma = sourceCode.getTokenAfter(right);
-
-				/*
-				 * Make bare this object literal.
-				 * And remove spaces inside of the braces for better formatting.
-				 */
-				for (const innerParen of innerParens) {
-					yield fixer.remove(innerParen);
-				}
-				const leftRange = [
-					left.range[0],
-					getEndWithSpaces(left, sourceCode),
-				];
-				const rightRange = [
-					Math.max(
-						getStartWithSpaces(right, sourceCode),
-						leftRange[1],
-					), // Ensure ranges don't overlap
-					right.range[1],
-				];
-
-				yield fixer.removeRange(leftRange);
-				yield fixer.removeRange(rightRange);
-
-				// Remove the comma of this argument if it's duplication.
-				if (
-					(argNode.properties.length === 0 ||
-						isCommaToken(maybeTrailingComma)) &&
-					isCommaToken(maybeArgumentComma)
-				) {
-					yield fixer.remove(maybeArgumentComma);
-				}
-			} else {
-				// Make spread.
-				if (argNeedsParens(argNode, sourceCode)) {
-					yield fixer.insertTextBefore(left, "...(");
-					yield fixer.insertTextAfter(right, ")");
-				} else {
-					yield fixer.insertTextBefore(left, "...");
-				}
-			}
-		}
-	};
-}
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/prefer-object-spread",
-		},
-
-		schema: [],
-		fixable: "code",
-
-		messages: {
-			useSpreadMessage:
-				"Use an object spread instead of `Object.assign` eg: `{ ...foo }`.",
-			useLiteralMessage:
-				"Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			Program(node) {
-				const scope = sourceCode.getScope(node);
-				const tracker = new ReferenceTracker(scope);
-				const trackMap = {
-					Object: {
-						assign: { [CALL]: true },
-					},
-				};
-
-				// Iterate all calls of `Object.assign` (only of the global variable `Object`).
-				for (const { node: refNode } of tracker.iterateGlobalReferences(
-					trackMap,
-				)) {
-					if (
-						refNode.arguments.length >= 1 &&
-						refNode.arguments[0].type === "ObjectExpression" &&
-						!hasArraySpread(refNode) &&
-						!(
-							refNode.arguments.length > 1 &&
-							hasArgumentsWithAccessors(refNode)
-						)
-					) {
-						const messageId =
-							refNode.arguments.length === 1
-								? "useLiteralMessage"
-								: "useSpreadMessage";
-						const fix = defineFixer(refNode, sourceCode);
-
-						context.report({ node: refNode, messageId, fix });
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/prefer-promise-reject-errors.js

@@ -1,154 +0,0 @@
-/**
- * @fileoverview restrict values that can be used as Promise rejection reasons
- * @author Teddy Katz
- */
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allowEmptyReject: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Require using Error objects as Promise rejection reasons",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/prefer-promise-reject-errors",
-		},
-
-		fixable: null,
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowEmptyReject: { type: "boolean" },
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			rejectAnError:
-				"Expected the Promise rejection reason to be an Error.",
-		},
-	},
-
-	create(context) {
-		const [{ allowEmptyReject }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		//----------------------------------------------------------------------
-		// Helpers
-		//----------------------------------------------------------------------
-
-		/**
-		 * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
-		 * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
-		 * @returns {void}
-		 */
-		function checkRejectCall(callExpression) {
-			if (!callExpression.arguments.length && allowEmptyReject) {
-				return;
-			}
-			if (
-				!callExpression.arguments.length ||
-				!astUtils.couldBeError(callExpression.arguments[0]) ||
-				(callExpression.arguments[0].type === "Identifier" &&
-					callExpression.arguments[0].name === "undefined")
-			) {
-				context.report({
-					node: callExpression,
-					messageId: "rejectAnError",
-				});
-			}
-		}
-
-		/**
-		 * Determines whether a function call is a Promise.reject() call
-		 * @param {ASTNode} node A CallExpression node
-		 * @returns {boolean} `true` if the call is a Promise.reject() call
-		 */
-		function isPromiseRejectCall(node) {
-			return astUtils.isSpecificMemberAccess(
-				node.callee,
-				"Promise",
-				"reject",
-			);
-		}
-
-		//----------------------------------------------------------------------
-		// Public
-		//----------------------------------------------------------------------
-
-		return {
-			// Check `Promise.reject(value)` calls.
-			CallExpression(node) {
-				if (isPromiseRejectCall(node)) {
-					checkRejectCall(node);
-				}
-			},
-
-			/*
-			 * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.
-			 * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that
-			 * the nodes in the expression already have the `parent` property.
-			 */
-			"NewExpression:exit"(node) {
-				if (
-					node.callee.type === "Identifier" &&
-					node.callee.name === "Promise" &&
-					node.arguments.length &&
-					astUtils.isFunction(node.arguments[0]) &&
-					node.arguments[0].params.length > 1 &&
-					node.arguments[0].params[1].type === "Identifier"
-				) {
-					sourceCode
-						.getDeclaredVariables(node.arguments[0])
-
-						/*
-						 * Find the first variable that matches the second parameter's name.
-						 * If the first parameter has the same name as the second parameter, then the variable will actually
-						 * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten
-						 * by the second parameter. It's not possible for an expression with the variable to be evaluated before
-						 * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or
-						 * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for
-						 * this case.
-						 */
-						.find(
-							variable =>
-								variable.name ===
-								node.arguments[0].params[1].name,
-						)
-
-						// Get the references to that variable.
-						.references // Only check the references that read the parameter's value.
-						.filter(ref => ref.isRead())
-
-						// Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.
-						.filter(
-							ref =>
-								ref.identifier.parent.type ===
-									"CallExpression" &&
-								ref.identifier === ref.identifier.parent.callee,
-						)
-
-						// Check the argument of the function call to determine whether it's an Error.
-						.forEach(ref => checkRejectCall(ref.identifier.parent));
-				}
-			},
-		};
-	},
-};

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

@@ -1,150 +0,0 @@
-/**
- * @fileoverview Rule to suggest using "Reflect" api over Function/Object methods
- * @author Keith Cirkel <http://keithcirkel.co.uk>
- * @deprecated in ESLint v3.9.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Require `Reflect` methods where applicable",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/prefer-reflect",
-		},
-
-		deprecated: {
-			message: "The original intention of this rule was misguided.",
-			deprecatedSince: "3.9.0",
-			availableUntil: null,
-			replacedBy: [],
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					exceptions: {
-						type: "array",
-						items: {
-							enum: [
-								"apply",
-								"call",
-								"delete",
-								"defineProperty",
-								"getOwnPropertyDescriptor",
-								"getPrototypeOf",
-								"setPrototypeOf",
-								"isExtensible",
-								"getOwnPropertyNames",
-								"preventExtensions",
-							],
-						},
-						uniqueItems: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			preferReflect:
-				"Avoid using {{existing}}, instead use {{substitute}}.",
-		},
-	},
-
-	create(context) {
-		const existingNames = {
-			apply: "Function.prototype.apply",
-			call: "Function.prototype.call",
-			defineProperty: "Object.defineProperty",
-			getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
-			getPrototypeOf: "Object.getPrototypeOf",
-			setPrototypeOf: "Object.setPrototypeOf",
-			isExtensible: "Object.isExtensible",
-			getOwnPropertyNames: "Object.getOwnPropertyNames",
-			preventExtensions: "Object.preventExtensions",
-		};
-
-		const reflectSubstitutes = {
-			apply: "Reflect.apply",
-			call: "Reflect.apply",
-			defineProperty: "Reflect.defineProperty",
-			getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
-			getPrototypeOf: "Reflect.getPrototypeOf",
-			setPrototypeOf: "Reflect.setPrototypeOf",
-			isExtensible: "Reflect.isExtensible",
-			getOwnPropertyNames: "Reflect.getOwnPropertyNames",
-			preventExtensions: "Reflect.preventExtensions",
-		};
-
-		const exceptions = (context.options[0] || {}).exceptions || [];
-
-		/**
-		 * Reports the Reflect violation based on the `existing` and `substitute`
-		 * @param {Object} node The node that violates the rule.
-		 * @param {string} existing The existing method name that has been used.
-		 * @param {string} substitute The Reflect substitute that should be used.
-		 * @returns {void}
-		 */
-		function report(node, existing, substitute) {
-			context.report({
-				node,
-				messageId: "preferReflect",
-				data: {
-					existing,
-					substitute,
-				},
-			});
-		}
-
-		return {
-			CallExpression(node) {
-				const methodName = (node.callee.property || {}).name;
-				const isReflectCall =
-					(node.callee.object || {}).name === "Reflect";
-				const hasReflectSubstitute = Object.hasOwn(
-					reflectSubstitutes,
-					methodName,
-				);
-				const userConfiguredException = exceptions.includes(methodName);
-
-				if (
-					hasReflectSubstitute &&
-					!isReflectCall &&
-					!userConfiguredException
-				) {
-					report(
-						node,
-						existingNames[methodName],
-						reflectSubstitutes[methodName],
-					);
-				}
-			},
-			UnaryExpression(node) {
-				const isDeleteOperator = node.operator === "delete";
-				const targetsIdentifier = node.argument.type === "Identifier";
-				const userConfiguredException = exceptions.includes("delete");
-
-				if (
-					isDeleteOperator &&
-					!targetsIdentifier &&
-					!userConfiguredException
-				) {
-					report(
-						node,
-						"the delete keyword",
-						"Reflect.deleteProperty",
-					);
-				}
-			},
-		};
-	},
-};