@blumintinc/eslint-plugin-blumint 1.7.1 → 1.7.3

package/lib/index.js

@@ -69,10 +69,11 @@ const enforce_centralized_mock_firestore_1 = require("./rules/enforce-centralize
 const require_hooks_default_params_1 = require("./rules/require-hooks-default-params");
 const prefer_destructuring_no_class_1 = require("./rules/prefer-destructuring-no-class");
 const enforce_render_hits_memoization_1 = require("./rules/enforce-render-hits-memoization");
+const prefer_fragment_component_1 = require("./rules/prefer-fragment-component");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.7.1',
+        version: '1.7.3',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -104,7 +105,7 @@ module.exports = {
                 '@blumintinc/blumint/no-unpinned-dependencies': 'error',
                 '@blumintinc/blumint/no-unused-props': 'error',
                 //'@blumintinc/blumint/no-useless-fragment': 'error',
-                '@blumintinc/blumint/prefer-fragment-shorthand': 'error',
+                //'@blumintinc/blumint/prefer-fragment-shorthand': 'error',
                 '@blumintinc/blumint/prefer-type-over-interface': 'error',
                 '@blumintinc/blumint/require-memo': 'error',
                 '@blumintinc/blumint/require-dynamic-firebase-imports': 'error',
@@ -147,6 +148,7 @@ module.exports = {
                 '@blumintinc/blumint/require-hooks-default-params': 'error',
                 '@blumintinc/blumint/prefer-destructuring-no-class': 'error',
                 '@blumintinc/blumint/enforce-render-hits-memoization': 'error',
+                '@blumintinc/blumint/prefer-fragment-component': 'error',
             },
         },
     },
@@ -217,6 +219,7 @@ module.exports = {
         'require-hooks-default-params': require_hooks_default_params_1.requireHooksDefaultParams,
         'prefer-destructuring-no-class': prefer_destructuring_no_class_1.preferDestructuringNoClass,
         'enforce-render-hits-memoization': enforce_render_hits_memoization_1.enforceRenderHitsMemoization,
+        'prefer-fragment-component': prefer_fragment_component_1.preferFragmentComponent,
     },
 };
 //# sourceMappingURL=index.js.map

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceCentralizedMockFirestore = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-const MOCK_FIRESTORE_PATH = '../../../../../__mocks__/functions/src/config/mockFirestore';
+const MOCK_FIRESTORE_PATH = '../../../../../__test-utils__/mockFirestore';
 exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
     name: 'enforce-centralized-mock-firestore',
     meta: {

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

@@ -18,8 +18,8 @@ exports.enforceFirestoreMock = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            noManualFirestoreMock: 'Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead of manually mocking Firestore. Replace `jest.mock("firebase-admin", () => ({ firestore: () => ({ /* mock */ }) }))` with `import { mockFirestore } from "__mocks__/functions/src/config/mockFirestore"; jest.mock("firebase-admin", () => mockFirestore)`.',
-            noMockFirebase: 'Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead of mockFirebase. Replace `import { mockFirebase } from "firestore-jest-mock"` with `import { mockFirestore } from "__mocks__/functions/src/config/mockFirestore"`.',
+            noManualFirestoreMock: 'Use mockFirestore from __test-utils__/mockFirestore instead of manually mocking Firestore. Replace `jest.mock("firebase-admin", () => ({ firestore: () => ({ /* mock */ }) }))` with `import { mockFirestore } from "__test-utils__/mockFirestore"; jest.mock("firebase-admin", () => mockFirestore)`.',
+            noMockFirebase: 'Use mockFirestore from __test-utils__/mockFirestore instead of mockFirebase. Replace `import { mockFirebase } from "firestore-jest-mock"` with `import { mockFirestore } from "__test-utils__/mockFirestore"`.',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-render-hits-memoization.js

@@ -35,7 +35,27 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             const name = node.name;
             return /^[A-Z]/.test(name);
         };
