@blumintinc/eslint-plugin-blumint 1.8.0 → 1.8.1

package/lib/rules/no-unused-usestate.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnusedUseState = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/BluMintInc/eslint-custom-rules/blob/main/docs/rules/${name}.md`);
+/**
+ * Rule to detect and remove unused useState hooks in React components
+ * This rule identifies cases where the state variable from useState is ignored (e.g., replaced with _)
+ */
+exports.noUnusedUseState = createRule({
+    name: 'no-unused-usestate',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow unused useState hooks',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        messages: {
+            unusedUseState: 'The state variable is ignored. Remove the unused useState hook.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            // Look for variable declarations that destructure from useState
+            VariableDeclarator(node) {
+                // Check if it's an array pattern (destructuring)
+                if (node.id.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayPattern &&
+                    node.init?.type === utils_1.TSESTree.AST_NODE_TYPES.CallExpression) {
+                    const callExpression = node.init;
+                    // Check if the call is to useState
+                    if (callExpression.callee.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
+                        callExpression.callee.name === 'useState') {
+                        const arrayPattern = node.id;
+                        // Check if the first element is ignored (named _ or unused)
+                        if (arrayPattern.elements.length > 0 &&
+                            arrayPattern.elements[0] &&
+                            arrayPattern.elements[0].type === utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
+                            (arrayPattern.elements[0].name === '_' || arrayPattern.elements[0].name.startsWith('_'))) {
+                            context.report({
+                                node,
+                                messageId: 'unusedUseState',
+                                fix: (fixer) => {
+                                    // Remove the entire useState declaration
+                                    const sourceCode = context.getSourceCode();
+                                    const parentStatement = node.parent;
+                                    if (parentStatement && parentStatement.type === utils_1.TSESTree.AST_NODE_TYPES.VariableDeclaration) {
+                                        // If this is the only declarator, remove the entire statement and any extra whitespace
+                                        if (parentStatement.declarations.length === 1) {
+                                            // Get the next token after the statement to handle whitespace properly
+                                            const nextToken = sourceCode.getTokenAfter(parentStatement, { includeComments: true });
+                                            if (nextToken) {
+                                                // Remove the statement and any whitespace up to the next token
+                                                return fixer.removeRange([parentStatement.range[0], nextToken.range[0]]);
+                                            }
+                                            return fixer.remove(parentStatement);
+                                        }
+                                        // Otherwise, just remove this declarator and any trailing comma
+                                        const declaratorRange = node.range;
+                                        // Check if there's a comma after this declarator
+                                        const tokenAfter = sourceCode.getTokenAfter(node);
+                                        if (tokenAfter && tokenAfter.value === ',') {
+                                            return fixer.removeRange([declaratorRange[0], tokenAfter.range[1]]);
+                                        }
+                                        // Check if there's a comma before this declarator
+                                        const tokenBefore = sourceCode.getTokenBefore(node);
+                                        if (tokenBefore && tokenBefore.value === ',') {
+                                            return fixer.removeRange([tokenBefore.range[0], declaratorRange[1]]);
+                                        }
+                                        return fixer.remove(node);
+                                    }
+                                    return null;
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unused-usestate.js.map

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

@@ -0,0 +1,7 @@
+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 {};

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omitIndexHtml = void 0;
+const createRule_1 = require("../utils/createRule");
+/**
+ * Checks if a string is a URL by looking for common URL patterns
+ * and excludes file system paths
+ */
+function isLikelyUrl(str) {
+    // Check if it's a URL
+    const isUrl = str.startsWith('http://') ||
+        str.startsWith('https://') ||
+        str.startsWith('/');
+    // Exclude file system paths (containing directories like /usr/, /var/, etc.)
+    const isFilePath = /^\/(?:usr|var|etc|home|opt|tmp|bin|lib|mnt|media|root|srv|sys|boot|dev)\//.test(str);
+    return isUrl && !isFilePath;
+}
+/**
+ * Checks if a URL has query parameters or hash fragments
+ */
+function hasQueryOrHash(url) {
+    return url.includes('?') || url.includes('#');
+}
+/**
+ * Removes 'index.html' from a URL and ensures proper trailing slash
+ */
+function fixUrl(url) {
+    // Replace /index.html with /
+    return url.replace(/\/index\.html($|[?#])/, '/$1');
+}
+exports.omitIndexHtml = (0, createRule_1.createRule)({
+    name: 'omit-index-html',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow the use of "index.html" in URLs',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowWithQueryOrHash: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            omitIndexHtml: 'Avoid using "index.html" in URLs. Many web servers automatically resolve directory requests to index.html.',
+        },
+    },
+    defaultOptions: [{ allowWithQueryOrHash: true }],
+    create(context, [options]) {
+        const allowWithQueryOrHash = options.allowWithQueryOrHash !== false;
+        return {
+            Literal(node) {
+                if (typeof node.value !== 'string')
+                    return;
+                const value = node.value;
+                // 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;
+                    context.report({
+                        node,
+                        messageId: 'omitIndexHtml',
+                        fix: (fixer) => {
+                            return fixer.replaceText(node, `"${fixUrl(value)}"`);
+                        },
+                    });
+                }
+            },
+            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')) {
+                    context.report({
+                        node,
+                        messageId: 'omitIndexHtml',
+                        // No automatic fix for template literals as they may contain dynamic parts
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=omit-index-html.js.map

package/lib/rules/prefer-usememo-over-useeffect-usestate.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export declare const preferUseMemoOverUseEffectUseState: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferUseMemo", never[], {
+    VariableDeclarator(node: TSESTree.VariableDeclarator): void;
+    CallExpression(node: TSESTree.CallExpression): void;
+}>;

package/lib/rules/prefer-usememo-over-useeffect-usestate.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferUseMemoOverUseEffectUseState = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
+    name: 'prefer-usememo-over-useeffect-usestate',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer useMemo over useEffect + useState for pure computations. Using useEffect to update state with a pure computation causes unnecessary re-renders.',
+            recommended: 'error',
+        },
+        messages: {
+            preferUseMemo: 'Prefer useMemo over useEffect + useState for pure computations to avoid unnecessary re-renders',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track useState declarations to match with useEffect
+        const stateSetters = new Map();
+        // Helper to check if a node is a pure computation (no side effects)
+        const isPureComputation = (node) => {
+            // If it's an arrow function or function expression, it's not pure for our purposes
+            if (node.type === 'ArrowFunctionExpression' ||
+                node.type === 'FunctionExpression') {
+                return false;
+            }
+            // If it's a call expression, check if it's likely to be pure
+            if (node.type === 'CallExpression') {
+                // Allow certain known pure functions
+                const callee = node.callee;
+                if (callee.type === 'Identifier') {
+                    // Allow functions that start with "compute", "calculate", "format", etc.
+                    const pureNamePatterns = /^(compute|calculate|format|transform|convert|get|derive|create|expensive)/i;
+                    if (pureNamePatterns.test(callee.name)) {
+                        return true;
+                    }
+                    // Consider all other named functions as potentially having side effects
+                    return false;
+                }
+                // Allow array methods like map, filter, reduce which are pure
+                if (callee.type === 'MemberExpression' &&
+                    callee.property.type === 'Identifier') {
+                    const arrayMethods = [
+                        'map',
+                        'filter',
+                        'reduce',
+                        'some',
+                        'every',
+                        'find',
+                        'findIndex',
+                    ];
+                    if (arrayMethods.includes(callee.property.name)) {
+                        return true;
+                    }
+                }
+                // For this rule, we'll consider all other function calls as potentially having side effects
+                return false;
+            }
+            // If it's an await expression, it's not pure
+            if (node.type === 'AwaitExpression') {
+                return false;
+            }
+            // If it contains assignments to variables outside its scope, it's not pure
+            if (node.type === 'AssignmentExpression') {
+                return false;
+            }
+            // Object and array literals are pure
+            if (node.type === 'ObjectExpression' || node.type === 'ArrayExpression') {
+                return true;
+            }
+            // Allow basic expressions and literals
+            return true;
+        };
+        return {
+            // Track useState declarations
+            VariableDeclarator(node) {
+                if (node.init?.type === 'CallExpression' &&
+                    node.init.callee.type === 'Identifier' &&
+                    node.init.callee.name === 'useState') {
+                    if (node.id.type === 'ArrayPattern' &&
+                        node.id.elements.length === 2 &&
+                        node.id.elements[0]?.type === 'Identifier' &&
+                        node.id.elements[1]?.type === 'Identifier') {
+                        const stateName = node.id.elements[0].name;
+                        const setterName = node.id.elements[1].name;
+                        const initialValue = node.init.arguments[0] || null;
+                        stateSetters.set(setterName, { stateName, initialValue });
+                    }
+                }
+            },
+            // Check useEffect calls
+            CallExpression(node) {
+                if (node.callee.type === 'Identifier' &&
+                    node.callee.name === 'useEffect' &&
+                    node.arguments.length > 0 &&
+                    (node.arguments[0].type === 'ArrowFunctionExpression' ||
+                        node.arguments[0].type === 'FunctionExpression')) {
+                    const effectCallback = node.arguments[0];
+                    // Check if the effect body is a block with a single statement
+                    if (effectCallback.body.type === 'BlockStatement' &&
+                        effectCallback.body.body.length === 1) {
+                        const statement = effectCallback.body.body[0];
+                        // Check if the statement is a call to a state setter
+                        if (statement.type === 'ExpressionStatement' &&
+                            statement.expression.type === 'CallExpression' &&
+                            statement.expression.callee.type === 'Identifier') {
+                            const setterName = statement.expression.callee.name;
+                            const stateInfo = stateSetters.get(setterName);
+                            if (stateInfo && statement.expression.arguments.length === 1) {
+                                const computation = statement.expression.arguments[0];
+                                // Check if the computation is pure
+                                if (isPureComputation(computation)) {
+                                    // Report the issue but without autofixing
+                                    context.report({
+                                        node,
+                                        messageId: 'preferUseMemo',
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-usememo-over-useeffect-usestate.js.map