@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

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

@@ -34,6 +34,7 @@ const DEFAULT_OPTIONS = {
     prefixes: DEFAULT_BOOLEAN_PREFIXES,
     ignoreOverriddenGetters: false,
 };
+const BOOLEANISH_BINARY_OPERATORS = new Set(['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof']);
 exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
     name: 'enforce-boolean-naming-prefixes',
     meta: {
@@ -62,17 +63,16 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            missingBooleanPrefix: 'Boolean {{type}} "{{name}}" should start with a prefix like "is", "has", "can", or "should" (e.g., is{{capitalizedName}}, has{{capitalizedName}}). ' +
-                'Boolean prefixes make code self-documenting—readers immediately know the value is true/false without checking its declaration or type. ' +
-                'This improves readability at call sites: `if (user.{{name}})` is ambiguous, but `if (user.is{{capitalizedName}})` clearly signals a boolean check.',
+            missingBooleanPrefix: 'Boolean {{type}} "{{name}}" is missing a common approved boolean prefix ({{prefixes}}). ' +
+                'Prefixes immediately communicate that the value is a true/false predicate; without one, checks like `if ({{name}})` read as generic truthiness guards and hide the boolean intent. ' +
+                'Rename by prepending any approved prefix so the name becomes `<prefix>{{capitalizedName}}`, making the boolean contract obvious at call sites and API boundaries.',
         },
     },
     defaultOptions: [DEFAULT_OPTIONS],
     create(context, [options]) {
         const approvedPrefixes = options.prefixes || DEFAULT_OPTIONS.prefixes;
-        const ignoreOverriddenGetters = options.ignoreOverriddenGetters ?? DEFAULT_OPTIONS.ignoreOverriddenGetters;
-        const importStatusCache = new Map();
-        const externalApiUsageCache = new Map();
+        const ignoreOverriddenGetters = options.ignoreOverriddenGetters ??
+            DEFAULT_OPTIONS.ignoreOverriddenGetters;
         function findVariableInScopes(name) {
             let currentScope = context.getScope();
             while (currentScope) {
@@ -127,8 +127,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             ];
             return (hasApprovedPrefix(normalizedName, {
                 treatLeadingUnderscoreAsApproved: false,
-            }) ||
-                suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
+            }) || suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
         }
         /**
          * Capitalize the first letter of a name for use in suggested alternatives
@@ -200,7 +199,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 }
                 // Check for logical expressions that typically return boolean
                 if (node.init.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
-                    ['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof'].includes(node.init.operator)) {
+                    BOOLEANISH_BINARY_OPERATORS.has(node.init.operator)) {
                     return true;
                 }
                 // Check for logical expressions (&&)
@@ -377,7 +376,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     return true;
                 }
                 if (node.body.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
-                    ['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof'].includes(node.body.operator)) {
+                    BOOLEANISH_BINARY_OPERATORS.has(node.body.operator)) {
                     return true;
                 }
                 if (node.body.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
@@ -434,9 +433,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 const calleeName = callExpression.callee.name;
                 const lowerCallee = calleeName.toLowerCase();
                 if (lowerCallee.startsWith('assert')) {
-                    return identifierReturnsBoolean(calleeName)
-                        ? 'boolean'
-                        : 'unknown';
+                    return identifierReturnsBoolean(calleeName) ? 'boolean' : 'unknown';
                 }
                 const matchesPrefix = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
                     lowerCallee.startsWith(prefix.toLowerCase()));
@@ -516,18 +513,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 return callExpressionLooksBoolean(currentExpression);
             }
             if (currentExpression.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                if ([
-                    '===',
-                    '!==',
-                    '==',
-                    '!=',
-                    '>',
-                    '<',
-                    '>=',
-                    '<=',
-                    'in',
-                    'instanceof',
-                ].includes(currentExpression.operator)) {
+                if (BOOLEANISH_BINARY_OPERATORS.has(currentExpression.operator)) {
                     return 'boolean';
                 }
             }
@@ -1084,215 +1070,6 @@ 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
          */
@@ -1402,7 +1179,6 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             },
             MethodDefinition: checkMethodDefinition,
             TSAbstractMethodDefinition: checkMethodDefinition,
-            Property: checkProperty,
             ClassProperty: checkClassProperty,
             PropertyDefinition: checkClassPropertyDeclaration,
             TSPropertySignature: checkPropertySignature,

package/lib/rules/enforce-callback-memo.js