+        const isMemoizedVariable = (node) => {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            // Get the variable declaration for this identifier
+            const variable = context.getScope().variables.find(v => v.name === node.name);
+            if (!variable)
+                return false;
+            // Check if the variable is initialized with a memoized call
+            const def = variable.defs[0];
+            if (!def || !def.node)
+                return false;
+            if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && def.node.init) {
+                return isMemoizedCall(def.node.init);
+            }
+            return false;
+        };
         const isInsideMemoizedCall = (node) => {
+            // Check if the node is a reference to a memoized variable
+            if (isMemoizedVariable(node))
+                return true;
+            // Check if the node is inside a memoization hook call
             let current = node;
             while (current?.parent) {
                 if (isMemoizedCall(current.parent))

package/lib/rules/enforce-verb-noun-naming.js

@@ -10,6 +10,7 @@ const compromise_1 = __importDefault(require("compromise"));
 const PREPOSITIONS = new Set(['to', 'from', 'with', 'by', 'at', 'of']);
 // Create a Set from the verbs list for O(1) lookup
 const VERBS_SET = new Set([
+    'clean',
     'abbreviate',
     'abort',
     'abstract',

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

@@ -32,7 +32,7 @@ exports.noFirestoreJestMock = (0, createRule_1.createRule)({
                         messageId: 'noFirestoreJestMock',
                         fix(fixer) {
                             // Replace with mockFirestore import
-                            return fixer.replaceText(node, "import { mockFirestore } from '../../../../../__mocks__/functions/src/config/mockFirestore';");
+                            return fixer.replaceText(node, "import { mockFirestore } from '../../../../../__test-utils__/mockFirestore';");
                         },
                     });
                 }

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

@@ -19,7 +19,7 @@ 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: [],

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) {

package/lib/rules/prefer-fragment-component.d.ts

@@ -0,0 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferFragment' | 'addFragmentImport';
+export declare const preferFragmentComponent: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
+export {};

package/lib/rules/prefer-fragment-component.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferFragmentComponent = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.preferFragmentComponent = (0, createRule_1.createRule)({
+    name: 'prefer-fragment-component',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using Fragment imported from react over shorthand fragments and React.Fragment',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferFragment: 'Use Fragment imported from react instead of {{type}}',
+            addFragmentImport: 'Add Fragment import from react',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        let hasFragmentImport = false;
+        let reactImportNode = null;
+        function getReactImportNode() {
+            const program = sourceCode.ast;
+            for (const node of program.body) {
+                if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                    node.source.value === 'react') {
+                    return node;
+                }
+            }
+            return null;
+        }
+        function checkFragmentImport(node) {
+            if (node.source.value === 'react') {
+                reactImportNode = node;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.name === 'Fragment') {
+                        hasFragmentImport = true;
+                        break;
+                    }
+                }
+            }
+        }
+        function addFragmentImport(fixer) {
+            if (reactImportNode) {
+                // Add Fragment to existing react import
+                const lastSpecifier = reactImportNode.specifiers[reactImportNode.specifiers.length - 1];
+                return fixer.insertTextAfter(lastSpecifier, ', Fragment');
+            }
+            // Add new react import with Fragment
+            return fixer.insertTextBefore(sourceCode.ast.body[0], 'import { Fragment } from \'react\';\n');
+        }
+        return {
+            ImportDeclaration: checkFragmentImport,
+            JSXFragment(node) {
+                context.report({
+                    node,
+                    messageId: 'preferFragment',
+                    data: { type: 'shorthand fragment (<>)' },
+                    *fix(fixer) {
+                        if (!hasFragmentImport) {
+                            yield addFragmentImport(fixer);
+                        }
+                        yield fixer.replaceText(node.openingFragment, '<Fragment>');
+                        yield fixer.replaceText(node.closingFragment, '</Fragment>');
+                    },
+                });
+            },
+            JSXIdentifier(node) {
+                if (node.name === 'Fragment' &&
+                    node.parent?.type === utils_1.AST_NODE_TYPES.JSXMemberExpression &&
+                    node.parent.object.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                    node.parent.object.name === 'React') {
+                    const memberExpr = node.parent;
+                    context.report({
+                        node: memberExpr,
+                        messageId: 'preferFragment',
+                        data: { type: 'React.Fragment' },
+                        *fix(fixer) {
+                            if (!hasFragmentImport) {
+                                yield addFragmentImport(fixer);
+                            }
+                            yield fixer.replaceText(memberExpr, 'Fragment');
+                        },
+                    });
+                }
+            },
+            'Program:exit'() {
+                // If we found any violations but no Fragment import, we need to add it
+                if (!hasFragmentImport && !reactImportNode) {
+                    reactImportNode = getReactImportNode();
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-fragment-component.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",