@favorodera/eslint-config 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -1,50 +1,13 @@
-import { FlatConfigComposer } from "eslint-flat-config-utils";
+import { FlatConfigComposer, renamePluginsInRules } from "eslint-flat-config-utils";
 import { defu } from "defu";
 import { mergeProcessors, processorPassThrough } from "eslint-merge-processors";
+import vueBlocksProcessor from "eslint-processor-vue-blocks";
 import globals from "globals";
-//#region src/utils.ts
-/**
-* Return the default export from a module-like object.
-* If the module has no default export, return the original resolved value.
-*
-* @param module - module or promise resolving to a module
-* @returns resolved module default or original module
-*/
-async function getModuleDefault(module) {
-	const resolvedModule = await module;
-	return resolvedModule.default || resolvedModule;
-}
-/**
-* Normalize boolean or options value into merged options or null.
-* Returns null when the input is false or undefined.
-*
-* @param value - boolean, options object, or undefined
-* @param defaults - defaults to merge with
-* @returns merged options or false
-*/
-function resolveOptions(value, defaults) {
-	if (!value) return false;
-	return defu(value === true ? {} : value, defaults);
-}
-/**
-* Rename rules by replacing configured plugin prefixes.
-*
-* @param rules - rules object to rename
-* @param map - prefix map used for renaming
-* @returns renamed rules object
-*/
-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];
-	}));
-}
-//#endregion
 //#region src/globs.ts
 /** Glob pattern for JavaScript linting */
-const jsGlob = "**/*.?([cm])js";
+const jsGlob = "**/*.{js,cjs,mjs}";
 /** Glob pattern for TypeScript linting */
-const tsGlob = "**/*.?([cm])ts";
+const tsGlob = "**/*.{ts,cts,mts}";
 /** Glob pattern for Vue linting */
 const vueGlob = "**/*.vue";
 /** Glob pattern for Markdown linting */
