eslint-plugin-maintainability 3.0.0

package/src/rules/maintainability/no-unreadable-iife.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnreadableIife = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
+    name: 'no-unreadable-iife',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent unreadable Immediately Invoked Function Expressions that harm code clarity',
+        },
+        hasSuggestions: true,
+        messages: {
+            unreadableIIFE: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.WARNING,
+                issueName: 'Unreadable IIFE',
+                description: 'Complex IIFE reduces code readability',
+                severity: 'MEDIUM',
+                fix: 'Extract to named function or simplify the IIFE structure',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Glossary/IIFE',
+            }),
+            suggestNamedFunction: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Extract Function',
+                description: 'Extract complex logic to named function',
+                severity: 'LOW',
+                fix: 'function processData() { /* logic */ } processData();',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions',
+            }),
+            suggestBlockScope: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Use Block Scope',
+                description: 'Use block scope instead of IIFE',
+                severity: 'LOW',
+                fix: '{ const isolated = value; /* logic */ }',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block',
+            }),
+            complexIIFE: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Simplify IIFE',
+                description: 'Complex IIFE detected',
+                severity: 'LOW',
+                fix: 'Simplify or extract to separate function',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Glossary/IIFE',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    maxStatements: {
+                        type: 'number',
+                        minimum: 1,
+                        default: 3,
+                    },
+                    maxDepth: {
+                        type: 'number',
+                        minimum: 1,
+                        default: 2,
+                    },
+                    allowReturningIIFE: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ maxStatements: 3, maxDepth: 2, allowReturningIIFE: true }],
+    create(context) {
+        const [options] = context.options;
+        const { maxStatements = 3, maxDepth = 2, allowReturningIIFE = true } = options || {};
+        function isIIFE(node) {
+            // Check if this is a call expression with a function expression or arrow function
+            // Note: In typescript-eslint AST, parentheses don't create a separate node type,
+            // so (function(){})() will have callee.type === 'FunctionExpression' directly
+            if (node.callee.type === 'FunctionExpression' ||
+                node.callee.type === 'ArrowFunctionExpression') {
+                return true;
+            }
+            // Check for unary operator IIFEs like !function(){}(), +function(){}(), void function(){}()
+            if (node.callee.type === 'UnaryExpression' &&
+                (node.callee.argument.type === 'FunctionExpression' ||
+                    node.callee.argument.type === 'ArrowFunctionExpression')) {
+                return true;
+            }
+            return false;
+        }
+        function countStatements(body) {
+            if (body.type === 'BlockStatement') {
+                return body.body.length;
+            }
+            return 1; // Single expression
+        }
+        function calculateDepth(node, currentDepth = 0) {
+            let maxDepthFound = currentDepth;
+            // Check for nested constructs that increase complexity
+            if (node.type === 'IfStatement' ||
+                node.type === 'ForStatement' ||
+                node.type === 'WhileStatement' ||
+                node.type === 'DoWhileStatement' ||
+                node.type === 'SwitchStatement' ||
+                node.type === 'TryStatement') {
+                currentDepth++;
+                maxDepthFound = Math.max(maxDepthFound, currentDepth);
+            }
+            // Properties to skip to avoid circular references
+            const skipProperties = new Set(['parent', 'tokens', 'comments', 'loc', 'range']);
+            // Recursively check children
+            for (const key in node) {
+                // Skip properties that cause circular references or aren't AST nodes
+                if (skipProperties.has(key)) {
+                    continue;
+                }
+                const child = node[key];
+                if (child && typeof child === 'object') {
+                    if (Array.isArray(child)) {
+                        for (const item of child) {
+                            if (item && typeof item === 'object' && 'type' in item) {
+                                maxDepthFound = Math.max(maxDepthFound, calculateDepth(item, currentDepth));
+                            }
+                        }
+                    }
+                    else if ('type' in child) {
+                        maxDepthFound = Math.max(maxDepthFound, calculateDepth(child, currentDepth));
+                    }
+                }
+            }
+            return maxDepthFound;
+        }
+        function hasComplexLogic(body) {
+            if (body.type !== 'BlockStatement') {
+                return false;
+            }
+            // Check for multiple statements
+            if (body.body.length > maxStatements) {
+                return true;
+            }
+            // Check for complex constructs
+            for (const statement of body.body) {
+                if (statement.type === 'IfStatement' ||
+                    statement.type === 'ForStatement' ||
+                    statement.type === 'WhileStatement' ||
+                    statement.type === 'SwitchStatement' ||
+                    statement.type === 'TryStatement') {
+                    return true;
+                }
+                // Check for nested function declarations
+                if (statement.type === 'FunctionDeclaration' ||
+                    statement.type === 'VariableDeclaration' &&
+                        statement.declarations.some((decl) => decl.init?.type === 'FunctionExpression' ||
+                            decl.init?.type === 'ArrowFunctionExpression')) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function analyzeIIFE(node) {
+            let functionNode = null;
+            if (node.callee.type === 'FunctionExpression' ||
+                node.callee.type === 'ArrowFunctionExpression') {
+                functionNode = node.callee;
+            }
+            else if (node.callee.type === 'UnaryExpression' &&
+                (node.callee.argument.type === 'FunctionExpression' ||
+                    node.callee.argument.type === 'ArrowFunctionExpression')) {
+                functionNode = node.callee.argument;
+            }
+            if (!functionNode) {
+                return;
+            }
+            const body = functionNode.body;
+            const statementCount = countStatements(body);
+            const nestingDepth = calculateDepth(body);
+            const hasComplex = hasComplexLogic(body);
+            const returnsValue = body.type === 'BlockStatement' &&
+                body.body.some((stmt) => stmt.type === 'ReturnStatement');
+            // Skip IIFEs that return values if allowed
+            if (allowReturningIIFE && returnsValue && !hasComplex) {
+                return;
+            }
+            // Check various conditions for unreadable IIFE
+            const issues = [];
+            if (statementCount > maxStatements) {
+                issues.push(`too many statements (${statementCount} > ${maxStatements})`);
+            }
+            if (nestingDepth > maxDepth) {
+                issues.push(`too deeply nested (${nestingDepth} > ${maxDepth})`);
+            }
+            if (hasComplex) {
+                issues.push('contains complex control flow');
+            }
+            if (functionNode.params.length > 2) {
+                issues.push('too many parameters');
+            }
+            if (issues.length > 0) {
+                context.report({
+                    node,
+                    messageId: 'unreadableIIFE',
+                    data: {
+                        issues: issues.join(', '),
+                        statementCount,
+                        nestingDepth,
+                        suggestion: hasComplex ? 'extract to named function' : 'simplify or use block scope',
+                    },
+                    suggest: [
+                        {
+                            messageId: 'suggestNamedFunction',
+                            fix(fixer) {
+                                // Complex fix - would need to generate a function name and hoist it
+                                return fixer.insertTextBefore(node, '// TODO: Extract complex IIFE to named function\n');
+                            },
+                        },
+                        {
+                            messageId: 'suggestBlockScope',
+                            fix(fixer) {
+                                return fixer.insertTextBefore(node, '// TODO: Consider using block scope { const x = ...; }\n');
+                            },
+                        },
+                    ],
+                });
+            }
+        }
+        return {
+            CallExpression(node) {
+                if (isIIFE(node)) {
+                    analyzeIIFE(node);
+                }
+            },
+        };
+    },
+});

