@blumintinc/eslint-plugin-blumint 1.20.131 → 1.20.133

package/lib/index.js

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

package/lib/rules/parallelize-async-operations.js

@@ -394,6 +394,97 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * The array folds whose callback receives the PREVIOUS iteration's result as
+         * its first parameter. `reduceRight` carries the same contract as `reduce`;
+         * only the traversal order differs, so both fold a chain the same way.
+         *
+         * `map`/`forEach`/`filter` are deliberately absent: their callbacks receive
+         * an ELEMENT first, and awaiting an element is an ordinary data read rather
+         * than a serialization point.
+         */
+        const SEQUENTIAL_FOLD_METHODS = new Set(['reduce', 'reduceRight']);
+        /**
+         * Reports whether a function node is the callback a fold folds WITH -- the
+         * first argument of a `.reduce(...)` / `.reduceRight(...)` call.
+         *
+         * Only a direct argument qualifies. A callback bound to a name first
+         * (`const step = async (promise, doc) => {...}; items.reduce(step, seed)`)
+         * is left alone rather than chased through the binding, which keeps the
+         * barrier to the shape it can prove.
+         */
+        function isFoldCallback(fn) {
+            const call = fn.parent;
+            if (!call ||
+                call.type !== utils_1.AST_NODE_TYPES.CallExpression ||
+                call.arguments[0] !== fn) {
+                return false;
+            }
+            const callee = call.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            const property = callee.property;
+            const methodName = callee.computed
+                ? property.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof property.value === 'string'
+                    ? property.value
+                    : null
+                : property.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? property.name
+                    : null;
+            return !!methodName && SEQUENTIAL_FOLD_METHODS.has(methodName);
+        }
+        /**
+         * Reports whether a parameter binding is the FIRST parameter of a function
+         * -- the accumulator slot of a fold callback.
+         *
+         * Keyed on position rather than on the binding's name, because the
+         * accumulator is spelled `promise`, `acc`, `previous`, `prev`, `chain` or
+         * anything else the author preferred, and matching a name list would both
+         * miss the unlisted spellings and fire on an element parameter that happens
+         * to be called `promise`. A default (`async (acc = Promise.resolve(), doc)`)
+         * still binds the accumulator first, so the pattern is unwrapped.
+         */
+        function isAccumulatorParameter(fn, binding) {
+            if (!FUNCTION_BOUNDARY_TYPES.has(fn.type)) {
+                return false;
+            }
+            const [first] = fn.params;
+            if (!first) {
+                return false;
+            }
+            const target = first.type === utils_1.AST_NODE_TYPES.AssignmentPattern ? first.left : first;
+            return target === binding;
+        }
+        /**
+         * Reports whether an awaited expression is a bare read of the ACCUMULATOR
+         * parameter of an enclosing fold callback.
+         *
+         * The parameter is resolved through the scope chain rather than matched by
+         * name, so a local that merely shadows the accumulator's spelling
+         * (`const promise = fetchThing(); await promise;` inside the callback) is
+         * correctly NOT the accumulator, and an accumulator under any spelling is.
+         * TS-only wrappers are unwrapped because `await acc!` and
+         * `await acc as Promise<void>` read the same binding.
+         */
+        function isFoldAccumulatorAwait(awaitExpr) {
+            let argument = awaitExpr.argument;
+            while (argument.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+                argument.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                argument = argument.expression;
+            }
+            if (argument.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, argument), argument.name);
+            if (!variable) {
+                return false;
+            }
+            return variable.defs.some((definition) => definition.type === utils_1.TSESLint.Scope.DefinitionType.Parameter &&
+                isAccumulatorParameter(definition.node, definition.name) &&
+                isFoldCallback(definition.node));
+        }
         /**
          * Follows an identifier back to the array literal a `const` binds to it.
          *
@@ -838,6 +929,27 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     }
                 }
             }
+            // 11. Fold-accumulator serialization barrier. `items.reduce(async
+            // (promise, item) => { await promise; await store(item); },
+            // Promise.resolve())` is the canonical idiom for FORCING sequential
+            // execution over a collection: the callback's first parameter IS the
+            // previous iteration's completion, so `await promise` is a serialization
+            // point rather than an operation of its own. The dependency it expresses
+            // is a sequencing one -- the accumulator and `store(item)` share no value
+            // at all -- so the identifier comparison above classifies the pair
+            // independent and the rewrite hoists the awaits into a Promise.all,
+            // starting every iteration's work at once and discarding the exact
+            // guarantee the idiom was written to provide. The run is deliberate, not
+            // a latency mistake, so the rule declines to report it rather than merely
+            // declining the fix. Only an accumulator await with something AFTER it
+            // qualifies, mirroring the guard barrier above: it is what follows the
+            // barrier that the rewrite would illegally start early. (#1851)
+            for (let i = 0; i < awaitNodes.length - 1; i++) {
+                const awaitExpr = getAwaitExpression(awaitNodes[i]);
+                if (awaitExpr && isFoldAccumulatorAwait(awaitExpr)) {
+                    return true;
+                }
+            }
             return false;
         }
         /**

package/lib/rules/prefer-type-over-interface.d.ts

@@ -1,2 +1,4 @@
 import { TSESLint } from '@typescript-eslint/utils';
-export declare const preferTypeOverInterface: TSESLint.RuleModule<'preferType', never[]>;
+type MessageIds = 'preferType' | 'preferTypeDefaultExport';
+export declare const preferTypeOverInterface: TSESLint.RuleModule<MessageIds, never[]>;
+export {};

package/lib/rules/prefer-type-over-interface.js

@@ -47,6 +47,21 @@ function isInsideModuleAugmentation(node) {
     }
     return false;
 }
+/**
+ * `export default interface X {…}` is the only spelling TypeScript has for a
+ * default-exported type: `export default type X = …` is a syntax error in every
+ * form, so the keyword swap has no landing site. It lands there anyway because
+ * the `TSInterfaceDeclaration`'s range starts at `interface` while
+ * `export default` belongs to the parent node, which made `eslint --fix` write
+ * a file that no longer parses (#1850).
+ *
+ * The conversion is still available to the author, as a two-statement
+ * restructure a keyword swap cannot express, so the report stands and carries
+ * that remedy instead of a fix.
+ */
+function isDefaultExported(node) {
+    return node.parent?.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration;
+}
 /**
  * Declaration merging is what `interface` can do and `type` cannot, so a name
  * carrying more than one declaration is not a stylistic choice: rewriting one
@@ -92,6 +107,10 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
             preferType: 'Interface "{{interfaceName}}" should be declared as a type alias. ' +
                 'Interfaces can merge across declarations and extend in chains, which fragments the resulting shape across files and makes composition harder to predict and trace. ' +
                 'Replace `interface` with `type` and use intersections (for example, `type {{interfaceName}} = Base & { field: string }`) to keep the contract closed and predictable.',
+            preferTypeDefaultExport: 'Interface "{{interfaceName}}" should be declared as a type alias, but a default-exported interface has no in-place conversion, so no autofix is offered here. ' +
+                'Interfaces can merge across declarations and extend in chains, which fragments the resulting shape across files and makes composition harder to predict and trace. ' +
+                'TypeScript has no default-exported type alias — `export default type {{interfaceName}} = ...` is a syntax error — so the conversion takes two statements: `type {{interfaceName}} = { field: string };` followed by `export type { {{interfaceName}} as default };`, which keeps every existing `import {{interfaceName}} from ...` working. ' +
+                'A named `export type {{interfaceName}} = ...` works too, once the import sites are switched to `import type { {{interfaceName}} }`.',
         },
         fixable: 'code',
     },
@@ -108,6 +127,22 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
                 if (isMergedDeclaration(context, node)) {
                     return;
                 }
+                // Withholding the fix rather than emitting a broken one: every rewrite
+                // below assumes the `interface` keyword can become `type` where it
+                // stands, and under `export default` that position accepts no
+                // declaration at all. The report is kept because the author *can* act
+                // on it — unlike a merge, the shape converts by hand — and the remedy
+                // travels in the message.
+                if (isDefaultExported(node)) {
+                    context.report({
+                        node,
+                        messageId: 'preferTypeDefaultExport',
+                        data: {
+                            interfaceName: node.id.name,
+                        },
+                    });
+                    return;
+                }
                 context.report({
                     node,
                     messageId: 'preferType',

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.133",
+    "date": "2026-08-07T14:16:50.604Z",
+    "rules": [
+      {
+        "name": "parallelize-async-operations",
+        "changeType": "fix",
+        "issues": [
+          1851
+        ],
+        "summary": "treat a fold accumulator await as a sequencing barrier (closes #1851)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.132",
+    "date": "2026-08-07T12:26:09.881Z",
+    "rules": [
+      {
+        "name": "prefer-type-over-interface",
+        "changeType": "fix",
+        "issues": [
+          1850
+        ],
+        "summary": "decline the fix for a default-exported interface (closes #1850)"
+      }
+    ]
+  },
   {
     "version": "1.20.131",
     "date": "2026-08-07T10:28:22.079Z",