@blumintinc/eslint-plugin-blumint 1.7.2 → 1.8.0

package/lib/rules/no-firestore-jest-mock.js

@@ -26,14 +26,26 @@ exports.noFirestoreJestMock = (0, createRule_1.createRule)({
         }
         return {
             ImportDeclaration(node) {
+                // Skip type imports completely
+                if (node.importKind === 'type') {
+                    return;
+                }
                 if (node.source.value === 'firestore-jest-mock') {
                     context.report({
                         node,
                         messageId: 'noFirestoreJestMock',
-                        fix(fixer) {
-                            // Replace with mockFirestore import
-                            return fixer.replaceText(node, "import { mockFirestore } from '../../../../../__mocks__/functions/src/config/mockFirestore';");
-                        },
+                        fix: (fixer) => {
+                            return fixer.replaceText(node, `import { mockFirestore } from '../../../../../__test-utils__/mockFirestore';`);
+                        }
+                    });
+                }
+            },
+            ImportExpression(node) {
+                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.source.value === 'firestore-jest-mock') {
+                    context.report({
+                        node,
+                        messageId: 'noFirestoreJestMock',
                     });
                 }
             },
@@ -52,6 +64,17 @@ exports.noFirestoreJestMock = (0, createRule_1.createRule)({
                         messageId: 'noFirestoreJestMock',
                     });
                 }
+                // Check for require('firestore-jest-mock')
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'require' &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.arguments[0].value === 'firestore-jest-mock') {
+                    context.report({
+                        node,
+                        messageId: 'noFirestoreJestMock',
+                    });
+                }
             },
         };
     },

package/lib/rules/no-mock-firebase-admin.js

@@ -4,9 +4,9 @@ exports.noMockFirebaseAdmin = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const FIREBASE_ADMIN_PATHS = [
-    '../../config/firebaseAdmin',
-    '../config/firebaseAdmin',
-    './config/firebaseAdmin',
+    'firebaseAdmin',
+    'config/firebaseAdmin',
+    'src/config/firebaseAdmin',
     'functions/src/config/firebaseAdmin',
 ];
 exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
