eslint-flat-config-utils

Variables

• DEFAULT_PLUGIN_CONFLICTS_ERROR
• pipe

Functions

• composer()
• concat()
• defineFlatConfig()
• disableRuleFixes()
• extend()
• hijackPluginRule()
• mergeConfigs()
• parseRuleId()
• renamePluginsInConfigs()
• renamePluginsInRules()

Classes

• FlatConfigComposer

  • append()
  • catch()
  • clone()
  • disableRulesFix()
  • finally()
  • insertAfter()
  • insertBefore()
  • onResolved()
  • override()
  • overrideRules()
  • overrides()
  • prepend()
  • remove()
  • removePlugins()
  • removeRules()
  • renamePlugins()
  • replace()
  • setPluginConflictsError()
  • then()
  • toConfigs()
• FlatConfigPipeline

Interfaces

• DefaultConfigNamesMap
• DisableFixesOptions

  • builtinRules
• FlatConfigItem

Type Aliases

• Arrayable
• Awaitable
• FilterType
• GetRuleRecordFromConfig
• NullableObject
• PluginConflictsError
• ResolvableFlatConfig
• StringLiteralUnion

variable DEFAULT_PLUGIN_CONFLICTS_ERROR

const DEFAULT_PLUGIN_CONFLICTS_ERROR: string;

variable pipe

const pipe: <
 T extends Linter.Config = Linter.Config,
 ConfigNames extends string = never
>(
 ...configs: ResolvableFlatConfig<Linter.Config extends T ? T : Linter.Config>[]
) => FlatConfigComposer<Linter.Config extends T ? T : Linter.Config, ConfigNames>;

• Deprecated

  Renamed to composer.

function composer

composer: <
 T extends Linter.Config = Linter.Config,
 ConfigNames extends string = never
>(
 ...configs: ResolvableFlatConfig<Linter.Config extends T ? T : Linter.Config>[]
) => FlatConfigComposer<Linter.Config extends T ? T : Linter.Config, ConfigNames>;

• Create a chainable composer object that makes manipulating ESLint flat config easier.

  It extends Promise, so that you can directly await or export it to eslint.config.mjs

  // eslint.config.mjs
  import { composer } from 'eslint-flat-config-utils'
   
  export default composer(
   {
   plugins: {},
   rules: {},
   }
   // ...some configs, accepts same arguments as `concat`
  )
   .append(
   // appends more configs at the end, accepts same arguments as `concat`
   )
   .prepend(
   // prepends more configs at the beginning, accepts same arguments as `concat`
   )
   .insertAfter(
   'config-name', // specify the name of the target config, or index
   // insert more configs after the target, accepts same arguments as `concat`
   )
   .renamePlugins({
   // rename plugins
   'old-name': 'new-name',
   // for example, rename `n` from `eslint-plugin-n` to more a explicit prefix `node`
   'n': 'node'
   // applies to all plugins and rules in the configs
   })
   .override(
   'config-name', // specify the name of the target config, or index
   {
   // merge with the target config
   rules: {
   'no-console': 'off'
   },
   }
   )
   
  // And you an directly return the composer object to `eslint.config.mjs`

function concat

concat: <T extends Linter.Config = Linter.Config>(
 ...configs: Awaitable<T | T[]>[]
) => Promise<T[]>;

• Concat multiple flat configs into a single flat config array.

  It also resolves promises and flattens the result.

  Example 1

  import { concat } from 'eslint-flat-config-utils'
  import eslint from '@eslint/js'
  import stylistic from '@stylistic/eslint-plugin'
   
  export default concat(
   eslint,
   stylistic.configs.customize(),
   { rules: { 'no-console': 'off' } },
   // ...
  )

function defineFlatConfig

defineFlatConfig: <T extends Linter.Config = Linter.Config>(config: T) => T;

• A function that returns the config as-is, useful for providing type hints.

function disableRuleFixes

disableRuleFixes: (rule: Rule.RuleModule) => Rule.RuleModule;

• Hijack into a rule's context.report to disable fixes.

function extend

extend: (
 configs: Awaitable<Linter.Config[]>,
 relativePath: string
) => Promise<Linter.Config[]>;

• Extend another flat configs and rename globs paths.

  Example 1

  import { extend } from 'eslint-flat-config-utils'
   
  export default [
   ...await extend(
   // configs to extend
   import('./other-configs/eslint.config.js').then(m => m.default),
   // relative directory path
   'other-configs/',
   ),
  ]

function hijackPluginRule

hijackPluginRule: (
 plugin: ESLint.Plugin,
 name: string,
 factory: (rule: Rule.RuleModule) => Rule.RuleModule
) => ESLint.Plugin;

• Replace a rule in a plugin with given factory.

function mergeConfigs

mergeConfigs: <T extends Linter.Config = Linter.Config>(...configs: T[]) => T;

• Merge multiple flat configs into a single flat config.

  Note there is no guarantee that the result works the same as the original configs.

function parseRuleId

parseRuleId: (ruleId: string) => { plugin: string | null; rule: string };

function renamePluginsInConfigs

renamePluginsInConfigs: <T extends Linter.Config = Linter.Config>(
 configs: T[],
 map: Record<string, string>
) => T[];

• Rename plugin names a flat configs array

  Example 1

  import { renamePluginsInConfigs } from 'eslint-flat-config-utils'
  import someConfigs from './some-configs'
   
  export default renamePluginsInConfigs(someConfigs, {
   '@typescript-eslint': 'ts',
   'import-x': 'import',
  })

function renamePluginsInRules

renamePluginsInRules: (
 rules: Record<string, any>,
 map: Record<string, string>
) => Record<string, any>;

• Rename plugin prefixes in a rule object. Accepts a map of prefixes to rename.

  Example 1

  import { renamePluginsInRules } from 'eslint-flat-config-utils'
   
  export default [{
   rules: renamePluginsInRules(
   {
   '@typescript-eslint/indent': 'error'
   },
   { '@typescript-eslint': 'ts' }
   )
  }]

type Arrayable

type Arrayable<T> = T | T[];

• A type that can be an array or a single item.

type Awaitable

type Awaitable<T> = T | Promise<T>;

• A type that can be awaited. Promise or T.

type FilterType

type FilterType<T, F> = T extends F ? T : never;

type GetRuleRecordFromConfig

type GetRuleRecordFromConfig<T> = T extends {
 rules?: infer R;
}
 ? R
 : Linter.RulesRecord;

type NullableObject

type NullableObject<T> = {
 [K in keyof T]?: T[K] | null | undefined;
};

type PluginConflictsError

type PluginConflictsError<T extends Linter.Config = Linter.Config> = (
 pluginName: string,
 configs: T[]
) => string;

type ResolvableFlatConfig

type ResolvableFlatConfig<T extends Linter.Config = Linter.Config> =
 | Awaitable<Arrayable<T | false | undefined | null>>
 | Awaitable<(Linter.Config | false | undefined | null)[]>
 | FlatConfigComposer<any>;

• Awaitable array of ESLint flat configs or a composer object.

type StringLiteralUnion

type StringLiteralUnion<T extends U, U = string> = T | (U & Nothing);

• type StringLiteralUnion<'foo'> = 'foo' | string This has auto completion whereas 'foo' | string doesn't Adapted from https://github.com/microsoft/TypeScript/issues/29729