eslint-plugin-absolute 0.0.3 → 0.1.1

package/dist/index.js

@@ -1,4 +1,118 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// src/rules/no-button-navigation.js
+var require_no_button_navigation = __commonJS((exports, module) => {
+  module.exports = {
+    meta: {
+      type: "suggestion",
+      docs: {
+        description: "Enforce using anchor tags for navigation instead of buttons with onClick handlers that change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + \u2026).",
+        category: "Best Practices",
+        recommended: false
+      },
+      schema: []
+    },
+    create(context) {
+      function containsWindowNavigation(node) {
+        let found = false;
+        function inspect(n, parent) {
+          if (found || !n || typeof n !== "object")
+            return;
+          if (n.type === "MemberExpression" && n.object.type === "Identifier" && n.object.name === "window" && n.property.type === "Identifier" && n.property.name === "open") {
+            found = true;
+            return;
+          }
+          if (n.type === "MemberExpression" && n.object.type === "Identifier" && n.object.name === "window" && n.property.type === "Identifier" && n.property.name === "location") {
+            if (parent && parent.type === "MemberExpression" && parent.object === n && parent.property.type === "Identifier" && (parent.property.name === "search" || parent.property.name === "hash")) {} else {
+              found = true;
+              return;
+            }
+          }
+          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")) {
+            if (parent && parent.type === "CallExpression" && Array.isArray(parent.arguments) && parent.arguments.length >= 3) {
+              const urlArg = parent.arguments[2];
+              if (!urlUsesAllowedLocation(urlArg)) {
+                found = true;
+                return;
+              }
+            }
+          }
+          for (const key of Object.keys(n)) {
+            if (key === "parent")
+              continue;
+            const child = n[key];
+            if (Array.isArray(child)) {
+              child.forEach((c) => inspect(c, n));
+            } else {
+              inspect(child, n);
+            }
+          }
+        }
+        function urlUsesAllowedLocation(argNode) {
+          let allowed = false;
+          function check(n) {
+            if (allowed || !n || typeof n !== "object")
+              return;
+            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 c = n[key];
+              if (Array.isArray(c)) {
+                c.forEach(check);
+              } else {
+                check(c);
+              }
+            }
+          }
+          check(argNode);
+          return allowed;
+        }
+        inspect(node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" ? node.body : node, null);
+        return found;
+      }
+      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") && containsWindowNavigation(expr)) {
+                  context.report({
+                    node: attr,
+                    message: "Use an anchor tag for navigation instead of a button with an onClick handler that changes the path. Only query/hash updates are allowed."
+                  });
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+  };
+});
+
 // src/rules/no-nested-jsx-return.js
 var no_nested_jsx_return_default = {
   meta: {
@@ -149,45 +263,6 @@ var explicit_object_types_default = {
   }
 };
 
-// src/rules/no-type-cast.js
-var no_type_cast_default = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: 'Disallow type assertions using "as", angle bracket syntax, or built-in conversion functions.',
-      recommended: false
-    },
-    schema: []
-  },
-  create(context) {
-    function isBuiltInConversion(node) {
-      return node && node.type === "Identifier" && ["Number", "String", "Boolean"].includes(node.name);
-    }
-    return {
-      TSAsExpression(node) {
-        context.report({
-          node,
-          message: 'Type assertions using "as" syntax are not allowed.'
-        });
-      },
-      TSTypeAssertion(node) {
-        context.report({
-          node,
-          message: "Type assertions using angle bracket syntax are not allowed."
-        });
-      },
-      CallExpression(node) {
-        if (isBuiltInConversion(node.callee)) {
-          context.report({
-            node,
-            message: `Type assertions using "${node.callee.name}()" syntax are not allowed.`
-          });
-        }
-      }
-    };
-  }
-};
-
 // src/rules/sort-keys-fixable.js
 var sort_keys_fixable_default = {
   meta: {
@@ -457,35 +532,89 @@ var no_explicit_return_types_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).",
+      description: "Enforce using anchor tags for navigation instead of buttons with onClick handlers that change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + \u2026).",
+      category: "Best Practices",
       recommended: false
     },
