@blumintinc/eslint-plugin-blumint 1.5.0 → 1.5.2

package/lib/rules/no-firestore-object-arrays.d.ts

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

package/lib/rules/no-firestore-object-arrays.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFirestoreObjectArrays = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const PRIMITIVE_TYPES = new Set([
+    'string',
+    'number',
+    'boolean',
+    'Date',
+    'Timestamp',
+    'null',
+    'undefined',
+    'GeoPoint',
+]);
+const isInFirestoreTypesDirectory = (filename) => {
+    return filename.includes('functions/src/types/firestore');
+};
+const isObjectType = (node) => {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+            if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const typeName = node.typeName.name;
+                return !PRIMITIVE_TYPES.has(typeName);
+            }
+            else if (node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                // Handle namespace.Type cases
+                return true;
+            }
+            return true;
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+            return node.types.some(isObjectType);
+        case utils_1.AST_NODE_TYPES.TSMappedType:
+        case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+            return true;
+        default:
+            return false;
+    }
+};
+exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
+    name: 'no-firestore-object-arrays',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow arrays of objects in Firestore type definitions to optimize performance and avoid unnecessary fetches',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            noObjectArrays: 'Arrays of objects are not recommended in Firestore. Use subcollections, arrays of IDs, or structured maps (Record<string, T>) instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        if (!isInFirestoreTypesDirectory(context.getFilename())) {
+            return {};
+        }
+        return {
+            TSArrayType(node) {
+                if (isObjectType(node.elementType)) {
+                    context.report({
+                        node,
+                        messageId: 'noObjectArrays',
+                    });
+                }
+            },
+            TSTypeReference(node) {
+                // Handle Array<T> and ReadonlyArray<T> syntax
+                const typeName = node.typeName.name;
+                if ((typeName === 'Array' || typeName === 'ReadonlyArray') && node.typeParameters) {
+                    const elementType = node.typeParameters.params[0];
+                    if (isObjectType(elementType)) {
+                        context.report({
+                            node,
+                            messageId: 'noObjectArrays',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-firestore-object-arrays.js.map

package/lib/rules/no-jsx-in-hooks.d.ts

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

package/lib/rules/no-jsx-in-hooks.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noJsxInHooks = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const isJsxElement = (node) => {
+    if (!node)
+        return false;
+    if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+        return isJsxElement(node.consequent) || isJsxElement(node.alternate);
+    }
+    return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        node.type === utils_1.AST_NODE_TYPES.JSXFragment ||
+        node.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer);
+};
+const isJsxReturnType = (node) => {
+    if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        const typeName = node.typeAnnotation.typeName;
+        if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return ['JSX', 'ReactNode', 'ReactElement'].includes(typeName.name);
+        }
+        if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+            return typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.left.name === 'JSX' &&
+                typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.right.name === 'Element';
+        }
+    }
+    return false;
+};
+const containsJsxInBlockStatement = (node) => {
+    const variablesWithJsx = new Set();
+    for (const statement of node.body) {
+        // Check variable declarations for JSX assignments
+        if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            for (const declarator of statement.declarations) {
+                if (declarator.init) {
+                    if (declarator.init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        containsJsxInUseMemo(declarator.init)) {
+                        if (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            variablesWithJsx.add(declarator.id.name);
+                        }
+                    }
+                }
+            }
+        }
+        // Check return statements
+        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+            if (isJsxElement(statement.argument)) {
+                return true;
+            }
+            if (statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                if (containsJsxInUseMemo(statement.argument)) {
+                    return true;
+                }
+            }
+            if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                variablesWithJsx.has(statement.argument.name)) {
+                return true;
+            }
+        }
+        // Check if statements
+        if (statement.type === utils_1.AST_NODE_TYPES.IfStatement) {
+            if (statement.consequent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                statement.consequent.argument) {
+                if (isJsxElement(statement.consequent.argument)) {
+                    return true;
+                }
+                if (statement.consequent.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    variablesWithJsx.has(statement.consequent.argument.name)) {
+                    return true;
+                }
+            }
+            if (statement.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                containsJsxInBlockStatement(statement.consequent)) {
+                return true;
+            }
+            if (statement.alternate) {
+                if (statement.alternate.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                    statement.alternate.argument) {
+                    if (isJsxElement(statement.alternate.argument)) {
+                        return true;
+                    }
+                    if (statement.alternate.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        variablesWithJsx.has(statement.alternate.argument.name)) {
+                        return true;
+                    }
+                }
+                if (statement.alternate.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                    containsJsxInBlockStatement(statement.alternate)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+const containsJsxInUseMemo = (node) => {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.callee.name === 'useMemo' &&
+        node.arguments.length > 0) {
+        const callback = node.arguments[0];
+        if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            const body = callback.body;
+            if (isJsxElement(body)) {
+                return true;
+            }
+            if (body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                return containsJsxInBlockStatement(body);
+            }
+            if (body.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                body.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                body.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                body.callee.property.name === 'map') {
+                const mapCallback = body.arguments[0];
+                if ((mapCallback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    mapCallback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                    isJsxElement(mapCallback.body)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+exports.noJsxInHooks = (0, createRule_1.createRule)({
+    name: 'no-jsx-in-hooks',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent hooks from returning JSX',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noJsxInHooks: 'Hooks should not return JSX. Convert this hook into a component or extract the JSX into a separate component.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            FunctionDeclaration(node) {
+                if (node.id && node.id.name.startsWith('use')) {
+                    // Check return type annotation
+                    if (node.returnType && isJsxReturnType(node.returnType)) {
+                        context.report({
+                            node: node.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check return statements
+                    if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        if (containsJsxInBlockStatement(node.body)) {
+                            context.report({
+                                node: node.id,
+                                messageId: 'noJsxInHooks',
+                            });
+                        }
+                    }
+                }
+            },
+            ArrowFunctionExpression(node) {
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    parent.id.name.startsWith('use')) {
+                    // Check return type annotation
+                    if (node.returnType && isJsxReturnType(node.returnType)) {
+                        context.report({
+                            node: parent.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check direct JSX return
+                    if (isJsxElement(node.body)) {
+                        context.report({
+                            node: parent.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check block body returns
+                    if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        if (containsJsxInBlockStatement(node.body)) {
+                            context.report({
+                                node: parent.id,
+                                messageId: 'noJsxInHooks',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-jsx-in-hooks.js.map

package/lib/rules/no-memoize-on-static.d.ts

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

package/lib/rules/no-memoize-on-static.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMemoizeOnStatic = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noMemoizeOnStatic = (0, createRule_1.createRule)({
+    name: 'no-memoize-on-static',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent using @Memoize() decorator on static methods',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMemoizeOnStatic: '@Memoize() decorator should not be used on static methods',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track renamed imports of Memoize
+        const memoizeAliases = new Set(['Memoize']);
+        return {
+            ImportSpecifier(node) {
+                if (node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.imported.name === 'Memoize' &&
+                    node.local.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    memoizeAliases.add(node.local.name);
+                }
+            },
+            'MethodDefinition[static=true]'(node) {
+                if (node.decorators) {
+                    for (const decorator of node.decorators) {
+                        const expr = decorator.expression;
+                        if (
+                        // Handle @Memoize()
+                        (expr.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                            expr.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            memoizeAliases.has(expr.callee.name)) ||
+                            // Handle @Memoize (without parentheses)
+                            (expr.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                memoizeAliases.has(expr.name))) {
+                            context.report({
+                                node: decorator,
+                                messageId: 'noMemoizeOnStatic',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-memoize-on-static.js.map

package/lib/rules/no-unsafe-firestore-spread.d.ts

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

package/lib/rules/no-unsafe-firestore-spread.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnsafeFirestoreSpread = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noUnsafeFirestoreSpread = (0, createRule_1.createRule)({
+    name: 'no-unsafe-firestore-spread',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent unsafe object/array spreads in Firestore updates',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unsafeObjectSpread: 'Avoid using object spread in Firestore updates. Use dot notation with FieldPath instead.',
+            unsafeArraySpread: 'Avoid using array spread in Firestore updates. Use FieldValue.arrayUnion() instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isFirestoreSetMergeCall(node) {
+            // Check for merge: true in the last argument
+            const lastArg = node.arguments[node.arguments.length - 1];
+            if (lastArg?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                const hasMergeTrue = lastArg.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    prop.key.name === 'merge' &&
+                    prop.value.type === utils_1.AST_NODE_TYPES.Literal &&
+                    prop.value.value === true);
+                if (!hasMergeTrue)
+                    return false;
+                // Check if it's a set() method call or setDoc() function call
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const property = node.callee.property;
+                    return (property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        property.name === 'set');
+                }
+                else if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return node.callee.name === 'setDoc';
+                }
+            }
+            return false;
+        }
+        function checkObjectForSpreads(node, parentPath = '') {
+            for (const property of node.properties) {
+                if (property.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    context.report({
+                        node: property,
+                        messageId: 'unsafeObjectSpread',
+                        fix: null,
+                    });
+                }
+                else if (property.type === utils_1.AST_NODE_TYPES.Property) {
+                    const key = property.key.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? property.key.name
+                        : '';
+                    const newPath = parentPath ? `${parentPath}.${key}` : key;
+                    if (property.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkObjectForSpreads(property.value, newPath);
+                    }
+                    else if (property.value.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                        checkArrayForSpreads(property.value);
+                    }
+                    else if (property.value.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        // Handle chained array methods like [...array].filter()
+                        let current = property.value;
+                        while (current) {
+                            if (current.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                                checkArrayForSpreads(current);
+                                break;
+                            }
+                            else if (current.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                                checkObjectForSpreads(current, newPath);
+                                break;
+                            }
+                            // Move up to check the caller if it's a method chain
+                            if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                                current.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                                current = current.callee.object;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        function checkArrayForSpreads(node) {
+            // Check for spreads in the array expression itself
+            for (const element of node.elements) {
+                if (element?.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    context.report({
+                        node: element,
+                        messageId: 'unsafeArraySpread',
+                        fix: null,
+                    });
+                }
+            }
+        }
+        return {
+            CallExpression(node) {
+                if (!isFirestoreSetMergeCall(node))
+                    return;
+                // For set() calls, the update object can be either the first or second argument
+                // If it's a docRef.set(data) call, it's the first argument
+                // If it's a docRef.set(docRef, data) call (like in transactions/batches), it's the second argument
+                let updateArg;
+                if (node.arguments.length === 2) {
+                    updateArg = node.arguments[0];
+                }
+                else if (node.arguments.length === 3) {
+                    // In a transaction or batch operation, the data is the second argument
+                    updateArg = node.arguments[1];
+                }
+                if (!updateArg || updateArg.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                    return;
+                checkObjectForSpreads(updateArg);
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unsafe-firestore-spread.js.map

package/lib/rules/require-hooks-default-params.d.ts

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