@eienjs/eslint-config 1.2.2 → 1.4.0

package/dist/configs/toml.js

@@ -0,0 +1,45 @@
+import { GLOB_TOML } from "../globs.js";
+import { interopDefault } from "../utils.js";
+
+//#region src/configs/toml.ts
+async function toml(options = {}) {
+	const { files = [GLOB_TOML], overrides = {}, stylistic = true } = options;
+	const { indent = 2 } = typeof stylistic === "boolean" ? {} : stylistic;
+	const [pluginToml, parserToml] = await Promise.all([interopDefault(import("eslint-plugin-toml")), interopDefault(import("toml-eslint-parser"))]);
+	return [{
+		name: "eienjs/toml/setup",
+		plugins: { toml: pluginToml }
+	}, {
+		files,
+		languageOptions: { parser: parserToml },
+		name: "eienjs/toml/rules",
+		rules: {
+			"@stylistic/spaced-comment": "off",
+			"toml/comma-style": "error",
+			"toml/keys-order": "error",
+			"toml/no-space-dots": "error",
+			"toml/no-unreadable-number-separator": "error",
+			"toml/precision-of-fractional-seconds": "error",
+			"toml/precision-of-integer": "error",
+			"toml/tables-order": "error",
+			"toml/vue-custom-block/no-parsing-error": "error",
+			...stylistic ? {
+				"toml/array-bracket-newline": "error",
+				"toml/array-bracket-spacing": "error",
+				"toml/array-element-newline": "error",
+				"toml/indent": ["error", indent === "tab" ? 2 : indent],
+				"toml/inline-table-curly-spacing": "error",
+				"toml/key-spacing": "error",
+				"toml/padding-line-between-pairs": "error",
+				"toml/padding-line-between-tables": "error",
+				"toml/quoted-keys": "error",
+				"toml/spaced-comment": "error",
+				"toml/table-bracket-spacing": "error"
+			} : {},
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+export { toml };

package/dist/configs/typescript.d.ts

@@ -0,0 +1,6 @@
+import { OptionsComponentExts, OptionsFiles, OptionsOverrides, OptionsStylistic, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes, OptionsTypescriptWithErasableSyntaxOnly, TypedFlatConfigItem } from "../types.js";
+
+//#region src/configs/typescript.d.ts
+declare function typescript(options?: OptionsFiles & OptionsComponentExts & OptionsOverrides & OptionsTypeScriptWithTypes & OptionsTypeScriptParserOptions & OptionsTypescriptWithErasableSyntaxOnly & OptionsStylistic): Promise<TypedFlatConfigItem[]>;
+//#endregion
+export { typescript };

package/dist/configs/typescript.js

@@ -0,0 +1,237 @@
+import { GLOB_ASTRO_TS, GLOB_MARKDOWN, GLOB_TS, GLOB_TSX } from "../globs.js";
+import { ensurePackages, interopDefault } from "../utils.js";
+import { pluginAntfu } from "../plugins.js";
+import process from "node:process";
+
+//#region src/configs/typescript.ts
+async function typescript(options = {}) {
+	const { componentExts = [], overrides = {}, overridesTypeAware = {}, parserOptions = {}, stylistic = true, erasableSyntaxOnly = false } = options;
+	const files = options.files ?? [
+		GLOB_TS,
+		GLOB_TSX,
+		...componentExts.map((ext) => `**/*.${ext}`)
+	];
+	const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
+	const ignoresTypeAware = options.ignoresTypeAware ?? [`${GLOB_MARKDOWN}/**`, GLOB_ASTRO_TS];
+	const tsconfigPath = options.tsconfigPath ?? void 0;
+	const isTypeAware = Boolean(tsconfigPath);
+	const isErasableSyntaxOnly = Boolean(erasableSyntaxOnly);
+	const typeAwareRules = {
+		"dot-notation": "off",
+		"no-implied-eval": "off",
+		"@typescript-eslint/await-thenable": "error",
+		"@typescript-eslint/consistent-type-exports": ["error", { fixMixedExportsWithInlineTypeSpecifier: true }],
+		"@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+		"@typescript-eslint/explicit-member-accessibility": "error",
+		"@typescript-eslint/explicit-module-boundary-types": "error",
+		"@typescript-eslint/naming-convention": [
+			"error",
+			{
+				format: ["camelCase", "UPPER_CASE"],
+				leadingUnderscore: "allowSingleOrDouble",
+				modifiers: ["const"],
+				selector: "variable",
+				trailingUnderscore: "allowSingleOrDouble",
+				types: ["string", "number"]
+			},
+			{
+				format: null,
+				leadingUnderscore: "allowSingleOrDouble",
+				selector: "objectLiteralProperty",
+				trailingUnderscore: "allowSingleOrDouble"
+			},
+			{
+				format: ["PascalCase"],
+				leadingUnderscore: "allowSingleOrDouble",
+				selector: "typeLike",
+				trailingUnderscore: "allowSingleOrDouble"
+			},
+			{
+				format: null,
+				modifiers: ["destructured"],
+				selector: "variable"
+			},
+			{
+				format: null,
+				selector: "typeProperty"
+			},
+			{
+				format: ["PascalCase"],
+				selector: "class"
+			},
+			{
+				custom: {
+					match: false,
+					regex: "^I[A-Z]"
+				},
+				format: ["PascalCase"],
+				selector: "interface"
+			},
+			{
+				selector: "variable",
+				format: [
+					"camelCase",
+					"UPPER_CASE",
+					"PascalCase"
+				],
+				leadingUnderscore: "allow"
+			}
+		],
+		"@typescript-eslint/no-floating-promises": "error",
+		"@typescript-eslint/no-for-in-array": "error",
+		"@typescript-eslint/no-implied-eval": "error",
+		"@typescript-eslint/no-misused-promises": "error",
+		"@typescript-eslint/no-unnecessary-type-assertion": "error",
+		"@typescript-eslint/no-unsafe-argument": "error",
+		"@typescript-eslint/no-unsafe-assignment": "error",
+		"@typescript-eslint/no-unsafe-call": "error",
+		"@typescript-eslint/no-unsafe-member-access": "error",
+		"@typescript-eslint/no-unsafe-return": "error",
+		"@typescript-eslint/prefer-nullish-coalescing": ["error", { ignorePrimitives: { string: true } }],
+		"@typescript-eslint/prefer-optional-chain": "error",
+		"@typescript-eslint/prefer-string-starts-ends-with": "error",
+		"@typescript-eslint/promise-function-async": "error",
+		"@typescript-eslint/restrict-plus-operands": "error",
+		"@typescript-eslint/restrict-template-expressions": "error",
+		"@typescript-eslint/return-await": ["error", "in-try-catch"],
+		"@typescript-eslint/switch-exhaustiveness-check": ["error", { considerDefaultExhaustiveForUnions: true }],
+		"@typescript-eslint/no-unused-vars": ["error", {
+			"args": "all",
+			"argsIgnorePattern": "^_",
+			"caughtErrors": "all",
+			"caughtErrorsIgnorePattern": "^_",
+			"destructuredArrayIgnorePattern": "^_",
+			"varsIgnorePattern": "^_",
+			"ignoreRestSiblings": true
+		}]
+	};
+	const [pluginTs, parserTs] = await Promise.all([interopDefault(import("@typescript-eslint/eslint-plugin")), interopDefault(import("@typescript-eslint/parser"))]);
+	function makeParser(typeAware, files$1, ignores) {
+		return {
+			files: files$1,
+			...ignores ? { ignores } : {},
+			languageOptions: {
+				parser: parserTs,
+				parserOptions: {
+					extraFileExtensions: componentExts.map((ext) => `.${ext}`),
+					sourceType: "module",
+					...typeAware ? {
+						projectService: {
+							allowDefaultProject: ["./*.js"],
+							defaultProject: tsconfigPath
+						},
+						tsconfigRootDir: process.cwd()
+					} : {},
+					...parserOptions
+				}
+			},
+			name: `eienjs/typescript/${typeAware ? "type-aware-parser" : "parser"}`
+		};
+	}
+	const rules = [{
+		name: "eienjs/typescript/setup",
+		plugins: {
+			"antfu": pluginAntfu,
+			"@typescript-eslint": pluginTs
+		}
+	}];
+	if (isTypeAware) rules.push(makeParser(false, files), makeParser(true, filesTypeAware, ignoresTypeAware));
+	else rules.push(makeParser(false, files));
+	rules.push({
+		files,
+		name: "eienjs/typescript/rules",
+		rules: {
+			...pluginTs.configs["eslint-recommended"].overrides?.[0].rules,
+			...pluginTs.configs.strict.rules,
+			...stylistic ? pluginTs.configs.stylistic.rules : {},
+			"no-dupe-class-members": "off",
+			"no-redeclare": "off",
+			"no-use-before-define": "off",
+			"no-useless-constructor": "off",
+			"@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": "allow-with-description" }],
+			"@typescript-eslint/consistent-type-assertions": "error",
+			"@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+			"@typescript-eslint/consistent-type-imports": ["error", {
+				disallowTypeAnnotations: false,
+				fixStyle: "separate-type-imports",
+				prefer: "type-imports"
+			}],
+			"@typescript-eslint/default-param-last": "error",
+			"@typescript-eslint/method-signature-style": ["error", "property"],
+			"@typescript-eslint/no-dupe-class-members": "error",
+			"@typescript-eslint/no-dynamic-delete": "off",
+			"@typescript-eslint/no-explicit-any": "off",
+			"@typescript-eslint/no-import-type-side-effects": "error",
+			"@typescript-eslint/no-invalid-void-type": "off",
+			"@typescript-eslint/no-redeclare": ["error", { builtinGlobals: false }],
+			"@typescript-eslint/no-require-imports": "error",
+			"@typescript-eslint/no-unused-expressions": ["error", {
+				allowShortCircuit: true,
+				allowTaggedTemplates: true,
+				allowTernary: true
+			}],
+			"@typescript-eslint/no-unused-vars": ["error", {
+				"args": "all",
+				"argsIgnorePattern": "^_",
+				"caughtErrors": "all",
+				"caughtErrorsIgnorePattern": "^_",
+				"destructuredArrayIgnorePattern": "^_",
+				"varsIgnorePattern": "^_",
+				"ignoreRestSiblings": true
+			}],
+			"@typescript-eslint/no-use-before-define": ["error", {
+				classes: false,
+				functions: false,
+				variables: true
+			}],
+			"@typescript-eslint/no-useless-constructor": "off",
+			"@typescript-eslint/no-wrapper-object-types": "error",
+			"@typescript-eslint/triple-slash-reference": "off",
+			"@typescript-eslint/unified-signatures": "off",
+			...overrides
+		}
+	});
+	if (isTypeAware) rules.push({
+		files: filesTypeAware,
+		ignores: ignoresTypeAware,
+		name: "eienjs/typescript/rules-type-aware",
+		rules: {
+			...pluginTs.configs["strict-type-checked"].rules,
+			...stylistic ? pluginTs.configs["stylistic-type-checked"].rules : {},
+			...typeAwareRules,
+			...overridesTypeAware
+		}
+	});
+	rules.push({
+		files: isTypeAware ? filesTypeAware : files,
+		name: "eienjs/typescript/disables",
+		rules: {
+			"@typescript-eslint/no-empty-object-type": "off",
+			"@typescript-eslint/no-extraneous-class": "off",
+			"@typescript-eslint/no-non-null-assertion": "off"
+		}
+	});
+	if (isErasableSyntaxOnly) {
+		await ensurePackages(["eslint-plugin-erasable-syntax-only"]);
+		const pluginErasableSyntaxOnly = await interopDefault(import("eslint-plugin-erasable-syntax-only"));
+		const { enums, parameterProperties } = typeof isErasableSyntaxOnly === "boolean" ? {
+			enums: true,
+			parameterProperties: true
+		} : isErasableSyntaxOnly;
+		rules.push({
+			files,
+			name: "eienjs/typescript/erasable-syntax-only",
+			plugins: { "erasable-syntax-only": pluginErasableSyntaxOnly },
+			rules: {
+				"erasable-syntax-only/enums": enums ? "error" : "off",
+				"erasable-syntax-only/import-aliases": "error",
+				"erasable-syntax-only/namespaces": "error",
+				"erasable-syntax-only/parameter-properties": parameterProperties ? "error" : "off"
+			}
+		});
+	}
+	return rules;
+}
+
+//#endregion
+export { typescript };

