@blumintinc/eslint-plugin-blumint 1.18.6 → 1.18.8

package/lib/index.js

@@ -218,7 +218,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.18.6',
+        version: '1.18.8',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/class-methods-read-top-to-bottom.js

@@ -5,7 +5,10 @@ const createRule_1 = require("../utils/createRule");
 const ClassGraphBuilder_1 = require("../utils/graph/ClassGraphBuilder");
 function getMemberName(member) {
     if (member.type === 'MethodDefinition' ||
-        member.type === 'PropertyDefinition') {
+        member.type === 'PropertyDefinition' ||
+        member.type === 'TSAbstractMethodDefinition' ||
+        member.type === 'TSAbstractPropertyDefinition' ||
+        member.type === 'TSAbstractAccessorProperty') {
         return member.key.type === 'Identifier' ? member.key.name : null;
     }
     return null;
@@ -43,10 +46,7 @@ exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
                 const graphBuilder = new ClassGraphBuilder_1.ClassGraphBuilder(className, node);
                 const sortedOrder = graphBuilder.memberNamesSorted;
                 const actualOrder = node.body
-                    .map((member) => member.type === 'MethodDefinition' ||
-                    member.type === 'PropertyDefinition'
-                    ? member.key.name
-                    : null)
+                    .map((member) => getMemberName(member))
                     .filter(Boolean);
                 // Check if we have the same number of methods in both arrays
                 // This prevents issues with similar method names being treated as duplicates
@@ -58,6 +58,19 @@ exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
                 if (uniqueMethodNames.size !== actualOrder.length) {
                     return; // Skip if there are actual duplicates
                 }
+                // Defense-in-depth: the fixer overwrites the ENTIRE class body from the
+                // tracked members. If any member is not tracked (unknown node type,
+                // non-Identifier/computed key, static block, index signature, etc.), it
+                // would be silently dropped by the rewrite. Bail rather than emit a body
+                // that deletes source the rule does not track.
+                const trackedNames = new Set(sortedOrder);
+                const allMembersRepresented = node.body.every((member) => {
+                    const name = getMemberName(member);
+                    return name !== null && trackedNames.has(name);
+                });
+                if (!allMembersRepresented) {
+                    return;
+                }
                 for (let i = 0; i < actualOrder.length; i++) {
                     const actualMember = actualOrder[i];
                     const expectedMember = sortedOrder[i];

package/lib/rules/enforce-positive-naming.js

@@ -729,6 +729,8 @@ const UN_EXCEPTIONS = [
     'universes',
     'universities',
     'university',
+    'unknown',
+    'unknowns',
     'unless',
     'until',
     'unto',
@@ -1063,16 +1065,33 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                             if (directMatch) {
                                 return { isNegative: true, alternatives: directMatch };
                             }
+                            const restOfName = name.replace(pattern, '');
+                            const capitalizedRest = restOfName
+                                ? restOfName.charAt(0).toUpperCase() + restOfName.slice(1)
+                                : '';
                             const alternatives = BOOLEAN_POSITIVE_ALTERNATIVES[key] || [];
                             if (alternatives.length > 0) {
                                 // Suggest the positive version with the rest of the name
-                                const restOfName = name.replace(pattern, '');
-                                const suggestedAlternatives = alternatives.map((alt) => `${alt}${restOfName.charAt(0).toUpperCase() + restOfName.slice(1)}`);
+                                const suggestedAlternatives = alternatives.map((alt) => `${alt}${capitalizedRest}`);
                                 return {
                                     isNegative: true,
                                     alternatives: suggestedAlternatives,
                                 };
                             }
+                            // No hand-maintained mapping covers this boolean+negative prefix
+                            // combination (e.g. `hasUn`, `canNo`). Derive the positive form by
+                            // dropping the negative prefix while keeping the boolean prefix
+                            // (hasUnavailableItems -> hasAvailableItems), mirroring the
+                            // `is`-prefix behavior so the report always names a real
+                            // alternative rather than the "a positive alternative" placeholder.
+                            const matched = name.match(pattern);
+                            if (matched && capitalizedRest) {
+                                const positivePrefix = matched[0].slice(0, matched[0].length - prefix.length);
+                                return {
+                                    isNegative: true,
+                                    alternatives: [`${positivePrefix}${capitalizedRest}`],
+                                };
+                            }
                             return {
                                 isNegative: true,
                                 alternatives: ['a positive alternative'],

package/lib/rules/react-memoize-literals.js

@@ -430,14 +430,18 @@ function buildMemoSuggestions(node, descriptor, sourceCode) {
  * style data consumed by a library rather than compared by reference (MUI `sx`
  * or the standard `style` prop).
  *
- * Walks up from the literal only through positions where it remains the
- * attribute's resolved value: conditional branches (`sx={c ? {…} : {…}}`),
- * logical fallbacks (`sx={c && {…}}`), array entries (MUI accepts `sx` arrays),
- * and expression wrappers (`{…} as const`, parentheses). Any other parent — a
- * function call, an object property, a spread — means the reference is observed
- * or transformed before reaching the attribute, so the walk stops and the
- * literal stays reported. This keeps the exemption tied to genuine style values
- * without silencing unrelated literals that merely appear deeper in the tree.
+ * Walks up from the literal only through positions where it remains part of the
+ * attribute's style value: conditional branches (`sx={c ? {…} : {…}}`), logical
+ * fallbacks (`sx={c && {…}}`), array entries (MUI accepts `sx` arrays), nested
+ * object property values (`sx={{ display: { xs: 'none', md: 'inline' } }}` —
+ * MUI's responsive breakpoint syntax), and expression wrappers (`{…} as const`,
+ * parentheses). MUI reprocesses the entire `sx`/`style` object subtree on every
+ * render, so nested values benefit no more from referential stability than the
+ * top-level object does. Any other parent — a function call, a spread — means
+ * the reference is observed or transformed before reaching the attribute, so the
+ * walk stops and the literal stays reported. This keeps the exemption tied to
+ * genuine style values without silencing unrelated literals that merely appear
+ * deeper in the tree.
  */
 function isStyleJSXAttributeValue(node) {
     let current = node;
@@ -474,6 +478,18 @@ function isStyleJSXAttributeValue(node) {
                 }
                 break;
             }
+            case utils_1.AST_NODE_TYPES.Property: {
+                if (parent.value !== current) {
+                    return false;
+                }
+                break;
+            }
+            case utils_1.AST_NODE_TYPES.ObjectExpression: {
+                if (!parent.properties.some((property) => property === current)) {
+                    return false;
+                }
+                break;
+            }
             default: {
                 if (!isExpressionWrapper(parent) || parent.expression !== current) {
                     return false;

package/lib/utils/graph/ClassGraphBuilder.js

@@ -36,7 +36,11 @@ class ClassGraphBuilder {
         });
     }
     static isClassMember(node) {
-        return (node.type === 'MethodDefinition' || node.type === 'PropertyDefinition');
+        return (node.type === 'MethodDefinition' ||
+            node.type === 'PropertyDefinition' ||
+            node.type === 'TSAbstractMethodDefinition' ||
+            node.type === 'TSAbstractPropertyDefinition' ||
+            node.type === 'TSAbstractAccessorProperty');
     }
     addMemberToGraph(member) {
         const name = member.key.name;
@@ -48,6 +52,10 @@ class ClassGraphBuilder {
         if (member.type === 'MethodDefinition') {
             return member.kind === 'constructor' ? 'constructor' : 'method';
         }
+        // Abstract methods can never be constructors, so they are always methods.
+        if (member.type === 'TSAbstractMethodDefinition') {
+            return 'method';
+        }
         return 'property';
     }
     static createGraphNode(name, type, accessibility, isStatic = false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.18.6",
+  "version": "1.18.8",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.18.8",
+    "date": "2026-07-10T21:29:12.501Z",
+    "rules": [
+      {
+        "name": "enforce-positive-naming",
+        "changeType": "fix",
+        "issues": [
+          1281
+        ],
+        "summary": "whitelist \"unknown\" and derive real suggestions for non-is prefixes (closes #1281)"
+      },
+      {
+        "name": "react-memoize-literals",
+        "changeType": "fix",
+        "issues": [
+          1280
+        ],
+        "summary": "exempt nested object literals inside sx/style values (closes #1280)"
+      }
+    ]
+  },
+  {
+    "version": "1.18.7",
+    "date": "2026-07-10T02:31:44.580Z",
+    "rules": [
+      {
+        "name": "class-methods-read-top-to-bottom",
+        "changeType": "fix",
+        "issues": [
+          1279
+        ],
+        "summary": "preserve abstract members during autofix (closes #1279)"
+      }
+    ]
+  },
   {
     "version": "1.18.6",
     "date": "2026-07-09T08:45:37.007Z",