@blumintinc/eslint-plugin-blumint 1.16.1 → 1.17.0

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

package/lib/rules/no-satisfies-in-frontend-bundle.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSatisfiesInFrontendBundle = void 0;
+const minimatch_1 = require("minimatch");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_EXCLUDE_PATHS = [
+    'functions/src/firestore/**',
+    'functions/src/callable/**',
+    'functions/src/pubsub/**',
+    'functions/src/webhooks/**',
+    'functions/src/queues/**',
+    'functions/src/realtime/**',
+];
+const DEFAULT_INCLUDE_PATHS = ['src/**', 'functions/src/**'];
+/**
+ * Normalizes a filesystem path to forward slashes for consistent
+ * glob matching on all platforms.
+ */
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+/**
+ * Returns the portion of the normalized path starting from a recognized
+ * root segment (`src/` or `functions/`), so that absolute paths from
+ * the RuleTester (e.g. `/project/src/components/Foo.tsx`) are matched
+ * against the configured include/exclude globs as if they were relative
+ * to the project root.
+ *
+ * Check `functions/` before `src/` because `functions/src/` paths contain
+ * `/src/` as a substring; matching `/src/` first would incorrectly strip
+ * the `functions/` prefix and break exclude-glob matching.
+ */
+function toRelativeLike(normalizedFilename) {
+    const functionsIdx = normalizedFilename.indexOf('/functions/');
+    if (functionsIdx !== -1) {
+        return normalizedFilename.slice(functionsIdx + 1); // "functions/..."
+    }
+    const srcIdx = normalizedFilename.indexOf('/src/');
+    if (srcIdx !== -1) {
+        return normalizedFilename.slice(srcIdx + 1); // "src/..."
+    }
+    return normalizedFilename;
+}
+exports.noSatisfiesInFrontendBundle = (0, createRule_1.createRule)({
+    name: 'no-satisfies-in-frontend-bundle',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow the `satisfies` operator in files that reach the frontend webpack bundle (Next.js 12 SWC cannot parse it)',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    excludePaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_EXCLUDE_PATHS,
+                    },
+                    includePaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_INCLUDE_PATHS,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noSatisfiesOperator: 'SWC in Next.js 12 cannot parse `satisfies`; this file is bundled by webpack and will fail the production build. Use an explicit type annotation, or a constrained identity helper when literal keys must be preserved.',
+        },
+    },
+    defaultOptions: [
+        {
+            excludePaths: DEFAULT_EXCLUDE_PATHS,
+            includePaths: DEFAULT_INCLUDE_PATHS,
+        },
+    ],
+    create(context, [options]) {
+        const excludePaths = options.excludePaths ?? DEFAULT_EXCLUDE_PATHS;
+        const includePaths = options.includePaths ?? DEFAULT_INCLUDE_PATHS;
+        const filename = context.getFilename();
+        // Skip synthetic filenames used by RuleTester when no filename is provided.
+        if (filename === '<input>' || filename === '<text>') {
+            return {};
+        }
+        const normalizedFilename = normalizePath(filename);
+        // Exempt declaration files — they are never bundled.
+        if (normalizedFilename.endsWith('.d.ts')) {
+            return {};
+        }
+        // Exempt test and spec files — they are never bundled.
+        if (/\.(test|spec)\.[jt]sx?$/.test(normalizedFilename)) {
+            return {};
+        }
+        // Derive a path relative to the project root for glob matching.
+        const relPath = toRelativeLike(normalizedFilename);
+        // Only enforce within the configured include paths.
+        const includeMatchers = includePaths.map((pattern) => new minimatch_1.Minimatch(pattern, { dot: true }));
+        const isIncluded = includeMatchers.some((mm) => mm.match(normalizedFilename) || mm.match(relPath));
+        if (!isIncluded) {
+            return {};
+        }
+        // Skip files that match any exclude path.
+        const excludeMatchers = excludePaths.map((pattern) => new minimatch_1.Minimatch(pattern, { dot: true }));
+        const isExcluded = excludeMatchers.some((mm) => mm.match(normalizedFilename) || mm.match(relPath));
+        if (isExcluded) {
+            return {};
+        }
+        return {
+            // Every TSSatisfiesExpression is reported regardless of wrapping context.
+            // "x as const satisfies T" is a TSSatisfiesExpression (wrapping a
+            // TSAsExpression), so it is caught. Bare "as const" (TSAsExpression
+            // only) is NOT caught — correct.
+            TSSatisfiesExpression(node) {
+                context.report({
+                    node,
+                    messageId: 'noSatisfiesOperator',
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-satisfies-in-frontend-bundle.js.map

package/lib/rules/no-single-dismiss-dialog-button.d.ts

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

package/lib/rules/no-single-dismiss-dialog-button.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSingleDismissDialogButton = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_DISMISS_LABELS = [
+    'Cancel',
+    'Close',
+    'Dismiss',
+    'Not now',
+    'Never mind',
+];
+/**
+ * Extracts the string value from a node that is either a string Literal or a
+ * TemplateLiteral with no expressions (i.e. a plain template string). Returns
+ * null for anything more dynamic.
+ */
+function getStaticStringValue(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+        return node.value;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1) {
+        return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
+    }
+    return null;
+}
+/**
+ * Returns true when the value (after trimming) matches one of the dismiss
+ * labels, case-insensitively.
+ */
+function isDismissLabel(value, dismissLabels) {
+    const normalized = value.trim().toLowerCase();
+    return dismissLabels.some((label) => label.toLowerCase() === normalized);
+}
+/**
+ * Searches the properties of an ObjectExpression for a property named
+ * `children` whose value is a static string matching a dismiss label.
+ * Returns the button ObjectExpression node if found, null otherwise.
+ */
+function findDismissChildrenProp(element, dismissLabels) {
+    for (const prop of element.properties) {
+        if (prop.type !== utils_1.AST_NODE_TYPES.Property)
+            continue;
+        if (prop.computed)
+            continue;
+        const key = prop.key;
+        const isChildrenKey = (key.type === utils_1.AST_NODE_TYPES.Identifier && key.name === 'children') ||
+            (key.type === utils_1.AST_NODE_TYPES.Literal && key.value === 'children');
+        if (!isChildrenKey)
+            continue;
+        const staticVal = getStaticStringValue(prop.value);
+        if (staticVal !== null && isDismissLabel(staticVal, dismissLabels)) {
+            return prop;
+        }
+    }
+    return null;
+}
+exports.noSingleDismissDialogButton = (0, createRule_1.createRule)({
+    name: 'no-single-dismiss-dialog-button',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow a single dialog button whose label is a dismiss action (Cancel, Close, Dismiss, Not now, Never mind). Use navigation.onClose for dismissal; the buttons array should only contain affirmative actions.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    dismissLabels: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_DISMISS_LABELS,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noSingleDismissDialogButton: 'A single dialog button with label "{{label}}" is a dismiss action. Use navigation.onClose to handle dismissal via the X close button instead; the buttons array should only contain affirmative actions.',
+        },
+    },
+    defaultOptions: [{ dismissLabels: DEFAULT_DISMISS_LABELS }],
+    create(context) {
+        const options = context.options[0] ?? {};
+        const dismissLabels = options.dismissLabels ?? DEFAULT_DISMISS_LABELS;
+        return {
+            Property(node) {
+                // Only care about properties named `buttons`
+                if (node.computed)
+                    return;
+                const key = node.key;
+                const isButtonsKey = (key.type === utils_1.AST_NODE_TYPES.Identifier && key.name === 'buttons') ||
+                    (key.type === utils_1.AST_NODE_TYPES.Literal && key.value === 'buttons');
+                if (!isButtonsKey)
+                    return;
+                // The value must be an array literal
+                if (node.value.type !== utils_1.AST_NODE_TYPES.ArrayExpression)
+                    return;
+                const arrayExpr = node.value;
+                // Only flag exactly one element
+                if (arrayExpr.elements.length !== 1)
+                    return;
+                const element = arrayExpr.elements[0];
+                if (!element || element.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                    return;
+                const dismissProp = findDismissChildrenProp(element, dismissLabels);
+                if (!dismissProp)
+                    return;
+                // Retrieve the label text for the error message
+                const labelNode = dismissProp.value;
+                const labelText = getStaticStringValue(labelNode) ?? '';
+                context.report({
+                    node: element,
+                    messageId: 'noSingleDismissDialogButton',
+                    data: {
+                        label: labelText.trim(),
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-single-dismiss-dialog-button.js.map

package/lib/rules/no-stablehash-react-nodes.d.ts

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