@rotki/eslint-config 6.2.0 → 7.0.0

package/dist/index.mjs

@@ -180,8 +180,19 @@ async function disables() {
 }
 //#endregion
 //#region src/configs/e18e.ts
-async function e18e(options = {}) {
+function resolveE18eOptions(options) {
 	const { isInEditor = false, modernization = true, type = "app", moduleReplacements = type === "lib" && isInEditor, overrides = {}, performanceImprovements = true } = options;
+	return {
+		isInEditor,
+		modernization,
+		moduleReplacements,
+		overrides,
+		performanceImprovements,
+		type
+	};
+}
+async function e18e(options = {}) {
+	const { modernization, moduleReplacements, overrides, performanceImprovements, type } = resolveE18eOptions(options);
 	const configs = pluginE18e.configs;
 	return [{
 		name: "rotki/e18e/rules",
@@ -391,20 +402,17 @@ function mergePrettierOptions(options, overrides) {
 		plugins: [...overrides.plugins || [], ...options.plugins || []]
 	};
 }
-async function formatters(options = {}, stylistic = {}) {
-	if (options === true) options = {
+function resolveFormattersOptions(options) {
+	if (options === true) return {
 		css: true,
 		html: true,
 		markdown: true,
 		xml: isPackageInScope("@prettier/plugin-xml")
 	};
-	await ensurePackages(["eslint-plugin-format", options.xml ? "@prettier/plugin-xml" : void 0]);
-	const { indent: rawIndent, quotes, semi } = {
-		...StylisticConfigDefaults,
-		...stylistic
-	};
-	const indent = Array.isArray(rawIndent) ? rawIndent[0] : rawIndent;
-	const prettierOptions = Object.assign({
+	return options;
+}
+function buildPrettierOptions(indent, quotes, semi, options) {
+	return Object.assign({
 		endOfLine: "auto",
 		printWidth: 120,
 		semi,
@@ -413,70 +421,95 @@ async function formatters(options = {}, stylistic = {}) {
 		trailingComma: "all",
 		useTabs: indent === "tab"
 	}, options.prettierOptions || {});
-	const dprintOptions = Object.assign({
+}
+function buildDprintOptions(indent, quotes, options) {
+	return Object.assign({
 		indentWidth: typeof indent === "number" ? indent : 2,
 		quoteStyle: quotes === "single" ? "preferSingle" : "preferDouble",
 		useTabs: indent === "tab"
 	}, options.dprintOptions || {});
-	const prettierXmlOptions = {
-		xmlQuoteAttributes: "double",
-		xmlSelfClosingSpace: true,
-		xmlSortAttributesByKey: false,
-		xmlWhitespaceSensitivity: "ignore"
-	};
-	const configs = [{
-		name: "rotki/formatter/setup",
-		plugins: { format: await interopDefault(import("eslint-plugin-format")) }
-	}];
-	if (options.css) configs.push({
-		files: [GLOB_CSS, GLOB_POSTCSS],
-		languageOptions: { parser: parserPlain },
-		name: "rotki/formatter/css",
-		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "css" })] }
-	}, {
-		files: [GLOB_SCSS],
-		languageOptions: { parser: parserPlain },
-		name: "rotki/formatter/scss",
-		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "scss" })] }
-	}, {
-		files: [GLOB_LESS],
-		languageOptions: { parser: parserPlain },
-		name: "rotki/formatter/less",
-		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "less" })] }
-	});
-	if (options.html) configs.push({
+}
+function cssFormatters(options, prettierOptions) {
+	if (!options.css) return [];
+	return [
+		{
+			files: [GLOB_CSS, GLOB_POSTCSS],
+			languageOptions: { parser: parserPlain },
+			name: "rotki/formatter/css",
+			rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "css" })] }
+		},
+		{
+			files: [GLOB_SCSS],
+			languageOptions: { parser: parserPlain },
+			name: "rotki/formatter/scss",
+			rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "scss" })] }
+		},
+		{
+			files: [GLOB_LESS],
+			languageOptions: { parser: parserPlain },
+			name: "rotki/formatter/less",
+			rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "less" })] }
+		}
+	];
+}
+function htmlFormatter(options, prettierOptions) {
+	if (!options.html) return [];
+	return [{
 		files: ["**/*.html"],
 		languageOptions: { parser: parserPlain },
 		name: "rotki/formatter/html",
 		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "html" })] }
