eslint-plugin-absolute 0.0.2 → 0.1.0

package/dist/index.js

@@ -149,45 +149,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: {
@@ -1203,51 +1164,35 @@ var no_button_navigation_default = {
   create(context) {
     function containsWindowNavigation(node) {
       let found = false;
-      const visited = new WeakSet;
       function inspect(n) {
-        if (!n || found)
-          return;
-        if (typeof n !== "object")
+        if (found || !n || typeof n !== "object")
           return;
-        if (visited.has(n))
+        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;
-        visited.add(n);
-        if (n.type === "MemberExpression") {
-          if (n.object && n.object.type === "Identifier" && n.object.name === "window" && n.property && (n.property.type === "Identifier" && (n.property.name === "location" || n.property.name === "open") || n.property.type === "Literal" && (n.property.value === "location" || n.property.value === "open"))) {
-            found = true;
-            return;
-          }
-        }
-        if (n.type === "CallExpression" && n.callee && n.callee.type === "MemberExpression") {
-          const callee = n.callee;
-          if (callee.object && callee.object.type === "Identifier" && callee.object.name === "window" && callee.property && callee.property.type === "Identifier" && callee.property.name === "open") {
-            found = true;
-            return;
-          }
         }
-        for (const key in n) {
-          if (Object.prototype.hasOwnProperty.call(n, key)) {
-            const child = n[key];
-            if (Array.isArray(child)) {
-              child.forEach(inspect);
-            } else if (child && typeof child === "object") {
-              inspect(child);
-            }
+        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);
+      inspect(node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" ? node.body : node);
       return found;
     }
     return {
       JSXElement(node) {
-        const openingElement = node.openingElement;
-        if (openingElement.name && openingElement.name.type === "JSXIdentifier" && openingElement.name.name === "button") {
-          const attributes = openingElement.attributes;
-          for (const attr of attributes) {
-            if (attr.type === "JSXAttribute" && attr.name && attr.name.name === "onClick" && attr.value && attr.value.type === "JSXExpressionContainer") {
-              const expression = attr.value.expression;
-              if (containsWindowNavigation(expression)) {
+        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."
@@ -1856,7 +1801,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,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-absolute",
-	"version": "0.0.2",
+	"version": "0.1.0",
 	"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

@@ -11,94 +11,67 @@ export default {
 	},
 	create(context) {
 		/**
-		 * Recursively inspects an AST node to see if it contains a reference to window.location or window.open.
-		 * Uses a WeakSet to track visited nodes to avoid infinite recursion.
-		 * @param {ASTNode} node - The node to inspect.
-		 * @returns {boolean} True if a window navigation reference is found.
+		 * 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;
-			const visited = new WeakSet();
 			function inspect(n) {
-				if (!n || found) return;
-				if (typeof n !== "object") return; // Only objects can be added to WeakSet
-				if (visited.has(n)) return;
-				visited.add(n);
-
-				// Check for MemberExpressions like window.location or window.open
-				if (n.type === "MemberExpression") {
-					if (
-						n.object &&
-						n.object.type === "Identifier" &&
-						n.object.name === "window" &&
-						n.property &&
-						((n.property.type === "Identifier" &&
-							(n.property.name === "location" ||
-								n.property.name === "open")) ||
-							(n.property.type === "Literal" &&
-								(n.property.value === "location" ||
-									n.property.value === "open")))
-					) {
-						found = true;
-						return;
-					}
-				}
-				// Check for CallExpressions like window.open()
+				if (found || !n || typeof n !== "object") return;
+				// Only match MemberExpressions on the global window identifier
 				if (
-					n.type === "CallExpression" &&
-					n.callee &&
-					n.callee.type === "MemberExpression"
+					n.type === "MemberExpression" &&
+					n.object.type === "Identifier" &&
+					n.object.name === "window" &&
+					n.property.type === "Identifier" &&
+					(n.property.name === "open" ||
+						n.property.name === "location")
 				) {
-					const callee = n.callee;
-					if (
-						callee.object &&
-						callee.object.type === "Identifier" &&
-						callee.object.name === "window" &&
-						callee.property &&
-						callee.property.type === "Identifier" &&
-						callee.property.name === "open"
-					) {
-						found = true;
-						return;
-					}
+					found = true;
+					return;
 				}
-				// Recursively inspect all child nodes
-				for (const key in n) {
-					if (Object.prototype.hasOwnProperty.call(n, key)) {
-						const child = n[key];
-						if (Array.isArray(child)) {
-							child.forEach(inspect);
-						} else if (child && typeof child === "object") {
-							inspect(child);
-						}
+				// recurse into children—but skip walking back up via `parent`
+				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);
+			// If it's a function, start at its body; otherwise start at the node itself
+			inspect(
+				node.type === "ArrowFunctionExpression" ||
+					node.type === "FunctionExpression"
+					? node.body
+					: node
+			);
 			return found;
 		}
 
 		return {
 			JSXElement(node) {
-				const openingElement = node.openingElement;
-				// Check if the element is a <button>
+				const { openingElement } = node;
+				// only care about <button ...>
 				if (
-					openingElement.name &&
 					openingElement.name.type === "JSXIdentifier" &&
 					openingElement.name.name === "button"
 				) {
-					// Look for the onClick attribute
-					const attributes = openingElement.attributes;
-					for (const attr of attributes) {
+					for (const attr of openingElement.attributes) {
 						if (
 							attr.type === "JSXAttribute" &&
-							attr.name &&
 							attr.name.name === "onClick" &&
-							attr.value &&
-							attr.value.type === "JSXExpressionContainer"
+							attr.value?.type === "JSXExpressionContainer"
 						) {
-							const expression = attr.value.expression;
-							if (containsWindowNavigation(expression)) {
+							const expr = attr.value.expression;
+							// only inspect the inline function, not any Identifier calls
+							if (
+								(expr.type === "ArrowFunctionExpression" ||
+									expr.type === "FunctionExpression") &&
+								containsWindowNavigation(expr)
+							) {
 								context.report({
 									node: attr,
 									message:

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.`
-					});
-				}
-			}
-		};
-	}
-};