@blumintinc/eslint-plugin-blumint 1.18.12 → 1.18.14

package/lib/index.js

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

package/lib/rules/no-compositing-layer-props.js

@@ -104,6 +104,38 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
             }
             return false;
         }
+        // A property key names a `@keyframes` at-rule when it is a string literal
+        // (`'@keyframes spin'`) or a template literal whose leading text starts the
+        // at-rule (`` [`@keyframes ${name}`] `` for a dynamically-named animation).
+        function keyNamesKeyframes(key) {
+            if (key.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof key.value === 'string') {
+                return /^\s*@keyframes/i.test(key.value);
+            }
+            if (key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                key.quasis.length > 0) {
+                const leading = key.quasis[0].value.cooked ?? key.quasis[0].value.raw;
+                return /^\s*@keyframes/i.test(leading);
+            }
+            return false;
+        }
+        // Compositing props declared inside a `@keyframes` block are exempt.
+        // Animating `transform`/`opacity` via `@keyframes` is the web-standard,
+        // GPU-accelerated animation pattern; this rule targets gratuitous *static*
+        // layer promotion, not a deliberate keyframe animation. Scoped to
+        // descendants of the `@keyframes` value object, so a static compositing prop
+        // sitting as a *sibling* of the `@keyframes` key is still flagged.
+        function isInKeyframes(node) {
+            let current = node.parent;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.Property &&
+                    keyNamesKeyframes(current.key)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
         function isStyleContext(node) {
             let current = node;
             while (current?.parent) {
@@ -145,6 +177,9 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
             // Skip if not in a style context
             if (!isStyleContext(node))
                 return;
+            // Skip compositing props inside a @keyframes animation definition
+            if (isInKeyframes(node))
+                return;
             let propertyName = '';
             let propertyValue = '';
             // Get property name

package/lib/rules/no-entire-object-hook-deps.js

@@ -65,9 +65,7 @@ function unwrapExpression(expr) {
     }
     return current;
 }
-function getObjectUsagesInHook(hookBody, objectName, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-context) {
+function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Map(); // Track usage and its position
     const visited = new Set();
     let needsEntireObject = false;
@@ -133,8 +131,15 @@ context) {
             const memberExpr = current;
             // Handle computed properties (like array indices)
             if (memberExpr.computed) {
-                // For computed properties with variables (like user[key]), we need the entire object
-                if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // why: only a *literal* computed key (obj[0], obj['special-key'])
+                // narrows to a single, stable field. EVERY other computed key —
+                // Identifier (obj[i]), CallExpression (obj[assertSafe(i)]),
+                // BinaryExpression (obj[i+1]), MemberExpression (obj[keys[j]]),
+                // TSAsExpression (obj[k as K]), TemplateLiteral (obj[`row-${i}`]), etc.
+                // — is a dynamic access that can read arbitrary elements across an
+                // iteration. There is no single narrowable field, so the whole object
+                // is a legitimate dependency: resolve the base and mark it accordingly.
+                if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Literal) {
                     // Check if this is accessing our target object
                     let currentBase = unwrapExpression(memberExpr.object);
                     while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -142,35 +147,23 @@ context) {
                     }
                     if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
                         currentBase.name === objectName) {
-                        // This is a computed property access on our target object, so we need the entire object
+                        // This is a dynamic computed property access on our target object,
+                        // so we need the entire object (no narrowable field exists).
                         needsEntireObject = true;
                     }
                     return null;
                 }
                 // For computed properties with literals
-                if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Literal) {
-                    const literalProp = memberExpr.property;
-                    if (typeof literalProp.value === 'number') {
-                        parts.unshift(`[${literalProp.value}]`);
-                    }
-                    else if (typeof literalProp.value === 'string') {
-                        parts.unshift(`[${JSON.stringify(literalProp.value)}]`);
-                    }
-                    else {
-                        // For other computed properties, use a wildcard
-                        parts.unshift('[*]');
-                    }
+                const literalProp = memberExpr.property;
+                if (typeof literalProp.value === 'number') {
+                    parts.unshift(`[${literalProp.value}]`);
+                }
+                else if (typeof literalProp.value === 'string') {
+                    parts.unshift(`[${JSON.stringify(literalProp.value)}]`);
                 }
                 else {
-                    // For other computed properties, use the exact expression
-                    try {
-                        const propertyText = context.sourceCode.getText(memberExpr.property);
-                        parts.unshift(`[${propertyText}]`);
-                    }
-                    catch (e) {
-                        // Fallback to wildcard if we can't get the source text
-                        parts.unshift('[*]');
-                    }
+                    // For other literal computed properties (e.g. boolean/null), wildcard
+                    parts.unshift('[*]');
                 }
             }
             else {
@@ -184,7 +177,7 @@ context) {
                         STRING_METHODS.has(memberExpr.property.name))) {
                     // Check if this is accessing our target object or a property of it
                     let currentBase = unwrapExpression(memberExpr.object);
-                    let pathParts = [];
+                    const pathParts = [];
                     let hasOptionalChainingInMethod = false;
                     // Build the path to the array/string being accessed
                     while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -352,7 +345,8 @@ context) {
                     effectiveParent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
                 effectiveParent = effectiveParent.parent;
             }
