bahlint 28.58.6934-dev-001

package/lib/rules/valid-typeof.js

@@ -0,0 +1,171 @@
+/**
+ * @fileoverview Ensures that the results of typeof are compared against a valid string
+ * @author Ian Christian Myers
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: [
+			{
+				requireStringLiterals: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Enforce comparing `typeof` expressions against valid strings",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/valid-typeof",
+		},
+
+		hasSuggestions: true,
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					requireStringLiterals: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		messages: {
+			invalidValue: "Invalid typeof comparison value.",
+			notString: "Typeof comparisons should be to string literals.",
+			suggestString: 'Use `"{{type}}"` instead of `{{type}}`.',
+		},
+	},
+
+	create(context) {
+		const VALID_TYPES = new Set([
+				"symbol",
+				"undefined",
+				"object",
+				"boolean",
+				"number",
+				"string",
+				"function",
+				"bigint",
+			]),
+			OPERATORS = new Set(["==", "===", "!=", "!=="]);
+		const sourceCode = context.sourceCode;
+		const [{ requireStringLiterals }] = context.options;
+
+		let globalScope;
+
+		/**
+		 * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+		 * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+		 * @param {ASTNode} node `Identifier` node to check.
+		 * @returns {boolean} `true` if the node is a reference to a global variable.
+		 */
+		function isReferenceToGlobalVariable(node) {
+			const variable = globalScope.set.get(node.name);
+
+			return (
+				variable &&
+				variable.defs.length === 0 &&
+				variable.references.some(ref => ref.identifier === node)
+			);
+		}
+
+		/**
+		 * Determines whether a node is a typeof expression.
+		 * @param {ASTNode} node The node
+		 * @returns {boolean} `true` if the node is a typeof expression
+		 */
+		function isTypeofExpression(node) {
+			return (
+				node.type === "UnaryExpression" && node.operator === "typeof"
+			);
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			Program(node) {
+				globalScope = sourceCode.getScope(node);
+			},
+
+			UnaryExpression(node) {
+				if (isTypeofExpression(node)) {
+					const { parent } = node;
+
+					if (
+						parent.type === "BinaryExpression" &&
+						OPERATORS.has(parent.operator)
+					) {
+						const sibling =
+							parent.left === node ? parent.right : parent.left;
+
+						if (
+							sibling.type === "Literal" ||
+							astUtils.isStaticTemplateLiteral(sibling)
+						) {
+							const value =
+								sibling.type === "Literal"
+									? sibling.value
+									: sibling.quasis[0].value.cooked;
+
+							if (!VALID_TYPES.has(value)) {
+								context.report({
+									node: sibling,
+									messageId: "invalidValue",
+								});
+							}
+						} else if (
+							sibling.type === "Identifier" &&
+							sibling.name === "undefined" &&
+							isReferenceToGlobalVariable(sibling)
+						) {
+							context.report({
+								node: sibling,
+								messageId: requireStringLiterals
+									? "notString"
+									: "invalidValue",
+								suggest: [
+									{
+										messageId: "suggestString",
+										data: { type: "undefined" },
+										fix(fixer) {
+											return fixer.replaceText(
+												sibling,
+												'"undefined"',
+											);
+										},
+									},
+								],
+							});
+						} else if (
+							requireStringLiterals &&
+							!isTypeofExpression(sibling)
+						) {
+							context.report({
+								node: sibling,
+								messageId: "notString",
+							});
+						}
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/vars-on-top.js

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview Rule to enforce var declarations are only at the top of a function.
+ * @author Danny Fritz
+ * @author Gyandeep Singh
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Require `var` declarations be placed at the top of their containing scope",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/vars-on-top",
+		},
+
+		schema: [],
+		messages: {
+			top: "All 'var' declarations must be at the top of the function scope.",
+		},
+	},
+
+	create(context) {
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Has AST suggesting a directive.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node structurally represents a directive
+		 */
+		function looksLikeDirective(node) {
+			return (
+				node.type === "ExpressionStatement" &&
+				node.expression.type === "Literal" &&
+				typeof node.expression.value === "string"
+			);
+		}
+
+		/**
+		 * Check to see if its a ES6 import declaration
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node represents a import declaration
+		 */
+		function looksLikeImport(node) {
+			return (
+				node.type === "ImportDeclaration" ||
+				node.type === "ImportSpecifier" ||
+				node.type === "ImportDefaultSpecifier" ||
+				node.type === "ImportNamespaceSpecifier"
+			);
+		}
+
+		/**
+		 * Checks whether a given node is a variable declaration or not.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} `true` if the node is a variable declaration.
+		 */
+		function isVariableDeclaration(node) {
+			return (
+				node.type === "VariableDeclaration" ||
+				(node.type === "ExportNamedDeclaration" &&
+					node.declaration &&
+					node.declaration.type === "VariableDeclaration")
+			);
+		}
+
+		/**
+		 * Checks whether this variable is on top of the block body
+		 * @param {ASTNode} node The node to check
+		 * @param {ASTNode[]} statements collection of ASTNodes for the parent node block
+		 * @returns {boolean} True if var is on top otherwise false
+		 */
+		function isVarOnTop(node, statements) {
+			const l = statements.length;
+			let i = 0;
+
+			// Skip over directives and imports. Static blocks don't have either.
+			if (node.parent.type !== "StaticBlock") {
+				for (; i < l; ++i) {
+					if (
+						!looksLikeDirective(statements[i]) &&
+						!looksLikeImport(statements[i])
+					) {
+						break;
+					}
+				}
+			}
+
+			for (; i < l; ++i) {
+				if (!isVariableDeclaration(statements[i])) {
+					return false;
+				}
+				if (statements[i] === node) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/**
+		 * Checks whether variable is on top at the global level
+		 * @param {ASTNode} node The node to check
+		 * @param {ASTNode} parent Parent of the node
+		 * @returns {void}
+		 */
+		function globalVarCheck(node, parent) {
+			if (!isVarOnTop(node, parent.body)) {
+				context.report({ node, messageId: "top" });
+			}
+		}
+
+		/**
+		 * Checks whether variable is on top at functional block scope level
+		 * @param {ASTNode} node The node to check
+		 * @returns {void}
+		 */
+		function blockScopeVarCheck(node) {
+			const { parent } = node;
+
+			if (
+				parent.type === "BlockStatement" &&
+				/Function/u.test(parent.parent.type) &&
+				isVarOnTop(node, parent.body)
+			) {
+				return;
+			}
+
+			if (
+				parent.type === "StaticBlock" &&
+				isVarOnTop(node, parent.body)
+			) {
+				return;
+			}
+
+			context.report({ node, messageId: "top" });
+		}
+
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
+
+		return {
+			"VariableDeclaration[kind='var']"(node) {
+				if (node.parent.type === "ExportNamedDeclaration") {
+					globalVarCheck(node.parent, node.parent.parent);
+				} else if (node.parent.type === "Program") {
+					globalVarCheck(node, node.parent);
+				} else {
+					blockScopeVarCheck(node);
+				}
+			},
+		};
+	},
+};

package/lib/rules/wrap-iife.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview Rule to flag when IIFE is not wrapped in parens
+ * @author Ilya Volodin
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const eslintUtils = require("@eslint-community/eslint-utils");
+
+//----------------------------------------------------------------------
+// Helpers
+//----------------------------------------------------------------------
+
+/**
+ * Check if the given node is callee of a `NewExpression` node
+ * @param {ASTNode} node node to check
+ * @returns {boolean} True if the node is callee of a `NewExpression` node
+ * @private
+ */
+function isCalleeOfNewExpression(node) {
+	const maybeCallee =
+		node.parent.type === "ChainExpression" ? node.parent : node;
+
+	return (
+		maybeCallee.parent.type === "NewExpression" &&
+		maybeCallee.parent.callee === maybeCallee
+	);
+}
+
+//------------------------------------------------------------------------------
+// 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: "wrap-iife",
+						url: "https://eslint.style/rules/wrap-iife",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description:
+				"Require parentheses around immediate `function` invocations",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/wrap-iife",
+		},
+
+		schema: [
+			{
+				enum: ["outside", "inside", "any"],
+			},
+			{
+				type: "object",
+				properties: {
+					functionPrototypeMethods: {
+						type: "boolean",
+						default: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "code",
+		messages: {
+			wrapInvocation:
+				"Wrap an immediate function invocation in parentheses.",
+			wrapExpression: "Wrap only the function expression in parens.",
+			moveInvocation:
+				"Move the invocation into the parens that contain the function.",
+		},
+	},
+
+	create(context) {
+		const style = context.options[0] || "outside";
+		const includeFunctionPrototypeMethods =
+			context.options[1] && context.options[1].functionPrototypeMethods;
+
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()
+		 * @param {ASTNode} node node to evaluate
+		 * @returns {boolean} True if it is wrapped in any parens
+		 * @private
+		 */
+		function isWrappedInAnyParens(node) {
+			return astUtils.isParenthesised(sourceCode, node);
+		}
+
+		/**
+		 * Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count
+		 * @param {ASTNode} node node to evaluate
+		 * @returns {boolean} True if it is wrapped in grouping parens
+		 * @private
+		 */
+		function isWrappedInGroupingParens(node) {
+			return eslintUtils.isParenthesized(1, node, sourceCode);
+		}
+
+		/**
+		 * Get the function node from an IIFE
+		 * @param {ASTNode} node node to evaluate
+		 * @returns {ASTNode} node that is the function expression of the given IIFE, or null if none exist
+		 */
+		function getFunctionNodeFromIIFE(node) {
+			const callee = astUtils.skipChainExpression(node.callee);
+
+			if (callee.type === "FunctionExpression") {
+				return callee;
+			}
+
+			if (
+				includeFunctionPrototypeMethods &&
+				callee.type === "MemberExpression" &&
+				callee.object.type === "FunctionExpression" &&
+				(astUtils.getStaticPropertyName(callee) === "call" ||
+					astUtils.getStaticPropertyName(callee) === "apply")
+			) {
+				return callee.object;
+			}
+
+			return null;
+		}
+
+		return {
+			CallExpression(node) {
+				const innerNode = getFunctionNodeFromIIFE(node);
+
+				if (!innerNode) {
+					return;
+				}
+
+				const isCallExpressionWrapped = isWrappedInAnyParens(node),
+					isFunctionExpressionWrapped =
+						isWrappedInAnyParens(innerNode);
+
+				if (!isCallExpressionWrapped && !isFunctionExpressionWrapped) {
+					context.report({
+						node,
+						messageId: "wrapInvocation",
+						fix(fixer) {
+							const nodeToSurround =
+								style === "inside" ? innerNode : node;
+
+							return fixer.replaceText(
+								nodeToSurround,
+								`(${sourceCode.getText(nodeToSurround)})`,
+							);
+						},
+					});
+				} else if (style === "inside" && !isFunctionExpressionWrapped) {
+					context.report({
+						node,
+						messageId: "wrapExpression",
+						fix(fixer) {
+							// The outer call expression will always be wrapped at this point.
+
+							if (
+								isWrappedInGroupingParens(node) &&
+								!isCalleeOfNewExpression(node)
+							) {
+								/*
+								 * Parenthesize the function expression and remove unnecessary grouping parens around the call expression.
+								 * Replace the range between the end of the function expression and the end of the call expression.
+								 * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
+								 */
+
+								const parenAfter =
+									sourceCode.getTokenAfter(node);
+
+								return fixer.replaceTextRange(
+									[innerNode.range[1], parenAfter.range[1]],
+									`)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`,
+								);
+							}
+
+							/*
+							 * Call expression is wrapped in mandatory parens such as if(), or in necessary grouping parens.
+							 * These parens cannot be removed, so just parenthesize the function expression.
+							 */
+
+							return fixer.replaceText(
+								innerNode,
+								`(${sourceCode.getText(innerNode)})`,
+							);
+						},
+					});
+				} else if (style === "outside" && !isCallExpressionWrapped) {
+					context.report({
+						node,
+						messageId: "moveInvocation",
+						fix(fixer) {
+							/*
+							 * The inner function expression will always be wrapped at this point.
+							 * It's only necessary to replace the range between the end of the function expression
+							 * and the call expression. For example, in `(function(foo) {})(bar)`, the range `)(bar)`
+							 * should get replaced with `(bar))`.
+							 */
+							const parenAfter =
+								sourceCode.getTokenAfter(innerNode);
+
+							return fixer.replaceTextRange(
+								[parenAfter.range[0], node.range[1]],
+								`${sourceCode.getText().slice(parenAfter.range[1], node.range[1])})`,
+							);
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/wrap-regex.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Rule to flag when regex literals are not wrapped in parens
+ * @author Matt DuVall <http://www.mattduvall.com>
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// 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: "wrap-regex",
+						url: "https://eslint.style/rules/wrap-regex",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Require parenthesis around regex literals",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/wrap-regex",
+		},
+
+		schema: [],
+		fixable: "code",
+
+		messages: {
+			requireParens:
+				"Wrap the regexp literal in parens to disambiguate the slash.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			Literal(node) {
+				const token = sourceCode.getFirstToken(node),
+					nodeType = token.type;
+
+				if (nodeType === "RegularExpression") {
+					const beforeToken = sourceCode.getTokenBefore(node);
+					const afterToken = sourceCode.getTokenAfter(node);
+					const { parent } = node;
+
+					if (
+						parent.type === "MemberExpression" &&
+						parent.object === node &&
+						!(
+							beforeToken &&
+							beforeToken.value === "(" &&
+							afterToken &&
+							afterToken.value === ")"
+						)
+					) {
+						context.report({
+							node,
+							messageId: "requireParens",
+							fix: fixer =>
+								fixer.replaceText(
+									node,
+									`(${sourceCode.getText(node)})`,
+								),
+						});
+					}
+				}
+			},
+		};
+	},
+};