or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

cli-tool.mdconstants-patterns.mdcore-configuration.mdfile-format-support.mdindex.mdlanguage-framework-support.mdstyling-formatting.mdutility-functions.md
tile.json

tessl/npm-antfu--eslint-config

Anthony's opinionated ESLint configuration with TypeScript, Vue, React support and auto-fixing

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@antfu/eslint-config@5.2.x

To install, run

npx @tessl/cli install tessl/npm-antfu--eslint-config@5.2.0

index.mddocs/

@antfu/eslint-config

Anthony's ESLint configuration preset designed for modern JavaScript and TypeScript development with strong opinions on code style and best practices. It offers automatic detection and support for multiple frameworks including Vue, React, Next.js, Svelte, Astro, and Solid, with built-in TypeScript support and flat config architecture.

Package Information

  • Package Name: @antfu/eslint-config
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install -D eslint @antfu/eslint-config

Core Imports

import antfu from "@antfu/eslint-config";

For CommonJS:

const antfu = require("@antfu/eslint-config");

Basic Usage

import antfu from "@antfu/eslint-config";

// Basic configuration
export default antfu();

// With TypeScript and Vue
export default antfu({
  typescript: true,
  vue: true,
});

// With custom options
export default antfu({
  stylistic: {
    indent: 2,
    quotes: "single",
  },
  typescript: {
    tsconfigPath: "./tsconfig.json",
  },
  ignores: ["**/fixtures", "**/temp"],
});

Architecture

@antfu/eslint-config is built around several key components:

  • Factory Function: Main antfu() function that composes ESLint flat configs
  • Configuration Modules: Individual config functions for each language/framework
  • Intelligent Detection: Automatic framework detection based on installed dependencies
  • Plugin Management: Automatic plugin renaming and installation prompts
  • Flat Config Composer: Built on eslint-flat-config-utils for advanced composition
  • CLI Tool: Interactive setup wizard for project initialization

Capabilities

Core Configuration

Main factory function for creating comprehensive ESLint configurations with intelligent defaults and extensive customization options.

function antfu(
  options?: OptionsConfig & Omit<TypedFlatConfigItem, 'files'>,
  ...userConfigs: Awaitable<TypedFlatConfigItem | TypedFlatConfigItem[] | FlatConfigComposer<any, any> | Linter.Config[]>[]
): FlatConfigComposer<TypedFlatConfigItem, ConfigNames>;

interface OptionsConfig extends OptionsComponentExts, OptionsProjectType {
  gitignore?: boolean | FlatGitignoreOptions;
  lessOpinionated?: boolean;
  javascript?: OptionsOverrides;
  typescript?: boolean | OptionsTypescript;
  jsx?: boolean | OptionsJSX;
  unicorn?: boolean | OptionsUnicorn;
  imports?: boolean | OptionsOverrides;
  test?: boolean | OptionsOverrides;
  vue?: boolean | OptionsVue;
  jsonc?: boolean | OptionsOverrides;
  yaml?: boolean | OptionsOverrides;
  toml?: boolean | OptionsOverrides;
  astro?: boolean | OptionsOverrides;
  markdown?: boolean | OptionsOverrides;
  stylistic?: boolean | (StylisticConfig & OptionsOverrides);
  regexp?: boolean | (OptionsRegExp & OptionsOverrides);
  react?: boolean | OptionsOverrides;
  nextjs?: boolean | OptionsOverrides;
  solid?: boolean | OptionsOverrides;
  svelte?: boolean | OptionsOverrides;
  unocss?: boolean | OptionsUnoCSS;
  pnpm?: boolean;
  formatters?: boolean | OptionsFormatters;
  isInEditor?: boolean;
  autoRenamePlugins?: boolean;
}

Core Configuration

Language & Framework Support

Individual configuration functions for specific languages and frameworks, providing tailored linting rules and settings.