package/src/types/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * Simplified type barrel for eslint-plugin-maintainability.
+ * Many rules were moved/removed; provide placeholders to keep builds green while
+ * still exposing option types. Replace with concrete types as rules evolve.
+ */
+type GenericRuleOptions = Record<string, unknown>;
+export type NoExternalApiCallsInUtilsOptions = GenericRuleOptions;
+export type ConsistentExistenceIndexCheckOptions = GenericRuleOptions;
+export type PreferEventTargetOptions = GenericRuleOptions;
+export type PreferAtOptions = GenericRuleOptions;
+export type NoUnreadableIifeOptions = GenericRuleOptions;
+export type NoAwaitInLoopOptions = GenericRuleOptions;
+export type CognitiveComplexityOptions = GenericRuleOptions;
+export type NestedComplexityHotspotsOptions = GenericRuleOptions;
+export type NoDeprecatedApiOptions = GenericRuleOptions;
+export type NoConsoleLogOptions = GenericRuleOptions;
+export type PreferDependencyVersionStrategyOptions = GenericRuleOptions;
+export type EnforceNamingOptions = GenericRuleOptions;
+export type DddAnemicDomainModelOptions = GenericRuleOptions;
+export type DddValueObjectImmutabilityOptions = GenericRuleOptions;
+export type IdenticalFunctionsOptions = GenericRuleOptions;
+export type ReactClassToHooksOptions = GenericRuleOptions;
+export type ReactNoInlineFunctionsOptions = GenericRuleOptions;
+export type NoBlockingOperationsOptions = GenericRuleOptions;
+export type NoMemoryLeakListenersOptions = GenericRuleOptions;
+export type NoUnboundedCacheOptions = GenericRuleOptions;
+export type NoUnnecessaryRerendersOptions = GenericRuleOptions;
+export type DetectNPlusOneQueriesOptions = GenericRuleOptions;
+export type ReactRenderOptimizationOptions = GenericRuleOptions;
+export type EnforceRestConventionsOptions = GenericRuleOptions;
+export type RequiredAttributesOptions = GenericRuleOptions;
+export type JsxKeyOptions = GenericRuleOptions;
+export type NoDirectMutationStateOptions = GenericRuleOptions;
+export type RequireOptimizationOptions = GenericRuleOptions;
+export type NoCommentedCodeOptions = GenericRuleOptions;
+export type MaxParametersOptions = GenericRuleOptions;
+export type NoMissingNullChecksOptions = GenericRuleOptions;
+export type NoUnsafeTypeNarrowingOptions = GenericRuleOptions;
+export type NoUnhandledPromiseOptions = GenericRuleOptions;
+export type NoSilentErrorsOptions = GenericRuleOptions;
+export type NoMissingErrorContextOptions = GenericRuleOptions;
+export type AllRulesOptions = Record<string, GenericRuleOptions>;
+export {};

package/src/types/index.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });