@dineroregnskab/eslint-plugin-custom-rules 3.0.0 → 3.0.1

package/eslint-plugin-custom-rules.js

@@ -9,6 +9,8 @@ const rules = {
     'signal-naming-convention': require('./rules/signal-naming-convention'),
     'filter-before-take': require('./rules/filter-before-take'),
     'no-viewencapsulation-none': require('./rules/no-viewencapsulation-none'),
+    'enum-comparison-reminder': require('./rules/enum-comparison-reminder'),
+    'enum-lowercase': require('./rules/enum-lowercase'),
 };
 
 console.log('Custom ESLint rules loaded:', Object.keys(rules)); // Debug log

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dineroregnskab/eslint-plugin-custom-rules",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "ESLint plugin with custom rules for Dinero Regnskab",
   "main": "eslint-plugin-custom-rules.js",
   "scripts": {

package/rules/enum-comparison-reminder.js

@@ -0,0 +1,103 @@
+module.exports = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Reminder to convert backend data to lower case when enum comparisons are made.",
+        },
+        schema: [],
+        messages: {
+            enumComparisonTip: "Remember '{{property}}' should be converted to lower case in the model class if the data is from a HTTP response, to ensure a valid comparison."
+        }
+    },
+    create(context) {
+        // Handle TypeScript Files
+        function checkTsEnumComparisons(node) {
+            if (node.operator !== "===" && node.operator !== "!==") {
+                return;
+            }
+
+            const left = node.left;
+            const right = node.right;
+
+            function isPascalCase(value) {
+                return /^[A-Z][a-zA-Z0-9]*$/.test(value);
+            }
+
+            function isPropertyAccess(node) {
+                return node.type === "MemberExpression" && node.object && node.property;
+            }
+
+            function isEnumReference(node) {
+                return isPropertyAccess(node) && node.object.type === "Identifier" && isPascalCase(node.object.name);
+            }
+
+            if (
+                (isPropertyAccess(left) && isEnumReference(right)) ||
+                (isPropertyAccess(right) && isEnumReference(left))
+            ) {
+                const property = isPropertyAccess(left) ? context.getSourceCode().getText(left) : context.getSourceCode().getText(right);
+                const enumValue = isEnumReference(left) ? context.getSourceCode().getText(left) : context.getSourceCode().getText(right);
+
+                context.report({
+                    node,
+                    messageId: "enumComparisonTip",
+                    data: {
+                        property,
+                        enumValue
+                    }
+                });
+            }
+        }
+
+        // Handle Angular Templates (`*.html`)
+        function checkHtmlEnumComparisons(node) {
+            if (
+                node.type !== "Binary" &&
+                node.type !== "Conditional" // Some AST parsers use ConditionalExpression
+            ) {
+                return;
+            }
+
+            // Ensure we're checking the correct properties
+            const operator = node.operator || node.operation; // Adjust for Angular's AST
+            if (operator !== "===" && operator !== "!==") {
+                return;
+            }
+
+            const left = node.left;
+            const right = node.right;
+
+            function isPascalCase(value) {
+                return typeof value === "string" && /^[A-Z][a-zA-Z0-9]*$/.test(value);
+            }
+
+            function extractNodeText(node) {
+                if (node && typeof node === "object" && node.name) {
+                    return node.name;
+                }
+                return "";
+            }
+
+            const leftValue = extractNodeText(left);
+            const rightValue = extractNodeText(right);
+
+            if (isPascalCase(leftValue) || isPascalCase(rightValue)) {
+                context.report({
+                    node,
+                    messageId: "enumComparisonTip",
+                    data: {
+                        property: leftValue || rightValue,
+                        enumValue: rightValue || leftValue
+                    }
+                });
+            }
+        }
+
+        return {
+            BinaryExpression: checkTsEnumComparisons, // ✅ TypeScript file support
+            Binary: checkHtmlEnumComparisons, // ✅ Angular v18 template (`@if`) support
+            ConditionalExpression: checkHtmlEnumComparisons // Support variations
+        };
+    }
+};
+

package/rules/enum-lowercase.js

@@ -0,0 +1,50 @@
+module.exports = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Warn when an enum string value is not in full lowercase.",
+        },
+        schema: [],
+        messages: {
+            enumLowercase:
+                "Enum value '{{enumKey}}' should be in full lowercase (e.g., '{{suggestedValue}}'). Avoid uppercase, spaces, dashes, or special characters."
+        }
+    },
+    create(context) {
+        return {
+            VariableDeclarator(node) {
+                // Check if it's an Enum declaration
+                if (
+                    node.init &&
+                    node.init.type === "ObjectExpression" &&
+                    node.id.type === "Identifier"
+                ) {
+                    node.init.properties.forEach((prop) => {
+                        if (
+                            prop.key &&
+                            prop.key.type === "Identifier" &&
+                            prop.value &&
+                            prop.value.type === "Literal" &&
+                            typeof prop.value.value === "string"
+                        ) {
+                            const enumKey = prop.key.name;
+                            const enumValue = prop.value.value;
+
+                            // Check if the value is not fully lowercase
+                            if (!/^[a-z]+$/.test(enumValue)) {
+                                context.report({
+                                    node: prop.value,
+                                    messageId: "enumLowercase",
+                                    data: {
+                                        enumKey,
+                                        suggestedValue: enumValue.toLowerCase(),
+                                    },
+                                });
+                            }
+                        }
+                    });
+                }
+            }
+        };
+    }
+};