no-unreadable-iife

Disallow unreadable IIFE (Immediately Invoked Function Expression) patterns. This rule is part of eslint-plugin-maintainability.

Quick SummaryCopy Anchor Link

Rule DetailsCopy Anchor Link

An immediately invoked function expression (IIFE) is a function or arrow expression called on the spot: (() => { ... })(), (function () { ... })(), async too, and through .call(...) / .apply(...). A long one hides logic a named function would document. The rule reports an IIFE whose block body:

• holds more than maxStatements statements, or
• nests control flow (if, loops, switch, try) more than maxDepth levels deep.

A short IIFE is not reported for holding a single if or try, declaring a helper, or taking several parameters: none of those exceeds a limit. The (async () => { try { await main(); } catch (e) { ... } })() entry point is the standard pattern.

ConfigurationCopy Anchor Link

ExamplesCopy Anchor Link

❌ IncorrectCopy Anchor Link

(() => {
  const a = read();
  const b = read();
  use(a);
  use(b);
})();

(function () {
  if (ready()) {
    for (const x of list()) {
      if (x) use(x); // depth 3
    }
  }
}).call(this);

✅ CorrectCopy Anchor Link

// Named function for clarity
function processValue() {
  return value;
}
const result = processValue();

// A scoped initializer (allowReturningIIFE)
const config = (() => {
  const env = process.env.NODE_ENV;
  const debug = env === 'development';
  const level = debug ? 'debug' : 'info';
  return { env, debug, level };
})();

// The async entry point
(async () => {
  try {
    await main();
  } catch (error) {
    fail(error);
  }
})();

Configuration ExamplesCopy Anchor Link

// eslint.config.mjs
export default [
  {
    rules: {
      'maintainability/no-unreadable-iife': ['warn', { maxStatements: 5 }],
    },
  },
];

Related RulesCopy Anchor Link

• cognitive-complexity - Code complexity limits

Further ReadingCopy Anchor Link

• IIFE - MDN - IIFE pattern explanation

Known False NegativesCopy Anchor Link

Expression-bodied IIFEsCopy Anchor Link

Why: an arrow with an expression body is one expression, however long.

// ❌ NOT DETECTED
const v = ((a) => a && a.b && a.b.c && a.b.c.d)(input);

Use this rule

npm install -D oxlint-plugin-maintainability

{  "jsPlugins": ["oxlint-plugin-maintainability"],  "rules": {    "maintainability/no-unreadable-iife": "error"  }}

import { defineConfig } from 'vite-plus';export default defineConfig({  lint: {    jsPlugins: ['oxlint-plugin-maintainability'],    rules: {      'maintainability/no-unreadable-iife': 'error',    },  },});