@@ -90,7 +90,7 @@ exports.default = (0, createRule_1.createRule)({
             return [];
         }
         function referencesParentScopeVariables(functionNode, parentParams) {
-            const scopeManager = context.getSourceCode().scopeManager;
+            const scopeManager = context.sourceCode.scopeManager;
             if (!scopeManager)
                 return false;
             const scope = scopeManager.acquire(functionNode);

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -140,7 +140,7 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
             },
             'Program:exit'() {
                 if (mockFirestoreNodes.size > 0) {
-                    const sourceCode = context.getSourceCode();
+                    const sourceCode = context.sourceCode;
                     // Report only once for the entire file
                     context.report({
                         node: Array.from(mockFirestoreNodes)[0],

package/lib/rules/enforce-console-error.js

@@ -8,13 +8,13 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce proper logging for useAlertDialog based on severity. When severity is "error", console.error must be included. When severity is "warning", console.warn must be included. This ensures all user-facing errors and warnings are properly logged to monitoring systems.',
+            description: 'Enforce proper logging for useAlertDialog based on severity. When severity is "error", console.error must be included. When severity is "warning", console.warn must be included. This ensures all user-facing errors and warnings are properly logged to observability systems.',
             recommended: 'error',
         },
         messages: {
-            missingConsoleError: 'useAlertDialog with severity "error" requires a console.error statement in the same function scope for proper monitoring.',
-            missingConsoleWarn: 'useAlertDialog with severity "warning" requires a console.warn statement in the same function scope for proper monitoring.',
-            missingConsoleBoth: 'useAlertDialog with dynamic severity requires both console.error and console.warn statements in the same function scope for proper monitoring.',
+            missingConsoleError: 'useAlertDialog call with severity "{{severity}}" shows an error dialog but this function never logs with {{consoleMethod}}. Without the log the alert is invisible to observability and post-incident breadcrumbs. Add a {{consoleMethod}} call in this function scope before or after the open() call so the dialog is paired with an observable error trail.',
+            missingConsoleWarn: 'useAlertDialog call with severity "{{severity}}" shows a warning dialog but this function never logs with {{consoleMethod}}. Without the log the warning is invisible to observability, making degraded states hard to diagnose. Add a {{consoleMethod}} call in this function scope before or after the open() call so the dialog is paired with an observable warning trail.',
+            missingConsoleBoth: 'useAlertDialog call uses dynamic severity, so runtime may render an error or a warning dialog. It is missing {{missingMethods}} in this function scope, leaving one or more runtime severity branches (error or warning) without observability breadcrumbs: {{missingPaths}}. Branch on the severity value and add the matching console method before or after the open() call (console.error for error branches, console.warn for warning branches), as in the conditional pattern shown in the rule docs, so each branch leaves a single appropriate log trail instead of double-logging both methods.',
         },
         schema: [],
     },
@@ -145,13 +145,33 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                     const needsConsoleError = hasError || hasDynamic;
                     const needsConsoleWarn = hasWarning || hasDynamic;
                     if (hasDynamic && (!hasConsoleError || !hasConsoleWarn)) {
-                        const dynamicCall = group.openCalls.find((call) => call.severity === 'dynamic');
-                        if (dynamicCall) {
+                        const missingMethods = [];
+                        const missingSeverities = [];
+                        if (!hasConsoleError) {
+                            missingMethods.push('console.error');
+                            missingSeverities.push('error');
+                        }
+                        if (!hasConsoleWarn) {
+                            missingMethods.push('console.warn');
+                            missingSeverities.push('warning');
+                        }
+                        const missingMethodsLabel = missingMethods.length === 2
+                            ? 'console.error and console.warn'
+                            : missingMethods[0];
+                        const missingPathsLabel = missingSeverities.length === 2
+                            ? 'the error and warning severity paths'
+                            : `the ${missingSeverities[0]} severity path`;
+                        const dynamicCalls = group.openCalls.filter((call) => call.severity === 'dynamic');
+                        dynamicCalls.forEach((dynamicCall) => {
                             context.report({
                                 node: dynamicCall.node,
                                 messageId: 'missingConsoleBoth',
+                                data: {
+                                    missingMethods: missingMethodsLabel,
+                                    missingPaths: missingPathsLabel,
+                                },
                             });
-                        }
+                        });
                     }
                     else {
                         if (needsConsoleError && !hasConsoleError) {
@@ -160,6 +180,10 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                                 context.report({
                                     node: errorCall.node,
                                     messageId: 'missingConsoleError',
+                                    data: {
+                                        severity: 'error',
+                                        consoleMethod: 'console.error',
+                                    },
                                 });
                             }
                         }
@@ -169,6 +193,10 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                                 context.report({
                                     node: warningCall.node,
                                     messageId: 'missingConsoleWarn',
+                                    data: {
+                                        severity: 'warning',
+                                        consoleMethod: 'console.warn',
+                                    },
                                 });
                             }
                         }

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

package/lib/rules/enforce-date-ttime.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceDateTTime = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
+const createRule_1 = require("../utils/createRule");
+exports.enforceDateTTime = (0, createRule_1.createRule)({
+    name: 'enforce-date-ttime',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce that any generic type parameter named TTime is explicitly set to Date in frontend code',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceDateTTime: '{{typeName}} leaves TTime unspecified or not Date → Firestore Frontend Hooks convert Timestamp to Date on the client, so non-Date TTime misrepresents runtime values and forces defensive conversions → Set the TTime argument to Date explicitly (e.g., {{typeName}}<..., Date, ...>).',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const parserServices = sourceCode?.parserServices ?? context.parserServices;
+        const checker = parserServices?.program?.getTypeChecker();
+        if (!parserServices || !checker) {
+            return {};
+        }
+        const tTimeIndexCache = new WeakMap();
+        /**
+         * Finds the index of the TTime parameter in the given symbol's declarations.
+         */
+        function findTTimeParameterIndex(symbol) {
+            if (tTimeIndexCache.has(symbol)) {
+                return tTimeIndexCache.get(symbol);
+            }
+            const declarations = symbol.getDeclarations();
+            if (!declarations) {
+                tTimeIndexCache.set(symbol, undefined);
+                return undefined;
+            }
+            for (const declaration of declarations) {
+                if (ts.isTypeAliasDeclaration(declaration) ||
+                    ts.isInterfaceDeclaration(declaration) ||
+                    ts.isClassDeclaration(declaration)) {
+                    if (declaration.typeParameters) {
+                        const index = declaration.typeParameters.findIndex((tp) => tp.name.text === 'TTime');
+                        if (index !== -1) {
+                            tTimeIndexCache.set(symbol, index);
+                            return index;
+                        }
+                    }
+                }
+            }
+            tTimeIndexCache.set(symbol, undefined);
+            return undefined;
+        }
+        /**
+         * Checks if a type node is exactly "Date".
+         */
+        function isExactDate(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.typeName.name === 'Date' &&
+                (!node.typeParameters || node.typeParameters.params.length === 0)) {
+                return true;
+            }
+            return false;
+        }
+        return {
+            TSTypeReference(node) {
+                const typeNameNode = node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName
+                    ? node.typeName.right
+                    : node.typeName;
+                if (typeNameNode.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                // Skip the "Date" type itself
+                if (typeNameNode.name === 'Date')
+                    return;
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                const symbol = checker.getSymbolAtLocation(tsNode.typeName);
+                if (!symbol)
+                    return;
+                const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias
+                    ? checker.getAliasedSymbol(symbol)
+                    : symbol;
+                const tTimeIndex = findTTimeParameterIndex(resolvedSymbol);
+                if (tTimeIndex === undefined)
+                    return;
+                const typeArgs = node.typeParameters?.params || [];
+                const tTimeArg = typeArgs[tTimeIndex];
+                const typeName = sourceCode.getText(node.typeName);
+                if (!tTimeArg) {
+                    // TTime is omitted
+                    context.report({
+                        node,
+                        messageId: 'enforceDateTTime',
+                        data: { typeName },
+                        fix(fixer) {
+                            if (node.typeParameters) {
+                                // Already has type parameters, but not enough to cover TTime
+                                const lastParam = node.typeParameters.params[node.typeParameters.params.length - 1];
+                                // Check if we can just append ", Date"
+                                // We can only do this safely if all parameters between existing ones and TTime have defaults.
+                                // For simplicity and safety, we only fix if tTimeIndex is the next one or if it's already provided.
+                                if (tTimeIndex === node.typeParameters.params.length) {
+                                    return fixer.insertTextAfter(lastParam, ', Date');
+                                }
+                            }
+                            else if (tTimeIndex === 0) {
+                                // No type parameters and TTime is the first one
+                                return fixer.insertTextAfter(node.typeName, '<Date>');
+                            }
+                            return null;
+                        },
+                    });
+                }
+                else if (!isExactDate(tTimeArg)) {
+                    // TTime is provided but is not exactly Date
+                    context.report({
+                        node: tTimeArg,
+                        messageId: 'enforceDateTTime',
+                        data: { typeName },
+                        fix(fixer) {
+                            return fixer.replaceText(tTimeArg, 'Date');
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-date-ttime.js.map

package/lib/rules/enforce-dynamic-file-naming.d.ts

@@ -1,3 +1,5 @@
 export declare const RULE_NAME = "enforce-dynamic-file-naming";
+export declare const REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE = "@blumintinc/blumint/require-dynamic-firebase-imports";
+export declare const DYNAMIC_RULES_LABEL: string;
 declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireDynamicExtension" | "requireDisableDirective", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;