@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

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

@@ -3,7 +3,8 @@ 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 +39,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 +83,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;
                 }
@@ -91,15 +125,32 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                     fix(fixer) {
                         const fixes = [];
                         const sourceCode = context.sourceCode;
-                        const decoratorIdent = memoizeNamespace
-                            ? `${memoizeNamespace}.Memoize`
-                            : memoizeAlias;
+                        // 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]);

package/lib/rules/enforce-mui-rounded-icons.js

@@ -3,6 +3,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMuiRoundedIcons = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Non-Rounded MUI variant suffixes. An icon imported as one of these variants
+ * (e.g. `AddReactionOutlined`) maps to the Rounded variant of its BASE name
+ * (`AddReactionRounded`), not `AddReactionOutlinedRounded` (which doesn't exist).
+ * Matched exactly, so a distinct icon like `MailOutline` (ends in "Outline", not
+ * "Outlined") is left intact → `MailOutlineRounded`, which does exist.
+ */
+const VARIANT_SUFFIXES = ['Outlined', 'Sharp', 'TwoTone'];
+/**
+ * @mui/icons-material brand icons that ship in a single (Filled) variant only —
+ * they have no Rounded counterpart, so the rule must not demand one. Computed
+ * from @mui/icons-material (the only base icons lacking a `*Rounded` sibling).
+ */
+const ICONS_WITHOUT_ROUNDED = new Set([
+    'Apple',
+    'GitHub',
+    'Google',
+    'Instagram',
+    'LinkedIn',
+    'Microsoft',
+    'Pinterest',
+    'Reddit',
+    'Telegram',
+    'Twitter',
+    'WhatsApp',
+    'X',
+    'YouTube',
+]);
+/** Strips a trailing non-Rounded variant suffix to recover the base icon name. */
+const toBaseIconName = (iconName) => {
+    const suffix = VARIANT_SUFFIXES.find((variant) => iconName.endsWith(variant));
+    return suffix ? iconName.slice(0, -suffix.length) : iconName;
+};
 exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     name: 'enforce-mui-rounded-icons',
     meta: {
@@ -36,8 +69,16 @@ exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
                     if (!iconName) {
                         return;
                     }
+                    // Map a non-Rounded variant import to its base icon so the Rounded
+                    // suggestion/fix targets a name that actually exists.
+                    const baseIconName = toBaseIconName(iconName);
+                    // Brand icons have no Rounded variant — demanding one is a false
+                    // positive and the fix would point at a non-existent module.
+                    if (ICONS_WITHOUT_ROUNDED.has(baseIconName)) {
+                        return;
+                    }
                     // Create the rounded variant name
-                    const roundedVariant = `${iconName}Rounded`;
+                    const roundedVariant = `${baseIconName}Rounded`;
                     context.report({
                         node,
                         messageId: 'enforceRoundedVariant',

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`;
@@ -138,6 +162,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 return;
             }
             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'
@@ -174,6 +199,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
         function checkClassMethod(node) {
             const method = node.value;
             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-stable-hash-spread-props.js

@@ -31,12 +31,12 @@ function getFunctionName(node) {
     }
     return null;
 }
-function isProbablyComponent(node) {
+function isProbablyComponent(node, context) {
     const name = getFunctionName(node);
     if (name && /^[A-Z]/.test(name)) {
         return true;
     }
-    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body)) {
+    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context)) {
         return true;
     }
     return false;
@@ -236,7 +236,7 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
                 }
                 functionStack.push({
                     node,
-                    isComponent: isProbablyComponent(node),
+                    isComponent: isProbablyComponent(node, context),
                     restNames,
                     propsIdentifiers,
                 });

package/lib/rules/enforce-transform-memoization.js

@@ -8,7 +8,7 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce memoization of adaptValue transformValue/transformOnChange so the adapted component receives stable handlers and avoids unnecessary re-renders.',
+            description: 'Enforce memoization of transformValue and transformOnChange in adaptValue',
             recommended: 'error',
         },
         schema: [],