@blumintinc/eslint-plugin-blumint 1.12.6 → 1.13.0

package/lib/rules/enforce-global-constants.d.ts

@@ -1 +1,4 @@
-export declare const enforceGlobalConstants: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useGlobalConstant", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'useGlobalConstant' | 'extractDefaultToGlobalConstant';
+export declare const enforceGlobalConstants: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
+export {};

package/lib/rules/enforce-global-constants.js

@@ -3,48 +3,250 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceGlobalConstants = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.enforceGlobalConstants = (0, createRule_1.createRule)({
     name: 'enforce-global-constants',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals',
+            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals, and extract inline destructuring defaults in React components/hooks to global constants',
             recommended: 'error',
         },
+        fixable: 'code',
         schema: [],
         messages: {
             useGlobalConstant: 'Use a global static constant instead of useMemo with an empty dependency array for object literals',
+            extractDefaultToGlobalConstant: 'Extract inline default value to a module-level constant for stable reference',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        function isHookName(name) {
+            return /^use[A-Z]/.test(name);
+        }
+        function isComponentOrHookFunction(fn) {
+            if (fn.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                const n = fn.id?.name ?? '';
+                return /^[A-Z]/.test(n) || isHookName(n);
+            }
+            const parent = fn.parent;
+            if (parent &&
+                parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const n = parent.id.name;
+                return /^[A-Z]/.test(n) || isHookName(n);
+            }
+            return false;
+        }
+        function getEnclosingFunction(node) {
+            let current = node;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    return current;
+                }
+                current = current.parent;
+            }
+            return null;
+        }
+        function toUpperSnakeCase(name) {
+            return name
+                .replace(/([A-Z])/g, '_$1')
+                .toUpperCase()
+                .replace(/^_/, '');
+        }
+        function collectAssignmentDefaultsFromPattern(pattern) {
+            const results = [];
+            const visitPattern = (p) => {
+                if (p.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    for (const prop of p.properties) {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            const value = prop.value;
+                            if (value &&
+                                value.type ===
+                                    utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                                const assign = value;
+                                const left = assign.left;
+                                if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    results.push({ assignment: assign, localName: left.name });
+                                }
+                                if (left.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                                    left.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                                    // Nested pattern on the left of an assignment; uncommon, ignore naming
+                                }
+                            }
+                            else if (value &&
+                                value
+                                    .type &&
+                                (value
+                                    .type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                                    value
+                                        .type === utils_1.AST_NODE_TYPES.ArrayPattern)) {
+                                visitPattern(value);
+                            }
+                        }
+                    }
+                }
+                else if (p.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                    for (const elem of p.elements) {
+                        if (!elem)
+                            continue;
+                        if (elem.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                            const left = elem.left;
+                            if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                results.push({ assignment: elem, localName: left.name });
+                            }
+                        }
+                        else if (elem.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+                            elem.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                            visitPattern(elem);
+                        }
+                    }
+                }
+                else if (p.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    const left = p.left;
+                    if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        results.push({ assignment: p, localName: left.name });
+                    }
+                }
+            };
+            visitPattern(pattern);
+            return results;
+        }
+        function hasIdentifiers(node) {
+            return !!node && ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(node);
+        }
+        function alreadyHasConst(program, constName) {
+            for (const stmt of program.body) {
+                if (stmt.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+                    stmt.kind === 'const') {
+                    for (const d of stmt.declarations) {
+                        if (d.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            d.id.name === constName) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        function buildConstDeclarationLine(constName, initText) {
+            const needsAsConst = /^(?:true|false|-?\d|\[|\{|[`'"])/.test(initText) &&
+                !/\bas const\b/.test(initText);
+            const initializer = needsAsConst ? `${initText} as const` : initText;
+            return `const ${constName} = ${initializer};`;
+        }
+        function reportStaticDefaults(patterns, enclosingFn, nodeForReport) {
+            if (!enclosingFn || !isComponentOrHookFunction(enclosingFn))
+                return;
+            const defaults = [];
+            for (const pattern of patterns) {
+                defaults.push(...collectAssignmentDefaultsFromPattern(pattern));
+            }
+            if (defaults.length === 0)
+                return;
+            const staticDefaults = defaults.filter((def) => {
+                const right = def.assignment.right;
+                return right && !hasIdentifiers(right);
+            });
+            if (staticDefaults.length === 0)
+                return;
+            context.report({
+                node: nodeForReport,
+                messageId: 'extractDefaultToGlobalConstant',
+                fix(fixer) {
+                    const fixes = [];
+                    const programNode = sourceCode.ast;
+                    const declLines = [];
+                    for (const def of staticDefaults) {
+                        const { assignment, localName } = def;
+                        const right = assignment.right;
+                        const rightText = sourceCode.getText(right);
+                        const constName = `DEFAULT_${toUpperSnakeCase(localName)}`;
+                        if (!alreadyHasConst(programNode, constName)) {
+                            declLines.push(buildConstDeclarationLine(constName, rightText));
+                        }
+                        fixes.push(fixer.replaceText(right, constName));
+                    }
+                    if (declLines.length > 0) {
+                        const program = sourceCode.ast;
+                        const constSection = declLines.length === 1
+                            ? declLines[0]
+                            : `${declLines[0]}\n\n${declLines.slice(1).join('\n')}`;
+                        const text = sourceCode.text;
+                        const findNextNonWhitespace = (start) => {
+                            let idx = start;
+                            while (idx < text.length && /\s/.test(text[idx])) {
+                                idx += 1;
+                            }
+                            return idx;
+                        };
+                        const buildBlock = (extraSpacing, insertPos, nextPos) => {
+                            const whitespace = text.slice(insertPos, nextPos);
+                            const lastNewline = whitespace.lastIndexOf('\n');
+                            const nextIndentRaw = lastNewline === -1
+                                ? ''
+                                : whitespace.slice(lastNewline + 1).replace(/[^\t ]/g, '');
+                            const separator = extraSpacing ? '\n\n\n' : '\n\n';
+                            const nextIndent = extraSpacing ? nextIndentRaw : '';
+                            return `\n${constSection}${separator}${nextIndent}`;
+                        };
+                        const imports = program.body.filter((s) => s.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                        if (imports.length > 0) {
+                            const lastImport = imports[imports.length - 1];
+                            const insertPos = lastImport.range[1];
+                            const nextPos = findNextNonWhitespace(insertPos);
+                            fixes.push(fixer.replaceTextRange([insertPos, nextPos], buildBlock(false, insertPos, nextPos)));
+                        }
+                        else {
+                            const body = program.body;
+                            let insertPos = 0;
+                            let afterDirectiveIdx = -1;
+                            for (let i = 0; i < body.length; i++) {
+                                const stmt = body[i];
+                                if (stmt.type === utils_1.AST_NODE_TYPES.ExpressionStatement &&
+                                    stmt.expression.type === utils_1.AST_NODE_TYPES.Literal &&
+                                    typeof stmt.expression.value === 'string') {
+                                    afterDirectiveIdx = i;
+                                }
+                                else {
+                                    break;
+                                }
+                            }
+                            if (afterDirectiveIdx >= 0) {
+                                insertPos = body[afterDirectiveIdx].range[1];
+                            }
+                            const nextPos = findNextNonWhitespace(insertPos);
+                            fixes.push(fixer.replaceTextRange([insertPos, nextPos], buildBlock(afterDirectiveIdx < 0, insertPos, nextPos)));
+                        }
+                    }
+                    return fixes;
+                },
+            });
+        }
         return {
             CallExpression(node) {
-                // Check if it's a useMemo call
                 if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier ||
                     node.callee.name !== 'useMemo') {
                     return;
                 }
-                // Check if it has exactly two arguments
                 if (node.arguments.length !== 2) {
                     return;
                 }
-                // Check if the second argument is an empty array
                 const depsArray = node.arguments[1];
                 if (depsArray.type !== utils_1.AST_NODE_TYPES.ArrayExpression ||
                     depsArray.elements.length !== 0) {
                     return;
                 }
-                // Check if the first argument is an arrow function
                 const callback = node.arguments[0];
-                if (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                if (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                    callback.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
                     return;
                 }
-                // Check if the arrow function body is a block statement with a return statement
-                // or a direct expression (implicit return)
                 let returnValue = null;
                 if (callback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                    // If it's a block, find the return statement
                     const returnStatement = callback.body.body.find((stmt) => stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement);
                     if (!returnStatement || !returnStatement.argument) {
                         return;
@@ -52,15 +254,12 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
                     returnValue = returnStatement.argument;
                 }
                 else {
-                    // If it's an expression (implicit return)
                     returnValue = callback.body;
                 }
-                // Handle 'as const' type assertions
                 let actualReturnValue = returnValue;
                 if (returnValue.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
                     actualReturnValue = returnValue.expression;
                 }
-                // Check if the return value is an object literal or an array of object literals
                 if (actualReturnValue.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
                     (actualReturnValue.type === utils_1.AST_NODE_TYPES.ArrayExpression &&
                         actualReturnValue.elements.some((element) => element !== null &&
@@ -71,6 +270,35 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
                     });
                 }
             },
+            VariableDeclaration(node) {
+                const relevantDeclarators = node.declarations.filter((d) => d.id.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    d.id.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (relevantDeclarators.length === 0)
+                    return;
+                const enclosingFn = getEnclosingFunction(node);
+                reportStaticDefaults(relevantDeclarators.map((d) => d.id), enclosingFn, node);
+            },
+            FunctionDeclaration(node) {
+                const patterns = node.params.filter((p) => p.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    p.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (patterns.length === 0)
+                    return;
+                reportStaticDefaults(patterns, node, node);
+            },
+            FunctionExpression(node) {
+                const patterns = node.params.filter((p) => p.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    p.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (patterns.length === 0)
+                    return;
+                reportStaticDefaults(patterns, node, node);
+            },
+            ArrowFunctionExpression(node) {
+                const patterns = node.params.filter((p) => p.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    p.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (patterns.length === 0)
+                    return;
+                reportStaticDefaults(patterns, node, node);
+            },
         };
     },
 });

package/lib/rules/enforce-memoize-async.d.ts

@@ -1 +1,2 @@
-export declare const enforceMemoizeAsync: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireMemoize", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceMemoizeAsync: TSESLint.RuleModule<"requireMemoize", [], TSESLint.RuleListener>;

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

@@ -3,6 +3,36 @@ 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';
+/**
+ * Matches a memoize decorator in supported syntaxes:
+ * - @Alias()
+ * - @Alias
+ * - @ns.Alias
+ */
+function isMemoizeDecorator(decorator, alias) {
+    const expression = decorator.expression;
+    /* @Alias() */
+    if (expression.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        const callee = expression.callee;
+        return ((callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === alias) ||
+            (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.property.name === alias));
+    }
+    /* @Alias */
+    if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return expression.name === alias;
+    }
+    /* @ns.Alias */
+    if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !expression.computed &&
+        expression.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return expression.property.name === alias;
+    }
+    return false;
+}
 exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
     name: 'enforce-memoize-async',
     meta: {
@@ -21,17 +51,22 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
     create(context) {
         let hasMemoizeImport = false;
         let memoizeAlias = 'Memoize';
+        let memoizeNamespace = null;
+        let scheduledImportFix = false;
         return {
             ImportDeclaration(node) {
-                if (node.source.value === 'typescript-memoize') {
-                    const memoizeSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                        spec.imported.name === 'Memoize');
-                    if (memoizeSpecifier) {
-                        hasMemoizeImport = true;
-                        if (memoizeSpecifier.local) {
-                            memoizeAlias = memoizeSpecifier.local.name;
+                if (node.source.value === MEMOIZE_MODULE) {
+                    node.specifiers.forEach((spec) => {
+                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.name === 'Memoize') {
+                            hasMemoizeImport = true;
+                            memoizeAlias = spec.local?.name ?? memoizeAlias;
                         }
-                    }
+                        else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                            hasMemoizeImport = true;
+                            memoizeNamespace = spec.local.name;
+                        }
+                    });
                 }
             },
             MethodDefinition(node) {
@@ -45,26 +80,60 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (node.value.params.length > 1) {
                     return;
                 }
-                // Check if method already has @Memoize decorator
-                const hasDecorator = node.decorators?.some((decorator) => {
-                    if (decorator.expression.type !== utils_1.AST_NODE_TYPES.CallExpression) {
-                        return false;
-                    }
-                    const callee = decorator.expression.callee;
-                    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        callee.name === memoizeAlias);
-                });
-                if (!hasDecorator && hasMemoizeImport) {
-                    context.report({
-                        node,
-                        messageId: 'requireMemoize',
-                        fix(fixer) {
-                            // Add import if needed
-                            // Add decorator
-                            return fixer.insertTextBefore(node, `@${memoizeAlias}()\n${' '.repeat(node.loc.start.column)}`);
-                        },
-                    });
+                // Check if method already has @Memoize or @Memoize() decorator
+                const hasDecorator = node.decorators?.some((decorator) => isMemoizeDecorator(decorator, memoizeAlias));
+                if (hasDecorator) {
+                    return;
                 }
+                context.report({
+                    node,
+                    messageId: 'requireMemoize',
+                    fix(fixer) {
+                        const fixes = [];
+                        const sourceCode = context.getSourceCode();
+                        const decoratorIdent = memoizeNamespace
+                            ? `${memoizeNamespace}.Memoize`
+                            : memoizeAlias;
+                        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)) {
+                            const programBody = sourceCode.ast.body;
+                            const firstImport = programBody.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                            const anchorNode = (firstImport ?? programBody[0]);
+                            if (anchorNode) {
+                                const text = sourceCode.text;
+                                const anchorStart = anchorNode.range[0];
+                                const lineStart = text.lastIndexOf('\n', anchorStart - 1) + 1;
+                                const leadingWhitespace = text.slice(lineStart, anchorStart).match(/^[ \t]*/)?.[0] ??
+                                    '';
+                                const importLine = `${leadingWhitespace}${importStatement}\n`;
+                                fixes.push(fixer.insertTextBeforeRange([lineStart, lineStart], importLine));
+                            }
+                            else {
+                                // Fallback: empty file
+                                fixes.push(fixer.insertTextBeforeRange([0, 0], `import { Memoize } from '${MEMOIZE_MODULE}';\n`));
+                            }
+                            scheduledImportFix = true;
+                        }
+                        // Add decorator for this method
+                        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 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-memoize-getters.d.ts

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

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceMemoizeGetters = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const MEMOIZE_PREFERRED_MODULE = '@blumintinc/typescript-memoize';
+const MEMOIZE_MODULES = new Set([
+    MEMOIZE_PREFERRED_MODULE,
+    'typescript-memoize',
+]);
+function isMemoizeDecorator(decorator, alias) {
+    const expression = decorator.expression;
+    // @Alias()
+    if (expression.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        const callee = expression.callee;
+        return ((callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === alias) ||
+            (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.property.name === alias));
+    }
+    // @Alias
+    if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return expression.name === alias;
+    }
+    // @ns.Alias
+    if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !expression.computed &&
+        expression.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return expression.property.name === alias;
+    }
+    return false;
+}
+exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
+    name: 'enforce-memoize-getters',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce @Memoize() decorator on private class getters to avoid re-instantiation and preserve state across accesses.',
+            recommended: 'error',
+        },
+        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".',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Only apply in TS/TSX files to avoid JS environments without decorators
+        const filename = context.getFilename();
+        if (!/\.tsx?$/i.test(filename)) {
+            return {};
+        }
+        let hasMemoizeImport = false;
+        let memoizeAlias = 'Memoize';
+        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';
+                    }
+                }
+            },
+            MethodDefinition(node) {
+                // Target: instance private getters
+                if (node.kind !== 'get')
+                    return;
+                // skip static getters
+                if (node.static)
+                    return;
+                // enforce only "private" accessibility (undefined => public)
+                if (node.accessibility !== 'private')
+                    return;
+                // Already memoized?
+                const hasDecorator = node.decorators?.some((d) => isMemoizeDecorator(d, memoizeAlias));
+                if (hasDecorator)
+                    return;
+                context.report({
+                    node,
+                    messageId: 'requireMemoizeGetter',
+                    fix(fixer) {
+                        const fixes = [];
+                        const sourceCode = context.getSourceCode();
+                        // Insert import if needed, at the top alongside other imports
+                        if (!hasMemoizeImport && !scheduledImportFix) {
+                            const programBody = sourceCode.ast.body;
+                            const firstImport = programBody.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                            const anchorNode = (firstImport ?? programBody[0]);
+                            if (anchorNode) {
+                                const text = sourceCode.text;
+                                const anchorStart = anchorNode.range[0];
+                                const lineStart = text.lastIndexOf('\n', anchorStart - 1) + 1;
+                                const leadingWhitespace = text.slice(lineStart, anchorStart).match(/^[ \t]*/)?.[0] ??
+                                    '';
+                                const importLine = `${leadingWhitespace}import { Memoize } from '${MEMOIZE_PREFERRED_MODULE}';\n`;
+                                fixes.push(fixer.insertTextBeforeRange([lineStart, lineStart], importLine));
+                            }
+                            else {
+                                fixes.push(fixer.insertTextBeforeRange([0, 0], `import { Memoize } from '${MEMOIZE_PREFERRED_MODULE}';\n`));
+                            }
+                            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`));
+                        return fixes;
+                    },
+                });
+            },
+        };
+    },
+});
+exports.default = exports.enforceMemoizeGetters;
+//# sourceMappingURL=enforce-memoize-getters.js.map