function javascript(options?: OptionsIsInEditor & OptionsOverrides): Promise<TypedFlatConfigItem[]>;
function typescript(options?: OptionsFiles & OptionsComponentExts & OptionsOverrides & OptionsTypeScriptWithTypes & OptionsTypeScriptParserOptions & OptionsProjectType): Promise<TypedFlatConfigItem[]>;
function vue(options?: OptionsVue & OptionsHasTypeScript & OptionsOverrides & OptionsStylistic & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function react(options?: OptionsTypeScriptParserOptions & OptionsTypeScriptWithTypes & OptionsOverrides & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function svelte(options?: OptionsOverrides & OptionsStylistic & OptionsHasTypeScript & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function solid(options?: OptionsOverrides & OptionsFiles & OptionsTypeScriptWithTypes & OptionsHasTypeScript): Promise<TypedFlatConfigItem[]>;
function astro(options?: OptionsOverrides & OptionsStylistic & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function nextjs(options?: OptionsOverrides & OptionsFiles): Promise<TypedFlatConfigItem[]>;

Language & Framework Support

Quality & Code Enhancement

Rules for code quality, testing, imports, comments, and advanced linting features.

function imports(options?: OptionsOverrides & OptionsStylistic): Promise<TypedFlatConfigItem[]>;
function comments(): Promise<TypedFlatConfigItem[]>;
function test(options?: OptionsIsInEditor & OptionsOverrides & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function jsdoc(options?: OptionsStylistic): Promise<TypedFlatConfigItem[]>;
function jsx(options?: OptionsJSX): Promise<TypedFlatConfigItem[]>;
function node(): Promise<TypedFlatConfigItem[]>;
function unicorn(options?: OptionsUnicorn): Promise<TypedFlatConfigItem[]>;
function perfectionist(): Promise<TypedFlatConfigItem[]>;
function regexp(options?: OptionsRegExp & OptionsOverrides): Promise<TypedFlatConfigItem[]>;
function unocss(options?: OptionsUnoCSS & OptionsOverrides & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function command(): Promise<TypedFlatConfigItem[]>;
function disables(): Promise<TypedFlatConfigItem[]>;
function pnpm(): Promise<TypedFlatConfigItem[]>;
function sortPackageJson(): Promise<TypedFlatConfigItem[]>;
function sortTsconfig(): TypedFlatConfigItem[];
function ignores(userIgnores?: string[]): Promise<TypedFlatConfigItem[]>;

File Format Support

Configuration functions for various file formats including JSON, YAML, TOML, and Markdown.

function jsonc(options?: OptionsOverrides & OptionsStylistic & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function yaml(options?: OptionsOverrides & OptionsStylistic & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function toml(options?: OptionsOverrides & OptionsStylistic & OptionsFiles): Promise<TypedFlatConfigItem[]>;
function markdown(options?: OptionsOverrides & OptionsComponentExts & OptionsFiles): Promise<TypedFlatConfigItem[]>;

File Format Support

Styling & Formatting

Code style enforcement and external formatter integration for consistent code appearance.

function stylistic(options?: StylisticOptions): Promise<TypedFlatConfigItem[]>;
function formatters(options?: OptionsFormatters | true, stylistic?: StylisticConfig): Promise<TypedFlatConfigItem[]>;

interface StylisticConfig {
  indent?: number | 'tab';
  quotes?: 'single' | 'double';
  jsx?: boolean;
  semi?: boolean;
}

interface OptionsFormatters {
  css?: 'prettier' | boolean;
  html?: 'prettier' | boolean;
  xml?: 'prettier' | boolean;
  svg?: 'prettier' | boolean;
  markdown?: 'prettier' | 'dprint' | boolean;
  graphql?: 'prettier' | boolean;
  astro?: 'prettier' | boolean;
  prettierOptions?: VendoredPrettierOptions;
  dprintOptions?: boolean;
  slidev?: boolean | { files?: string[] };
}

Styling & Formatting

Utility Functions

Helper functions for configuration manipulation, plugin management, and environment detection.

const parserPlain: { meta: { name: string }; parseForESLint: (code: string) => object };
function combine(...configs: Awaitable<TypedFlatConfigItem | TypedFlatConfigItem[]>[]): Promise<TypedFlatConfigItem[]>;
function renameRules(rules: Record<string, any>, map: Record<string, string>): Record<string, any>;
function renamePluginInConfigs(configs: TypedFlatConfigItem[], map: Record<string, string>): TypedFlatConfigItem[];
function toArray<T>(value: T | T[]): T[];
function interopDefault<T>(m: Awaitable<T>): Promise<T extends { default: infer U } ? U : T>;
function isPackageInScope(name: string): boolean;
function ensurePackages(packages: (string | undefined)[]): Promise<void>;
function isInEditorEnv(): boolean;
function isInGitHooksOrLintStaged(): boolean;

Utility Functions

CLI Tool

Interactive command line interface for project setup and configuration migration.

function run(options?: CliRunOptions): Promise<void>;
function isGitClean(): boolean;
function getEslintConfigContent(mainConfig: string, additionalConfigs?: string[]): string;

interface CliRunOptions {
  yes?: boolean;
  frameworks?: string[];
  extra?: string[];
}

const vscodeSettingsString: string;
const frameworkOptions: PromItem<FrameworkOption>[];
const frameworks: FrameworkOption[];
const extraOptions: PromItem<ExtraLibrariesOption>[];
const extra: ExtraLibrariesOption[];
const dependenciesMap: Record<string, string[]>;

CLI Tool

Plugin Exports

Re-exported ESLint plugins for direct use.

const pluginComments: any;
const pluginAntfu: any;
const pluginImportLite: any;
const pluginNode: any;
const pluginPerfectionist: any;
const pluginUnicorn: any;
const pluginUnusedImports: any;

Constants & File Patterns

Pre-defined glob patterns and constants for file matching and configuration.

const GLOB_SRC_EXT: string;
const GLOB_SRC: string;
const GLOB_JS: string;
const GLOB_JSX: string;
const GLOB_TS: string;
const GLOB_TSX: string;
const GLOB_STYLE: string;
const GLOB_CSS: string;
const GLOB_POSTCSS: string;
const GLOB_LESS: string;
const GLOB_SCSS: string;
const GLOB_JSON: string;
const GLOB_JSON5: string;
const GLOB_JSONC: string;
const GLOB_YAML: string;
const GLOB_TOML: string;
const GLOB_MARKDOWN: string;
const GLOB_MARKDOWN_IN_MARKDOWN: string;
const GLOB_SVELTE: string;
const GLOB_VUE: string;
const GLOB_XML: string;
const GLOB_SVG: string;
const GLOB_HTML: string;
const GLOB_ASTRO: string;
const GLOB_ASTRO_TS: string;
const GLOB_GRAPHQL: string;
const GLOB_MARKDOWN_CODE: string;
const GLOB_TESTS: string[];
const GLOB_ALL_SRC: string[];
const GLOB_EXCLUDE: string[];
const defaultPluginRenaming: Record<string, string>;
const StylisticConfigDefaults: StylisticConfig;

Constants & File Patterns

Factory Helpers

Internal factory helper functions for configuration composition.

function resolveSubOptions<K extends keyof OptionsConfig>(options: OptionsConfig, key: K): ResolvedOptions<OptionsConfig[K]>;
function getOverrides<K extends keyof OptionsConfig>(options: OptionsConfig, key: K): Partial<Linter.RulesRecord & RuleOptions>;

Types

type Awaitable<T> = T | Promise<T>;
type Rules = Record<string, Linter.RuleEntry<any> | undefined> & RuleOptions;
type ConfigNames = string;

interface TypedFlatConfigItem extends Omit<Linter.Config, 'plugins' | 'rules'> {
  plugins?: Record<string, any>;
  rules?: Rules;
}

interface OptionsOverrides {
  overrides?: TypedFlatConfigItem['rules'];
}

interface OptionsFiles {
  files?: string[];
}

interface OptionsProjectType {
  type?: 'app' | 'lib';
}

interface OptionsComponentExts {
  componentExts?: string[];
}

interface OptionsVue {
  vueVersion?: 2 | 3;
  sfcBlocks?: boolean | VueSfcBlocksOptions;
}

interface OptionsJSXA11y {
  pluginJsxA11y?: any;
}

interface OptionsJSX {
  factory?: string;
  version?: string;
}

interface OptionsTypescript {
  tsconfigPath?: string | string[];
  parserOptions?: Partial<ParserOptions>;
  filesTypeAware?: string[];
}

interface OptionsUnicorn {
  rules?: Partial<UnicornRules>;
}

interface OptionsTypeScriptParserOptions {
  parserOptions?: Partial<ParserOptions>;
}

interface OptionsTypeScriptWithTypes {
  tsconfigPath?: string | string[];
  filesTypeAware?: string[];
}

interface OptionsHasTypeScript {
  typescript?: boolean;
}

interface OptionsStylistic {
  stylistic?: boolean | StylisticConfig;
}

interface OptionsIsInEditor {
  isInEditor?: boolean;
}

interface OptionsRegExp {
  level?: 'error' | 'warn';
}

interface OptionsUnoCSS {
  attributify?: boolean;
  strict?: boolean;
}

interface StylisticOptions extends StylisticConfig, OptionsOverrides {
  lessOpinionated?: boolean;
}

interface PromItem<T> {
  label?: string;
  value: T;
  hint?: string;
}

interface PromptResult {
  uncommittedChanges: boolean;
  frameworks: FrameworkOption[];
  extra?: ExtraLibrariesOption[];
  updateVscodeSettings: boolean;
}

type FrameworkOption = 'vue' | 'react' | 'svelte' | 'astro' | 'solid' | 'slidev' | 'next';
type ExtraLibrariesOption = 'formatter' | 'unocss';