consistent-function-scoping

Move functions to the highest possible scope. This rule is part of eslint-plugin-maintainability.

Quick SummaryCopy Anchor Link

Rule DetailsCopy Anchor Link

A helper declared inside a function - a function declaration, or a function or arrow expression bound to a variable - that references no binding of its enclosing function is recreated on every call and can move to module scope.

What counts is the binding, resolved by scope, not the name:

• a variable the helper declares itself under an outer name shadows the outer one and is not a use;
• a module-level binding is reachable after the move, so using only module bindings still lets the helper move;
• a use counts wherever it is: in a nested callback, a default parameter value, a type annotation naming a type the enclosing function declares, or a call of a sibling helper.

It does not report a function at module level, a function passed as an argument (an inline callback), an object or class member, or an arrow that uses this (an arrow's this is the enclosing one). A function helper's this is its own, so using it does not tie the helper to the enclosing scope.

ConfigurationCopy Anchor Link

Why This MattersCopy Anchor Link

ExamplesCopy Anchor Link

❌ IncorrectCopy Anchor Link

function outer() {
  // This function doesn't use any variables from outer
  function helper(x: number) {
    return x * 2;
  }
  
  return [1, 2, 3].map(helper);
}

✅ CorrectCopy Anchor Link

// Moved to module scope
function helper(x: number) {
  return x * 2;
}

function outer() {
  return [1, 2, 3].map(helper);
}

// Or when closure is needed (correct nesting)
function createMultiplier(factor: number) {
  return function multiply(x: number) {  // Uses factor from parent
    return x * factor;
  };
}

Configuration ExamplesCopy Anchor Link

Basic UsageCopy Anchor Link

{
  rules: {
    'maintainability/consistent-function-scoping': 'warn'
  }
}

Related RulesCopy Anchor Link

• cognitive-complexity - Code complexity

Further ReadingCopy Anchor Link

• Closures - MDN - JavaScript closures

Known False NegativesCopy Anchor Link

The following patterns are not detected due to static analysis limitations:

Dynamic Variable ReferencesCopy Anchor Link

Why: Static analysis cannot trace values stored in variables or passed through function parameters.

// ❌ NOT DETECTED - Value from variable
const value = externalSource();
processValue(value); // Variable origin not tracked

Mitigation: Implement runtime validation and review code manually. Consider using TypeScript branded types for validated inputs.

Imported ValuesCopy Anchor Link

Why: When values come from imports, the rule cannot analyze their origin or construction.

// ❌ NOT DETECTED - Value from import
import { getValue } from './helpers';
processValue(getValue()); // Cross-file not tracked

Mitigation: Ensure imported values follow the same constraints. Use TypeScript for type safety.

Use this rule

npm install -D oxlint-plugin-maintainability

{  "jsPlugins": ["oxlint-plugin-maintainability"],  "rules": {    "maintainability/consistent-function-scoping": "error"  }}

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