Config

Presets (Flat Config)Copy Anchor Link

Register the plugin under baseline-js before using a preset. All helpers accept available and level. Their defaults are 'widely' and 'error'. They also accept baseline as an alias for available.

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

export default [
  { plugins: { 'baseline-js': baselineJs } },
  baselineJs.configs.recommended({ available: 'widely', level: 'warn' }), 
];

Rule optionsCopy Anchor Link

Use these options with baseline-js/use-baseline.

available: 'widely' reports features that are not widely available. available: 'newly' reports features with Limited availability. A year reports features that entered Baseline after that year, plus features with Limited availability.

Additional Web API and built-in checks use the matched API member's Baseline status when available. Members grouped under one feature can have different dates or availability: URL.parse(), for example, is newer than the URL interface. Feature-level coverage tables describe the group; only, ignore, and ignoreFeatures continue to use feature IDs.

These checks use the data bundled with the installed plugin. See Concepts for the policy and coverage limits.

Feature detectionCopy Anchor Link

The rule always checks its mapped features. Additional Web API and built-in detection is off unless you enable it.

If you already use the rule directly, add these two options for the recommended detection behavior:

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

export default [
  {
    files: ['**/*.{js,mjs,cjs}'],
    plugins: { 'baseline-js': baselineJs },
    rules: {
      'baseline-js/use-baseline': ['error', {
        available: 'widely',
        includeWebApis: { preset: 'auto' }, 
        includeJsBuiltins: { preset: 'auto' }, 
      }],
    },
  },
];

Both includeWebApis and includeJsBuiltins accept the same options:

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

Without type information, auto and type-aware skip instance-member and other type-dependent checks. They still run the remaining checks and do not throw an error.

The safe checks include global constructors, static members, and selected constructor options. Instance method arguments, such as Canvas context options and WebGL extension names, require type information and auto or type-aware mode. These checks verify the receiver's standard-library member before reporting a literal argument. They do not cover every API or usage pattern.

Typed checks use members declared in the program's standard libraries, including compiler-selected replacement libraries. A member added only by a user declaration does not establish native API usage.

Typed instance checks recognize well-known Symbol keys such as stream[Symbol.asyncIterator]. The key must retain its unique symbol type from the standard library. Custom keys, aliases widened to symbol, and custom member overrides do not establish native API usage. The string '@@iterator' is not a Symbol key.

Buffer constructor checks require an object literal with a known final maxByteLength value. An explicit non-undefined primitive literal qualifies. An unresolved value, getter, or later spread does not. ArrayBuffer options work in safe mode. SharedArrayBuffer options require type information for JavaScript built-in checks. Options variables remain outside these checks.

type Include = boolean | {
  preset?: 'safe' | 'auto' | 'type-aware' | 'heuristic';
  useTypes?: 'off' | 'auto' | 'require';
  heuristics?: 'off' | 'conservative' | 'aggressive';
  only?: string[];
  ignore?: string[];
};

Feature filtersCopy Anchor Link

only and ignore accept exact web-features IDs within that detector. They do not support regular expressions or change the mapped-rule checks. An empty only array does not limit detection. Add this rules property to your existing config object.

rules: {
  'baseline-js/use-baseline': ['error', {
    available: 'widely',
    includeJsBuiltins: {
      preset: 'auto',
      only: ['iterator-join', 'set-methods'], 
    },
  }],
}

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

Legacy config (.eslintrc)Copy Anchor Link

Use Flat Config with this package. Its ESM default export does not load correctly through ESLint 9's legacy plugin loader.

ESLint 10 also removes legacy config support. See Examples for supported Flat Config setups.

Use with oxlintCopy Anchor Link

Load the package as an oxlint JavaScript plugin.

{
  "jsPlugins": ["eslint-plugin-baseline-js"], 
  "rules": {
    "baseline-js/use-baseline": [
      "warn",
      {
        "available": "widely",
        "includeWebApis": { "preset": "auto" },
        "includeJsBuiltins": { "preset": "auto" }
      }
    ]
  }
}

See oxlint for setup details and the FAQ for detection limits.

MessagesCopy Anchor Link

The highlighted line shows the reported usage. Messages name the API or feature, your configured Baseline target, and the reason it does not meet that target. Each message ends with a Feature ID for use in ignoreFeatures.

Static APIs use canonical paths such as 'Object.groupBy'. Additional instance-member checks use descriptions such as The 'union' member of Set instances. These members can be methods or properties.

In call patterns, ... marks unspecified values and | separates alternatives.

const year = new Date().getYear(); 

'Date.prototype.getYear' does not meet your Baseline Widely available target. It has Limited availability. Feature ID: date-get-year-set-year.

When diagnostic text changes, tests that snapshot it need updated expectations.

Standalone rulesCopy Anchor Link

Most projects should use baseline-js/use-baseline. It enables mapped checks based on the selected Baseline threshold.

These rules are also exported directly. When enabled directly, they report matching usage without checking a Baseline threshold.

The global-based rules check for shadowed globals and support window and globalThis prefixes. They do not follow aliases. no-function-caller-arguments recognizes function expressions, function declarations and function initializers without reassignment, and unshadowed Function.prototype. It skips unknown receivers, parameters, imports, aliases, and reassigned bindings.