eslint-plugin-absolute 0.1.6 → 0.2.1

package/src/rules/min-var-length.js

@@ -1,300 +0,0 @@
-/**
- * @fileoverview Disallow variable names shorter than a specified minimum length unless an outer variable
- * with a corresponding longer name exists, with an option to exempt specific variable names.
- *
- * Options:
- *  - minLength: a number specifying the minimum allowed length for variable names. Defaults to 1.
- *  - allowedVars: an array of variable names that are exempt from the minimum length rule.
- *    Each allowed variable name should have a length of at least 1 and at most minLength.
- *
- * This rule checks variable declarations, function parameters, catch clauses,
- * and destructuring patterns. It uses the ESLint v9 APIs (via the scopeManager on the
- * SourceCode object) and a custom helper to get ancestors.
- */
-export default {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Disallow variable names shorter than the configured minimum length unless an outer variable with a longer name starting with the same characters exists. You can exempt specific variable names using the allowedVars option.",
-			recommended: false
-		},
-		schema: [
-			{
-				type: "object",
-				properties: {
-					minLength: {
-						type: "number",
-						default: 1
-					},
-					allowedVars: {
-						type: "array",
-						items: {
-							type: "string",
-							minLength: 1
-							// Note: The maxLength for each string should be at most the configured minLength.
-						},
-						default: []
-					}
-				},
-				additionalProperties: false
-			}
-		],
-		messages: {
-			variableNameTooShort:
-				"Variable '{{name}}' is too short. Minimum allowed length is {{minLength}} characters unless an outer variable with a longer name starting with '{{name}}' exists."
-		}
-	},
-
-	create(context) {
-		const sourceCode = context.getSourceCode();
-		const options = context.options[0] || {};
-		const minLength =
-			typeof options.minLength === "number" ? options.minLength : 1;
-		const allowedVars = options.allowedVars || [];
-
-		// Helper: walk up the node.parent chain to get ancestors.
-		function getAncestors(node) {
-			const ancestors = [];
-			let current = node.parent;
-			while (current) {
-				ancestors.push(current);
-				current = current.parent;
-			}
-			return ancestors;
-		}
-
-		// Helper: retrieve the scope for a given node using the scopeManager.
-		function getScope(node) {
-			return (
-				sourceCode.scopeManager.acquire(node) ||
-				sourceCode.scopeManager.globalScope
-			);
-		}
-
-		// Fallback: get declared variable names in the nearest BlockStatement.
-		function getVariablesInNearestBlock(node) {
-			let current = node.parent;
-			while (current && current.type !== "BlockStatement") {
-				current = current.parent;
-			}
-			const names = [];
-			if (current && Array.isArray(current.body)) {
-				for (const stmt of current.body) {
-					if (stmt.type === "VariableDeclaration") {
-						for (const decl of stmt.declarations) {
-							if (decl.id && decl.id.type === "Identifier") {
-								names.push(decl.id.name);
-							}
-						}
-					}
-				}
-			}
-			return names;
-		}
-
-		/**
-		 * Recursively extract identifier names from a pattern (for destructuring)
-		 * @param {ASTNode} pattern The pattern node.
-		 * @param {string[]} identifiers Array to accumulate names.
-		 * @returns {string[]} Array of identifier names.
-		 */
-		function extractIdentifiersFromPattern(pattern, identifiers = []) {
-			if (!pattern) return identifiers;
-			switch (pattern.type) {
-				case "Identifier":
-					identifiers.push(pattern.name);
-					break;
-				case "ObjectPattern":
-					for (const prop of pattern.properties) {
-						if (prop.type === "Property") {
-							extractIdentifiersFromPattern(
-								prop.value,
-								identifiers
-							);
-						} else if (prop.type === "RestElement") {
-							extractIdentifiersFromPattern(
-								prop.argument,
-								identifiers
-							);
-						}
-					}
-					break;
-				case "ArrayPattern":
-					for (const element of pattern.elements) {
-						if (element)
-							extractIdentifiersFromPattern(element, identifiers);
-					}
-					break;
-				case "AssignmentPattern":
-					extractIdentifiersFromPattern(pattern.left, identifiers);
-					break;
-				default:
-					break;
-			}
-			return identifiers;
-		}
-
-		/**
-		 * Checks if there is an outer variable whose name is longer than the current short name
-		 * and starts with the same characters.
-		 * It first uses the scope manager; if that doesn’t yield a match,
-		 * it falls back on scanning the nearest block and ancestors.
-		 * @param {string} shortName The variable name that is shorter than minLength.
-		 * @param {ASTNode} node The current identifier node.
-		 * @returns {boolean} True if an outer variable is found.
-		 */
-		function hasOuterCorrespondingIdentifier(shortName, node) {
-			// First, try using the scope manager.
-			let currentScope = getScope(node);
-			let outer = currentScope.upper;
-			while (outer) {
-				for (const variable of outer.variables) {
-					if (
-						variable.name.length >= minLength &&
-						variable.name.length > shortName.length &&
-						variable.name.startsWith(shortName)
-					) {
-						return true;
-					}
-				}
-				outer = outer.upper;
-			}
-			// Fallback: scan the nearest BlockStatement.
-			const blockVars = getVariablesInNearestBlock(node);
-			for (const name of blockVars) {
-				if (
-					name.length >= minLength &&
-					name.length > shortName.length &&
-					name.startsWith(shortName)
-				) {
-					return true;
-				}
-			}
-			// Fallback: scan ancestors.
-			const ancestors = getAncestors(node);
-			for (const anc of ancestors) {
-				if (
-					anc.type === "VariableDeclarator" &&
-					anc.id &&
-					anc.id.type === "Identifier"
-				) {
-					const outerName = anc.id.name;
-					if (
-						outerName.length >= minLength &&
-						outerName.length > shortName.length &&
-						outerName.startsWith(shortName)
-					) {
-						return true;
-					}
-				}
-				if (
-					(anc.type === "FunctionDeclaration" ||
-						anc.type === "FunctionExpression" ||
-						anc.type === "ArrowFunctionExpression") &&
-					Array.isArray(anc.params)
-				) {
-					for (const param of anc.params) {
-						const names = extractIdentifiersFromPattern(param, []);
-						for (const n of names) {
-							if (
-								n.length >= minLength &&
-								n.length > shortName.length &&
-								n.startsWith(shortName)
-							) {
-								return true;
-							}
-						}
-					}
-				}
-				if (anc.type === "CatchClause" && anc.param) {
-					const names = extractIdentifiersFromPattern(anc.param, []);
-					for (const n of names) {
-						if (
-							n.length >= minLength &&
-							n.length > shortName.length &&
-							n.startsWith(shortName)
-						) {
-							return true;
-						}
-					}
-				}
-			}
-			return false;
-		}
-
-		/**
-		 * Checks an Identifier node. If its name is shorter than minLength (and not in the allowed list)
-		 * and no outer variable with a longer name starting with the short name is found, it reports an error.
-		 * @param {ASTNode} node The Identifier node.
-		 */
-		function checkIdentifier(node) {
-			const name = node.name;
-			if (typeof name === "string" && name.length < minLength) {
-				// If the name is in the allowed list, skip.
-				if (allowedVars.includes(name)) {
-					return;
-				}
-				if (!hasOuterCorrespondingIdentifier(name, node)) {
-					context.report({
-						node,
-						messageId: "variableNameTooShort",
-						data: { name, minLength }
-					});
-				}
-			}
-		}
-
-		/**
-		 * Recursively checks a pattern node for identifiers.
-		 * @param {ASTNode} pattern The pattern node.
-		 */
-		function checkPattern(pattern) {
-			if (!pattern) return;
-			switch (pattern.type) {
-				case "Identifier":
-					checkIdentifier(pattern);
-					break;
-				case "ObjectPattern":
-					for (const prop of pattern.properties) {
-						if (prop.type === "Property") {
-							checkPattern(prop.value);
-						} else if (prop.type === "RestElement") {
-							checkPattern(prop.argument);
-						}
-					}
-					break;
-				case "ArrayPattern":
-					for (const element of pattern.elements) {
-						if (element) checkPattern(element);
-					}
-					break;
-				case "AssignmentPattern":
-					checkPattern(pattern.left);
-					break;
-				default:
-					break;
-			}
-		}
-
-		return {
-			VariableDeclarator(node) {
-				if (node.id) {
-					checkPattern(node.id);
-				}
-			},
-			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
-				node
-			) {
-				for (const param of node.params) {
-					checkPattern(param);
-				}
-			},
-			CatchClause(node) {
-				if (node.param) {
-					checkPattern(node.param);
-				}
-			}
-		};
-	}
-};

