@blumintinc/eslint-plugin-blumint 1.20.57 → 1.20.59

package/lib/index.js

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

package/lib/rules/enforce-memoize-async.js

@@ -42,6 +42,39 @@ function bindsMemoize(variable) {
                 ALLOWED_MEMOIZE_MODULES.has(String(declaration.source.value)));
         }));
 }
+/**
+ * Whether a declared return type annotation promises no value: `void` or
+ * `Promise<void>`.
+ *
+ * Memoizing such a method caches nothing — there is no result to hand back —
+ * while changing runtime behaviour: the side effects run once per instance and
+ * every later call silently no-ops. Because the decision comes from the
+ * annotation node, spacing and line breaks inside the type are irrelevant.
+ *
+ * The check stays keyed to a plain `void`: a union (`Promise<void | undefined>`)
+ * or a type parameter (`Promise<T>`) can resolve to a value, so those still
+ * warrant caching. Absent annotations are likewise not exempt — this rule is
+ * syntactic (no `parserOptions.project`), so an unannotated body carries no
+ * declaration of intent to honour, and exempting inferred void would silently
+ * drop methods the author never marked value-less.
+ */
+function declaresVoidResult(returnType) {
+    const annotation = returnType?.typeAnnotation;
+    if (!annotation) {
+        return false;
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+        return true;
+    }
+    if (annotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+        annotation.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        annotation.typeName.name !== 'Promise') {
+        return false;
+    }
+    const typeArguments = annotation.typeParameters?.params;
+    return (typeArguments?.length === 1 &&
+        typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
+}
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -148,6 +181,13 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (node.value.params.length > 1) {
                     return;
                 }
+                // A method declared to produce no value has no result to cache, so the
+                // decorator's benefit is unobtainable while its cost is real: the
+                // fixer would convert a repeatable side effect into a
+                // once-per-instance one, unattended, under `--fix`.
+                if (declaresVoidResult(node.value.returnType)) {
+                    return;
+                }
                 const { aliases: memoizeAliases, namespaces: memoizeNamespaces } = memoizeImports();
                 const hasMemoizeImport = memoizeAliases.size > 0 || memoizeNamespaces.size > 0;
                 // Check if method already has @Memoize or @Memoize() decorator

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

@@ -2,6 +2,51 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferTypeOverInterface = void 0;
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * A module augmentation targets either an external module
+ * (`declare module 'pkg'`, whose id is a string literal) or the global scope
+ * (`declare global`). Declaration merging is the whole point of such a block
+ * and only `interface` can merge, so the `type` rewrite does not merely change
+ * style: it drops the augmentation and collides with the original declaration
+ * (TS2300 "Duplicate identifier").
+ *
+ * A plain `namespace X` — including the ambient `declare namespace X`, whose
+ * id is an identifier — augments nothing, so interfaces inside it stay
+ * reportable and a type alias works there.
+ */
+function isModuleAugmentation(node) {
+    if (node.id.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.id.value === 'string') {
+        return true;
+    }
+    // `declare global` carries a dedicated flag, which also covers the bare
+    // `global { ... }` form nested inside an ambient module (that form has no
+    // `declare` of its own).
+    if (node.global === true) {
+        return true;
+    }
+    // Parser versions that predate the `global` flag spell the same block as an
+    // ambient module whose id is the `global` keyword. Requiring `declare` keeps
+    // an ordinary `namespace global { ... }` reportable.
+    return (node.declare === true &&
+        node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.id.name === 'global');
+}
+/**
+ * The interface need not be a direct child of the augmentation block; it can
+ * sit inside a nested namespace or any other container within it, so the whole
+ * ancestor chain is inspected.
+ */
+function isInsideModuleAugmentation(node) {
+    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+        if (ancestor.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+            isModuleAugmentation(ancestor)) {
+            return true;
+        }
+    }
+    return false;
+}
 exports.preferTypeOverInterface = (0, createRule_1.createRule)({
     name: 'prefer-type-over-interface',
     meta: {
@@ -22,6 +67,9 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
     create(context) {
         return {
             TSInterfaceDeclaration(node) {
+                if (isInsideModuleAugmentation(node)) {
+                    return;
+                }
                 context.report({
                     node,
                     messageId: 'preferType',

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.59",
+    "date": "2026-08-01T04:43:54.837Z",
+    "rules": [
+      {
+        "name": "prefer-type-over-interface",
+        "changeType": "fix",
+        "issues": [
+          1549
+        ],
+        "summary": "exempt module augmentations (closes #1549)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.58",
+    "date": "2026-08-01T04:26:49.434Z",
+    "rules": [
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1548
+        ],
+        "summary": "skip methods declared Promise<void> (closes #1548)"
+      }
+    ]
+  },
   {
     "version": "1.20.57",
     "date": "2026-08-01T03:42:42.343Z",