@blumintinc/eslint-plugin-blumint 1.4.0 → 1.5.1

package/lib/rules/no-redundant-param-types.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noRedundantParamTypes: TSESLint.RuleModule<"redundantParamType", [], TSESLint.RuleListener>;

package/lib/rules/no-redundant-param-types.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRedundantParamTypes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+function isIdentifierWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.Identifier && node.typeAnnotation !== undefined);
+}
+function isRestElementWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.RestElement &&
+        node.typeAnnotation !== undefined);
+}
+function isObjectPatternWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+        node.typeAnnotation !== undefined);
+}
+function isArrayPatternWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrayPattern &&
+        node.typeAnnotation !== undefined);
+}
+function isAssignmentPatternWithTypeAnnotation(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+        node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.left.typeAnnotation !== undefined);
+}
+function removeTypeAnnotation(fixer, typeAnnotation, sourceCode) {
+    const typeStart = typeAnnotation.range[0];
+    const typeEnd = typeAnnotation.range[1];
+    // Check if there's a question mark before the type annotation
+    const hasQuestionMark = typeStart > 0 && sourceCode.getText().charAt(typeStart - 1) === '?';
+    const startPos = hasQuestionMark ? typeStart - 1 : typeStart;
+    return fixer.removeRange([startPos, typeEnd]);
+}
+function hasRedundantTypeAnnotation(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    // Check variable declarations
+    if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        parent.id.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+        return true;
+    }
+    // Check class property assignments
+    if (parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+        parent.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+        return true;
+    }
+    // Check assignments
+    if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+        parent.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+        parent.left.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+        return true;
+    }
+    return false;
+}
+exports.noRedundantParamTypes = (0, createRule_1.createRule)({
+    name: 'no-redundant-param-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow redundant parameter type annotations',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            redundantParamType: 'Parameter type annotation is redundant',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ArrowFunctionExpression(node) {
+                if (!hasRedundantTypeAnnotation(node))
+                    return;
+                const params = node.params;
+                params.forEach((param) => {
+                    if (isIdentifierWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isRestElementWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isObjectPatternWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isArrayPatternWithTypeAnnotation(param)) {
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, param.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                    else if (isAssignmentPatternWithTypeAnnotation(param)) {
+                        const { left } = param;
+                        context.report({
+                            node: param,
+                            messageId: 'redundantParamType',
+                            fix(fixer) {
+                                return removeTypeAnnotation(fixer, left.typeAnnotation, context.getSourceCode());
+                            },
+                        });
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-redundant-param-types.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/no-unused-props.js

@@ -13,7 +13,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unusedProp: 'Prop "{{propName}}" is defined in type but not used in component',
+            unusedProp: 'Prop "{{propName}}" is defined in the Props type but not used in the component. Either use the prop in your component or remove it from the Props type. If you need to forward all props, use a rest spread operator: `const MyComponent = ({ usedProp, ...rest }: Props) => ...`',
         },
         fixable: 'code',
     },

package/lib/rules/no-useless-fragment.js

@@ -38,7 +38,7 @@ exports.noUselessFragment = {
             recommended: 'error',
         },
         messages: {
-            noUselessFragment: 'React fragment is unnecessary when wrapping a single child',
+            noUselessFragment: 'React fragment is unnecessary when wrapping a single child. Instead of `<>{"text"}</> or <Fragment>{"text"}</Fragment>`, use just `{"text"}`. Fragments are only needed when returning multiple elements.',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/prefer-destructuring-no-class.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        object?: boolean;
+        enforceForRenamedProperties?: boolean;
+    }
+];
+export declare const preferDestructuringNoClass: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferDestructuring", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/prefer-destructuring-no-class.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferDestructuringNoClass = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = [
+    {
+        object: true,
+        enforceForRenamedProperties: false,
+    },
+];
+function isClassInstance(node, context) {
+    // Check if node is a MemberExpression
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const object = node.object;
+        // If object is a NewExpression, it's a class instance
+        if (object.type === utils_1.AST_NODE_TYPES.NewExpression) {
+            return true;
+        }
+        // If object is an identifier, check if it refers to a class instance
+        if (object.type === utils_1.AST_NODE_TYPES.Identifier) {
+            const variable = object.name;
+            const scope = context.getScope();
+            const ref = scope.references.find((ref) => ref.identifier.name === variable);
+            if (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                const init = ref.resolved.defs[0].node.init;
+                return init?.type === utils_1.AST_NODE_TYPES.NewExpression;
+            }
+            // Check if the identifier refers to a class (not an instance)
+            if (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration) {
+                return false;
+            }
+        }
+        // Recursively check if parent object is a class instance
+        if (object.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            return isClassInstance(object, context);
+        }
+    }
+    return false;
+}
+function isStaticClassMember(node, context) {
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const object = node.object;
+        if (object.type === utils_1.AST_NODE_TYPES.Identifier) {
+            const variable = object.name;
+            const scope = context.getScope();
+            const ref = scope.references.find((ref) => ref.identifier.name === variable);
+            return (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+        }
+    }
+    return false;
+}
+/**
+ * Check if the property name matches the variable name in an assignment
+ */
+function isMatchingPropertyName(propertyNode, variableName) {
+    if (propertyNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return propertyNode.name === variableName;
+    }
+    if (propertyNode.type === utils_1.AST_NODE_TYPES.Literal) {
+        return propertyNode.value === variableName;
+    }
+    return false;
+}
+/**
+ * Get the property text for destructuring
+ */
+function getPropertyText(property, computed, sourceCode) {
+    if (computed) {
+        return sourceCode.getText(property);
+    }
+    if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return property.name;
+    }
+    if (property.type === utils_1.AST_NODE_TYPES.Literal) {
+        return String(property.value);
+    }
+    // For any other type, use the source text
+    return sourceCode.getText(property);
+}
+exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
+    name: 'prefer-destructuring-no-class',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce destructuring when accessing object properties, except for class instances',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    object: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                    enforceForRenamedProperties: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferDestructuring: 'Use destructuring instead of accessing the property directly.',
+        },
+    },
+    defaultOptions,
+    create(context) {
+        const options = {
+            object: defaultOptions[0].object,
+            enforceForRenamedProperties: defaultOptions[0].enforceForRenamedProperties,
+            ...context.options[0],
+        };
+        /**
+         * Check if destructuring should be used for this node
+         */
+        function shouldUseDestructuring(node, leftNode) {
+            // Skip if this is a class instance or static class member
+            if (isClassInstance(node, context) ||
+                isStaticClassMember(node, context)) {
+                return false;
+            }
+            // Check object destructuring
+            if (options.object) {
+                if (options.enforceForRenamedProperties) {
+                    return true;
+                }
+                // Only suggest destructuring when property name matches variable name
+                if (leftNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return isMatchingPropertyName(node.property, leftNode.name);
+                }
+            }
+            return false;
+        }
+        return {
+            VariableDeclarator(node) {
+                // Skip if variable is declared without assignment or if init is not a MemberExpression
+                if (!node.init)
+                    return;
+                if (node.init.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+                    return;
+                if (shouldUseDestructuring(node.init, node.id)) {
+                    const sourceCode = context.getSourceCode();
+                    const objectText = sourceCode.getText(node.init.object);
+                    const propertyText = getPropertyText(node.init.property, node.init.computed, sourceCode);
+                    context.report({
+                        node,
+                        messageId: 'preferDestructuring',
+                        fix(fixer) {
+                            // Get the variable declaration kind (const, let, var)
+                            const parentNode = node.parent;
+                            if (!parentNode ||
+                                parentNode.type !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                                return null;
+                            }
+                            const kind = parentNode.kind;
+                            // Handle renamed properties
+                            if (options.enforceForRenamedProperties &&
+                                node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                node.init &&
+                                node.init.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                !isMatchingPropertyName(node.init.property, node.id.name)) {
+                                return fixer.replaceText(parentNode, `${kind} { ${propertyText}: ${node.id.name} } = ${objectText};`);
+                            }
+                            return fixer.replaceText(parentNode, `${kind} { ${propertyText} } = ${objectText};`);
+                        },
+                    });
+                }
+            },
+            AssignmentExpression(node) {
+                if (node.operator === '=' &&
+                    node.right.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    if (shouldUseDestructuring(node.right, node.left)) {
+                        const sourceCode = context.getSourceCode();
+                        const objectText = sourceCode.getText(node.right.object);
+                        const propertyText = getPropertyText(node.right.property, node.right.computed, sourceCode);
+                        context.report({
+                            node,
+                            messageId: 'preferDestructuring',
+                            fix(fixer) {
+                                // Handle renamed properties
+                                if (options.enforceForRenamedProperties &&
+                                    node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                    node.right.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                    !isMatchingPropertyName(node.right.property, node.left.name)) {
+                                    return fixer.replaceText(node, `({ ${propertyText}: ${node.left.name} } = ${objectText})`);
+                                }
+                                return fixer.replaceText(node, `({ ${propertyText} } = ${objectText})`);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-destructuring-no-class.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>;