package/dist/configs/unicorn.d.ts

@@ -0,0 +1,6 @@
+import { OptionsOverrides, TypedFlatConfigItem } from "../types.js";
+
+//#region src/configs/unicorn.d.ts
+declare function unicorn(options?: OptionsOverrides): TypedFlatConfigItem[];
+//#endregion
+export { unicorn };

package/dist/configs/unicorn.js

@@ -0,0 +1,42 @@
+import { GLOB_SRC } from "../globs.js";
+import { pluginUnicorn } from "../plugins.js";
+
+//#region src/configs/unicorn.ts
+function unicorn(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		name: "eienjs/unicorn/rules",
+		plugins: { unicorn: pluginUnicorn },
+		rules: {
+			...pluginUnicorn.configs.recommended.rules,
+			"unicorn/no-this-assignment": "off",
+			"unicorn/consistent-destructuring": "error",
+			"unicorn/consistent-function-scoping": ["error", { checkArrowFunctions: false }],
+			"unicorn/no-null": "off",
+			"unicorn/no-static-only-class": "off",
+			"unicorn/numeric-separators-style": "off",
+			"unicorn/prefer-dom-node-append": "off",
+			"unicorn/prefer-dom-node-dataset": "off",
+			"unicorn/prefer-dom-node-remove": "off",
+			"unicorn/prefer-dom-node-text-content": "off",
+			"unicorn/prefer-modern-dom-apis": "off",
+			"unicorn/prefer-query-selector": "off",
+			"unicorn/prefer-switch": ["error", { emptyDefaultCase: "do-nothing-comment" }],
+			"unicorn/prevent-abbreviations": "off",
+			"unicorn/no-thenable": "off",
+			"unicorn/expiring-todo-comments": "off",
+			"unicorn/no-array-reduce": "off",
+			"unicorn/prefer-export-from": "off",
+			"unicorn/prefer-top-level-await": "off",
+			"unicorn/filename-case": "off",
+			...overrides
+		}
+	}, {
+		files: [GLOB_SRC],
+		name: "eienjs/unicorn/special-rules",
+		rules: { "unicorn/filename-case": ["error", { case: "snakeCase" }] }
+	}];
+}
+
+//#endregion
+export { unicorn };