-            const isIntermediate = effectiveParent && effectiveParent.type === utils_1.AST_NODE_TYPES.MemberExpression;
+            const isIntermediate = effectiveParent &&
+                effectiveParent.type === utils_1.AST_NODE_TYPES.MemberExpression;
             if (!isIntermediate) {
                 // Check if this member expression involves our target object
                 let current = memberExpr;
@@ -361,9 +355,12 @@ context) {
                 // Walk up the member expression chain to see if it involves our target object
                 while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                     const currentMember = current;
-                    // Check if this level uses dynamic computed property access
+                    // Check if this level uses dynamic computed property access.
+                    // why: any non-literal computed key reads arbitrary elements, so it
+                    // requires the entire object. Only a literal key (obj[0], obj['k'])
+                    // narrows to a single, stable field.
                     if (currentMember.computed &&
-                        currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        currentMember.property.type !== utils_1.AST_NODE_TYPES.Literal) {
                         hasDynamicComputed = true;
                     }
                     current = unwrapExpression(currentMember.object);
@@ -582,7 +579,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                             }
                         }
                         // For testing without TypeScript services, we'll assume all identifiers are objects
-                        const result = getObjectUsagesInHook(callbackArg.body, objectName, context);
+                        const result = getObjectUsagesInHook(callbackArg.body, objectName);
                         // If the object is not used at all, suggest removing it
                         if (result.notUsed) {
                             context.report({

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

@@ -206,6 +206,50 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             }
             return null;
         }
+        /**
+         * Extracts the bare receiver identifier of an awaited *named-method* call:
+         * the `object` of a `MemberExpression` callee when that object is a plain
+         * identifier and the accessed member is a named method -- either a
+         * non-computed property (`versionRef.set(...)`) or a computed string-literal
+         * key (`api['getData']()`). Both denote invoking a method on the shared
+         * receiver, so they are equivalent for ordering purposes.
+         *
+         * Returns null when the receiver is not a bare identifier -- a computed
+         * chain (`realtimeDb.ref(path).remove()`), a nested member
+         * (`api.users.getAll()`), a `this`/`super` receiver, or a non-member callee.
+         * Also returns null for a numeric or dynamic index (`operations[0]()`,
+         * `operations[i]()`): those select a distinct callable from a container
+         * rather than invoking a method on a stateful receiver, so they are
+         * genuinely independent and must not be collapsed onto a shared receiver.
+         * Handles optional-call ChainExpressions.
+         */
+        function getCalleeReceiverName(awaitExpr) {
+            let callExpr = null;
+            if (awaitExpr.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                callExpr = awaitExpr.argument;
+            }
+            else if (awaitExpr.argument.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                awaitExpr.argument.expression.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                callExpr = awaitExpr.argument.expression;
+            }
+            if (!callExpr) {
+                return null;
+            }
+            const callee = callExpr.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                callee.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            const property = callee.property;
+            const isNamedMember = callee.computed
+                ? property.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof property.value === 'string'
+                : property.type === utils_1.AST_NODE_TYPES.Identifier;
+            if (!isNamedMember) {
+                return null;
+            }
+            return callee.object.name;
+        }
         /**
          * Checks if there are dependencies between await expressions
          */
@@ -290,6 +334,31 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     }
                 }
             }
