eslint-plugin-absolute 0.2.0 → 0.2.1

package/eslint.config.mjs

@@ -0,0 +1,107 @@
+import pluginJs from "@eslint/js";
+import tsParser from "@typescript-eslint/parser";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
+
+// Import ourselves from dist — this IS the plugin (run `bun run build` first)
+import absolutePlugin from "./dist/index.js";
+
+export default defineConfig([
+	{ ignores: ["dist/**", "node_modules/**", ".absolutejs/**"] },
+
+	pluginJs.configs.recommended,
+
+	...tseslint.configs.recommended,
+
+	{
+		files: ["**/*.ts"],
+		languageOptions: {
+			parser: tsParser,
+			parserOptions: {
+				project: "./tsconfig.json"
+			}
+		},
+		rules: {
+			"@typescript-eslint/consistent-type-assertions": [
+				"error",
+				{ assertionStyle: "never" }
+			],
+			"@typescript-eslint/no-unnecessary-type-assertion": "error"
+		}
+	},
+	{
+		files: ["**/*.{ts,js,mjs}"],
+		plugins: {
+			absolute: absolutePlugin
+		},
+		rules: {
+			"absolute/explicit-object-types": "error",
+			"absolute/max-depth-extended": ["error", 1],
+			"absolute/min-var-length": [
+				"error",
+				{ allowedVars: ["_", "id"], minLength: 3 }
+			],
+			"absolute/no-explicit-return-type": "error",
+			"absolute/no-useless-function": "error",
+			"absolute/sort-exports": [
+				"error",
+				{ caseSensitive: true, natural: true, order: "asc" }
+			],
+			"absolute/sort-keys-fixable": [
+				"error",
+				{ caseSensitive: true, natural: true, order: "asc" }
+			],
+			"arrow-body-style": ["error", "as-needed"],
+			"consistent-return": "error",
+			eqeqeq: "error",
+			"func-style": [
+				"error",
+				"expression",
+				{ allowArrowFunctions: true }
+			],
+			"no-await-in-loop": "error",
+			"no-duplicate-imports": "error",
+			"no-else-return": "error",
+			"no-empty-function": "error",
+			"no-floating-decimal": "error",
+			"no-implicit-coercion": "error",
+			"no-implicit-globals": "error",
+			"no-loop-func": "error",
+			"no-magic-numbers": [
+				"warn",
+				{ detectObjects: false, enforceConst: true, ignore: [0, 1, 2] }
+			],
+			"no-nested-ternary": "error",
+			"no-new-wrappers": "error",
+			"no-param-reassign": "error",
+			"no-return-await": "error",
+			"no-shadow": "error",
+			"no-unneeded-ternary": "error",
+			"no-useless-assignment": "error",
+			"no-useless-concat": "error",
+			"no-useless-return": "error",
+			"no-var": "error",
+			"prefer-arrow-callback": "error",
+			"prefer-const": "error",
+			"prefer-destructuring": [
+				"error",
+				{ array: true, object: true },
+				{ enforceForRenamedProperties: false }
+			],
+			"prefer-template": "error"
+		}
+	},
+	{
+		files: ["eslint.config.mjs"],
+		rules: {
+			"@typescript-eslint/no-unused-expressions": "off"
+		}
+	},
+	{
+		files: ["**/*.test.ts"],
+		rules: {
+			"absolute/min-var-length": "off",
+			"no-magic-numbers": "off"
+		}
+	}
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-absolute",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"description": "ESLint plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",
@@ -13,20 +13,22 @@
 	"scripts": {
 		"test": "bun test tests/",
 		"build": "rm -rf dist && bun build src/index.ts --outdir dist --splitting --target=bun --external eslint --external @typescript-eslint/utils",
-		"format": "prettier --write \"./**/*.{js,jsx,ts,tsx,css,json,mjs}\"",
+		"format": "absolutejs prettier --write",
 		"release": "bun run format && bun run build && bun publish",
 		"prune": "ts-prune --error",
+		"lint": "bun run build && bun run absolutejs eslint",
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.3",
-		"@types/react": "^19.2.14",
-		"@typescript-eslint/rule-tester": "^8.56.0",
-		"@typescript-eslint/utils": "^8.56.0",
+		"@types/bun": "1.3.3",
+		"@absolutejs/absolute": "0.16.10",
+		"@types/react": "19.2.14",
+		"@typescript-eslint/rule-tester": "8.56.0",
+		"@typescript-eslint/utils": "8.56.0",
 		"eslint": "10",
-		"prettier": "^3.8.1",
+		"prettier": "3.8.1",
 		"ts-prune": "0.10.3",
 		"typescript": "5.9.3",
-		"typescript-eslint": "^8.56.0"
+		"typescript-eslint": "8.56.0"
 	}
 }

package/src/index.ts

@@ -21,25 +21,25 @@ import { noUnnecessaryDiv } from "./rules/no-unnecessary-div";
 
 export default {
 	rules: {
-		"no-nested-jsx-return": noNestedJSXReturn,
 		"explicit-object-types": explicitObjectTypes,
-		"sort-keys-fixable": sortKeysFixable,
-		"no-transition-cssproperties": noTransitionCSSProperties,
-		"no-explicit-return-type": noExplicitReturnTypes,
-		"max-jsxnesting": maxJSXNesting,
-		"seperate-style-files": seperateStyleFiles,
-		"no-unnecessary-key": noUnnecessaryKey,
-		"sort-exports": sortExports,
+		"inline-style-limit": inlineStyleLimit,
 		"localize-react-props": localizeReactProps,
-		"no-or-none-component": noOrNoneComponent,
+		"max-depth-extended": maxDepthExtended,
+		"max-jsxnesting": maxJSXNesting,
+		"min-var-length": minVarLength,
 		"no-button-navigation": noButtonNavigation,
+		"no-explicit-return-type": noExplicitReturnTypes,
+		"no-inline-prop-types": noInlinePropTypes,
 		"no-multi-style-objects": noMultiStyleObjects,
+		"no-nested-jsx-return": noNestedJSXReturn,
+		"no-or-none-component": noOrNoneComponent,
+		"no-transition-cssproperties": noTransitionCSSProperties,
+		"no-unnecessary-div": noUnnecessaryDiv,
+		"no-unnecessary-key": noUnnecessaryKey,
 		"no-useless-function": noUselessFunction,
-		"min-var-length": minVarLength,
-		"max-depth-extended": maxDepthExtended,
-		"spring-naming-convention": springNamingConvention,
-		"inline-style-limit": inlineStyleLimit,
-		"no-inline-prop-types": noInlinePropTypes,
-		"no-unnecessary-div": noUnnecessaryDiv
+		"seperate-style-files": seperateStyleFiles,
+		"sort-exports": sortExports,
+		"sort-keys-fixable": sortKeysFixable,
+		"spring-naming-convention": springNamingConvention
 	}
 };

package/src/rules/explicit-object-types.ts

@@ -4,31 +4,17 @@ type Options = [];
 type MessageIds = "objectLiteralNeedsType" | "arrayOfObjectLiteralsNeedsType";
 
 export const explicitObjectTypes: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Require explicit type annotations for object literals and arrays of object literals"
-		},
-		schema: [],
-		messages: {
-			objectLiteralNeedsType:
-				"Object literal must have an explicit type annotation.",
-			arrayOfObjectLiteralsNeedsType:
-				"Array of object literals must have an explicit type annotation."
-		}
-	},
-	defaultOptions: [],
 	create(context) {
 		/**
 		 * Returns true if the node is an object literal.
 		 * @param {ASTNode} node The AST node to check.
 		 */
-		function isObjectLiteral(
+		const isObjectLiteral = (
 			node: TSESTree.Node | null | undefined
-		): node is TSESTree.ObjectExpression {
-			return !!node && node.type === "ObjectExpression";
-		}
+		): node is TSESTree.ObjectExpression =>
+			node !== null &&
+			node !== undefined &&
+			node.type === "ObjectExpression";
 
 		return {
 			VariableDeclarator(node: TSESTree.VariableDeclarator) {
@@ -40,34 +26,50 @@ export const explicitObjectTypes: TSESLint.RuleModule<MessageIds, Options> = {
 					return;
 
 				// Check if the initializer is an object literal.
-				if (isObjectLiteral(node.init)) {
-					if (node.id.type === "Identifier") {
-						context.report({
-							node: node.id,
-							messageId: "objectLiteralNeedsType"
-						});
-					}
+				if (
+					isObjectLiteral(node.init) &&
+					node.id.type === "Identifier"
+				) {
+					context.report({
+						messageId: "objectLiteralNeedsType",
+						node: node.id
+					});
 					return;
 				}
 
 				// Check if the initializer is an array literal containing any object literals.
-				if (node.init.type === "ArrayExpression") {
-					const hasObjectLiteral = node.init.elements.some(
-						(element) => {
-							if (!element || element.type === "SpreadElement")
-								return false;
-							return isObjectLiteral(element);
-						}
-					);
+				if (node.init.type !== "ArrayExpression") {
+					return;
+				}
 
-					if (hasObjectLiteral && node.id.type === "Identifier") {
-						context.report({
-							node: node.id,
-							messageId: "arrayOfObjectLiteralsNeedsType"
-						});
-					}
+				const hasObjectLiteral = node.init.elements.some((element) => {
+					if (!element || element.type === "SpreadElement")
+						return false;
+					return isObjectLiteral(element);
+				});
+
+				if (hasObjectLiteral && node.id.type === "Identifier") {
+					context.report({
+						messageId: "arrayOfObjectLiteralsNeedsType",
+						node: node.id
+					});
 				}
 			}
 		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description:
+				"Require explicit type annotations for object literals and arrays of object literals"
+		},
+		messages: {
+			arrayOfObjectLiteralsNeedsType:
+				"Array of object literals must have an explicit type annotation.",
+			objectLiteralNeedsType:
+				"Object literal must have an explicit type annotation."
+		},
+		schema: [],
+		type: "problem"
 	}
 };

package/src/rules/inline-style-limit.ts

@@ -1,50 +1,18 @@
 import { TSESLint, TSESTree } from "@typescript-eslint/utils";
 
+const DEFAULT_MAX_KEYS = 3;
+
 type Options = [number | { maxKeys?: number }];
 type MessageIds = "extractStyle";
 
 export const inlineStyleLimit: TSESLint.RuleModule<MessageIds, Options> = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Disallow inline style objects with too many keys and encourage extracting them"
-		},
-		schema: [
-			{
-				anyOf: [
-					{
-						type: "number"
-					},
-					{
-						type: "object",
-						properties: {
-							maxKeys: {
-								type: "number",
-								description:
-									"Maximum number of keys allowed in an inline style object before it must be extracted."
-							}
-						},
-						additionalProperties: false
-					}
-				]
-			}
-		],
-		messages: {
-			extractStyle:
-				"Inline style objects should be extracted into a separate object or file when containing more than {{max}} keys."
-		}
-	},
-
-	defaultOptions: [3],
-
 	create(context) {
-		const option = context.options[0];
+		const [option] = context.options;
 		// If a number is passed directly, use it as maxKeys; otherwise, extract maxKeys from the object (default to 3)
 		const maxKeys =
 			typeof option === "number"
 				? option
-				: (option && option.maxKeys) || 3;
+				: (option && option.maxKeys) || DEFAULT_MAX_KEYS;
 
 		return {
 			JSXAttribute(node: TSESTree.JSXAttribute) {
@@ -58,29 +26,63 @@ export const inlineStyleLimit: TSESLint.RuleModule<MessageIds, Options> = {
 
 				// Ensure the value is a JSX expression container with an object literal
 				if (
-					node.value &&
-					node.value.type === "JSXExpressionContainer" &&
-					node.value.expression &&
-					node.value.expression.type === "ObjectExpression"
+					!node.value ||
+					node.value.type !== "JSXExpressionContainer" ||
+					!node.value.expression ||
+					node.value.expression.type !== "ObjectExpression"
 				) {
-					const styleObject = node.value.expression;
+					return;
+				}
 
-					// Count only "Property" nodes (ignoring spread elements or others)
-					const keyCount = styleObject.properties.filter(
-						(prop): prop is TSESTree.Property =>
-							prop.type === "Property"
-					).length;
+				const styleObject = node.value.expression;
 
-					// Report only if the number of keys exceeds the allowed maximum
-					if (keyCount > maxKeys) {
-						context.report({
-							node,
-							messageId: "extractStyle",
-							data: { max: maxKeys }
-						});
-					}
+				// Count only "Property" nodes (ignoring spread elements or others)
+				const keyCount = styleObject.properties.filter(
+					(prop): prop is TSESTree.Property =>
+						prop.type === "Property"
+				).length;
+
+				// Report only if the number of keys exceeds the allowed maximum
+				if (keyCount > maxKeys) {
+					context.report({
+						data: { max: maxKeys },
+						messageId: "extractStyle",
+						node
+					});
 				}
 			}
 		};
+	},
+	defaultOptions: [DEFAULT_MAX_KEYS],
+	meta: {
+		docs: {
+			description:
+				"Disallow inline style objects with too many keys and encourage extracting them"
+		},
+		messages: {
+			extractStyle:
+				"Inline style objects should be extracted into a separate object or file when containing more than {{max}} keys."
+		},
+		schema: [
+			{
+				anyOf: [
+					{
+						type: "number"
+					},
+					{
+						additionalProperties: false,
+						properties: {
+							maxKeys: {
+								description:
+									"Maximum number of keys allowed in an inline style object before it must be extracted.",
+								type: "number"
+							}
+						},
+						type: "object"
+					}
+				]
+			}
+		],
+		type: "suggestion"
 	}
 };