@blumintinc/eslint-plugin-blumint 1.0.5 → 1.1.1

package/README.md

@@ -64,6 +64,7 @@ Or use the recommended config:
 | [export-if-in-doubt](docs/rules/export-if-in-doubt.md)                             | All top-level const definitions, type definitions, and functions should be exported                                                             |    |    |    |
 | [extract-global-constants](docs/rules/extract-global-constants.md)                 | Extract constants/functions to the global scope when possible                                                                                   |    |    |    |
 | [generic-starts-with-t](docs/rules/generic-starts-with-t.md)                       | Enforce TypeScript generic types to start with T                                                                                                |    | ✅  |    |
+| [global-const-style](docs/rules/global-const-style.md)                             | Enforce UPPER_SNAKE_CASE and as const for global static constants                                                                                | ✅  |    | 🔧 |
 | [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                                                                                                | ✅  |    |    |

package/lib/index.js

@@ -1,25 +1,41 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const array_methods_this_context_1 = require("./rules/array-methods-this-context");
 const class_methods_read_top_to_bottom_1 = require("./rules/class-methods-read-top-to-bottom");
+const consistent_callback_naming_1 = __importDefault(require("./rules/consistent-callback-naming"));
 const dynamic_https_errors_1 = require("./rules/dynamic-https-errors");
+const enforce_identifiable_firestore_type_1 = require("./rules/enforce-identifiable-firestore-type");
+const enforce_callback_memo_1 = __importDefault(require("./rules/enforce-callback-memo"));
+const enforce_callable_types_1 = require("./rules/enforce-callable-types");
+const enforce_dynamic_firebase_imports_1 = require("./rules/enforce-dynamic-firebase-imports");
 const export_if_in_doubt_1 = require("./rules/export-if-in-doubt");
 const extract_global_constants_1 = require("./rules/extract-global-constants");
 const generic_starts_with_t_1 = require("./rules/generic-starts-with-t");
+const global_const_style_1 = __importDefault(require("./rules/global-const-style"));
 const no_async_array_filter_1 = require("./rules/no-async-array-filter");
 const no_async_foreach_1 = require("./rules/no-async-foreach");
 const no_conditional_literals_in_jsx_1 = require("./rules/no-conditional-literals-in-jsx");
 const no_filter_without_return_1 = require("./rules/no-filter-without-return");
 const no_misused_switch_case_1 = require("./rules/no-misused-switch-case");
 const no_unpinned_dependencies_1 = require("./rules/no-unpinned-dependencies");
+const no_unused_props_1 = require("./rules/no-unused-props");
 const no_useless_fragment_1 = require("./rules/no-useless-fragment");
 const prefer_fragment_shorthand_1 = require("./rules/prefer-fragment-shorthand");
 const prefer_type_over_interface_1 = require("./rules/prefer-type-over-interface");
 const require_memo_1 = require("./rules/require-memo");
+const no_jsx_whitespace_literal_1 = require("./rules/no-jsx-whitespace-literal");
+const require_dynamic_firebase_imports_1 = __importDefault(require("./rules/require-dynamic-firebase-imports"));
+const require_https_error_1 = __importDefault(require("./rules/require-https-error"));
+const use_custom_router_1 = require("./rules/use-custom-router");
+const require_image_overlayed_1 = __importDefault(require("./rules/require-image-overlayed"));
+const require_usememo_object_literals_1 = require("./rules/require-usememo-object-literals");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.0.5',
+        version: '1.1.1',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -28,42 +44,68 @@ module.exports = {
         recommended: {
             plugins: ['@blumintinc/blumint'],
             rules: {
+                '@blumintinc/blumint/no-jsx-whitespace-literal': 'error',
                 '@blumintinc/blumint/array-methods-this-context': 'warn',
                 '@blumintinc/blumint/class-methods-read-top-to-bottom': 'warn',
+                '@blumintinc/blumint/consistent-callback-naming': 'error',
                 '@blumintinc/blumint/dynamic-https-errors': 'warn',
+                '@blumintinc/blumint/enforce-identifiable-firestore-type': 'error',
+                '@blumintinc/blumint/enforce-callback-memo': 'error',
+                '@blumintinc/blumint/enforce-callable-types': 'error',
+                '@blumintinc/blumint/enforce-dynamic-firebase-imports': 'error',
                 // '@blumintinc/blumint/export-if-in-doubt': 'warn',
-                // '@blumintinc/blumint/extract-global-constants': 'warn',
+                '@blumintinc/blumint/extract-global-constants': 'warn',
                 '@blumintinc/blumint/generic-starts-with-t': 'warn',
+                '@blumintinc/blumint/global-const-style': 'error',
                 '@blumintinc/blumint/no-async-array-filter': 'error',
                 '@blumintinc/blumint/no-async-foreach': 'error',
                 '@blumintinc/blumint/no-conditional-literals-in-jsx': 'error',
                 '@blumintinc/blumint/no-filter-without-return': 'error',
                 '@blumintinc/blumint/no-misused-switch-case': 'error',
                 '@blumintinc/blumint/no-unpinned-dependencies': 'error',
+                '@blumintinc/blumint/no-unused-props': 'error',
                 '@blumintinc/blumint/no-useless-fragment': 'warn',
                 '@blumintinc/blumint/prefer-fragment-shorthand': 'warn',
                 '@blumintinc/blumint/prefer-type-over-interface': 'warn',
                 '@blumintinc/blumint/require-memo': 'error',
+                '@blumintinc/blumint/require-dynamic-firebase-imports': 'error',
+                '@blumintinc/blumint/require-https-error': 'error',
+                '@blumintinc/blumint/use-custom-router': 'error',
+                '@blumintinc/blumint/require-image-overlayed': 'error',
+                '@blumintinc/blumint/require-usememo-object-literals': 'error',
             },
         },
     },
     rules: {
         'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
         'class-methods-read-top-to-bottom': class_methods_read_top_to_bottom_1.classMethodsReadTopToBottom,
+        'consistent-callback-naming': consistent_callback_naming_1.default,
         'dynamic-https-errors': dynamic_https_errors_1.dynamicHttpsErrors,
+        'enforce-identifiable-firestore-type': enforce_identifiable_firestore_type_1.enforceIdentifiableFirestoreType,
+        'enforce-callback-memo': enforce_callback_memo_1.default,
+        'enforce-callable-types': enforce_callable_types_1.enforceCallableTypes,
+        'enforce-dynamic-firebase-imports': enforce_dynamic_firebase_imports_1.enforceFirebaseImports,
         'export-if-in-doubt': export_if_in_doubt_1.exportIfInDoubt,
         'extract-global-constants': extract_global_constants_1.extractGlobalConstants,
         'generic-starts-with-t': generic_starts_with_t_1.genericStartsWithT,
+        'global-const-style': global_const_style_1.default,
         'no-async-array-filter': no_async_array_filter_1.noAsyncArrayFilter,
         'no-async-foreach': no_async_foreach_1.noAsyncForEach,
         'no-conditional-literals-in-jsx': no_conditional_literals_in_jsx_1.noConditionalLiteralsInJsx,
         'no-filter-without-return': no_filter_without_return_1.noFilterWithoutReturn,
         'no-misused-switch-case': no_misused_switch_case_1.noMisusedSwitchCase,
         'no-unpinned-dependencies': no_unpinned_dependencies_1.noUnpinnedDependencies,
+        'no-unused-props': no_unused_props_1.noUnusedProps,
         'no-useless-fragment': no_useless_fragment_1.noUselessFragment,
         'prefer-fragment-shorthand': prefer_fragment_shorthand_1.preferFragmentShorthand,
         'prefer-type-over-interface': prefer_type_over_interface_1.preferTypeOverInterface,
         'require-memo': require_memo_1.requireMemo,
+        'no-jsx-whitespace-literal': no_jsx_whitespace_literal_1.noJsxWhitespaceLiteral,
+        'require-dynamic-firebase-imports': require_dynamic_firebase_imports_1.default,
+        'require-https-error': require_https_error_1.default,
+        'use-custom-router': use_custom_router_1.useCustomRouter,
+        'require-image-overlayed': require_image_overlayed_1.default,
+        'require-usememo-object-literals': require_usememo_object_literals_1.requireUseMemoObjectLiterals,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/consistent-callback-naming.d.ts

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

package/lib/rules/consistent-callback-naming.js

@@ -0,0 +1,93 @@
+"use strict";
+const createRule_1 = require("../utils/createRule");
+module.exports = (0, createRule_1.createRule)({
+    name: 'consistent-callback-naming',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent naming conventions for callback props and functions',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            callbackPropPrefix: 'Callback props (function type props) must be prefixed with "on" (e.g., onClick, onChange)',
+            callbackFunctionPrefix: 'Callback functions should not use "handle" prefix, use descriptive verb phrases instead',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = context.parserServices;
+        // Check if we have access to TypeScript services
+        if (!parserServices?.program || !parserServices?.esTreeNodeToTSNodeMap) {
+            throw new Error('You have to enable the `project` setting in parser options to use this rule');
+        }
+        const checker = parserServices.program.getTypeChecker();
+        function isFunctionType(node) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return type.getCallSignatures().length > 0;
+        }
+        return {
+            // Check JSX attributes for callback props
+            JSXAttribute(node) {
+                if (node.value?.type === 'JSXExpressionContainer' &&
+                    node.value.expression.type === 'Identifier') {
+                    const propName = node.name.type === 'JSXIdentifier' ? node.name.name : undefined;
+                    // Skip React's built-in event handlers
+                    if (propName?.match(/^on[A-Z]/)) {
+                        return;
+                    }
+                    // Check if the value is a function type
+                    if (isFunctionType(node.value.expression) &&
+                        propName &&
+                        !propName.startsWith('on')) {
+                        context.report({
+                            node,
+                            messageId: 'callbackPropPrefix',
+                            fix(fixer) {
+                                // Convert camelCase to PascalCase for the event name
+                                const eventName = propName.charAt(0).toUpperCase() + propName.slice(1);
+                                return fixer.replaceText(node.name, `on${eventName}`);
+                            },
+                        });
+                    }
+                }
+            },
+            // Check function declarations and variable declarations for callback functions
+            'FunctionDeclaration, VariableDeclarator'(node) {
+                const functionName = node.id?.type === 'Identifier' ? node.id.name : undefined;
+                if (functionName && functionName.startsWith('handle') && node.id) {
+                    context.report({
+                        node,
+                        messageId: 'callbackFunctionPrefix',
+                        fix(fixer) {
+                            // Remove 'handle' prefix and convert first character to lowercase
+                            const newName = functionName.slice(6).charAt(0).toLowerCase() +
+                                functionName.slice(7);
+                            return fixer.replaceText(node.id, newName);
+                        },
+                    });
+                }
+            },
+            // Check class methods and object methods
+            'MethodDefinition, Property'(node) {
+                if (node.key.type === 'Identifier' &&
+                    node.key.name &&
+                    node.key.name.startsWith('handle')) {
+                    const name = node.key.name;
+                    context.report({
+                        node: node.key,
+                        messageId: 'callbackFunctionPrefix',
+                        fix(fixer) {
+                            // Remove 'handle' prefix and convert first character to lowercase
+                            const newName = name.slice(6).charAt(0).toLowerCase() + name.slice(7);
+                            return fixer.replaceText(node.key, newName);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=consistent-callback-naming.js.map

package/lib/rules/enforce-callable-types.d.ts

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

package/lib/rules/enforce-callable-types.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceCallableTypes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceCallableTypes = (0, createRule_1.createRule)({
+    name: 'enforce-callable-types',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce Params and Response type exports in callable functions',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            missingParamsType: 'Missing Params type export in callable function file',
+            missingResponseType: 'Missing Response type export in callable function file',
+            unusedParamsType: 'Params type is exported but not used in the callable function',
+            unusedResponseType: 'Response type is exported but not used in the callable function',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename();
+        // Only apply to .f.ts files in the callable directory
+        if (!filename.endsWith('.f.ts') || !filename.includes('/callable/')) {
+            return {};
+        }
+        let hasParamsExport = false;
+        let hasResponseExport = false;
+        let hasCallableFunction = false;
+        let paramsTypeUsed = false;
+        let responseTypeUsed = false;
+        return {
+            // Check for type exports
+            ExportNamedDeclaration(node) {
+                if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                    const typeName = node.declaration.id.name;
+                    if (typeName === 'Params') {
+                        hasParamsExport = true;
+                    }
+                    else if (typeName === 'Response') {
+                        hasResponseExport = true;
+                    }
+                }
+            },
+            // Check for onCall usage
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'onCall') {
+                    hasCallableFunction = true;
+                }
+            },
+            // Check for type usage in function parameters and return types
+            TSTypeReference(node) {
+                if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (node.typeName.name === 'Params') {
+                        paramsTypeUsed = true;
+                    }
+                    else if (node.typeName.name === 'Response') {
+                        responseTypeUsed = true;
+                    }
+                }
+            },
+            'Program:exit'() {
+                if (!hasCallableFunction) {
+                    return;
+                }
+                if (!hasParamsExport) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'missingParamsType',
+                    });
+                }
+                else if (!paramsTypeUsed) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'unusedParamsType',
+                    });
+                }
+                if (!hasResponseExport) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'missingResponseType',
+                    });
+                }
+                else if (!responseTypeUsed) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'unusedResponseType',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-callable-types.js.map

