@blumintinc/eslint-plugin-blumint 1.20.59 → 1.20.61

package/lib/index.js

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

package/lib/rules/enforce-singular-type-names.js

@@ -41,19 +41,36 @@ const NON_PLURALIZABLE_SUFFIXES = [
  * the reference itself as a container.
  */
 const ARRAY_GENERIC_NAMES = new Set(['Array', 'ReadonlyArray']);
+/**
+ * Union members that only express absence. Stripping them keeps a nullable
+ * container recognisable as a container: `T[]` and `T[] | null` describe the
+ * same collection, so they must not disagree about whether a plural name fits.
+ */
+const NULLISH_TYPE_NODES = new Set([
+    utils_1.AST_NODE_TYPES.TSNullKeyword,
+    utils_1.AST_NODE_TYPES.TSUndefinedKeyword,
+]);
+/**
+ * Shared budget for wrapper peeling and union recursion. Wrapper nesting is
+ * finite in real code; the cap only guards against a pathological cycle. Every
+ * peel and every descent into a union member spends one unit, so the recursion
+ * a union introduces stays bounded by the same constant.
+ */
+const MAX_TYPE_DEPTH = 10;
 /**
  * Returns true when the type alias RHS resolves to a container shape — a
  * `TSArrayType` (`Foo[]`) or `TSTupleType` (`[A, B]`) — for which a plural name
  * is the correct, self-documenting choice. Sees through identity-ish wrappers
  * over the same shape: the `readonly` type operator, parenthesized types, and
  * the `Readonly<T>` utility type; `Array<T>`/`ReadonlyArray<T>` are containers
- * outright.
+ * outright. A union whose non-nullish members are all containers counts too.
+ *
+ * @param depth Budget already spent by an enclosing wrapper or union member.
  */
-function resolvesToContainerType(node) {
+function resolvesToContainerType(node, depth = 0) {
     let current = node;
     // Fixpoint loop: peel identity wrappers until a concrete shape is reached.
-    // Wrappers are finite; the cap only guards against a pathological cycle.
-    for (let i = 0; i < 10; i++) {
+    for (let i = depth; i < MAX_TYPE_DEPTH; i++) {
         switch (current.type) {
             case utils_1.AST_NODE_TYPES.TSArrayType:
             case utils_1.AST_NODE_TYPES.TSTupleType:
@@ -66,6 +83,18 @@ function resolvesToContainerType(node) {
                 current = operator.typeAnnotation;
                 continue;
             }
+            case utils_1.AST_NODE_TYPES.TSUnionType: {
+                const union = current;
+                const substantive = union.types.filter((member) => !NULLISH_TYPE_NODES.has(member.type));
+                // `null | undefined` holds no collection at all.
+                if (substantive.length === 0)
+                    return false;
+                // Requiring EVERY remaining member to be a container keeps the
+                // exemption conservative: a mixed union such as `Edge[] | Edge` can hold
+                // a single value, so a plural name there still misleads. Members recurse
+                // with the spent budget so nesting cannot escape the cap.
+                return substantive.every((member) => resolvesToContainerType(member, i + 1));
+            }
             case utils_1.AST_NODE_TYPES.TSTypeReference: {
                 const ref = current;
                 if (ref.typeName.type !== utils_1.AST_NODE_TYPES.Identifier)

package/lib/rules/prefer-fragment-shorthand.js

@@ -8,6 +8,11 @@ exports.preferFragmentShorthand = (0, createRule_1.createRule)({
         return {
             JSXElement(node) {
                 const openingElement = node.openingElement;
+                // The <> shorthand cannot carry attributes, so an attributed fragment
+                // (key, spread, ...) has no valid rewrite and must not be reported.
+                if (openingElement.attributes.length > 0) {
+                    return;
+                }
                 if (openingElement.name.type === 'JSXMemberExpression' &&
                     openingElement.name.object.type === 'JSXIdentifier' &&
                     openingElement.name.object.name === 'React' &&
@@ -17,11 +22,18 @@ exports.preferFragmentShorthand = (0, createRule_1.createRule)({
                         node,
                         messageId: 'preferShorthand',
                         data: { fragmentName: 'React.Fragment' },
-                        fix: (fixer) => [
-                            fixer.replaceTextRange(openingElement.range, '<>'),
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            fixer.replaceTextRange(node.closingElement.range, '</>'),
-                        ],
+                        fix: (fixer) => {
+                            const { closingElement } = node;
+                            // A self-closing <React.Fragment /> has no children and no
+                            // closing element; <></> is its equivalent shorthand.
+                            if (!closingElement) {
+                                return fixer.replaceText(node, '<></>');
+                            }
+                            return [
+                                fixer.replaceTextRange(openingElement.range, '<>'),
+                                fixer.replaceTextRange(closingElement.range, '</>'),
+                            ];
+                        },
                     });
                 }
             },

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.61",
+    "date": "2026-08-01T06:30:50.860Z",
+    "rules": [
+      {
+        "name": "prefer-fragment-shorthand",
+        "changeType": "fix",
+        "issues": [
+          1552
+        ],
+        "summary": "don't report attributed fragments (closes #1552)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.60",
+    "date": "2026-08-01T05:06:58.616Z",
+    "rules": [
+      {
+        "name": "enforce-singular-type-names",
+        "changeType": "fix",
+        "issues": [
+          1550
+        ],
+        "summary": "keep the container exemption when nullable (closes #1550)"
+      }
+    ]
+  },
   {
     "version": "1.20.59",
     "date": "2026-08-01T04:43:54.837Z",