@blumintinc/eslint-plugin-blumint 1.15.0 → 1.16.1

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

@@ -32,6 +32,21 @@ const COMPOSITING_VALUES = new Set([
     'translateZ',
     'transparent',
 ]);
+// CSS reset/identity values that explicitly DON'T promote a layer for a given
+// property. These are the opt-out counterparts to COMPOSITING_VALUES: `none`
+// removes the effect, `auto`/global keywords disable the hint, and the default
+// keyword leaves the element un-promoted. Keyed by normalized property name so
+// the allowlist stays property-specific (e.g. `none` clears `transform` but is
+// not a valid no-op for `opacity`).
+const NON_COMPOSITING_VALUES = {
+    filter: new Set(['none']),
+    'backdrop-filter': new Set(['none']),
+    transform: new Set(['none']),
+    contain: new Set(['none']),
+    perspective: new Set(['none']),
+    'will-change': new Set(['auto', 'unset', 'initial', 'inherit', 'revert']),
+    'backface-visibility': new Set(['visible']),
+};
 exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     name: 'no-compositing-layer-props',
     meta: {
@@ -54,6 +69,14 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                 value.includes('scale3d') ||
                 value.includes('translateZ'));
         }
+        // Strip `!important` and normalize casing so reset/identity values written
+        // as e.g. `none !important` are still recognized as non-promoting.
+        function normalizePropertyValue(value) {
+            return value
+                .replace(/\s*!important\s*$/i, '')
+                .trim()
+                .toLowerCase();
+        }
         function checkProperty(propertyName, propertyValue) {
             const normalizedName = normalizePropertyName(propertyName);
             if (COMPOSITING_PROPERTIES.has(normalizedName)) {
@@ -66,6 +89,14 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                         return false;
                     return numValue > 0 && numValue < 1;
                 }
+                // CSS reset/identity values can't create a compositing layer, so don't
+                // flag them (mirrors the opacity value-awareness for the other props).
+                const allowedValues = NON_COMPOSITING_VALUES[normalizedName];
+                if (allowedValues &&
+                    propertyValue &&
+                    allowedValues.has(normalizePropertyValue(propertyValue))) {
+                    return false;
+                }
                 return true;
             }
             if (propertyValue && checkPropertyValue(propertyValue)) {

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

@@ -55,6 +55,16 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
         return false;
     }
 }
+function unwrapExpression(expr) {
+    let current = expr;
+    while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+        current.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+        current = current.expression;
+    }
+    return current;
+}
 function getObjectUsagesInHook(hookBody, objectName, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 context) {
@@ -126,12 +136,12 @@ context) {
                 // For computed properties with variables (like user[key]), we need the entire object
                 if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     // Check if this is accessing our target object
-                    let current = memberExpr.object;
-                    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        current = current.object;
+                    let currentBase = unwrapExpression(memberExpr.object);
+                    while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        currentBase = unwrapExpression(currentBase.object);
                     }
-                    if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        current.name === objectName) {
+                    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
                         needsEntireObject = true;
                     }
@@ -173,29 +183,29 @@ context) {
                     (ARRAY_METHODS.has(memberExpr.property.name) ||
                         STRING_METHODS.has(memberExpr.property.name))) {
                     // Check if this is accessing our target object or a property of it
-                    let current = memberExpr.object;
+                    let currentBase = unwrapExpression(memberExpr.object);
                     let pathParts = [];
-                    let hasOptionalChaining = false;
+                    let hasOptionalChainingInMethod = false;
                     // Build the path to the array/string being accessed
-                    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        const currentMember = current;
+                    while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const currentMember = currentBase;
                         if (currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                             pathParts.unshift(currentMember.property.name);
                         }
                         if (currentMember.optional) {
-                            hasOptionalChaining = true;
+                            hasOptionalChainingInMethod = true;
                         }
-                        current = currentMember.object;
+                        currentBase = unwrapExpression(currentMember.object);
                     }