package/dist/configs/vue.d.ts

@@ -0,0 +1,6 @@
+import { OptionsFiles, OptionsHasTypeScript, OptionsOverrides, OptionsStylistic, OptionsVue, TypedFlatConfigItem } from "../types.js";
+
+//#region src/configs/vue.d.ts
+declare function vue(options?: OptionsVue & OptionsHasTypeScript & OptionsOverrides & OptionsStylistic & OptionsFiles): Promise<TypedFlatConfigItem[]>;
+//#endregion
+export { vue };

package/dist/configs/vue.js

@@ -0,0 +1,206 @@
+import { GLOB_SRC, GLOB_VUE } from "../globs.js";
+import { interopDefault } from "../utils.js";
+import { mergeProcessors } from "eslint-merge-processors";
+
+//#region src/configs/vue.ts
+async function vue(options = {}) {
+	const { files = [GLOB_VUE], overrides = {}, stylistic = true, typescript, componentNameInTemplateCasingOnlyRegistered = false, componentNameInTemplateCasingIgnores = [], componentNameInTemplateCasingGlobals = [] } = options;
+	const sfcBlocks = options.sfcBlocks === true ? {} : options.sfcBlocks ?? {};
+	const { indent = 2 } = typeof stylistic === "boolean" ? {} : stylistic;
+	const [pluginVue, parserVue, processorVueBlocks] = await Promise.all([
+		interopDefault(import("eslint-plugin-vue")),
+		interopDefault(import("vue-eslint-parser")),
+		interopDefault(import("eslint-processor-vue-blocks"))
+	]);
+	return [
+		{
+			languageOptions: { globals: {
+				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: "eienjs/vue/setup",
+			plugins: { vue: pluginVue }
+		},
+		{
+			files,
+			languageOptions: {
+				parser: parserVue,
+				parserOptions: {
+					ecmaFeatures: { jsx: true },
+					extraFileExtensions: [".vue"],
+					parser: typescript ? await interopDefault(import("@typescript-eslint/parser")) : null,
+					sourceType: "module"
+				}
+			},
+			name: "eienjs/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
+				}), {}),
+				...pluginVue.configs["flat/strongly-recommended"].map((c) => c.rules).reduce((acc, c) => ({
+					...acc,
+					...c
+				}), {}),
+				...pluginVue.configs["flat/recommended"].map((c) => c.rules).reduce((acc, c) => ({
+					...acc,
+					...c
+				}), {}),
+				"vue/block-lang": ["error", { script: { lang: "ts" } }],
+				"vue/block-order": ["error", { order: [
+					"script",
+					"template",
+					"style"
+				] }],
+				"vue/component-api-style": ["error", ["script-setup"]],
+				"vue/component-name-in-template-casing": [
+					"error",
+					"PascalCase",
+					{
+						registeredComponentsOnly: componentNameInTemplateCasingOnlyRegistered,
+						ignores: componentNameInTemplateCasingIgnores,
+						globals: componentNameInTemplateCasingGlobals
+					}
+				],
+				"vue/component-options-name-casing": ["error", "PascalCase"],
+				"vue/custom-event-name-casing": ["error", "camelCase"],
+				"vue/define-macros-order": ["error", { order: [
+					"defineOptions",
+					"defineProps",
+					"defineEmits",
+					"defineSlots"
+				] }],
+				"vue/define-props-declaration": ["error", "runtime"],
+				"vue/dot-location": ["error", "property"],
+				"vue/dot-notation": ["error", { allowKeywords: true }],
+				"vue/eqeqeq": ["error", "smart"],
+				"vue/html-indent": ["error", indent],
+				"vue/html-quotes": ["error", "double"],
+				"vue/max-attributes-per-line": "off",
+				"vue/multi-word-component-names": "off",
+				"vue/no-dupe-keys": "off",
+				"vue/no-empty-component-block": "error",
+				"vue/no-empty-pattern": "error",
+				"vue/no-irregular-whitespace": "error",
+				"vue/no-loss-of-precision": "error",
+				"vue/no-multiple-objects-in-class": "error",
+				"vue/no-ref-object-reactivity-loss": "error",
+				"vue/no-required-prop-with-default": "error",
+				"vue/no-restricted-syntax": [
+					"error",
+					"DebuggerStatement",
+					"LabeledStatement",
+					"WithStatement"
+				],
+				"vue/no-restricted-v-bind": ["error", "/^v-/"],
+				"vue/no-root-v-if": "error",
+				"vue/no-setup-props-reactivity-loss": "off",
+				"vue/no-sparse-arrays": "error",
+				"vue/no-template-target-blank": "error",
+				"vue/no-unused-properties": "error",
+				"vue/no-unused-refs": "error",
+				"vue/no-use-v-else-with-v-for": "error",
+				"vue/no-useless-mustaches": "error",
+				"vue/no-useless-v-bind": "error",
+				"vue/no-v-html": "off",
+				"vue/object-shorthand": [
+					"error",
+					"always",
+					{
+						avoidQuotes: true,
+						ignoreConstructors: false
+					}
+				],
+				"vue/prefer-separate-static-class": "error",
+				"vue/prefer-template": "error",
+				"vue/prefer-true-attribute-shorthand": "error",
+				"vue/prop-name-casing": ["error", "camelCase"],
+				"vue/require-typed-ref": "error",
+				"vue/space-infix-ops": "error",
+				"vue/space-unary-ops": ["error", {
+					nonwords: false,
+					words: true
+				}],
+				"vue/static-class-names-order": "off",
+				...stylistic ? {
+					"vue/array-bracket-spacing": ["error", "never"],
+					"vue/arrow-spacing": ["error", {
+						after: true,
+						before: true
+					}],
+					"vue/block-spacing": ["error", "always"],
+					"vue/block-tag-newline": ["error", {
+						multiline: "always",
+						singleline: "always"
+					}],
+					"vue/brace-style": [
+						"error",
+						"1tbs",
+						{ allowSingleLine: true }
+					],
+					"vue/comma-dangle": ["error", "always-multiline"],
+					"vue/comma-spacing": ["error", {
+						after: true,
+						before: false
+					}],
+					"vue/comma-style": ["error", "last"],
+					"vue/html-comment-content-spacing": [
+						"error",
+						"always",
+						{ exceptions: ["-"] }
+					],
+					"vue/key-spacing": ["error", {
+						afterColon: true,
+						beforeColon: false
+					}],
+					"vue/keyword-spacing": ["error", {
+						after: true,
+						before: true
+					}],
+					"vue/object-curly-newline": "off",
+					"vue/object-curly-spacing": ["error", "always"],
+					"vue/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+					"vue/operator-linebreak": ["error", "before"],
+					"vue/padding-line-between-blocks": ["error", "always"],
+					"vue/quote-props": ["error", "consistent-as-needed"],
+					"vue/space-in-parens": ["error", "never"],
+					"vue/template-curly-spacing": "error"
+				} : {},
+				"antfu/no-top-level-await": "off",
+				"n/prefer-global/process": "off",
+				"@typescript-eslint/explicit-function-return-type": "off",
+				"@typescript-eslint/naming-convention": "off",
+				"@stylistic/max-len": "off",
+				...overrides
+			}
+		},
+		{
+			files: [`**/composables/${GLOB_SRC}`],
+			name: "eienjs/vue/composables-disables",
+			rules: { "@typescript-eslint/explicit-module-boundary-types": "off" }
+		}
+	];
+}
+
+//#endregion
+export { vue };

