@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/no-uuidv4-base62-as-key.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUuidv4Base62AsKey = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
     name: 'no-uuidv4-base62-as-key',
     meta: {
@@ -13,13 +14,13 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            noUuidv4Base62AsKey: 'Do not use uuidv4Base62() to generate keys for elements in a list or loop. ' +
-                'These keys are not stable across renders and can cause performance issues. ' +
-                'Use a stable identifier from your data instead.',
+            noUuidv4Base62AsKey: 'Key "{{keyExpression}}" comes from uuidv4Base62(), which regenerates on every render so React cannot reconcile list items and may remount components, drop local state, or reorder DOM nodes. ' +
+                'Use a stable identifier from your data (for example a database id, slug, or memoized array of ids) instead of generating a new UUID inside render.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.sourceCode;
         // Track imported uuidv4Base62 identifiers
         const importedUuidv4Base62 = new Set();
         // Track elements that we've already reported to avoid duplicate reports
@@ -31,14 +32,18 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
         // Flag to indicate we've seen the itemKeys pattern
         let hasPreGeneratedKeys = false;
         // Helper function to report a rule violation while avoiding duplicates
-        function reportViolation(node, messageId = 'noUuidv4Base62AsKey') {
+        function reportViolation(node, keyExpression, messageId = 'noUuidv4Base62AsKey') {
             // Skip if we've already reported this element
             if (reportedElements.has(node))
                 return;
             reportedElements.add(node);
+            const keyExpressionText = keyExpression
+                ? sourceCode.getText(keyExpression).trim()
+                : 'uuidv4Base62()';
             context.report({
                 node,
                 messageId,
+                data: { keyExpression: keyExpressionText },
             });
         }
         // Helper to check if a node is a call to uuidv4Base62()
@@ -117,7 +122,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                     const { expression } = attr.value;
                     // Direct uuidv4Base62() call in key
                     if (containsUuidV4Base62Call(expression)) {
-                        reportViolation(jsxElement);
+                        reportViolation(jsxElement, expression);
                         return;
                     }
                     // Check for member expressions (item.key pattern)
@@ -128,12 +133,12 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                         const objName = expression.object.name;
                         // Check if this variable has been marked as containing keys with uuidv4Base62
                         if (variablesWithUuidv4Base62Keys.has(objName)) {
-                            reportViolation(jsxElement);
+                            reportViolation(jsxElement, expression);
                             return;
                         }
                         // Special case for the failing 'itemKeys' test
                         if (hasPreGeneratedKeys) {
-                            const ancestors = context.getAncestors();
+                            const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, jsxElement);
                             // Check if we're inside a map callback
                             for (let i = ancestors.length - 1; i >= 0; i--) {
                                 const ancestor = ancestors[i];
@@ -144,7 +149,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                                     ancestor.callee.object.type === utils_1.AST_NODE_TYPES.Identifier) {
                                     // If we're mapping over a variable with pre-generated keys
                                     if (variablesWithUuidv4Base62Keys.has(ancestor.callee.object.name)) {
-                                        reportViolation(jsxElement);
+                                        reportViolation(jsxElement, expression);
                                         return;
                                     }
                                 }
@@ -155,8 +160,8 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             }
         }
         // Helper to check for react mapping functions
