@blumintinc/eslint-plugin-blumint 1.1.9 → 1.2.1

package/README.md

@@ -59,12 +59,14 @@ Or use the recommended config:
 | Name                                                                                     | Description                                                                                                                                     | 💼 | ⚠️ | 🔧 |
 | :--------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- |
 | [array-methods-this-context](docs/rules/array-methods-this-context.md)                   | Prevent misuse of Array methods in OOP                                                                                                          |    | ✅  |    |
+| [avoid-utils-directory](docs/rules/avoid-utils-directory.md)                             | Enforce using util/ instead of utils/ directory                                                                                                 | ✅  |    | 🔧 |
 | [class-methods-read-top-to-bottom](docs/rules/class-methods-read-top-to-bottom.md)       | Ensures classes read linearly from top to bottom.                                                                                               |    | ✅  | 🔧 |
 | [consistent-callback-naming](docs/rules/consistent-callback-naming.md)                   | Enforce consistent naming conventions for callback props and functions                                                                          | ✅  |    | 🔧 |
 | [dynamic-https-errors](docs/rules/dynamic-https-errors.md)                               | Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id. |    | ✅  |    |
 | [enforce-callable-types](docs/rules/enforce-callable-types.md)                           | Enforce Params and Response type exports in callable functions                                                                                  | ✅  |    |    |
 | [enforce-callback-memo](docs/rules/enforce-callback-memo.md)                             | Enforce useCallback or useMemo for inline functions in JSX props                                                                                | ✅  |    |    |
 | [enforce-dynamic-firebase-imports](docs/rules/enforce-dynamic-firebase-imports.md)       | Enforce dynamic importing for modules within the firebaseCloud directory                                                                        | ✅  |    |    |
+| [enforce-firestore-path-utils](docs/rules/enforce-firestore-path-utils.md)               | Enforce usage of utility functions for Firestore paths                                                                                          | ✅  |    |    |
 | [enforce-identifiable-firestore-type](docs/rules/enforce-identifiable-firestore-type.md) | Enforce that Firestore type definitions extend Identifiable and match their folder name                                                         | ✅  |    |    |
 | [enforce-safe-stringify](docs/rules/enforce-safe-stringify.md)                           | Enforce using safe-stable-stringify instead of JSON.stringify                                                                                   | ✅  |    | 🔧 |
 | [export-if-in-doubt](docs/rules/export-if-in-doubt.md)                                   | All top-level const definitions, type definitions, and functions should be exported                                                             |    |    |    |
@@ -74,6 +76,7 @@ Or use the recommended config:
 | [no-async-array-filter](docs/rules/no-async-array-filter.md)                             | Disallow async callbacks for Array.filter                                                                                                       | ✅  |    |    |
 | [no-async-foreach](docs/rules/no-async-foreach.md)                                       | Disallow Array.forEach with an async callback function                                                                                          | ✅  |    |    |
 | [no-conditional-literals-in-jsx](docs/rules/no-conditional-literals-in-jsx.md)           | Disallow use of conditional literals in JSX code                                                                                                | ✅  |    |    |
+| [no-entire-object-hook-deps](docs/rules/no-entire-object-hook-deps.md)                   | Avoid using entire objects in React hook dependency arrays when only specific fields are used                                                   | ✅  |    | 🔧 |
 | [no-filter-without-return](docs/rules/no-filter-without-return.md)                       | Disallow Array.filter callbacks without an explicit return (if part of a block statement)                                                       | ✅  |    |    |
 | [no-jsx-whitespace-literal](docs/rules/no-jsx-whitespace-literal.md)                     | Disallow the use of {" "} elements in JSX code                                                                                                  | ✅  |    |    |
 | [no-misused-switch-case](docs/rules/no-misused-switch-case.md)                           | Prevent misuse of logical OR in switch case statements                                                                                          | ✅  |    |    |

package/lib/index.js

