@blumintinc/eslint-plugin-blumint 1.5.5 → 1.7.0

package/lib/rules/no-mixed-firestore-transactions.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMixedFirestoreTransactions = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const NON_TRANSACTIONAL_CLASSES = new Set([
+    'DocSetter',
+    'FirestoreDocFetcher',
+    'FirestoreFetcher',
+]);
+exports.noMixedFirestoreTransactions = (0, createRule_1.createRule)({
+    name: 'no-mixed-firestore-transactions',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent mixing transactional and non-transactional Firestore operations within a transaction',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMixedTransactions: 'Do not use non-transactional Firestore operations ({{ className }}) inside a transaction. Use {{ transactionalClass }} instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const transactionScopes = new Set();
+        function getTransactionalClassName(className) {
+            if (className === 'DocSetter')
+                return 'DocSetterTransaction';
+            if (className === 'FirestoreDocFetcher')
+                return 'FirestoreDocFetcherTransaction';
+            if (className === 'FirestoreFetcher')
+                return 'FirestoreFetcherTransaction';
+            return className;
+        }
+        function isFirestoreTransaction(node) {
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+                return false;
+            const property = callee.property;
+            return property.type === utils_1.AST_NODE_TYPES.Identifier && property.name === 'runTransaction';
+        }
+        function isNonTransactionalClass(node) {
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            return NON_TRANSACTIONAL_CLASSES.has(callee.name);
+        }
+        function isTransactionParameter(param) {
+            if (param.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            const typeAnnotation = param.typeAnnotation;
+            if (!typeAnnotation || typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation)
+                return false;
+            const type = typeAnnotation.typeAnnotation;
+            if (type.type !== utils_1.AST_NODE_TYPES.TSTypeReference)
+                return false;
+            const typeName = type.typeName;
+            if (typeName.type !== utils_1.AST_NODE_TYPES.TSQualifiedName)
+                return false;
+            return typeName.left.type === utils_1.AST_NODE_TYPES.Identifier && typeName.left.name === 'FirebaseFirestore' &&
+                typeName.right.type === utils_1.AST_NODE_TYPES.Identifier && typeName.right.name === 'Transaction';
+        }
+        function isInTransactionScope(node) {
+            let current = node;
+            while (current) {
+                if (transactionScopes.has(current)) {
+                    return true;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    const params = current.params;
+                    if (params.some(isTransactionParameter)) {
+                        return true;
+                    }
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        return {
+            'CallExpression[callee.property.name="runTransaction"]'(node) {
+                if (!isFirestoreTransaction(node))
+                    return;
+                const callback = node.arguments[0];
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    transactionScopes.add(callback.body);
+                }
+            },
+            'CallExpression[callee.property.name="runTransaction"]:exit'(node) {
+                const callback = node.arguments[0];
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    transactionScopes.delete(callback.body);
+                }
+            },
+            NewExpression(node) {
+                if (!isInTransactionScope(node) || !isNonTransactionalClass(node))
+                    return;
+                const className = node.callee.name;
+                context.report({
+                    node,
+                    messageId: 'noMixedTransactions',
+                    data: {
+                        className,
+                        transactionalClass: getTransactionalClassName(className),
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-mixed-firestore-transactions.js.map

package/lib/rules/no-mock-firebase-admin.d.ts

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

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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',
+    'functions/src/config/firebaseAdmin',
+];
+exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
+    name: 'no-mock-firebase-admin',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent mocking of functions/src/config/firebaseAdmin',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMockFirebaseAdmin: 'Do not mock firebaseAdmin directly. Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.object.name === 'jest' &&
+                    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'));
+                    if (isFirebaseAdminMock) {
+                        context.report({
+                            node,
+                            messageId: 'noMockFirebaseAdmin',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-mock-firebase-admin.js.map

package/lib/rules/prefer-batch-operations.d.ts

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

package/lib/rules/prefer-batch-operations.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferBatchOperations = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const SETTER_METHODS = new Set(['set', 'overwrite']);
+const ARRAY_METHODS = new Set(['map', 'forEach', 'filter', 'reduce', 'every', 'some']);
+function isArrayMethod(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
+        return { isValid: false };
+    const callee = node.callee;
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        ARRAY_METHODS.has(callee.property.name)) {
+        return { isValid: true, methodName: callee.property.name };
+    }
+    return { isValid: false };
+}
+function isPromiseAll(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
+        return false;
+    const callee = node.callee;
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        callee.object.name === 'Promise' &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        callee.property.name === 'all');
+}
+function findLoopNode(node) {
+    let current = node;
+    let loopNode = null;
+    while (current) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.ForStatement:
+            case utils_1.AST_NODE_TYPES.ForInStatement:
+            case utils_1.AST_NODE_TYPES.ForOfStatement:
+            case utils_1.AST_NODE_TYPES.WhileStatement:
+            case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                loopNode = current;
+                break;
+            case utils_1.AST_NODE_TYPES.CallExpression:
+                // Check for Promise.all
+                if (isPromiseAll(current)) {
+                    return { node: current, isArrayMethod: 'map' };
+                }
+                // Check for array methods
+                const { isValid, methodName: currentMethodName } = isArrayMethod(current);
+                if (isValid && currentMethodName) {
+                    // For sequential array methods, check if the callback is async
+                    if (currentMethodName === 'forEach' || currentMethodName === 'reduce' || currentMethodName === 'filter') {
+                        const callback = current.arguments[0];
+                        if (callback && (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                            callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                            callback.async) {
+                            return { node: current, isArrayMethod: currentMethodName };
+                        }
+                    }
+                    return { node: current, isArrayMethod: currentMethodName };
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.Program:
+                // Return loop if we found one
+                if (loopNode) {
+                    return { node: loopNode };
+                }
+                return undefined;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function isSetterMethodCall(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
+        return { isValid: false };
+    const callee = node.callee;
+    if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+        return { isValid: false };
+    if (callee.property.type !== utils_1.AST_NODE_TYPES.Identifier)
+        return { isValid: false };
+    if (!SETTER_METHODS.has(callee.property.name))
+        return { isValid: false };
+    // Get the setter instance
+    const object = callee.object;
+    if (object.type !== utils_1.AST_NODE_TYPES.Identifier)
+        return { isValid: false };
+    const setterInstance = object.name;
+    // Get the method name
+    const methodName = callee.property.name;
+    return { isValid: true, methodName, setterInstance };
+}
+const loopSetterCalls = new Map();
+exports.preferBatchOperations = (0, createRule_1.createRule)({
+    name: 'prefer-batch-operations',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using setAll() and overwriteAll() instead of multiple set() or overwrite() calls',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferSetAll: 'Use setAll() instead of multiple set() calls for better performance',
+            preferOverwriteAll: 'Use overwriteAll() instead of multiple overwrite() calls for better performance',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'Program:exit'() {
+                // Clear the maps for the next file
+                loopSetterCalls.clear();
+            },
+            CallExpression(node) {
+                const { isValid, methodName, setterInstance } = isSetterMethodCall(node);
+                if (!isValid || !methodName || !setterInstance)
+                    return;
+                // Check if we're in a loop or Promise.all
+                const loopInfo = findLoopNode(node);
+                if (!loopInfo)
+                    return;
+                // Get or create the setter calls map for this loop
+                let setterCalls = loopSetterCalls.get(loopInfo.node);
+                if (!setterCalls) {
+                    setterCalls = new Map();
+                    loopSetterCalls.set(loopInfo.node, setterCalls);
+                }
+                // Track setter instance and method calls for this loop
+                const key = setterInstance;
+                const existing = setterCalls.get(key);
+                if (existing) {
+                    // If we see a different method on the same setter instance, don't report
+                    if (existing.methodName !== methodName)
+                        return;
+                    existing.count++;
+                }
+                else {
+                    setterCalls.set(key, { methodName, count: 1 });
+                }
+                // Report on the first occurrence of a repeated call
+                // For Promise.all and array methods, report on the first occurrence
+                // For regular loops, report on the first occurrence too since we know it's in a loop
+                const shouldReport = loopInfo.isArrayMethod
+                    ? ['forEach', 'reduce', 'filter', 'map'].includes(loopInfo.isArrayMethod)
+                    : setterCalls.get(key).count === 1;
+                // Don't report if we have multiple different setter instances in a loop
+                // Only check this for regular loops, not array methods or Promise.all
+                if (shouldReport && !loopInfo.isArrayMethod) {
+                    const setterInstances = new Set(Array.from(setterCalls.keys()));
+                    if (setterInstances.size > 1) {
+                        // This is a valid use case when using multiple setters in a loop
+                        // For example: userSetter.set(doc.user) and orderSetter.set(doc.order)
+                        // Each setter operates on a different collection, so they can't be batched together
+                        // We only want to report when using the same setter instance multiple times
+                        // For example: userSetter.set(doc.user) multiple times should use userSetter.setAll()
+                        if (loopInfo.node.type.startsWith('For') || loopInfo.node.type.startsWith('While') || loopInfo.node.type.startsWith('Do')) {
+                            return;
+                        }
+                    }
+                }
+                // Report on the first occurrence of a repeated call
+                // For Promise.all and array methods, report on the first occurrence
+                // For regular loops, report on the first occurrence too since we know it's in a loop
+                if (shouldReport) {
+                    const messageId = methodName === 'set' ? 'preferSetAll' : 'preferOverwriteAll';
+                    context.report({
+                        node,
+                        messageId,
+                        fix: () => null, // We can't provide a fix because we don't know the array structure
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-batch-operations.js.map

package/lib/rules/prefer-clone-deep.d.ts

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

package/lib/rules/prefer-clone-deep.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferCloneDeep = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.preferCloneDeep = (0, createRule_1.createRule)({
+    name: 'prefer-clone-deep',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer using cloneDeep over nested spread copying',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferCloneDeep: 'Use cloneDeep from functions/src/util/cloneDeep.ts instead of nested spread operators for deep object copying',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function hasNestedSpread(node) {
+            let spreadCount = 0;
+            let hasFunction = false;
+            let hasSymbol = false;
+            function visit(node) {
+                if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    spreadCount++;
+                }
+                else if (node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    hasFunction = true;
+                }
+                else if (node.type === utils_1.AST_NODE_TYPES.Property &&
+                    node.computed &&
+                    node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === 'Symbol') {
+                    hasSymbol = true;
+                }
+                for (const key in node) {
+                    const value = node[key];
+                    if (value && typeof value === 'object') {
+                        visit(value);
+                    }
+                }
+            }
+            visit(node);
+            return spreadCount > 1 && !hasFunction && !hasSymbol;
+        }
+        function getSourceText(node) {
+            return context.getSourceCode().getText(node);
+        }
+        function generateCloneDeepFix(node) {
+            const sourceText = getSourceText(node);
+            return `cloneDeep(${sourceText.replace(/\.\.\./g, '')}, {} as const)`;
+        }
+        return {
+            ObjectExpression(node) {
+                if (hasNestedSpread(node)) {
+                    context.report({
+                        node,
+                        messageId: 'preferCloneDeep',
+                        fix(fixer) {
+                            return fixer.replaceText(node, generateCloneDeepFix(node));
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-clone-deep.js.map

package/lib/rules/prefer-settings-object.js

@@ -51,6 +51,16 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
             if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
                 return getParameterType(param.left);
             }
+            if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
+                // For destructured parameters, use the type annotation name
+                const typeNode = param.typeAnnotation.typeAnnotation;
+                if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                    return typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? typeNode.typeName.name
+                        : 'unknown';
+                }
+                return typeNode.type;
+            }
             if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
@@ -72,18 +82,158 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
             const typeMap = new Map();
             for (const param of params) {
                 const type = getParameterType(param);
-                typeMap.set(type, (typeMap.get(type) || 0) + 1);
-                if (typeMap.get(type) > 1) {
+                const count = (typeMap.get(type) || 0) + 1;
+                typeMap.set(type, count);
+                if (count > 1) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function isBuiltInOrThirdParty(node) {
+            // Check if the node is part of a new expression (constructor call)
+            let current = node;
+            while (current.parent) {
+                const parent = current.parent;
+                // Check if we're in a constructor call
+                if (parent.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                    const callee = parent.callee;
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // List of built-in objects that should be ignored
+                        const builtInObjects = new Set([
+                            'Promise',
+                            'Map',
+                            'Set',
+                            'WeakMap',
+                            'WeakSet',
+                            'Int8Array',
+                            'Uint8Array',
+                            'Uint8ClampedArray',
+                            'Int16Array',
+                            'Uint16Array',
+                            'Int32Array',
+                            'Uint32Array',
+                            'Float32Array',
+                            'Float64Array',
+                            'BigInt64Array',
+                            'BigUint64Array',
+                            'ArrayBuffer',
+                            'SharedArrayBuffer',
+                            'DataView',
+                            'Date',
+                            'RegExp',
+                            'Error',
+                            'AggregateError',
+                            'EvalError',
+                            'RangeError',
+                            'ReferenceError',
+                            'SyntaxError',
+                            'TypeError',
+                            'URIError',
+                            'Transform', // Added Transform to built-in objects
+                        ]);
+                        if (builtInObjects.has(callee.name)) {
+                            return true;
+                        }
+                        // Check if the identifier is imported from a third-party module
+                        const scope = context.getScope();
+                        const variable = scope.variables.find((v) => v.name === callee.name);
+                        if (variable) {
+                            const def = variable.defs[0];
+                            if (def?.type === 'ImportBinding') {
+                                const importDecl = def.parent;
+                                let source;
+                                if (importDecl.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                                    source = importDecl.source.value;
+                                }
+                                else if (importDecl.type ===
+                                    utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration &&
+                                    importDecl.moduleReference.type ===
+                                        utils_1.AST_NODE_TYPES.TSExternalModuleReference &&
+                                    importDecl.moduleReference.expression.type ===
+                                        utils_1.AST_NODE_TYPES.Literal) {
+                                    source = importDecl.moduleReference.expression
+                                        .value;
+                                }
+                                // If it's a third-party module (doesn't start with '.' or '/'), ignore it
+                                if (source &&
+                                    !source.startsWith('.') &&
+                                    !source.startsWith('/')) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    else if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        // Handle cases like React.Component or lodash.debounce
+                        const obj = callee.object;
+                        if (obj.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const scope = context.getScope();
+                            const variable = scope.variables.find((v) => v.name === obj.name);
+                            if (variable) {
+                                const def = variable.defs[0];
+                                if (def?.type === 'ImportBinding') {
+                                    const importDecl = def.parent;
+                                    let source;
+                                    if (importDecl.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                                        source = importDecl.source.value;
+                                    }
+                                    else if (importDecl.type ===
+                                        utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration &&
+                                        importDecl.moduleReference.type ===
+                                            utils_1.AST_NODE_TYPES.TSExternalModuleReference &&
+                                        importDecl.moduleReference.expression.type ===
+                                            utils_1.AST_NODE_TYPES.Literal) {
+                                        source = importDecl.moduleReference.expression
+                                            .value;
+                                    }
+                                    // If it's a third-party module (doesn't start with '.' or '/'), ignore it
+                                    if (source &&
+                                        !source.startsWith('.') &&
+                                        !source.startsWith('/')) {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                // Also check if we're in a property of an object that's passed to a constructor
+                if (parent.type === utils_1.AST_NODE_TYPES.Property &&
+                    parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    parent.parent.parent?.type === utils_1.AST_NODE_TYPES.NewExpression) {
                     return true;
                 }
+                current = parent;
+            }
+            return false;
+        }
+        function hasABPattern(params) {
+            if (params.length !== 2)
+                return false;
+            const paramNames = params.map(param => {
+                if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return param.name;
+                }
+                return '';
+            });
+            // Check if both parameters end with 'A' and 'B' respectively and have the same prefix
+            const [first, second] = paramNames;
+            if (first.endsWith('A') && second.endsWith('B')) {
+                const firstPrefix = first.slice(0, -1);
+                const secondPrefix = second.slice(0, -1);
+                return firstPrefix === secondPrefix;
             }
             return false;
         }
         function shouldIgnoreNode(node) {
+            // Ignore built-in objects and third-party modules
+            if (isBuiltInOrThirdParty(node))
+                return true;
             // Ignore variadic functions if configured
             if (finalOptions.ignoreVariadicFunctions) {
                 const hasRestParam = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
-                    node.params.some(param => param.type === utils_1.AST_NODE_TYPES.RestElement);
+                    node.params.some((param) => param.type === utils_1.AST_NODE_TYPES.RestElement);
                 if (hasRestParam)
                     return true;
             }
@@ -98,6 +248,16 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                     parent = parent.parent;
                 }
             }
+            // Ignore functions with A/B pattern parameters
+            if ((node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.TSMethodSignature ||
+                node.type === utils_1.AST_NODE_TYPES.TSFunctionType) &&
+                Array.isArray(node.params)) {
+                if (hasABPattern(node.params))
+                    return true;
+            }
             return false;
         }
         function checkFunction(node) {
@@ -105,9 +265,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 return;
             const params = node.params;
             // Check for too many parameters first
-            const minParams = finalOptions.minimumParameters !== undefined
-                ? finalOptions.minimumParameters
-                : defaultOptions.minimumParameters;
+            const minParams = finalOptions.minimumParameters ?? defaultOptions.minimumParameters ?? 3;
             if (params.length >= minParams) {
                 context.report({
                     node,

package/lib/rules/semantic-function-prefixes.js

@@ -4,6 +4,7 @@ exports.semanticFunctionPrefixes = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const DISALLOWED_PREFIXES = new Set(['get', 'update', 'check', 'manage', 'process', 'do']);
+const NEXTJS_DATA_FUNCTIONS = new Set(['getServerSideProps', 'getStaticProps', 'getStaticPaths']);
 const SUGGESTED_ALTERNATIVES = {
     get: ['fetch', 'retrieve', 'compute', 'derive'],
     update: ['modify', 'set', 'apply'],
@@ -38,6 +39,9 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             // Skip if method starts with 'is' (boolean check methods are okay)
             if (methodName.startsWith('is'))
                 return;
+            // Skip Next.js data-fetching functions
+            if (NEXTJS_DATA_FUNCTIONS.has(methodName))
+                return;
             // Extract first word from PascalCase/camelCase
             let firstWord = methodName;
             for (let i = 1; i < methodName.length; i++) {
@@ -79,6 +83,9 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             // Skip if function starts with 'is' (boolean check functions are okay)
             if (functionName.startsWith('is'))
                 return;
+            // Skip Next.js data-fetching functions
+            if (NEXTJS_DATA_FUNCTIONS.has(functionName))
+                return;
             // Extract first word from PascalCase/camelCase
             let firstWord = functionName;
             for (let i = 1; i < functionName.length; i++) {

package/lib/rules/sync-onwrite-name-func.d.ts

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