@alexlit/lint-kit 166.0.1 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/getter-return.js

@@ -1,242 +0,0 @@
-/**
- * @fileoverview Enforces that a return statement is present in property getters.
- * @author Aladdin-ADD(hh_2013@foxmail.com)
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
-
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				allowImplicit: false,
-			},
-		],
-
-		docs: {
-			description: "Enforce `return` statements in getters",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/getter-return",
-		},
-
-		fixable: null,
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowImplicit: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			expected: "Expected to return a value in {{name}}.",
-			expectedAlways: "Expected {{name}} to always return a value.",
-		},
-	},
-
-	create(context) {
-		const [{ allowImplicit }] = context.options;
-		const sourceCode = context.sourceCode;
-
-		let funcInfo = {
-			upper: null,
-			codePath: null,
-			hasReturn: false,
-			shouldCheck: false,
-			node: null,
-			currentSegments: [],
-		};
-
-		/**
-		 * Checks whether or not the last code path segment is reachable.
-		 * Then reports this function if the segment is reachable.
-		 *
-		 * If the last code path segment is reachable, there are paths which are not
-		 * returned or thrown.
-		 * @param {ASTNode} node A node to check.
-		 * @returns {void}
-		 */
-		function checkLastSegment(node) {
-			if (
-				funcInfo.shouldCheck &&
-				isAnySegmentReachable(funcInfo.currentSegments)
-			) {
-				context.report({
-					node,
-					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
-					messageId: funcInfo.hasReturn
-						? "expectedAlways"
-						: "expected",
-					data: {
-						name: astUtils.getFunctionNameWithKind(funcInfo.node),
-					},
-				});
-			}
-		}
-
-		/**
-		 * Checks whether a node means a getter function.
-		 * @param {ASTNode} node a node to check.
-		 * @returns {boolean} if node means a getter, return true; else return false.
-		 */
-		function isGetter(node) {
-			const parent = node.parent;
-
-			if (
-				TARGET_NODE_TYPE.test(node.type) &&
-				node.body.type === "BlockStatement"
-			) {
-				if (parent.kind === "get") {
-					return true;
-				}
-				if (
-					parent.type === "Property" &&
-					astUtils.getStaticPropertyName(parent) === "get" &&
-					parent.parent.type === "ObjectExpression"
-				) {
-					// Object.defineProperty() or Reflect.defineProperty()
-					if (parent.parent.parent.type === "CallExpression") {
-						const callNode = parent.parent.parent.callee;
-
-						if (
-							astUtils.isSpecificMemberAccess(
-								callNode,
-								"Object",
-								"defineProperty",
-							) ||
-							astUtils.isSpecificMemberAccess(
-								callNode,
-								"Reflect",
-								"defineProperty",
-							)
-						) {
-							return true;
-						}
-					}
-
-					// Object.defineProperties() or Object.create()
-					if (
-						parent.parent.parent.type === "Property" &&
-						parent.parent.parent.parent.type ===
-							"ObjectExpression" &&
-						parent.parent.parent.parent.parent.type ===
-							"CallExpression"
-					) {
-						const callNode =
-							parent.parent.parent.parent.parent.callee;
-
-						return (
-							astUtils.isSpecificMemberAccess(
-								callNode,
-								"Object",
-								"defineProperties",
-							) ||
-							astUtils.isSpecificMemberAccess(
-								callNode,
-								"Object",
-								"create",
-							)
-						);
-					}
-				}
-			}
-			return false;
-		}
-		return {
-			// Stacks this function's information.
-			onCodePathStart(codePath, node) {
-				funcInfo = {
-					upper: funcInfo,
-					codePath,
-					hasReturn: false,
-					shouldCheck: isGetter(node),
-					node,
-					currentSegments: new Set(),
-				};
-			},
-
-			// Pops this function's information.
-			onCodePathEnd() {
-				funcInfo = funcInfo.upper;
-			},
-			onUnreachableCodePathSegmentStart(segment) {
-				funcInfo.currentSegments.add(segment);
-			},
-
-			onUnreachableCodePathSegmentEnd(segment) {
-				funcInfo.currentSegments.delete(segment);
-			},
-
-			onCodePathSegmentStart(segment) {
-				funcInfo.currentSegments.add(segment);
-			},
-
-			onCodePathSegmentEnd(segment) {
-				funcInfo.currentSegments.delete(segment);
-			},
-
-			// Checks the return statement is valid.
-			ReturnStatement(node) {
-				if (funcInfo.shouldCheck) {
-					funcInfo.hasReturn = true;
-
-					// if allowImplicit: false, should also check node.argument
-					if (!allowImplicit && !node.argument) {
-						context.report({
-							node,
-							messageId: "expected",
-							data: {
-								name: astUtils.getFunctionNameWithKind(
-									funcInfo.node,
-								),
-							},
-						});
-					}
-				}
-			},
-
-			// Reports a given function if the last path is reachable.
-			"FunctionExpression:exit": checkLastSegment,
-			"ArrowFunctionExpression:exit": checkLastSegment,
-		};
-	},
-};

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

