@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

package/lib/rules/enforce-identifiable-firestore-type.js

@@ -5,8 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceIdentifiableFirestoreType = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../utils/createRule");
 const path_1 = __importDefault(require("path"));
+const createRule_1 = require("../utils/createRule");
+const TRANSPARENT_TYPE_NAMES = new Set(['Readonly', 'Resolve']);
 exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
     name: 'enforce-identifiable-firestore-type',
     meta: {
@@ -63,94 +64,143 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
             TSTypeAliasDeclaration(node) {
                 if (node.id.name === folderName) {
                     hasExpectedType = true;
-                    // Find Identifiable in type's dependencies
+                    const findTypeAliasAnnotation = (typeName) => {
+                        let scope = context.getScope();
+                        while (scope) {
+                            const variable = scope.variables.find((variableNode) => variableNode.name === typeName);
+                            if (variable) {
+                                const definition = variable.defs.find((definition) => definition.node.type ===
+                                    utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
+                                if (definition &&
+                                    definition.node.type ===
+                                        utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
+                                    definition.node.typeAnnotation) {
+                                    return definition.node.typeAnnotation;
+                                }
+                            }
+                            scope = scope.upper;
+                        }
+                        return null;
+                    };
+                    const isParenthesizedType = (node) => node?.type === 'TSParenthesizedType';
+                    const isReadonlyTypeOperator = (node) => node?.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                        node.operator === 'readonly';
+                    const unwrapTransparentType = (typeNode) => {
+                        let current = typeNode;
+                        while (current) {
+                            if (isParenthesizedType(current)) {
+                                const parenthesized = current;
+                                current = parenthesized.typeAnnotation ?? null;
+                                continue;
+                            }
+                            if (isReadonlyTypeOperator(current)) {
+                                current = current.typeAnnotation ?? null;
+                                continue;
+                            }
+                            break;
+                        }
+                        return current ?? null;
+                    };
                     const findIdentifiable = (type, checkedTypes = new Set()) => {
-                        if (!type)
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
                             return false;
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            type.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            const typeName = type.typeName.name;
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = resolvedType.typeName.name;
                             if (typeName === 'Identifiable') {
                                 return true;
                             }
-                            if (!checkedTypes.has(typeName)) {
-                                checkedTypes.add(typeName);
-                                // Look for the type in all scopes
-                                const scope = context.getScope();
-                                const variable = scope.variables.find((v) => v.name === typeName);
-                                if (variable) {
-                                    const def = variable.defs.find((d) => d.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
-                                    if (def &&
-                                        'typeAnnotation' in def.node &&
-                                        def.node.typeAnnotation) {
-                                        return findIdentifiable(def.node.typeAnnotation, checkedTypes);
-                                    }
-                                }
-                                // Try looking in the parent scope
-                                if (scope.upper) {
-                                    const parentVariable = scope.upper.variables.find((v) => v.name === typeName);
-                                    if (parentVariable) {
-                                        const def = parentVariable.defs.find((d) => d.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
-                                        if (def &&
-                                            'typeAnnotation' in def.node &&
-                                            def.node.typeAnnotation) {
-                                            return findIdentifiable(def.node.typeAnnotation, checkedTypes);
-                                        }
-                                    }
-                                }
+                            if (TRANSPARENT_TYPE_NAMES.has(typeName) &&
+                                resolvedType.typeParameters?.params?.some((param) => findIdentifiable(param, checkedTypes))) {
+                                return true;
+                            }
+                            if (checkedTypes.has(typeName)) {
+                                return false;
                             }
+                            checkedTypes.add(typeName);
+                            const aliasAnnotation = findTypeAliasAnnotation(typeName);
+                            return findIdentifiable(aliasAnnotation, checkedTypes);
                         }
-                        else if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            // For intersection types, check each part
-                            return type.types.some((part) => findIdentifiable(part, checkedTypes));
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => findIdentifiable(part, new Set(checkedTypes)));
                         }
                         return false;
                     };
-                    // Check if type extends Identifiable
-                    const checkIdentifiableExtension = (type) => {
-                        if (!type)
-                            return false;
-                        return findIdentifiable(type);
-                    };
                     // Check if type has id: string field
-                    const checkIdField = (type) => {
-                        // Check for id: string field in type literal
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
-                            return type.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                    const checkIdField = (type, visitedTypes = new Set()) => {
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
+                            return false;
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                            return resolvedType.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
                                 member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                                 member.key.name === 'id' &&
                                 member.typeAnnotation?.typeAnnotation.type ===
                                     utils_1.AST_NODE_TYPES.TSStringKeyword);
                         }
-                        // Check intersection types
-                        if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            return type.types.some(checkIdField);
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => checkIdField(part, new Set(visitedTypes)));
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                            if (resolvedType.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                                return false;
+                            }
+                            const typeName = resolvedType.typeName.name;
+                            if (typeName === 'Identifiable') {
+                                return true;
+                            }
+                            if (TRANSPARENT_TYPE_NAMES.has(typeName) &&
+                                resolvedType.typeParameters?.params?.some((param) => checkIdField(param, visitedTypes))) {
+                                return true;
+                            }
+                            if (visitedTypes.has(typeName)) {
+                                return false;
+                            }
+                            visitedTypes.add(typeName);
+                            const referencedType = findTypeAliasAnnotation(typeName);
+                            return checkIdField(referencedType, visitedTypes);
                         }
                         return false;
                     };
                     // Check if type is wrapped in a utility type
                     const isUtilityType = (type) => {
+                        if (!type) {
+                            return false;
+                        }
                         return (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                             type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                             type.typeName.name === 'Resolve');
                     };
                     // Recursively check the type and its parameters
-                    const checkType = (type) => {
-                        // Check if type extends Identifiable
-                        if (checkIdentifiableExtension(type)) {
+                    const checkType = (type, visitedTypes = new Set()) => {
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
+                            return false;
+                        }
+                        if (findIdentifiable(resolvedType)) {
                             return true;
                         }
-                        // Check if type has id: string field (only for utility types)
-                        if (isUtilityType(type) &&
-                            checkIdField(type.typeParameters.params[0])) {
+                        if (isUtilityType(resolvedType) &&
+                            resolvedType.typeParameters?.params?.[0] &&
+                            checkIdField(resolvedType.typeParameters.params[0])) {
                             return true;
                         }
-                        // Check if type is wrapped in a utility type
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            type.typeParameters?.params?.[0]) {
-                            return checkType(type.typeParameters.params[0]);
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = resolvedType.typeName.name;
+                            if (visitedTypes.has(typeName)) {
+                                return false;
+                            }
+                            visitedTypes.add(typeName);
+                            const aliasAnnotation = findTypeAliasAnnotation(typeName);
+                            return checkType(aliasAnnotation, visitedTypes);
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => checkType(part, new Set(visitedTypes)));
                         }
-                        // For direct type definitions, require extending Identifiable
                         return false;
                     };
                     typeHasIdentifiable = checkType(node.typeAnnotation);

package/lib/rules/enforce-memoize-async.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMemoizeAsync = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-const MEMOIZE_MODULE = 'typescript-memoize';
+const MEMOIZE_MODULE = '@blumintinc/typescript-memoize';
+const ALLOWED_MEMOIZE_MODULES = new Set([
+    MEMOIZE_MODULE,
+    'typescript-memoize',
+]);
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -38,33 +42,34 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters to cache results and prevent redundant API calls or expensive computations. This improves performance by reusing previous results when the same parameters are provided, particularly useful for data fetching methods.',
+            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters to cache results and prevent redundant API calls or expensive computations. Without memoization, repeated calls trigger redundant requests or expensive computations, increasing latency. @Memoize() caches results by parameter, ensuring subsequent calls with identical inputs return immediately.',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize() to cache results and improve performance. Instead of `async getData(id?: string)`, use `@Memoize()\nasync getData(id?: string)`. Import Memoize from "typescript-memoize".',
+            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize(). Without memoization, repeated calls trigger redundant network requests or expensive computations, increasing latency and risk of rate-limiting. @Memoize() caches results by parameter, ensuring subsequent calls with identical inputs return immediately. Fix: add @Memoize() above the method and import Memoize from "@blumintinc/typescript-memoize".',
         },
     },
     defaultOptions: [],
     create(context) {
         let hasMemoizeImport = false;
-        let memoizeAlias = 'Memoize';
-        let memoizeNamespace = null;
+        const memoizeAliases = new Map(); // alias -> source module
+        const memoizeNamespaces = new Map(); // namespace -> source module
         let scheduledImportFix = false;
         return {
             ImportDeclaration(node) {
-                if (node.source.value === MEMOIZE_MODULE) {
+                if (ALLOWED_MEMOIZE_MODULES.has(String(node.source.value))) {
                     node.specifiers.forEach((spec) => {
                         if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
                             spec.imported.name === 'Memoize') {
                             hasMemoizeImport = true;
-                            memoizeAlias = spec.local?.name ?? memoizeAlias;
+                            memoizeAliases.set(spec.local.name, String(node.source.value));
                         }
                         else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
                             hasMemoizeImport = true;
-                            memoizeNamespace = spec.local.name;
+                            memoizeNamespaces.set(spec.local.name, String(node.source.value));
                         }
                     });
                 }
@@ -81,7 +86,39 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                     return;
                 }
                 // Check if method already has @Memoize or @Memoize() decorator
-                const hasDecorator = node.decorators?.some((decorator) => isMemoizeDecorator(decorator, memoizeAlias));
+                const hasDecorator = node.decorators?.some((decorator) => {
+                    // If no named imports were found, we assume 'Memoize' is the intended name (for legacy/global support)
+                    const aliasesToCheck = memoizeAliases.size === 0
+                        ? ['Memoize']
+                        : Array.from(memoizeAliases.keys());
+                    // Check against all known aliases
+                    for (const alias of aliasesToCheck) {
+                        if (isMemoizeDecorator(decorator, alias)) {
+                            return true;
+                        }
+                    }
+                    // Also check against namespaces
+                    const expression = decorator.expression;
+                    if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        !expression.computed &&
+                        expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        expression.property.name === 'Memoize' &&
+                        expression.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        memoizeNamespaces.has(expression.object.name)) {
+                        return true;
+                    }
+                    // Handle namespace call: @ns.Memoize()
+                    if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        expression.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        !expression.callee.computed &&
+                        expression.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        expression.callee.property.name === 'Memoize' &&
+                        expression.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        memoizeNamespaces.has(expression.callee.object.name)) {
+                        return true;
+                    }
+                    return false;
+                });
                 if (hasDecorator) {
                     return;
                 }
