eslint-plugin-maintainability 3.0.4 → 3.0.6

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 ## [3.0.3] - 2026-02-08
 
+## 3.0.6
+
+### Patch Changes
+
+- [#225](https://github.com/ofri-peretz/eslint/pull/225) [`34ff5a8`](https://github.com/ofri-peretz/eslint/commit/34ff5a8e6f5126c5d1c0a524759e0af2b5476b46) Thanks [@ofri-peretz](https://github.com/ofri-peretz)! - CI-only: pin all coverage thresholds at 100% (integration target, merges last).
+
+## 3.0.5
+
+### Patch Changes
+
+- [#200](https://github.com/ofri-peretz/eslint/pull/200) [`02e0baf`](https://github.com/ofri-peretz/eslint/commit/02e0baf7a4e8ba83e8b2ec2b82169f733e4f4d87) Thanks [@ofri-peretz](https://github.com/ofri-peretz)! - fix: republish `recommended` preset with the correct plugin namespace
+
+  The published builds of `eslint-plugin-maintainability` and
+  `eslint-plugin-operability` shipped a `recommended` config whose plugin KEY
+  (`@interlace/maintainability`) did not match its rule PREFIX
+  (`@interlace/maintainability/maintainability/…` — doubled). ESLint cannot
+  resolve that, so spreading `...configs.recommended` throws
+  "could not find plugin" the moment a consumer lints a file — under both
+  ESLint 9 and 10.
+
+  The source was corrected in the 2026-05-16 namespace cleanup (alongside
+  `react-features`, which has since been republished via other changesets), but
+  these two plugins were never bumped — so npm still serves the broken builds and
+  they are the only two doubled-namespace plugins still unfixed downstream. This
+  republishes them from the corrected source.
+
+  Regression lock: `packages/eslint-config-interlace/src/ecosystem-integrity.test.ts`
+  loads every plugin's every config preset into a real ESLint instance and fails
+  if any rule→plugin reference cannot be resolved. Run it against the built
+  `dist/` in the release pipeline (pre-publish) to also catch a stale-artifact
+  publish — the failure mode that let these two ship broken.
+
 ## 3.0.4
 
 ### Patch Changes

package/README.md

@@ -10,7 +10,7 @@
   <a href="https://www.npmjs.com/package/eslint-plugin-maintainability" target="_blank"><img src="https://img.shields.io/npm/v/eslint-plugin-maintainability.svg" alt="NPM Version" /></a>
   <a href="https://www.npmjs.com/package/eslint-plugin-maintainability" target="_blank"><img src="https://img.shields.io/npm/dm/eslint-plugin-maintainability.svg" alt="NPM Downloads" /></a>
   <a href="https://opensource.org/licenses/MIT" target="_blank"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="Package License" /></a>
-  <a href="https://app.codecov.io/gh/ofri-peretz/eslint/components?components%5B0%5D=maintainability" target="_blank"><img src="https://codecov.io/gh/ofri-peretz/eslint/graph/badge.svg?component=maintainability" alt="Codecov" /></a>
+  <a href="https://app.codecov.io/gh/ofri-peretz/eslint/tree/main" target="_blank"><img src="https://codecov.io/gh/ofri-peretz/eslint/graph/badge.svg?flag=eslint-plugin-maintainability" alt="Codecov" /></a>
   <a href="https://github.com/ofri-peretz/eslint" target="_blank"><img src="https://img.shields.io/badge/Since-Dec_2025-blue?logo=rocket&logoColor=white" alt="Since Dec 2025" /></a>
 </p>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-maintainability",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "description": "ESLint rules for reducing cognitive load and ensuring code readability.",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/index.js

@@ -58,7 +58,7 @@ exports.plugin = {
         // `@interlace` scope; a scoped name here drifts from how consumers install
         // and reference the plugin. Locked in index.test.ts.
         name: 'eslint-plugin-maintainability',
-        version: '3.0.4',
+        version: '3.0.6',
     },
     rules: exports.rules,
 };

package/src/rules/error-handling/no-silent-errors.js

@@ -13,7 +13,6 @@ const eslint_devkit_2 = require("@interlace/eslint-devkit");
  */
 function isEmptyCatchBlock(catchClause) {
     const body = catchClause.body;
-    /* v8 ignore next 3 -- defensive: catch clause body is always BlockStatement in valid JS */
     if (!body || body.type !== 'BlockStatement') {
         return true;
     }
@@ -33,7 +32,6 @@ function hasExplanatoryComment(catchClause, sourceCode) {
     // Check for comments before the catch clause
     const comments = sourceCode.getAllComments();
     const catchStart = catchClause.loc?.start;
-    /* v8 ignore next 3 -- defensive: catch clause always has location, and no comments = no match */
     if (!catchStart || !comments.length) {
         return false;
     }

package/src/rules/error-handling/no-unhandled-promise.d.ts

@@ -11,7 +11,7 @@
  * @see https://cwe.mitre.org/data/definitions/1024.html
  * @see https://rules.sonarsource.com/javascript/RSPEC-4635/
  */
-import type { TSESLint } from '@interlace/eslint-devkit';
+import type { TSESLint, TSESTree } from '@interlace/eslint-devkit';
 type MessageIds = 'unhandledPromise' | 'addCatch' | 'useTryCatch' | 'useAwait';
 export interface Options {
     /** Ignore promises in test files. Default: true */
@@ -20,6 +20,21 @@ export interface Options {
     ignoreVoidExpressions?: boolean;
 }
 type RuleOptions = [Options?];
+/**
+ * Check if a node is a Promise-like expression
+ * For now, we check all CallExpressions since we can't statically determine
+ * which functions return promises. The isPromiseHandled function will filter out
+ * non-promise calls that are inside handled promise chains.
+ */
+export declare function isPromiseExpression(node: TSESTree.Node): boolean;
+/**
+ * Check if a CallExpression is inside a promise chain callback
+ */
+export declare function isInsidePromiseCallback(node: TSESTree.CallExpression): boolean;
+/**
+ * Check if promise is handled (has .catch, .then, or is in try/catch)
+ */
+export declare function isPromiseHandled(node: TSESTree.Node): boolean;
 export declare const noUnhandledPromise: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
     name: string;
 };

package/src/rules/error-handling/no-unhandled-promise.js

@@ -6,6 +6,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnhandledPromise = void 0;
+exports.isPromiseExpression = isPromiseExpression;
+exports.isInsidePromiseCallback = isInsidePromiseCallback;
+exports.isPromiseHandled = isPromiseHandled;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
 /**

package/src/rules/maintainability/cognitive-complexity.js

@@ -80,8 +80,7 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
         },
     ],
     create(context) {
-        const options = context.options[0] || {};
-        const { maxComplexity = 15 } = options || {};
+        const { maxComplexity = 15 } = context.options[0] || {};
         const filename = context.filename;
         /**
          * Calculate cognitive complexity for a function

package/src/rules/maintainability/identical-functions.d.ts

@@ -21,6 +21,12 @@ export interface Options {
     ignoreTestFiles?: boolean;
 }
 type RuleOptions = [Options?];
+/**
+ * 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.
+ */
+export declare function buildGenericName(firstFunctionName: string): string;
 export declare const identicalFunctions: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
     name: string;
 };

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

@@ -6,9 +6,19 @@
  */
 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'}`;
+}
 exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
     name: 'identical-functions',
     meta: {
@@ -86,8 +96,7 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
         },
     ],
     create(context) {
-        const options = context.options[0] || {};
-        const { minLines = 3, similarityThreshold = 0.9, ignoreTestFiles = true, } = options || {};
+        const { minLines = 3, similarityThreshold = 0.9, ignoreTestFiles = true, } = context.options[0] || {};
         const sourceCode = context.sourceCode;
         const filename = context.filename;
         // Skip test files if configured
@@ -120,10 +129,9 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
         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;
-            if (longer.length === 0)
-                return 1.0;
             const editDistance = levenshteinDistance(longer, shorter);
             return (longer.length - editDistance) / longer.length;
         }