package/dist/configs/yaml.d.ts

@@ -0,0 +1,6 @@
+import { OptionsFiles, OptionsOverrides, OptionsStylistic, TypedFlatConfigItem } from "../types.js";
+
+//#region src/configs/yaml.d.ts
+declare function yaml(options?: OptionsOverrides & OptionsStylistic & OptionsFiles): Promise<TypedFlatConfigItem[]>;
+//#endregion
+export { yaml };

package/dist/configs/yaml.js

@@ -0,0 +1,83 @@
+import { GLOB_YAML } from "../globs.js";
+import { interopDefault } from "../utils.js";
+
+//#region src/configs/yaml.ts
+async function yaml(options = {}) {
+	const { files = [GLOB_YAML], overrides = {}, stylistic = true } = options;
+	const { indent = 2, quotes = "single" } = typeof stylistic === "boolean" ? {} : stylistic;
+	const [pluginYaml, parserYaml] = await Promise.all([interopDefault(import("eslint-plugin-yml")), interopDefault(import("yaml-eslint-parser"))]);
+	return [
+		{
+			name: "eienjs/yaml/setup",
+			plugins: { yaml: pluginYaml }
+		},
+		{
+			files,
+			languageOptions: { parser: parserYaml },
+			name: "eienjs/yaml/rules",
+			rules: {
+				"@stylistic/spaced-comment": "off",
+				"yaml/block-mapping": "error",
+				"yaml/block-sequence": "error",
+				"yaml/no-empty-key": "error",
+				"yaml/no-empty-sequence-entry": "error",
+				"yaml/no-irregular-whitespace": "error",
+				"yaml/plain-scalar": "error",
+				"yaml/vue-custom-block/no-parsing-error": "error",
+				...stylistic ? {
+					"yaml/block-mapping-question-indicator-newline": "error",
+					"yaml/block-sequence-hyphen-indicator-newline": "error",
+					"yaml/flow-mapping-curly-newline": "error",
+					"yaml/flow-mapping-curly-spacing": "error",
+					"yaml/flow-sequence-bracket-newline": "error",
+					"yaml/flow-sequence-bracket-spacing": "error",
+					"yaml/indent": ["error", indent === "tab" ? 2 : indent],
+					"yaml/key-spacing": "error",
+					"yaml/no-tab-indent": "error",
+					"yaml/quotes": ["error", {
+						avoidEscape: true,
+						prefer: quotes === "backtick" ? "single" : quotes
+					}],
+					"yaml/spaced-comment": "error"
+				} : {},
+				...overrides
+			}
+		},
+		{
+			files: ["pnpm-workspace.yaml"],
+			name: "eienjs/yaml/pnpm-workspace",
+			rules: { "yaml/sort-keys": [
+				"error",
+				{
+					order: [
+						"packages",
+						"overrides",
+						"patchedDependencies",
+						"hoistPattern",
+						"catalog",
+						"catalogs",
+						"allowedDeprecatedVersions",
+						"allowNonAppliedPatches",
+						"configDependencies",
+						"ignoredBuiltDependencies",
+						"ignoredOptionalDependencies",
+						"neverBuiltDependencies",
+						"onlyBuiltDependencies",
+						"onlyBuiltDependenciesFile",
+						"packageExtensions",
+						"peerDependencyRules",
+						"supportedArchitectures"
+					],
+					pathPattern: "^$"
+				},
+				{
+					order: { type: "asc" },
+					pathPattern: ".*"
+				}
+			] }
+		}
+	];
+}
+
+//#endregion
+export { yaml };

package/dist/factory.d.ts

@@ -0,0 +1,17 @@
+import { ConfigNames, RuleOptions } from "./typegen.js";
+import { OptionsConfig, TypedFlatConfigItem } from "./types.js";
+import { FlatConfigComposer } from "eslint-flat-config-utils";
+import { Linter } from "eslint";
+
+//#region src/factory.d.ts
+declare const defaultPluginRenaming: {
+  'import-lite': string;
+  vitest: string;
+  yml: string;
+};
+declare function eienjs(options?: OptionsConfig & Omit<TypedFlatConfigItem, 'files'>): FlatConfigComposer<TypedFlatConfigItem, ConfigNames>;
+type ResolvedOptions<T> = T extends boolean ? never : NonNullable<T>;
+declare function resolveSubOptions<K extends keyof OptionsConfig>(options: OptionsConfig, key: K): ResolvedOptions<OptionsConfig[K]>;
+declare function getOverrides(options: OptionsConfig, key: keyof OptionsConfig): Partial<Linter.RulesRecord & RuleOptions>;
+//#endregion
+export { ResolvedOptions, defaultPluginRenaming, eienjs, getOverrides, resolveSubOptions };