@blumintinc/eslint-plugin-blumint 1.16.2 → 1.17.0

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 {};

package/lib/rules/no-redundant-boolean-callback-props.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRedundantBooleanCallbackProps = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Default boolean prop prefixes that signal visibility/enablement control —
+ * the patterns most likely to be redundant when a matching callback exists.
+ * Prefixes like `is`/`has` represent state rather than control, so they are
+ * excluded by default to avoid false positives on state props.
+ */
+const DEFAULT_BOOLEAN_PREFIXES = [
+    'shouldShow',
+    'shouldEnable',
+    'shouldAllow',
+    'enable',
+    'allow',
+    'show',
+    'hide',
+    'display',
+];
+/**
+ * Default callback prefixes to match against the boolean's core noun.
+ */
+const DEFAULT_CALLBACK_PREFIXES = ['on', 'handle'];
+/**
+ * Trailing decorative suffixes that do not change the noun being controlled.
+ * E.g. `shouldShowMinimizeIcon` — `Icon` is purely decorative; the feature
+ * being toggled is still `Minimize`.
+ *
+ * When suffix stripping IS used to produce a noun match, the rule requires the
+ * resulting noun to be at least `minNounLengthForSuffixMatch` characters long
+ * to avoid false positives on short generic action words (e.g. `Close`) that
+ * appear in many general-purpose callbacks.
+ */
+const DEFAULT_BOOLEAN_SUFFIXES_TO_STRIP = [
+    'Icon',
+    'Button',
+    'Action',
+    'Control',
+    'Badge',
+];
+/**
+ * Minimum noun length when suffix stripping is involved in the match. Short
+ * nouns like `Close` (5) are often generic action names used in callbacks that
+ * span more than one trigger (e.g. `onClose` handles backdrop, escape, and
+ * icon clicks). Requiring at least 6 chars lets specific nouns like `Delete`,
+ * `Submit`, `Dismiss` match while excluding single-word generic actions.
+ */
+const DEFAULT_MIN_NOUN_LENGTH_FOR_SUFFIX_MATCH = 6;
+/**
+ * Qualifying word-parts whose presence in the boolean name changes its
+ * semantics enough that the boolean is NOT a simple feature-presence toggle.
+ * E.g. `shouldExpandInitially` is an initial-state control, not feature-
+ * presence control, so we do not flag it even if `onExpand` is present.
+ */
+const DEFAULT_EXEMPT_QUALIFIERS = [
+    'Initially',
+    'OnMount',
+    'ByDefault',
+    'WhenHovered',
+    'WhenFocused',
+    'WhenActive',
+    'Always',
+    'Never',
+];
+/**
+ * Determine whether a boolean prop name (after stripping its visibility prefix)
+ * "matches" a callback noun with enough confidence to flag a redundancy.
+ *
+ * Two tiers of match:
+ * 1. **Exact match** (no suffix stripping): the boolean remainder equals the
+ *    callback noun exactly — high confidence, no length restriction.
+ * 2. **Suffix-strip match**: the boolean remainder starts with the callback
+ *    noun and the leftover is a recognized decorative suffix. Requires the
+ *    callback noun to be at least `minNounLength` characters to avoid matching
+ *    short generic action words.
+ */
+function booleanCoreMatchesCallbackNoun(booleanRemainder, callbackNoun, suffixesToStrip, minNounLengthForSuffixMatch) {
+    const lowerRemainder = booleanRemainder.toLowerCase();
+    const lowerNoun = callbackNoun.toLowerCase();
+    // Tier 1: exact match (case-insensitive) — highest confidence
+    if (lowerRemainder === lowerNoun)
+        return true;
+    // Tier 2: remainder starts with noun + recognized decorative suffix
+    if (!lowerRemainder.startsWith(lowerNoun))
+        return false;
+    if (callbackNoun.length < minNounLengthForSuffixMatch)
+        return false;
+    const leftover = booleanRemainder.slice(callbackNoun.length);
+    for (const suffix of suffixesToStrip) {
+        if (leftover === suffix)
+            return true;
+    }
+    return false;
+}
+/**
+ * Check whether a boolean prop name contains an exempt qualifier word,
+ * indicating that the boolean controls something beyond simple feature
+ * presence (e.g. initial state, conditional display).
+ */
+function hasExemptQualifier(name, exemptQualifiers) {
+    for (const qualifier of exemptQualifiers) {
+        if (name.includes(qualifier))
+            return true;
+    }
+    return false;
+}
+/**
+ * Extract the remainder of a boolean prop name after stripping its leading
+ * visibility/enablement prefix. Returns null if no matching prefix is found
+ * or if the name is entirely the prefix.
+ *
+ * Longest prefix wins (so `shouldShow` beats `should`).
+ */
+function stripBooleanPrefix(name, prefixes) {
+    const sortedPrefixes = [...prefixes].sort((a, b) => b.length - a.length);
+    for (const prefix of sortedPrefixes) {
+        if (name.toLowerCase().startsWith(prefix.toLowerCase())) {
+            const remainder = name.slice(prefix.length);
+            if (remainder.length === 0)
+                return null;
+            // Require a camelCase word boundary after the prefix
+            if (remainder[0] >= 'A' && remainder[0] <= 'Z')
+                return remainder;
+        }
+    }
+    return null;
+}
+/**
+ * Extract the core noun from a callback prop name after stripping its leading
+ * callback prefix (e.g. `on` from `onMinimize` → `Minimize`). Returns null
+ * if no matching prefix is found or if the name is entirely the prefix.
+ */
+function extractCallbackNoun(name, callbackPrefixes) {
+    const sortedPrefixes = [...callbackPrefixes].sort((a, b) => b.length - a.length);
+    for (const prefix of sortedPrefixes) {
+        if (name.toLowerCase().startsWith(prefix.toLowerCase())) {
+            const remainder = name.slice(prefix.length);
+            if (remainder.length === 0)
+                return null;
+            if (remainder[0] >= 'A' && remainder[0] <= 'Z')
+                return remainder;
+        }
+    }
+    return null;
+}
+/**
+ * Determine if a type annotation node represents a boolean (or a
+ * boolean-containing union like `boolean | undefined`).
+ */
+function isBooleanTypeNode(typeAnnotation) {
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword)
+        return true;
+    // Handle `boolean | undefined` / `boolean | null` explicit union forms
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return typeAnnotation.types.every((t) => t.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword ||
+            t.type === utils_1.AST_NODE_TYPES.TSUndefinedKeyword ||
+            t.type === utils_1.AST_NODE_TYPES.TSNullKeyword);
+    }
+    return false;
+}
+/**
+ * Determine if a type annotation node represents a callable (function type,
+ * named callback type reference, or union involving a function type —
+ * including the `callback | 'disabled'` pattern).
+ */
+function isCallableTypeNode(typeAnnotation) {
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSFunctionType)
+        return true;
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference)
+        return true;
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return typeAnnotation.types.some((t) => t.type === utils_1.AST_NODE_TYPES.TSFunctionType ||
+            t.type === utils_1.AST_NODE_TYPES.TSTypeReference);
+    }
+    return false;
+}
+/**
+ * Get the string name of a TSPropertySignature key, or null for computed keys.
+ */
+function getPropName(prop) {
+    const key = prop.key;
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier)
+        return key.name;
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return null;
+}
+/**
+ * Collect all TSPropertySignature members from a type-level node, recursively
+ * unwrapping `Readonly<{...}>` wrappers and flattening inline `&` intersection
+ * constituent type literals. External type references in intersections are
+ * intentionally skipped to avoid flagging inherited library props.
+ */
+function collectMembers(node) {
+    const results = [];
+    if (node.type === utils_1.AST_NODE_TYPES.TSPropertySignature) {
+        results.push(node);
+        return results;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+        for (const member of node.members) {
+            if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                results.push(member);
+            }
+        }
+        return results;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+        for (const constituent of node.types) {
+            if (constituent.type === utils_1.AST_NODE_TYPES.TSTypeLiteral ||
+                constituent.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                results.push(...collectMembers(constituent));
+            }
+            else if (constituent.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                // Unwrap `Readonly<{...}>` — recognized safe wrapper
+                const ref = constituent;
+                if (ref.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    ref.typeName.name === 'Readonly' &&
+                    ref.typeParameters?.params?.length === 1 &&
+                    ref.typeParameters.params[0].type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                    results.push(...collectMembers(ref.typeParameters.params[0]));
+                }
+                // Other TSTypeReference in an intersection = external type, skip
+            }
+        }
+        return results;
+    }
+    // Top-level `Readonly<{...}>` wrapper
+    if (node.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        const ref = node;
+        if (ref.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+            ref.typeName.name === 'Readonly' &&
+            ref.typeParameters?.params?.length === 1 &&
+            ref.typeParameters.params[0].type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+            return collectMembers(ref.typeParameters.params[0]);
+        }
+    }
+    return results;
+}
+exports.noRedundantBooleanCallbackProps = (0, createRule_1.createRule)({
+    name: 'no-redundant-boolean-callback-props',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow redundant boolean props that duplicate the semantic meaning of optional callback props, violating the Interface Segregation Principle.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    booleanPrefixes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    callbackPrefixes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    booleanSuffixesToStrip: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    exemptQualifiers: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    minNounLengthForSuffixMatch: {
+                        type: 'number',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            redundantBooleanProp: 'Boolean prop "{{booleanProp}}" is redundant alongside callback prop "{{callbackProp}}" — the callback\'s presence already communicates whether the feature is enabled. Remove "{{booleanProp}}" and key off the callback\'s presence instead, or use the `callback | \'disabled\'` union pattern.',
+        },
+    },
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const booleanPrefixes = options?.booleanPrefixes ?? DEFAULT_BOOLEAN_PREFIXES;
+        const callbackPrefixes = options?.callbackPrefixes ?? DEFAULT_CALLBACK_PREFIXES;
+        const booleanSuffixesToStrip = options?.booleanSuffixesToStrip ?? DEFAULT_BOOLEAN_SUFFIXES_TO_STRIP;
+        const exemptQualifiers = options?.exemptQualifiers ?? DEFAULT_EXEMPT_QUALIFIERS;
+        const minNounLengthForSuffixMatch = options?.minNounLengthForSuffixMatch ??
+            DEFAULT_MIN_NOUN_LENGTH_FOR_SUFFIX_MATCH;
+        function checkMembers(members) {
+            // Collect boolean candidates: props whose type is boolean and whose name
+            // matches a visibility/enablement prefix and has no exempt qualifier.
+            const booleanCandidates = [];
+            // Map from callback noun (lower-case) → original prop name for reporting
+            const callbackNouns = new Map();
+            for (const member of members) {
+                const name = getPropName(member);
+                if (!name || !member.typeAnnotation)
+                    continue;
+                const typeNode = member.typeAnnotation.typeAnnotation;
+                if (isBooleanTypeNode(typeNode)) {
+                    const remainder = stripBooleanPrefix(name, booleanPrefixes);
+                    if (remainder && !hasExemptQualifier(name, exemptQualifiers)) {
+                        booleanCandidates.push({ prop: member, name, remainder });
+                    }
+                }
+                else if (isCallableTypeNode(typeNode)) {
+                    const noun = extractCallbackNoun(name, callbackPrefixes);
+                    if (noun) {
+                        callbackNouns.set(noun.toLowerCase(), name);
+                    }
+                }
+            }
+            // For each boolean candidate, look for a matching callback
+            for (const { prop, name, remainder } of booleanCandidates) {
+                for (const [callbackNounLower, callbackName] of callbackNouns) {
+                    // Reconstruct the callback noun with its original casing (first char
+                    // uppercase) to use for the suffix-match length check.
+                    const callbackNoun = callbackNounLower.charAt(0).toUpperCase() +
+                        callbackNounLower.slice(1);
+                    if (booleanCoreMatchesCallbackNoun(remainder, callbackNoun, booleanSuffixesToStrip, minNounLengthForSuffixMatch)) {
+                        context.report({
+                            node: prop,
+                            messageId: 'redundantBooleanProp',
+                            data: {
+                                booleanProp: name,
+                                callbackProp: callbackName,
+                            },
+                        });
+                        break; // report at most one error per boolean prop
+                    }
+                }
+            }
+        }
+        function analyzeTypeNode(typeNode) {
+            const members = collectMembers(typeNode);
+            if (members.length > 0) {
+                checkMembers(members);
+            }
+        }
+        return {
+            TSTypeAliasDeclaration(node) {
+                analyzeTypeNode(node.typeAnnotation);
+            },
+            TSInterfaceDeclaration(node) {
+                // Analyze the interface body's own members; ignore `extends` clauses
+                // (inherited external types are not analyzed to avoid false positives).
+                const members = node.body.body.filter((m) => m.type === utils_1.AST_NODE_TYPES.TSPropertySignature);
+                checkMembers(members);
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-redundant-boolean-callback-props.js.map

package/lib/rules/no-satisfies-in-frontend-bundle.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        excludePaths?: string[];
+        includePaths?: string[];
+    }
+];
+export declare const noSatisfiesInFrontendBundle: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noSatisfiesOperator", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};