@blumintinc/eslint-plugin-blumint 1.16.2 → 1.17.1

package/lib/rules/no-direct-function-state.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDirectFunctionState = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_FUNCTION_PATTERNS = [
+    'callback',
+    'handler',
+    'fn',
+    'func',
+    'on[A-Z].*',
+];
+/**
+ * Returns true if the TSTypeAnnotation node (from useState's type parameter)
+ * represents a function type — either directly or as part of a union with
+ * null/undefined. We check purely syntactically; no type-checker required.
+ */
+function isFunctionTypeAnnotation(typeNode) {
+    switch (typeNode.type) {
+        case utils_1.AST_NODE_TYPES.TSFunctionType:
+        case utils_1.AST_NODE_TYPES.TSConstructorType:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+            // Union like `(() => void) | null` — any member being a function type suffices
+            return typeNode.types.some(isFunctionTypeAnnotation);
+        default:
+            return false;
+    }
+}
+/**
+ * Checks whether a useState call expression has a type parameter that
+ * includes a function type, e.g. useState<(() => void) | null>(null).
+ */
+function useStateHasFunctionTypeParam(callNode) {
+    const typeParams = callNode.typeParameters;
+    if (!typeParams || typeParams.params.length === 0) {
+        return false;
+    }
+    return isFunctionTypeAnnotation(typeParams.params[0]);
+}
+/**
+ * Returns true when the AST node is a safe value to pass to a setter — i.e.,
+ * NOT a bare identifier or member expression that could be a function reference.
+ * Arrow/function expressions are always safe (they are intentional).
+ * Literals, null, undefined, call expressions, arrays, objects are all safe.
+ */
+function isDefinitelySafeArg(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+        case utils_1.AST_NODE_TYPES.FunctionExpression:
+            // Inline function/arrow — always intentional (updater or thunk)
+            return true;
+        case utils_1.AST_NODE_TYPES.Literal:
+            // Literal values (numbers, strings, booleans, null, regex)
+            return true;
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return true;
+        case utils_1.AST_NODE_TYPES.Identifier:
+            // `undefined` is safe; generic identifiers may be function refs
+            return node.name === 'undefined';
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            // `void 0`, `!flag`, `typeof x` etc. — all non-function values
+            return true;
+        case utils_1.AST_NODE_TYPES.BinaryExpression:
+            // `a + b`, `a * b`, etc. — never callable
+            return true;
+        case utils_1.AST_NODE_TYPES.CallExpression:
+        case utils_1.AST_NODE_TYPES.NewExpression:
+            // Call/new expressions — return value unknown without types; skip (no FP)
+            return true;
+        case utils_1.AST_NODE_TYPES.ArrayExpression:
+        case utils_1.AST_NODE_TYPES.ObjectExpression:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            // Unwrap type assertions and recurse
+            return isDefinitelySafeArg(node.expression);
+        default:
+            // MemberExpression, Identifier (non-undefined), etc. are NOT definitely safe
+            return false;
+    }
+}
+/**
+ * Checks whether an identifier name matches any of the function-naming patterns
+ * (e.g. onClose, handler, fn, callback).
+ */
+function matchesFunctionPattern(name, patterns) {
+    for (const pattern of patterns) {
+        try {
+            const regex = new RegExp(`^${pattern}$`);
+            if (regex.test(name)) {
+                return true;
+            }
+        }
+        catch {
+            // Ignore invalid regex patterns
+        }
+    }
+    return false;
+}
+/**
+ * Extracts the identifier name from an argument node for pattern matching.
+ * For MemberExpression like `obj.handler`, returns `handler`.
+ * For Identifier like `myCallback`, returns `myCallback`.
+ */
+function getArgName(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const prop = node.property;
+        if (prop.type === utils_1.AST_NODE_TYPES.Identifier && !node.computed) {
+            return prop.name;
+        }
+    }
+    return null;
+}
+/**
+ * Walks up the scope to find if an identifier is bound (in scope) to a
+ * function — an arrow function expression or function expression/declaration.
+ * This covers: `const x = () => ...` and `function x() {...}`.
+ */
+function isIdentifierBoundToFunction(name, scope) {
+    let currentScope = scope;
+    while (currentScope) {
+        for (const variable of currentScope.variables) {
+            if (variable.name !== name)
+                continue;
+            for (const def of variable.defs) {
+                if (def.type === 'Variable' &&
+                    def.node.init &&
+                    (def.node.init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        def.node.init.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    return true;
+                }
+                if (def.type === 'FunctionName' ||
+                    def.type === 'ImplicitGlobalVariable') {
+                    return true;
+                }
+            }
+        }
+        currentScope = currentScope.upper;
+    }
+    return false;
+}
+exports.noDirectFunctionState = (0, createRule_1.createRule)({
+    name: 'no-direct-function-state',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent passing a function directly to a useState setter — React will invoke it as a functional updater instead of storing it. Wrap in a thunk: setState(() => fn).',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    functionPatterns: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_FUNCTION_PATTERNS,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noDirectFunctionState: 'What\'s wrong: "{{argText}}" is passed directly to "{{setterName}}", but React invokes a function argument as a functional updater (prev => next) instead of storing it. ' +
+                'Why it matters: The function will be called with the previous state value and its return value stored — a silent bug with no error. ' +
+                'How to fix: Wrap it in a thunk so React stores the function as a value: {{setterName}}(() => {{argText}})',
+        },
+    },
+    defaultOptions: [{ functionPatterns: DEFAULT_FUNCTION_PATTERNS }],
+    create(context) {
+        const options = context.options[0] ?? {};
+        const functionPatterns = options.functionPatterns ?? DEFAULT_FUNCTION_PATTERNS;
+        /**
+         * Maps setter-variable names to whether the corresponding useState has
+         * an explicit function type parameter. This is populated as we encounter
+         * useState array-destructuring declarations.
+         */
+        const setterFunctionTyped = new Map();
+        return {
+            VariableDeclarator(node) {
+                // Look for `const [state, setter] = useState<T>(...)` or
+                // `const [state, setter] = React.useState<T>(...)`.
+                if (node.id.type !== utils_1.AST_NODE_TYPES.ArrayPattern ||
+                    !node.init ||
+                    node.init.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                    return;
+                }
+                const callNode = node.init;
+                const callee = callNode.callee;
+                const isUseStateCall = (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.name === 'useState') ||
+                    (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        callee.property.name === 'useState');
+                if (!isUseStateCall)
+                    return;
+                // The setter is the second element of the destructured array
+                const elements = node.id.elements;
+                if (elements.length < 2)
+                    return;
+                const setterElement = elements[1];
+                if (!setterElement ||
+                    setterElement.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const setterName = setterElement.name;
+                const hasFunctionType = useStateHasFunctionTypeParam(callNode);
+                setterFunctionTyped.set(setterName, hasFunctionType);
+            },
+            CallExpression(node) {
+                // We are looking for calls like `setter(arg)` where:
+                // 1. setter is known (tracked from useState destructuring), AND
+                //    - the useState type is function-typed, OR
+                //    - the arg name matches a function pattern, OR
+                //    - the arg is bound to a function in scope
+                // 2. The arg is NOT already a safe value (arrow/function expr, literal, etc.)
+                const callee = node.callee;
+                if (callee.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                const setterName = callee.name;
+                // Only flag calls to tracked setters
+                if (!setterFunctionTyped.has(setterName))
+                    return;
+                // Only consider single-argument calls (setters take exactly one value arg)
+                if (node.arguments.length !== 1)
+                    return;
+                const arg = node.arguments[0];
+                // SpreadElement is not a plain expression; skip
+                if (arg.type === utils_1.AST_NODE_TYPES.SpreadElement)
+                    return;
+                // If arg is a definitely-safe type (inline arrow, literal, undefined, etc.),
+                // skip without further checks
+                if (isDefinitelySafeArg(arg))
+                    return;
+                // At this point arg is an Identifier (non-undefined) or MemberExpression.
+                // Decide whether it is a function reference.
+                const isFunctionTypedState = setterFunctionTyped.get(setterName) === true;
+                if (isFunctionTypedState) {
+                    // Type annotation says the state holds a function — any bare
+                    // identifier or member expression is suspect.
+                    reportAndFix(node, arg, setterName, context);
+                    return;
+                }
+                // No explicit function type. Fall back to heuristic: name pattern match
+                // or scope-level binding to a function.
+                const argName = getArgName(arg);
+                if (argName && matchesFunctionPattern(argName, functionPatterns)) {
+                    reportAndFix(node, arg, setterName, context);
+                    return;
+                }
+                // Check if the identifier is bound to a function in scope
+                if (arg.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    arg.name !== 'undefined') {
+                    const scope = context.getScope();
+                    if (isIdentifierBoundToFunction(arg.name, scope)) {
+                        reportAndFix(node, arg, setterName, context);
+                        return;
+                    }
+                }
+            },
+        };
+    },
+});
+function reportAndFix(callNode, arg, setterName, context) {
+    const sourceCode = context.getSourceCode();
+    const argText = sourceCode.getText(arg);
+    context.report({
+        node: callNode,
+        messageId: 'noDirectFunctionState',
+        data: {
+            argText,
+            setterName,
+        },
+        fix(fixer) {
+            return fixer.replaceText(arg, `() => ${argText}`);
+        },
+    });
+}
+//# sourceMappingURL=no-direct-function-state.js.map

package/lib/rules/no-fill-template-mutation.d.ts

@@ -0,0 +1 @@
+export declare const noFillTemplateMutation: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noFillTemplateMutation", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-fill-template-mutation.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFillTemplateMutation = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * The import path suffix that identifies the Algolia realtime fillTemplate
+ * function. Only calls imported from a path ending with this string are
+ * tracked, avoiding false positives from the unrelated marketing
+ * fillTemplate at src/pages/api/marketing/fillTemplate.ts.
+ */
+const FILL_TEMPLATE_MODULE_SUFFIX = 'algoliaRealtime/fillTemplate';
+/**
+ * String methods whose invocation on a fillTemplate result constitutes
+ * a structural mutation of the filled filter string.
+ */
+const MUTATING_STRING_METHODS = new Set([
+    'concat',
+    'replace',
+    'replaceAll',
+    'trim',
+    'trimStart',
+    'trimEnd',
+    'trimLeft',
+    'trimRight',
+    'toLowerCase',
+    'toUpperCase',
+    'toLocaleLowerCase',
+    'toLocaleUpperCase',
+    'slice',
+    'substring',
+    'substr',
+    'padStart',
+    'padEnd',
+    'repeat',
+    'normalize',
+    'split',
+]);
+exports.noFillTemplateMutation = (0, createRule_1.createRule)({
+    name: 'no-fill-template-mutation',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow mutating the return value of fillTemplate() via string concatenation, template literals, or string method calls. The filled Algolia filter must be used verbatim so matchesTemplate() can regex-match it; post-fill modification silently breaks realtime hash parity.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [],
+        messages: {
+            noFillTemplateMutation: 'The return value of fillTemplate() must not be modified after the call. String operations (concatenation, template literals, string methods) on a filled filter break matchesTemplate() and cause silent realtime hash parity failures. To add conditions, create a new template variant in REALTIME_PREEMPTIVE_FILTER_TEMPLATES or PREEMPTIVE_FILTER_TEMPLATES instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * Local names (possibly aliased) that are bound to the Algolia
+         * fillTemplate function in the current file.
+         * e.g. `import { fillTemplate as fill }` → fill is tracked.
+         */
+        const filledFunctionNames = new Set();
+        /**
+         * Namespace import names whose .fillTemplate property is the tracked
+         * function. e.g. `import * as ft` → ft.fillTemplate is tracked.
+         */
+        const namespaceNames = new Set();
+        /**
+         * Variable names that hold a direct fillTemplate() call result.
+         * e.g. `const f = fillTemplate(...)` → f is a filled variable.
+         * Only single-level const/let bindings are tracked; no cross-function
+         * data-flow.
+         */
+        const filledVariables = new Set();
+        // ------------------------------------------------------------------ //
+        // Helpers
+        // ------------------------------------------------------------------ //
+        /**
+         * Returns true when node is a call to the tracked fillTemplate function,
+         * either as a named import (filledFunctionNames) or namespace member
+         * (namespaceNames.fillTemplate).
+         */
+        function isFillTemplateCall(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
+                return false;
+            const { callee } = node;
+            // Direct call: fillTemplate(...)  or aliased: fill(...)
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                filledFunctionNames.has(callee.name)) {
+                return true;
+            }
+            // Namespace call: ft.fillTemplate(...)
+            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                namespaceNames.has(callee.object.name) &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.property.name === 'fillTemplate') {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Returns true when node is either a direct fillTemplate() call or an
+         * identifier that holds a single-level fillTemplate() result.
+         */
+        function isFilledValue(node) {
+            if (isFillTemplateCall(node))
+                return true;
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+                filledVariables.has(node.name)) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Set of AST nodes that have already been reported to prevent
+         * double-reporting when a mutation is both the right-hand side of an
+         * AssignmentExpression and a BinaryExpression/TemplateLiteral.
+         */
+        const reportedNodes = new Set();
+        /**
+         * Reports a mutation violation on the given node.
+         */
+        function report(node) {
+            if (reportedNodes.has(node))
+                return;
+            reportedNodes.add(node);
+            context.report({ node, messageId: 'noFillTemplateMutation' });
+        }
+        /**
+         * Returns true when a TemplateLiteral node is used solely as an argument
+         * to a console method (console.log, console.warn, etc.), which is safe
+         * per the spec — logging output is not used as a filter value.
+         */
+        function isInsideConsoleCall(node) {
+            const parent = node.parent;
+            if (!parent)
+                return false;
+            if (parent.type !== utils_1.AST_NODE_TYPES.CallExpression)
+                return false;
+            const { callee } = parent;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+                return false;
+            const { object, property } = callee;
+            return (object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                object.name === 'console' &&
+                property.type === utils_1.AST_NODE_TYPES.Identifier);
+        }
+        /**
+         * Checks whether a TemplateLiteral constitutes a mutation of a filled
+         * value. A bare `` `${f}` `` with exactly one expression and no
+         * surrounding text is considered non-mutating (it is a redundant wrap,
+         * not a structural addition). Any template that also contains non-empty
+         * quasi (literal text) or additional expressions is flagged.
+         */
+        function isTemplateLiteralMutation(node) {
+            const { expressions, quasis } = node;
+            // Find whether any expression is a filled value.
+            const filledExprIndices = [];
+            for (let i = 0; i < expressions.length; i++) {
+                if (isFilledValue(expressions[i])) {
+                    filledExprIndices.push(i);
+                }
+            }
+            if (filledExprIndices.length === 0) {
+                return { isMutation: false, filledExprIndex: -1 };
+            }
+            // A bare `${f}` has one expression and all quasis are empty strings.
+            if (expressions.length === 1 && quasis.every((q) => q.value.raw === '')) {
+                return { isMutation: false, filledExprIndex: -1 };
+            }
+            // Any other pattern: more than one expression, or at least one quasi
+            // with non-empty text → mutation.
+            return { isMutation: true, filledExprIndex: filledExprIndices[0] };
+        }
+        // ------------------------------------------------------------------ //
+        // Visitor
+        // ------------------------------------------------------------------ //
+        return {
+            // ---- Import tracking ------------------------------------------- //
+            ImportDeclaration(node) {
+                const src = String(node.source.value);
+                if (!src.endsWith(FILL_TEMPLATE_MODULE_SUFFIX))
+                    return;
+                for (const spec of node.specifiers) {
+                    if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                        // Named import: `import { fillTemplate }` or
+                        //              `import { fillTemplate as fill }`
+                        // spec.imported is the exported name; spec.local is the local alias.
+                        const importedName = spec.imported.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? spec.imported.name
+                            : '';
+                        if (importedName === 'fillTemplate') {
+                            filledFunctionNames.add(spec.local.name);
+                        }
+                    }
+                    else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                        // Namespace import: `import * as ft`
+                        namespaceNames.add(spec.local.name);
+                    }
+                    else if (spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                        // Default import of the module itself, treat as fillTemplate
+                        filledFunctionNames.add(spec.local.name);
+                    }
+                }
+            },
+            // ---- Variable binding tracking ---------------------------------- //
+            VariableDeclarator(node) {
+                // Track: const f = fillTemplate(...)
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.init &&
+                    isFillTemplateCall(node.init)) {
+                    filledVariables.add(node.id.name);
+                }
+            },
+            // ---- Binary expression: + / += ---------------------------------- //
+            BinaryExpression(node) {
+                if (node.operator !== '+')
+                    return;
+                if (!isFilledValue(node.left) && !isFilledValue(node.right))
+                    return;
+                // When this BinaryExpression is the right-hand side of a `=`
+                // assignment to a tracked variable, the AssignmentExpression visitor
+                // handles the report to prevent double errors.
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                    parent.operator === '=' &&
+                    parent.right === node &&
+                    parent.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    filledVariables.has(parent.left.name)) {
+                    return;
+                }
+                report(node);
+            },
+            // ---- Assignment expression: +=, and reassignment with + --------- //
+            AssignmentExpression(node) {
+                if (node.operator === '+=') {
+                    // `f += '...'` — left must be a filled variable
+                    if (node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        filledVariables.has(node.left.name)) {
+                        report(node);
+                    }
+                    return;
+                }
+                if (node.operator === '=') {
+                    // `f = f + '...'` or `f = \`${f}...\``
+                    if (node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        filledVariables.has(node.left.name)) {
+                        // Right side is a BinaryExpression involving the variable
+                        if (node.right.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                            node.right.operator === '+' &&
+                            (isFilledValue(node.right.left) ||
+                                isFilledValue(node.right.right))) {
+                            report(node);
+                            return;
+                        }
+                        // Right side is a TemplateLiteral involving the variable
+                        if (node.right.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                            const { isMutation } = isTemplateLiteralMutation(node.right);
+                            if (isMutation) {
+                                report(node);
+                            }
+                        }
+                    }
+                }
+            },
+            // ---- Template literals ------------------------------------------ //
+            TemplateLiteral(node) {
+                // Template literals used solely for console output are safe.
+                if (isInsideConsoleCall(node))
+                    return;
+                const { isMutation } = isTemplateLiteralMutation(node);
+                if (!isMutation)
+                    return;
+                // When this template literal is the right-hand side of an assignment
+                // to a tracked variable, the AssignmentExpression visitor reports it
+                // to avoid duplicate errors. Suppress here in that case.
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                    parent.operator === '=' &&
+                    parent.right === node &&
+                    parent.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    filledVariables.has(parent.left.name)) {
+                    return;
+                }
+                report(node);
+            },
+            // ---- String method calls ---------------------------------------- //
+            CallExpression(node) {
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+                    return;
+                const { object, property, computed } = node.callee;
+                if (computed)
+                    return;
+                if (property.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                if (!MUTATING_STRING_METHODS.has(property.name))
+                    return;
+                // object is a filled value → mutation
+                if (isFilledValue(object)) {
+                    report(node);
+                }
+            },
+            // ---- Array.join on arrays of filled values ----------------------- //
+            // Tracked via CallExpression: array.join(separator)
+            // We detect `[...].join(...)` where any element is a filled value.
+            // We also detect variables bound to arrays of filled values via map.
+            // (Simple cases: literal array in the join call.)
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            'CallExpression[callee.property.name="join"]'(node) {
+                const callee = node.callee;
+                const obj = callee.object;
+                if (obj.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    const hasFilledElement = obj.elements.some((el) => el !== null && isFilledValue(el));
+                    if (hasFilledElement) {
+                        report(node);
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-fill-template-mutation.js.map

package/lib/rules/no-hungarian.js

@@ -353,36 +353,28 @@ exports.noHungarian = (0, createRule_1.createRule)({
                     return true;
                 }
                 // Abbreviation markers (str, num, int, bool, arr, obj, fn, func) are
-                // short enough that the raw-character boundary heuristic below can fire
-                // on them as substrings inside real English words (e.g. "int" inside
-                // "Mint", "str" inside "stream"). For these markers, require an exact
-                // match against a full camelCase token so that "Mint" → ["Mint"] never
-                // matches "int", while genuine Hungarian like intValue → ["int","Value"]
-                // still does.
+                // short enough that a raw-character boundary check can fire on them as
+                // substrings inside real English words (e.g. "int" inside "Mint", "str"
+                // inside "stream"). Require an exact match against a full camelCase
+                // token so that "Mint" → ["Mint"] never matches "int", while genuine
+                // Hungarian like intValue → ["int","Value"] still does.
                 if (ABBREVIATION_MARKER_SET.has(normalizedMarker)) {
                     const segments = splitCamelSegments(variableName);
                     return segments.some((s) => s.toLowerCase() === normalizedMarker);
                 }
-                // Check for word boundaries to avoid matching substrings
-                // For example, avoid matching "int" in "points" or "str" in "stream"
-                const markerIndex = normalizedVarName.indexOf(normalizedMarker);
-                if (markerIndex === -1) {
-                    return false;
-                }
-                const preMarkerPrefix = markerIndex > 0 ? variableName[markerIndex - 1] : '';
-                const suffix = variableName[markerIndex + normalizedMarker.length] ?? '';
-                // Ensure we have proper word boundaries
-                // A word boundary is defined by:
-                // 1. Start of string OR underscore OR capital letter before the marker
-                // 2. End of string OR underscore OR capital letter after the marker
-                const hasStartBoundary = markerIndex === 0 ||
-                    preMarkerPrefix === '_' ||
-                    /[A-Z]/.test(preMarkerPrefix) ||
-                    /[A-Z]/.test(variableName[markerIndex]);
-                const hasEndBoundary = markerIndex + normalizedMarker.length === normalizedVarName.length ||
-                    suffix === '_' ||
-                    /[A-Z]/.test(suffix);
-                return hasStartBoundary && hasEndBoundary;
+                // Full type-word markers (non-abbreviations: String, Number, Function,
+                // Array, Object, Boolean, …) are Hungarian only when they occupy the
+                // first or last camelCase segment — a genuine prefix or suffix that
+                // tags the entity's runtime type. The prefix/suffix character checks
+                // above already return `true` for those positions, so reaching this
+                // point means the marker sits in a middle segment of the identifier
+                // (e.g. cloud·Function·Registry, user·String·Name). A middle
+                // full-type-word qualifies a domain concept ("a registry of cloud
+                // functions") rather than redundantly encoding the entity's type.
+                // Accepting the resulting false negatives is the deliberate trade-off:
+                // middle-segment full-type-words are overwhelmingly domain vocabulary,
+                // not type tags.
+                return false;
             });
         }
         // Check if the identifier is a built-in method or imported from an external module