Skip to content

./configs ​

Programmatic exports include createAngularConfigs, createCommonConfigs, createCommonJsConfigs, createEnvironmentConfigs, createNodeToolingConfigs, createImportConfigs, createJavaScriptConfig(s), createJsonExtends, createJsonConfigs, createLodashConfigs, createMarkdownConfigs, createPrettierConfigs, createPromiseConfigs, createReactConfigs, createRegexpConfigs, createPackageJsonSortConfigs, createTsconfigSortConfigs, createTypeScriptParserOptions, createTypeScriptExtends, createTypeScriptConfig(s), createTypeScriptDeclarationConfigs, createTypeAwareConfigs, createVueConfigs, createYamlConfigs, and their option types.

js
const { createPromiseConfigs, createRegexpConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	overrides: [
		...createPromiseConfigs(["src/**/*.{js,ts}"]),
		...createRegexpConfigs(["src/**/*.{js,ts}"]),
		{
			files: ["src/**/*.{js,ts}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Factories return ESLint 8 legacy configs or overrides. Place fragments at the correct root, extends, or overrides level.

createAngularConfigs Create ​

Creates Angular TypeScript, external-template, and inline-template legacy overrides.

The TypeScript override inherits typescript-eslint before Angular recommended rules. When inline templates are enabled, the same override registers the Angular template processor. External templates always use their dedicated parser. An empty file scope produces no corresponding override.

Signature ​

ts
export const createAngularConfigs = ({
		inlineTemplates = true,
		templateAccessibility = true,
		templateFiles = [GLOB_ANGULAR_TEMPLATE],
		typescriptFiles = [GLOB_ANGULAR_TYPESCRIPT],
	}: AngularConfigOptions = {}, typeScriptOptions: TypeScriptConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createAngularConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createAngularConfigs({ inlineTemplates: true, templateAccessibility: true }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsAngularConfigOptionsOptional; defaults to {}Angular file scopes, processor, and template accessibility options.
typeScriptOptionsTypeScriptConfigOptionsOptional; defaults to {}Parser and type-aware options passed to the TypeScript layer.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]ESLint 8 overrides ordered by TypeScript source, then external templates.

createCommonConfigs Create ​

Creates base configuration across JavaScript, TypeScript, Vue, React, and Angular sources.

eslint:recommended provides language-level correctness; documented common rules are appended afterward.

Signature ​

ts
export const createCommonConfigs = (files: readonly string[] = GLOBS_CODE): Linter.ConfigOverride[];

Example ​

js
const { createCommonConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createCommonConfigs(["src/**/*.{js,ts}"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
filesreadonly string[]Optional; defaults to GLOBS_CODEGlobs receiving base correctness rules.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One file-scoped override; an empty file set returns an empty array.

createCommonJsConfigs Create ​

Creates a CommonJS-extension compatibility override.

.cjs and .cts already identify module format, so the TypeScript prohibition on require() is disabled; the override changes neither parser, env, nor other module rules.

Signature ​

ts
export const createCommonJsConfigs = (): Linter.ConfigOverride[];

Example ​

js
const { createCommonJsConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createCommonJsConfigs(),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

This method has no input parameters.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One rule override shared by .cjs and .cts files.

createEnvironmentConfigs Create ​

Creates application runtime environment configuration.

Signature ​

ts
export const createEnvironmentConfigs = ({ environment = "browser", files = [] }: EnvironmentConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createEnvironmentConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createEnvironmentConfigs({ environment: "browser", files: ["src/**/*.ts"] }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsEnvironmentConfigOptionsOptional; defaults to {}Runtime environment and target files.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One file-scoped env override; an empty scope returns an empty array.

createNodeToolingConfigs Create ​

Creates Node tooling environment configuration.

Matches only config, setup, scripts, bin, CLI, and test tooling files, keeping Node globals out of browser application source. Apply after language rules to reliably disable no-console in tooling.

Signature ​

ts
export const createNodeToolingConfigs = (): Linter.ConfigOverride[];

Example ​

js
const { createNodeToolingConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createNodeToolingConfigs(),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

This method has no input parameters.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One Node-tooling-specific override.

createImportConfigs Create ​

Creates module-import configuration.

The shared library does not guess aliases or resolvers; it enables import-x recommendations and deterministic ordering, while importRules explicitly disables resolver-dependent rules.

Signature ​

ts
export const createImportConfigs = (files: readonly string[]): Linter.ConfigOverride[];

Example ​

js
const { createImportConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createImportConfigs(["src/**/*.{ts,tsx}"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
filesreadonly string[]RequiredScript/framework file globs receiving import-x rules.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One file-scoped override; an empty file set returns an empty array.

createJavaScriptConfig Create ​

Creates JavaScript and JSX configuration.

Explicitly enables JSX parsing; earlier createCommonConfigs() supplies base correctness and common rules.

Signature ​

ts
export const createJavaScriptConfig = (files: readonly string[] = GLOBS_JAVASCRIPT): JavaScriptConfigOverride;

Example ​

js
const { createJavaScriptConfig } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		createJavaScriptConfig(["src/**/*.js"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
filesreadonly string[]Optional; defaults to GLOBS_JAVASCRIPTJavaScript file globs owned by this override.

Returns ​

ValueTypeDescription
configsJavaScriptConfigOverrideOne override with parserOptions and local JavaScript rules.

createJavaScriptConfigs Create ​

Wraps the configuration in an override array for composition.

Signature ​

ts
export const createJavaScriptConfigs = (files: readonly string[] = GLOBS_JAVASCRIPT): Linter.ConfigOverride[];

Example ​

js
const { createJavaScriptConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createJavaScriptConfigs(["src/**/*.js"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
filesreadonly string[]Optional; defaults to GLOBS_JAVASCRIPTFile globs owned by JavaScript configuration.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]Array always containing one JavaScript override.

createJsonExtends Create ​

Returns the legacy recommended extends chain for a JSON dialect.

Signature ​

ts
export const createJsonExtends = (dialect: "json" | "json5" | "jsonc", prettier = true): string[];

Example ​

js
const { createJsonExtends } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		{
			files: ["**/*.jsonc"],
			extends: createJsonExtends("jsonc", true),
			rules: { "jsonc/sort-keys": "off" },
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
dialect"json" | "json5" | "jsonc"RequiredStrict JSON, JSON5, or comment-permitting JSONC.
prettierunknownOptional; defaults to trueWhether to disable Prettier-conflicting rules after recommendations.

Returns ​

ValueTypeDescription
configsstring[]Ordered names usable directly as legacy override extends.

createJsonConfigs Create ​

Creates JSON, JSONC, and JSON5 configuration.

Strict JSON excludes .json-named tsconfig and VS Code settings files whose formats permit comments. Each dialect uses its own override so strict JSON rules do not misread JSONC/JSON5.

Signature ​

ts
export const createJsonConfigs = ({ prettier = true }: JsonConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createJsonConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createJsonConfigs({ prettier: true }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsJsonConfigOptionsOptional; defaults to {}Prettier compatibility switch.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]Overrides ordered by strict JSON, JSONC, JSON5, VS Code settings, then tsconfig.

createLodashConfigs Create ​

Creates Lodash static-import source restrictions.

Signature ​

ts
export const createLodashConfigs = (preference: LodashPreference, files: readonly string[]): Linter.ConfigOverride[];

Example ​

js
const { createLodashConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createLodashConfigs("lodash", ["src/**/*.ts"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
preferenceLodashPreferenceRequiredOnly permitted Lodash package entry.
filesreadonly string[]RequiredCode globs receiving this organizational policy.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One rule override; empty file sets return an empty array.

createMarkdownConfigs Create ​

Creates Markdown processor and virtual-code-block configuration.

Examples lack full project context, so noisy resolver, unused-symbol, and console checks are disabled. Root processor extends and virtual-file overrides are returned separately; preserve both and their order.

Signature ​

ts
export const createMarkdownConfigs = (): MarkdownConfigs;

Example ​

js
const { createMarkdownConfigs } = require("@fast-china/eslint-config-legacy/configs");

const markdown = createMarkdownConfigs();

module.exports = {
	root: true,
	extends: markdown.extends,
	overrides: [
		...markdown.overrides,
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

This method has no input parameters.

Returns ​

ValueTypeDescription
configsMarkdownConfigsCombined root Markdown extends and code-block override result.

createPrettierConfigs Create ​

Creates the Prettier compatibility layer.

Only disables conflicting rules; it does not execute Prettier in ESLint. Project rules still apply afterward.

Signature ​

ts
export const createPrettierConfigs = (files: readonly string[]): Linter.ConfigOverride[];

Example ​

js
const { createPrettierConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createPrettierConfigs(["src/**/*.{js,ts}"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
filesreadonly string[]RequiredCode globs requiring formatting-conflict rules disabled.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One Prettier compatibility override; empty file sets return an empty array.

createPromiseConfigs Create ​

Creates recommended Promise control-flow/error-handling configuration.

Applies plugin:promise/recommended without starting type services; type-aware Promise checks come from typescript-eslint presets in /type-aware.

Signature ​

ts
export const createPromiseConfigs = (files: readonly string[]): Linter.ConfigOverride[];

Example ​

js
const { createPromiseConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createPromiseConfigs(["src/**/*.{js,ts}"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
filesreadonly string[]RequiredCode globs receiving Promise rules.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One recommended-rule override; empty file sets return an empty array.

createReactConfigs Create ​

Creates React, Hooks, and JSX-accessibility legacy overrides.

JavaScript and TypeScript use separate overrides while sharing React, Hooks, JSX accessibility extends and React version settings. TSX additionally disables PropTypes; automatic runtime disables React-in-scope rules. Disabled languages or empty scopes produce no corresponding override.

Signature ​

ts
export const createReactConfigs = ({
		javascriptFiles = [...GLOBS_JAVASCRIPT],
		jsxRuntime = "automatic",
		typescriptFiles = [...GLOBS_TYPESCRIPT],
		version = "detect",
	}: ReactConfigOptions = {}, { javascript = true, typescript = true, typescriptOptions = {} }: ReactLanguageOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createReactConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createReactConfigs({ importSource: "react", version: "detect" }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsReactConfigOptionsOptional; defaults to {}React version, JSX runtime, and both language file scopes.
optionsReactLanguageOptionsOptional; defaults to {}React version, JSX runtime, and both language file scopes.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]React overrides ordered by JavaScript, then TypeScript.

createRegexpConfigs Create ​

Creates regular-expression correctness/security configuration.

Explicitly enables invalid-structure, potential-error, and catastrophic-backtracking rules matching the modern config, without inheriting the style-oriented full recommended preset. Some rules autofix; verify actual matching behavior afterward.

Signature ​

ts
export const createRegexpConfigs = (files: readonly string[]): Linter.ConfigOverride[];

Example ​

js
const { createRegexpConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createRegexpConfigs(["src/**/*.{js,ts}"]),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
filesreadonly string[]RequiredCode globs receiving RegExp rules.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One recommended-rule override; empty file sets return an empty array.

createPackageJsonSortConfigs Create ​

Creates an explicitly enabled package.json sorting override.

Without a loaded JSON base configuration, supplies the strict JSON parser and recommended rules for package.json. packageJsonSortRules defines ordering and intentionally avoids conditional-export objects.

Signature ​

ts
export const createPackageJsonSortConfigs = ({ json = true, prettier = true }: PackageJsonSortConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createPackageJsonSortConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createPackageJsonSortConfigs({ json: true, prettier: true }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsPackageJsonSortConfigOptionsOptional; defaults to {}Whether JSON base configuration exists and whether Prettier compatibility is enabled.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One override matching only package.json.

createTsconfigSortConfigs Create ​

Creates an explicitly enabled tsconfig*.json sorting override.

Without JSON base configuration, supplies a JSONC parser and recommended rules, preserving valid comments. Sorting changes field order only, not compiler options, file lists, or project-reference values.

Signature ​

ts
export const createTsconfigSortConfigs = ({ json = true, prettier = true }: TsconfigSortConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createTsconfigSortConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createTsconfigSortConfigs({ json: true, prettier: true }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsTsconfigSortConfigOptionsOptional; defaults to {}Whether JSON base configuration exists and whether Prettier compatibility is enabled.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One override matching base and derived tsconfig files.

createTypeScriptParserOptions Create ​

Creates shared parserOptions for TypeScript and Vue TypeScript.

Non-type-aware mode declares modern ECMAScript module semantics. Type-aware mode additionally starts Project Service with consistent Vue/NVue extensions and sets tsconfigRootDir only when explicitly supplied. All type-aware files must share extraFileExtensions to avoid repeated TypeScript Server reloads while checking mixed TypeScript and Vue files.

Signature ​

ts
export const createTypeScriptParserOptions = (options: TypeAwareOptions = {}): Linter.ParserOptions;

Example ​

js
const { createTypeScriptParserOptions } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	parser: "@typescript-eslint/parser",
	parserOptions: createTypeScriptParserOptions({ typeChecked: true }),
	extends: ["@fast-china/eslint-config-legacy/typescript"],
};

Input ​

InputTypeRequired / defaultDescription
optionsTypeAwareOptionsOptional; defaults to {}Type-aware switch and optional tsconfig root.

Returns ​

ValueTypeDescription
configsLinter.ParserOptionsNew parserOptions usable by @typescript-eslint/parser or a Vue child parser.

createTypeScriptExtends Create ​

Returns typescript-eslint legacy recommendations for the selected type-aware mode.

Signature ​

ts
export const createTypeScriptExtends = (options: TypeAwareOptions = {}): string[];

Example ​

js
const { createTypeScriptExtends } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		{
			files: ["src/**/*.ts"],
			extends: createTypeScriptExtends({}),
			rules: { "no-console": "warn" },
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsTypeAwareOptionsOptional; defaults to {}Type-aware switch.

Returns ​

ValueTypeDescription
configsstring[]Legacy extends names corresponding to the modern recommendedTypeChecked baseline.

createTypeScriptConfig Create ​

Creates TypeScript configuration.

Local JavaScript rules also apply to TypeScript, followed by typescript-eslint replacements disabling core rules that do not understand type syntax.

Signature ​

ts
export const createTypeScriptConfig = (options: TypeScriptConfigOptions = {}, files: readonly string[] = options.files ?? GLOBS_TYPESCRIPT): TypeScriptConfigOverride;

Example ​

js
const { createTypeScriptConfig } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		createTypeScriptConfig({}),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsTypeScriptConfigOptionsOptional; defaults to {}TypeScript file scopes and type-aware parser options.
filesreadonly string[]Optional; defaults to options.files ?? GLOBS_TYPESCRIPTExplicit file scope overriding options.files for framework reuse.

Returns ​

ValueTypeDescription
configsTypeScriptConfigOverrideOne override containing parser, extends, parserOptions, and complete local rules.

createTypeScriptConfigs Create ​

Wraps the configuration in an override array for composition.

Signature ​

ts
export const createTypeScriptConfigs = (options: TypeScriptConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createTypeScriptConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createTypeScriptConfigs({ typeChecked: true }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsTypeScriptConfigOptionsOptional; defaults to {}TypeScript file scope and parser options.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]Array always containing one TypeScript override.

createTypeScriptDeclarationConfigs Create ​

Creates TypeScript declaration-file compatibility overrides.

Declaration files may contain unused public symbols and imports used only for global augmentation, so implementation-cleanup unused/type-import rules are disabled. Place after ordinary TypeScript configuration.

Signature ​

ts
export const createTypeScriptDeclarationConfigs = (): Linter.ConfigOverride[];

Example ​

js
const { createTypeScriptDeclarationConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createTypeScriptDeclarationConfigs(),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

This method has no input parameters.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One override for .d.ts, .d.cts, and .d.mts.

createTypeAwareConfigs Create ​

Creates type-aware fragments composable after TypeScript, React, Angular, or Vue configuration.

Project Service finds the nearest tsconfig above each checked file; complex monorepos can add parserOptions.tsconfigRootDir in their own eslintrc overrides. TypeScript/TSX and Vue SFC use separate parser chains to avoid treating templates as TypeScript.

Signature ​

ts
export const createTypeAwareConfigs = (): Linter.ConfigOverride[];

Example ​

js
const { createTypeAwareConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createTypeAwareConfigs(),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

This method has no input parameters.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]Two type-aware overrides for TypeScript dialects, then Vue SFCs.

createVueConfigs Create ​

Creates Vue 2/3 SFC configuration.

vue-eslint-parser always parses templates; when TypeScript is enabled, parserOptions.parser handles scripts and TypeScript core replacements. Common Vue rules follow upstream presets, with Vue-major-specific rules applied last.

Signature ​

ts
export const createVueConfigs = ({
	files = [GLOB_VUE],
	typeChecked = false,
	tsconfigRootDir,
	typescript = true,
	version = 3,
}: VueConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createVueConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createVueConfigs({ version: 3, typescript: true }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsVueConfigOptionsOptional; defaults to {}Vue major version, file scopes, TypeScript, and type-aware options.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One legacy override matching Vue SFCs.

createYamlConfigs Create ​

Creates YAML parsing, recommended rules, and optional Prettier compatibility.

Signature ​

ts
export const createYamlConfigs = ({ prettier = true }: YamlConfigOptions = {}): Linter.ConfigOverride[];

Example ​

js
const { createYamlConfigs } = require("@fast-china/eslint-config-legacy/configs");

module.exports = {
	root: true,
	overrides: [
		...createYamlConfigs({ prettier: true }),
		{
			files: ["src/**/*.{js,ts,vue}"],
			rules: {
				"no-console": "warn",
			},
		},
	],
};

Input ​

InputTypeRequired / defaultDescription
optionsYamlConfigOptionsOptional; defaults to {}Prettier compatibility switch.

Returns ​

ValueTypeDescription
configsLinter.ConfigOverride[]One override matching .yaml and .yml.