@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-dupe-class-members.js

@@ -1,117 +0,0 @@
-/**
- * @fileoverview A rule to disallow duplicate name in class members.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
-
-		docs: {
-			description: "Disallow duplicate class members",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-dupe-class-members",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Duplicate name '{{name}}'.",
-		},
-	},
-
-	create(context) {
-		let stack = [];
-
-		/**
-		 * Gets state of a given member name.
-		 * @param {string} name A name of a member.
-		 * @param {boolean} isStatic A flag which specifies that is a static member.
-		 * @returns {Object} A state of a given member name.
-		 *   - retv.init {boolean} A flag which shows the name is declared as normal member.
-		 *   - retv.get {boolean} A flag which shows the name is declared as getter.
-		 *   - retv.set {boolean} A flag which shows the name is declared as setter.
-		 */
-		function getState(name, isStatic) {
-			const stateMap = stack.at(-1);
-			const key = `$${name}`; // to avoid "__proto__".
-
-			if (!stateMap[key]) {
-				stateMap[key] = {
-					nonStatic: { init: false, get: false, set: false },
-					static: { init: false, get: false, set: false },
-				};
-			}
-
-			return stateMap[key][isStatic ? "static" : "nonStatic"];
-		}
-
-		return {
-			// Initializes the stack of state of member declarations.
-			Program() {
-				stack = [];
-			},
-
-			// Initializes state of member declarations for the class.
-			ClassBody() {
-				stack.push(Object.create(null));
-			},
-
-			// Disposes the state for the class.
-			"ClassBody:exit"() {
-				stack.pop();
-			},
-
-			// Reports the node if its name has been declared already.
-			"MethodDefinition, PropertyDefinition"(node) {
-				if (
-					node.value &&
-					node.value.type === "TSEmptyBodyFunctionExpression"
-				) {
-					return;
-				}
-
-				const name = astUtils.getStaticPropertyName(node);
-				const kind =
-					node.type === "MethodDefinition" ? node.kind : "field";
-
-				if (name === null || kind === "constructor") {
-					return;
-				}
-
-				const state = getState(name, node.static);
-				let isDuplicate;
-
-				if (kind === "get") {
-					isDuplicate = state.init || state.get;
-					state.get = true;
-				} else if (kind === "set") {
-					isDuplicate = state.init || state.set;
-					state.set = true;
-				} else {
-					isDuplicate = state.init || state.get || state.set;
-					state.init = true;
-				}
-
-				if (isDuplicate) {
-					context.report({
-						loc: node.key.loc,
-						messageId: "unexpected",
-						data: { name },
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-dupe-else-if.js

@@ -1,145 +0,0 @@
-/**
- * @fileoverview Rule to disallow duplicate conditions in if-else-if chains
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines whether the first given array is a subset of the second given array.
- * @param {Function} comparator A function to compare two elements, should return `true` if they are equal.
- * @param {Array} arrA The array to compare from.
- * @param {Array} arrB The array to compare against.
- * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.
- */
-function isSubsetByComparator(comparator, arrA, arrB) {
-	return arrA.every(a => arrB.some(b => comparator(a, b)));
-}
-
-/**
- * Splits the given node by the given logical operator.
- * @param {string} operator Logical operator `||` or `&&`.
- * @param {ASTNode} node The node to split.
- * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.
- */
-function splitByLogicalOperator(operator, node) {
-	if (node.type === "LogicalExpression" && node.operator === operator) {
-		return [
-			...splitByLogicalOperator(operator, node.left),
-			...splitByLogicalOperator(operator, node.right),
-		];
-	}
-	return [node];
-}
-
-const splitByOr = splitByLogicalOperator.bind(null, "||");
-const splitByAnd = splitByLogicalOperator.bind(null, "&&");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow duplicate conditions in if-else-if chains",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-dupe-else-if",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected:
-				"This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes
-		 * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.
-		 * @param {ASTNode} a First node.
-		 * @param {ASTNode} b Second node.
-		 * @returns {boolean} `true` if the nodes are considered to be equal.
-		 */
-		function equal(a, b) {
-			if (a.type !== b.type) {
-				return false;
-			}
-
-			if (
-				a.type === "LogicalExpression" &&
-				(a.operator === "||" || a.operator === "&&") &&
-				a.operator === b.operator
-			) {
-				return (
-					(equal(a.left, b.left) && equal(a.right, b.right)) ||
-					(equal(a.left, b.right) && equal(a.right, b.left))
-				);
-			}
-
-			return astUtils.equalTokens(a, b, sourceCode);
-		}
-
-		const isSubset = isSubsetByComparator.bind(null, equal);
-
-		return {
-			IfStatement(node) {
-				const test = node.test,
-					conditionsToCheck =
-						test.type === "LogicalExpression" &&
-						test.operator === "&&"
-							? [test, ...splitByAnd(test)]
-							: [test];
-				let current = node,
-					listToCheck = conditionsToCheck.map(c =>
-						splitByOr(c).map(splitByAnd),
-					);
-
-				while (
-					current.parent &&
-					current.parent.type === "IfStatement" &&
-					current.parent.alternate === current
-				) {
-					current = current.parent;
-
-					const currentOrOperands = splitByOr(current.test).map(
-						splitByAnd,
-					);
-
-					listToCheck = listToCheck.map(orOperands =>
-						orOperands.filter(
-							orOperand =>
-								!currentOrOperands.some(currentOrOperand =>
-									isSubset(currentOrOperand, orOperand),
-								),
-						),
-					);
-
-					if (
-						listToCheck.some(orOperands => orOperands.length === 0)
-					) {
-						context.report({ node: test, messageId: "unexpected" });
-						break;
-					}
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-dupe-keys.js

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Rule to flag use of duplicate keys in an object.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const GET_KIND = /^(?:init|get)$/u;
-const SET_KIND = /^(?:init|set)$/u;
-
-/**
- * The class which stores properties' information of an object.
- */
-class ObjectInfo {
-	/**
-	 * @param {ObjectInfo|null} upper The information of the outer object.
-	 * @param {ASTNode} node The ObjectExpression node of this information.
-	 */
-	constructor(upper, node) {
-		this.upper = upper;
-		this.node = node;
-		this.properties = new Map();
-	}
-
-	/**
-	 * Gets the information of the given Property node.
-	 * @param {ASTNode} node The Property node to get.
-	 * @returns {{get: boolean, set: boolean}} The information of the property.
-	 */
-	getPropertyInfo(node) {
-		const name = astUtils.getStaticPropertyName(node);
-
-		if (!this.properties.has(name)) {
-			this.properties.set(name, { get: false, set: false });
-		}
-		return this.properties.get(name);
-	}
-
-	/**
-	 * Checks whether the given property has been defined already or not.
-	 * @param {ASTNode} node The Property node to check.
-	 * @returns {boolean} `true` if the property has been defined.
-	 */
-	isPropertyDefined(node) {
-		const entry = this.getPropertyInfo(node);
-
-		return (
-			(GET_KIND.test(node.kind) && entry.get) ||
-			(SET_KIND.test(node.kind) && entry.set)
-		);
-	}
-
-	/**
-	 * Defines the given property.
-	 * @param {ASTNode} node The Property node to define.
-	 * @returns {void}
-	 */
-	defineProperty(node) {
-		const entry = this.getPropertyInfo(node);
-
-		if (GET_KIND.test(node.kind)) {
-			entry.get = true;
-		}
-		if (SET_KIND.test(node.kind)) {
-			entry.set = true;
-		}
-	}
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow duplicate keys in object literals",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-dupe-keys",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Duplicate key '{{name}}'.",
-		},
-	},
-
-	create(context) {
-		let info = null;
-
-		return {
-			ObjectExpression(node) {
-				info = new ObjectInfo(info, node);
-			},
-			"ObjectExpression:exit"() {
-				info = info.upper;
-			},
-
-			Property(node) {
-				const name = astUtils.getStaticPropertyName(node);
-
-				// Skip destructuring.
-				if (node.parent.type !== "ObjectExpression") {
-					return;
-				}
-
-				// Skip if the name is not static.
-				if (name === null) {
-					return;
-				}
-
-				/*
-				 * Skip if the property node is a proto setter.
-				 * Proto setter is a special syntax that sets
-				 * object's prototype instead of creating a property.
-				 * It can be in one of the following forms:
-				 *
-				 *    __proto__: <expression>
-				 *    '__proto__': <expression>
-				 *    "__proto__": <expression>
-				 *
-				 * Duplicate proto setters produce parsing errors,
-				 * so we can just skip them to not interfere with
-				 * regular properties named "__proto__".
-				 */
-				if (
-					name === "__proto__" &&
-					node.kind === "init" &&
-					!node.computed &&
-					!node.shorthand &&
-					!node.method
-				) {
-					return;
-				}
-
-				// Reports if the name is defined already.
-				if (info.isPropertyDefined(node)) {
-					context.report({
-						node: info.node,
-						loc: node.key.loc,
-						messageId: "unexpected",
-						data: { name },
-					});
-				}
-
-				// Update info.
-				info.defineProperty(node);
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-duplicate-case.js

@@ -1,78 +0,0 @@
-/**
- * @fileoverview Rule to disallow a duplicate case label.
- * @author Dieter Oberkofler
- * @author Burak Yigit Kaya
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Disallow duplicate case labels",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-duplicate-case",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpected: "Duplicate case label.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Determines whether the two given nodes are considered to be equal.
-		 * @param {ASTNode} a First node.
-		 * @param {ASTNode} b Second node.
-		 * @returns {boolean} `true` if the nodes are considered to be equal.
-		 */
-		function equal(a, b) {
-			if (a.type !== b.type) {
-				return false;
-			}
-
-			return astUtils.equalTokens(a, b, sourceCode);
-		}
-		return {
-			SwitchStatement(node) {
-				const previousTests = [];
-
-				for (const switchCase of node.cases) {
-					if (switchCase.test) {
-						const test = switchCase.test;
-
-						if (
-							previousTests.some(previousTest =>
-								equal(previousTest, test),
-							)
-						) {
-							context.report({
-								node: switchCase,
-								messageId: "unexpected",
-							});
-						} else {
-							previousTests.push(test);
-						}
-					}
-				}
-			},
-		};
-	},
-};