@@ -36,10 +36,12 @@ const enforce_safe_stringify_1 = require("./rules/enforce-safe-stringify");
 const avoid_utils_directory_1 = require("./rules/avoid-utils-directory");
 const no_entire_object_hook_deps_1 = require("./rules/no-entire-object-hook-deps");
 const enforce_firestore_path_utils_1 = require("./rules/enforce-firestore-path-utils");
+const no_compositing_layer_props_1 = require("./rules/no-compositing-layer-props");
+const enforce_firestore_doc_ref_generic_1 = require("./rules/enforce-firestore-doc-ref-generic");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.1.9',
+        version: '1.2.1',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -81,6 +83,8 @@ module.exports = {
                 '@blumintinc/blumint/require-usememo-object-literals': 'error',
                 '@blumintinc/blumint/enforce-safe-stringify': 'error',
                 '@blumintinc/blumint/no-entire-object-hook-deps': 'error',
+                '@blumintinc/blumint/no-compositing-layer-props': 'warn',
+                '@blumintinc/blumint/enforce-firestore-doc-ref-generic': 'error',
             },
         },
     },
@@ -118,6 +122,8 @@ module.exports = {
         'avoid-utils-directory': avoid_utils_directory_1.avoidUtilsDirectory,
         'no-entire-object-hook-deps': no_entire_object_hook_deps_1.noEntireObjectHookDeps,
         'enforce-firestore-path-utils': enforce_firestore_path_utils_1.enforceFirestorePathUtils,
+        'no-compositing-layer-props': no_compositing_layer_props_1.noCompositingLayerProps,
+        'enforce-firestore-doc-ref-generic': enforce_firestore_doc_ref_generic_1.enforceFirestoreDocRefGeneric,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/dynamic-https-errors.js

@@ -20,7 +20,7 @@ exports.dynamicHttpsErrors = (0, createRule_1.createRule)({
         type: 'suggestion',
         docs: {
             description: 'Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id.',
-            recommended: 'warn',
+            recommended: 'error',
         },
         schema: [],
         messages: {

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

@@ -40,6 +40,19 @@ exports.default = (0, createRule_1.createRule)({
             }
             return false;
         }
+        function hasJSXWithFunction(node) {
+            if (node.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement) {
+                return node.openingElement.attributes.some((attr) => {
+                    if (attr.type === utils_1.TSESTree.AST_NODE_TYPES.JSXAttribute && attr.value) {
+                        if (attr.value.type === utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
+                            return containsFunction(attr.value.expression);
+                        }
+                    }
+                    return false;
+                });
+            }
+            return false;
+        }
         function checkJSXAttribute(node) {
             if (!node.value ||
                 node.value.type !== utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
@@ -61,10 +74,15 @@ exports.default = (0, createRule_1.createRule)({
                 });
                 return;
             }
-            // Check for objects/arrays containing functions
+            // Check for objects/arrays/JSX elements containing functions
             if ((expression.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression ||
-                expression.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayExpression) &&
-                containsFunction(expression)) {
+                expression.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayExpression ||
+                expression.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement) &&
+                (containsFunction(expression) || hasJSXWithFunction(expression))) {
+                // Skip reporting if this is a JSX element and we already reported an inline function
+                if (expression.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement && hasJSXWithFunction(expression)) {
+                    return;
+                }
                 context.report({
                     node,
                     messageId: 'enforceMemo',

package/lib/rules/enforce-exported-function-types.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'missingExportedType' | 'missingExportedReturnType' | 'missingExportedPropsType';
+export declare const enforceExportedFunctionTypes: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-exported-function-types.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceExportedFunctionTypes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
+    name: 'enforce-exported-function-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce exporting types for function props and return values',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            missingExportedType: 'Type {{typeName}} should be exported since it is used in an exported function',
+            missingExportedReturnType: 'Return type {{typeName}} should be exported since it is used in an exported function',
+            missingExportedPropsType: 'Props type {{typeName}} should be exported since it is used in an exported React component',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const reportedTypes = new Set();
+        function isExported(node) {
+            if (!node)
+                return false;
+            if (node.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+                node.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
+                return true;
+            }
+            const parent = node.parent;
+            if (!parent)
+                return false;
+            if (parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+                parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration ||
+                parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && isExported(parent.parent)) {
+                return true;
+            }
+            return false;
+        }
+        function getTypeName(node) {
+            if (!node)
+                return undefined;
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.TSTypeReference:
+                    if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        return node.typeName.name;
+                    }
+                    break;
+                case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+                    return 'AnonymousType';
+            }
+            return undefined;
+        }
+        function isTypeExported(typeName) {
+            const sourceCode = context.getSourceCode();
+            const program = sourceCode.ast;
+            // Check for exported type declarations
+            const exportedTypes = program.body.filter(node => {
+                if (node.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                    if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                        return node.declaration.id.name === typeName;
+                    }
+                    if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                        return node.declaration.id.name === typeName;
+                    }
+                }
+                return false;
+            });
+            if (exportedTypes.length > 0) {
+                return true;
+            }
+            // Check for type aliases in the current scope
+            const scope = context.getScope();
+            const variable = scope.variables.find(v => v.name === typeName);
+            if (!variable)
+                return false;
+            const def = variable.defs[0];
+            if (!def)
+                return false;
+            // Check if the type is directly exported
+            if (isExported(def.node))
+                return true;
+            // Check if the type is part of an export declaration
+            const parent = def.node.parent;
+            if (!parent)
+                return false;
+            // Handle type aliases in export declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                return true;
+            }
+            // Handle type aliases in variable declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                if (parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                    return true;
+                }
+            }
+            // Handle type aliases in interface declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                if (parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (!isExported(node))
+                    return;
+                // Skip React components
+                if (node.id?.name && /^[A-Z]/.test(node.id.name))
+                    return;
+                // Check return type
+                if (node.returnType?.typeAnnotation) {
+                    const typeName = getTypeName(node.returnType.typeAnnotation);
+                    if (typeName && !isTypeExported(typeName)) {
+                        // Check if we've already reported this type
+                        const key = `${typeName}-${node.loc?.start.line}-${node.loc?.start.column}`;
+                        if (!reportedTypes.has(key)) {
+                            reportedTypes.add(key);
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'missingExportedReturnType',
+                                data: { typeName },
+                            });
+                        }
+                    }
+                }
+                // Check parameter types
+                node.params.forEach(param => {
+                    if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+                        const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                        if (typeName && !isTypeExported(typeName)) {
+                            // Check if we've already reported this type
+                            const key = `${typeName}-${param.loc?.start.line}-${param.loc?.start.column}`;
+                            if (!reportedTypes.has(key)) {
+                                reportedTypes.add(key);
+                                context.report({
+                                    node: param.typeAnnotation,
+                                    messageId: 'missingExportedType',
+                                    data: { typeName },
+                                });
+                            }
+                        }
+                    }
+                });
+            },
+            'VariableDeclarator > ArrowFunctionExpression'(node) {
+                if (!node.parent?.parent || !isExported(node.parent.parent))
+                    return;
+                // Skip React components
+                if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    /^[A-Z]/.test(node.parent.id.name))
+                    return;
+                // Check return type
+                if (node.returnType?.typeAnnotation) {
+                    const typeName = getTypeName(node.returnType.typeAnnotation);
+                    if (typeName && !isTypeExported(typeName)) {
+                        // Check if we've already reported this type
+                        const key = `${typeName}-${node.loc?.start.line}-${node.loc?.start.column}`;
+                        if (!reportedTypes.has(key)) {
+                            reportedTypes.add(key);
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'missingExportedReturnType',
+                                data: { typeName },
+                            });
+                        }
+                    }
+                }
+                // Check parameter types
+                node.params.forEach(param => {
+                    if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+                        const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                        if (typeName && !isTypeExported(typeName)) {
+                            // Check if we've already reported this type
+                            const key = `${typeName}-${param.loc?.start.line}-${param.loc?.start.column}`;
+                            if (!reportedTypes.has(key)) {
+                                reportedTypes.add(key);
+                                context.report({
+                                    node: param.typeAnnotation,
+                                    messageId: 'missingExportedType',
+                                    data: { typeName },
+                                });
+                            }
+                        }
+                    }
+                });
+            },
+            // Handle React components
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation]'(node) {
+                if (!isExported(node.parent))
+                    return;
+                // Check props parameter
+                if (node.typeAnnotation) {
+                    const typeName = getTypeName(node.typeAnnotation.typeAnnotation);
+                    if (typeName && !isTypeExported(typeName)) {
+                        // Check if we've already reported this type
+                        const key = `${typeName}-${node.loc?.start.line}-${node.loc?.start.column}`;
+                        if (!reportedTypes.has(key)) {
+                            reportedTypes.add(key);
+                            context.report({
+                                node: node.typeAnnotation,
+                                messageId: 'missingExportedType',
+                                data: { typeName },
+                            });
+                            return;
+                        }
+                    }
+                }
+            },
+            // Skip type checking for React components since we handle them separately
+            'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation > TSTypeReference'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > TSTypeAnnotation'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > TSTypeAnnotation > TSTypeReference'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+        };
+    },
+});
+//# sourceMappingURL=enforce-exported-function-types.js.map

