Config

Options (overview)

Quick reference (all options)

type BaselineName = 'widely' | 'newly';
type BaselineOption = BaselineName | number; // YYYY

type IncludePreset = 'auto' | 'safe' | 'type-aware';
type Include = boolean | { preset?: IncludePreset };

interface UseBaselineOptions {
  available?: BaselineOption;
  baseline?: BaselineOption;

  includeWebApis?: Include;
  includeJsBuiltins?: Include;

  ignoreFeatures?: string[];  // featureId or /regex/
  ignoreNodeTypes?: string[]; // ESTree node.type or /regex/
}

type UseTypes = 'off' | 'auto' | 'require';
interface IncludeAdvanced {
  preset?: 'auto' | 'safe' | 'type-aware';
  useTypes?: UseTypes;   // How to use types ('type-aware' effectively means 'require')
  only?: string[];       // Limit to specific featureIds
  ignore?: string[];     // Exclude specific featureIds
}

Core options

Feature detection

includeWebApis

type Include = boolean | { preset?: 'auto' | 'safe' | 'type-aware' };

• Default: off in configs.baseline, 'auto' in configs.recommended
• Purpose: choose how aggressively to detect Web APIs (see presets)

rules: {
  'baseline-js/use-baseline': ['error', {
    available: 'widely',
    includeWebApis: { preset: 'auto' },
  }],
}

includeJsBuiltins

type Include = boolean | { preset?: 'auto' | 'safe' | 'type-aware' };

• Default: off in configs.baseline, 'auto' in configs.recommended
• Purpose: choose how aggressively to detect JS Builtins (same shape as includeWebApis)

rules: {
  'baseline-js/use-baseline': ['error', {
    available: 'widely',
    includeJsBuiltins: { preset: 'auto' },
  }],
}

Filters & suppression

• ignoreFeatures: string[] — web‑features featureId or /regex/
• ignoreNodeTypes: string[] — ESTree node.type (e.g. WithStatement)

rules: {
  'baseline-js/use-baseline': ['error', {
    available: 2020,
    ignoreFeatures: ['nullish-coalescing', '/^optional-/'],
    ignoreNodeTypes: ['WithStatement', '/Expression$/'],
  }],
}

Preset semantics (overview)

See below for code examples showing preset: 'safe' | 'auto' | 'type‑aware' in action.

includeWebApis / includeJsBuiltins — meaning & examples

Both control “what surface to detect and how aggressive it should be”. The three common modes:

• preset: 'safe' (most conservative)

  • Detects only literal‑safe patterns (low false positives)
  • Example:

    rules: {
      'baseline-js/use-baseline': ['error', {
        available: 'widely',
        includeJsBuiltins: { preset: 'safe' },
      }],
    }

• preset: 'auto' (recommended)

  • Uses types when available, otherwise falls back safely
  • Example:

    rules: {
      'baseline-js/use-baseline': ['error', {
        available: 'widely',
        includeWebApis: { preset: 'auto' },
        includeJsBuiltins: { preset: 'auto' },
      }],
    }

• preset: 'type-aware' (strictest)

  • Requires TS types. Resolves the receiver’s actual type before reporting instance members
  • Example:

    import tsParser from '@typescript-eslint/parser';
    
    export default [
      { files: ['**/*.{ts,tsx}'], languageOptions: { parser: tsParser, parserOptions: { project: ['./tsconfig.json'] } } },
      {
        rules: {
          'baseline-js/use-baseline': ['error', {
            available: 'widely',
            includeWebApis: { preset: 'type-aware' },
            includeJsBuiltins: { preset: 'type-aware' },
          }],
        },
      },
    ]

Filtering (optional)

• only: string[] — watch only these featureIds
• ignore: string[] — exclude these featureIds

featureId refers to web‑features IDs (e.g. nullish-coalescing, intl-locale-info).

rules: {
  'baseline-js/use-baseline': ['error', {
    available: 'widely',
    includeWebApis: { preset: 'safe', only: ['canvas-2d-alpha'] },
  }],
}

Presets (Flat Config)

We currently provide three presets; start here in most cases.

import baselineJs from 'eslint-plugin-baseline-js';