-	});
-	if (options.xml) configs.push({
+	}];
+}
+function xmlFormatter(options, prettierOptions) {
+	if (!options.xml) return [];
+	return [{
 		files: [GLOB_XML],
 		languageOptions: { parser: parserPlain },
 		name: "rotki/formatter/xml",
 		rules: { "format/prettier": ["error", mergePrettierOptions({
-			...prettierXmlOptions,
+			xmlQuoteAttributes: "double",
+			xmlSelfClosingSpace: true,
+			xmlSortAttributesByKey: false,
+			xmlWhitespaceSensitivity: "ignore",
 			...prettierOptions
 		}, {
 			parser: "xml",
 			plugins: ["@prettier/plugin-xml"]
 		})] }
-	});
-	if (options.markdown) {
-		const formater = options.markdown === true ? "prettier" : options.markdown;
-		configs.push({
-			files: [GLOB_MARKDOWN],
-			languageOptions: { parser: parserPlain },
-			name: "rotki/formatter/markdown",
-			rules: { [`format/${formater}`]: ["error", formater === "prettier" ? mergePrettierOptions(prettierOptions, {
-				embeddedLanguageFormatting: "off",
-				parser: "markdown"
-			}) : {
-				...dprintOptions,
-				language: "markdown"
-			}] }
-		});
-	}
+	}];
+}
+function markdownFormatter(options, prettierOptions, dprintOptions) {
+	if (!options.markdown) return [];
+	const formater = options.markdown === true ? "prettier" : options.markdown;
+	return [{
+		files: [GLOB_MARKDOWN],
+		languageOptions: { parser: parserPlain },
+		name: "rotki/formatter/markdown",
+		rules: { [`format/${formater}`]: ["error", formater === "prettier" ? mergePrettierOptions(prettierOptions, {
+			embeddedLanguageFormatting: "off",
+			parser: "markdown"
+		}) : {
+			...dprintOptions,
+			language: "markdown"
+		}] }
+	}];
+}
+async function formatters(options = {}, stylistic = {}) {
+	const resolvedOptions = resolveFormattersOptions(options);
+	await ensurePackages(["eslint-plugin-format", resolvedOptions.xml ? "@prettier/plugin-xml" : void 0]);
+	const { indent: rawIndent, quotes, semi } = {
+		...StylisticConfigDefaults,
+		...stylistic
+	};
+	const indent = Array.isArray(rawIndent) ? rawIndent[0] : rawIndent;
+	const prettierOptions = buildPrettierOptions(indent, quotes, semi, resolvedOptions);
+	const dprintOptions = buildDprintOptions(indent, quotes, resolvedOptions);
+	const configs = [{
+		name: "rotki/formatter/setup",
+		plugins: { format: await interopDefault(import("eslint-plugin-format")) }
+	}];
+	configs.push(...cssFormatters(resolvedOptions, prettierOptions), ...htmlFormatter(resolvedOptions, prettierOptions), ...xmlFormatter(resolvedOptions, prettierOptions), ...markdownFormatter(resolvedOptions, prettierOptions, dprintOptions));
 	return configs;
 }
 //#endregion
