@blumintinc/eslint-plugin-blumint 1.20.73 → 1.20.75

package/lib/index.js

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

package/lib/rules/global-const-style.js

@@ -3,6 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const isUpperSnakeCase = (str) => /^[A-Z][A-Z0-9_]*$/.test(str);
+/**
+ * Converts an identifier to UPPER_SNAKE_CASE by splitting on case *boundaries*.
+ *
+ * Idempotence is a correctness requirement, not a nicety: `--fix` re-lints its
+ * own output up to ten times per file, and a sibling rule can rewrite the same
+ * identifier in between (`enforce-react-type-naming` lowercases it), so a
+ * converter that re-separates what it already separated compounds every pass
+ * and writes an ever-growing, corrupted identifier into source (Issue #1605).
+ * Splitting on boundaries also keeps acronym runs intact, so `HTTPServer` reads
+ * as `HTTP_SERVER` rather than `H_T_T_P_SERVER`.
+ *
+ * The leading underscore is dropped because `_PRIVATE_THING` fails
+ * `isUpperSnakeCase`, which would leave the rule demanding a rename it can
+ * never satisfy.
+ */
+const toUpperSnakeCase = (name) => name
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase()
+    .replace(/^_/, '');
 // Jest mock handles produced by an `as` cast to a `jest.Mock*` type are
 // stateful test doubles that are reassigned/mutated through
 // `.mockImplementation()`, `.mockReturnValue()`, etc. They are not immutable