+            // 6. Shared-receiver ordering barrier. Two awaited calls whose callees are
+            // member expressions on the SAME receiver identifier (e.g. `ref.set(x)`
+            // then `ref.get()`) can carry a read-after-write / write-after-write
+            // dependency: the later call may observe or overwrite state the earlier
+            // one produced on that shared object. Promise.all runs its operands
+            // concurrently, so it would race that ordering and let the read see the
+            // stale value. Keep such a run sequential. Skipping a genuinely
+            // independent pair of reads on one receiver is only a missed
+            // parallelization (a safe no-op), which is preferable to silently
+            // reordering a real data dependency. The receiver must be a bare
+            // identifier; computed chains and nested members are left untouched.
+            const receiverNames = awaitNodes.map((node) => {
+                const awaitExpr = getAwaitExpression(node);
+                return awaitExpr ? getCalleeReceiverName(awaitExpr) : null;
+            });
+            for (let i = 1; i < receiverNames.length; i++) {
+                const receiver = receiverNames[i];
+                if (!receiver)
+                    continue;
+                for (let j = 0; j < i; j++) {
+                    if (receiverNames[j] === receiver) {
+                        return true;
+                    }
+                }
+            }
             return false;
         }
         /**

package/lib/rules/react-memoize-literals.js

@@ -62,6 +62,30 @@ const HOOKS_ALLOWING_NESTED_LITERALS = new Set([
  * MUI's `sx` and the standard `style` prop both fall into this category.
  */
 const STYLE_JSX_ATTRIBUTE_NAMES = new Set(['sx', 'style']);
+/**
+ * Array iteration higher-order methods that invoke their callback argument
+ * synchronously and then discard it. A function literal passed directly as such
+ * a callback is never observed by any hook dependency, prop, effect, or memoized
+ * child, so re-creating it each render costs nothing and memoizing it buys
+ * nothing — the same "identity is never observably compared" rationale that
+ * exempts throw-argument literals. Matched by (non-computed) method name only;
+ * the rule is not type-aware, mirroring how the hook-argument sets work.
+ */
+const ITERATION_METHODS = new Set([
+    'map',
+    'filter',
+    'forEach',
+    'reduce',
+    'reduceRight',
+    'some',
+    'every',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'flatMap',
+    'sort',
+]);
 const MEMOIZATION_DEPS_TODO_PLACEHOLDER = '__TODO_MEMOIZATION_DEPENDENCIES__';
 const TODO_DEPS_COMMENT = `/* ${MEMOIZATION_DEPS_TODO_PLACEHOLDER} */`;
 const PARENTHESIZED_EXPRESSION_TYPE = utils_1.AST_NODE_TYPES.ParenthesizedExpression ??
