@blumintinc/eslint-plugin-blumint 1.20.162 → 1.20.163

package/lib/index.js

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

package/lib/rules/prefer-clone-deep.js

@@ -34,15 +34,13 @@ function isConstAssertion(node) {
 /**
  * A `const` assertion is legal only on a literal, so leaving one wrapped around
  * the emitted `cloneDeep(...)` call yields TS1355 and turns a compiling file
- * into a broken one (#2011). The fix is declined there rather than absorbing
- * the assertion, which is the conservative reading of a `const` the author
- * asked for on a value this rule replaces.
+ * into a broken one (#2011).
  *
- * The whole assertion chain is walked because each of its links still applies
- * to the emitted call: `as Foo as const`, `satisfies Foo as const` and
- * `! as const` are TS1355 just the same. The walk stops at the first parent
- * that is not an assertion, which keeps `as const` on an ENCLOSING literal
- * fixable — that assertion still has a literal to apply to.
+ * The whole assertion chain above `node` is walked because each of its links
+ * still applies to the emitted call: `as Foo as const`, `satisfies Foo as
+ * const` and `! as const` are TS1355 just the same. The walk stops at the first
+ * parent that is not an assertion, which keeps `as const` on an ENCLOSING
+ * literal fixable — that assertion still has a literal to apply to.
  *
  * Only a `const` assertion is disqualifying: `as Foo` and `satisfies Foo` are
  * legal on a call expression and keep their fix.
@@ -60,6 +58,30 @@ function isConstAsserted(node) {
     }
     return false;
 }
+/**
+ * The node the `cloneDeep(...)` call replaces for a rewritten literal, or null
+ * where the fix has to be declined.
+ *
+ * A `const` assertion applied DIRECTLY to the literal (`{ ... } as const`,
+ * optionally followed by `as Foo`, `satisfies Foo` or `!`) is absorbed: the
+ * replaced range covers the assertion, so the call takes its place with no
+ * `as const` left to wrap it. The emitted call already spells `as const` on its
+ * overrides literal, which is the only place a `const` assertion stays legal
+ * after the rewrite, so the author's literal typing lands there. Absorbing it
+ * is also what keeps the fix reachable under a composed `--fix`:
+ * `global-const-style` wins the range race on a module-scope constant and
+ * appends `as const` before this rule's turn, and declining on that assertion
+ * would report the hazard forever without ever fixing it (#2032).
+ *
+ * A `const` assertion behind another link (`as Foo as const`) cannot be
+ * absorbed without dropping the intervening assertion, and it would still wrap
+ * the emitted call — TS1355 either way — so the fix is declined there.
+ */
+function rewriteSiteOf(target) {
+    const parent = target.parent;
+    const site = parent && isConstAssertion(parent) ? parent : target;
+    return isConstAsserted(site) ? null : site;
+}
 exports.preferCloneDeep = (0, createRule_1.createRule)({
     name: 'prefer-clone-deep',
     meta: {
@@ -479,14 +501,15 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                                     return null;
                                 }
                                 for (const target of targets) {
-                                    if (isConstAsserted(target)) {
+                                    const site = rewriteSiteOf(target);
+                                    if (site === null) {
                                         return null;
                                     }
                                     const call = buildCloneDeepCall(target);
                                     if (call === null) {
                                         return null;
                                     }
-                                    rewrites.push(fixer.replaceText(target, call));
+                                    rewrites.push(fixer.replaceText(site, call));
                                 }
                                 return rewrites;
                             },

package/lib/rules/require-memoize-jsx-returners.js

@@ -12,6 +12,25 @@ const MEMOIZE_MODULES = new Set([
     'typescript-memoize',
 ]);
 const MEMOIZE_EXPORT_NAME = 'Memoize';
+/**
+ * The base classes React ships for class components. A class extending one of
+ * them hands its `render()` to React, which re-invokes it on every state and
+ * props change by contract (see `isReactComponentClass`).
+ */
+const REACT_COMPONENT_BASE_NAMES = new Set(['Component', 'PureComponent']);
+const RENDER_METHOD_NAME = 'render';
+/**
+ * The wrappers `unwrapSuperClass` strips. `ChainExpression` is ESTree's
+ * envelope for `extends X?.Component`, which is grammatical and, whenever the
+ * receiver is defined, means exactly `X.Component`.
+ */
+const SUPERCLASS_WRAPPER_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.ChainExpression,
+]);
 function isMemoizeDecorator(decorator, alias, namespaceAlias) {
     const expression = decorator.expression;
     const matchesAliasIdentifier = (node) => !!node && node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === alias;
@@ -46,6 +65,100 @@ function isMemoizeDecorator(decorator, alias, namespaceAlias) {
     }
     return false;
 }
+/**
+ * The expression a class extends, with the wrappers an author can put around it
+ * stripped: `extends (React.Component)`, `extends (Component as any)`,
+ * `extends Base!`, `extends React?.Component`. The type arguments in
+ * `extends Component<Props, State>` live on `superTypeParameters` and never
+ * reach here.
+ */
+function unwrapSuperClass(expression) {
+    let current = expression;
+    for (;;) {
+        if (isParenthesizedExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        // Compared as strings: `superClass` is typed as a LeftHandSideExpression,
+        // which excludes the assertion forms the parser nevertheless yields there.
+        if (SUPERCLASS_WRAPPER_TYPES.has(current.type)) {
+            current = current
+                .expression;
+            continue;
+        }
+        return current;
+    }
+}
+/**
+ * Whether the class hands its `render()` to React — that is, whether it extends
+ * React's `Component` or `PureComponent`.
+ *
+ * The match is keyed on React's VOCABULARY, not on the binding's provenance: a
+ * superclass spelled `Component` or `PureComponent` qualifies wherever the name
+ * is bound — an unaliased `import { Component } from 'react'`, an ambient
+ * global, a fixture that omits the import — and so does `X.Component` /
+ * `X.PureComponent` through any namespace object (`React.Component`,
+ * `Preact.PureComponent`, an aliased default import). Only where the spelling
+ * carries no vocabulary is the binding resolved through the scope chain: an
+ * import specifier renamed away from those names
+ * (`import { Component as ReactComponent } from 'react'`) and a same-file class
+ * that itself extends one of them (`class Base extends React.Component {}` …
+ * `class Boundary extends Base {}`). A superclass whose name is neither of
+ * those and resolves to nothing React-shaped in this file — `extends Base` from
+ * another module — is NOT treated as a component.
+ *
+ * Provenance is deliberately not verified: `class Foo extends Component` where
+ * `Component` is an unrelated local class is a corner case whose cost is one
+ * unreported factory named `render`, while treating a real component's `render`
+ * as a factory hands `--fix` a decorator that pins the component to its first
+ * output — a silent behavioural break (#2033). A false negative is the cheaper
+ * mistake, so the vocabulary wins.
+ */
+function isReactComponentClass(classNode, context, visited = new Set()) {
+    if (!classNode.superClass || visited.has(classNode)) {
+        return false;
+    }
+    visited.add(classNode);
+    const superClass = unwrapSuperClass(classNode.superClass);
+    if (superClass.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !superClass.computed &&
+        superClass.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return REACT_COMPONENT_BASE_NAMES.has(superClass.property.name);
+    }
+    if (superClass.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (REACT_COMPONENT_BASE_NAMES.has(superClass.name)) {
+        return true;
+    }
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, classNode), superClass.name);
+    if (!variable) {
+        return false;
+    }
+    return variable.defs.some((def) => {
+        const declaration = def.node;
+        if (declaration.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+            declaration.imported.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return REACT_COMPONENT_BASE_NAMES.has(declaration.imported.name);
+        }
+        if (declaration.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            declaration.type === utils_1.AST_NODE_TYPES.ClassExpression) {
+            return isReactComponentClass(declaration, context, visited);
+        }
+        return false;
+    });
+}
+/**
+ * Whether the member is the `render` React calls — the key is read literally,
+ * so a computed `[render]()` naming some other value does not qualify.
+ */
+function isRenderMember(node) {
+    const { key } = node;
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier && !node.computed) {
+        return key.name === RENDER_METHOD_NAME;
+    }
+    return (key.type === utils_1.AST_NODE_TYPES.Literal && key.value === RENDER_METHOD_NAME);
+}
 function getMemberName(node) {
     const key = node.key;
     if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -548,6 +661,30 @@ exports.requireMemoizeJsxReturners = (0, createRule_1.createRule)({
                 if (classBody?.parent?.type === utils_1.AST_NODE_TYPES.ClassExpression) {
                     return;
                 }
+                // React re-invokes a class component's `render()` on every state and
+                // props change BY CONTRACT, so `@Memoize()` there is never a remedy:
+                // it pins the component to the output of its first render. An error
+                // boundary is the sharpest case — it catches, `getDerivedStateFromError`
+                // sets state, React re-renders, and the memoized `render()` hands back
+                // the cached pre-error children, so the fallback can never appear
+                // (#2033). Unlike this rule's compile-breaking autofix defects
+                // (#1414, #1434, #1950, #1951, #1955), the result compiles and lints
+                // clean, so nothing downstream catches it. Report and fix are both
+                // withheld — the message's only remedy is the very edit that breaks
+                // the component. `render` is the ONLY instance lifecycle method that
+                // returns an element (`shouldComponentUpdate` returns a boolean,
+                // `getSnapshotBeforeUpdate` an opaque snapshot, the rest `void`), and
+                // the statics React also calls — `getDerivedStateFromError`,
+                // `getDerivedStateFromProps` — return state and are out of scope above
+                // regardless, so the exemption is keyed on that one name. Other
+                // members of a class component are the author's own factories, called
+                // on the author's schedule, and stay under the rule. Withholding the
+                // report here also keeps `render` out of the import-carrier race below.
+                if (isRenderMember(node) &&
+                    classBody?.parent?.type === utils_1.AST_NODE_TYPES.ClassDeclaration &&
+                    isReactComponentClass(classBody.parent, context)) {
+                    return;
+                }
                 const hasDecorator = node.decorators?.some((decorator) => isMemoizeDecorator(decorator, memoizeAlias, memoizeNamespace));
                 if (hasDecorator) {
                     return;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.163",
+    "date": "2026-08-17T20:02:54.585Z",
+    "rules": [
+      {
+        "name": "prefer-clone-deep",
+        "changeType": "fix",
+        "issues": [
+          2032
+        ],
+        "summary": "absorb a direct `as const` so the composed --fix lands (closes #2032)"
+      },
+      {
+        "name": "require-memoize-jsx-returners",
+        "changeType": "fix",
+        "issues": [
+          2033
+        ],
+        "summary": "exempt render() on a React class component (closes #2033)"
+      }
+    ]
+  },
   {
     "version": "1.20.162",
     "date": "2026-08-17T15:38:50.817Z",