@@ -188,25 +196,6 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
             }
             return groups;
         }
-        /**
-         * Generate unified function suggestion
-         */
-        // oxlint-disable-next-line consistent-function-scoping
-        function generateUnifiedFunction(group) {
-            const firstFunc = group.functions[0];
-            // Analyze parameter differences
-            const allParams = new Set();
-            group.functions.forEach((func) => func.params.forEach((p) => allParams.add(p)));
-            // Generate generic function name
-            const baseName = firstFunc.name.replace(/^(handle|process|get|set|create|update|delete)/, '');
-            const genericName = `handle${baseName || 'Generic'}`;
-            // If functions differ only in constant values, extract as parameter
-            const paramList = Array.from(allParams);
-            if (paramList.length > firstFunc.params.length) {
-                paramList.push('options');
-            }
-            return `function ${genericName}(${paramList.join(', ')}) {\n  ${firstFunc.body.trim()}\n}`;
-        }
         /**
          * Suggest refactoring approach
          */
@@ -264,7 +253,6 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
             const groups = findDuplicationGroups();
             groups.forEach((group) => {
                 const refactoringApproach = suggestRefactoringApproach(group);
-                const unifiedFunction = generateUnifiedFunction(group);
                 const primaryFunction = group.functions[0];
                 const similarityPercent = Math.round(group.similarityScore * 100);
                 context.report({
@@ -280,8 +268,7 @@ exports.identicalFunctions = (0, eslint_devkit_2.createRule)({
                         {
                             messageId: 'extractGeneric',
                             data: {
-                                functionName: unifiedFunction.match(/function (\w+)/)?.[1] ||
-                                    'handleGeneric',
+                                functionName: buildGenericName(primaryFunction.name),
                             },
                             fix: () => null,
                         },

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

@@ -79,21 +79,21 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
         const [options] = context.options;
         const { maxStatements = 3, maxDepth = 2, allowReturningIIFE = true } = options || {};
         // oxlint-disable-next-line consistent-function-scoping
-        function isIIFE(node) {
+        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 true;
+                return node.callee;
             }
-            // Check for unary operator IIFEs like !function(){}(), +function(){}(), void function(){}()
+            // 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 node.callee.argument;
             }
-            return false;
+            return null;
         }
         // oxlint-disable-next-line consistent-function-scoping
         function countStatements(body) {
@@ -161,20 +161,7 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
             }
             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;
-            }
+        function analyzeIIFE(node, functionNode) {
             const body = functionNode.body;
             const statementCount = countStatements(body);
             const nestingDepth = calculateDepth(body);
@@ -229,8 +216,9 @@ exports.noUnreadableIife = (0, eslint_devkit_1.createRule)({
         }
         return {
             CallExpression(node) {
-                if (isIIFE(node)) {
-                    analyzeIIFE(node);
+                const functionNode = getIifeFunctionNode(node);
+                if (functionNode) {
+                    analyzeIIFE(node, functionNode);
                 }
             },
         };