-    schema: [],
-    messages: {
-      noExplicitReturnType: "Explicit return types are disallowed; rely on TypeScript's inference instead."
-    }
+    schema: []
   },
   create(context) {
-    return {
-      "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
-        if (node.returnType) {
-          const typeAnnotation = node.returnType.typeAnnotation;
-          if (typeAnnotation && typeAnnotation.type === "TSTypePredicate") {
+    function containsWindowNavigation(node) {
+      let found = false;
+      function inspect(n, parent) {
+        if (found || !n || typeof n !== "object")
+          return;
+        if (n.type === "MemberExpression" && n.object.type === "Identifier" && n.object.name === "window" && n.property.type === "Identifier" && n.property.name === "open") {
+          found = true;
+          return;
+        }
+        if (n.type === "MemberExpression" && n.object.type === "Identifier" && n.object.name === "window" && n.property.type === "Identifier" && n.property.name === "location") {
+          if (parent && parent.type === "MemberExpression" && parent.object === n && parent.property.type === "Identifier" && (parent.property.name === "search" || parent.property.name === "hash")) {} else {
+            found = true;
             return;
           }
-          if (node.type === "ArrowFunctionExpression" && node.expression && node.body && node.body.type === "ObjectExpression") {
+        }
+        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")) {
+          if (parent && parent.type === "CallExpression" && Array.isArray(parent.arguments) && parent.arguments.length >= 3) {
+            const urlArg = parent.arguments[2];
+            if (!urlUsesAllowedLocation(urlArg)) {
+              found = true;
+              return;
+            }
+          }
+        }
+        for (const key of Object.keys(n)) {
+          if (key === "parent")
+            continue;
+          const child = n[key];
+          if (Array.isArray(child)) {
+            child.forEach((c) => inspect(c, n));
+          } else {
+            inspect(child, n);
+          }
+        }
+      }
+      function urlUsesAllowedLocation(argNode) {
+        let allowed = false;
+        function check(n) {
+          if (allowed || !n || typeof n !== "object")
+            return;
+          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;
           }
-          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;
+          for (const key of Object.keys(n)) {
+            if (key === "parent")
+              continue;
+            const c = n[key];
+            if (Array.isArray(c)) {
+              c.forEach(check);
+            } else {
+              check(c);
+            }
+          }
+        }
+        check(argNode);
+        return allowed;
+      }
+      inspect(node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" ? node.body : node, null);
+      return found;
+    }
+    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") && containsWindowNavigation(expr)) {
+                context.report({
+                  node: attr,
+                  message: "Use an anchor tag for navigation instead of a button with an onClick handler that changes the path. Only query/hash updates are allowed."
+                });
+              }
             }
           }
-          context.report({
-            node: node.returnType,
-            messageId: "noExplicitReturnType"
-          });
         }
       }
     };
@@ -1189,61 +1318,8 @@ var no_or_none_component_default = {
   }
 };
 