package/src/rules/no-button-navigation.js

@@ -1,232 +0,0 @@
-export default {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Enforce using anchor tags for navigation instead of buttons whose onClick handlers change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + …).",
-			category: "Best Practices",
-			recommended: false
-		},
-		schema: []
-	},
-	create(context) {
-		/**
-		 * Returns true if the given AST subtree contains a MemberExpression of
-		 * the form `window.location.pathname`, `window.location.search`, or `window.location.hash`.
-		 */
-		function urlUsesAllowedLocation(argNode) {
-			let allowed = false;
-			const visited = new WeakSet();
-
-			function check(n) {
-				if (allowed || !n || typeof n !== "object" || visited.has(n))
-					return;
-				visited.add(n);
-
-				if (
-					n.type === "MemberExpression" &&
-					n.object.type === "MemberExpression" &&
-					n.object.object.type === "Identifier" &&
-					n.object.object.name === "window" &&
-					n.object.property.type === "Identifier" &&
-					n.object.property.name === "location" &&
-					n.property.type === "Identifier" &&
-					(n.property.name === "pathname" ||
-						n.property.name === "search" ||
-						n.property.name === "hash")
-				) {
-					allowed = true;
-					return;
-				}
-
-				for (const key of Object.keys(n)) {
-					if (key === "parent") continue;
-					const child = n[key];
-					if (Array.isArray(child)) {
-						child.forEach((c) => check(c));
-					} else {
-						check(child);
-					}
-				}
-			}
-
-			check(argNode);
-			return allowed;
-		}
-
-		/**
-		 * Returns an object { shouldReport, reason } after inspecting the
-		 * function body for forbidden patterns.  - shouldReport is true if
-		 * we must flag.  - reason explains which pattern was found.
-		 */
-		function containsWindowNavigation(node) {
-			let reason = null;
-			const visited = new WeakSet();
-			let sawReplaceCall = false;
-			let sawAllowedLocationRead = false;
-
-			function inspect(n, parent) {
-				if (reason || !n || typeof n !== "object" || visited.has(n))
-					return;
-				visited.add(n);
-
-				// 1) window.open(...)
-				if (
-					n.type === "MemberExpression" &&
-					n.object.type === "Identifier" &&
-					n.object.name === "window" &&
-					n.property.type === "Identifier" &&
-					n.property.name === "open"
-				) {
-					reason = "window.open";
-					return;
-				}
-
-				// 2) Assignment to window.location or window.location.*
-				if (
-					n.type === "AssignmentExpression" &&
-					n.left.type === "MemberExpression"
-				) {
-					const left = n.left;
-
-					// window.location = ...
-					if (
-						left.object.type === "Identifier" &&
-						left.object.name === "window" &&
-						left.property.type === "Identifier" &&
-						left.property.name === "location"
-					) {
-						reason = "assignment to window.location";
-						return;
-					}
-
-					// window.location.href = ...  OR  window.location.pathname =
-					if (
-						left.object.type === "MemberExpression" &&
-						left.object.object.type === "Identifier" &&
-						left.object.object.name === "window" &&
-						left.object.property.type === "Identifier" &&
-						left.object.property.name === "location"
-					) {
-						reason = "assignment to window.location sub-property";
-						return;
-					}
-				}
-
-				// 3) window.location.replace(...) (or any call on window.location besides .search/.hash)
-				if (
-					n.type === "MemberExpression" &&
-					n.object.type === "MemberExpression" &&
-					n.object.object.type === "Identifier" &&
-					n.object.object.name === "window" &&
-					n.object.property.type === "Identifier" &&
-					n.object.property.name === "location" &&
-					n.property.type === "Identifier" &&
-					n.property.name === "replace"
-				) {
-					if (parent && parent.type === "CallExpression") {
-						reason = "window.location.replace";
-						return;
-					}
-				}
-
-				// 4) window.history.pushState(...) or replaceState(...)
-				if (
-					n.type === "MemberExpression" &&
-					n.object.type === "MemberExpression" &&
-					n.object.object.type === "Identifier" &&
-					n.object.object.name === "window" &&
-					n.object.property.type === "Identifier" &&
-					n.object.property.name === "history" &&
-					n.property.type === "Identifier" &&
-					(n.property.name === "pushState" ||
-						n.property.name === "replaceState")
-				) {
-					sawReplaceCall = true;
-				}
-
-				// 5) Reading window.location.search, .pathname, or .hash
-				if (
-					n.type === "MemberExpression" &&
-					n.object.type === "MemberExpression" &&
-					n.object.object.type === "Identifier" &&
-					n.object.object.name === "window" &&
-					n.object.property.type === "Identifier" &&
-					n.object.property.name === "location" &&
-					n.property.type === "Identifier" &&
-					(n.property.name === "search" ||
-						n.property.name === "pathname" ||
-						n.property.name === "hash")
-				) {
-					sawAllowedLocationRead = true;
-				}
-
-				// Recurse into children
-				for (const key of Object.keys(n)) {
-					if (key === "parent" || reason) continue;
-					const child = n[key];
-					if (Array.isArray(child)) {
-						child.forEach((c) => inspect(c, n));
-					} else {
-						inspect(child, n);
-					}
-					if (reason) return;
-				}
-			}
-
-			inspect(
-				node.type === "ArrowFunctionExpression" ||
-					node.type === "FunctionExpression"
-					? node.body
-					: node,
-				null
-			);
-
-			if (reason) {
-				return { shouldReport: true, reason };
-			}
-			if (sawReplaceCall && !sawAllowedLocationRead) {
-				return {
-					shouldReport: true,
-					reason: "history.replace/pushState without reading window.location"
-				};
-			}
-			return { shouldReport: false, reason: null };
-		}
-
-		return {
-			JSXElement(node) {
-				const { openingElement } = node;
-				if (
-					openingElement.name.type === "JSXIdentifier" &&
-					openingElement.name.name === "button"
-				) {
-					for (const attr of openingElement.attributes) {
-						if (
-							attr.type === "JSXAttribute" &&
-							attr.name.name === "onClick" &&
-							attr.value?.type === "JSXExpressionContainer"
-						) {
-							const expr = attr.value.expression;
-							if (
-								expr.type === "ArrowFunctionExpression" ||
-								expr.type === "FunctionExpression"
-							) {
-								const { shouldReport, reason } =
-									containsWindowNavigation(expr);
-								if (shouldReport) {
-									context.report({
-										node: attr,
-										message:
-											`Use an anchor tag for navigation instead of a button whose onClick handler changes the path. ` +
-											`Detected: ${reason}. Only query/hash updates (reading window.location.search, .pathname, or .hash) are allowed.`
-									});
-								}
-							}
-						}
-					}
-				}
-			}
-		};
-	}
-};

