@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

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,56 @@ 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.sourceCode;
+                        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?.[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] ?? '';
+                        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,147 @@
+"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 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: [],
+    create(context) {
+        // Only apply in TS/TSX files to avoid JS environments without decorators
+        const filename = context.getFilename();
+        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))) {
+                    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;
+                            }
+                        }
+                    }
+                }
+            },
+            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;
+                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 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;
+                            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 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;
+                    },
+                });
+            },
+        };
+    },
+});
+exports.default = exports.enforceMemoizeGetters;
+//# sourceMappingURL=enforce-memoize-getters.js.map

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;
@@ -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-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

@@ -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',
@@ -844,14 +847,13 @@ const DIS_EXCEPTIONS = [
     'dismissal',
     'disk',
     'disks',
+    'dispute',
+    'disputed',
+    'disputes',
+    'disputing',
 ];
 // 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 +959,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 {};