@@ -90,16 +127,33 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                     messageId: 'requireMemoize',
                     fix(fixer) {
                         const fixes = [];
-                        const sourceCode = context.getSourceCode();
-                        const decoratorIdent = memoizeNamespace
-                            ? `${memoizeNamespace}.Memoize`
-                            : memoizeAlias;
+                        const sourceCode = context.sourceCode;
+                        // Determine which identifier to use for the decorator
+                        let decoratorIdent = 'Memoize';
+                        if (hasMemoizeImport) {
+                            // Prefer 'Memoize' from the new package if available
+                            if (memoizeAliases.has('Memoize') &&
+                                memoizeAliases.get('Memoize') === MEMOIZE_MODULE) {
+                                decoratorIdent = 'Memoize';
+                            }
+                            else if (memoizeAliases.size > 0) {
+                                // Find first alias from new package, fallback to any alias
+                                const newPackageAlias = Array.from(memoizeAliases.entries()).find(([_, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
+                                decoratorIdent =
+                                    newPackageAlias || Array.from(memoizeAliases.keys())[0];
+                            }
+                            else if (memoizeNamespaces.size > 0) {
+                                // Prefer namespace from the new package if available
+                                const newPackageNs = Array.from(memoizeNamespaces.entries()).find(([_, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
+                                const selectedNs = newPackageNs || Array.from(memoizeNamespaces.keys())[0];
+                                decoratorIdent = `${selectedNs}.Memoize`;
+                            }
+                        }
                         const importStatement = `import { Memoize } from '${MEMOIZE_MODULE}';`;
                         // Add import if it's not already present; ensure we only add once per file
                         if (!hasMemoizeImport &&
-                            !memoizeNamespace &&
-                            !scheduledImportFix &&
-                            !sourceCode.text.includes(importStatement)) {
+                            memoizeNamespaces.size === 0 &&
+                            !scheduledImportFix) {
                             const programBody = sourceCode.ast.body;
                             const firstImport = programBody.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
                             const anchorNode = (firstImport ?? programBody[0]);
@@ -122,11 +176,7 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                         const insertionTarget = node.decorators && node.decorators.length > 0
                             ? node.decorators[0]
                             : node;
-                        const insertionStart = insertionTarget.range
-                            ? insertionTarget.range[0]
-                            : node.range
-                                ? node.range[0]
-                                : 0;
+                        const insertionStart = insertionTarget.range?.[0] ?? node.range?.[0] ?? 0;
                         const text = sourceCode.text;
                         const lineStart = text.lastIndexOf('\n', insertionStart - 1) + 1;
                         const leadingWhitespace = text.slice(lineStart, insertionStart).match(/^[ \t]*/)?.[0] ?? '';

package/lib/rules/enforce-memoize-getters.js

@@ -42,7 +42,7 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            requireMemoizeGetter: 'Private getters should be decorated with @Memoize() to preserve instance state and avoid redundant instantiation. Import Memoize from "@blumintinc/typescript-memoize".',
+            requireMemoizeGetter: 'Private getter "{{name}}" should use @Memoize() so repeated accesses reuse the same instance instead of re-instantiating and losing internal state. Add @Memoize() and import Memoize from "@blumintinc/typescript-memoize" to avoid redundant setup work.',
         },
     },
     defaultOptions: [],
@@ -52,17 +52,28 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
         if (!/\.tsx?$/i.test(filename)) {
             return {};
         }
+        const sourceCode = context.getSourceCode();
         let hasMemoizeImport = false;
         let memoizeAlias = 'Memoize';
+        let memoizeNamespace = null;
+        let hasNamedImport = false;
         let scheduledImportFix = false;
         return {
             ImportDeclaration(node) {
                 if (MEMOIZE_MODULES.has(String(node.source.value))) {
-                    const spec = node.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                        s.imported.name === 'Memoize');
-                    if (spec) {
-                        hasMemoizeImport = true;
-                        memoizeAlias = spec.local?.name ?? 'Memoize';
+                    for (const spec of node.specifiers) {
+                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.name === 'Memoize') {
+                            hasMemoizeImport = true;
+                            hasNamedImport = true;
+                            memoizeAlias = spec.local.name;
+                        }
+                        else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                            hasMemoizeImport = true;
+                            if (!hasNamedImport) {
+                                memoizeNamespace = spec.local.name;
+                            }
+                        }
                     }
                 }
             },
@@ -76,16 +87,29 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                 // enforce only "private" accessibility (undefined => public)
                 if (node.accessibility !== 'private')
                     return;
-                // Already memoized?
-                const hasDecorator = node.decorators?.some((d) => isMemoizeDecorator(d, memoizeAlias));
+                const decoratorAliases = memoizeAlias === 'Memoize' ? ['Memoize'] : ['Memoize', memoizeAlias];
+                const hasDecorator = node.decorators?.some((decorator) => decoratorAliases.some((alias) => isMemoizeDecorator(decorator, alias)));
                 if (hasDecorator)
                     return;
+                const propertyName = node.computed
+                    ? '[computed]'
+                    : sourceCode.getText(node.key);
                 context.report({
                     node,
                     messageId: 'requireMemoizeGetter',
+                    data: { name: propertyName },
                     fix(fixer) {
                         const fixes = [];
-                        const sourceCode = context.getSourceCode();
+                        const getDecoratorIdent = () => {
+                            if (hasNamedImport) {
+                                return memoizeAlias;
+                            }
+                            if (memoizeNamespace) {
+                                return `${memoizeNamespace}.Memoize`;
+                            }
+                            return memoizeAlias;
+                        };
+                        const decoratorIdent = getDecoratorIdent();
                         // Insert import if needed, at the top alongside other imports
                         if (!hasMemoizeImport && !scheduledImportFix) {
                             const programBody = sourceCode.ast.body;
@@ -106,12 +130,12 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                             scheduledImportFix = true;
                         }
                         // Insert decorator above the getter (or before the first decorator), preserving indentation
-                        const indent = ' '.repeat(node.loc.start.column);
-                        const lineStart = node.range
-                            ? sourceCode.text.lastIndexOf('\n', node.range[0] - 1) + 1
-                            : 0;
-                        const insertPosition = Math.max(0, lineStart);
-                        fixes.push(fixer.insertTextBeforeRange([insertPosition, insertPosition], `${indent}@${memoizeAlias}()\n`));
+                        const insertionTarget = node.decorators?.[0] ?? node;
+                        const insertionStart = insertionTarget.range[0];
+                        const text = sourceCode.text;
+                        const lineStart = text.lastIndexOf('\n', insertionStart - 1) + 1;
+                        const leadingWhitespace = text.slice(lineStart, insertionStart).match(/^[ \t]*/)?.[0] ?? '';
+                        fixes.push(fixer.insertTextBeforeRange([lineStart, lineStart], `${leadingWhitespace}@${decoratorIdent}()\n`));
                         return fixes;
                     },
                 });

package/lib/rules/enforce-microdiff.js

@@ -20,7 +20,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         const importedDiffLibraries = new Map();
         const importedFunctions = new Map(); // Map of imported function names to their sources
         let hasMicrodiffImport = false;

package/lib/rules/enforce-object-literal-as-const.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceObjectLiteralAsConst = void 0;
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
     name: 'enforce-object-literal-as-const',
     meta: {
@@ -55,10 +56,9 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
                     return;
                 }
                 // Check if the return statement is inside a function
-                const sourceCode = context.getSourceCode();
-                // Use context.getAncestors() for now, but note it's deprecated
-                // We'll need to update this when upgrading to ESLint v9
-                const ancestors = context.getAncestors();
+                const sourceCode = context.sourceCode;
+                // Use ASTHelpers.getAncestors for ESLint v8/v9 compatibility
+                const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, node);
                 const isInFunction = ancestors.some((ancestor) => ancestor.type === 'FunctionDeclaration' ||
                     ancestor.type === 'ArrowFunctionExpression' ||
                     ancestor.type === 'FunctionExpression' ||

package/lib/rules/enforce-positive-naming.js

@@ -847,6 +847,10 @@ const DIS_EXCEPTIONS = [
     'dismissal',
     'disk',
     'disks',
+    'dispute',
+    'disputed',
+    'disputes',
+    'disputing',
 ];
 // Words that contain negative prefixes but should be treated as valid
 const EXCEPTION_WORDS_SET = new Set([...IN_EXCEPTIONS, ...NO_EXCEPTIONS, ...UN_EXCEPTIONS, ...DIS_EXCEPTIONS].map((word) => word.toLowerCase()));

package/lib/rules/enforce-props-argument-name.js

@@ -34,14 +34,48 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
         function endsWithProps(typeName) {
             return typeName.endsWith('Props');
         }
+        // Get all parameters that have a "Props" type
+        function getPropsParams(params) {
+            return params
+                .map((param) => {
+                const id = getIdFromParam(param);
+                if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
+                    const paramTypeName = getTypeName(id.typeAnnotation.typeAnnotation);
+                    if (paramTypeName && endsWithProps(paramTypeName)) {
+                        return { id, typeName: paramTypeName };
+                    }
+                }
+                return null;
+            })
+                .filter((p) => !!p);
+        }
         // Generate suggested parameter name for Props types
-        function getSuggestedParameterName(typeName, allParams, currentParam) {
+        function getSuggestedParameterName(typeName, allParams, currentParam, propsParams) {
             const currentId = getIdFromParam(currentParam);
             const currentName = currentId?.name;
             const existingNames = new Set(allParams
                 .map((p) => getIdFromParam(p))
                 .filter((id) => !!id && id.name !== currentName)
                 .map((id) => id.name));
+            // If multiple parameters have the exact same Props type, allow the current names.
+            // This handles cases like (prevProps: TProps, nextProps: TProps) where
+            // forcing a single name based on the type would cause a collision or
+            // break descriptive naming.
+            const sameTypeParams = propsParams.filter((p) => p.typeName === typeName);
+            if (sameTypeParams.length > 1) {
+                // Keep the current name when multiple params share the same Props type.
+                // This preserves descriptive names like prevProps/nextProps.
+                if (!currentName) {
+                    // Fallback should not occur since destructured params are filtered upstream.
+                    let candidate = 'props';
+                    let suffix = 2;
+                    while (existingNames.has(candidate)) {
+                        candidate = `props${suffix++}`;
+                    }
+                    return candidate;
+                }
+                return currentName;
+            }
             if (typeName === 'Props') {
                 let candidate = 'props';
                 let suffix = 2;
@@ -50,17 +84,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
                 return candidate;
             }
-            // Count how many parameters have Props types
-            const propsParams = allParams.filter((param) => {
-                if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    param.typeAnnotation &&
-                    param.typeAnnotation.typeAnnotation) {
-                    const paramTypeName = getTypeName(param.typeAnnotation.typeAnnotation);
-                    return paramTypeName && endsWithProps(paramTypeName);
-                }
-                return false;
-            });
-            // If there's only one Props parameter, suggest "props"
+            // If there's only one Props parameter (regardless of type name), suggest "props"
             if (propsParams.length <= 1) {
                 let candidate = 'props';
                 let suffix = 2;
@@ -69,8 +93,8 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
                 return candidate;
             }
-            // If there are multiple Props parameters, use prefixed names
-            // For types like "UserProps", suggest "userProps"
+            // If there are multiple Props parameters with different types, use prefixed names.
+            // For types like "UserProps", suggest "userProps".
             const baseName = typeName.slice(0, -5); // Remove "Props"
             const camelCaseBase = baseName.charAt(0).toLowerCase() + baseName.slice(1);
             let candidate = `${camelCaseBase}Props`;
@@ -137,7 +161,8 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
                 return;
             }
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
+            const propsParams = getPropsParams(node.params);
             node.params.forEach((param) => {
                 if (isDestructuredParameter(param)) {
                     return;
@@ -146,7 +171,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
                     const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
                     if (typeName && endsWithProps(typeName)) {
-                        const suggestedName = getSuggestedParameterName(typeName, node.params, param);
+                        const suggestedName = getSuggestedParameterName(typeName, node.params, param, propsParams);
                         if (id.name !== suggestedName) {
                             const messageId = suggestedName === 'props'
                                 ? 'usePropsParameterName'
@@ -173,7 +198,8 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
         // Check class method parameters (including constructors)
         function checkClassMethod(node) {
             const method = node.value;
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
+            const propsParams = getPropsParams(method.params);
             method.params.forEach((param) => {
                 if (isDestructuredParameter(param)) {
                     return;
@@ -182,7 +208,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
                     const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
                     if (typeName && endsWithProps(typeName)) {
-                        const suggestedName = getSuggestedParameterName(typeName, method.params, param);
+                        const suggestedName = getSuggestedParameterName(typeName, method.params, param, propsParams);
                         if (id.name !== suggestedName) {
                             const messageId = suggestedName === 'props'
                                 ? 'usePropsParameterName'

package/lib/rules/enforce-safe-stringify.js

@@ -40,7 +40,7 @@ exports.enforceStableStringify = (0, createRule_1.createRule)({
                             const fixes = [];
                             // Add import if not present
                             if (!hasStringifyImport) {
-                                const program = context.getSourceCode().ast;
+                                const program = context.sourceCode.ast;
                                 const firstImport = program.body.find((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
                                 const importStatement = "import stringify from 'safe-stable-stringify';\n";
                                 if (firstImport) {