@blumintinc/eslint-plugin-blumint 1.20.161 → 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.161',
+        version: '1.20.163',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/no-hungarian.js

@@ -155,6 +155,53 @@ const DOMAIN_SYMBOL_HEAD_NOUNS = new Set([
     'unicode',
     'ascii',
 ]);
+// Domain head nouns that legitimately precede a "Class" suffix. In
+// <taxonomy>Class the trailing "Class" is the HEAD NOUN of the domain concept —
+// the BUCKET a value falls into — not the JavaScript `class` construct bolted
+// onto the name. "Window size class" is the Material Design 3 / UIKit term for
+// a breakpoint bucket (compact/medium/expanded), a regex *character class* is
+// `[a-z]`, an S3 *storage class* is "STANDARD" — in each case the value is a
+// string or number map, so there is no type marker to strip: removing the
+// suffix yields a wrong name (WINDOW_SIZE names a width, not a bucket). Same
+// reasoning as the <entity>Number (#1277) and <domain>Symbol (#1835)
+// carve-outs, applied to the taxonomy sense of "class" (#2030).
+//
+// Nouns whose <noun>Class reads as a tag on a JS class value — user, config,
+// helper, base, model, controller, wrapper — are intentionally ABSENT, so
+// UserClass / userClass / HELPER_CLASS stay flagged, as do all PREFIX uses
+// (classRegistry, CLASS_MAP). The carve-out is additionally vetoed whenever the
+// declaration syntactically proves a real class (see isClassValuedDeclaration).
+const DOMAIN_CLASS_HEAD_NOUNS = new Set([
+    // Layout / responsive design: M3 and UIKit bucket a window's width into a
+    // "size class".
+    'size',
+    // Regex and linguistics: character class ([a-z]), word class (noun/verb).
+    'character',
+    'word',
+    // Mathematics / CS taxonomy: equivalence class, complexity class (P, NP).
+    'equivalence',
+    'complexity',
+    // Systems / infrastructure: C and S3 storage class, QoS traffic/service
+    // class, USB device class.
+    'storage',
+    'traffic',
+    'service',
+    'device',
+    // Finance: asset class, share class.
+    'asset',
+    'share',
+    // Travel: fare/cabin/booking class (airline RBD codes).
+    'fare',
+    'cabin',
+    'booking',
+    // Categorization by attribute: weight class (boxing), age class, hazard
+    // class (DOT), drug class (pharmacology), vehicle class (DMV).
+    'weight',
+    'age',
+    'hazard',
+    'drug',
+    'vehicle',
+]);
 // Common built-in JavaScript prototype methods
 const BUILT_IN_METHODS = new Set([
     // String methods
@@ -404,6 +451,24 @@ function isDomainSymbolCompound(name) {
     const lastSegment = segments[segments.length - 1];
     return (!!lastSegment && DOMAIN_SYMBOL_HEAD_NOUNS.has(lastSegment.toLowerCase()));
 }
+// Is `name` a domain compound of the form <taxonomy>Class, where the word
+// directly before the trailing "Class" names a bucketing taxonomy
+// (windowSizeClass, characterClass, storageClass)? Only the LAST head segment
+// is consulted, so prefixed variants generalize (currentWindowSizeClass passes)
+// while names whose value is a real JS class keep firing (userClass -> head
+// segment "user", not a taxonomy).
+function isDomainClassCompound(name) {
+    if (!name.endsWith('Class')) {
+        return false;
+    }
+    const head = name.slice(0, -'Class'.length);
+    if (head.length === 0) {
+        return false;
+    }
+    const segments = splitCamelSegments(head);
+    const lastSegment = segments[segments.length - 1];
+    return (!!lastSegment && DOMAIN_CLASS_HEAD_NOUNS.has(lastSegment.toLowerCase()));
+}
 // Does a type annotation denote the JS `symbol` primitive (`symbol` or the
 // declaration-site form `unique symbol`)?
 function isSymbolTypeAnnotation(node) {
@@ -476,6 +541,43 @@ function isSymbolTypedDeclaration(node) {
             return false;
     }
 }
+// Does a type annotation denote a class constructor (`new (...) => T`)? Such an
+// annotation is the one syntactic spelling that proves the annotated value is a
+// class without type information.
+function isConstructorTypeAnnotation(node) {
+    return !!node && node.type === utils_1.AST_NODE_TYPES.TSConstructorType;
+}
+// Does the declaration site PROVE, syntactically, that the named value is a JS
+// class? Only a `class` expression initializer, a class declaration's own name,
+// or an explicit constructor-type annotation are conclusive without type
+// information — an aliased constructor (`const sizeClass = User`) is invisible
+// here, which is precisely why the taxonomy carve-out is keyed on the head noun
+// rather than on the type. When this holds, the trailing "Class" genuinely
+// encodes the value's type and the DOMAIN_CLASS_HEAD_NOUNS carve-out is vetoed,
+// so `const SizeClass = class {}` still reports. Mirrors
+// isSymbolTypedDeclaration (#1835).
+function isClassValuedDeclaration(node) {
+    if (isConstructorTypeAnnotation(node.typeAnnotation?.typeAnnotation)) {
+        return true;
+    }
+    const parent = node.parent;
+    if (!parent) {
+        return false;
+    }
+    switch (parent.type) {
+        case utils_1.AST_NODE_TYPES.ClassDeclaration:
+        case utils_1.AST_NODE_TYPES.ClassExpression:
+            return parent.id === node;
+        case utils_1.AST_NODE_TYPES.VariableDeclarator:
+            return (parent.id === node &&
+                parent.init?.type === utils_1.AST_NODE_TYPES.ClassExpression);
+        case utils_1.AST_NODE_TYPES.PropertyDefinition:
+            return (parent.key === node &&
+                parent.value?.type === utils_1.AST_NODE_TYPES.ClassExpression);
+        default:
+            return false;
+    }
+}
 // Rebuild a SCREAMING_SNAKE_CASE identifier's segments into a PascalCase compound
 // (["MATCH","NUMBER"] -> "MatchNumber") so the snake-case branch can reuse the
 // camelCase isDomainNumberCompound / DOMAIN_NUMBER_HEAD_NOUNS exemption verbatim,
@@ -512,7 +614,9 @@ exports.noHungarian = (0, createRule_1.createRule)({
         // interfaces, classes), enabling the semantic-type-concept exemption.
         // `isSymbolTyped` is true when the declaration syntactically proves a JS
         // `symbol` value, which vetoes the <domain>Symbol glyph exemption.
-        function hasTypeMarker(variableName, isTypeName = false, isSymbolTyped = false) {
+        // `isClassValued` is true when the declaration syntactically proves a JS
+        // class value, which vetoes the <taxonomy>Class exemption.
+        function hasTypeMarker(variableName, isTypeName = false, isSymbolTyped = false, isClassValued = false) {
             // Type names whose type-word denotes a concept/relation (StringToNumber,
             // CapitalizedString, FuncKeys, PromiseOrValue) are not Hungarian — the word
             // is part of the type's meaning, like the allowed compound noun PhoneNumber.
@@ -621,6 +725,17 @@ exports.noHungarian = (0, createRule_1.createRule)({
                             isDomainSymbolCompound(screamingSnakePartsToPascalCase(parts))) {
                             return false;
                         }
+                        // A trailing "..._CLASS" whose preceding head noun names a
+                        // bucketing taxonomy (WINDOW_SIZE_CLASS, STORAGE_CLASS) is a
+                        // domain compound, not a type tag — same carve-out as camelCase
+                        // windowSizeClass (#2030), routed through the shared PascalCase
+                        // helper so the two casings cannot diverge (the #1294 asymmetry).
+                        if (normalizedMarker === 'class' &&
+                            index === lastIndex &&
+                            !isClassValued &&
+                            isDomainClassCompound(screamingSnakePartsToPascalCase(parts))) {
+                            return false;
+                        }
                         return true;
                     });
                 });
@@ -695,6 +810,20 @@ exports.noHungarian = (0, createRule_1.createRule)({
                         isDomainSymbolCompound(variableName)) {
                         return false;
                     }
+                    // A trailing "...Class" whose head noun names a bucketing taxonomy
+                    // (windowSizeClass, characterClass, storageClass) is a domain
+                    // compound: the suffix names WHAT the value is (the BUCKET a window
+                    // width falls into — Material Design 3 / UIKit vocabulary), and
+                    // stripping it yields a wrong name (windowSize is a width, not a
+                    // bucket) (#2030). Scoped to the full-word `Class` marker in SUFFIX
+                    // position only, and vetoed when the declaration proves a real
+                    // class, so userClass / classRegistry / `const SizeClass = class {}`
+                    // keep firing.
+                    if (normalizedMarker === 'class' &&
+                        !isClassValued &&
+                        isDomainClassCompound(variableName)) {
+                        return false;
+                    }
                     return true;
                 }
                 // Full type-word markers (non-abbreviations: String, Number, Function,
@@ -770,7 +899,7 @@ exports.noHungarian = (0, createRule_1.createRule)({
             if (isExternalOrBuiltIn(node))
                 return;
             // Check for type markers
-            if (hasTypeMarker(name, isTypeName, isSymbolTypedDeclaration(node))) {
+            if (hasTypeMarker(name, isTypeName, isSymbolTypedDeclaration(node), isClassValuedDeclaration(node))) {
                 context.report({
                     node,
                     messageId: 'noHungarian',

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.161",
+  "version": "1.20.163",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "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",
+    "rules": [
+      {
+        "name": "no-hungarian",
+        "changeType": "fix",
+        "issues": [
+          2030
+        ],
+        "summary": "treat Class as a taxonomy head noun in suffix position (closes #2030)"
+      }
+    ]
+  },
   {
     "version": "1.20.161",
     "date": "2026-08-17T13:22:13.676Z",