@@ -54,8 +17,8 @@ const mdGlob = "**/*.md";
 * Includes common build outputs, dependencies, caches, and temporary files
 */
 const ignoresGlob = [
-	"**/node_modules",
-	"**/dist",
+	"**/node_modules/**",
+	"**/dist/**",
 	"**/package-lock.json",
 	"**/yarn.lock",
 	"**/pnpm-lock.yaml",
@@ -91,6 +54,35 @@ const ignoresGlob = [
 	"**/.*/skills"
 ];
 //#endregion
+//#region src/utils.ts
+/**
+* Resolves a module (or a promise of one) and returns its default export
+* if present, otherwise returns the module itself.
+*
+* Handles both ESM modules (which wrap exports under `.default`) and
+* CJS / plain-object modules uniformly.
+*
+* @param module - A module or a promise that resolves to one
+* @returns The `.default` export if it exists, otherwise the module itself
+*/
+async function importModule(module) {
+	const resolved = await module;
+	if (resolved !== null && typeof resolved === "object" && "default" in resolved) return resolved.default;
+	return resolved;
+}
+/**
+* Normalize boolean or options value into merged options or null.
+* Returns null when the input is false or undefined.
+*
+* @param value - boolean, options object, or undefined
+* @param defaults - defaults to merge with
+* @returns merged options or false
+*/
+function resolveOptions(value, defaults) {
+	if (!value) return false;
+	return defu(value === true ? {} : value, defaults);
+}
+//#endregion
 //#region src/configs/vue.ts
 const sfcBlocksDefaults = { blocks: {
 	styles: true,
@@ -101,22 +93,21 @@ const vueDefaults = {
 	files: [vueGlob],
 	sfcBlocks: sfcBlocksDefaults
 };
-/**
-* Vue SFC linting via `vue-eslint-parser`, `eslint-plugin-vue`, `typescript-eslint(parser)`.
-* @param options - Vue configuration options
-* @returns Promise resolving to Vue ESLint config items
-*/
 async function vue(options) {
 	const resolved = defu(options, vueDefaults);
 	const sfcBlocks = resolveOptions(resolved.sfcBlocks, sfcBlocksDefaults);
-	const [vuePlugin, vueParser, tsEsLint, vueBlocksProcessor] = await Promise.all([
-		getModuleDefault(import("eslint-plugin-vue")),
-		getModuleDefault(import("vue-eslint-parser")),
-		getModuleDefault(import("typescript-eslint")),
-		getModuleDefault(import("eslint-processor-vue-blocks"))
+	const [vuePlugin, vueParser, tsEsLint] = await Promise.all([
+		importModule(import("eslint-plugin-vue")),
+		importModule(import("vue-eslint-parser")),
+		importModule(import("typescript-eslint"))
 	]);
+	const inheritedRules = Object.assign({}, ...[
+		...vuePlugin.configs["flat/essential"],
+		...vuePlugin.configs["flat/strongly-recommended"],
+		...vuePlugin.configs["flat/recommended"]
+	].map((config) => config?.rules || {}));
 	return [{
-		name: "favorodera/vue/rules",
+		name: "favorodera/vue",
 		plugins: { vue: vuePlugin },
 		files: resolved.files,
 		languageOptions: {
@@ -145,19 +136,7 @@ async function vue(options) {
 		},
 		processor: sfcBlocks === false ? vuePlugin.processors[".vue"] : mergeProcessors([vuePlugin.processors[".vue"], vueBlocksProcessor(sfcBlocks)]),
 		rules: {
-			...vuePlugin.configs.base.rules,
-			...vuePlugin.configs["flat/essential"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
-				...accumulator,
-				...currentConfig
-			}), {}),
-			...vuePlugin.configs["flat/strongly-recommended"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
-				...accumulator,
-				...currentConfig
-			}), {}),
-			...vuePlugin.configs["flat/recommended"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
-				...accumulator,
-				...currentConfig
-			}), {}),
+			...inheritedRules,
 			"vue/block-order": ["error", { order: [
 				"script",
 				"template",
@@ -179,43 +158,6 @@ async function vue(options) {
 	}];
 }
 //#endregion
-//#region src/configs/typescript.ts
-const typescriptDefaults = { files: [tsGlob] };
-/**
-* Extract and merge rules from a compatible config array.
-* @param configs - Array of compatible ESLint configs
-* @returns Merged rules object from all configs
-*/
-function extractRules(configs) {
-	return Object.assign({}, ...configs.map((config) => config.rules || {}));
-}
-/**
-* Typescript linting via `typescript-eslint`.
-* @param options - TypeScript configuration options
-* @returns Promise resolving to TypeScript ESLint config items
-*/
-async function typescript(options) {
-	const resolved = defu(options, typescriptDefaults);
-	const tsEsLint = await getModuleDefault(import("typescript-eslint"));
-	return [{
-		name: "favorodera/typescript/rules",
-		files: resolved.files,
-		plugins: { ts: tsEsLint.plugin },
-		languageOptions: {
-			parser: tsEsLint.parser,
-			parserOptions: { sourceType: "module" }
-		},
-		rules: {
-			...renameRules(extractRules(tsEsLint.configs.strict), { "@typescript-eslint": "ts" }),
-			...renameRules(extractRules(tsEsLint.configs.stylistic), { "@typescript-eslint": "ts" }),
-			"ts/consistent-type-imports": ["error", { prefer: "type-imports" }],
-			"ts/no-empty-object-type": ["error", { allowInterfaces: "with-single-extends" }],
-			"ts/array-type": ["error", { default: "array" }],
-			...resolved.overrides
-		}
-	}];
-}
-//#endregion
 //#region src/configs/ignores.ts
 const defaultPatterns = ignoresGlob;
 /**
@@ -230,141 +172,25 @@ function ignores(patterns = []) {
 	}];
 }
 //#endregion
-//#region src/configs/stylistic.ts
-const stylisticDefaults = {
-	indent: 2,
-	experimental: false,
-	quotes: "single",
-	semi: false,
-	jsx: false
-};
-/**
-* Code style via `@stylistic/eslint-plugin`.
-* @param options - Stylistic configuration options
-* @returns Promise resolving to stylistic ESLint config items
-*/
-async function stylistic(options) {
-	const resolved = defu(options, stylisticDefaults);
-	const stylePlugin = await getModuleDefault(import("@stylistic/eslint-plugin"));
-	const customizedStyleConfig = stylePlugin.configs.customize({
-		pluginName: "style",
-		...resolved
-	});
-	return [{
-		name: "favorodera/stylistic/rules",
-		plugins: { style: stylePlugin },
-		rules: {
-			...customizedStyleConfig.rules,
-			"style/quotes": [
-				"error",
-				"single",
-				{ avoidEscape: true }
-			],
-			"style/no-multiple-empty-lines": ["error", {
-				max: 2,
-				maxEOF: 2,
-				maxBOF: 0
-			}],
-			"style/padded-blocks": "off",
-			"style/no-trailing-spaces": ["error", { skipBlankLines: true }],
-			"style/brace-style": "off",
-			"style/generator-star-spacing": ["error", {
-				after: true,
-				before: false
-			}],
-			"style/yield-star-spacing": ["error", {
-				after: true,
-				before: false
-			}],
-			...resolved.overrides
-		}
-	}];
-}
-//#endregion
-//#region src/configs/tailwind.ts
-const tailwindDefaults = {
-	files: [
-		jsGlob,
-		tsGlob,
-		vueGlob
-	],
-	settings: { detectComponentClasses: true }
-};
-/**
-* Tailwind linting via `eslint-plugin-better-tailwindcss`.
-* @param options - Tailwind configuration options
-* @returns Promise resolving to Tailwind ESLint config items
-*/
-async function tailwind(options) {
-	const resolved = defu(options, tailwindDefaults);
-	const tailwindPlugin = await getModuleDefault(import("eslint-plugin-better-tailwindcss"));
-	return [{
-		name: "favorodera/tailwind/rules",
-		plugins: { tailwind: tailwindPlugin },
-		files: resolved.files,
-		settings: { tailwindcss: resolved.settings },
-		rules: {
-			...renameRules(tailwindPlugin.configs["recommended-error"].rules, { "better-tailwindcss": "tailwind" }),
-			...renameRules(tailwindPlugin.configs["stylistic-error"].rules, { "better-tailwindcss": "tailwind" }),
-			"tailwind/no-unregistered-classes": "off",
-			"tailwind/enforce-consistent-line-wrapping": ["error", { group: "emptyLine" }],
-			...resolved.overrides
-		}
-	}];
-}
-//#endregion
-//#region src/configs/comments.ts
-const commentsDefaults = { files: [
-	jsGlob,
-	tsGlob,
-	vueGlob
-] };
-/**
-* Comments linting via `@eslint-community/eslint-plugin-eslint-comments`
-* @param options - Comments configuration options
-* @returns Promise resolving to comments ESLint config items
-*/
-async function comments(options) {
-	const resolved = defu(options, commentsDefaults);
-	const commentsPlugin = await getModuleDefault(import("@eslint-community/eslint-plugin-eslint-comments"));
-	return [{
-		name: "favorodera/comments/rules",
-		files: resolved.files,
-		plugins: { comments: commentsPlugin },
-		rules: {
-			...renameRules(commentsPlugin.configs.recommended?.rules || {}, { "@eslint-community/eslint-comments": "comments" }),
-			"comments/no-aggregating-enable": "error",
-			"comments/no-duplicate-disable": "error",
-			"comments/no-unlimited-disable": "error",
-			"comments/no-unused-enable": "error",
-			...resolved.overrides
-		}
-	}];
-}
-//#endregion
 //#region src/configs/imports.ts
 const importsDefaults = { files: [
 	jsGlob,
 	tsGlob,
 	vueGlob
 ] };
-/**
-* Imports & unused imports linting via `eslint-plugin-import-lite` and `eslint-plugin-unused-imports`.
-* @param options - Imports & unused imports configuration options
-* @returns Promise resolving to imports & unused imports ESLint config items
-*/
 async function imports(options) {
 	const resolved = defu(options, importsDefaults);
-	const [importPlugin, unusedImportsPlugin] = await Promise.all([getModuleDefault(import("eslint-plugin-import-lite")), getModuleDefault(import("eslint-plugin-unused-imports"))]);
+	const [importPlugin, unusedImportsPlugin] = await Promise.all([importModule(import("eslint-plugin-import-lite")), importModule(import("eslint-plugin-unused-imports"))]);
+	const inheritedRules = importPlugin.configs.recommended?.rules || {};
 	return [{
-		name: "favorodera/imports/rules",
+		name: "favorodera/imports",
 		files: resolved.files,
 		plugins: {
 			"import": importPlugin,
 			"unused-imports": unusedImportsPlugin
 		},
 		rules: {
-			...renameRules(importPlugin.configs.recommended?.rules || {}, { "import-lite": "import" }),
+			...renamePluginsInRules(inheritedRules, { "import-lite": "import" }),
 			"import/consistent-type-specifier-style": ["error", "top-level"],
 			"import/first": "error",
 			"import/no-duplicates": "error",
@@ -384,34 +210,6 @@ async function imports(options) {
 	}];
 }
 //#endregion
-//#region src/configs/markdown.ts
-const markdownDefaults = {
-	files: [mdGlob],
-	gfm: true
-};
-/**
-* Markdown linting via `@eslint/markdown`.
-* @param options - Markdown configuration options
-* @returns Promise resolving to Markdown ESLint config items
-*/
-async function markdown(options) {
-	const resolved = defu(options, markdownDefaults);
-	const markdownPlugin = await getModuleDefault(import("@eslint/markdown"));
-	return [{
-		name: "favorodera/markdown/rules",
-		files: resolved.files,
-		plugins: { md: markdownPlugin },
-		processor: mergeProcessors([markdownPlugin.processors?.markdown, processorPassThrough]),
-		language: resolved.gfm ? "md/gfm" : "md/commonmark",
-		rules: {
-			...renameRules(markdownPlugin.configs.recommended[0]?.rules || {}, { markdown: "md" }),
-			"md/fenced-code-language": "off",
-			"md/no-missing-label-refs": "off",
-			...resolved.overrides
-		}
-	}];
-}
-//#endregion
 //#region src/configs/javascript.ts
 const javascriptDefaults = { files: [
 	jsGlob,
@@ -425,9 +223,9 @@ const javascriptDefaults = { files: [
 */
 async function javascript(options) {
 	const resolved = defu(options, javascriptDefaults);
-	const jsPlugin = await getModuleDefault(import("@eslint/js"));
+	const inheritedRules = (await importModule(import("@eslint/js"))).configs.recommended.rules;
 	return [{
-		name: "favorodera/javascript/rules",
+		name: "favorodera/javascript",
 		files: resolved.files,
 		languageOptions: {
 			ecmaVersion: "latest",
@@ -442,189 +240,156 @@ async function javascript(options) {
 			}
 		},
 		linterOptions: { reportUnusedDisableDirectives: true },
-		plugins: { js: jsPlugin },
 		rules: {
-			...jsPlugin.configs.recommended.rules,
+			...inheritedRules,
 			"accessor-pairs": ["error", {
 				enforceForClassMembers: true,
 				setWithoutGet: true
 			}],
 			"array-callback-return": "error",
 			"block-scoped-var": "error",
-			"constructor-super": "error",
-			"default-case-last": "error",
-			"dot-notation": ["error", { allowKeywords: true }],
-			"eqeqeq": ["error", "smart"],
-			"new-cap": ["error", {
-				capIsNew: false,
-				newIsCap: true,
-				properties: true
-			}],
-			"no-alert": "error",
-			"no-array-constructor": "error",
-			"no-async-promise-executor": "error",
-			"no-caller": "error",
-			"no-case-declarations": "error",
-			"no-class-assign": "error",
-			"no-compare-neg-zero": "error",
-			"no-cond-assign": ["error", "always"],
-			"no-console": ["error", { allow: ["warn", "error"] }],
-			"no-const-assign": "error",
-			"no-control-regex": "error",
-			"no-debugger": "error",
-			"no-delete-var": "error",
-			"no-dupe-args": "error",
-			"no-dupe-class-members": "error",
-			"no-dupe-keys": "error",
-			"no-duplicate-case": "error",
-			"no-empty": ["error", { allowEmptyCatch: true }],
-			"no-empty-character-class": "error",
-			"no-empty-pattern": "error",
-			"no-eval": "error",
-			"no-ex-assign": "error",
-			"no-extend-native": "error",
-			"no-extra-bind": "error",
-			"no-extra-boolean-cast": "error",
-			"no-fallthrough": "error",
-			"no-func-assign": "error",
-			"no-global-assign": "error",
-			"no-implied-eval": "error",
-			"no-import-assign": "error",
-			"no-invalid-regexp": "error",
-			"no-irregular-whitespace": "error",
-			"no-iterator": "error",
-			"no-labels": ["error", {
-				allowLoop: false,
-				allowSwitch: false
-			}],
-			"no-lone-blocks": "error",
-			"no-loss-of-precision": "error",
-			"no-misleading-character-class": "error",
-			"no-multi-str": "error",
-			"no-new": "error",
-			"no-new-func": "error",
-			"no-new-native-nonconstructor": "error",
-			"no-new-wrappers": "error",
-			"no-obj-calls": "error",
-			"no-octal": "error",
-			"no-octal-escape": "error",
-			"no-proto": "error",
-			"no-prototype-builtins": "error",
-			"no-redeclare": ["error", { builtinGlobals: false }],
-			"no-regex-spaces": "error",
-			"no-restricted-globals": [
-				"error",
-				{
-					message: "Use `globalThis` instead.",
-					name: "global"
-				},
-				{
-					message: "Use `globalThis` instead.",
-					name: "self"
-				}
-			],
-			"no-restricted-properties": [
-				"error",
-				{
-					message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
-					property: "__proto__"
-				},
-				{
-					message: "Use `Object.defineProperty` instead.",
-					property: "__defineGetter__"
-				},
-				{
-					message: "Use `Object.defineProperty` instead.",
-					property: "__defineSetter__"
-				},
-				{
-					message: "Use `Object.getOwnPropertyDescriptor` instead.",
-					property: "__lookupGetter__"
-				},
-				{
-					message: "Use `Object.getOwnPropertyDescriptor` instead.",
-					property: "__lookupSetter__"
-				}
-			],
-			"no-restricted-syntax": [
-				"error",
-				"TSEnumDeclaration[const=true]",
-				"TSExportAssignment"
-			],
-			"no-self-assign": ["error", { props: true }],
-			"no-self-compare": "error",
-			"no-sequences": "error",
-			"no-shadow-restricted-names": "error",
-			"no-sparse-arrays": "error",
-			"no-template-curly-in-string": "error",
-			"no-this-before-super": "error",
-			"no-throw-literal": "error",
-			"no-undef": "error",
-			"no-undef-init": "error",
-			"no-unexpected-multiline": "error",
-			"no-unmodified-loop-condition": "error",
-			"no-unneeded-ternary": ["error", { defaultAssignment: false }],
-			"no-unreachable": "error",
-			"no-unreachable-loop": "error",
-			"no-unsafe-finally": "error",
-			"no-unsafe-negation": "error",
-			"no-unused-expressions": ["error", {
-				allowShortCircuit: true,
-				allowTaggedTemplates: true,
-				allowTernary: true
-			}],
-			"no-unused-vars": ["error", {
-				args: "none",
-				caughtErrors: "none",
-				ignoreRestSiblings: true,
-				vars: "all"
-			}],
-			"no-use-before-define": ["error", {
-				classes: false,
-				functions: false,
-				variables: true
-			}],
-			"no-useless-backreference": "error",
-			"no-useless-call": "error",
-			"no-useless-catch": "error",
-			"no-useless-computed-key": "error",
-			"no-useless-constructor": "error",
-			"no-useless-rename": "error",
-			"no-useless-return": "error",
-			"no-var": "error",
-			"no-with": "error",
-			"object-shorthand": [
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/markdown.ts
+const markdownDefaults = {
+	files: [mdGlob],
+	gfm: true
+};
+async function markdown(options) {
+	const resolved = defu(options, markdownDefaults);
+	const markdownPlugin = await importModule(import("@eslint/markdown"));
+	const inheritedRules = Object.assign({}, ...[...markdownPlugin.configs.recommended].map((config) => config?.rules || {}));
+	return [{
+		name: "favorodera/markdown",
+		files: resolved.files,
+		plugins: { md: markdownPlugin },
+		processor: mergeProcessors([markdownPlugin.processors?.markdown, processorPassThrough]),
+		language: resolved.gfm ? "md/gfm" : "md/commonmark",
+		rules: {
+			...renamePluginsInRules(inheritedRules, { markdown: "md" }),
+			"md/fenced-code-language": "off",
+			"md/no-missing-label-refs": "off",
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/stylistic.ts
+const stylisticDefaults = {
+	settings: {
+		indent: 2,
+		experimental: false,
+		quotes: "single",
+		semi: false,
+		jsx: false
+	},
+	files: [
+		jsGlob,
+		tsGlob,
+		vueGlob
+	]
+};
+async function stylistic(options) {
+	const resolved = defu(options, stylisticDefaults);
+	const config = (await importModule(import("@stylistic/eslint-plugin"))).configs.customize({
+		pluginName: "style",
+		...resolved.settings
+	});
+	const inheritedRules = config?.rules || {};
+	return [{
+		...config,
+		name: "favorodera/stylistic",
+		files: resolved.files,
+		rules: {
+			...inheritedRules,
+			"style/quotes": [
 				"error",
-				"always",
-				{
-					avoidQuotes: true,
-					ignoreConstructors: false
-				}
+				"single",
+				{ avoidEscape: true }
 			],
-			"one-var": ["error", { initialized: "never" }],
-			"prefer-arrow-callback": ["error", {
-				allowNamedFunctions: false,
-				allowUnboundThis: true
+			"style/no-multiple-empty-lines": ["error", {
+				max: 2,
+				maxEOF: 2,
+				maxBOF: 0
 			}],
-			"prefer-const": ["error", {
-				destructuring: "all",
-				ignoreReadBeforeAssign: true
+			"style/padded-blocks": "off",
+			"style/no-trailing-spaces": ["error", { skipBlankLines: true }],
+			"style/brace-style": "off",
+			"style/generator-star-spacing": ["error", {
+				after: true,
+				before: false
 			}],
-			"prefer-exponentiation-operator": "error",
-			"prefer-promise-reject-errors": "error",
-			"prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
-			"prefer-rest-params": "error",
-			"prefer-spread": "error",
-			"prefer-template": "error",
-			"symbol-description": "error",
-			"unicode-bom": ["error", "never"],
-			"use-isnan": ["error", {
-				enforceForIndexOf: true,
-				enforceForSwitchCase: true
+			"style/yield-star-spacing": ["error", {
+				after: true,
+				before: false
 			}],
-			"valid-typeof": ["error", { requireStringLiterals: true }],
-			"vars-on-top": "error",
-			"yoda": ["error", "never"],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/tailwind.ts
+const tailwindDefaults = {
+	files: [
+		jsGlob,
+		tsGlob,
+		vueGlob
+	],
+	settings: { detectComponentClasses: true }
+};
+/**
+* Tailwind linting via `eslint-plugin-better-tailwindcss`.
+* @param options - Tailwind configuration options
+* @returns Promise resolving to Tailwind ESLint config items
+*/
+async function tailwind(options) {
+	const resolved = defu(options, tailwindDefaults);
+	const tailwindPlugin = await importModule(import("eslint-plugin-better-tailwindcss"));
+	const inheritedRules = {
+		...tailwindPlugin.configs["recommended-error"].rules,
+		...tailwindPlugin.configs["stylistic-error"].rules
+	};
+	return [{
+		name: "favorodera/tailwind",
+		files: resolved.files,
+		plugins: { tailwind: tailwindPlugin },
+		settings: { tailwindcss: resolved.settings },
+		rules: {
+			...renamePluginsInRules(inheritedRules, { "better-tailwindcss": "tailwind" }),
+			"tailwind/no-unregistered-classes": "off",
+			"tailwind/enforce-consistent-line-wrapping": ["error", { group: "emptyLine" }],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/typescript.ts
+const typescriptDefaults = { files: [tsGlob] };
+/**
+* Typescript linting via `typescript-eslint`.
+* @param options - TypeScript configuration options
+* @returns Array of TypeScript ESLint config items
+*/
+async function typescript(options) {
+	const resolved = defu(options, typescriptDefaults);
+	const tsEsLint = await importModule(import("typescript-eslint"));
+	const inheritedRules = Object.assign({}, ...[...tsEsLint.configs.recommended, ...tsEsLint.configs.strict].map((config) => config?.rules || {}));
+	return [{
+		name: "favorodera/typescript",
+		plugins: { ts: tsEsLint.plugin },
+		languageOptions: {
+			parser: tsEsLint.parser,
+			parserOptions: { sourceType: "module" }
+		},
+		files: resolved.files,
+		rules: {
+			...renamePluginsInRules(inheritedRules, { "@typescript-eslint": "ts" }),
+			"ts/consistent-type-imports": ["error", { prefer: "type-imports" }],
+			"ts/no-empty-object-type": ["error", { allowInterfaces: "with-single-extends" }],
+			"ts/array-type": ["error", { default: "array" }],
 			...resolved.overrides
 		}
 	}];
@@ -639,25 +404,28 @@ async function javascript(options) {
 function factory(options = {}) {
 	const configs = [];
 	configs.push(ignores(options.ignores));
-	const vueOptions = resolveOptions(options.vue, {});
-	const typescriptOptions = resolveOptions(options.typescript, {});
-	const stylisticOptions = resolveOptions(options.stylistic, {});
-	const tailwindOptions = resolveOptions(options.tailwind, {});
-	const commentsOptions = resolveOptions(options.comments, {});
-	const importsOptions = resolveOptions(options.imports, {});
-	const markdownOptions = resolveOptions(options.markdown, {});
-	const javascriptOptions = resolveOptions(options.javascript, {});
-	if (vueOptions) configs.push(vue(vueOptions));
-	if (typescriptOptions) configs.push(typescript(typescriptOptions));
-	if (stylisticOptions) configs.push(stylistic(stylisticOptions));
-	if (tailwindOptions) configs.push(tailwind(tailwindOptions));
-	if (commentsOptions) configs.push(comments(commentsOptions));
-	if (importsOptions) configs.push(imports(importsOptions));
-	if (markdownOptions) configs.push(markdown(markdownOptions));
-	if (javascriptOptions) configs.push(javascript(javascriptOptions));
+	const configFunctions = {
+		vue,
+		typescript,
+		stylistic,
+		tailwind,
+		imports,
+		markdown,
+		javascript
+	};
+	for (const [key, configFunction] of Object.entries(configFunctions)) {
+		const configOption = options[key];
+		const resolved = resolveOptions(configOption ?? true, {});
+		if (resolved) configs.push(configFunction(resolved));
+	}
 	let composer = new FlatConfigComposer();
-	composer = composer.append(...configs);
+	composer = composer.append(...configs).renamePlugins({
+		"better-tailwindcss": "tailwind",
+		"@typescript-eslint": "ts",
+		"markdown": "md",
+		"import-lite": "import"
+	});
 	return composer;
 }
 //#endregion
-export { factory, getModuleDefault, renameRules };
+export { factory, importModule };