@blumintinc/eslint-plugin-blumint 1.20.75 → 1.20.77

package/lib/index.js

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

package/lib/rules/no-type-assertion-returns.js

@@ -156,6 +156,17 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             if (node.parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
                 return true;
             }
+            // An assertion whose parent is another assertion is an inner link of a chain
+            // (`x as unknown as T`). The chain expresses ONE violation, and only the
+            // outermost link describes the type that actually reaches the caller, so it
+            // alone carries the report — otherwise the author is told to fix a cast to
+            // "unknown", which is not actionable. Exempting inner links also makes the
+            // report count independent of body style: an expression-bodied arrow has no
+            // ReturnStatement node, so its chain yields a single report either way.
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                node.parent?.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                return true;
+            }
             // If the parent is an arrow function, we already handle it in ArrowFunctionExpression
             if (node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
                 return true;
@@ -268,11 +279,9 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     if (mergedOptions.allowAsConst && isAsConstAssertion(node.argument)) {
                         return;
                     }
-                    // For nested type assertions, only report the outermost one
-                    if (node.argument.expression.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
-                        reportTypeAssertion(node.argument);
-                        return;
-                    }
+                    // The returned expression is the outermost link of any assertion chain, so
+                    // reporting it here yields one report naming the final asserted type; inner
+                    // links are exempted in shouldAllowTypeAssertion.
                     reportTypeAssertion(node.argument);
                 }
                 // Check for type assertions using angle bracket syntax

package/lib/rules/prefer-spread-over-reassembly.js

@@ -147,23 +147,57 @@ function collectObjectForwardedFields(objectExpression, destructuredNames) {
     }
     return forwarded;
 }
-function getSingleTarget(fn) {
-    const body = fn.body;
-    // Concise arrow: `(props) => <X />`
-    if (body.type === utils_1.AST_NODE_TYPES.JSXElement) {
+/**
+ * Wrappers that exist only for the type checker: they compile away entirely, so
+ * the value they wrap is the value the function actually produces.
+ */
+const TRANSPARENT_WRAPPERS = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+/**
+ * Strips every type-only wrapper (`as T`, `as const`, `satisfies T`, `!`) from
+ * an expression. An assertion removes no reassembly — `{ a, b } as const` is
+ * the very same destructure-then-reassemble as `{ a, b }` — so classifying the
+ * target without stripping first turns an assertion into an accidental
+ * suppression. The loop is what handles chains such as `{...} as unknown as T`,
+ * and `enforce-object-literal-as-const` appends `as const` to exactly this
+ * shape, so wrapped literals are the common case rather than the exotic one.
+ */
+function unwrapTransparent(node) {
+    let current = node;
+    while (TRANSPARENT_WRAPPERS.has(current.type)) {
+        current = current.expression;
+    }
+    return current;
+}
+/**
+ * Classifies an already-unwrapped expression as a spread target. The fix is
+ * anchored on the node returned here — the JSX opening element or the object
+ * literal's own braces — so any wrapper stripped on the way in keeps its source
+ * text untouched.
+ */
+function classifyTarget(expression) {
+    if (expression.type === utils_1.AST_NODE_TYPES.JSXElement) {
         return {
             kind: 'jsx',
-            openingElement: body.openingElement,
-            jsxElement: body,
+            openingElement: expression.openingElement,
+            jsxElement: expression,
         };
     }
     // Concise arrow returning object literal: `({ x, y }) => ({ x, y, extra: 1 })`
     // The parser represents the parenthesized object as an ObjectExpression body.
-    if (body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-        return { kind: 'object', expression: body };
+    if (expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+        return { kind: 'object', expression };
     }
+    return null;
+}
+function getSingleTarget(fn) {
+    const body = fn.body;
+    // Concise arrow: `(props) => <X />`, `({ x, y }) => ({ x, y } as const)`.
     if (body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-        return null;
+        return classifyTarget(unwrapTransparent(body));
     }
     // Require exactly one statement in the block, which must be a return.
     if (body.body.length !== 1) {
@@ -173,30 +207,7 @@ function getSingleTarget(fn) {
     if (stmt.type !== utils_1.AST_NODE_TYPES.ReturnStatement || !stmt.argument) {
         return null;
     }
-    const arg = stmt.argument;
-    if (arg.type === utils_1.AST_NODE_TYPES.JSXElement) {
-        return {
-            kind: 'jsx',
-            openingElement: arg.openingElement,
-            jsxElement: arg,
-        };
-    }
-    // Parenthesized JSX in arrow: `(props) => (<X />)` — arg may wrap with
-    // TSAsExpression or similar. We unwrap one level of TSAsExpression / TSSatisfiesExpression.
-    if ((arg.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-        arg.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) &&
-        arg.expression.type === utils_1.AST_NODE_TYPES.JSXElement) {
-        const jsx = arg.expression;
-        return {
-            kind: 'jsx',
-            openingElement: jsx.openingElement,
-            jsxElement: jsx,
-        };
-    }
-    if (arg.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-        return { kind: 'object', expression: arg };
-    }
-    return null;
+    return classifyTarget(unwrapTransparent(stmt.argument));
 }
 /**
  * Checks whether any of the destructured names is used anywhere in the

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.77",
+    "date": "2026-08-02T08:02:01.009Z",
+    "rules": [
+      {
+        "name": "prefer-spread-over-reassembly",
+        "changeType": "fix",
+        "issues": [
+          1610
+        ],
+        "summary": "see through transparent type-assertion wrappers (closes #1610)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.76",
+    "date": "2026-08-02T07:09:34.794Z",
+    "rules": [
+      {
+        "name": "no-type-assertion-returns",
+        "changeType": "fix",
+        "issues": [
+          1609
+        ],
+        "summary": "report a chained assertion once, on the outermost link (closes #1609)"
+      }
+    ]
+  },
   {
     "version": "1.20.75",
     "date": "2026-08-02T06:40:23.306Z",