@@ -82,6 +106,31 @@ function isHookName(name) {
 function isComponentName(name) {
     return !!name && /^[A-Z]/.test(name);
 }
+/**
+ * True when `node` is a function literal passed directly as an argument to an
+ * Array iteration method call (`items.map((x) => ...)`,
+ * `list.filter(fn)`, `xs.reduce(fn, init)`, ...). Such a callback is invoked
+ * synchronously during render and then discarded, so its referential identity
+ * is never observed. Matched by (non-computed) method name only, since the rule
+ * is not type-aware.
+ */
+function isIterationMethodCallback(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+        node.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return false;
+    }
+    const parent = node.parent;
+    if (!parent ||
+        parent.type !== utils_1.AST_NODE_TYPES.CallExpression ||
+        !parent.arguments.includes(node)) {
+        return false;
+    }
+    const callee = parent.callee;
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        ITERATION_METHODS.has(callee.property.name));
+}
 /**
  * Type guard for parenthesized expressions to unwrap safely.
  * @param node Node to evaluate.
@@ -773,6 +822,18 @@ exports.reactMemoizeLiterals = (0, createRule_1.createRule)({
             if (isTerminalUsage(node)) {
                 return;
             }
+            // A function literal passed directly as the callback to an Array
+            // iteration method (.map/.filter/.reduce/.forEach/...) is invoked
+            // synchronously during render and then discarded, so its identity is
+            // never observed by a hook dependency, prop, effect, or memoized child —
+            // memoizing it buys nothing. The rule's own advice is also unfollowable
+            // here: the callback closes over loop/render scope so it can't be hoisted
+            // to module level, and useCallback can't run inside a .map loop. Inline
+            // functions passed as JSX-attribute props *inside* the callback body are
+            // separate nodes and remain flagged.
+            if (isIterationMethodCallback(node)) {
+                return;
+            }
             // Inline literals that resolve to a style JSX attribute (sx, style),
             // whether directly or via conditional/logical/array wrappers, are
             // consumed by the library without reference equality checks, so

package/lib/rules/require-props-composition.js

@@ -236,6 +236,88 @@ function getPropsTypeNameFromParam(funcNode) {
     }
     return null;
 }
+/**
+ * Returns the first-parameter type annotation node of a component function, or
+ * null when the parameter is untyped or a rest element. Unlike
+ * getPropsTypeNameFromParam, this returns the raw TypeNode (e.g. the whole
+ * `Omit<ParentProps, 'children'>`) so it can be tested for composition.
+ */
+function getFirstParamTypeNode(funcNode) {
+    const firstParam = funcNode.params[0];
+    if (!firstParam)
+        return null;
+    if ((firstParam.type === utils_1.AST_NODE_TYPES.Identifier ||
+        firstParam.type === utils_1.AST_NODE_TYPES.ObjectPattern) &&
+        firstParam.typeAnnotation) {
+        return firstParam.typeAnnotation.typeAnnotation;
+    }
+    return null;
+}
+/**
+ * Resolve the function node for a component name in the program, following a
+ * single-identifier alias (`const Live = LiveUnmemoized`) and unwrapping a HOC
+ * call (`memo((props) => ...)`). Returns null when no function is found. The
+ * `seen` set guards against alias cycles.
+ */
+function findComponentFunction(program, name, seen = new Set()) {
+    if (seen.has(name))
+        return null;
+    seen.add(name);
+    for (const stmt of program.body) {
+        const decl = stmt.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration
+            ? stmt.declaration
+            : stmt;
+        if (!decl)
+            continue;
+        if (decl.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+            decl.id?.name === name) {
+            return decl;
+        }
+        if (decl.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            for (const declarator of decl.declarations) {
+                if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    declarator.id.name !== name ||
+                    !declarator.init) {
+                    continue;
+                }
+                const init = declarator.init;
+                if (init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    init.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    return init;
+                }
+                if (init.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const arg0 = init.arguments[0];
+                    if (arg0 &&
+                        (arg0.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                            arg0.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                        return arg0;
+                    }
+                }
+                if (init.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return findComponentFunction(program, init.name, seen);
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolve the type node that defines a rendered dependency's props: its
+ * `{Dep}Props` alias if one exists, otherwise the dependency component's
+ * first-parameter type annotation. Used to detect inverse composition, where
+ * the child derives its props from the parent's props type.
+ */
+function getDependencyPropsSourceType(program, depName) {
+    const alias = findPropsTypeAliasByName(program, toPropsTypeName(depName));
+    if (alias) {
+        return alias.typeAnnotation;
+    }
+    const fn = findComponentFunction(program, depName);
+    if (fn) {
+        return getFirstParamTypeNode(fn);
+    }
+    return null;
+}
 exports.requirePropsComposition = (0, createRule_1.createRule)({
     name: 'require-props-composition',
     meta: {
@@ -384,7 +466,20 @@ exports.requirePropsComposition = (0, createRule_1.createRule)({
             const missingComposition = [];
             for (const dep of depComponents) {
                 const expectedPropsType = toPropsTypeName(dep);
-                const composes = typeNodeComposesWithProps(propsTypeNode, expectedPropsType);
+                let composes = typeNodeComposesWithProps(propsTypeNode, expectedPropsType);
+                // Inverse composition: the child derives its props FROM this parent's
+                // props type (e.g. `Omit<ParentProps, 'children'>`, often with no named
+                // ChildProps at all). The parent is then the single shared source of
+                // truth, so the DRY guarantee is already met; requiring the parent to
+                // *also* compose from ChildProps would invert the source of truth or
+                // create a circular dependency.
+                if (!composes && propsTypeName) {
+                    const depPropsSource = getDependencyPropsSourceType(prog, dep);
+                    if (depPropsSource &&
+                        typeNodeComposesWithProps(depPropsSource, propsTypeName)) {
+                        composes = true;
+                    }
+                }
                 if (composes) {
                     composedWith.add(dep);
                 }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,56 @@
 [
+  {
+    "version": "1.18.14",
+    "date": "2026-07-13T08:30:23.444Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1291
+        ],
+        "summary": "treat non-literal computed keys as whole-object access (closes #1291)"
+      }
+    ]
+  },
+  {
+    "version": "1.18.13",
+    "date": "2026-07-13T01:43:11.918Z",
+    "rules": [
+      {
+        "name": "no-compositing-layer-props",
+        "changeType": "fix",
+        "issues": [
+          1288
+        ],
+        "summary": "exempt transform/opacity inside @keyframes (closes #1288)"
+      },
+      {
+        "name": "parallelize-async-operations",
+        "changeType": "fix",
+        "issues": [
+          1287
+        ],
+        "summary": "don't flag write-then-read on the same receiver (closes #1287)"
+      },
+      {
+        "name": "react-memoize-literals",
+        "changeType": "fix",
+        "issues": [
+          1290
+        ],
+        "summary": "exempt Array iteration callbacks (.map/.filter/...) (closes #1290)"
+      },
+      {
+        "name": "require-props-composition",
+        "changeType": "fix",
+        "issues": [
+          1289
+        ],
+        "summary": "recognize inverse composition (child derives from parent) (closes #1289)"
+      }
+    ]
+  },
   {
     "version": "1.18.12",
     "date": "2026-07-12T03:45:44.071Z",