@blumintinc/eslint-plugin-blumint 1.16.1 → 1.17.0

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

@@ -352,6 +352,17 @@ exports.noHungarian = (0, createRule_1.createRule)({
                         /[A-Z]/.test(variableName[variableName.length - normalizedMarker.length]))) {
                     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.
+                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);

package/lib/rules/no-portal-inside-tooltip.d.ts

@@ -0,0 +1,10 @@
+type Options = [
+    {
+        tooltipComponents?: string[];
+        portalComponents?: string[];
+        detectTooltipSuffix?: boolean;
+        detectPortalSuffix?: boolean;
+    }?
+];
+export declare const noPortalInsideTooltip: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"portalInsideTooltip", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/no-portal-inside-tooltip.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noPortalInsideTooltip = void 0;
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_TOOLTIP_COMPONENTS = [
+    'Tooltip',
+    'WYSIWYGTooltip',
+    'MatchPayoutTooltip',
+    'TeamDisplayTooltip',
+    'OptionalTooltip',
+    'ComingSoonTooltip',
+    'TooltipDynamicDelay',
+    'ValidationTooltip',
+];
+const DEFAULT_PORTAL_COMPONENTS = [
+    'Dialog',
+    'Drawer',
+    'Menu',
+    'Popover',
+    'Portal',
+    'Modal',
+    'WizardPortal',
+    'DialogCentered',
+    'AlertDialog',
+];
+const PORTAL_SUFFIXES = ['Portal', 'Dialog', 'Drawer', 'Menu', 'Popover'];
+/**
+ * Extracts the string name from a JSX element's opening tag name expression.
+ * Returns null for member expressions (e.g. Foo.Bar) since they're out of scope.
+ */
+function getJsxElementName(nameExpr) {
+    if (nameExpr.type === 'JSXIdentifier') {
+        return nameExpr.name;
+    }
+    return null;
+}
+/**
+ * Recursively searches a node's JSX descendant tree for portal components,
+ * including those nested inside expression containers (logical/conditional
+ * expressions), fragments, and regular elements.
+ *
+ * Returns the first portal node found, or null if none.
+ */
+function findPortalInDescendants(node, isPortalComponent) {
+    if (node.type === 'JSXElement') {
+        const name = getJsxElementName(node.openingElement.name);
+        if (name !== null && isPortalComponent(name)) {
+            return node;
+        }
+        // Recurse into JSXElement children
+        for (const child of node.children) {
+            const found = findPortalInDescendants(child, isPortalComponent);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    if (node.type === 'JSXFragment') {
+        // Treat fragments as transparent — recurse into their children
+        for (const child of node.children) {
+            const found = findPortalInDescendants(child, isPortalComponent);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    if (node.type === 'JSXExpressionContainer') {
+        return findPortalInExpression(node.expression, isPortalComponent);
+    }
+    return null;
+}
+/**
+ * Descends into expression nodes (logical, conditional) looking for portal
+ * JSX elements. Call expressions and other dynamic shapes are out of scope
+ * and silently produce no match (avoiding false positives).
+ */
+function findPortalInExpression(expr, isPortalComponent) {
+    if (expr.type === 'JSXElement') {
+        return findPortalInDescendants(expr, isPortalComponent);
+    }
+    if (expr.type === 'JSXFragment') {
+        return findPortalInDescendants(expr, isPortalComponent);
+    }
+    if (expr.type === 'LogicalExpression') {
+        // Both sides could be JSX — check the right operand (the render branch)
+        // and also the left in case of || chaining
+        const rightResult = findPortalInExpression(expr.right, isPortalComponent);
+        if (rightResult)
+            return rightResult;
+        return findPortalInExpression(expr.left, isPortalComponent);
+    }
+    if (expr.type === 'ConditionalExpression') {
+        const consequentResult = findPortalInExpression(expr.consequent, isPortalComponent);
+        if (consequentResult)
+            return consequentResult;
+        return findPortalInExpression(expr.alternate, isPortalComponent);
+    }
+    if (expr.type === 'Identifier') {
+        // Handle {Portal} — an Identifier whose name matches a portal component name
+        if (isPortalComponent(expr.name)) {
+            return expr;
+        }
+    }
+    // CallExpression, TemplateLiteral, etc. are out of scope — return null
+    return null;
+}
+exports.noPortalInsideTooltip = (0, createRule_1.createRule)({
+    name: 'no-portal-inside-tooltip',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow portal-rendering components (Dialog, Drawer, Menu, Popover, Portal, Modal) inside Tooltip wrapper components. React Portals preserve React-tree event bubbling, so a portal nested under a Tooltip leaves the tooltip orphaned over the modal.',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    tooltipComponents: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Additional tooltip wrapper component names to detect.',
+                    },
+                    portalComponents: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Additional portal-rendering component names to detect.',
+                    },
+                    detectTooltipSuffix: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'When true, any component whose name ends in "Tooltip" is treated as a tooltip wrapper.',
+                    },
+                    detectPortalSuffix: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'When true, any component whose name ends in Portal, Dialog, Drawer, Menu, or Popover is treated as a portal.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            portalInsideTooltip: "Portal-rendering component '{{portalName}}' must not be nested inside Tooltip wrapper '{{tooltipName}}'. React Portals preserve React-tree event bubbling, so the portal's modal Backdrop becomes a logical descendant of the tooltip wrapper — preventing onMouseLeave from firing and leaving the tooltip orphaned over the modal. Hoist the portal out of the tooltip (use TooltipChipTrigger or render the portal as a sibling).",
+        },
+        fixable: undefined,
+    },
+    defaultOptions: [{}],
+    create(context) {
+        const options = context.options[0] ?? {};
+        const detectTooltipSuffix = options.detectTooltipSuffix !== false;
+        const detectPortalSuffix = options.detectPortalSuffix !== false;
+        // Build the tooltip component name set
+        const tooltipSet = new Set(DEFAULT_TOOLTIP_COMPONENTS);
+        if (options.tooltipComponents) {
+            for (const name of options.tooltipComponents) {
+                tooltipSet.add(name);
+            }
+        }
+        // Build the portal component name set
+        const portalSet = new Set(DEFAULT_PORTAL_COMPONENTS);
+        if (options.portalComponents) {
+            for (const name of options.portalComponents) {
+                portalSet.add(name);
+            }
+        }
+        const isTooltipComponent = (name) => {
+            if (tooltipSet.has(name))
+                return true;
+            if (detectTooltipSuffix && name.endsWith('Tooltip'))
+                return true;
+            return false;
+        };
+        const isPortalComponent = (name) => {
+            if (portalSet.has(name))
+                return true;
+            if (detectPortalSuffix) {
+                for (const suffix of PORTAL_SUFFIXES) {
+                    if (name.endsWith(suffix) && name !== suffix)
+                        return true;
+                }
+            }
+            return false;
+        };
+        return {
+            JSXElement(node) {
+                const tooltipName = getJsxElementName(node.openingElement.name);
+                if (tooltipName === null || !isTooltipComponent(tooltipName)) {
+                    return;
+                }
+                // Only walk the tooltip's children (not its attributes like `title`)
+                for (const child of node.children) {
+                    const portalNode = findPortalInDescendants(child, isPortalComponent);
+                    if (portalNode) {
+                        let portalName = 'Portal';
+                        if (portalNode.type === 'JSXElement') {
+                            portalName =
+                                getJsxElementName(portalNode.openingElement.name) ?? 'Portal';
+                        }
+                        else if (portalNode.type === 'Identifier') {
+                            portalName = portalNode.name;
+                        }
+                        context.report({
+                            node: portalNode,
+                            messageId: 'portalInsideTooltip',
+                            data: {
+                                portalName,
+                                tooltipName,
+                            },
+                        });
+                        // Report only the first portal found per tooltip to avoid flooding
+                        break;
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-portal-inside-tooltip.js.map

package/lib/rules/no-redundant-boolean-callback-props.d.ts

@@ -0,0 +1,11 @@
+type Options = [
+    {
+        booleanPrefixes?: string[];
+        callbackPrefixes?: string[];
+        booleanSuffixesToStrip?: string[];
+        exemptQualifiers?: string[];
+        minNounLengthForSuffixMatch?: number;
+    }?
+];
+export declare const noRedundantBooleanCallbackProps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"redundantBooleanProp", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};