@@ -19,11 +19,18 @@ exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            noMockFirebaseAdmin: 'Do not mock firebaseAdmin directly. Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead.',
+            noMockFirebaseAdmin: 'Do not mock firebaseAdmin directly. Use mockFirestore from __test-utils__/mockFirestore instead.',
         },
     },
     defaultOptions: [],
     create(context) {
+        // Check if the current file is a test file
+        const filename = context.getFilename();
+        const isTestFile = /\.test\.[jt]sx?$/.test(filename) || /\.spec\.[jt]sx?$/.test(filename);
+        // If it's not a test file, don't apply the rule
+        if (!isTestFile) {
+            return {};
+        }
         return {
             CallExpression(node) {
                 if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
@@ -32,10 +39,16 @@ exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
                     node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.callee.property.name === 'mock' &&
                     node.arguments.length > 0 &&
-                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.arguments[0].value === 'string') {
-                    const mockPath = node.arguments[0].value;
-                    const isFirebaseAdminMock = FIREBASE_ADMIN_PATHS.some(path => mockPath.endsWith(path) || mockPath.includes('firebaseAdmin'));
+                    (node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal ||
+                        node.arguments[0].type === utils_1.AST_NODE_TYPES.TemplateLiteral)) {
+                    let mockPath = '';
+                    if (node.arguments[0].type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                        mockPath = node.arguments[0].quasis[0].value.raw;
+                    }
+                    else if (node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal) {
+                        mockPath = String(node.arguments[0].value);
+                    }
+                    const isFirebaseAdminMock = FIREBASE_ADMIN_PATHS.some(path => mockPath.endsWith(path) && !mockPath.endsWith('Helper') && !mockPath.endsWith('utils') && !mockPath.endsWith('test') && !mockPath.endsWith('mock') && !mockPath.endsWith('jest-mock'));
                     if (isFirebaseAdminMock) {
                         context.report({
                             node,

package/lib/rules/no-type-assertion-returns.d.ts

@@ -0,0 +1,9 @@
+type MessageIds = 'noTypeAssertionReturns' | 'useExplicitVariable';
+type Options = [
+    {
+        allowAsConst?: boolean;
+        allowTypePredicates?: boolean;
+    }
+];
+export declare const noTypeAssertionReturns: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/no-type-assertion-returns.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noTypeAssertionReturns = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = {
+    allowAsConst: true,
+    allowTypePredicates: true,
+};
+/**
+ * Checks if a type assertion is 'as const'
+ */
+function isAsConstAssertion(node) {
+    const typeAnnotation = node.typeAnnotation;
+    return (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        typeAnnotation.typeName.name === 'const');
+}
+/**
+ * Checks if a node is a type predicate (using 'is' keyword)
+ */
+function isTypePredicate(node) {
+    return node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate;
+}
+exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
+    name: 'no-type-assertion-returns',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce typing variables before returning them, rather than using type assertions or explicit return types',
+            recommended: 'error',
+            requiresTypeChecking: false,
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowAsConst: { type: 'boolean' },
+                    allowTypePredicates: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noTypeAssertionReturns: 'Type assertions in return statements are not allowed. Type the variable explicitly before returning it.',
+            useExplicitVariable: 'Explicit return type annotations are not allowed. Type the variable explicitly before returning it.',
+        },
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [options]) {
+        const mergedOptions = { ...defaultOptions, ...options };
+        return {
+            // Check for return statements with type assertions
+            ReturnStatement(node) {
+                if (!node.argument)
+                    return;
+                // Check for type assertions using 'as' keyword
+                if (node.argument.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                    // Allow 'as const' assertions if configured
+                    if (mergedOptions.allowAsConst && isAsConstAssertion(node.argument)) {
+                        return;
+                    }
+                    // For nested type assertions, only report the outermost one
+                    if (node.argument.expression.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                        context.report({
+                            node: node.argument,
+                            messageId: 'noTypeAssertionReturns',
+                        });
+                        return;
+                    }
+                    context.report({
+                        node: node.argument,
+                        messageId: 'noTypeAssertionReturns',
+                    });
+                }
+                // Check for type assertions using angle bracket syntax
+                if (node.argument.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                    context.report({
+                        node: node.argument,
+                        messageId: 'noTypeAssertionReturns',
+                    });
+                }
+            },
+            // Check functions with explicit return types
+            FunctionDeclaration(node) {
+                if (!node.returnType)
+                    return;
+                // Allow type predicates if configured
+                if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                    return;
+                }
+                // If type predicates are not allowed, report them
+                if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                    context.report({
+                        node: node.returnType,
+                        messageId: 'useExplicitVariable',
+                    });
+                    return;
+                }
+                // Check if the function has a return statement with a direct value (not a variable)
+                if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    for (const statement of node.body.body) {
+                        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+                            // If returning a variable reference, that's fine
+                            if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                continue;
+                            }
+                            // If returning an object literal, array literal, or other complex expression
+                            // without first assigning it to a typed variable, that's a problem
+                            if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                                statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                                statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                                context.report({
+                                    node: node.returnType,
+                                    messageId: 'useExplicitVariable',
+                                });
+                                break;
+                            }
+                        }
+                    }
+                }
+            },
+            // Check function expressions with explicit return types
+            FunctionExpression(node) {
+                if (!node.returnType)
+                    return;
+                // Allow type predicates if configured
+                if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                    return;
+                }
+                // If type predicates are not allowed, report them
+                if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                    context.report({
+                        node: node.returnType,
+                        messageId: 'useExplicitVariable',
+                    });
+                    return;
+                }
+                // Check if the function has a return statement with a direct value (not a variable)
+                if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    for (const statement of node.body.body) {
+                        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+                            // If returning a variable reference, that's fine
+                            if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                continue;
+                            }
+                            // If returning an object literal, array literal, or other complex expression
+                            // without first assigning it to a typed variable, that's a problem
+                            if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                                statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                                statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                                context.report({
+                                    node: node.returnType,
+                                    messageId: 'useExplicitVariable',
+                                });
+                                break;
+                            }
+                        }
+                    }
+                }
+            },
+            // Check arrow functions
+            ArrowFunctionExpression(node) {
+                // For arrow functions with expression bodies (no block)
+                if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                    // Check for explicit return type
+                    if (node.returnType) {
+                        // Allow type predicates if configured
+                        if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                            return;
+                        }
+                        // If type predicates are not allowed, report them
+                        if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'useExplicitVariable',
+                            });
+                            return;
+                        }
+                        // If returning an object literal with explicit return type, report it
+                        if (node.body.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                            node.body.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'useExplicitVariable',
+                            });
+                        }
+                    }
+                    // Check for type assertions in the body
+                    if (node.body.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                        // Allow 'as const' assertions if configured
+                        if (mergedOptions.allowAsConst && isAsConstAssertion(node.body)) {
+                            return;
+                        }
+                        context.report({
+                            node: node.body,
+                            messageId: 'noTypeAssertionReturns',
+                        });
+                    }
+                    else if (node.body.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                        context.report({
+                            node: node.body,
+                            messageId: 'noTypeAssertionReturns',
+                        });
+                    }
+                }
+                else if (node.returnType) {
+                    // For arrow functions with block bodies
+                    // Allow type predicates if configured
+                    if (mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                        return;
+                    }
+                    // If type predicates are not allowed, report them
+                    if (!mergedOptions.allowTypePredicates && isTypePredicate(node.returnType)) {
+                        context.report({
+                            node: node.returnType,
+                            messageId: 'useExplicitVariable',
+                        });
+                        return;
+                    }
+                    // Check if the function has a return statement with a direct value (not a variable)
+                    if (node.body && node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        for (const statement of node.body.body) {
+                            if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+                                // If returning a variable reference, that's fine
+                                if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    continue;
+                                }
+                                // If returning an object literal, array literal, or other complex expression
+                                // without first assigning it to a typed variable, that's a problem
+                                if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                                    statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                                    statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                                    context.report({
+                                        node: node.returnType,
+                                        messageId: 'useExplicitVariable',
+                                    });
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            // Check for array methods with type assertions
+            CallExpression() {
+                // Skip this check as we'll handle it in the TSAsExpression and TSTypeAssertion handlers
+            },
+            // Check for type assertions in expressions
+            TSAsExpression(node) {
+                // Allow 'as const' assertions if configured
+                if (mergedOptions.allowAsConst && isAsConstAssertion(node)) {
+                    return;
+                }
+                // If the parent is a return statement, we already handle it in ReturnStatement
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                    return;
+                }
+                // If the parent is an arrow function, we already handle it in ArrowFunctionExpression
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    return;
+                }
+                // For standalone type assertions in expressions
+                context.report({
+                    node,
+                    messageId: 'noTypeAssertionReturns',
+                });
+            },
+            // Check for type assertions using angle bracket syntax
+            TSTypeAssertion(node) {
+                // If the parent is a return statement, we already handle it in ReturnStatement
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                    return;
+                }
+                // If the parent is an arrow function, we already handle it in ArrowFunctionExpression
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    return;
+                }
+                // For standalone type assertions in expressions
+                context.report({
+                    node,
+                    messageId: 'noTypeAssertionReturns',
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-type-assertion-returns.js.map

package/lib/rules/no-unnecessary-verb-suffix.d.ts

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

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnnecessaryVerbSuffix = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const COMMON_PREPOSITION_SUFFIXES = new Set([
+    // Basic prepositions
+    'From',
+    'For',
+    'With',
+    'To',
+    'By',
+    'In',
+    'On',
+    'At',
+    'Of',
+    // Directional prepositions
+    'Above',
+    'Below',
+    'Over',
+    'Under',
+    'Up',
+    'Down',
+    'Into',
+    'Onto',
+    'Out',
+    'Off',
+    'Through',
+    'Throughout',
+    'Across',
+    'Along',
+    'Around',
+    'Past',
+    // Temporal prepositions
+    'After',
+    'Before',
+    'During',
+    'Until',
+    'Till',
+    'Since',
+    'Within',
+    // Logical/causal prepositions
+    'Because',
+    'Despite',
+    'Instead',
+    'Via',
+    'Without',
+    'Versus',
+    'Vs',
+    // Comparative prepositions
+    'Than',
+    'Like',
+    'As',
+    // Compound prepositions
+    'According',
+    'Ahead',
+    'Apart',
+    'Aside',
+    'Away',
+    'Back',
+    'Forward',
+    'Backward',
+    'Inside',
+    'Outside',
+    'Together',
+    // Phrasal prepositions (common endings)
+    'About',
+    'Against',
+    'Among',
+    'Amongst',
+    'Beside',
+    'Besides',
+    'Between',
+    'Beyond',
+    'Concerning',
+    'Considering',
+    'Regarding',
+    'Respecting',
+    'Towards',
+    'Toward',
+    'Upon',
+    // Preposition-like adverbs
+    'Again',
+    'Already',
+    'Always',
+    'Ever',
+    'Never',
+    'Now',
+    'Soon',
+    'Then',
+    'There',
+    'Where',
+    'When',
+    'While',
+    // Programming-specific suffixes
+    'Async',
+    'Sync',
+]);
+exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
+    name: 'no-unnecessary-verb-suffix',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent unnecessary verb suffixes in function and method names',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unnecessaryVerbSuffix: 'Unnecessary verb suffix "{{suffix}}" in function name. Consider using "{{suggestion}}" instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function checkFunctionName(node, name) {
+            if (!name)
+                return;
+            for (const suffix of COMMON_PREPOSITION_SUFFIXES) {
+                // Check if the name ends with the suffix
+                if (name.endsWith(suffix)) {
+                    // Make sure there's a verb before the suffix (camelCase format)
+                    // This regex checks for a verb pattern before the suffix
+                    // It looks for a word character followed by lowercase letters before the suffix
+                    const verbBeforeSuffixPattern = new RegExp(`\\w[a-z]+${suffix}$`);
+                    if (verbBeforeSuffixPattern.test(name)) {
+                        const suggestion = name.substring(0, name.length - suffix.length);
+                        // Skip if the suggestion would be empty or just a single character
+                        if (suggestion.length <= 1)
+                            continue;
+                        context.report({
+                            node,
+                            messageId: 'unnecessaryVerbSuffix',
+                            data: {
+                                suffix,
+                                suggestion,
+                            },
+                            fix(fixer) {
+                                if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                                    return fixer.replaceText(node.id, suggestion);
+                                }
+                                else if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                                    node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                                    const parent = node.parent;
+                                    if (parent &&
+                                        (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                                            parent.type === utils_1.AST_NODE_TYPES.Property ||
+                                            parent.type === utils_1.AST_NODE_TYPES.MethodDefinition)) {
+                                        if ('key' in parent) {
+                                            return fixer.replaceText(parent.key, suggestion);
+                                        }
+                                        else if ('id' in parent && parent.id) {
+                                            return fixer.replaceText(parent.id, suggestion);
+                                        }
+                                    }
+                                }
+                                return null;
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (node.id) {
+                    checkFunctionName(node, node.id.name);
+                }
+            },
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        node.init?.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    checkFunctionName(node.init, node.id.name);
+                }
+            },
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    checkFunctionName(node.value, node.key.name);
+                }
+            },
+            TSMethodSignature(node) {
+                // Handle interface method signatures
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    checkFunctionName(node, node.key.name);
+                }
+            },
+            Property(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    checkFunctionName(node.value, node.key.name);
+                }
+            },
+            FunctionExpression(node) {
+                // Handle named function expressions
+                if (node.id) {
+                    checkFunctionName(node, node.id.name);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unnecessary-verb-suffix.js.map

package/lib/rules/no-unused-props.js

@@ -36,7 +36,53 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                             });
                         }
                         else if (typeNode.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            typeNode.types.forEach(extractProps);
+                            typeNode.types.forEach((type) => {
+                                if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                                    const typeName = type.typeName;
+                                    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        if (typeName.name === 'Pick' && type.typeParameters) {
+                                            // Handle Pick utility type in intersection
+                                            const [baseType, pickedProps] = type.typeParameters.params;
+                                            if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                                baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                                // Extract the picked properties from the union type
+                                                if (pickedProps.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                                                    pickedProps.types.forEach((t) => {
+                                                        if (t.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                                            t.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                                            typeof t.literal.value === 'string') {
+                                                            // Add each picked property as a regular prop
+                                                            props[t.literal.value] = t.literal;
+                                                        }
+                                                    });
+                                                }
+                                                else if (pickedProps.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                                    pickedProps.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                                    typeof pickedProps.literal.value === 'string') {
+                                                    // Single property pick
+                                                    props[pickedProps.literal.value] = pickedProps.literal;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            // For referenced types in intersections, we need to find their type declaration
+                                            const scope = context.getScope();
+                                            const variable = scope.variables.find(v => v.name === typeName.name);
+                                            if (variable && variable.defs[0]?.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                                extractProps(variable.defs[0].node.typeAnnotation);
+                                            }
+                                            else {
+                                                // If we can't find the type declaration, it's likely an imported type
+                                                // Mark it as a forwarded prop
+                                                props[`...${typeName.name}`] = typeName;
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    extractProps(type);
+                                }
+                            });
                         }
                         else if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                             if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {