eslint-plugin-absolute 0.1.6 → 0.2.1

package/src/rules/spring-naming-convention.ts

@@ -0,0 +1,160 @@
+import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+
+type Options = [];
+type MessageIds =
+	| "firstMustEndWithSprings"
+	| "firstMustHaveBase"
+	| "secondMustMatch"
+	| "pluralRequired";
+
+const SPRINGS_SUFFIX = "Springs";
+
+const checkUseSpring = (
+	context: TSESLint.RuleContext<MessageIds, Options>,
+	firstElem: TSESTree.Identifier,
+	secondElem: TSESTree.Identifier
+) => {
+	const firstName = firstElem.name;
+	const secondName = secondElem.name;
+
+	if (!firstName.endsWith(SPRINGS_SUFFIX)) {
+		context.report({
+			messageId: "firstMustEndWithSprings",
+			node: firstElem
+		});
+		return;
+	}
+
+	const base = firstName.slice(0, -SPRINGS_SUFFIX.length);
+	if (!base) {
+		context.report({
+			messageId: "firstMustHaveBase",
+			node: firstElem
+		});
+		return;
+	}
+
+	const expectedSecond = `${base}Api`;
+	if (secondName !== expectedSecond) {
+		context.report({
+			data: { expected: expectedSecond },
+			messageId: "secondMustMatch",
+			node: secondElem
+		});
+	}
+};
+
+const checkUseSprings = (
+	context: TSESLint.RuleContext<MessageIds, Options>,
+	firstElem: TSESTree.Identifier,
+	secondElem: TSESTree.Identifier
+) => {
+	const firstName = firstElem.name;
+	const secondName = secondElem.name;
+
+	if (!firstName.endsWith(SPRINGS_SUFFIX)) {
+		context.report({
+			messageId: "firstMustEndWithSprings",
+			node: firstElem
+		});
+		return;
+	}
+
+	const basePlural = firstName.slice(0, -SPRINGS_SUFFIX.length);
+	if (!basePlural) {
+		context.report({
+			messageId: "firstMustHaveBase",
+			node: firstElem
+		});
+		return;
+	}
+
+	if (!basePlural.endsWith("s")) {
+		context.report({
+			messageId: "pluralRequired",
+			node: firstElem
+		});
+		return;
+	}
+
+	const expectedSecond = `${basePlural}Api`;
+	if (secondName !== expectedSecond) {
+		context.report({
+			data: { expected: expectedSecond },
+			messageId: "secondMustMatch",
+			node: secondElem
+		});
+	}
+};
+
+export const springNamingConvention: TSESLint.RuleModule<MessageIds, Options> =
+	{
+		create(context) {
+			return {
+				VariableDeclarator(node: TSESTree.VariableDeclarator) {
+					const { init } = node;
+
+					if (
+						!init ||
+						init.type !== "CallExpression" ||
+						init.callee.type !== "Identifier"
+					) {
+						return;
+					}
+
+					const hookName = init.callee.name;
+					if (hookName !== "useSpring" && hookName !== "useSprings") {
+						return;
+					}
+
+					if (node.id.type !== "ArrayPattern") {
+						return;
+					}
+
+					const { elements } = node.id;
+					if (elements.length < 2) {
+						return;
+					}
+
+					const [firstElem, secondElem] = elements;
+
+					if (
+						!firstElem ||
+						firstElem.type !== "Identifier" ||
+						!secondElem ||
+						secondElem.type !== "Identifier"
+					) {
+						return;
+					}
+
+					if (hookName === "useSpring") {
+						checkUseSpring(context, firstElem, secondElem);
+						return;
+					}
+
+					if (hookName === "useSprings") {
+						checkUseSprings(context, firstElem, secondElem);
+					}
+				}
+			};
+		},
+		defaultOptions: [],
+		meta: {
+			docs: {
+				description:
+					"Enforce correct naming for useSpring and useSprings hook destructuring"
+			},
+			messages: {
+				firstMustEndWithSprings:
+					"The first variable must end with 'Springs'.",
+				firstMustHaveBase:
+					"The first variable must have a non-empty name before 'Springs'.",
+				pluralRequired:
+					"The first variable for useSprings should be plural (ending with 's') before 'Springs'.",
+				secondMustMatch:
+					"The second variable must be named '{{expected}}'."
+			},
+			schema: [],
+			type: "problem"
+		}
+	};

package/tsconfig.json

@@ -8,7 +8,10 @@
 		"moduleResolution": "bundler",
 		"skipLibCheck": true,
 		"strict": true,
-		"target": "ESNext", // "noUncheckedIndexedAccess": true,
+		"target": "ESNext",
+		"noUncheckedIndexedAccess": true,
+		"incremental": true,
+		"tsBuildInfoFile": ".absolutejs/tsconfig.tsbuildinfo",
 		"types": ["bun-types"]
 	}
 }

package/src/index.js

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

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

@@ -1,54 +0,0 @@
-export default {
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Require explicit type annotations for object literals and arrays of object literals",
-			recommended: false
-		},
-		schema: []
-	},
-	create(context) {
-		/**
-		 * Returns true if the node is an object literal.
-		 * @param {ASTNode} node The AST node to check.
-		 */
-		function isObjectLiteral(node) {
-			return node && node.type === "ObjectExpression";
-		}
-
-		return {
-			VariableDeclarator(node) {
-				// Skip if there's no initializer.
-				if (!node.init) return;
-
-				// Skip if the variable already has a type annotation.
-				if (node.id && node.id.typeAnnotation) return;
-
-				// Check if the initializer is an object literal.
-				if (isObjectLiteral(node.init)) {
-					context.report({
-						node: node.id,
-						message:
-							"Object literal must have an explicit type annotation."
-					});
-					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) => element && isObjectLiteral(element)
-					);
-					if (hasObjectLiteral) {
-						context.report({
-							node: node.id,
-							message:
-								"Array of object literals must have an explicit type annotation."
-						});
-					}
-				}
-			}
-		};
-	}
-};

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

@@ -1,77 +0,0 @@
-export default {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description:
-				"Disallow inline style objects with too many keys and encourage extracting them",
-			category: "Best Practices",
-			recommended: false
-		},
-		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."
-		}
-	},
-
-	create(context) {
-		const option = context.options[0];
-		// 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;
-
-		return {
-			JSXAttribute(node) {
-				// Check if the attribute name is 'style'
-				if (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"
-				) {
-					const styleObject = node.value.expression;
-
-					// Count only "Property" nodes (ignoring spread elements or others)
-					const keyCount = styleObject.properties.filter(
-						(prop) => prop.type === "Property"
-					).length;
-
-					// Report only if the number of keys exceeds the allowed maximum
-					if (keyCount > maxKeys) {
-						context.report({
-							node,
-							messageId: "extractStyle",
-							data: { max: maxKeys }
-						});
-					}
-				}
-			}
-		};
-	}
-};