@@ -526,7 +559,7 @@ async function javascript(options = {}) {
 	const { isInEditor = false, overrides = {} } = options;
 	const customRules = {
 		"arrow-body-style": ["error", "as-needed"],
-		"complexity": ["warn", { max: 10 }],
+		"complexity": ["error", { max: 10 }],
 		"max-lines": ["error", { max: 400 }]
 	};
 	return [{
@@ -1143,24 +1176,26 @@ async function rotkiPlugin(options = {}) {
 		},
 		name: "rotki/rotki/rules",
 		rules: {
-			"@rotki/composable-no-default-export": "warn",
-			"@rotki/composable-prefer-shallowref": "warn",
-			"@rotki/composable-require-cleanup": "warn",
-			"@rotki/composable-return-readonly": "warn",
-			"@rotki/composable-ssr-safety": "warn",
+			"@rotki/composable-no-default-export": "error",
+			"@rotki/composable-prefer-shallowref": "error",
+			"@rotki/composable-require-cleanup": "error",
+			"@rotki/composable-return-readonly": "error",
+			"@rotki/composable-ssr-safety": "error",
 			"@rotki/consistent-ref-type-annotation": ["error", { allowInference: true }],
 			"@rotki/no-deprecated-classes": "error",
 			"@rotki/no-deprecated-props": "error",
 			"@rotki/no-dot-ts-imports": "error",
+			"@rotki/no-redundant-flex-row": "error",
+			"@rotki/no-shared-pinia": "error",
 			"@rotki/no-unused-i18n-keys": ["error", {
 				extensions: [".ts", ".vue"],
 				ignoreKeys,
 				src
 			}],
 			...stylistic ? {
-				"@rotki/composable-input-flexibility": "warn",
-				"@rotki/composable-naming-convention": "warn",
-				"@rotki/require-jsdoc-on-composable-options": "warn"
+				"@rotki/composable-input-flexibility": "error",
+				"@rotki/composable-naming-convention": "error",
+				"@rotki/require-jsdoc-on-composable-options": "error"
 			} : {},
 			...overrides
 		}
@@ -1210,6 +1245,7 @@ async function sortPackageJson() {
 						"directories",
 						"publishConfig",
 						"scripts",
+						"scripts-info",
 						"peerDependencies",
 						"peerDependenciesMeta",
 						"optionalDependencies",
@@ -1466,24 +1502,86 @@ async function test(options = {}) {
 }
 //#endregion
 //#region src/configs/typescript.ts
-async function typescript(options = {}) {
+const typeAwareCustom = {
+	"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+	"@typescript-eslint/naming-convention": [
+		"error",
+		{
+			format: null,
+			modifiers: ["destructured"],
+			selector: "variable"
+		},
+		{
+			format: ["camelCase"],
+			leadingUnderscore: "allow",
+			selector: "parameter"
+		},
+		{
+			format: ["camelCase"],
+			selector: "variable"
+		},
+		{
+			format: [
+				"camelCase",
+				"UPPER_CASE",
+				"PascalCase"
+			],
+			modifiers: ["const"],
+			selector: "variable"
+		},
+		{
+			format: ["camelCase"],
+			leadingUnderscore: "allow",
+			modifiers: ["private"],
+			selector: "memberLike"
+		},
+		{
+			format: ["PascalCase"],
+			selector: "typeLike"
+		}
+	]
+};
+const customRules = {
+	"@typescript-eslint/prefer-as-const": "error",
+	"@typescript-eslint/prefer-literal-enum-member": ["warn", { allowBitwiseExpressions: true }],
+	"max-lines": ["error", { max: 400 }]
+};
+function resolveTypeScriptFiles(options, componentExts) {
+	return {
+		files: options.files ?? [
+			"**/*.?([cm])ts",
+			"**/*.?([cm])tsx",
+			...componentExts.map((ext) => `**/*.${ext}`)
+		],
+		filesTypeAware: options.filesTypeAware ?? ["**/*.?([cm])ts", "**/*.?([cm])tsx"],
+		ignoresTypeAware: options.ignoresTypeAware ?? [`**/*.md/**`]
+	};
+}
+function resolveTypeScriptOptions(options) {
 	const { componentExts = [], isInEditor = false, overrides = {}, overridesTypeAware = {}, parserOptions = {}, type = "app" } = options;
-	const files = options.files ?? [
-		"**/*.?([cm])ts",
-		"**/*.?([cm])tsx",
-		...componentExts.map((ext) => `**/*.${ext}`)
-	];
-	const filesTypeAware = options.filesTypeAware ?? ["**/*.?([cm])ts", "**/*.?([cm])tsx"];
-	const ignoresTypeAware = options.ignoresTypeAware ?? [`**/*.md/**`];
-	const tsconfigPath = options?.tsconfigPath ? options.tsconfigPath : void 0;
-	const isTypeAware = !!tsconfigPath;
-	const typeAwareRules = {
-		"@typescript-eslint/await-thenable": "warn",
+	const tsconfigPath = options.tsconfigPath ? options.tsconfigPath : void 0;
+	return {
+		componentExts,
+		isInEditor,
+		isTypeAware: !!tsconfigPath,
+		overrides,
+		overridesTypeAware,
+		parserOptions,
+		tsconfigPath,
+		type,
+		...resolveTypeScriptFiles(options, componentExts)
+	};
+}
+function buildTypeAwareRules(isInEditor) {
+	return {
+		"@typescript-eslint/await-thenable": "error",
+		"@typescript-eslint/consistent-type-exports": "error",
 		"@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
 		"@typescript-eslint/no-floating-promises": ["error", { ignoreIIFE: true }],
 		"@typescript-eslint/no-for-in-array": "error",
 		"@typescript-eslint/no-implied-eval": "error",
-		"@typescript-eslint/no-misused-promises": "warn",
+		"@typescript-eslint/no-misused-promises": "error",
+		"@typescript-eslint/no-unnecessary-boolean-literal-compare": "error",
 		"@typescript-eslint/no-unnecessary-type-assertion": "error",
 		"@typescript-eslint/no-unsafe-argument": isInEditor ? "warn" : "off",
 		"@typescript-eslint/no-unsafe-assignment": isInEditor ? "warn" : "off",
@@ -1491,6 +1589,9 @@ async function typescript(options = {}) {
 		"@typescript-eslint/no-unsafe-member-access": isInEditor ? "warn" : "off",
 		"@typescript-eslint/no-unsafe-return": isInEditor ? "warn" : "off",
 		"@typescript-eslint/only-throw-error": "error",
+		"@typescript-eslint/prefer-nullish-coalescing": "error",
+		"@typescript-eslint/prefer-optional-chain": "error",
+		"@typescript-eslint/prefer-readonly": "error",
 		"@typescript-eslint/promise-function-async": "error",
 		"@typescript-eslint/restrict-plus-operands": "error",
 		"@typescript-eslint/restrict-template-expressions": "error",
@@ -1500,49 +1601,18 @@ async function typescript(options = {}) {
 		"dot-notation": "off",
 		"no-implied-eval": "off",
 		"no-throw-literal": "off",
-		"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
-		"@typescript-eslint/naming-convention": [
-			"error",
-			{
-				format: null,
-				modifiers: ["destructured"],
-				selector: "variable"
-			},
-			{
-				format: ["camelCase"],
-				leadingUnderscore: "allow",
-				selector: "parameter"
-			},
-			{
-				format: ["camelCase"],
-				selector: "variable"
-			},
-			{
-				format: [
-					"camelCase",
-					"UPPER_CASE",
-					"PascalCase"
-				],
-				modifiers: ["const"],
-				selector: "variable"
-			},
-			{
-				format: ["camelCase"],
-				leadingUnderscore: "allow",
-				modifiers: ["private"],
-				selector: "memberLike"
-			},
-			{
-				format: ["PascalCase"],
-				selector: "typeLike"
-			}
-		]
-	};
-	const customRules = {
-		"@typescript-eslint/prefer-as-const": "warn",
-		"@typescript-eslint/prefer-literal-enum-member": ["warn", { allowBitwiseExpressions: true }],
-		"max-lines": ["error", { max: 400 }]
+		...typeAwareCustom
 	};
+}
+function buildLibRules(type) {
+	return type === "lib" ? { "@typescript-eslint/explicit-function-return-type": ["error", {
+		allowExpressions: true,
+		allowHigherOrderFunctions: true,
+		allowIIFEs: true
+	}] } : {};
+}
+async function typescript(options = {}) {
+	const { componentExts, files, filesTypeAware, ignoresTypeAware, isInEditor, isTypeAware, overrides, overridesTypeAware, parserOptions, tsconfigPath, type } = resolveTypeScriptOptions(options);
 	const [pluginTs, parserTs] = await Promise.all([interopDefault(import("@typescript-eslint/eslint-plugin")), interopDefault(import("@typescript-eslint/parser"))]);
 	function makeParser(typeAware, files, ignores) {
 		return {
@@ -1614,11 +1684,7 @@ async function typescript(options = {}) {
 				"no-redeclare": "off",
 				"no-use-before-define": "off",
 				"no-useless-constructor": "off",
-				...type === "lib" ? { "@typescript-eslint/explicit-function-return-type": ["error", {
-					allowExpressions: true,
-					allowHigherOrderFunctions: true,
-					allowIIFEs: true
-				}] } : {},
+				...buildLibRules(type),
 				...customRules,
 				...overrides
 			}
@@ -1628,7 +1694,7 @@ async function typescript(options = {}) {
 			ignores: ignoresTypeAware,
 			name: "rotki/typescript/rules-type-aware",
 			rules: {
-				...typeAwareRules,
+				...buildTypeAwareRules(isInEditor),
 				...overridesTypeAware
 			}
 		}] : []
@@ -1639,11 +1705,12 @@ async function typescript(options = {}) {
 const FILENAME_CASE_IGNORE = /^[A-Z]+\..*$/;
 async function unicorn(options = {}) {
 	return [{
+		files: [GLOB_SRC, GLOB_VUE],
 		name: "rotki/unicorn/rules",
 		plugins: { unicorn: pluginUnicorn },
 		rules: { ...options.allRecommended ? pluginUnicorn.configs.recommended.rules : {
 			"unicorn/catch-error-name": "error",
-			"unicorn/consistent-destructuring": "warn",
+			"unicorn/consistent-destructuring": "error",
 			"unicorn/custom-error-definition": "error",
 			"unicorn/error-message": "error",
 			"unicorn/escape-case": "error",
@@ -1694,18 +1761,26 @@ async function unicorn(options = {}) {
 			"unicorn/prefer-type-error": "error",
 			"unicorn/throw-new-error": "error"
 		} }
-	}, {
-		files: [".github/**/*.md"],
-		name: "rotki/unicorn/github-markdown",
-		rules: { "unicorn/filename-case": "off" }
 	}];
 }
 //#endregion
 //#region src/configs/vue.ts
-async function vue(options = {}) {
+function resolveVueOptions(options) {
 	const { files = [GLOB_VUE], overrides = {}, stylistic = true, typescript } = options;
 	const sfcBlocks = options.sfcBlocks === true ? {} : options.sfcBlocks ?? {};
 	const { braceStyle = "stroustrup", indent = 2 } = typeof stylistic === "boolean" ? {} : stylistic;
+	return {
+		braceStyle,
+		files,
+		indent,
+		overrides,
+		sfcBlocks,
+		stylistic,
+		typescript
+	};
+}
+async function vue(options = {}) {
+	const { braceStyle, files, indent, overrides, sfcBlocks, stylistic, typescript } = resolveVueOptions(options);
 	const [pluginVue, parserVue, processorVueBlocks] = await Promise.all([
 		interopDefault(import("eslint-plugin-vue")),
 		interopDefault(import("vue-eslint-parser")),
@@ -1713,10 +1788,11 @@ async function vue(options = {}) {
 	]);
 	const customRules = {
 		"max-lines": ["warn", { max: 800 }],
+		"vue/block-lang": ["error", { script: { lang: "ts" } }],
 		"vue/component-api-style": ["error", ["script-setup"]],
 		"vue/define-emits-declaration": ["error", "type-literal"],
 		"vue/define-props-declaration": ["error", "type-based"],
-		"vue/define-props-destructuring": "warn",
+		"vue/define-props-destructuring": "error",
 		"vue/first-attribute-linebreak": ["error", {
 			multiline: "below",
 			singleline: "ignore"
@@ -1731,14 +1807,14 @@ async function vue(options = {}) {
 			math: "always",
 			svg: "always"
 		}],
-		"vue/max-props": ["warn", { maxProps: 6 }],
-		"vue/max-template-depth": ["warn", { maxDepth: 8 }],
+		"vue/max-props": ["error", { maxProps: 8 }],
+		"vue/max-template-depth": ["error", { maxDepth: 8 }],
 		"vue/multiline-html-element-content-newline": ["error", {
 			allowEmptyLines: false,
 			ignores: ["pre", "textarea"],
 			ignoreWhenEmpty: true
 		}],
-		"vue/no-constant-condition": "warn",
+		"vue/no-constant-condition": "error",
 		"vue/no-deprecated-dollar-listeners-api": "error",
 		"vue/no-deprecated-events-api": "error",
 		"vue/no-deprecated-filter": "error",
@@ -1748,7 +1824,7 @@ async function vue(options = {}) {
 		"vue/no-required-prop-with-default": ["error", { autofix: true }],
 		"vue/no-static-inline-styles": ["error", { allowBinding: false }],
 		"vue/no-unused-emit-declarations": "error",
-		"vue/no-unused-properties": ["warn", { groups: [
+		"vue/no-unused-properties": ["error", { groups: [
 			"props",
 			"data",
 			"computed",
@@ -1756,9 +1832,10 @@ async function vue(options = {}) {
 		] }],
 		"vue/prefer-define-options": "error",
 		"vue/prefer-import-from-vue": "error",
-		"vue/prefer-use-template-ref": "warn",
+		"vue/prefer-true-attribute-shorthand": "error",
+		"vue/prefer-use-template-ref": "error",
 		"vue/require-explicit-emits": "error",
-		"vue/require-explicit-slots": "warn",
+		"vue/require-explicit-slots": "error",
 		"vue/require-expose": "error",
 		"vue/require-macro-variable-name": ["error", {
 			defineEmits: "emit",
@@ -1970,7 +2047,7 @@ async function vue(options = {}) {
 }
 //#endregion
 //#region src/configs/vue-i18n.ts
-async function vueI18n(options = {}) {
+function resolveVueI18nOptions(options) {
 	const { files = [GLOB_TS, GLOB_VUE], isInEditor = false, localesDirectory = "locales", noRawTextIgnores = {
 		nodes: [
 			"md-icon",
@@ -1984,6 +2061,18 @@ async function vueI18n(options = {}) {
 			"USD"
 		]
 	}, overrides = {}, src = "src", typescript } = options;
+	return {
+		files,
+		isInEditor,
+		localesDirectory,
+		noRawTextIgnores,
+		overrides,
+		src,
+		typescript
+	};
+}
+async function vueI18n(options = {}) {
+	const { files, isInEditor, localesDirectory, noRawTextIgnores, overrides, src, typescript } = resolveVueI18nOptions(options);
 	const fileGlobs = files.map((x) => `**/${src}/${x}`);
 	if (localesDirectory) fileGlobs.push(`**/${src}/${localesDirectory}/${GLOB_JSON}`, `**/${src}/${localesDirectory}/${GLOB_JSON5}`, `**/${src}/${localesDirectory}/${GLOB_YAML}`);
 	const localeDir = path.resolve(path.join(process.cwd(), src, localesDirectory));
@@ -2035,10 +2124,19 @@ async function vueI18n(options = {}) {
 }
 //#endregion
 //#region src/configs/yaml.ts
-async function yaml(options = {}) {
+function resolveYamlOptions(options) {
 	const { files = [GLOB_YAML], overrides = {}, stylistic = true } = options;
 	const { indent: rawIndent = 2, quotes = "single" } = typeof stylistic === "boolean" ? {} : stylistic;
-	const indent = Array.isArray(rawIndent) ? rawIndent[0] : rawIndent;
+	return {
+		files,
+		indent: Array.isArray(rawIndent) ? rawIndent[0] : rawIndent,
+		overrides,
+		quotes,
+		stylistic
+	};
+}
+async function yaml(options = {}) {
+	const { files, indent, overrides, quotes, stylistic } = resolveYamlOptions(options);
 	const [pluginYaml, parserYaml] = await Promise.all([interopDefault(import("eslint-plugin-yml")), interopDefault(import("yaml-eslint-parser"))]);
 	return [{
 		name: "rotki/yaml/setup",
@@ -2100,24 +2198,49 @@ const defaultPluginRenaming = {
 	"vitest": "test",
 	"yml": "yaml"
 };
-/**
-* Construct an array of ESLint flat config items.
-*/
-function rotki(options = {}, ...userConfigs) {
-	const { autoRenamePlugins = true, componentExts = [], e18e: enableE18e = true, gitignore: enableGitignore = true, jsx = true, perfectionist: enablePerfectionist = true, pnpm: enablePnpm = !!findUpSync("pnpm-workspace.yaml"), regexp: enableRegexp = false, rotki: enableRotki, storybook: enableStorybook, typescript: enableTypeScript = isPackageExists("typescript") || isPackageExists("@typescript/native-preview"), unicorn: enableUnicorn = true, vue: enableVue = VuePackages.some((i) => isPackageExists(i)), vueI18n: enableVueI18n } = options;
+function resolveStylisticOptions(options, jsx) {
+	if (options.stylistic === false) return false;
+	const stylisticOptions = typeof options.stylistic === "object" ? options.stylistic : {};
+	if (!("jsx" in stylisticOptions)) stylisticOptions.jsx = jsx;
+	return stylisticOptions;
+}
+function resolveEnableFlags(options) {
+	return {
+		autoRenamePlugins: options.autoRenamePlugins ?? true,
+		enableE18e: options.e18e ?? true,
+		enableGitignore: options.gitignore ?? true,
+		enablePerfectionist: !!(options.perfectionist ?? true),
+		enablePnpm: !!(options.pnpm ?? findUpSync("pnpm-workspace.yaml")),
+		enableRegexp: options.regexp ?? false,
+		enableRotki: options.rotki,
+		enableStorybook: options.storybook,
+		enableUnicorn: options.unicorn ?? true,
+		enableVueI18n: options.vueI18n
+	};
+}
+function resolveIsInEditor(options) {
 	let isInEditor = options.isInEditor;
 	if (isInEditor === null) {
 		isInEditor = isInEditorEnv();
 		if (isInEditor) console.log("[@rotki/eslint-config] Detected running in editor, some rules are disabled.");
 	}
-	function resolveStylisticOptions() {
-		if (options.stylistic === false) return false;
-		if (typeof options.stylistic === "object") return options.stylistic;
-		return {};
-	}
-	const stylisticOptions = resolveStylisticOptions();
-	if (stylisticOptions && !("jsx" in stylisticOptions)) stylisticOptions.jsx = jsx;
-	const configs = [];
+	return !!isInEditor;
+}
+function resolveOptions(options) {
+	const jsx = options.jsx ?? true;
+	const enableVue = !!(options.vue ?? VuePackages.some((i) => isPackageExists(i)));
+	return {
+		...resolveEnableFlags(options),
+		componentExts: [...options.componentExts ?? [], ...enableVue ? ["vue"] : []],
+		enableTypeScript: options.typescript ?? (isPackageExists("typescript") || isPackageExists("@typescript/native-preview")),
+		enableVue,
+		isInEditor: resolveIsInEditor(options),
+		stylisticOptions: resolveStylisticOptions(options, jsx),
+		typescriptOptions: resolveSubOptions(options, "typescript")
+	};
+}
+function buildLanguageConfigs(configs, options, resolved) {
+	const { enableE18e, enableGitignore, enablePerfectionist, enableUnicorn, isInEditor, stylisticOptions } = resolved;
 	if (enableGitignore) {
 		const gitignoreOptions = typeof enableGitignore !== "boolean" ? enableGitignore : { strict: false };
 		configs.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r({
@@ -2125,7 +2248,6 @@ function rotki(options = {}, ...userConfigs) {
 			...gitignoreOptions
 		})]));
 	}
-	const typescriptOptions = resolveSubOptions(options, "typescript");
 	configs.push(ignores(options.ignores), javascript({
 		isInEditor,
 		overrides: getOverrides(options, "javascript")
@@ -2140,7 +2262,9 @@ function rotki(options = {}, ...userConfigs) {
 		isInEditor,
 		type: options.type
 	}));
-	if (enableVue) componentExts.push("vue");
+}
+function buildTypeScriptAndStyleConfigs(configs, options, resolved) {
+	const { componentExts, enableRegexp, enableTypeScript, isInEditor, stylisticOptions, typescriptOptions } = resolved;
 	if (enableTypeScript) configs.push(typescript({
 		...typescriptOptions,
 		componentExts,
@@ -2157,6 +2281,9 @@ function rotki(options = {}, ...userConfigs) {
 		isInEditor,
 		overrides: getOverrides(options, "test")
 	}));
+}
+function buildFrameworkConfigs(configs, options, resolved) {
+	const { enableRotki, enableStorybook, enableTypeScript, enableVue, enableVueI18n, stylisticOptions } = resolved;
 	if (enableVue) configs.push(vue({
 		...resolveSubOptions(options, "vue"),
 		overrides: getOverrides(options, "vue"),
@@ -2175,19 +2302,19 @@ function rotki(options = {}, ...userConfigs) {
 		typescript: !!enableTypeScript
 	}));
 	if (enableStorybook) configs.push(storybook({ overrides: getOverrides(options, "storybook") }));
+}
+function buildFileFormatConfigs(configs, options, resolved) {
+	const { componentExts, enablePnpm, isInEditor, stylisticOptions } = resolved;
 	if (options.jsonc ?? true) configs.push(jsonc({
 		overrides: getOverrides(options, "jsonc"),
 		stylistic: stylisticOptions
 	}), sortPackageJson(), sortTsconfig());
-	if (enablePnpm) {
-		const optionsPnpm = resolveSubOptions(options, "pnpm");
-		configs.push(pnpm({
-			isInEditor,
-			json: options.jsonc !== false,
-			yaml: options.yaml !== false,
-			...optionsPnpm
-		}));
-	}
+	if (enablePnpm) configs.push(pnpm({
+		isInEditor,
+		json: options.jsonc !== false,
+		yaml: options.yaml !== false,
+		...resolveSubOptions(options, "pnpm")
+	}));
 	if (options.yaml ?? true) configs.push(yaml({
 		overrides: getOverrides(options, "yaml"),
 		stylistic: stylisticOptions
@@ -2197,8 +2324,8 @@ function rotki(options = {}, ...userConfigs) {
 		overrides: getOverrides(options, "markdown")
 	}));
 	if (options.formatters) configs.push(formatters(options.formatters, typeof stylisticOptions === "boolean" ? {} : stylisticOptions));
-	configs.push(disables());
-	if ("files" in options) throw new Error("[@rotki/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.");
+}
+function finalizeComposer(configs, options, resolved, userConfigs) {
 	const fusedConfig = flatConfigProps.reduce((acc, key) => {
 		if (key in options) acc[key] = options[key];
 		return acc;
@@ -2207,14 +2334,28 @@ function rotki(options = {}, ...userConfigs) {
 	let composer = new FlatConfigComposer();
 	composer = composer.append(...configs, ...userConfigs);
 	if (options.markdown ?? true) composer = composer.setDefaultIgnores((prev) => [...prev, GLOB_MARKDOWN]);
-	if (autoRenamePlugins) composer = composer.renamePlugins(defaultPluginRenaming);
-	if (isInEditor) composer = composer.disableRulesFix([
+	if (resolved.autoRenamePlugins) composer = composer.renamePlugins(defaultPluginRenaming);
+	if (resolved.isInEditor) composer = composer.disableRulesFix([
 		"unused-imports/no-unused-imports",
 		"test/no-only-tests",
 		"prefer-const"
 	], { builtinRules: () => import(["eslint", "use-at-your-own-risk"].join("/")).then((r) => r.builtinRules) });
 	return composer;
 }
+/**
+* Construct an array of ESLint flat config items.
+*/
+function rotki(options = {}, ...userConfigs) {
+	if ("files" in options) throw new Error("[@rotki/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 resolved = resolveOptions(options);
+	const configs = [];
+	buildLanguageConfigs(configs, options, resolved);
+	buildTypeScriptAndStyleConfigs(configs, options, resolved);
+	buildFrameworkConfigs(configs, options, resolved);
+	buildFileFormatConfigs(configs, options, resolved);
+	configs.push(disables());
+	return finalizeComposer(configs, options, resolved, userConfigs);
+}
 function resolveSubOptions(options, key) {
 	return typeof options[key] === "boolean" ? {} : options[key] || {};
 }