@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -33,6 +33,14 @@ const DEFAULT_BOOLEAN_PREFIXES = [
 const DEFAULT_OPTIONS = {
     prefixes: DEFAULT_BOOLEAN_PREFIXES,
     ignoreOverriddenGetters: false,
+    // Property names declared in interfaces and type aliases are frequently
+    // dictated by contracts the author cannot rename: external API request/response
+    // shapes, third-party library interfaces, and persisted data-model schemas
+    // (e.g. Firestore document fields). Flagging those produces unavoidable false
+    // positives, so property-signature enforcement is opt-in. Names the author does
+    // choose freshly — variables, function returns, class fields, parameters — stay
+    // enforced by default.
+    enforceForPropertySignatures: false,
 };
 const BOOLEANISH_BINARY_OPERATORS = new Set(['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof']);
 exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
@@ -58,6 +66,10 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                         type: 'boolean',
                         default: false,
                     },
+                    enforceForPropertySignatures: {
+                        type: 'boolean',
+                        default: false,
+                    },
                 },
                 additionalProperties: false,
             },
@@ -71,10 +83,11 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
     defaultOptions: [DEFAULT_OPTIONS],
     create(context, [options]) {
         const approvedPrefixes = options.prefixes || DEFAULT_OPTIONS.prefixes;
+        const approvedPrefixesWithoutAsserts = approvedPrefixes.filter((p) => p !== 'asserts');
         const ignoreOverriddenGetters = options.ignoreOverriddenGetters ??
             DEFAULT_OPTIONS.ignoreOverriddenGetters;
-        const importStatusCache = new Map();
-        const externalApiUsageCache = new Map();
+        const enforceForPropertySignatures = options.enforceForPropertySignatures ??
+            DEFAULT_OPTIONS.enforceForPropertySignatures;
         function findVariableInScopes(name) {
             let currentScope = context.getScope();
             while (currentScope) {
@@ -85,32 +98,58 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             }
             return undefined;
         }
+        /**
+         * Check if a name is prefixed by a boolean keyword with proper boundaries.
+         * Supports camelCase (isSomething), snake_case (is_something, IS_SOMETHING),
+         * and exact matches.
+         */
+        function isPrefixedByBooleanKeyword(name, prefixes) {
+            const normalizedName = name.startsWith('_') ? name.slice(1) : name;
+            const checkPrefix = (p) => {
+                if (!normalizedName.toLowerCase().startsWith(p.toLowerCase())) {
+                    return false;
+                }
+                if (normalizedName.length === p.length) {
+                    return true;
+                }
+                const nextChar = normalizedName.charAt(p.length);
+                // For SCREAMING_SNAKE_CASE or similar all-uppercase names,
+                // we require an underscore boundary.
+                const isAllUppercase = normalizedName === normalizedName.toUpperCase() &&
+                    /[a-z]/i.test(normalizedName);
+                if (isAllUppercase) {
+                    return nextChar === '_';
+                }
+                // For camelCase, the next char must be uppercase, a digit, or $
+                return (nextChar === '_' ||
+                    nextChar === '$' ||
+                    (nextChar >= '0' && nextChar <= '9') ||
+                    (nextChar === nextChar.toUpperCase() &&
+                        nextChar !== nextChar.toLowerCase()));
+            };
+            const checkPrefixWithPlural = (p) => {
+                if (checkPrefix(p))
+                    return true;
+                if (['is', 'has', 'does', 'was', 'had', 'did'].includes(p)) {
+                    const pluralPrefix = pluralize_1.default.plural(p);
+                    if (checkPrefix(pluralPrefix))
+                        return true;
+                }
+                return false;
+            };
+            return prefixes.some((prefix) => checkPrefixWithPlural(prefix));
+        }
         /**
          * Check if a name starts with any of the approved prefixes, their plural forms,
          * or if it starts with an underscore (which indicates a private/internal property)
          */
         function hasApprovedPrefix(name, options) {
             const treatLeadingUnderscoreAsApproved = options?.treatLeadingUnderscoreAsApproved ?? true;
-            const normalizedName = name.startsWith('_') ? name.slice(1) : name;
             // Skip checking properties that start with an underscore (private/internal properties)
             if (treatLeadingUnderscoreAsApproved && name.startsWith('_')) {
                 return true;
             }
-            return approvedPrefixes.some((prefix) => {
-                // Check for exact prefix match
-                if (normalizedName.toLowerCase().startsWith(prefix.toLowerCase())) {
-                    return true;
-                }
-                // Check for plural form of the prefix
-                // Only apply pluralization to certain prefixes that have meaningful plural forms
-                if (['is', 'has', 'does', 'was', 'had', 'did'].includes(prefix)) {
-                    const pluralPrefix = pluralize_1.default.plural(prefix);
-                    return normalizedName
-                        .toLowerCase()
-                        .startsWith(pluralPrefix.toLowerCase());
-                }
-                return false;
-            });
+            return isPrefixedByBooleanKeyword(name, approvedPrefixes);
         }
         function nameSuggestsBoolean(name) {
             const normalizedName = name.startsWith('_') ? name.slice(1) : name;
@@ -127,9 +166,8 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 'authenticated',
                 'authorized',
             ];
-            return (hasApprovedPrefix(normalizedName, {
-                treatLeadingUnderscoreAsApproved: false,
-            }) || suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
+            return (isPrefixedByBooleanKeyword(normalizedName, approvedPrefixes) ||
+                suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
         }
         /**
          * Capitalize the first letter of a name for use in suggested alternatives
@@ -207,94 +245,20 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 // Check for logical expressions (&&)
                 if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
                     node.init.operator === '&&') {
-                    // Check if the right side is a method call that might return a non-boolean value
-                    const rightSide = node.init.right;
-                    if (rightSide.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        // If right side is a simple identifier call
-                        if (rightSide.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            const calleeName = rightSide.callee.name;
-                            const lowerCallee = calleeName.toLowerCase();
-                            // For assert*-style utilities, only treat as boolean if we can confirm boolean return type
-                            if (lowerCallee.startsWith('assert')) {
-                                return identifierReturnsBoolean(calleeName);
-                            }
-                            // Otherwise, infer based on naming heuristics
-                            const isBooleanCall = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                                lowerCallee.startsWith(prefix.toLowerCase()));
-                            if (isBooleanCall ||
-                                lowerCallee.includes('boolean') ||
-                                lowerCallee.includes('enabled') ||
-                                lowerCallee.includes('auth') ||
-                                lowerCallee.includes('valid') ||
-                                lowerCallee.includes('check')) {
-                                return true;
-                            }
-                            if (lowerCallee.startsWith('get') ||
-                                lowerCallee.startsWith('fetch') ||
-                                lowerCallee.startsWith('retrieve') ||
-                                lowerCallee.startsWith('load') ||
-                                lowerCallee.startsWith('read')) {
-                                return false;
-                            }
-                        }
-                        // If the method name doesn't suggest it returns a boolean, don't flag it
-                        if (rightSide.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                            rightSide.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            const methodName = rightSide.callee.property.name;
-                            const lowerMethodName = methodName.toLowerCase();
-                            // Ignore assert*-style methods which often return the input value
-                            if (lowerMethodName.startsWith('assert')) {
-                                return false;
-                            }
-                            // Check if the method name suggests it returns a boolean
-                            const isBooleanMethod = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                                lowerMethodName.startsWith(prefix.toLowerCase()));
-                            // If the method name suggests it returns a boolean (starts with a boolean prefix or contains 'boolean' or 'enabled'),
-                            // then the variable should be treated as a boolean
-                            if (isBooleanMethod ||
-                                lowerMethodName.includes('boolean') ||
-                                lowerMethodName.includes('enabled') ||
-                                lowerMethodName.includes('auth') ||
-                                lowerMethodName.includes('valid') ||
-                                lowerMethodName.includes('check')) {
-                                return true;
-                            }
-                            // For methods like getVolume(), getData(), etc., assume they return non-boolean values
-                            if (lowerMethodName.startsWith('get') ||
-                                lowerMethodName.startsWith('fetch') ||
-                                lowerMethodName.startsWith('retrieve') ||
-                                lowerMethodName.startsWith('load') ||
-                                lowerMethodName.startsWith('read')) {
-                                return false;
-                            }
-                        }
+                    const left = evaluateBooleanishExpression(node.init.left);
+                    const right = evaluateBooleanishExpression(node.init.right);
+                    // If both sides are boolean, the result is boolean.
+                    if (left === 'boolean' && right === 'boolean') {
+                        return true;
                     }
-                    // Check if the right side is a property access that might return a non-boolean value
-                    if (rightSide.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        rightSide.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const propertyName = rightSide.property.name;
-                        const lowerPropertyName = propertyName.toLowerCase();
-                        // If the property name is 'parentElement', 'parentNode', etc., it's likely not a boolean
-                        if (lowerPropertyName.includes('parent') ||
-                            lowerPropertyName.includes('element') ||
-                            lowerPropertyName.includes('node') ||
-                            lowerPropertyName.includes('child') ||
-                            lowerPropertyName.includes('sibling')) {
-                            return false;
-                        }
-                        // Ignore assert*-style properties which often return the input value
-                        if (lowerPropertyName.startsWith('assert')) {
-                            return false;
-                        }
-                        // For property access like user.isAuthenticated, treat as boolean
-                        const isBooleanProperty = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                            lowerPropertyName.startsWith(prefix.toLowerCase()));
-                        if (isBooleanProperty) {
-                            return true;
-                        }
+                    // If the right side is boolean, and the left side is unknown (but not non-boolean),
+                    // we treat it as boolean to avoid false negatives for common patterns like `user && user.isActive`.
+                    // This is a trade-off: it might cause some false positives for non-boolean variables
+                    // used as guards, but those are less common than the `user && user.isActive` pattern.
+                    if (right === 'boolean' && left === 'unknown') {
+                        return true;
                     }
-                    // Default to true for other cases with && to avoid false negatives
-                    return true;
+                    return false;
                 }
                 // Special case for logical OR (||) - only consider it boolean if:
                 // 1. It's used with boolean literals or
@@ -332,8 +296,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                         if (lowerCallee.startsWith('assert')) {
                             return identifierReturnsBoolean(calleeName);
                         }
-                        return approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                            lowerCallee.startsWith(prefix.toLowerCase()));
+                        return isPrefixedByBooleanKeyword(calleeName, approvedPrefixesWithoutAsserts);
                     }
                     // Default to false for other cases with || to avoid false positives
                     return false;
@@ -353,8 +316,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                         return identifierReturnsBoolean(calleeName);
                     }
                     // Check if the function name suggests it returns a boolean
-                    return approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                        lowerCallee.startsWith(prefix.toLowerCase()));
+                    return isPrefixedByBooleanKeyword(calleeName, approvedPrefixes.filter((p) => p !== 'asserts'));
                 }
             }
             return false;
@@ -437,8 +399,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 if (lowerCallee.startsWith('assert')) {
                     return identifierReturnsBoolean(calleeName) ? 'boolean' : 'unknown';
                 }
-                const matchesPrefix = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                    lowerCallee.startsWith(prefix.toLowerCase()));
+                const matchesPrefix = isPrefixedByBooleanKeyword(calleeName, approvedPrefixesWithoutAsserts);
                 if (matchesPrefix ||
                     lowerCallee.includes('boolean') ||
                     lowerCallee.includes('enabled') ||
@@ -462,8 +423,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 if (lowerMethodName.startsWith('assert')) {
                     return 'unknown';
                 }
-                const matchesPrefix = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                    lowerMethodName.startsWith(prefix.toLowerCase()));
+                const matchesPrefix = isPrefixedByBooleanKeyword(methodName, approvedPrefixesWithoutAsserts);
                 if (matchesPrefix ||
                     lowerMethodName.includes('boolean') ||
                     lowerMethodName.includes('enabled') ||
@@ -477,7 +437,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
         }
         function evaluateBooleanishExpression(expression) {
             if (!expression)
-                return 'nonBoolean';
+                return 'unknown';
             let currentExpression = expression;
             if (currentExpression.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
                 currentExpression.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
@@ -827,10 +787,10 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             });
         }
         /**
-         * Check if a variable is used in a while loop condition and is likely a boolean
+         * Check if a variable is initialized with a boolean-suggesting member expression
          * This helps identify variables that should be flagged as needing a boolean prefix
          */
-        function isLikelyBooleanInWhileLoop(node) {
+        function isLikelyBooleanByMemberExpression(node) {
             // Check if the variable is initialized with a boolean-related value
             const variableDeclarator = node.parent;
             if (variableDeclarator?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
@@ -846,7 +806,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     init.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     const propertyName = init.property.name;
                     // If the property name suggests it's a boolean (starts with a boolean prefix)
-                    const isBooleanProperty = approvedPrefixes.some((prefix) => propertyName.toLowerCase().startsWith(prefix.toLowerCase()));
+                    const isBooleanProperty = isPrefixedByBooleanKeyword(propertyName, approvedPrefixes);
                     if (isBooleanProperty) {
                         return true;
                     }
@@ -897,8 +857,8 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 return;
             // Check if it's a boolean variable
             let isBooleanVar = hasBooleanTypeAnnotation(node.id) || hasInitialBooleanValue(node);
-            // Check if it's a boolean variable used in a while loop
-            if (!isBooleanVar && isLikelyBooleanInWhileLoop(node.id)) {
+            // Check if it's a boolean variable used in a while loop or initialized with a boolean property
+            if (!isBooleanVar && isLikelyBooleanByMemberExpression(node.id)) {
                 isBooleanVar = true;
             }
             // Check if it's an arrow function with boolean return type
@@ -1072,219 +1032,15 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 });
             }
         }
-        /**
-         * Check if an identifier is imported from an external module
-         */
-        function isImportedIdentifier(name) {
-            if (importStatusCache.has(name)) {
-                const cached = importStatusCache.get(name);
-                if (cached !== undefined)
-                    return cached;
-            }
-            const variable = findVariableInScopes(name);
-            if (!variable) {
-                importStatusCache.set(name, false);
-                return false;
-            }
-            const isImport = variable.defs.some((def) => def.type === 'ImportBinding');
-            importStatusCache.set(name, isImport);
-            return isImport;
-        }
-        /**
-         * Check if a variable is used with an external API
-         */
-        function isVariableUsedWithExternalApi(variableName) {
-            if (externalApiUsageCache.has(variableName)) {
-                const cached = externalApiUsageCache.get(variableName);
-                if (cached !== undefined)
-                    return cached;
-            }
-            const variable = findVariableInScopes(variableName);
-            if (!variable) {
-                externalApiUsageCache.set(variableName, false);
-                return false;
-            }
-            for (const reference of variable.references) {
-                if (reference.identifier === variable.identifiers[0])
-                    continue;
-                const id = reference.identifier;
-                const markAndReturnTrue = () => {
-                    externalApiUsageCache.set(variableName, true);
-                    return true;
-                };
-                if (id.parent?.type === utils_1.AST_NODE_TYPES.Property &&
-                    id.parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                    id.parent.parent.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                    id.parent.parent.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    isImportedIdentifier(id.parent.parent.parent.callee.name)) {
-                    return markAndReturnTrue();
-                }
-                if (id.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    if (id.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        isImportedIdentifier(id.parent.callee.name)) {
-                        return markAndReturnTrue();
-                    }
-                    if (id.parent.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        id.parent.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        isImportedIdentifier(id.parent.callee.object.name)) {
-                        return markAndReturnTrue();
-                    }
-                }
-                if (id.parent?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
-                    id.parent.parent?.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
-                    id.parent.parent.parent?.type === utils_1.AST_NODE_TYPES.JSXOpeningElement &&
-                    id.parent.parent.parent.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
-                    isImportedIdentifier(id.parent.parent.parent.name.name)) {
-                    return markAndReturnTrue();
-                }
-                if (id.parent?.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute &&
-                    id.parent.parent?.type === utils_1.AST_NODE_TYPES.JSXOpeningElement &&
-                    id.parent.parent.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
-                    isImportedIdentifier(id.parent.parent.name.name)) {
-                    return markAndReturnTrue();
-                }
-            }
-            externalApiUsageCache.set(variableName, false);
-            return false;
-        }
-        const HOOK_NAMES = new Set(['useMemo', 'useCallback', 'useState']);
-        function findVariableFromReactHook(objectExpr) {
-            let current = objectExpr;
-            while (current) {
-                if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
-                    current = current.parent;
-                    continue;
-                }
-                if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
-                    current.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                    current.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    HOOK_NAMES.has(current.parent.callee.name) &&
-                    current.parent.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    current.parent.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    return current.parent.parent.id.name;
-                }
-                current = current.parent;
-            }
-            return undefined;
-        }
-        /**
-         * Check property definitions for boolean values
-         */
-        function checkProperty(node) {
-            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
-                return;
-            const propertyName = node.key.name;
-            // Check if it's a boolean property
-            let isBooleanProperty = false;
-            // Check if it's initialized with a boolean value
-            if (node.value.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.value.value === 'boolean') {
-                isBooleanProperty = true;
-            }
-            // Check if it's a method that returns a boolean
-            if ((node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                node.value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
-                node.value.returnType?.typeAnnotation.type ===
-                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
-                isBooleanProperty = true;
-            }
-            // Skip checking if this property is part of an object literal passed to an external function
-            if (isBooleanProperty && !hasApprovedPrefix(propertyName)) {
-                // Special cases for common Node.js API boolean properties
-                if ((propertyName === 'recursive' || propertyName === 'keepAlive') &&
-                    node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    return; // Skip checking for these properties in object literals passed to functions
-                }
-                // Check if this property is in an object literal that's an argument to a function call
-                let isExternalApiCall = false;
-                // Navigate up to find if we're in an object expression that's an argument to a function call
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    const callExpression = node.parent.parent;
-                    // Check if the function being called is an identifier (like mkdirSync, createServer, etc.)
-                    if (callExpression.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const calleeName = callExpression.callee.name;
-                        if (isImportedIdentifier(calleeName)) {
-                            isExternalApiCall = true;
-                        }
-                    }
-                    // Also check for member expressions like fs.mkdirSync
-                    if (callExpression.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        // For member expressions, check if the object is imported
-                        const objectNode = callExpression.callee.object;
-                        if (objectNode.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            const objectName = objectNode.name;
-                            if (isImportedIdentifier(objectName)) {
-                                isExternalApiCall = true;
-                            }
-                        }
-                    }
-                }
-                // Check if this property is in an object literal that's being assigned to a variable
-                // This handles cases like const messageInputProps = { grow: true }
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    node.parent.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    const variableName = node.parent.parent.id.name;
-                    if (isVariableUsedWithExternalApi(variableName)) {
-                        isExternalApiCall = true;
-                    }
-                }
-                // Special case for useMemo and other React hooks
-                // This handles cases like:
-                // 1. const messageInputProps = useMemo(() => ({ grow: true }), [])
-                // 2. const messageInputProps = useMemo(() => { return { grow: true }; }, [])
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    const hookVariable = findVariableFromReactHook(node.parent);
-                    if (hookVariable && isVariableUsedWithExternalApi(hookVariable)) {
-                        isExternalApiCall = true;
-                    }
-                }
-                // Check if this property is in an object literal that's directly passed to an imported function
-                // This handles cases like ExternalComponent({ grow: true })
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                    node.parent.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    const calleeName = node.parent.parent.callee.name;
-                    if (isImportedIdentifier(calleeName)) {
-                        isExternalApiCall = true;
-                    }
-                }
-                // Check if this property is in an object literal that's directly passed as a JSX attribute
-                // This handles cases like <ExternalComponent config={{ active: true }} />
-                if (node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
-                    node.parent.parent.parent?.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
-                    node.parent.parent.parent.parent?.type ===
-                        utils_1.AST_NODE_TYPES.JSXOpeningElement) {
-                    const jsxOpeningElement = node.parent.parent.parent.parent;
-                    if (jsxOpeningElement.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
-                        const componentName = jsxOpeningElement.name.name;
-                        if (isImportedIdentifier(componentName)) {
-                            isExternalApiCall = true;
-                        }
-                    }
-                }
-                // Only report if it's not an external API call
-                if (!isExternalApiCall) {
-                    context.report({
-                        node: node.key,
-                        messageId: 'missingBooleanPrefix',
-                        data: {
-                            type: 'property',
-                            name: propertyName,
-                            capitalizedName: capitalizeFirst(propertyName),
-                            prefixes: formatPrefixes(),
-                        },
-                    });
-                }
-            }
-        }
         /**
          * Check property signatures in interfaces/types for boolean types
          */
         function checkPropertySignature(node) {
+            // Interface/type-alias property names are commonly imposed by contracts the
+            // author cannot rename (external APIs, data-model schemas), so they are only
+            // enforced when explicitly opted in.
+            if (!enforceForPropertySignatures)
+                return;
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
             const propertyName = node.key.name;
@@ -1390,7 +1146,6 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             },
             MethodDefinition: checkMethodDefinition,
             TSAbstractMethodDefinition: checkMethodDefinition,
-            Property: checkProperty,
             ClassProperty: checkClassProperty,
             PropertyDefinition: checkClassPropertyDeclaration,
             TSPropertySignature: checkPropertySignature,

package/lib/rules/enforce-date-ttime.d.ts

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