@blumintinc/eslint-plugin-blumint 1.20.160 → 1.20.162

package/lib/index.js

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

package/lib/rules/enforce-react-type-naming.js

@@ -191,6 +191,68 @@ const isGlobalConstStyleGoverned = (declarator) => {
     }
     return (!isDynamicValue(init) && !isBindingAlias(init) && !isJestMockCast(init));
 };
+// `as const` is spelled as a `TSTypeReference` named `const`, so it reaches
+// `getTypeName` like any other type name and has to be excluded by name.
+const isAsConstAssertion = (typeAnnotation) => typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+    typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+    typeAnnotation.typeName.name === 'const';
+/**
+ * The React type an `as`/`<T>` assertion pins on an initializer, or `undefined`.
+ *
+ * An assertion declares the binding's type exactly as bindingly as an
+ * annotation does — `tsc --emitDeclarationOnly` emits the same
+ * `export declare const config: FC;` for `const config: FC = {} as FC` and for
+ * `const config = {} as FC` — so it is a detection carrier, not decoration.
+ * Reading only the annotation made the shipped config's own `--fix` erase this
+ * rule's report: `no-redundant-annotation-assertion` deletes the redundant
+ * ANNOTATION and keeps the assertion (its fix direction is the type-safe one,
+ * since dropping the assertion instead leaves `const config: FC = {}`, TS2322),
+ * so a reported violation became an unreportable one (Issue #2029).
+ *
+ * Only the OUTERMOST assertion applied to the initializer answers. A nested one
+ * describes a sub-expression rather than the binding: in `(e as FC)()` the
+ * binding holds FC's RETURN value, and in `thing as unknown as FC` the
+ * intermediate `unknown` is discarded by the outer `as FC`. Parentheses need no
+ * handling because TSESTree does not model them, so `({} as FC)` IS the
+ * assertion node; `!` does, and is read through — non-nullability cannot change
+ * which React type names the value.
+ *
+ * `satisfies` is excluded because it leaves the expression's type alone
+ * (`{} satisfies FC` is still `{}`), and `as const` names no React type.
+ */
+const assertedTypeOf = (init) => {
+    let target = init ?? undefined;
+    while (target?.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+        target = target.expression;
+    }
+    if (target?.type !== utils_1.AST_NODE_TYPES.TSAsExpression &&
+        target?.type !== utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+        return undefined;
+    }
+    return isAsConstAssertion(target.typeAnnotation)
+        ? undefined
+        : target.typeAnnotation;
+};
+/**
+ * Reports whether this identifier is the NAME of a JSX element (`<Content />`),
+ * as opposed to a value reference inside one (`{Content}`).
+ *
+ * A JSX element name resolves to a binding only while it starts uppercase: the
+ * scope analyzer models `<content />` as an intrinsic host element instead. So
+ * lowercasing such a name does not carry the reference across — it unbinds it,
+ * leaving the declaration orphaned and an unknown HTML tag rendered in its
+ * place. `JSXMemberExpression` is excluded on purpose: a dot always means value
+ * access, so `<ns.Thing />` keeps resolving whatever the case of `ns`.
+ */
+const isJsxElementName = (node) => {
+    const { parent } = node;
+    if (!parent) {
+        return false;
+    }
+    return ((parent.type === utils_1.AST_NODE_TYPES.JSXOpeningElement ||
+        parent.type === utils_1.AST_NODE_TYPES.JSXClosingElement) &&
+        parent.name === node);
+};
 exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
     name: 'enforce-react-type-naming',
     meta: {
@@ -296,6 +358,28 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
                 newName,
             });
         }
+        /**
+         * Reports whether lowercasing this variable's name would unbind a
+         * `<Name />` that resolves to it.
+         *
+         * The rename is withheld there and the report stands alone, on the same
+         * terms as a colliding rename: an incomplete rename is worse than none. The
+         * rewritten element would render an intrinsic host tag while the declaration
+         * it used to name sits unreferenced, which is dead code the fix itself
+         * created — and a consumer building with `noUnusedLocals` gets a red CI out
+         * of running `--fix`.
+         *
+         * Asked of variables only. An unused PARAMETER is an ordinary
+         * signature-driven shape rather than dead code, so the parameter rename
+         * stays as #1357 pinned it.
+         */
+        function renameUnbindsJsxElement(owner, declarationId) {
+            const variable = context
+                .getDeclaredVariables(owner)
+                .find((candidate) => candidate.defs.some((def) => def.name === declarationId));
+            return !!variable?.references.some((reference) => reference.identifier !== declarationId &&
+                isJsxElementName(reference.identifier));
+        }
         /**
          * Check variable declarations for React type naming conventions
          */
@@ -313,8 +397,11 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
             if (isGlobalConstStyleGoverned(node))
                 return;
             const variableName = id.name;
-            // Get the type annotation
-            const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+            // The declared type, from either carrier: the annotation when it is
+            // written, otherwise the assertion that stands in for it (#2029). The
+            // annotation wins when both are present — it is what the binding's type
+            // resolves to — so `const x: unknown = {} as FC` reads `unknown`.
+            const typeAnnotation = id.typeAnnotation?.typeAnnotation ?? assertedTypeOf(node.init);
             const typeName = getTypeName(typeAnnotation);
             if (!typeName)
                 return;
@@ -328,7 +415,9 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
                         type: typeName,
                         suggestion,
                     },
-                    fix: (fixer) => buildRenameFixes(fixer, node, id, suggestion),
+                    fix: (fixer) => renameUnbindsJsxElement(node, id)
+                        ? null
+                        : buildRenameFixes(fixer, node, id, suggestion),
                 });
             }
             // Check if it's a ComponentType or FC (should be uppercase)
@@ -341,6 +430,8 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
                         type: typeName,
                         suggestion,
                     },
+                    // Uppercasing cannot unbind a `<Name />`: the target starts uppercase,
+                    // which is exactly what a JSX element name needs to resolve at all.
                     fix: (fixer) => buildRenameFixes(fixer, node, id, suggestion),
                 });
             }

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/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "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",
+    "rules": [
+      {
+        "name": "enforce-react-type-naming",
+        "changeType": "fix",
+        "issues": [
+          2029
+        ],
+        "summary": "read the type from a type assertion (closes #2029)"
+      }
+    ]
+  },
   {
     "version": "1.20.160",
     "date": "2026-08-17T02:55:06.538Z",