@rhapsodic/eslint-config 0.1.0

package/dist/index.mjs

@@ -0,0 +1,890 @@
+import pluginImportX from "eslint-plugin-import-x";
+import pluginUnicorn from "eslint-plugin-unicorn";
+import globals from "globals";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { isPackageExists } from "local-pkg";
+import { mergeProcessors } from "eslint-merge-processors";
+import { FlatConfigComposer } from "eslint-flat-config-utils";
+
+//#region src/configs/disables.ts
+async function disables() {
+	return [{
+		files: ["**/*.js", "**/*.cjs"],
+		name: "rhapsodic/disables/cjs",
+		rules: {
+			"ts/explicit-function-return-type": "off",
+			"ts/explicit-module-boundary-types": "off",
+			"ts/no-var-requires": "off",
+			"unicorn/prefer-module": "off"
+		}
+	}];
+}
+
+//#endregion
+//#region src/globs.ts
+const GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+const GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+const GLOB_JS = "**/*.?([cm])js";
+const GLOB_JSX = "**/*.?([cm])jsx";
+const GLOB_TS = "**/*.?([cm])ts";
+const GLOB_TSX = "**/*.?([cm])tsx";
+const GLOB_VUE = "**/*.vue";
+const GLOB_TESTS = [
+	`**/__tests__/**/*.${GLOB_SRC_EXT}`,
+	`**/*.spec.${GLOB_SRC_EXT}`,
+	`**/*.test.${GLOB_SRC_EXT}`,
+	`**/*.bench.${GLOB_SRC_EXT}`,
+	`**/*.benchmark.${GLOB_SRC_EXT}`
+];
+const GLOB_ALL_SRC = [GLOB_SRC, GLOB_VUE];
+const GLOB_EXCLUDE = [
+	"**/node_modules",
+	"**/dist",
+	"**/package-lock.json",
+	"**/yarn.lock",
+	"**/pnpm-lock.yaml",
+	"**/bun.lockb",
+	"**/output",
+	"**/coverage",
+	"**/temp",
+	"**/.temp",
+	"**/tmp",
+	"**/.tmp",
+	"**/.history",
+	"**/.vitepress/cache",
+	"**/.nuxt",
+	"**/.next",
+	"**/.svelte-kit",
+	"**/.vercel",
+	"**/.changeset",
+	"**/.idea",
+	"**/.cache",
+	"**/.output",
+	"**/.vite-inspect",
+	"**/.yarn",
+	"**/vite.config.*.timestamp-*",
+	"**/CHANGELOG*.md",
+	"**/*.min.*",
+	"**/LICENSE*",
+	"**/__snapshots__",
+	"**/auto-import?(s).d.ts",
+	"**/components.d.ts"
+];
+
+//#endregion
+//#region src/configs/ignores.ts
+async function ignores(userIgnores = []) {
+	let ignoresArray = [...GLOB_EXCLUDE];
+	if (typeof userIgnores === "function") ignoresArray = userIgnores(ignoresArray);
+	else ignoresArray = [...ignoresArray, ...userIgnores];
+	return [{
+		ignores: ignoresArray,
+		name: "rhapsodic/ignores"
+	}];
+}
+
+//#endregion
+//#region src/configs/imports.ts
+async function imports(options = {}) {
+	const { overrides = {}, stylistic: stylistic$1 = true } = options;
+	return [{
+		name: "rhapsodic/imports/rules",
+		plugins: { import: pluginImportX },
+		rules: {
+			"import/default": "error",
+			"import/namespace": "error",
+			"import/export": "error",
+			"import/no-named-as-default": "warn",
+			"import/no-named-as-default-member": "warn",
+			"import/no-duplicates": "warn",
+			...stylistic$1 ? { "import/newline-after-import": ["error", { count: 1 }] } : {},
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+//#region src/configs/javascript.ts
+async function javascript(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		languageOptions: {
+			ecmaVersion: "latest",
+			globals: {
+				...globals.browser,
+				...globals.es2021,
+				...globals.node,
+				document: "readonly",
+				navigator: "readonly",
+				window: "readonly"
+			},
+			parserOptions: {
+				ecmaVersion: "latest",
+				sourceType: "module"
+			},
+			sourceType: "module"
+		},
+		linterOptions: { reportUnusedDisableDirectives: true },
+		name: "rhapsodic/javascript/setup"
+	}, {
+		name: "rhapsodic/javascript/rules",
+		rules: {
+			"constructor-super": "error",
+			"for-direction": "error",
+			"getter-return": ["error", { allowImplicit: true }],
+			"no-async-promise-executor": "error",
+			"no-await-in-loop": "off",
+			"no-case-declarations": "error",
+			"no-class-assign": "error",
+			"no-compare-neg-zero": "error",
+			"no-cond-assign": "error",
+			"no-console": "off",
+			"no-const-assign": "error",
+			"no-constant-binary-expression": "error",
+			"no-constant-condition": "error",
+			"no-continue": "off",
+			"no-control-regex": "error",
+			"no-debugger": "error",
+			"no-delete-var": "error",
+			"no-dupe-args": "error",
+			"no-dupe-class-members": "error",
+			"no-dupe-else-if": "error",
+			"no-dupe-keys": "error",
+			"no-duplicate-case": "error",
+			"no-empty": "error",
+			"no-empty-character-class": "error",
+			"no-empty-pattern": "error",
+			"no-empty-static-block": "error",
+			"no-ex-assign": "error",
+			"no-extra-boolean-cast": "error",
+			"no-fallthrough": "error",
+			"no-func-assign": "error",
+			"no-global-assign": "error",
+			"no-import-assign": "error",
+			"no-implicit-coercion": ["error", { allow: ["!!", "+"] }],
+			"no-invalid-regexp": "error",
+			"no-irregular-whitespace": "error",
+			"no-loss-of-precision": "error",
+			"no-misleading-character-class": "error",
+			"no-new-native-nonconstructor": "error",
+			"no-new-symbol": "error",
+			"no-nonoctal-decimal-escape": "error",
+			"no-obj-calls": "error",
+			"no-octal": "error",
+			"no-plusplus": "off",
+			"no-prototype-builtins": "error",
+			"no-redeclare": "error",
+			"no-regex-spaces": "error",
+			"no-self-assign": "error",
+			"no-setter-return": "error",
+			"no-shadow": "off",
+			"no-shadow-restricted-names": "error",
+			"no-sparse-arrays": "error",
+			"no-this-before-super": "error",
+			"no-unassigned-vars": "error",
+			"no-undef": "error",
+			"no-underscore-dangle": "off",
+			"no-unexpected-multiline": "error",
+			"no-unreachable": "error",
+			"no-unsafe-finally": "error",
+			"no-unsafe-negation": "error",
+			"no-unsafe-optional-chaining": "error",
+			"no-unused-labels": "error",
+			"no-unused-private-class-members": "error",
+			"no-unused-vars": "error",
+			"no-use-before-define": "off",
+			"no-useless-assignment": "off",
+			"no-useless-backreference": "error",
+			"no-useless-catch": "error",
+			"no-useless-escape": "error",
+			"no-useless-return": "off",
+			"no-var": "error",
+			"no-with": "error",
+			"prefer-const": "error",
+			"prefer-template": "error",
+			"preserve-caught-error": "error",
+			"require-yield": "error",
+			"use-isnan": "error",
+			"valid-typeof": ["error", { requireStringLiterals: true }],
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+//#region src/utils.ts
+const scopeUrl = fileURLToPath(new URL(".", import.meta.url));
+const isCwdInScope = isPackageExists("@rhapsodic/eslint-config");
+const parserPlain = {
+	meta: { name: "parser-plain" },
+	parseForESLint: (code) => ({
+		ast: {
+			body: [],
+			comments: [],
+			loc: {
+				end: code.length,
+				start: 0
+			},
+			range: [0, code.length],
+			tokens: [],
+			type: "Program"
+		},
+		scopeManager: null,
+		services: { isPlain: true },
+		visitorKeys: { Program: [] }
+	})
+};
+/**
+* Combine array and non-array configs into a single array.
+*/
+async function combine(...configs) {
+	return (await Promise.all(configs)).flat();
+}
+/**
+* Rename plugin prefixes in a rule object.
+* Accepts a map of prefixes to rename.
+*
+* @example
+* ```ts
+* import { renameRules } from '@rhapsodic/eslint-config'
+*
+* export default [{
+*   rules: renameRules(
+*     {
+*       '@typescript-eslint/indent': 'error'
+*     },
+*     { '@typescript-eslint': 'ts' }
+*   )
+* }]
+* ```
+*/
+function renameRules(rules, map) {
+	return Object.fromEntries(Object.entries(rules).map(([key, value]) => {
+		for (const [from, to] of Object.entries(map)) if (key.startsWith(`${from}/`)) return [to + key.slice(from.length), value];
+		return [key, value];
+	}));
+}
+async function interopDefault(m) {
+	const resolved = await m;
+	return resolved.default ?? resolved;
+}
+function isPackageInScope(name) {
+	return isPackageExists(name, { paths: [scopeUrl] });
+}
+async function ensurePackages(packages) {
+	if (process.env.CI || process.stdout.isTTY === false || isCwdInScope === false) return;
+	const nonExistingPackages = packages.filter((i) => i && !isPackageInScope(i));
+	if (nonExistingPackages.length === 0) return;
+	if (await (await import("@clack/prompts")).confirm({ message: `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(", ")}. Do you want to install them?` })) await import("@antfu/install-pkg").then((i) => i.installPackage(nonExistingPackages, { dev: true }));
+}
+
+//#endregion
+//#region src/configs/stylistic.ts
+const StylisticConfigDefaults = {
+	arrowParens: true,
+	blockSpacing: true,
+	braceStyle: "1tbs",
+	commaDangle: "always-multiline",
+	indent: 2,
+	quoteProps: "as-needed",
+	quotes: "single",
+	semi: true
+};
+async function stylistic(options = {}) {
+	const { arrowParens, blockSpacing, braceStyle, commaDangle, indent, quoteProps, quotes, overrides, semi } = {
+		...StylisticConfigDefaults,
+		...options
+	};
+	const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
+	const config = pluginStylistic.configs.customize({
+		arrowParens,
+		blockSpacing,
+		braceStyle,
+		commaDangle,
+		indent,
+		jsx: false,
+		quoteProps,
+		pluginName: "style",
+		quotes,
+		semi
+	});
+	return [{
+		name: "rhapsodic/stylistic/rules",
+		plugins: { style: pluginStylistic },
+		rules: {
+			...config.rules,
+			"style/array-bracket-newline": ["error", "consistent"],
+			"style/array-element-newline": ["error", "consistent"],
+			"style/function-call-argument-newline": ["error", "consistent"],
+			"style/function-call-spacing": ["error", "never"],
+			"style/function-paren-newline": ["error", "multiline"],
+			"style/lines-between-class-members": [
+				"error",
+				"always",
+				{
+					exceptAfterSingleLine: true,
+					exceptAfterOverload: true
+				}
+			],
+			"style/multiline-comment-style": ["error", "separate-lines"],
+			"style/max-len": ["error", {
+				code: 120,
+				ignoreStrings: true,
+				ignoreComments: true,
+				ignoreTemplateLiterals: true,
+				ignoreRegExpLiterals: true
+			}],
+			"style/newline-per-chained-call": ["error", { ignoreChainWithDepth: 2 }],
+			"style/no-confusing-arrow": ["error", {
+				allowParens: true,
+				onlyOneSimpleParam: false
+			}],
+			"style/no-extra-semi": "error",
+			"style/nonblock-statement-body-position": ["error", "beside"],
+			"style/object-curly-newline": ["error", {
+				ObjectExpression: {
+					multiline: true,
+					minProperties: 4,
+					consistent: true
+				},
+				ObjectPattern: {
+					multiline: true,
+					consistent: true
+				},
+				ImportDeclaration: {
+					multiline: true,
+					minProperties: 4,
+					consistent: true
+				},
+				ExportDeclaration: {
+					multiline: true,
+					consistent: true
+				}
+			}],
+			"style/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+			"style/one-var-declaration-per-line": ["error", "always"],
+			"style/semi-style": ["error", "last"],
+			"style/switch-colon-spacing": ["error", {
+				after: true,
+				before: false
+			}],
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+//#region src/configs/typescript.ts
+async function typescript(options = {}) {
+	const { componentExts = [], overrides = {}, parserOptions = {} } = options;
+	const files = options.files ?? [
+		GLOB_TS,
+		GLOB_TSX,
+		...componentExts.map((ext) => `**/*.${ext}`)
+	];
+	const tsconfigPath = options?.tsconfigPath ?? void 0;
+	const [pluginTs, parserTs] = await Promise.all([interopDefault(import("@typescript-eslint/eslint-plugin")), interopDefault(import("@typescript-eslint/parser"))]);
+	function makeParser(filesArray, ignores$1) {
+		return {
+			files: filesArray,
+			...ignores$1 ? { ignores: ignores$1 } : {},
+			languageOptions: {
+				parser: parserTs,
+				parserOptions: {
+					extraFileExtensions: componentExts.map((ext) => `.${ext}`),
+					sourceType: "module",
+					projectService: {
+						allowDefaultProject: ["./*.js"],
+						defaultProject: tsconfigPath
+					},
+					tsconfigRootDir: process.cwd(),
+					...parserOptions
+				}
+			},
+			name: "rhapsodic/typescript/parser"
+		};
+	}
+	return [
+		{
+			name: "rhapsodic/typescript/setup",
+			plugins: { ts: pluginTs }
+		},
+		makeParser(files),
+		{
+			files,
+			name: "rhapsodic/typescript/rules",
+			rules: {
+				...renameRules(pluginTs.configs.recommended.rules, { "@typescript-eslint": "ts" }),
+				...renameRules(pluginTs.configs["stylistic-type-checked"].rules, { "@typescript-eslint": "ts" }),
+				"ts/no-inferrable-types": "off",
+				"ts/no-shadow": ["error"],
+				"ts/no-unused-vars": ["error", {
+					args: "all",
+					argsIgnorePattern: "^_",
+					caughtErrors: "all",
+					caughtErrorsIgnorePattern: "^_",
+					destructuredArrayIgnorePattern: "^_",
+					varsIgnorePattern: "^_",
+					ignoreRestSiblings: true
+				}],
+				"ts/prefer-function-type": "off",
+				"ts/consistent-type-imports": ["error", {
+					disallowTypeAnnotations: false,
+					fixStyle: "separate-type-imports",
+					prefer: "type-imports"
+				}],
+				"ts/naming-convention": ["error", {
+					selector: "typeLike",
+					format: ["PascalCase"]
+				}],
+				...overrides
+			}
+		}
+	];
+}
+
+//#endregion
+//#region src/configs/unicorn.ts
+async function unicorn(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		name: "rhapsodic/unicorn/rules",
+		plugins: { unicorn: pluginUnicorn },
+		rules: {
+			...pluginUnicorn.configs.recommended.rules,
+			"unicorn/consistent-function-scoping": "off",
+			"unicorn/explicit-length-check": "off",
+			"unicorn/filename-case": "off",
+			"unicorn/no-array-for-each": "off",
+			"unicorn/no-array-reduce": "off",
+			"unicorn/no-for-loop": "off",
+			"unicorn/no-null": "off",
+			"unicorn/no-static-only-class": "off",
+			"unicorn/prefer-switch": "off",
+			"unicorn/prefer-ternary": "off",
+			"unicorn/prevent-abbreviations": "off",
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+//#region src/configs/vue.ts
+async function vue(options = {}) {
+	const { a11y = false, files = [GLOB_VUE], overrides = {}, stylistic: stylistic$1 = true } = options;
+	const sfcBlocks = options.sfcBlocks === true ? {} : options.sfcBlocks ?? {};
+	const { indent = 2 } = typeof stylistic$1 === "boolean" ? {} : stylistic$1;
+	if (a11y) await ensurePackages(["eslint-plugin-vuejs-accessibility"]);
+	const [pluginVue, parserVue, processorVueBlocks, pluginVueA11y] = await Promise.all([
+		interopDefault(import("eslint-plugin-vue")),
+		interopDefault(import("vue-eslint-parser")),
+		interopDefault(import("eslint-processor-vue-blocks")),
+		...a11y ? [interopDefault(import("eslint-plugin-vuejs-accessibility"))] : []
+	]);
+	return [{
+		languageOptions: { globals: {
+			...globals["shared-node-browser"],
+			computed: "readonly",
+			defineEmits: "readonly",
+			defineExpose: "readonly",
+			defineProps: "readonly",
+			onMounted: "readonly",
+			onUnmounted: "readonly",
+			reactive: "readonly",
+			ref: "readonly",
+			shallowReactive: "readonly",
+			shallowRef: "readonly",
+			toRef: "readonly",
+			toRefs: "readonly",
+			watch: "readonly",
+			watchEffect: "readonly"
+		} },
+		name: "rhapsodic/vue/setup",
+		plugins: {
+			vue: pluginVue,
+			...a11y ? { "vue-a11y": pluginVueA11y } : {}
+		}
+	}, {
+		files,
+		languageOptions: {
+			parser: parserVue,
+			parserOptions: {
+				ecmaFeatures: { jsx: true },
+				extraFileExtensions: [".vue"],
+				parser: options.typescript ? await interopDefault(import("@typescript-eslint/parser")) : null,
+				sourceType: "module"
+			}
+		},
+		name: "rhapsodic/vue/rules",
+		processor: sfcBlocks === false ? pluginVue.processors[".vue"] : mergeProcessors([pluginVue.processors[".vue"], processorVueBlocks({
+			...sfcBlocks,
+			blocks: {
+				styles: true,
+				...sfcBlocks.blocks
+			}
+		})]),
+		rules: {
+			...pluginVue.configs.base.rules,
+			...pluginVue.configs["flat/essential"].map((c) => c.rules).reduce((acc, c) => ({
+				...acc,
+				...c
+			}), {}),
+			"vue/block-lang": ["error", { script: {
+				lang: "ts",
+				allowNoLang: false
+			} }],
+			"vue/camelcase": ["error", {
+				properties: "never",
+				ignoreDestructuring: false
+			}],
+			"vue/component-definition-name-casing": ["error", "PascalCase"],
+			"vue/eqeqeq": [
+				"error",
+				"always",
+				{ null: "ignore" }
+			],
+			"vue/html-button-has-type": ["error", {
+				button: true,
+				submit: true,
+				reset: false
+			}],
+			"vue/html-self-closing": ["error", { html: { void: "any" } }],
+			"vue/max-len": ["error", {
+				code: 120,
+				template: 120,
+				comments: 120,
+				ignoreUrls: true,
+				ignoreStrings: true,
+				ignoreHTMLAttributeValues: true,
+				ignoreHTMLTextContents: true
+			}],
+			"vue/multi-word-component-names": "off",
+			"vue/no-child-content": "error",
+			"vue/no-constant-condition": "warn",
+			"vue/no-duplicate-attributes": ["error", {
+				allowCoexistClass: true,
+				allowCoexistStyle: true
+			}],
+			"vue/no-empty-pattern": "error",
+			"vue/no-implicit-coercion": ["error", { allow: ["!!", "+"] }],
+			"vue/no-irregular-whitespace": "error",
+			"vue/no-loss-of-precision": "error",
+			"vue/no-potential-component-option-typo": "error",
+			"vue/no-sparse-arrays": "error",
+			"vue/no-template-target-blank": ["error", {
+				allowReferrer: true,
+				enforceDynamicLinks: "always"
+			}],
+			"vue/no-useless-concat": "error",
+			"vue/no-v-html": "off",
+			"vue/object-shorthand": [
+				"error",
+				"always",
+				{
+					ignoreConstructors: false,
+					avoidQuotes: true
+				}
+			],
+			"vue/prefer-template": "error",
+			"vue/require-default-prop": "off",
+			...stylistic$1 ? {
+				"@stylistic/max-len": "off",
+				"vue/array-bracket-newline": ["error", "consistent"],
+				"vue/array-bracket-spacing": ["error", "never"],
+				"vue/arrow-spacing": ["error", {
+					after: true,
+					before: true
+				}],
+				"vue/block-order": ["error", { order: [
+					"template",
+					"script",
+					"style"
+				] }],
+				"vue/block-spacing": ["error", "always"],
+				"vue/brace-style": [
+					"error",
+					"1tbs",
+					{ allowSingleLine: true }
+				],
+				"vue/comma-dangle": ["error", {
+					arrays: "always-multiline",
+					objects: "always-multiline",
+					imports: "always-multiline",
+					exports: "always-multiline",
+					functions: "always-multiline"
+				}],
+				"vue/comma-spacing": ["error", {
+					before: false,
+					after: true
+				}],
+				"vue/comma-style": [
+					"error",
+					"last",
+					{ exceptions: {
+						ArrayExpression: false,
+						ArrayPattern: false,
+						ArrowFunctionExpression: false,
+						CallExpression: false,
+						FunctionDeclaration: false,
+						FunctionExpression: false,
+						ImportDeclaration: false,
+						ObjectExpression: false,
+						ObjectPattern: false,
+						VariableDeclaration: false,
+						NewExpression: false
+					} }
+				],
+				"vue/dot-location": ["error", "property"],
+				"vue/dot-notation": ["error", { allowKeywords: true }],
+				"vue/first-attribute-linebreak": "off",
+				"vue/func-call-spacing": ["error", "never"],
+				"vue/html-closing-bracket-spacing": ["error", {
+					startTag: "never",
+					endTag: "never",
+					selfClosingTag: "always"
+				}],
+				"vue/html-closing-bracket-newline": ["error", {
+					singleline: "never",
+					multiline: "always",
+					selfClosingTag: {
+						singleline: "never",
+						multiline: "always"
+					}
+				}],
+				"vue/html-indent": ["error", indent],
+				"vue/key-spacing": ["error", {
+					beforeColon: false,
+					afterColon: true
+				}],
+				"vue/keyword-spacing": ["error", {
+					before: true,
+					after: true,
+					overrides: {
+						return: { after: true },
+						throw: { after: true },
+						case: { after: true }
+					}
+				}],
+				"vue/max-attributes-per-line": ["error", {
+					singleline: { max: 3 },
+					multiline: { max: 1 }
+				}],
+				"vue/multiline-html-element-content-newline": ["error", {
+					ignoreWhenEmpty: true,
+					ignores: [
+						"nuxt-link",
+						"nuxt-link-locale",
+						"pre",
+						"textarea",
+						"a",
+						"abbr",
+						"audio",
+						"b",
+						"bdi",
+						"bdo",
+						"canvas",
+						"cite",
+						"code",
+						"data",
+						"del",
+						"dfn",
+						"em",
+						"i",
+						"iframe",
+						"ins",
+						"kbd",
+						"label",
+						"map",
+						"mark",
+						"noscript",
+						"object",
+						"output",
+						"picture",
+						"q",
+						"ruby",
+						"s",
+						"samp",
+						"small",
+						"span",
+						"strong",
+						"sub",
+						"sup",
+						"svg",
+						"time",
+						"u",
+						"var",
+						"video"
+					],
+					allowEmptyLines: false
+				}],
+				"vue/no-extra-parens": [
+					"off",
+					"all",
+					{
+						conditionalAssign: true,
+						nestedBinaryExpressions: false,
+						returnAssign: false,
+						ignoreJSX: "all",
+						enforceForArrowConditionals: false
+					}
+				],
+				"vue/no-multi-spaces": "error",
+				"vue/no-spaces-around-equal-signs-in-attribute": "error",
+				"vue/object-curly-newline": ["error", {
+					ObjectExpression: {
+						multiline: true,
+						consistent: true
+					},
+					ObjectPattern: {
+						multiline: true,
+						consistent: true
+					},
+					ImportDeclaration: {
+						multiline: true,
+						minProperties: 4,
+						consistent: true
+					},
+					ExportDeclaration: {
+						multiline: true,
+						consistent: true
+					}
+				}],
+				"vue/object-curly-spacing": ["error", "always"],
+				"vue/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+				"vue/operator-linebreak": [
+					"error",
+					"before",
+					{ overrides: { "=": "none" } }
+				],
+				"vue/quote-props": [
+					"error",
+					"as-needed",
+					{
+						keywords: false,
+						unnecessary: true,
+						numbers: false
+					}
+				],
+				"vue/singleline-html-element-content-newline": "off",
+				"vue/space-in-parens": ["error", "never"],
+				"vue/space-infix-ops": "error",
+				"vue/space-unary-ops": ["error", {
+					words: true,
+					nonwords: false,
+					overrides: {}
+				}],
+				"vue/template-curly-spacing": "error"
+			} : {},
+			...a11y ? {
+				"vue-a11y/alt-text": ["error", {
+					elements: [
+						"img",
+						"object",
+						"area",
+						"input[type=\"image\"]"
+					],
+					img: [],
+					object: [],
+					area: [],
+					"input[type=\"image\"]": []
+				}],
+				"vue-a11y/anchor-has-content": ["error", {
+					components: [],
+					accessibleChildren: [],
+					accessibleDirectives: []
+				}],
+				"vue-a11y/aria-props": "error",
+				"vue-a11y/aria-role": ["error", { ignoreNonDOM: false }],
+				"vue-a11y/aria-unsupported-elements": "error",
+				"vue-a11y/click-events-have-key-events": "error",
+				"vue-a11y/form-control-has-label": "off",
+				"vue-a11y/heading-has-content": "error",
+				"vue-a11y/iframe-has-title": "error",
+				"vue-a11y/interactive-supports-focus": "error",
+				"vue-a11y/label-has-for": "off",
+				"vue-a11y/media-has-caption": "error",
+				"vue-a11y/mouse-events-have-key-events": "error",
+				"vue-a11y/no-access-key": "error",
+				"vue-a11y/no-autofocus": ["error", { ignoreNonDOM: true }],
+				"vue-a11y/no-distracting-elements": ["error", { elements: ["marquee", "blink"] }],
+				"vue-a11y/no-redundant-roles": "error",
+				"vue-a11y/no-static-element-interactions": "error",
+				"vue-a11y/role-has-required-aria-props": "error",
+				"vue-a11y/tabindex-no-positive": "error"
+			} : {},
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+//#region src/factory.ts
+const flatConfigProps = [
+	"name",
+	"languageOptions",
+	"linterOptions",
+	"processor",
+	"plugins",
+	"rules",
+	"settings"
+];
+const VuePackages = ["vue", "nuxt"];
+/**
+* Construct an array of ESLint flat config items.
+*
+* @param {OptionsConfig & TypedFlatConfigItem} options
+*  The options for generating the ESLint configurations.
+* @param {Awaitable<TypedFlatConfigItem | TypedFlatConfigItem[]>[]} userConfigs
+*  The user configurations to be merged with the generated configurations.
+* @returns {Promise<TypedFlatConfigItem[]>}
+*  The merged ESLint configurations.
+*/
+function rhapsodic(options = {}, ...userConfigs) {
+	const { componentExts = [], ignores: userIgnores = [], imports: enableImports = true, typescript: enableTypeScript = isPackageExists("typescript"), unicorn: enableUnicorn = true, vue: enableVue = VuePackages.some((i) => isPackageExists(i)) } = options;
+	const stylisticOptions = options.stylistic === false ? false : typeof options.stylistic === "object" ? options.stylistic : {};
+	const configs = [];
+	const typescriptOptions = resolveSubOptions(options, "typescript");
+	configs.push(ignores(userIgnores), javascript({ overrides: getOverrides(options, "javascript") }));
+	if (enableImports) configs.push(imports(enableImports === true ? {} : { ...enableImports }));
+	if (enableUnicorn) configs.push(unicorn(enableUnicorn === true ? {} : enableUnicorn));
+	if (enableVue) componentExts.push("vue");
+	if (enableTypeScript) configs.push(typescript({
+		...typescriptOptions,
+		componentExts,
+		overrides: getOverrides(options, "typescript")
+	}));
+	if (stylisticOptions) configs.push(stylistic({
+		...stylisticOptions,
+		overrides: getOverrides(options, "stylistic")
+	}));
+	if (enableVue) configs.push(vue({
+		...resolveSubOptions(options, "vue"),
+		overrides: getOverrides(options, "vue"),
+		stylistic: stylisticOptions,
+		typescript: !!enableTypeScript
+	}));
+	configs.push(disables());
+	if ("files" in options) throw new Error("[@rhapsodic/eslint-config] The first argument should not contain the \"files\" property as the options are supposed to be global. Place it in the second or later config instead.");
+	const fusedConfig = flatConfigProps.reduce((acc, key) => {
+		if (key in options) acc[key] = options[key];
+		return acc;
+	}, {});
+	if (Object.keys(fusedConfig).length) configs.push([fusedConfig]);
+	let composer = new FlatConfigComposer();
+	composer = composer.append(...configs, ...userConfigs);
+	return composer;
+}
+function resolveSubOptions(options, key) {
+	return typeof options[key] === "boolean" ? {} : options[key] || {};
+}
+function getOverrides(options, key) {
+	const sub = resolveSubOptions(options, key);
+	return {
+		...options.overrides?.[key],
+		..."overrides" in sub ? sub.overrides : {}
+	};
+}
+
+//#endregion
+export { GLOB_ALL_SRC, GLOB_EXCLUDE, GLOB_JS, GLOB_JSX, GLOB_SRC, GLOB_SRC_EXT, GLOB_TESTS, GLOB_TS, GLOB_TSX, GLOB_VUE, StylisticConfigDefaults, combine, rhapsodic as default, rhapsodic, disables, ensurePackages, getOverrides, ignores, imports, interopDefault, isPackageInScope, javascript, parserPlain, renameRules, resolveSubOptions, stylistic, typescript, unicorn, vue };