-                    if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        current.name === objectName) {
+                    if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        currentBase.name === objectName) {
                         if (pathParts.length === 0) {
                             // Direct method call on the object (e.g., userData.map(...))
                             needsEntireObject = true;
                         }
                         else {
                             // Method call on a property (e.g., userData.items.map(...) or userData?.items?.map(...))
-                            let path = objectName + (hasOptionalChaining ? '?' : '');
+                            let path = objectName + (hasOptionalChainingInMethod ? '?' : '');
                             path += '.' + pathParts.join('.');
                             usages.set(path, memberExpr.range?.[0] || 0);
                         }
@@ -207,11 +217,11 @@ context) {
             if (memberExpr.optional) {
                 hasOptionalChaining = true;
             }
-            current = memberExpr.object;
+            current = unwrapExpression(memberExpr.object);
         }
         // Check if we reached the target identifier
-        if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-            current.name === objectName) {
+        const base = unwrapExpression(current);
+        if (base.type === utils_1.AST_NODE_TYPES.Identifier && base.name === objectName) {
             // Build the path with optional chaining
             let path = objectName + (hasOptionalChaining ? '?' : '');
             // Add each part with proper formatting (dot notation or bracket notation)
@@ -231,47 +241,57 @@ context) {
         if (!node || visited.has(node))
             return;
         visited.add(node);
-        // Direct usage of the target identifier to distinguish between:
-        // 1. Never used (not even present) → suggest removal
-        // 2. Used in ways requiring entire object → no suggestion
-        // 3. Used only via specific fields → suggest replacing with fields
         if (node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === objectName) {
-            const parent = node.parent;
+            // Skip TS type assertions, ChainExpression and TSNonNullExpression wrappers
+            // (used around the Identifier) so we can attribute the Identifier's usage
+            // to its actual parent context (e.g., call/member/assignment) and avoid
+            // misclassifying the dependency when determining if the whole object is referenced.
+            let wrapperNode = node;
+            let effectiveParent = node.parent;
+            while (effectiveParent &&
+                (effectiveParent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
+                wrapperNode = effectiveParent;
+                effectiveParent = effectiveParent.parent;
+            }
             // Exclude: property name in `other.objectName` (not our target object)
-            const isMemberProperty = parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                parent.property === node &&
-                !parent.computed;
+            const isMemberProperty = effectiveParent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                effectiveParent.property === wrapperNode &&
+                !effectiveParent.computed;
             // Exclude: object in `objectName.prop` (handled by MemberExpression visitor for field tracking)
-            const isMemberObject = parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                parent.object === node;
+            const isMemberObject = effectiveParent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                effectiveParent.object === wrapperNode;
             // Exclude: key in `{ objectName: value }` (not usage, just a label)
             // Include: shorthand `{ objectName }` (actual usage)
-            const isPropertyKey = parent?.type === utils_1.AST_NODE_TYPES.Property &&
-                parent.key === node &&
-                !parent.computed &&
-                !parent.shorthand;
+            const isPropertyKey = effectiveParent?.type === utils_1.AST_NODE_TYPES.Property &&
+                effectiveParent.key === wrapperNode &&
+                !effectiveParent.computed &&
+                !effectiveParent.shorthand;
             if (!isMemberProperty && !isMemberObject && !isPropertyKey) {
                 isUsed = true;
                 // Patterns that require the entire object (cannot refactor to specific fields)
-                const isTypeAUsage = parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
-                    parent?.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
-                    parent?.type === utils_1.AST_NODE_TYPES.BinaryExpression ||
-                    parent?.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
-                    parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
-                    parent?.type === utils_1.AST_NODE_TYPES.UnaryExpression ||
-                    (parent?.type === utils_1.AST_NODE_TYPES.Property &&
-                        (parent.value === node ||
-                            parent.shorthand ||
-                            (parent.key === node && parent.computed))) ||
-                    parent?.type === utils_1.AST_NODE_TYPES.TemplateLiteral ||
-                    parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
-                    parent?.type === utils_1.AST_NODE_TYPES.AssignmentExpression ||
-                    parent?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer ||
-                    parent?.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute ||
-                    parent?.type === utils_1.AST_NODE_TYPES.SpreadElement ||
-                    parent?.type === utils_1.AST_NODE_TYPES.ForInStatement ||
-                    parent?.type === utils_1.AST_NODE_TYPES.ForOfStatement ||
-                    parent?.type === utils_1.AST_NODE_TYPES.CallExpression;
+                const isTypeAUsage = effectiveParent?.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.BinaryExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.UnaryExpression ||
+                    (effectiveParent?.type === utils_1.AST_NODE_TYPES.Property &&
+                        (effectiveParent.value === wrapperNode ||
+                            effectiveParent.shorthand ||
+                            (effectiveParent.key === wrapperNode &&
+                                effectiveParent.computed))) ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.TemplateLiteral ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.SpreadElement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ForInStatement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ForOfStatement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.CallExpression;
                 if (isTypeAUsage) {
                     needsEntireObject = true;
                 }
@@ -279,13 +299,16 @@ context) {
         }
         if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
             // Check if the object is being called as a function
-            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.callee.name === objectName) {
+            const callee = unwrapExpression(node.callee);
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.name === objectName) {
                 needsEntireObject = true;
             }
             // Check if the object is directly passed as an argument
             node.arguments.forEach((arg) => {
-                if (arg.type === utils_1.AST_NODE_TYPES.Identifier && arg.name === objectName) {
+                const unwrappedArg = unwrapExpression(arg);
+                if (unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    unwrappedArg.name === objectName) {
                     needsEntireObject = true;
                 }
             });
@@ -295,18 +318,21 @@ context) {
             // If we find a JSX element, check its attributes for spread operator
             if (node.type === utils_1.AST_NODE_TYPES.JSXElement) {
                 node.openingElement.attributes.forEach((attr) => {
-                    if (attr.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute &&
-                        attr.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        attr.argument.name === objectName) {
-                        needsEntireObject = true;
+                    if (attr.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute) {
+                        const argument = unwrapExpression(attr.argument);
+                        if (argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            argument.name === objectName) {
+                            needsEntireObject = true;
+                        }
                     }
                 });
             }
         }
         else if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
             // If we find a spread operator with our target object, consider it as accessing all properties
-            if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.argument.name === objectName) {
+            const argument = unwrapExpression(node.argument);
+            if (argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                argument.name === objectName) {
                 needsEntireObject = true;
                 return;
             }
@@ -314,43 +340,51 @@ context) {
         else if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             // Check if this is accessing a property of our target object
             const memberExpr = node;
-            // Only process if this is the outermost member expression in a chain
-            // (i.e., its parent is not also a member expression)
-            const parent = memberExpr.parent;
-            if (parent && parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                // This is an intermediate member expression, skip it
-                return;
+            // Skip TS type assertions, ChainExpression and TSNonNullExpression wrappers
+            // so we can attribute the MemberExpression's usage to its actual parent
+            // context and avoid misclassifying the dependency.
+            // We only process if this is the outermost member expression in a chain.
+            let effectiveParent = memberExpr.parent;
+            while (effectiveParent &&
+                (effectiveParent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
+                effectiveParent = effectiveParent.parent;
             }
-            // Check if this member expression involves our target object
-            let current = memberExpr;
-            let foundTargetObject = false;
-            let hasDynamicComputed = false;
-            // 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
-                if (currentMember.computed &&
-                    currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    hasDynamicComputed = true;
+            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;
+                let foundTargetObject = false;
+                let hasDynamicComputed = false;
+                // 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
+                    if (currentMember.computed &&
+                        currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        hasDynamicComputed = true;
+                    }
+                    current = unwrapExpression(currentMember.object);
                 }
-                current = currentMember.object;
-            }
-            // Check if we reached our target object
-            if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-                current.name === objectName) {
-                foundTargetObject = true;
-            }
-            if (foundTargetObject) {
-                if (hasDynamicComputed) {
-                    // Dynamic computed property access means we need the entire object
-                    needsEntireObject = true;
-                    return;
+                // Check if we reached our target object
+                const base = unwrapExpression(current);
+                if (base.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    base.name === objectName) {
+                    foundTargetObject = true;
                 }
-                else {
-                    // Static property access - add to usages
-                    const path = buildAccessPath(memberExpr);
-                    if (path) {
-                        usages.set(path, memberExpr.range?.[0] || 0);
+                if (foundTargetObject) {
+                    if (hasDynamicComputed) {
+                        // Dynamic computed property access means we need the entire object
+                        needsEntireObject = true;
+                    }
+                    else {
+                        // Static property access - add to usages
+                        const path = buildAccessPath(memberExpr);
+                        if (path) {
+                            usages.set(path, memberExpr.range?.[0] || 0);
+                        }
                     }
                 }
             }
@@ -533,16 +567,17 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                 }
                 // Check each dependency in the array
                 depsArg.elements.forEach((element) => {
-                    if (!element)
+                    const unwrappedElement = element ? unwrapExpression(element) : null;
+                    if (!unwrappedElement)
                         return; // Skip null elements (holes in the array)
-                    if (element.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const objectName = element.name;
+                    if (unwrappedElement.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const objectName = unwrappedElement.name;
                         // Skip type checking if we don't have TypeScript services
                         if (hasFullTypeChecking && parserServices) {
                             const checker = parserServices.program.getTypeChecker();
                             const nodeMap = parserServices.esTreeNodeToTSNodeMap;
                             // Skip if the dependency is an array or primitive type
-                            if (isArrayOrPrimitive(checker, element, nodeMap)) {
+                            if (isArrayOrPrimitive(checker, unwrappedElement, nodeMap)) {
                                 return;
                             }
                         }

package/lib/rules/no-explicit-return-type.js

@@ -225,6 +225,12 @@ function isTypeGuardFunction(node) {
     // Check for type predicates (is keyword)
     if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate)
         return true;
+    // `never` is never inferred: TypeScript infers `void` for a function whose
+    // every path throws, so an explicit `: never` always carries more information
+    // than inference (callers rely on it for control-flow narrowing and
+    // exhaustiveness). Removing it would silently widen the type to `void`.
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSNeverKeyword)
+        return true;
     // Check for assertion functions (asserts keyword)
     if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
         const typeName = typeAnnotation.typeName;

package/lib/rules/no-hungarian.js

@@ -17,8 +17,10 @@ const COMMON_TYPES = [
     'Symbol',
     'BigInt',
 ];
-// Combined type markers (former Hungarian prefixes and type suffixes)
-const TYPE_MARKERS = [
+// Abbreviation type markers (e.g. str, arr, obj). No English word is spelled this
+// way, so their presence as a segment — even in the middle of a name — is
+// unambiguously a type tag (strName, USER_STR_NAME, ConfigArrSettings).
+const ABBREVIATION_MARKERS = [
     'str',
     'num',
     'int',
@@ -27,6 +29,10 @@ const TYPE_MARKERS = [
     'obj',
     'fn',
     'func',
+];
+// Combined type markers (former Hungarian prefixes and type suffixes)
+const TYPE_MARKERS = [
+    ...ABBREVIATION_MARKERS,
     'array',
     ...COMMON_TYPES,
     'Class',
@@ -34,6 +40,20 @@ const TYPE_MARKERS = [
     //'Type', people like to use 'type' as a general purpose noun
     'Enum',
 ];
+const ABBREVIATION_MARKER_SET = new Set(ABBREVIATION_MARKERS);
+// Single-letter Hungarian type prefixes (b=boolean, i=integer/index).
+// Only matched as a strict camelCase prefix (e.g. bIsActive, iCount); never as
+// a suffix/middle/SCREAMING_SNAKE segment, where a lone letter is almost always
+// a real word fragment (tab, lib, ui) rather than a type tag.
+const SINGLE_LETTER_PREFIXES = new Set(['b', 'i']);
+// Full type-concept words (spelled out). When one of these appears as a clean
+// PascalCase segment inside a multi-word TYPE name (alias/interface/class), it
+// denotes a type concept/relation (e.g. StringToNumber, CapitalizedString,
+// PromiseOrValue) rather than a redundant Hungarian type tag — comparable to the
+// allowed compound noun PhoneNumber. Abbreviation markers (str/arr/obj/...) are
+// deliberately excluded: no English word is spelled that way, so their presence
+// as a segment is unambiguously a type tag even inside a type name.
+const FULL_TYPE_WORDS = new Set([...COMMON_TYPES, 'Func'].map((word) => word.toLowerCase()));
 // Allowed descriptive suffixes that should not be flagged as Hungarian notation
 const ALLOWED_SUFFIXES = [
     'Formatted',
@@ -190,6 +210,30 @@ const BUILT_IN_METHODS = new Set([
     'catch',
     'finally',
 ]);
+// Split a PascalCase/camelCase identifier into its word segments
+// (e.g. "StringToNumber" -> ["String","To","Number"], "FuncKeys" -> ["Func","Keys"]).
+function splitCamelSegments(name) {
+    return name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g) ?? [];
+}
+// A TYPE name (alias/interface/class) is exempt from a full-type-word marker when
+// that marker is one clean PascalCase segment among OTHER descriptive segments —
+// i.e. the word denotes a type concept/relation, not a redundant type tag.
+// Examples: StringToNumber, CapitalizedString, PromiseOrValue, FuncKeys.
+// Abbreviation markers (str/arr/obj/...) never qualify, so genuine Hungarian type
+// names like UserStrName / ConfigArrSettings / UserObjData still fire.
+function isSemanticTypeConcept(typeName) {
+    const segments = splitCamelSegments(typeName);
+    if (segments.length < 2) {
+        return false;
+    }
+    const fullTypeWordSegments = segments.filter((segment) => FULL_TYPE_WORDS.has(segment.toLowerCase()));
+    if (fullTypeWordSegments.length === 0) {
+        return false;
+    }
+    // At least one segment must be a non-type-word descriptor so the name reads as a
+    // concept (e.g. Extract+Number) rather than bare type tags glued together.
+    return segments.some((segment) => !FULL_TYPE_WORDS.has(segment.toLowerCase()));
+}
 exports.noHungarian = (0, createRule_1.createRule)({
     name: 'no-hungarian',
     meta: {
@@ -208,8 +252,28 @@ exports.noHungarian = (0, createRule_1.createRule)({
     create(context) {
         // Track identifiers that have already been checked to prevent double reporting
         const checkedIdentifiers = new Set();
-        // Check if a variable name contains a type marker with proper word boundaries
-        function hasTypeMarker(variableName) {
+        // Names declared as generic type parameters (e.g. TNumber, TKey). The leading
+        // `T` is the TypeScript convention for "Type parameter", not a Hungarian tag,
+        // so neither the declaration nor any reference to it is ever flagged.
+        const typeParameterNames = new Set();
+        // Check if a variable name contains a type marker with proper word boundaries.
+        // `isTypeName` is true for PascalCase type declarations (type aliases,
+        // interfaces, classes), enabling the semantic-type-concept exemption.
+        function hasTypeMarker(variableName, isTypeName = 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.
+            if (isTypeName && isSemanticTypeConcept(variableName)) {
+                return false;
+            }
+            // Single-letter Hungarian prefixes (bIsActive, iCount): a lone b/i directly
+            // followed by an uppercase letter is a type tag. Restricted to camelCase
+            // (lowercase first letter) to avoid PascalCase type names like IButton.
+            if (variableName.length > 1 &&
+                SINGLE_LETTER_PREFIXES.has(variableName[0]) &&
+                /[A-Z]/.test(variableName[1])) {
+                return true;
+            }
             // Check if the variable name is exactly one of the allowed compound nouns
             // or if it contains one of the allowed compound nouns but is not a prefix like "strPhoneNumber"
             for (const compoundNoun of ALLOWED_COMPOUND_NOUNS) {
@@ -244,22 +308,28 @@ exports.noHungarian = (0, createRule_1.createRule)({
                 if (!variableName.includes('_')) {
                     return false;
                 }
+                const parts = variableName.split('_');
+                const lastIndex = parts.length - 1;
                 return TYPE_MARKERS.some((marker) => {
                     const markerUpper = marker.toUpperCase();
-                    // Check if it's a prefix (PREFIX_REST)
-                    if (variableName.startsWith(markerUpper + '_') &&
-                        variableName.length > markerUpper.length + 1) {
-                        return true;
-                    }
-                    // Check if it's a suffix (REST_SUFFIX)
-                    if (variableName.endsWith('_' + markerUpper) &&
-                        variableName.length > markerUpper.length + 1) {
-                        return true;
-                    }
-                    // Check if it's in the middle (PART_MARKER_PART)
-                    const parts = variableName.split('_');
-                    // Only consider exact matches for parts, not substrings
-                    return parts.some((part) => part === markerUpper);
+                    const normalizedMarker = marker.toLowerCase();
+                    const isAbbreviation = ABBREVIATION_MARKER_SET.has(normalizedMarker);
+                    return parts.some((part, index) => {
+                        if (part !== markerUpper) {
+                            return false;
+                        }
+                        // Abbreviation markers (STR/ARR/OBJ/...) are type tags in any
+                        // position — no English word is spelled that way.
+                        if (isAbbreviation) {
+                            return true;
+                        }
+                        // A FULL type word tags the entity's type only at the start (prefix),
+                        // the end (suffix), or directly before the final noun
+                        // (..._STRING_NAME). Buried deeper (EDITABLE_WRAPPER_NUMBER_PROPS_…)
+                        // it qualifies an intermediate segment — a descriptive variant, not a
+                        // type tag.
+                        return (index === 0 || index === lastIndex || index === lastIndex - 1);
+                    });
                 });
             }
             // For camelCase, PascalCase, etc.
@@ -328,9 +398,27 @@ exports.noHungarian = (0, createRule_1.createRule)({
             }
             return false;
         }
-        // Check identifier for type markers (Hungarian notation)
-        function checkIdentifier(node) {
+        // Determine whether an identifier is (or references) a generic type parameter.
+        function isTypeParameter(node) {
+            // The type-parameter declaration itself: <TNumber>
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.TSTypeParameter &&
+                node.parent.name === node) {
+                return true;
+            }
+            // A reference to a declared type parameter (e.g. x: TNumber).
+            return typeParameterNames.has(node.name);
+        }
+        // Check identifier for type markers (Hungarian notation).
+        // `isTypeName` enables the semantic-type-concept exemption for type
+        // declarations (aliases, interfaces, classes).
+        function checkIdentifier(node, isTypeName = false) {
             const name = node.name;
+            // Generic type parameters (TNumber, TKey, ...) are a TypeScript naming
+            // convention, never Hungarian — skip the declaration and all references.
+            if (isTypeParameter(node)) {
+                return;
+            }
             // Create a unique ID for this node to avoid checking it twice
             // Use the name along with source location for uniqueness
             const nodeId = `${name}:${node.loc.start.line}:${node.loc.start.column}`;
@@ -344,7 +432,7 @@ exports.noHungarian = (0, createRule_1.createRule)({
             if (isExternalOrBuiltIn(node))
                 return;
             // Check for type markers
-            if (hasTypeMarker(name)) {
+            if (hasTypeMarker(name, isTypeName)) {
                 context.report({
                     node,
                     messageId: 'noHungarian',
@@ -388,10 +476,17 @@ exports.noHungarian = (0, createRule_1.createRule)({
                     }
                 }
             },
+            // Record generic type-parameter names so neither the declaration nor any
+            // reference to them is flagged (the leading `T` is a TS convention).
+            TSTypeParameter(node) {
+                if (node.name.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    typeParameterNames.add(node.name.name);
+                }
+            },
             // Check class declarations
             ClassDeclaration(node) {
                 if (node.id) {
-                    checkIdentifier(node.id);
+                    checkIdentifier(node.id, true);
                 }
                 // Check class methods and properties
                 for (const member of node.body.body) {
@@ -421,11 +516,11 @@ exports.noHungarian = (0, createRule_1.createRule)({
             },
             // Check type aliases
             TSTypeAliasDeclaration(node) {
-                checkIdentifier(node.id);
+                checkIdentifier(node.id, true);
             },
             // Check interface declarations
             TSInterfaceDeclaration(node) {
-                checkIdentifier(node.id);
+                checkIdentifier(node.id, true);
             },
         };
     },