package/lib/rules/enforce-callback-memo.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'enforceCallback' | 'enforceMemo';
+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;

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.default = (0, createRule_1.createRule)({
+    name: 'enforce-callback-memo',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce useCallback or useMemo for inline functions in JSX props',
+            recommended: 'error',
+        },
+        messages: {
+            enforceCallback: 'Inline functions in JSX props should be wrapped with useCallback',
+            enforceMemo: 'Objects/arrays containing functions in JSX props should be wrapped with useMemo',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        function isFunction(node) {
+            return (node.type === utils_1.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === utils_1.TSESTree.AST_NODE_TYPES.FunctionExpression);
+        }
+        function containsFunction(node) {
+            if (isFunction(node)) {
+                return true;
+            }
+            if (node.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression) {
+                return node.properties.some((prop) => {
+                    if (prop.type === utils_1.TSESTree.AST_NODE_TYPES.Property &&
+                        'value' in prop) {
+                        return containsFunction(prop.value);
+                    }
+                    return false;
+                });
+            }
+            if (node.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayExpression) {
+                return node.elements.some((element) => element && containsFunction(element));
+            }
+            return false;
+        }
+        function checkJSXAttribute(node) {
+            if (!node.value ||
+                node.value.type !== utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
+                return;
+            }
+            const { expression } = node.value;
+            // Skip if the prop is already wrapped in useCallback or useMemo
+            if (expression.type === utils_1.TSESTree.AST_NODE_TYPES.CallExpression &&
+                expression.callee.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
+                (expression.callee.name === 'useCallback' ||
+                    expression.callee.name === 'useMemo')) {
+                return;
+            }
+            // Check for direct inline functions
+            if (isFunction(expression)) {
+                context.report({
+                    node,
+                    messageId: 'enforceCallback',
+                });
+                return;
+            }
+            // Check for objects/arrays containing functions
+            if ((expression.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression ||
+                expression.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayExpression) &&
+                containsFunction(expression)) {
+                context.report({
+                    node,
+                    messageId: 'enforceMemo',
+                });
+            }
+        }
+        return {
+            JSXAttribute: checkJSXAttribute,
+        };
+    },
+});
+//# sourceMappingURL=enforce-callback-memo.js.map