package/src/rules/no-explicit-return-types.js

@@ -1,64 +0,0 @@
-export default {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Disallow explicit return type annotations on functions, except when using type predicates for type guards or inline object literal returns (e.g., style objects).",
-			recommended: false
-		},
-		schema: [],
-		messages: {
-			noExplicitReturnType:
-				"Explicit return types are disallowed; rely on TypeScript's inference instead."
-		}
-	},
-
-	create(context) {
-		return {
-			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
-				node
-			) {
-				if (node.returnType) {
-					// Allow type predicate annotations for type guards.
-					const typeAnnotation = node.returnType.typeAnnotation;
-					if (
-						typeAnnotation &&
-						typeAnnotation.type === "TSTypePredicate"
-					) {
-						return;
-					}
-
-					// Allow if it's an arrow function that directly returns an object literal.
-					if (
-						node.type === "ArrowFunctionExpression" &&
-						node.expression &&
-						node.body &&
-						node.body.type === "ObjectExpression"
-					) {
-						return;
-					}
-
-					// Allow if the function has a block body with a single return statement that returns an object literal.
-					if (node.body && node.body.type === "BlockStatement") {
-						const returns = node.body.body.filter(
-							(stmt) => stmt.type === "ReturnStatement"
-						);
-						if (
-							returns.length === 1 &&
-							returns[0].argument &&
-							returns[0].argument.type === "ObjectExpression"
-						) {
-							return;
-						}
-					}
-
-					// Otherwise, report an error.
-					context.report({
-						node: node.returnType,
-						messageId: "noExplicitReturnType"
-					});
-				}
-			}
-		};
-	}
-};