@@ -1,117 +0,0 @@
-/**
- * @fileoverview Rule for disallowing require() outside of the top-level module context
- * @author Jamund Ferguson
- * @deprecated in ESLint v7.0.0
- */
-
-"use strict";
-
-const ACCEPTABLE_PARENTS = new Set([
-	"AssignmentExpression",
-	"VariableDeclarator",
-	"MemberExpression",
-	"ExpressionStatement",
-	"CallExpression",
-	"ConditionalExpression",
-	"Program",
-	"VariableDeclaration",
-	"ChainExpression",
-]);
-
-/**
- * Finds the eslint-scope reference in the given scope.
- * @param {Object} scope The scope to search.
- * @param {ASTNode} node The identifier node.
- * @returns {Reference|null} Returns the found reference or null if none were found.
- */
-function findReference(scope, node) {
-	const references = scope.references.filter(
-		reference =>
-			reference.identifier.range[0] === node.range[0] &&
-			reference.identifier.range[1] === node.range[1],
-	);
-
-	if (references.length === 1) {
-		return references[0];
-	}
-
-	/* c8 ignore next */
-	return null;
-}
-
-/**
- * Checks if the given identifier node is shadowed in the given scope.
- * @param {Object} scope The current scope.
- * @param {ASTNode} node The identifier node to check.
- * @returns {boolean} Whether or not the name is shadowed.
- */
-function isShadowed(scope, node) {
-	const reference = findReference(scope, node);
-
-	return (
-		reference && reference.resolved && reference.resolved.defs.length > 0
-	);
-}
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Node.js rules were moved out of ESLint core.",
-			url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
-			deprecatedSince: "7.0.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"eslint-plugin-n now maintains deprecated Node.js-related rules.",
-					plugin: {
-						name: "eslint-plugin-n",
-						url: "https://github.com/eslint-community/eslint-plugin-n",
-					},
-					rule: {
-						name: "global-require",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/global-require.md",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Require `require()` calls to be placed at top-level module scope",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/global-require",
-		},
-
-		schema: [],
-		messages: {
-			unexpected: "Unexpected require().",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			CallExpression(node) {
-				const currentScope = sourceCode.getScope(node);
-
-				if (
-					node.callee.name === "require" &&
-					!isShadowed(currentScope, node.callee)
-				) {
-					const isGoodRequire = sourceCode
-						.getAncestors(node)
-						.every(parent => ACCEPTABLE_PARENTS.has(parent.type));
-
-					if (!isGoodRequire) {
-						context.report({ node, messageId: "unexpected" });
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/grouped-accessor-pairs.js

@@ -1,268 +0,0 @@
-/**
- * @fileoverview Rule to require grouped accessor pairs in object literals and classes
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/**
- * Property name if it can be computed statically, otherwise the list of the tokens of the key node.
- * @typedef {string|Token[]} Key
- */
-
-/**
- * Accessor nodes with the same key.
- * @typedef {Object} AccessorData
- * @property {Key} key Accessor's key
- * @property {ASTNode[]} getters List of getter nodes.
- * @property {ASTNode[]} setters List of setter nodes.
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not the given lists represent the equal tokens in the same order.
- * Tokens are compared by their properties, not by instance.
- * @param {Token[]} left First list of tokens.
- * @param {Token[]} right Second list of tokens.
- * @returns {boolean} `true` if the lists have same tokens.
- */
-function areEqualTokenLists(left, right) {
-	if (left.length !== right.length) {
-		return false;
-	}
-
-	for (let i = 0; i < left.length; i++) {
-		const leftToken = left[i],
-			rightToken = right[i];
-
-		if (
-			leftToken.type !== rightToken.type ||
-			leftToken.value !== rightToken.value
-		) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
- * Checks whether or not the given keys are equal.
- * @param {Key} left First key.
- * @param {Key} right Second key.
- * @returns {boolean} `true` if the keys are equal.
- */
-function areEqualKeys(left, right) {
-	if (typeof left === "string" && typeof right === "string") {
-		// Statically computed names.
-		return left === right;
-	}
-	if (Array.isArray(left) && Array.isArray(right)) {
-		// Token lists.
-		return areEqualTokenLists(left, right);
-	}
-
-	return false;
-}
-
-/**
- * Checks whether or not a given node is of an accessor kind ('get' or 'set').
- * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if the node is of an accessor kind.
- */
-function isAccessorKind(node) {
-	return node.kind === "get" || node.kind === "set";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			"anyOrder",
-			{
-				enforceForTSTypes: false,
-			},
-		],
-
-		docs: {
-			description:
-				"Require grouped accessor pairs in object literals and classes",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/grouped-accessor-pairs",
-		},
-
-		schema: [
-			{ enum: ["anyOrder", "getBeforeSet", "setBeforeGet"] },
-			{
-				type: "object",
-				properties: {
-					enforceForTSTypes: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			notGrouped:
-				"Accessor pair {{ formerName }} and {{ latterName }} should be grouped.",
-			invalidOrder:
-				"Expected {{ latterName }} to be before {{ formerName }}.",
-		},
-	},
-
-	create(context) {
-		const [order, { enforceForTSTypes }] = context.options;
-		const { sourceCode } = context;
-
-		/**
-		 * Reports the given accessor pair.
-		 * @param {string} messageId messageId to report.
-		 * @param {ASTNode} formerNode getter/setter node that is defined before `latterNode`.
-		 * @param {ASTNode} latterNode getter/setter node that is defined after `formerNode`.
-		 * @returns {void}
-		 * @private
-		 */
-		function report(messageId, formerNode, latterNode) {
-			context.report({
-				node: latterNode,
-				messageId,
-				loc: astUtils.getFunctionHeadLoc(
-					latterNode.type !== "TSMethodSignature"
-						? latterNode.value
-						: latterNode,
-					sourceCode,
-				),
-				data: {
-					formerName: astUtils.getFunctionNameWithKind(
-						formerNode.type !== "TSMethodSignature"
-							? formerNode.value
-							: formerNode,
-					),
-					latterName: astUtils.getFunctionNameWithKind(
-						latterNode.type !== "TSMethodSignature"
-							? latterNode.value
-							: latterNode,
-					),
-				},
-			});
-		}
-
-		/**
-		 * Checks accessor pairs in the given list of nodes.
-		 * @param {ASTNode[]} nodes The list to check.
-		 * @param {Function} shouldCheck – Predicate that returns `true` if the node should be checked.
-		 * @returns {void}
-		 * @private
-		 */
-		function checkList(nodes, shouldCheck) {
-			const accessors = [];
-			let found = false;
-
-			for (let i = 0; i < nodes.length; i++) {
-				const node = nodes[i];
-
-				if (shouldCheck(node) && isAccessorKind(node)) {
-					// Creates a new `AccessorData` object for the given getter or setter node.
-					const name = astUtils.getStaticPropertyName(node);
-					const key =
-						name !== null ? name : sourceCode.getTokens(node.key);
-
-					// Merges the given `AccessorData` object into the given accessors list.
-					for (let j = 0; j < accessors.length; j++) {
-						const accessor = accessors[j];
-
-						if (areEqualKeys(accessor.key, key)) {
-							accessor.getters.push(
-								...(node.kind === "get" ? [node] : []),
-							);
-							accessor.setters.push(
-								...(node.kind === "set" ? [node] : []),
-							);
-							found = true;
-							break;
-						}
-					}
-					if (!found) {
-						accessors.push({
-							key,
-							getters: node.kind === "get" ? [node] : [],
-							setters: node.kind === "set" ? [node] : [],
-						});
-					}
-					found = false;
-				}
-			}
-
-			for (const { getters, setters } of accessors) {
-				// Don't report accessor properties that have duplicate getters or setters.
-				if (getters.length === 1 && setters.length === 1) {
-					const [getter] = getters,
-						[setter] = setters,
-						getterIndex = nodes.indexOf(getter),
-						setterIndex = nodes.indexOf(setter),
-						formerNode =
-							getterIndex < setterIndex ? getter : setter,
-						latterNode =
-							getterIndex < setterIndex ? setter : getter;
-
-					if (Math.abs(getterIndex - setterIndex) > 1) {
-						report("notGrouped", formerNode, latterNode);
-					} else if (
-						(order === "getBeforeSet" &&
-							getterIndex > setterIndex) ||
-						(order === "setBeforeGet" && getterIndex < setterIndex)
-					) {
-						report("invalidOrder", formerNode, latterNode);
-					}
-				}
-			}
-		}
-
-		return {
-			ObjectExpression(node) {
-				checkList(node.properties, n => n.type === "Property");
-			},
-			ClassBody(node) {
-				checkList(
-					node.body,
-					n => n.type === "MethodDefinition" && !n.static,
-				);
-				checkList(
-					node.body,
-					n => n.type === "MethodDefinition" && n.static,
-				);
-			},
-			"TSTypeLiteral, TSInterfaceBody"(node) {
-				if (enforceForTSTypes) {
-					checkList(
-						node.type === "TSTypeLiteral"
-							? node.members
-							: node.body,
-						n => n.type === "TSMethodSignature",
-					);
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/guard-for-in.js

@@ -1,85 +0,0 @@
-/**
- * @fileoverview Rule to flag for-in loops without if statements inside
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Require `for-in` loops to include an `if` statement",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/guard-for-in",
-		},
-
-		schema: [],
-		messages: {
-			wrap: "The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.",
-		},
-	},
-
-	create(context) {
-		return {
-			ForInStatement(node) {
-				const body = node.body;
-
-				// empty statement
-				if (body.type === "EmptyStatement") {
-					return;
-				}
-
-				// if statement
-				if (body.type === "IfStatement") {
-					return;
-				}
-
-				// empty block
-				if (body.type === "BlockStatement" && body.body.length === 0) {
-					return;
-				}
-
-				// block with just if statement
-				if (
-					body.type === "BlockStatement" &&
-					body.body.length === 1 &&
-					body.body[0].type === "IfStatement"
-				) {
-					return;
-				}
-
-				// block that starts with if statement
-				if (
-					body.type === "BlockStatement" &&
-					body.body.length >= 1 &&
-					body.body[0].type === "IfStatement"
-				) {
-					const i = body.body[0];
-
-					// ... whose consequent is a continue
-					if (i.consequent.type === "ContinueStatement") {
-						return;
-					}
-
-					// ... whose consequent is a block that contains only a continue
-					if (
-						i.consequent.type === "BlockStatement" &&
-						i.consequent.body.length === 1 &&
-						i.consequent.body[0].type === "ContinueStatement"
-					) {
-						return;
-					}
-				}
-
-				context.report({ node, messageId: "wrap" });
-			},
-		};
-	},
-};