@blumintinc/eslint-plugin-blumint 1.14.0 → 1.15.0

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

@@ -73,8 +73,6 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
         const approvedPrefixes = options.prefixes || DEFAULT_OPTIONS.prefixes;
         const ignoreOverriddenGetters = options.ignoreOverriddenGetters ??
             DEFAULT_OPTIONS.ignoreOverriddenGetters;
-        const importStatusCache = new Map();
-        const externalApiUsageCache = new Map();
         function findVariableInScopes(name) {
             let currentScope = context.getScope();
             while (currentScope) {
@@ -1072,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
          */
@@ -1390,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-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-firebase-imports.d.ts

@@ -1,4 +1,5 @@
 import { TSESTree } from '@typescript-eslint/utils';
-export declare const enforceFirebaseImports: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noDynamicImport", never[], {
+declare const enforceFirebaseImports: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noDynamicImport", never[], {
     ImportDeclaration(node: TSESTree.ImportDeclaration): void;
 }>;
+export default enforceFirebaseImports;

package/lib/rules/enforce-dynamic-firebase-imports.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enforceFirebaseImports = void 0;
 const createRule_1 = require("../utils/createRule");
-exports.enforceFirebaseImports = (0, createRule_1.createRule)({
+const enforceFirebaseImports = (0, createRule_1.createRule)({
     name: 'enforce-dynamic-firebase-imports',
     meta: {
         type: 'problem',
@@ -112,6 +111,7 @@ exports.enforceFirebaseImports = (0, createRule_1.createRule)({
                     suggest: [
                         {
                             messageId: 'noDynamicImport',
+                            data: { importPath },
                             fix(fixer) {
                                 const replacement = buildReplacement({
                                     allowSideEffectFix: true,
@@ -127,4 +127,5 @@ exports.enforceFirebaseImports = (0, createRule_1.createRule)({
         };
     },
 });
+exports.default = enforceFirebaseImports;
 //# sourceMappingURL=enforce-dynamic-firebase-imports.js.map

package/lib/rules/enforce-f-extension-for-entry-points.d.ts

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type EnforceFExtensionOptions = [
+    {
+        entryPoints?: string[];
+    }
+];
+export declare const enforceFExtensionForEntryPoints: TSESLint.RuleModule<"requireFExtension", EnforceFExtensionOptions, TSESLint.RuleListener>;
+export {};