package/lib/rules/enforce-microdiff.js

@@ -144,7 +144,8 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                         // Get the source of the imported function
                         const importSource = importedFunctions.get(name);
                         // Skip reporting if it's from fast-deep-equal
-                        if (importSource === 'fast-deep-equal' || importSource === 'fast-deep-equal/es6') {
+                        if (importSource === 'fast-deep-equal' ||
+                            importSource === 'fast-deep-equal/es6') {
                             return;
                         }
                         // Report it if it's from any other tracked library

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

@@ -333,6 +333,7 @@ const IN_EXCEPTIONS = [
     'insurgents',
     'insurrection',
     'intake',
+    'integer',
     'integers',
     'intel',
     'intellect',
@@ -424,6 +425,8 @@ const IN_EXCEPTIONS = [
     'interruptions',
     'interrupts',
     'intersect',
+    'intersected',
+    'intersecting',
     'intersection',
     'intersections',
     'interspersed',
@@ -846,12 +849,7 @@ const DIS_EXCEPTIONS = [
     'disks',
 ];
 // Words that contain negative prefixes but should be treated as valid
-const EXCEPTION_WORDS = [
-    ...IN_EXCEPTIONS,
-    ...NO_EXCEPTIONS,
-    ...UN_EXCEPTIONS,
-    ...DIS_EXCEPTIONS,
-];
+const EXCEPTION_WORDS_SET = new Set([...IN_EXCEPTIONS, ...NO_EXCEPTIONS, ...UN_EXCEPTIONS, ...DIS_EXCEPTIONS].map((word) => word.toLowerCase()));
 /**
  * Splits a variable name into individual words based on naming conventions:
  * - camelCase or PascalCase: split on uppercase letters
@@ -957,7 +955,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // Make sure words[1] exists before trying to access it
             if (words.length > 1) {
                 const secondWord = words[1].toLowerCase();
-                if (EXCEPTION_WORDS.some((exception) => secondWord === exception.toLowerCase())) {
+                if (EXCEPTION_WORDS_SET.has(secondWord)) {
                     return { isNegative: false, alternatives: [] };
                 }
             }

package/lib/rules/enforce-props-argument-name.d.ts

@@ -1,8 +1,3 @@
-type Options = [
-    {
-        enforceDestructuring?: boolean;
-        ignoreExternalInterfaces?: boolean;
-    }
-];
-export declare const enforcePropsArgumentName: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"usePropsForType", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+type MessageIds = 'usePropsParameterName' | 'usePropsParameterNameWithPrefix';
+export declare const enforcePropsArgumentName: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export {};