eslint-plugin-absolute 0.1.6 → 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.1.6",
+	"version": "0.2.1",
 	"description": "ESLint plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",
@@ -11,21 +11,24 @@
 	"license": "CC BY-NC 4.0",
 	"author": "Alex Kahn",
 	"scripts": {
-		"test": "echo \"Error: no test specified\" && exit 1",
-		"build": "rm -rf dist && bun build src/index.js --outdir dist --splitting --target=bun",
-		"format": "prettier --write \"./**/*.{js,jsx,ts,tsx,css,json,mjs}\"",
-		"dev": "bun run --watch example/server.ts",
+		"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": "absolutejs prettier --write",
 		"release": "bun run format && bun run build && bun publish",
 		"prune": "ts-prune --error",
-		"type-check": "bun run tsc --noEmit"
+		"lint": "bun run build && bun run absolutejs eslint",
+		"typecheck": "bun run tsc --noEmit"
 	},
 	"devDependencies": {
-		"eslint": "9.23.0",
-		"prettier": "3.5.3",
+		"@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",
 		"ts-prune": "0.10.3",
-		"typescript": "5.8.2",
-		"@types/react": "19.1.0",
-		"@types/bun": "latest",
-		"typescript-eslint": "8.28.0"
+		"typescript": "5.9.3",
+		"typescript-eslint": "8.56.0"
 	}
 }

package/src/index.ts

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

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

@@ -0,0 +1,75 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+type Options = [];
+type MessageIds = "objectLiteralNeedsType" | "arrayOfObjectLiteralsNeedsType";
+
+export const explicitObjectTypes: TSESLint.RuleModule<MessageIds, Options> = {
+	create(context) {
+		/**
+		 * Returns true if the node is an object literal.
+		 * @param {ASTNode} node The AST node to check.
+		 */
+		const isObjectLiteral = (
+			node: TSESTree.Node | null | undefined
+		): node is TSESTree.ObjectExpression =>
+			node !== null &&
+			node !== undefined &&
+			node.type === "ObjectExpression";
+
+		return {
+			VariableDeclarator(node: TSESTree.VariableDeclarator) {
+				// Skip if there's no initializer.
+				if (!node.init) return;
+
+				// Skip if the variable already has a type annotation.
+				if (node.id.type === "Identifier" && node.id.typeAnnotation)
+					return;
+
+				// Check if the initializer is an object literal.
+				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") {
+					return;
+				}
+
+				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

@@ -0,0 +1,88 @@
+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> = {
+	create(context) {
+		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) || DEFAULT_MAX_KEYS;
+
+		return {
+			JSXAttribute(node: TSESTree.JSXAttribute) {
+				// Check if the attribute name is 'style'
+				if (
+					node.name.type !== "JSXIdentifier" ||
+					node.name.name !== "style"
+				) {
+					return;
+				}
+
+				// 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"
+				) {
+					return;
+				}
+
+				const styleObject = node.value.expression;
+
+				// 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"
+	}
+};