-// src/rules/no-button-navigation.js
-var no_button_navigation_default = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Enforce using anchor tags for navigation instead of buttons with onClick handlers that use window navigation methods (e.g., window.location, window.open)",
-      category: "Best Practices",
-      recommended: false
-    },
-    schema: []
-  },
-  create(context) {
-    function containsWindowNavigation(node) {
-      let found = false;
-      function inspect(n) {
-        if (found || !n || typeof n !== "object")
-          return;
-        if (n.type === "MemberExpression" && n.object.type === "Identifier" && n.object.name === "window" && n.property.type === "Identifier" && (n.property.name === "open" || n.property.name === "location")) {
-          found = true;
-          return;
-        }
-        for (const key of Object.keys(n)) {
-          if (key === "parent")
-            continue;
-          const child = n[key];
-          if (Array.isArray(child)) {
-            child.forEach(inspect);
-          } else {
-            inspect(child);
-          }
-        }
-      }
-      inspect(node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" ? node.body : node);
-      return found;
-    }
-    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") && containsWindowNavigation(expr)) {
-                context.report({
-                  node: attr,
-                  message: "Use an anchor tag for navigation instead of a button with an onClick handler that uses window navigation methods."
-                });
-              }
-            }
-          }
-        }
-      }
-    };
-  }
-};
+// src/index.js
+var import_no_button_navigation = __toESM(require_no_button_navigation(), 1);
 
 // src/rules/no-multi-style-objects.js
 var no_multi_style_objects_default = {
@@ -1840,7 +1916,6 @@ var src_default = {
   rules: {
     "no-nested-jsx-return": no_nested_jsx_return_default,
     "explicit-object-types": explicit_object_types_default,
-    "no-type-cast": no_type_cast_default,
     "sort-keys-fixable": sort_keys_fixable_default,
     "no-transition-cssproperties": no_transition_cssproperties_default,
     "no-explicit-return-type": no_explicit_return_types_default,
@@ -1850,7 +1925,7 @@ var src_default = {
     "sort-exports": sort_exports_default,
     "localize-react-props": localize_react_props_default,
     "no-or-none-component": no_or_none_component_default,
-    "no-button-navigation": no_button_navigation_default,
+    "no-button-navigation": import_no_button_navigation.default,
     "no-multi-style-objects": no_multi_style_objects_default,
     "no-useless-function": no_useless_function_default,
     "min-var-length": min_var_length_default,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-absolute",
-	"version": "0.0.3",
+	"version": "0.1.1",
 	"description": "ESLint plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",

package/src/index.js

@@ -1,6 +1,5 @@
 import noNestedJsxReturn from "./rules/no-nested-jsx-return.js";
 import explicitObjectTypes from "./rules/explicit-object-types.js";
-import noTypeCast from "./rules/no-type-cast.js";
 import sortKeysFixable from "./rules/sort-keys-fixable.js";
 import noTransitionCssproperties from "./rules/no-transition-cssproperties.js";
 import noExplicitReturnTypes from "./rules/no-explicit-return-types.js";
@@ -24,7 +23,6 @@ export default {
 	rules: {
 		"no-nested-jsx-return": noNestedJsxReturn,
 		"explicit-object-types": explicitObjectTypes,
-		"no-type-cast": noTypeCast,
 		"sort-keys-fixable": sortKeysFixable,
 		"no-transition-cssproperties": noTransitionCssproperties,
 		"no-explicit-return-type": noExplicitReturnTypes,

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

@@ -1,52 +1,137 @@
-export default {
+module.exports = {
 	meta: {
 		type: "suggestion",
 		docs: {
 			description:
-				"Enforce using anchor tags for navigation instead of buttons with onClick handlers that use window navigation methods (e.g., window.location, window.open)",
+				"Enforce using anchor tags for navigation instead of buttons with onClick handlers that 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) {
-		/**
-		 * Inspects an AST node *only* for MemberExpressions where
-		 * the object is literally `window` and the property is `open` or `location`.
-		 */
 		function containsWindowNavigation(node) {
 			let found = false;
-			function inspect(n) {
+
+			function inspect(n, parent) {
 				if (found || !n || typeof n !== "object") return;
-				// Only match MemberExpressions on the global window identifier
+
+				// Detect window.open(...)
 				if (
 					n.type === "MemberExpression" &&
 					n.object.type === "Identifier" &&
 					n.object.name === "window" &&
 					n.property.type === "Identifier" &&
-					(n.property.name === "open" ||
-						n.property.name === "location")
+					n.property.name === "open"
 				) {
 					found = true;
 					return;
 				}
-				// recurse into children—but skip walking back up via `parent`
+
+				// Detect direct use of window.location (not just .search or .hash)
+				if (
+					n.type === "MemberExpression" &&
+					n.object.type === "Identifier" &&
+					n.object.name === "window" &&
+					n.property.type === "Identifier" &&
+					n.property.name === "location"
+				) {
+					if (
+						parent &&
+						parent.type === "MemberExpression" &&
+						parent.object === n &&
+						parent.property.type === "Identifier" &&
+						(parent.property.name === "search" ||
+							parent.property.name === "hash")
+					) {
+						// reading window.location.search or window.location.hash → OK
+					} else {
+						// any other use of window.location → flag
+						found = true;
+						return;
+					}
+				}
+
+				// Detect 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")
+				) {
+					if (
+						parent &&
+						parent.type === "CallExpression" &&
+						Array.isArray(parent.arguments) &&
+						parent.arguments.length >= 3
+					) {
+						const urlArg = parent.arguments[2];
+						if (!urlUsesAllowedLocation(urlArg)) {
+							found = true;
+							return;
+						}
+						// If urlArg references window.location.pathname/search/hash → OK
+					}
+				}
+
+				// Recurse into child nodes
 				for (const key of Object.keys(n)) {
 					if (key === "parent") continue;
 					const child = n[key];
 					if (Array.isArray(child)) {
-						child.forEach(inspect);
+						child.forEach((c) => inspect(c, n));
 					} else {
-						inspect(child);
+						inspect(child, n);
 					}
 				}
 			}
-			// If it's a function, start at its body; otherwise start at the node itself
+
+			function urlUsesAllowedLocation(argNode) {
+				let allowed = false;
+
+				function check(n) {
+					if (allowed || !n || typeof n !== "object") return;
+					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 c = n[key];
+						if (Array.isArray(c)) {
+							c.forEach(check);
+						} else {
+							check(c);
+						}
+					}
+				}
+
+				check(argNode);
+				return allowed;
+			}
+
 			inspect(
 				node.type === "ArrowFunctionExpression" ||
 					node.type === "FunctionExpression"
 					? node.body
-					: node
+					: node,
+				null
 			);
 			return found;
 		}
@@ -54,7 +139,6 @@ export default {
 		return {
 			JSXElement(node) {
 				const { openingElement } = node;
-				// only care about <button ...>
 				if (
 					openingElement.name.type === "JSXIdentifier" &&
 					openingElement.name.name === "button"
@@ -66,7 +150,6 @@ export default {
 							attr.value?.type === "JSXExpressionContainer"
 						) {
 							const expr = attr.value.expression;
-							// only inspect the inline function, not any Identifier calls
 							if (
 								(expr.type === "ArrowFunctionExpression" ||
 									expr.type === "FunctionExpression") &&
@@ -75,7 +158,7 @@ export default {
 								context.report({
 									node: attr,
 									message:
-										"Use an anchor tag for navigation instead of a button with an onClick handler that uses window navigation methods."
+										"Use an anchor tag for navigation instead of a button with an onClick handler that changes the path. Only query/hash updates are allowed."
 								});
 							}
 						}

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

@@ -3,60 +3,166 @@ export default {
 		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).",
+				"Enforce using anchor tags for navigation instead of buttons with onClick handlers that change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + …).",
+			category: "Best Practices",
 			recommended: false
 		},
-		schema: [],
-		messages: {
-			noExplicitReturnType:
-				"Explicit return types are disallowed; rely on TypeScript's inference instead."
-		}
+		schema: []
 	},
-
 	create(context) {
-		return {
-			"FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(
-				node
-			) {
-				if (node.returnType) {
-					// Allow type predicate annotations for type guards.
-					const typeAnnotation = node.returnType.typeAnnotation;
+		function containsWindowNavigation(node) {
+			let found = false;
+
+			function inspect(n, parent) {
+				if (found || !n || typeof n !== "object") return;
+
+				// Detect window.open(...)
+				if (
+					n.type === "MemberExpression" &&
+					n.object.type === "Identifier" &&
+					n.object.name === "window" &&
+					n.property.type === "Identifier" &&
+					n.property.name === "open"
+				) {
+					found = true;
+					return;
+				}
+
+				// Detect direct use of window.location (not just .search or .hash)
+				if (
+					n.type === "MemberExpression" &&
+					n.object.type === "Identifier" &&
+					n.object.name === "window" &&
+					n.property.type === "Identifier" &&
+					n.property.name === "location"
+				) {
 					if (
-						typeAnnotation &&
-						typeAnnotation.type === "TSTypePredicate"
+						parent &&
+						parent.type === "MemberExpression" &&
+						parent.object === n &&
+						parent.property.type === "Identifier" &&
+						(parent.property.name === "search" ||
+							parent.property.name === "hash")
 					) {
+						// reading window.location.search or window.location.hash → OK
+					} else {
+						// any other use of window.location → flag
+						found = true;
 						return;
 					}
+				}
+
+				// Detect 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")
+				) {
+					if (
+						parent &&
+						parent.type === "CallExpression" &&
+						Array.isArray(parent.arguments) &&
+						parent.arguments.length >= 3
+					) {
+						const urlArg = parent.arguments[2];
+						if (!urlUsesAllowedLocation(urlArg)) {
+							found = true;
+							return;
+						}
+						// If urlArg references window.location.pathname/search/hash → OK
+					}
+				}
+
+				// Recurse into child nodes
+				for (const key of Object.keys(n)) {
+					if (key === "parent") continue;
+					const child = n[key];
+					if (Array.isArray(child)) {
+						child.forEach((c) => inspect(c, n));
+					} else {
+						inspect(child, n);
+					}
+				}
+			}
 
-					// Allow if it's an arrow function that directly returns an object literal.
+			function urlUsesAllowedLocation(argNode) {
+				let allowed = false;
+
+				function check(n) {
+					if (allowed || !n || typeof n !== "object") return;
 					if (
-						node.type === "ArrowFunctionExpression" &&
-						node.expression &&
-						node.body &&
-						node.body.type === "ObjectExpression"
+						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 c = n[key];
+						if (Array.isArray(c)) {
+							c.forEach(check);
+						} else {
+							check(c);
+						}
+					}
+				}
 
-					// 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"
-						);
+				check(argNode);
+				return allowed;
+			}
+
+			inspect(
+				node.type === "ArrowFunctionExpression" ||
+					node.type === "FunctionExpression"
+					? node.body
+					: node,
+				null
+			);
+			return found;
+		}
+
+		return {
+			JSXElement(node) {
+				const { openingElement } = node;
+				if (
+					openingElement.name.type === "JSXIdentifier" &&
+					openingElement.name.name === "button"
+				) {
+					for (const attr of openingElement.attributes) {
 						if (
-							returns.length === 1 &&
-							returns[0].argument &&
-							returns[0].argument.type === "ObjectExpression"
+							attr.type === "JSXAttribute" &&
+							attr.name.name === "onClick" &&
+							attr.value?.type === "JSXExpressionContainer"
 						) {
-							return;
+							const expr = attr.value.expression;
+							if (
+								(expr.type === "ArrowFunctionExpression" ||
+									expr.type === "FunctionExpression") &&
+								containsWindowNavigation(expr)
+							) {
+								context.report({
+									node: attr,
+									message:
+										"Use an anchor tag for navigation instead of a button with an onClick handler that changes the path. Only query/hash updates are allowed."
+								});
+							}
 						}
 					}
-
-					// Otherwise, report an error.
-					context.report({
-						node: node.returnType,
-						messageId: "noExplicitReturnType"
-					});
 				}
 			}
 		};

package/src/rules/no-type-cast.js

@@ -1,50 +0,0 @@
-export default {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				'Disallow type assertions using "as", angle bracket syntax, or built-in conversion functions.',
-			recommended: false
-		},
-		schema: []
-	},
-	create(context) {
-		// Helper function to determine if a call expression is a built-in conversion.
-		function isBuiltInConversion(node) {
-			return (
-				node &&
-				node.type === "Identifier" &&
-				["Number", "String", "Boolean"].includes(node.name)
-			);
-		}
-
-		return {
-			// Catch type assertions using "as" syntax.
-			TSAsExpression(node) {
-				context.report({
-					node,
-					message:
-						'Type assertions using "as" syntax are not allowed.'
-				});
-			},
-			// Catch type assertions using angle bracket syntax.
-			TSTypeAssertion(node) {
-				context.report({
-					node,
-					message:
-						"Type assertions using angle bracket syntax are not allowed."
-				});
-			},
-			// Catch type conversions using built-in functions like Number(prop)
-			CallExpression(node) {
-				// Check if the callee is a built-in conversion function.
-				if (isBuiltInConversion(node.callee)) {
-					context.report({
-						node,
-						message: `Type assertions using "${node.callee.name}()" syntax are not allowed.`
-					});
-				}
-			}
-		};
-	}
-};