@@ -328,10 +348,7 @@ exports.default = (0, createRule_1.createRule)({
                     // the `mockedX` idiom is intentional. The exemption gates only this
                     // rename check — the `as const` logic above is untouched.
                     if (!isUpperSnakeCase(name) && !isJestMockCast(init)) {
-                        const newName = name
-                            .replace(/([A-Z])/g, '_$1')
-                            .toUpperCase()
-                            .replace(/^_/, '');
+                        const newName = toUpperSnakeCase(name);
                         const idNode = declaration.id;
                         context.report({
                             node: declaration,

package/lib/rules/no-misleading-boolean-prefixes.js

@@ -81,6 +81,25 @@ function isTsBooleanLike(typeNode) {
 }
 function isExpressionBooleanLike(expr) {
     switch (expr.type) {
+        // Assertion wrappers restate a type but never change the runtime value, so
+        // the expression beneath one still decides what the function returns
+        // (#1606). Recursing per level rather than unwrapping the whole chain at
+        // once is what lets a boolean declared at any level answer first, and it
+        // reaches through nesting such as `({...} as const)!`.
+        // `enforce-object-literal-as-const` ships in the same recommended config
+        // and appends `as const` to returned object literals by `--fix`, so
+        // without this the plugin's own fixer silences the report.
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+            // A declared boolean-like type is the same promise an explicit return
+            // annotation makes, which the rule already accepts; `as const` names no
+            // type at all and falls through to the asserted expression.
+            if (isTsBooleanLike(expr.typeAnnotation))
+                return true;
+            return isExpressionBooleanLike(expr.expression);
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            return isExpressionBooleanLike(expr.expression);
         case utils_1.AST_NODE_TYPES.Literal:
             return typeof expr.value === 'boolean' ? true : 'non';
         case utils_1.AST_NODE_TYPES.TemplateLiteral:

package/lib/rules/prefer-field-paths-in-transforms.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferFieldPathsInTransforms = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const minimatch_1 = require("minimatch");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 // Defaults aim to catch common BluMint aggregation container names
 const DEFAULT_CONTAINERS = ['*Aggregation', 'previews', '*Previews'];
@@ -19,8 +20,9 @@ function describeNestedPath(containerValue) {
         const firstKey = getPropertyName(prop);
         if (!firstKey)
             continue;
-        if (isObjectExpression(prop.value)) {
-            for (const child of prop.value.properties) {
+        const nestedValue = unwrapToObjectExpression(prop.value);
+        if (nestedValue) {
+            for (const child of nestedValue.properties) {
                 if (child.type === utils_1.AST_NODE_TYPES.SpreadElement)
                     continue;
                 if (!isProperty(child))
@@ -44,6 +46,50 @@ function describeNestedPath(containerValue) {
 function isObjectExpression(node) {
     return !!node && node.type === utils_1.AST_NODE_TYPES.ObjectExpression;
 }
+/**
+ * Resolves the object literal a value ultimately is, seeing through assertion
+ * wrappers (`as const`, `as T`, `satisfies T`, `!`, `<T>x`), which nest.
+ *
+ * An assertion changes no runtime value, so the write shape a transform sends
+ * to Firestore — the only thing this rule judges — is identical with or without
+ * one. Matching the bare `ObjectExpression` alone made the rule blind to its own
+ * ecosystem: `enforce-object-literal-as-const` ships `'error'` in the same
+ * recommended config and is fixable, so `eslint --fix` appends `as const` to
+ * exactly these literals and silences the nested-write report (#1607).
+ *
+ * Unwrapping the whole chain rather than one level at a time is safe here
+ * because no wrapper's `typeAnnotation` carries information this rule reads;
+ * only the key names and value shapes underneath matter.
+ */
+function unwrapToObjectExpression(node) {
+    if (!node)
+        return null;
+    const inner = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(node);
+    return isObjectExpression(inner) ? inner : null;
+}
+/**
+ * Assertion wrappers as seen from below, for walks that climb toward the
+ * declaration a function is bound to. A wrapped transform
+ * (`transformEach: ((doc) => ({...})) as Transform`) is still bound to that
+ * key, so the wrapper must not hide the binding.
+ */
+const ASSERTION_WRAPPER_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+function bindingParentOf(node) {
+    let current = node;
+    let parent = current.parent ?? null;
+    while (parent &&
+        ASSERTION_WRAPPER_TYPES.has(parent.type) &&
+        parent.expression === current) {
+        current = parent;
+        parent = current.parent ?? null;
+    }
+    return parent;
+}
 function isProperty(node) {
     return node.type === utils_1.AST_NODE_TYPES.Property;
 }
@@ -68,7 +114,7 @@ function isBoundToName(fn, name) {
     if (fn.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
         return isNamedFunction(fn, name);
     }
-    const parent = fn.parent;
+    const parent = bindingParentOf(fn);
     if (!parent)
         return false;
     if (parent.type === utils_1.AST_NODE_TYPES.Property ||
@@ -112,15 +158,14 @@ function isTransformEachVaripotent(fn) {
 function hasDeeperThanOneLevelUnderContainer(containerObj) {
     for (const prop of containerObj.properties) {
         if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-            if (isObjectExpression(prop.argument)) {
+            if (unwrapToObjectExpression(prop.argument)) {
                 return true;
             }
             continue;
         }
         if (!isProperty(prop))
             continue;
-        const value = prop.value;
-        if (isObjectExpression(value)) {
+        if (unwrapToObjectExpression(prop.value)) {
             // Any nested object literal implies depth >= 2 (even if it only spreads)
             return true;
         }
@@ -143,9 +188,10 @@ function analyzeReturnedObject(obj, context, containerNameMatches) {
             continue;
         if (!containerNameMatches(keyName))
             continue;
-        const containerValue = top.value;
-        if (!isObjectExpression(containerValue))
-            continue; // only care if returning an object under the container
+        // only care if returning an object under the container
+        const containerValue = unwrapToObjectExpression(top.value);
+        if (!containerValue)
+            continue;
         if (hasDeeperThanOneLevelUnderContainer(containerValue)) {
             const nestedPath = describeNestedPath(containerValue) ?? 'nestedField';
             context.report({
@@ -229,18 +275,20 @@ exports.preferFieldPathsInTransforms = (0, createRule_1.createRule)({
         }
         return {
             ReturnStatement(node) {
-                if (!node.argument || !isObjectExpression(node.argument))
+                const returned = unwrapToObjectExpression(node.argument);
+                if (!returned)
                     return;
                 if (!isInTargetTransform(node))
                     return;
-                analyzeReturnedObject(node.argument, context, containerNameMatches);
+                analyzeReturnedObject(returned, context, containerNameMatches);
             },
             ArrowFunctionExpression(node) {
                 // Handle implicit returns: transformEach: doc => ({ ... })
                 if (!isTransformEachFunction(node) || isTransformEachVaripotent(node))
                     return;
-                if (isObjectExpression(node.body)) {
-                    analyzeReturnedObject(node.body, context, containerNameMatches);
+                const returned = unwrapToObjectExpression(node.body);
+                if (returned) {
+                    analyzeReturnedObject(returned, context, containerNameMatches);
                 }
             },
         };

package/lib/rules/prefer-flat-transform-each-keys.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferFlatTransformEachKeys = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 // Propagation strategy shape signals: an object literal with one of these
 // properties (besides transformEach) is treated as a propagation strategy.
@@ -15,6 +16,34 @@ const STRATEGY_SHAPE_KEYS = new Set([
 function isObjectExpression(node) {
     return !!node && node.type === utils_1.AST_NODE_TYPES.ObjectExpression;
 }
+/**
+ * Strips assertion wrappers (`as const`, `as T`, `satisfies T`, `!`, `<T>x`),
+ * which nest, from an expression before its node type is inspected.
+ *
+ * An assertion changes no runtime value, so the write shape transformEach sends
+ * to Firestore — the only thing this rule judges — is identical with or without
+ * one. Matching bare node types alone leaves the rule blind to its own
+ * ecosystem: `enforce-object-literal-as-const` ships `'error'` in the same
+ * recommended config and is fixable, so `eslint --fix` appends `as const` to
+ * exactly these literals, which silences the nested-key report while the nested
+ * write shape survives (#1608).
+ *
+ * Unwrapping the whole chain rather than one level is safe because no wrapper's
+ * `typeAnnotation` carries information this rule reads; only key names and value
+ * shapes underneath matter.
+ */
+function unwrapAssertions(node) {
+    return ASTHelpers_1.ASTHelpers.unwrapTSAssertions(node);
+}
+// Resolve the object literal an expression ultimately is, seeing through
+// assertion wrappers. Returns null when the underlying expression is anything
+// else (a call, a member expression, a binding reference).
+function unwrapToObjectExpression(node) {
+    if (!node)
+        return null;
+    const inner = unwrapAssertions(node);
+    return isObjectExpression(inner) ? inner : null;
+}
 function isProperty(node) {
     return node.type === utils_1.AST_NODE_TYPES.Property;
 }
@@ -79,7 +108,9 @@ function usesResolveSelf(obj) {
     const resolveAllProp = findProp(obj, 'resolveAll');
     if (!resolveAllProp)
         return false;
-    const val = resolveAllProp.value;
+    // `resolveAll: resolveSelf as ResolveAllStrategy` still resolves self, so the
+    // exemption must survive an assertion on the reference.
+    const val = unwrapAssertions(resolveAllProp.value);
     return val.type === utils_1.AST_NODE_TYPES.Identifier && val.name === 'resolveSelf';
 }
 // Extract the effective "data" object from a return value:
@@ -89,8 +120,8 @@ function usesResolveSelf(obj) {
 function getDataObject(obj) {
     const afterDataProp = findProp(obj, 'afterData');
     if (afterDataProp) {
-        const val = afterDataProp.value;
-        if (isObjectExpression(val))
+        const val = unwrapToObjectExpression(afterDataProp.value);
+        if (val)
             return val;
         // afterData exists but its value isn't a literal (e.g. a variable) — skip.
         return null;
@@ -111,12 +142,13 @@ function resolveVariableBinding(returnArg, funcBody) {
         if (stmt.type !== utils_1.AST_NODE_TYPES.VariableDeclaration)
             continue;
         for (const decl of stmt.declarations) {
-            if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                decl.id.name === varName &&
-                decl.init &&
-                isObjectExpression(decl.init)) {
-                return decl.init;
+            if (decl.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                decl.id.name !== varName) {
+                continue;
             }
+            const init = unwrapToObjectExpression(decl.init);
+            if (init)
+                return init;
         }
     }
     return null;
@@ -139,7 +171,7 @@ function checkDataObject(dataObj, report) {
         if (isDotNotationKey(keyName))
             continue;
         // Flag when the value is a nested object literal.
-        if (isObjectExpression(prop.value)) {
+        if (unwrapToObjectExpression(prop.value)) {
             report(prop);
         }
     }
@@ -152,14 +184,11 @@ function analyzeBlockBody(body, report) {
             continue;
         if (!stmt.argument)
             continue;
-        let retObj = null;
-        if (isObjectExpression(stmt.argument)) {
-            retObj = stmt.argument;
-        }
-        else {
-            // Try single-binding pattern: const x = {...}; return x;
-            retObj = resolveVariableBinding(stmt.argument, body);
-        }
+        const returned = unwrapAssertions(stmt.argument);
+        // Try single-binding pattern: const x = {...}; return x;
+        const retObj = isObjectExpression(returned)
+            ? returned
+            : resolveVariableBinding(returned, body);
         if (!retObj)
             continue;
         const dataObj = getDataObject(retObj);
@@ -201,7 +230,10 @@ exports.preferFlatTransformEachKeys = (0, createRule_1.createRule)({
                 const transformEachProp = findProp(node, 'transformEach');
                 if (!transformEachProp)
                     return;
-                const fn = transformEachProp.value;
+                // A transform asserted at its binding
+                // (`transformEach: ((doc) => ({...})) as TransformEach`) is still the
+                // function the strategy runs.
+                const fn = unwrapAssertions(transformEachProp.value);
                 const report = (violatingNode) => {
                     context.report({
                         node: violatingNode,
@@ -211,9 +243,10 @@ exports.preferFlatTransformEachKeys = (0, createRule_1.createRule)({
                 if (fn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                     fn.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                     const body = fn.body;
-                    if (isObjectExpression(body)) {
-                        // Arrow function with implicit return: () => ({ ... })
-                        const dataObj = getDataObject(body);
+                    // Arrow function with implicit return: () => ({ ... })
+                    const implicitReturn = unwrapToObjectExpression(body);
+                    if (implicitReturn) {
+                        const dataObj = getDataObject(implicitReturn);
                         if (dataObj)
                             checkDataObject(dataObj, report);
                     }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,48 @@
 [
+  {
+    "version": "1.20.75",
+    "date": "2026-08-02T06:40:23.306Z",
+    "rules": [
+      {
+        "name": "no-misleading-boolean-prefixes",
+        "changeType": "fix",
+        "issues": [
+          1606
+        ],
+        "summary": "see through assertion wrappers on a returned value (closes #1606)"
+      },
+      {
+        "name": "prefer-field-paths-in-transforms",
+        "changeType": "fix",
+        "issues": [
+          1607
+        ],
+        "summary": "see through assertion wrappers when classifying a transform return (closes #1607)"
+      },
+      {
+        "name": "prefer-flat-transform-each-keys",
+        "changeType": "fix",
+        "issues": [
+          1608
+        ],
+        "summary": "see through assertion wrappers when classifying a transform return (closes #1608)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.74",
+    "date": "2026-08-02T06:07:00.009Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          1605
+        ],
+        "summary": "split the rename on case boundaries so it is idempotent (closes #1605)"
+      }
+    ]
+  },
   {
     "version": "1.20.73",
     "date": "2026-08-02T05:14:39.301Z",