eslint-plugin-require-explicit-array-types

ESLint plugin that requires explicit type annotations for empty arrays. Catches [], new Array(), and Array() in variable declarations, class properties, and object literal properties.

Why?

TypeScript infers empty arrays as an "evolving any" type that evolves as you push elements. This is type-safe, but without an explicit annotation it's not immediately clear what type the array should contain.

This rule enforces explicit type annotations for empty arrays for code clarity and consistency.

Installation

npm install --save-dev eslint-plugin-require-explicit-array-types

Usage

Flat config (ESLint v9+)

// eslint.config.js
import requireExplicitArrayTypes from 'eslint-plugin-require-explicit-array-types';

export default [
  // Use the recommended config (enables the rule as 'error')
  requireExplicitArrayTypes.configs.recommended,

  // Or configure manually
  {
    plugins: {
      'require-explicit-array-types': requireExplicitArrayTypes,
    },
    rules: {
      'require-explicit-array-types/require-explicit-array-types': 'error',
    },
  },
];

Rule: require-explicit-array-types

What it catches

// ❌ These will be flagged
const arr = [];
let items = [];
const data = new Array();
const extra = Array();

class Foo {
  items = [];
  data = new Array();
}

const obj = {
  items: [],
  data: new Array(),
};

// ✅ These are fine
const arr: string[] = [];
let items: number[] = [];
const data: boolean[] = new Array();
const extra = new Array<string>();

class Foo {
  items: string[] = [];
  data: number[] = new Array();
}

// Object literal properties use a type assertion on the value
const obj = {
  items: [] as string[],
  data: new Array<number>(),
};

// Non-empty arrays don't need annotations
const numbers = [1, 2, 3];

// Type assertions are accepted
const typed = [] as string[];

Suggestion fix

The rule provides a suggestion fix which you can then narrow to the correct type. For variable declarations and class properties it adds a : unknown[] type annotation; for object literal properties it adds an as unknown[] type assertion (since properties can't carry an inline annotation).

Options

ignoreMutableVariables

Type: boolean
Default: false

When true, let and var declarations are ignored. Useful if you rely on TypeScript's evolving array type for mutable variables. const declarations and class properties are always checked.

'require-explicit-array-types/require-explicit-array-types': ['error', {
  ignoreMutableVariables: true,
}]

// With ignoreMutableVariables: true
let arr = [];        // ✅ ignored
var list = [];       // ✅ ignored
const arr = [];      // ❌ still flagged

class Foo {
  items = [];        // ❌ still flagged
}

License

MIT