-        function isInsideMapCallback() {
-            const ancestors = context.getAncestors();
+        function isInsideMapCallback(node) {
+            const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, node);
             for (let i = ancestors.length - 1; i >= 0; i--) {
                 const ancestor = ancestors[i];
                 if (ancestor.type === utils_1.AST_NODE_TYPES.CallExpression &&
@@ -276,7 +281,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             },
             // Check JSX elements for uuidv4Base62 keys
             JSXElement(node) {
-                if (!isInsideMapCallback())
+                if (!isInsideMapCallback(node))
                     return;
                 if (node.openingElement.attributes) {
                     checkJSXAttributesForUuidv4Base62(node.openingElement.attributes, node);
@@ -284,7 +289,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             },
             // Check JSX fragments for children with uuidv4Base62 keys
             JSXFragment(node) {
-                if (!isInsideMapCallback())
+                if (!isInsideMapCallback(node))
                     return;
                 for (const child of node.children) {
                     if (child.type === utils_1.AST_NODE_TYPES.JSXElement &&
@@ -336,7 +341,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                                         utils_1.AST_NODE_TYPES.Identifier &&
                                     attr.value.expression.property.name === 'key') {
                                     // The test case - directly report this element
-                                    reportViolation(returnExpr);
+                                    reportViolation(returnExpr, attr.value.expression);
                                     break;
                                 }
                             }

package/lib/rules/omit-index-html.d.ts

@@ -1,7 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         allowWithQueryOrHash?: boolean;
     }
 ];
-export declare const omitIndexHtml: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"omitIndexHtml", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const omitIndexHtml: TSESLint.RuleModule<"omitIndexHtml", Options, TSESLint.RuleListener>;
 export {};

package/lib/rules/omit-index-html.js

@@ -25,8 +25,26 @@ function hasQueryOrHash(url) {
  * Removes 'index.html' from a URL and ensures proper trailing slash
  */
 function fixUrl(url) {
-    // Replace /index.html with /
-    return url.replace(/\/index\.html($|[?#])/, '/$1');
+    // Replace /index.html/ with / and /index.html with / at the end or before ?/#/${
+    return url
+        .replace(/\/index\.html\//g, '/')
+        .replace(/\/index\.html(?=(?:$|[?#]|\$\{))/g, '/');
+}
+/**
+ * Reconstructs a template literal using cooked values so static checks and
+ * reporting align with what runtime sees (escape sequences are resolved).
+ */
+function describeTemplateLiteral(node, sourceCode) {
+    const parts = [];
+    node.quasis.forEach((quasi, index) => {
+        const text = quasi.value.cooked ?? quasi.value.raw;
+        parts.push(text);
+        const expression = node.expressions[index];
+        if (expression) {
+            parts.push(`\${${sourceCode.getText(expression)}}`);
+        }
+    });
+    return parts.join('');
 }
 exports.omitIndexHtml = (0, createRule_1.createRule)({
     name: 'omit-index-html',
@@ -49,11 +67,12 @@ exports.omitIndexHtml = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            omitIndexHtml: 'Avoid using "index.html" in URLs. Many web servers automatically resolve directory requests to index.html.',
+            omitIndexHtml: 'URL "{{url}}" includes "index.html", which servers already serve implicitly for directory paths. Keeping the file name creates duplicate URLs, breaks canonical links, and can make caches treat the same page as different assets. {{fixHint}}',
         },
     },
     defaultOptions: [{ allowWithQueryOrHash: true }],
     create(context, [options]) {
+        const sourceCode = context.getSourceCode();
         const allowWithQueryOrHash = options.allowWithQueryOrHash !== false;
         return {
             Literal(node) {
@@ -65,22 +84,58 @@ exports.omitIndexHtml = (0, createRule_1.createRule)({
                     // Skip if it has query parameters or hash fragments and we're allowing those
                     if (allowWithQueryOrHash && hasQueryOrHash(value))
                         return;
+                    const suggestedUrl = fixUrl(value);
+                    const fixHint = `Replace it with the directory path (e.g., "${suggestedUrl}").`;
                     context.report({
                         node,
                         messageId: 'omitIndexHtml',
+                        data: {
+                            url: value,
+                            suggestedUrl,
+                            fixHint,
+                        },
                         fix: (fixer) => {
-                            return fixer.replaceText(node, `"${fixUrl(value)}"`);
+                            const quote = sourceCode.getText(node).startsWith("'")
+                                ? "'"
+                                : '"';
+                            const escapedUrl = suggestedUrl.split(quote).join(`\\${quote}`);
+                            return fixer.replaceText(node, `${quote}${escapedUrl}${quote}`);
                         },
                     });
                 }
             },
             TemplateLiteral(node) {
-                // For template literals, we can only check if the static parts contain index.html
-                const value = node.quasis.map((q) => q.value.raw).join('');
-                if (value.includes('/index.html')) {
+                const hasIndexHtmlInStatic = node.quasis.some((quasi) => {
+                    const text = quasi.value.cooked ?? quasi.value.raw;
+                    return text.includes('/index.html');
+                });
+                if (!hasIndexHtmlInStatic) {
+                    return;
+                }
+                const value = describeTemplateLiteral(node, sourceCode);
+                // Check if it's a URL and contains index.html
+                if (isLikelyUrl(value) && value.includes('/index.html')) {
+                    // Skip if it has query parameters or hash fragments and we're allowing those
+                    if (allowWithQueryOrHash && hasQueryOrHash(value))
+                        return;
+                    const hasDynamicParts = node.expressions.length > 0;
+                    const suggestedUrlRaw = fixUrl(value);
+                    const suggestedUrl = hasDynamicParts
+                        ? `\`${suggestedUrlRaw
+                            .replace(/\\/g, '\\\\')
+                            .replace(/`/g, '\\`')}\``
+                        : suggestedUrlRaw;
+                    const fixHint = hasDynamicParts
+                        ? `Remove "index.html" from the static portion of the template so it resolves to the directory path (e.g., ${suggestedUrl}).`
+                        : `Replace it with the directory path (e.g., "${suggestedUrl}").`;
                     context.report({
                         node,
                         messageId: 'omitIndexHtml',
+                        data: {
+                            url: value,
+                            suggestedUrl,
+                            fixHint,
+                        },
                         // No automatic fix for template literals as they may contain dynamic parts
                     });
                 }

package/lib/rules/optimize-object-boolean-conditions.d.ts

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

package/lib/rules/optimize-object-boolean-conditions.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeObjectBooleanConditions = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
+function isHookCall(node) {
+    const callee = node.callee;
+    return ((callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        HOOK_NAMES.has(callee.name)) ||
+        (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+            callee.object.name === 'React' &&
+            callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            HOOK_NAMES.has(callee.property.name)));
+}
+function generateBooleanVariableName(objectName, conditionType, isNegated) {
+    const base = capitalize(objectName);
+    if (conditionType === 'existence') {
+        return isNegated ? `is${base}Missing` : `has${base}`;
+    }
+    if (conditionType === 'keyCount') {
+        return isNegated ? `is${base}Empty` : `has${base}`;
+    }
+    // complex: default to hasX to avoid over-guessing semantics
+    return `has${base}`;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function isObjectExistenceCheck(node) {
+    // Check for patterns like !obj
+    if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
+        // !obj
+        if (node.operator === '!' &&
+            node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return true;
+        }
+        // !!obj
+        if (node.operator === '!' &&
+            node.argument.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+            node.argument.operator === '!' &&
+            node.argument.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return true;
+        }
+    }
+    return false;
+}
+function isObjectKeyCountCheck(node) {
+    // Check for patterns like Object.keys(obj).length === 0 or Object.keys(obj).length > 0
+    if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        const { left, operator, right } = node;
+        // Check if left side is Object.keys(obj).length
+        if (left.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            left.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            left.property.name === 'length' &&
+            left.object.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            const callExpr = left.object;
+            if (callExpr.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                callExpr.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callExpr.callee.object.name === 'Object' &&
+                callExpr.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callExpr.callee.property.name === 'keys' &&
+                callExpr.arguments.length === 1 &&
+                callExpr.arguments[0].type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Check if right side is a number
+                if (right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof right.value === 'number' &&
+                    ['===', '!==', '>', '<', '>=', '<='].includes(operator)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function isComplexBooleanExpression(node) {
+    // Check for complex expressions involving objects
+    if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+        return (containsObjectCondition(node.left) || containsObjectCondition(node.right));
+    }
+    return false;
+}
+function containsObjectCondition(node) {
+    return (isObjectExistenceCheck(node) ||
+        isObjectKeyCountCheck(node) ||
+        isComplexBooleanExpression(node));
+}
+function extractObjectName(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
+        if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return node.argument.name;
+        }
+    }
+    else if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        const { left } = node;
+        if (left.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            left.object.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            left.object.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            left.object.arguments.length === 1 &&
+            left.object.arguments[0].type === utils_1.AST_NODE_TYPES.Identifier) {
+            return left.object.arguments[0].name;
+        }
+    }
+    else if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+        // For complex expressions, try to extract from the first object condition found
+        const leftObj = extractObjectName(node.left);
+        if (leftObj)
+            return leftObj;
+        return extractObjectName(node.right);
+    }
+    return null;
+}
+function analyzeBooleanCondition(node, context) {
+    const sourceCode = context.sourceCode;
+    const expression = sourceCode.getText(node);
+    if (isObjectExistenceCheck(node)) {
+        const objectName = extractObjectName(node);
+        if (objectName) {
+            const isNegated = node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                node.operator === '!' &&
+                !(node.argument.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    node.argument.operator === '!');
+            return {
+                type: 'existence',
+                objectName,
+                expression,
+                suggestedName: generateBooleanVariableName(objectName, 'existence', isNegated),
+                node,
+            };
+        }
+    }
+    else if (isObjectKeyCountCheck(node)) {
+        const objectName = extractObjectName(node);
+        if (objectName) {
+            const isNegated = expression.includes('=== 0') || expression.includes('<= 0');
+            return {
+                type: 'keyCount',
+                objectName,
+                expression,
+                suggestedName: generateBooleanVariableName(objectName, 'keyCount', isNegated),
+                node,
+            };
+        }
+    }
+    else if (isComplexBooleanExpression(node)) {
+        const objectName = extractObjectName(node);
+        if (objectName) {
+            return {
+                type: 'complex',
+                objectName,
+                expression,
+                suggestedName: generateBooleanVariableName(objectName, 'complex', false),
+                node,
+            };
+        }
+    }
+    return null;
+}
+function findBooleanConditionsInDependencies(depsArray, context) {
+    const patterns = [];
+    for (const element of depsArray.elements) {
+        if (!element)
+            continue; // Skip holes in array
+        const pattern = analyzeBooleanCondition(element, context);
+        if (pattern) {
+            patterns.push(pattern);
+        }
+    }
+    return patterns;
+}
+function isAlreadyBooleanVariable(node) {
+    // Check if the dependency is already a boolean variable (starts with is, has, can, etc.)
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        const name = node.name;
+        const booleanPrefixes = [
+            'is',
+            'has',
+            'can',
+            'should',
+            'will',
+            'was',
+            'were',
+        ];
+        return booleanPrefixes.some((prefix) => name.toLowerCase().startsWith(prefix.toLowerCase()));
+    }
+    return false;
+}
+exports.optimizeObjectBooleanConditions = (0, createRule_1.createRule)({
+    name: 'optimize-object-boolean-conditions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Detects and suggests optimizations for boolean conditions formed over objects in React hook dependencies. Suggests extracting boolean conditions into separate variables to reduce unnecessary re-computations when objects change frequently but the boolean condition changes less frequently.',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            extractBooleanCondition: 'Dependency array includes boolean condition "{{expression}}" derived from object "{{objectName}}". Hook re-runs every time the object reference changes even when the boolean outcome stays the same, leading to wasted renders and unstable memoization. Extract the condition into a stable boolean like "{{suggestedName}}" and depend on that variable instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isHookCall(node)) {
+                    return;
+                }
+                // Get the dependency array argument (last argument for hooks)
+                const depsArg = node.arguments[node.arguments.length - 1];
+                if (!depsArg || depsArg.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    return;
+                }
+                // Find boolean conditions in dependencies
+                const patterns = findBooleanConditionsInDependencies(depsArg, context);
+                for (const pattern of patterns) {
+                    // Skip if it's already a boolean variable
+                    if (isAlreadyBooleanVariable(pattern.node)) {
+                        continue;
+                    }
+                    context.report({
+                        node: pattern.node,
+                        messageId: 'extractBooleanCondition',
+                        data: {
+                            expression: pattern.expression,
+                            suggestedName: pattern.suggestedName,
+                            objectName: pattern.objectName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=optimize-object-boolean-conditions.js.map

package/lib/rules/parallelize-async-operations.d.ts

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        sideEffectPatterns?: Array<string | RegExp>;
+    }
+];
+export declare const parallelizeAsyncOperations: TSESLint.RuleModule<"parallelizeAsyncOperations", Options, TSESLint.RuleListener>;
+export {};