export default [
  { plugins: { 'baseline-js': baselineJs } },
  // opts: { available?: 'widely'|'newly'|YYYY; level?: 'error'|'warn' }
  baselineJs.configs.baseline({ available: 'widely', level: 'error' }),
]

rules: { 
  'baseline-js/use-baseline': [level, { available: baseline }]
}

import baselineJs from 'eslint-plugin-baseline-js';

export default [
  { plugins: { 'baseline-js': baselineJs } },
  // opts: { available?: 'widely'|'newly'|YYYY; level?: 'error'|'warn' }
  baselineJs.configs.recommended({ available: 'widely' }),
]

rules: {
  'baseline-js/use-baseline': [
    level,
    { 
      available: baseline,
      includeWebApis: { preset: 'auto' }, 
      includeJsBuiltins: { preset: 'auto' }
    },
  ],
}

import tsParser from '@typescript-eslint/parser';
import baselineJs from 'eslint-plugin-baseline-js';

export default [
  { files: ['**/*.{ts,tsx}'], languageOptions: { parser: tsParser, parserOptions: { project: ['./tsconfig.json'] } } },
  { plugins: { 'baseline-js': baselineJs } },
  // opts: { available?: 'widely'|'newly'|YYYY; level?: 'error'|'warn' }
  baselineJs.configs['recommended-ts']({ available: 'widely' }),
]

rules: {
  'baseline-js/use-baseline': [
    level,
    { 
      available: baseline,
      includeWebApis: { preset: 'type-aware' },
      includeJsBuiltins: { preset: 'type-aware' }
    },
  ],
}

Use with .eslintrc.* (non‑Flat Config)

Equivalent setup when not using Flat Config. For consistency, all arguments/options are unified under available.

// .eslintrc.js
module.exports = {
  plugins: ['baseline-js'],
  rules: {
    'baseline-js/use-baseline': ['error', { available: 'widely' }],
  },
};

// .eslintrc.js
module.exports = {
  plugins: ['baseline-js'],
  rules: {
    'baseline-js/use-baseline': ['error', {
      available: 'widely',
      includeWebApis: { preset: 'auto' },
      includeJsBuiltins: { preset: 'auto' },
    }],
  },
};

// .eslintrc.js
module.exports = {
  plugins: ['baseline-js'],
  overrides: [
    {
      files: ['**/*.ts', '**/*.tsx'],
      parser: '@typescript-eslint/parser',
      parserOptions: { project: ['./tsconfig.json'] },
      rules: {
        'baseline-js/use-baseline': ['error', {
          available: 'widely',
          includeWebApis: { preset: 'type-aware' },
          includeJsBuiltins: { preset: 'type-aware' },
        }],
      },
    },
  ],
};

// .eslintrc.js
const baselineJs = require('eslint-plugin-baseline-js');

module.exports = {
  plugins: ['baseline-js'],
  // Use either 'baseline' or 'recommended'
  baselineJs.configs.recommended({ available: 'widely' }),
};

// .eslintrc.js (TypeScript: recommended-ts)
const baselineJs = require('eslint-plugin-baseline-js');

module.exports = {
  plugins: ['baseline-js'],
  overrides: [
    {
      files: ['**/*.ts', '**/*.tsx'],
      parser: '@typescript-eslint/parser',
      parserOptions: { project: ['./tsconfig.json'] },
      baselineJs.configs['recommended-ts']({ available: 'widely' }),
    },
  ],
};

Messages

widely

Feature '<id>' is not a widely available Baseline feature. 

newly

Feature '<id>' is not a newly available Baseline feature. 

Year‑based

Feature '<id>' became Baseline in <YYYY> and exceeds <year>. 

Self rules (internal)

Minimal supplements where community rules don’t exist.

baseline-js/no-bigint64array

• Detects use of BigInt64Array / BigUint64Array (new / calls / member access)
• Limitation: shadowed identifiers/aliases not handled yet (ReferenceTracker TBD)

baseline-js/no-function-caller-arguments

• Detects Function#caller / Function#arguments
• Limitation: type‑unaware; may react to arbitrary objects’ .caller/.arguments

baseline-js/no-math-sum-precise

• Detects Math.sumPrecise() (proposal tracking)
• Limitation: alias calls not handled yet

baseline-js/no-temporal

• Detects Temporal API usage
• Limitation: shadowed/aliased Temporal not handled yet