@alexlit/lint-kit 166.1.0 → 167.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-param-reassign.js

@@ -1,248 +0,0 @@
-/**
- * @fileoverview Disallow reassigning function parameters.
- * @author Nat Burns
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const stopNodePattern =
-	/(?:Statement|Declaration|Function(?:Expression)?|Program)$/u;
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow reassigning function parameters",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-param-reassign",
-		},
-
-		schema: [
-			{
-				oneOf: [
-					{
-						type: "object",
-						properties: {
-							props: {
-								enum: [false],
-							},
-						},
-						additionalProperties: false,
-					},
-					{
-						type: "object",
-						properties: {
-							props: {
-								enum: [true],
-							},
-							ignorePropertyModificationsFor: {
-								type: "array",
-								items: {
-									type: "string",
-								},
-								uniqueItems: true,
-							},
-							ignorePropertyModificationsForRegex: {
-								type: "array",
-								items: {
-									type: "string",
-								},
-								uniqueItems: true,
-							},
-						},
-						additionalProperties: false,
-					},
-				],
-			},
-		],
-
-		messages: {
-			assignmentToFunctionParam:
-				"Assignment to function parameter '{{name}}'.",
-			assignmentToFunctionParamProp:
-				"Assignment to property of function parameter '{{name}}'.",
-		},
-	},
-
-	create(context) {
-		const props = context.options[0] && context.options[0].props;
-		const ignoredPropertyAssignmentsFor =
-			(context.options[0] &&
-				context.options[0].ignorePropertyModificationsFor) ||
-			[];
-		const ignoredPropertyAssignmentsForRegex =
-			(context.options[0] &&
-				context.options[0].ignorePropertyModificationsForRegex) ||
-			[];
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Checks whether or not the reference modifies properties of its variable.
-		 * @param {Reference} reference A reference to check.
-		 * @returns {boolean} Whether or not the reference modifies properties of its variable.
-		 */
-		function isModifyingProp(reference) {
-			let node = reference.identifier;
-			let parent = node.parent;
-
-			while (
-				parent &&
-				(!stopNodePattern.test(parent.type) ||
-					parent.type === "ForInStatement" ||
-					parent.type === "ForOfStatement")
-			) {
-				switch (parent.type) {
-					// e.g. foo.a = 0;
-					case "AssignmentExpression":
-						return parent.left === node;
-
-					// e.g. ++foo.a;
-					case "UpdateExpression":
-						return true;
-
-					// e.g. delete foo.a;
-					case "UnaryExpression":
-						if (parent.operator === "delete") {
-							return true;
-						}
-						break;
-
-					// e.g. for (foo.a in b) {}
-					case "ForInStatement":
-					case "ForOfStatement":
-						if (parent.left === node) {
-							return true;
-						}
-
-						// this is a stop node for parent.right and parent.body
-						return false;
-
-					// EXCLUDES: e.g. cache.get(foo.a).b = 0;
-					case "CallExpression":
-						if (parent.callee !== node) {
-							return false;
-						}
-						break;
-
-					// EXCLUDES: e.g. cache[foo.a] = 0;
-					case "MemberExpression":
-						if (parent.property === node) {
-							return false;
-						}
-						break;
-
-					// EXCLUDES: e.g. ({ [foo]: a }) = bar;
-					case "Property":
-						if (parent.key === node) {
-							return false;
-						}
-
-						break;
-
-					// EXCLUDES: e.g. (foo ? a : b).c = bar;
-					case "ConditionalExpression":
-						if (parent.test === node) {
-							return false;
-						}
-
-						break;
-
-					// no default
-				}
-
-				node = parent;
-				parent = node.parent;
-			}
-
-			return false;
-		}
-
-		/**
-		 * Tests that an identifier name matches any of the ignored property assignments.
-		 * First we test strings in ignoredPropertyAssignmentsFor.
-		 * Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings.
-		 * @param {string} identifierName A string that describes the name of an identifier to
-		 * ignore property assignments for.
-		 * @returns {boolean} Whether the string matches an ignored property assignment regular expression or not.
-		 */
-		function isIgnoredPropertyAssignment(identifierName) {
-			return (
-				ignoredPropertyAssignmentsFor.includes(identifierName) ||
-				ignoredPropertyAssignmentsForRegex.some(ignored =>
-					new RegExp(ignored, "u").test(identifierName),
-				)
-			);
-		}
-
-		/**
-		 * Reports a reference if is non initializer and writable.
-		 * @param {Reference} reference A reference to check.
-		 * @param {number} index The index of the reference in the references.
-		 * @param {Reference[]} references The array that the reference belongs to.
-		 * @returns {void}
-		 */
-		function checkReference(reference, index, references) {
-			const identifier = reference.identifier;
-
-			if (
-				identifier &&
-				!reference.init &&
-				/*
-				 * Destructuring assignments can have multiple default value,
-				 * so possibly there are multiple writeable references for the same identifier.
-				 */
-				(index === 0 || references[index - 1].identifier !== identifier)
-			) {
-				if (reference.isWrite()) {
-					context.report({
-						node: identifier,
-						messageId: "assignmentToFunctionParam",
-						data: { name: identifier.name },
-					});
-				} else if (
-					props &&
-					isModifyingProp(reference) &&
-					!isIgnoredPropertyAssignment(identifier.name)
-				) {
-					context.report({
-						node: identifier,
-						messageId: "assignmentToFunctionParamProp",
-						data: { name: identifier.name },
-					});
-				}
-			}
-		}
-
-		/**
-		 * Finds and reports references that are non initializer and writable.
-		 * @param {Variable} variable A variable to check.
-		 * @returns {void}
-		 */
-		function checkVariable(variable) {
-			if (variable.defs[0].type === "Parameter") {
-				variable.references.forEach(checkReference);
-			}
-		}
-
-		/**
-		 * Checks parameters of a given function node.
-		 * @param {ASTNode} node A function node to check.
-		 * @returns {void}
-		 */
-		function checkForFunction(node) {
-			sourceCode.getDeclaredVariables(node).forEach(checkVariable);
-		}
-
-		return {
-			// `:exit` is needed for the `node.parent` property of identifier nodes.
-			"FunctionDeclaration:exit": checkForFunction,
-			"FunctionExpression:exit": checkForFunction,
-			"ArrowFunctionExpression:exit": checkForFunction,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-path-concat.js

@@ -1,79 +0,0 @@
-/**
- * @fileoverview Disallow string concatenation when using __dirname and __filename
- * @author Nicholas C. Zakas
- * @deprecated in ESLint v7.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @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: "no-path-concat",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-path-concat.md",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow string concatenation with `__dirname` and `__filename`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-path-concat",
-		},
-
-		schema: [],
-
-		messages: {
-			usePathFunctions:
-				"Use path.join() or path.resolve() instead of + to create paths.",
-		},
-	},
-
-	create(context) {
-		const MATCHER = /^__(?:dir|file)name$/u;
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			BinaryExpression(node) {
-				const left = node.left,
-					right = node.right;
-
-				if (
-					node.operator === "+" &&
-					((left.type === "Identifier" && MATCHER.test(left.name)) ||
-						(right.type === "Identifier" &&
-							MATCHER.test(right.name)))
-				) {
-					context.report({
-						node,
-						messageId: "usePathFunctions",
-					});
-				}
-			},
-		};
-	},
-};

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

@@ -1,102 +0,0 @@
-/**
- * @fileoverview Rule to flag use of unary increment and decrement operators.
- * @author Ian Christian Myers
- * @author Brody McKee (github.com/mrmckeb)
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines whether the given node is the update node of a `ForStatement`.
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is `ForStatement` update.
- */
-function isForStatementUpdate(node) {
-	const parent = node.parent;
-
-	return parent.type === "ForStatement" && parent.update === node;
-}
-
-/**
- * Determines whether the given node is considered to be a for loop "afterthought" by the logic of this rule.
- * In particular, it returns `true` if the given node is either:
- *   - The update node of a `ForStatement`: for (;; i++) {}
- *   - An operand of a sequence expression that is the update node: for (;; foo(), i++) {}
- *   - An operand of a sequence expression that is child of another sequence expression, etc.,
- *     up to the sequence expression that is the update node: for (;; foo(), (bar(), (baz(), i++))) {}
- * @param {ASTNode} node The node to check.
- * @returns {boolean} `true` if the node is a for loop afterthought.
- */
-function isForLoopAfterthought(node) {
-	const parent = node.parent;
-
-	if (parent.type === "SequenceExpression") {
-		return isForLoopAfterthought(parent);
-	}
-
-	return isForStatementUpdate(node);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				allowForLoopAfterthoughts: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow the unary operators `++` and `--`",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-plusplus",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowForLoopAfterthoughts: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedUnaryOp: "Unary operator '{{operator}}' used.",
-		},
-	},
-
-	create(context) {
-		const [{ allowForLoopAfterthoughts }] = context.options;
-
-		return {
-			UpdateExpression(node) {
-				if (allowForLoopAfterthoughts && isForLoopAfterthought(node)) {
-					return;
-				}
-
-				context.report({
-					node,
-					messageId: "unexpectedUnaryOp",
-					data: {
-						operator: node.operator,
-					},
-				});
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-process-env.js

@@ -1,68 +0,0 @@
-/**
- * @fileoverview Disallow the use of process.env()
- * @author Vignesh Anand
- * @deprecated in ESLint v7.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @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: "no-process-env",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-env.md",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow the use of `process.env`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-process-env",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpectedProcessEnv: "Unexpected use of process.env.",
-		},
-	},
-
-	create(context) {
-		return {
-			MemberExpression(node) {
-				const objectName = node.object.name,
-					propertyName = node.property.name;
-
-				if (
-					objectName === "process" &&
-					!node.computed &&
-					propertyName &&
-					propertyName === "env"
-				) {
-					context.report({ node, messageId: "unexpectedProcessEnv" });
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-process-exit.js

@@ -1,67 +0,0 @@
-/**
- * @fileoverview Disallow the use of process.exit()
- * @author Nicholas C. Zakas
- * @deprecated in ESLint v7.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @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: "no-process-exit",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-exit.md",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow the use of `process.exit()`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-process-exit",
-		},
-
-		schema: [],
-
-		messages: {
-			noProcessExit: "Don't use process.exit(); throw an error instead.",
-		},
-	},
-
-	create(context) {
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			"CallExpression > MemberExpression.callee[object.name = 'process'][property.name = 'exit']"(
-				node,
-			) {
-				context.report({
-					node: node.parent,
-					messageId: "noProcessExit",
-				});
-			},
-		};
-	},
-};