package/src/rules/no-inline-prop-types.js

@@ -1,55 +0,0 @@
-export default {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Enforce that component prop types are not defined inline (using an object literal) but rather use a named type or interface.",
-			category: "Best Practices",
-			recommended: false
-		},
-		schema: [],
-		messages: {
-			noInlinePropTypes:
-				"Inline prop type definitions are not allowed. Use a named type alias or interface instead of an inline object type."
-		}
-	},
-
-	create(context) {
-		/**
-		 * Checks the node representing a parameter to determine if it is an ObjectPattern with an inline type literal.
-		 * @param {ASTNode} param The parameter node from the function declaration/expression.
-		 */
-		function checkParameter(param) {
-			// Ensure we are dealing with a destructured object pattern with a type annotation.
-			if (
-				param &&
-				param.type === "ObjectPattern" &&
-				param.typeAnnotation &&
-				param.typeAnnotation.type === "TSTypeAnnotation"
-			) {
-				// The actual type annotation node (for example, { mode: string } yields a TSTypeLiteral).
-				const annotation = param.typeAnnotation.typeAnnotation;
-				// If the type is an inline object (TSTypeLiteral), we want to report it.
-				if (annotation.type === "TSTypeLiteral") {
-					context.report({
-						node: param,
-						messageId: "noInlinePropTypes"
-					});
-				}
-			}
-		}
-
-		return {
-			// Applies to FunctionDeclaration, ArrowFunctionExpression, and FunctionExpression nodes.
-			"FunctionDeclaration, ArrowFunctionExpression, FunctionExpression"(
-				node
-			) {
-				// It is common to define props as the first parameter.
-				const firstParam = node.params[0];
-				if (firstParam) {
-					checkParameter(firstParam);
-				}
-			}
-		};
-	}
-};