eslint-plugin-maintainability 3.0.9 → 3.0.10

package/src/rules/maintainability/identical-functions.js

@@ -1,20 +1,10 @@
 "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.identicalFunctions = void 0;
 exports.buildGenericName = buildGenericName;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
 const eslint_devkit_3 = require("@interlace/eslint-devkit");
-/**
- * Build the generic extracted-function name suggested for a duplication group.
- * Shared by the unified-function template and the report data so the two can
- * never drift apart.
- */
 function buildGenericName(firstFunctionName) {
     const baseName = firstFunctionName.replace(/^(handle|process|get|set|create|update|delete)/, '');
     return `handle${baseName || 'Generic'}`;
@@ -28,7 +18,6 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
             description: 'Detects duplicate function implementations with DRY refactoring suggestions',
         },
         messages: {
-            // 🎯 Token optimization: 43% reduction (56→32 tokens) - DRY principle violation detected
             identicalFunctions: (0, eslint_devkit_1.formatLLMMessage)({
                 icon: eslint_devkit_1.MessageIcons.DUPLICATION,
                 issueName: 'Code duplication',
@@ -99,46 +88,27 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
         const { minLines = 3, similarityThreshold = 0.9, ignoreTestFiles = true, } = context.options[0] || {};
         const sourceCode = context.sourceCode;
         const filename = context.filename;
-        // Skip test files if configured
         if (ignoreTestFiles && /\.(test|spec)\.[jt]sx?$/.test(filename)) {
             return {};
         }
         const functions = [];
-        /**
-         * Normalize function body for comparison
-         * Remove variable names, keep structure
-         */
-        // oxlint-disable-next-line consistent-function-scoping
         function normalizeBody(body) {
             return (body
-                // Remove whitespace
                 .replace(/\s+/g, ' ')
-                // Normalize string quotes
                 .replace(/["'`]/g, '"')
-                // Normalize variable names to generic identifiers
                 .replace(/\b[a-z_$][a-zA-Z0-9_$]*\b/g, 'VAR')
-                // Remove comments
                 .replace(/\/\*[\s\S]*?\*\//g, '')
                 .replace(/\/\/.*/g, '')
                 .trim());
         }
-        /**
-         * Calculate similarity between two normalized strings
-         * Using Levenshtein distance ratio
-         */
         function calculateSimilarity(str1, str2) {
             if (str1 === str2)
                 return 1.0;
-            // str1 !== str2 here, so the longer string is never empty.
             const longer = str1.length > str2.length ? str1 : str2;
             const shorter = str1.length > str2.length ? str2 : str1;
             const editDistance = levenshteinDistance(longer, shorter);
             return (longer.length - editDistance) / longer.length;
         }
-        /**
-         * Levenshtein distance algorithm
-         */
-        // oxlint-disable-next-line consistent-function-scoping
         function levenshteinDistance(str1, str2) {
             const matrix = [];
             for (let i = 0; i <= str2.length; i++) {
@@ -159,9 +129,6 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
             }
             return matrix[str2.length][str1.length];
         }
-        /**
-         * Find groups of similar functions
-         */
         function findDuplicationGroups() {
             const groups = [];
             const processed = new Set();
@@ -196,10 +163,6 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
             }
             return groups;
         }
-        /**
-         * Suggest refactoring approach
-         */
-        // oxlint-disable-next-line consistent-function-scoping
         function suggestRefactoringApproach(group) {
             const funcNames = group.functions.map((f) => f.name);
             const hasRolePattern = funcNames.some((name) => /user|admin|guest|customer/i.test(name));
@@ -224,9 +187,6 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
                 complexity: 'simple',
             };
         }
-        /**
-         * Store function information
-         */
         function storeFunctionInfo(node) {
             const body = node.body ? sourceCode.getText(node.body) : '';
             const lines = body.split('\n').length;
@@ -246,9 +206,6 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
                 params,
             });
         }
-        /**
-         * Report duplications after analyzing all functions
-         */
         function reportDuplications() {
             const groups = findDuplicationGroups();
             groups.forEach((group) => {

package/src/rules/maintainability/max-parameters.js

@@ -1,17 +1,9 @@
 "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.maxParameters = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
 const eslint_devkit_3 = require("@interlace/eslint-devkit");
-/**
- * Count function parameters
- */
 function countParameters(node) {
     return node.params.length;
 }
@@ -87,20 +79,13 @@ exports.maxParameters = (0, eslint_devkit_2.createRule)({
         },
     ],
     create(context, [options = {}]) {
-        const { max = 4, ignoreConstructors = false,
-        // ignoreOverriddenMethods = false, // Not used
-         } = options || {};
-        /**
-         * Check function parameters
-         */
+        const { max = 4, ignoreConstructors = false, } = options || {};
         function checkFunction(node) {
-            // Check if it's a constructor
             if (ignoreConstructors) {
                 if (node.type === 'FunctionDeclaration' &&
                     node.id &&
                     node.id.name &&
                     /^[A-Z]/.test(node.id.name)) {
-                    // Likely a constructor
                     return;
                 }
             }
@@ -122,7 +107,7 @@ exports.maxParameters = (0, eslint_devkit_2.createRule)({
                 suggest: [
                     {
                         messageId: 'useObjectParameter',
-                        fix: () => null, // Complex refactoring, cannot auto-fix
+                        fix: () => null,
                     },
                     {
                         messageId: 'extractToClass',

package/src/rules/maintainability/nested-complexity-hotspots.js

@@ -1,52 +1,8 @@
 "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.nestedComplexityHotspots = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
-/**
- * Calculate nesting depth for a node
- * Note: Currently unused, keeping for future implementation
- */
-/*
-function calculateNestingDepth(
-  node: TSESTree.Node,
-  sourceCode: TSESLint.SourceCode
-): number {
-  let depth = 0;
-  let current: TSESTree.Node | null = node;
-  const maxDepth = 20;
-
-  // Start from the node itself and traverse up
-  while (current && depth < maxDepth) {
-    const parent = (current as any).parent;
-
-    if (!parent) break;
-
-    // Count nested control structures
-    if (
-      parent.type === 'IfStatement' ||
-      parent.type === 'ForStatement' ||
-      parent.type === 'ForInStatement' ||
-      parent.type === 'ForOfStatement' ||
-      parent.type === 'WhileStatement' ||
-      parent.type === 'DoWhileStatement' ||
-      parent.type === 'SwitchStatement' ||
-      parent.type === 'TryStatement'
-    ) {
-      depth++;
-    }
-
-    current = parent as TSESTree.Node;
-  }
-
-  return depth;
-}
-*/
 exports.nestedComplexityHotspots = (0, eslint_devkit_2.createRule)({
     name: 'nested-complexity-hotspots',
     meta: {
@@ -123,22 +79,15 @@ exports.nestedComplexityHotspots = (0, eslint_devkit_2.createRule)({
     ],
     create(context, [options = {}]) {
         const { maxDepth = 4, countConditionals = true, countLoops = true, } = options || {};
-        // const sourceCode = context.sourceCode; // Not used
-        /**
-         * Check control structures
-         */
         function checkControlStructure(node) {
-            // Count how many control structures are nested above this node
             let depth = 0;
             let current = node;
             const maxDepthCheck = 20;
-            // Start from the node itself and traverse up
             while (current && depth < maxDepthCheck) {
                 const parent = current
                     .parent;
                 if (!parent)
                     break;
-                // Count nested control structures above this node
                 if (parent.type === 'IfStatement' ||
                     parent.type === 'ForStatement' ||
                     parent.type === 'ForInStatement' ||
@@ -151,15 +100,12 @@ exports.nestedComplexityHotspots = (0, eslint_devkit_2.createRule)({
                 }
                 current = parent;
             }
-            // depth now represents how many control structures are nested above this node
-            // For 5 nested ifs, the innermost if will have depth = 4 (4 ifs above it)
-            // So we check if depth >= maxDepth (not >)
             if (depth >= maxDepth) {
                 context.report({
                     node,
                     messageId: 'nestedComplexity',
                     data: {
-                        depth: String(depth + 1), // +1 to include the current node
+                        depth: String(depth + 1),
                         max: String(maxDepth),
                     },
                     suggest: [

package/src/rules/maintainability/no-lonely-if.js

@@ -1,9 +1,4 @@
 "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.noLonelyIf = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
@@ -47,10 +42,7 @@ exports.noLonelyIf = (0, eslint_devkit_1.createRule)({
         const { allow = [] } = options || {};
         const allowedContexts = new Set(allow);
         function isInAllowedContext() {
-            // Check if we're in an allowed context
-            // This is a simple implementation - could be extended for more complex cases
             for (const allowedContext of allowedContexts) {
-                // For now, just check if the context string appears anywhere in the source
                 const sourceCode = context.sourceCode;
                 const sourceText = sourceCode.getText();
                 if (sourceText.includes(allowedContext)) {
@@ -59,18 +51,13 @@ exports.noLonelyIf = (0, eslint_devkit_1.createRule)({
             }
             return false;
         }
-        // oxlint-disable-next-line consistent-function-scoping
         function isLonelyIf(node) {
-            // Check if this if statement is inside an else block (not a proper else if)
             const parent = node.parent;
-            // If parent is a BlockStatement, check if that block is an else block
             if (parent?.type === 'BlockStatement') {
                 const grandParent = parent.parent;
-                // Check if the block is the alternate (else) of an if statement
                 return (grandParent?.type === 'IfStatement' &&
                     grandParent.alternate === parent);
             }
-            // If not in a block, it's not a lonely if (it's either a proper else if or top-level)
             return false;
         }
         return {
@@ -88,7 +75,6 @@ exports.noLonelyIf = (0, eslint_devkit_1.createRule)({
                                 messageId: 'noLonelyIf',
                                 fix(fixer) {
                                     const sourceCode = context.sourceCode;
-                                    // Find the else keyword
                                     let elseToken = null;
                                     const tokens = sourceCode.getTokensBefore(node, 10);
                                     for (let i = tokens.length - 1; i >= 0; i--) {
@@ -98,7 +84,6 @@ exports.noLonelyIf = (0, eslint_devkit_1.createRule)({
                                         }
                                     }
                                     if (elseToken) {
-                                        // Remove 'else' and replace 'if' with 'else if'
                                         const ifToken = sourceCode.getTokenAfter(elseToken);
                                         if (ifToken && ifToken.value === 'if') {
                                             return [

package/src/rules/maintainability/no-nested-ternary.js

@@ -1,9 +1,4 @@
 "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.noNestedTernary = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
@@ -45,37 +40,25 @@ exports.noNestedTernary = (0, eslint_devkit_1.createRule)({
     create(context) {
         const [options] = context.options;
         const { allow = [] } = options || {};
-        /**
-         * Check if node is in an allowed context based on the allow option.
-         * Supported contexts:
-         * - 'jsx': Allow nested ternaries in JSX expressions
-         * - 'variable': Allow nested ternaries in variable declarations
-         * - 'return': Allow nested ternaries in return statements
-         * - 'argument': Allow nested ternaries in function arguments
-         */
         function isInAllowedContext(node) {
             if (allow.length === 0) {
                 return false;
             }
             let current = node.parent;
             while (current) {
-                // Check for JSX context
                 if (allow.includes('jsx') &&
                     (current.type === 'JSXExpressionContainer' ||
                         current.type === 'JSXElement' ||
                         current.type === 'JSXFragment')) {
                     return true;
                 }
-                // Check for variable declaration context
                 if (allow.includes('variable') &&
                     current.type === 'VariableDeclarator') {
                     return true;
                 }
-                // Check for return statement context
                 if (allow.includes('return') && current.type === 'ReturnStatement') {
                     return true;
                 }
-                // Check for function argument context
                 if (allow.includes('argument') && current.type === 'CallExpression') {
                     return true;
                 }
@@ -84,12 +67,10 @@ exports.noNestedTernary = (0, eslint_devkit_1.createRule)({
             return false;
         }
         function hasNestedTernary(node) {
-            // Check if the consequent or alternate contains another ternary
             function containsTernary(expr) {
                 if (expr.type === 'ConditionalExpression') {
                     return true;
                 }
-                // For other expression types, check their child expressions
                 switch (expr.type) {
                     case 'ArrayExpression':
                         return expr.elements.some((element) => element &&
@@ -115,21 +96,17 @@ exports.noNestedTernary = (0, eslint_devkit_1.createRule)({
                         return containsTernary(expr.argument);
                     case 'AssignmentExpression':
                         return containsTernary(expr.right);
-                    // For literals and identifiers, no nested expressions
                     case 'Literal':
                     case 'Identifier':
                     case 'ThisExpression':
                     case 'Super':
                     case 'MetaProperty':
                         return false;
-                    // For template literals, check expressions
                     case 'TemplateLiteral':
                         return expr.expressions.some((exp) => containsTernary(exp));
-                    // For tagged templates, check tag and expressions
                     case 'TaggedTemplateExpression':
                         return (containsTernary(expr.tag) ||
                             expr.quasi.expressions.some((exp) => containsTernary(exp)));
-                    // Default: assume no nested expressions for unknown types
                     default:
                         return false;
                 }
@@ -150,10 +127,6 @@ exports.noNestedTernary = (0, eslint_devkit_1.createRule)({
                             {
                                 messageId: 'noNestedTernary',
                                 fix() {
-                                    // This is a complex fix that would require:
-                                    // 1. Extracting the nested ternary to a variable
-                                    // 2. Replacing the nested part
-                                    // For now, just provide the suggestion
                                     return null;
                                 },
                             },

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

@@ -1,9 +1,4 @@
 "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");
@@ -78,16 +73,11 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
     create(context) {
         const [options] = context.options;
         const { maxStatements = 3, maxDepth = 2, allowReturningIIFE = true } = options || {};
-        // oxlint-disable-next-line consistent-function-scoping
         function getIifeFunctionNode(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 node.callee;
             }
-            // 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')) {
@@ -95,22 +85,18 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
             }
             return null;
         }
-        // oxlint-disable-next-line consistent-function-scoping
         function countStatements(body) {
             if (body.type === 'BlockStatement') {
                 return body.body.length;
             }
-            return 1; // Single expression
+            return 1;
         }
         function calculateDepth(node) {
-            // AST-based nesting depth calculation — no regex needed
             const CONTROL_FLOW_TYPES = new Set([
                 'IfStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement',
                 'WhileStatement', 'DoWhileStatement', 'SwitchStatement', 'TryStatement',
             ]);
-            // Non-AST keys that should never be traversed
             const SKIP_KEYS = new Set(['parent', 'loc', 'range', 'tokens', 'comments', 'leadingComments', 'trailingComments']);
-            // oxlint-disable-next-line consistent-function-scoping
             function isASTNode(value) {
                 return !!value && typeof value === 'object' && 'type' in value && 'loc' in value;
             }
@@ -138,11 +124,9 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
             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' ||
@@ -151,7 +135,6 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
                     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' ||
@@ -168,11 +151,9 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
             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})`);
@@ -200,7 +181,6 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
                         {
                             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');
                             },
                         },

package/src/types/index.js

@@ -1,7 +1,2 @@
 "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 });