package/lib/rules/enforce-firestore-doc-ref-generic.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Enforce generic argument for Firestore DocumentReference
+ * @author BluMint
+ */
+type MessageIds = 'missingGeneric' | 'invalidGeneric';
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export declare const enforceFirestoreDocRefGeneric: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * @fileoverview Enforce generic argument for Firestore DocumentReference
+ * @author BluMint
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceFirestoreDocRefGeneric = void 0;
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
+    name: 'enforce-firestore-doc-ref-generic',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce generic argument for Firestore DocumentReference',
+            recommended: 'error',
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            missingGeneric: 'DocumentReference must specify a generic type argument',
+            invalidGeneric: 'DocumentReference must not use "any" or "{}" as generic type argument',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const typeCache = new Map();
+        function hasInvalidType(node) {
+            if (!node)
+                return false;
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+                    return true;
+                case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+                    if (!node.members || node.members.length === 0) {
+                        return true;
+                    }
+                    return node.members.some((member) => {
+                        if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                            member.typeAnnotation) {
+                            return hasInvalidType(member.typeAnnotation.typeAnnotation);
+                        }
+                        return false;
+                    });
+                case utils_1.AST_NODE_TYPES.TSTypeReference:
+                    if (node.typeParameters) {
+                        return node.typeParameters.params.some(hasInvalidType);
+                    }
+                    if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const typeName = node.typeName.name;
+                        if (typeCache.has(typeName)) {
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                            return typeCache.get(typeName);
+                        }
+                        // Prevent infinite recursion
+                        typeCache.set(typeName, false);
+                        const program = context.getSourceCode().ast;
+                        const interfaceDecl = program.body.find((n) => n.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration &&
+                            n.id.name === typeName);
+                        if (interfaceDecl) {
+                            const result = interfaceDecl.body.body.some((member) => {
+                                if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                                    member.typeAnnotation) {
+                                    return hasInvalidType(member.typeAnnotation.typeAnnotation);
+                                }
+                                return false;
+                            });
+                            typeCache.set(typeName, result);
+                            return result;
+                        }
+                    }
+                    return false;
+                case utils_1.AST_NODE_TYPES.TSIntersectionType:
+                case utils_1.AST_NODE_TYPES.TSUnionType:
+                    return node.types.some(hasInvalidType);
+                case utils_1.AST_NODE_TYPES.TSTypeOperator:
+                    if ('typeAnnotation' in node) {
+                        return hasInvalidType(node.typeAnnotation);
+                    }
+                    return false;
+                case utils_1.AST_NODE_TYPES.TSMappedType:
+                    if ('typeAnnotation' in node) {
+                        return hasInvalidType(node.typeAnnotation);
+                    }
+                    return false;
+                case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+                    return (hasInvalidType(node.objectType) || hasInvalidType(node.indexType));
+                case utils_1.AST_NODE_TYPES.TSConditionalType:
+                    return (hasInvalidType(node.checkType) ||
+                        hasInvalidType(node.extendsType) ||
+                        hasInvalidType(node.trueType) ||
+                        hasInvalidType(node.falseType));
+                case utils_1.AST_NODE_TYPES.TSArrayType:
+                    return hasInvalidType(node.elementType);
+                case utils_1.AST_NODE_TYPES.TSTupleType:
+                    return node.elementTypes.some(hasInvalidType);
+                case utils_1.AST_NODE_TYPES.TSTypeQuery:
+                    return false;
+                default:
+                    return false;
+            }
+        }
+        return {
+            TSTypeReference(node) {
+                if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.typeName.name === 'DocumentReference') {
+                    // Check if generic type argument is missing
+                    if (!node.typeParameters || node.typeParameters.params.length === 0) {
+                        context.report({
+                            node,
+                            messageId: 'missingGeneric',
+                        });
+                        return;
+                    }
+                    // Check for invalid generic type arguments (any or {}) recursively
+                    const typeArg = node.typeParameters.params[0];
+                    if (hasInvalidType(typeArg)) {
+                        context.report({
+                            node,
+                            messageId: 'invalidGeneric',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-firestore-doc-ref-generic.js.map

package/lib/rules/enforce-memoize-async.d.ts

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

package/lib/rules/enforce-memoize-async.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceMemoizeAsync = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
+    name: 'enforce-memoize-async',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize()',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        let hasMemoizeImport = false;
+        let memoizeAlias = 'Memoize';
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'typescript-memoize') {
+                    const memoizeSpecifier = node.specifiers.find(spec => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        spec.imported.name === 'Memoize');
+                    if (memoizeSpecifier) {
+                        hasMemoizeImport = true;
+                        if (memoizeSpecifier.local) {
+                            memoizeAlias = memoizeSpecifier.local.name;
+                        }
+                    }
+                }
+            },
+            MethodDefinition(node) {
+                // Only process async methods
+                if (node.value.type !== utils_1.AST_NODE_TYPES.FunctionExpression || !node.value.async) {
+                    return;
+                }
+                // Skip methods with more than one parameter
+                if (node.value.params.length > 1) {
+                    return;
+                }
+                // Check if method already has @Memoize decorator
+                const hasDecorator = node.decorators?.some(decorator => {
+                    if (decorator.expression.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                        return false;
+                    }
+                    const callee = decorator.expression.callee;
+                    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        callee.name === memoizeAlias);
+                });
+                if (!hasDecorator && hasMemoizeImport) {
+                    context.report({
+                        node,
+                        messageId: 'requireMemoize',
+                        fix(fixer) {
+                            // Add import if needed
+                            // Add decorator
+                            return fixer.insertTextBefore(node, `@${memoizeAlias}()\n${' '.repeat(node.loc.start.column)}`);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-memoize-async.js.map

package/lib/rules/export-if-in-doubt.js

@@ -9,7 +9,7 @@ exports.exportIfInDoubt = (0, createRule_1.createRule)({
         type: 'suggestion',
         docs: {
             description: 'All top-level const definitions, type definitions, and functions should be exported',
-            recommended: 'warn',
+            recommended: 'error',
         },
         schema: [],
         messages: {

package/lib/rules/global-const-style.d.ts

@@ -1,5 +1,3 @@
-import { TSESTree } from '@typescript-eslint/utils';
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"upperSnakeCase" | "asConst", never[], {
-    VariableDeclaration(node: TSESTree.VariableDeclaration): void;
-}>;
+type MessageIds = 'upperSnakeCase' | 'asConst';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;