package/lib/rules/enforce-dynamic-firebase-imports.d.ts

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

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceFirebaseImports = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.enforceFirebaseImports = (0, createRule_1.createRule)({
+    name: 'enforce-dynamic-firebase-imports',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce dynamic importing for modules within the firebaseCloud directory',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noDynamicImport: 'Static imports from firebaseCloud directory are not allowed. Use dynamic imports instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                // Skip type-only imports
+                if (node.importKind === 'type') {
+                    return;
+                }
+                const importPath = node.source.value;
+                // Check if the import is from firebaseCloud directory
+                if (importPath.includes('firebaseCloud/')) {
+                    context.report({
+                        node,
+                        messageId: 'noDynamicImport',
+                        fix(fixer) {
+                            const importSpecifiers = node.specifiers
+                                .filter((spec) => spec.type === 'ImportSpecifier')
+                                .map((spec) => spec.imported.name);
+                            if (importSpecifiers.length === 0) {
+                                return null;
+                            }
+                            const destructuredImports = `{ ${importSpecifiers.join(', ')} }`;
+                            const dynamicImport = `const ${destructuredImports} = await import('${importPath}');`;
+                            return fixer.replaceText(node, dynamicImport);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-dynamic-firebase-imports.js.map

package/lib/rules/enforce-identifiable-firestore-type.d.ts

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

package/lib/rules/enforce-identifiable-firestore-type.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceIdentifiableFirestoreType = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const path_1 = __importDefault(require("path"));
+exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
+    name: 'enforce-identifiable-firestore-type',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that Firestore type definitions extend Identifiable and match their folder name',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            missingType: 'Expected exported type "{{ typeName }}" in index.ts under folder "{{ folderName }}"',
+            notExtendingIdentifiable: 'Type "{{ typeName }}" must extend "Identifiable", including an "id: string" field',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename();
+        const firestoreTypesPattern = /functions\/src\/types\/firestore\/.*\/index\.ts$/;
+        // Only apply rule to index.ts files in the firestore types directory
+        if (!firestoreTypesPattern.test(filename)) {
+            return {};
+        }
+        // Get the expected type name from the parent folder
+        const folderName = path_1.default.basename(path_1.default.dirname(filename));
+        let hasExpectedType = false;
+        let typeHasIdentifiable = false;
+        return {
+            Program() {
+                // Reset flags for each file
+                hasExpectedType = false;
+                typeHasIdentifiable = false;
+            },
+            'Program:exit'(node) {
+                if (!hasExpectedType) {
+                    context.report({
+                        node,
+                        messageId: 'missingType',
+                        data: {
+                            typeName: folderName,
+                            folderName,
+                        },
+                    });
+                }
+                else if (!typeHasIdentifiable) {
+                    context.report({
+                        node,
+                        messageId: 'notExtendingIdentifiable',
+                        data: {
+                            typeName: folderName,
+                        },
+                    });
+                }
+            },
+            TSTypeAliasDeclaration(node) {
+                if (node.id.name === folderName) {
+                    hasExpectedType = true;
+                    // Check if type extends Identifiable
+                    const checkIdentifiableExtension = (type) => {
+                        // Check for direct Identifiable extension
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            type.typeName.name === 'Identifiable') {
+                            return true;
+                        }
+                        // Check intersection types
+                        if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return type.types.some(checkIdentifiableExtension);
+                        }
+                        // Check generic type parameters
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            type.typeParameters?.params) {
+                            return type.typeParameters.params.some(checkIdentifiableExtension);
+                        }
+                        return false;
+                    };
+                    // Check if type has id: string field
+                    const checkIdField = (type) => {
+                        // Check for id: string field in type literal
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                            return type.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                                member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                member.key.name === 'id' &&
+                                member.typeAnnotation?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSStringKeyword);
+                        }
+                        // Check intersection types
+                        if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return type.types.some(checkIdField);
+                        }
+                        return false;
+                    };
+                    // Check if type is wrapped in a utility type
+                    const isUtilityType = (type) => {
+                        return (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            type.typeName.name === 'Resolve');
+                    };
+                    // Recursively check the type and its parameters
+                    const checkType = (type) => {
+                        // Check if type extends Identifiable
+                        if (checkIdentifiableExtension(type)) {
+                            return true;
+                        }
+                        // Check if type has id: string field (only for utility types)
+                        if (isUtilityType(type) && checkIdField(type.typeParameters.params[0])) {
+                            return true;
+                        }
+                        // Check if type is wrapped in a utility type
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            type.typeParameters?.params?.[0]) {
+                            return checkType(type.typeParameters.params[0]);
+                        }
+                        // For direct type definitions, require extending Identifiable
+                        return false;
+                    };
+                    typeHasIdentifiable = checkType(node.typeAnnotation);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-identifiable-firestore-type.js.map

package/lib/rules/enforce-serializable-params.d.ts

@@ -0,0 +1,9 @@
+import { TSESTree } from '@typescript-eslint/utils';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"nonSerializableParam" | "nonSerializableProperty", {
+    additionalNonSerializableTypes: never[];
+    functionTypes: string[];
+}[], {
+    TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
+    TSTypeReference(node: TSESTree.TSTypeReference): void;
+}>;
+export default _default;