@so1ve/eslint-config 4.1.8 → 4.2.1

package/dist/configs/sort-imports.d.mts

@@ -0,0 +1,6 @@
+import { TypedFlatConfigItem } from "../types.mjs";
+
+//#region src/configs/sort-imports.d.ts
+declare const sortImports: () => TypedFlatConfigItem[];
+//#endregion
+export { sortImports };

package/dist/configs/sort-imports.mjs

@@ -0,0 +1,11 @@
+//#region src/configs/sort-imports.ts
+const sortImports = () => [{
+	name: "so1ve/sort-imports/rules",
+	rules: {
+		"so1ve/sort-imports": "error",
+		"so1ve/sort-exports": "error"
+	}
+}];
+
+//#endregion
+export { sortImports };

package/dist/configs/test.d.mts

@@ -0,0 +1,8 @@
+import { OptionsOverrides, TypedFlatConfigItem } from "../types.mjs";
+
+//#region src/configs/test.d.ts
+declare function test({
+  overrides
+}?: OptionsOverrides): Promise<TypedFlatConfigItem[]>;
+//#endregion
+export { test };

package/dist/configs/test.mjs

@@ -0,0 +1,46 @@
+import { GLOB_TESTS } from "../globs.mjs";
+import { interopDefault } from "../utils.mjs";
+
+//#region src/configs/test.ts
+async function test({ overrides } = {}) {
+	const [pluginNoOnlyTests, pluginVitest, pluginJestFormatting] = await Promise.all([
+		interopDefault(import("eslint-plugin-no-only-tests")),
+		interopDefault(import("@vitest/eslint-plugin")),
+		interopDefault(import("eslint-plugin-jest-formatting"))
+	]);
+	return [{
+		name: "so1ve/test/setup",
+		plugins: {
+			"jest-formatting": pluginJestFormatting,
+			"no-only-tests": pluginNoOnlyTests,
+			"vitest": pluginVitest
+		}
+	}, {
+		name: "so1ve/test/rules",
+		files: GLOB_TESTS,
+		rules: {
+			...pluginVitest.configs.recommended.rules,
+			"no-only-tests/no-only-tests": "error",
+			"vitest/expect-expect": "off",
+			"vitest/no-alias-methods": "error",
+			"vitest/no-interpolation-in-snapshots": "error",
+			"vitest/no-test-prefixes": "error",
+			"vitest/prefer-comparison-matcher": "error",
+			"vitest/prefer-expect-resolves": "error",
+			"vitest/prefer-mock-promise-shorthand": "error",
+			"vitest/prefer-spy-on": "error",
+			"vitest/prefer-to-be-falsy": "error",
+			"vitest/prefer-to-be-object": "error",
+			"vitest/prefer-to-be-truthy": "error",
+			"vitest/prefer-to-contain": "error",
+			"vitest/prefer-to-have-length": "error",
+			"vitest/prefer-todo": "error",
+			"vitest/valid-describe-callback": "off",
+			"vitest/valid-title": "off",
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+export { test };

package/dist/configs/toml.d.mts

@@ -0,0 +1,8 @@
+import { OptionsOverrides, TypedFlatConfigItem } from "../types.mjs";
+
+//#region src/configs/toml.d.ts
+declare function toml({
+  overrides
+}?: OptionsOverrides): Promise<TypedFlatConfigItem[]>;
+//#endregion
+export { toml };

package/dist/configs/toml.mjs

@@ -0,0 +1,24 @@
+import { GLOB_TOML } from "../globs.mjs";
+import { interopDefault } from "../utils.mjs";
+
+//#region src/configs/toml.ts
+async function toml({ overrides } = {}) {
+	const [parserToml, pluginToml] = await Promise.all([interopDefault(import("toml-eslint-parser")), interopDefault(import("eslint-plugin-toml"))]);
+	return [{
+		name: "so1ve/toml/setup",
+		plugins: { toml: pluginToml }
+	}, {
+		name: "so1ve/toml/rules",
+		languageOptions: { parser: parserToml },
+		files: [GLOB_TOML],
+		rules: {
+			...pluginToml.configs.recommended.rules,
+			"no-irregular-whitespace": "off",
+			"style/spaced-comment": "off",
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+export { toml };

package/dist/configs/typescript.d.mts

@@ -0,0 +1,10 @@
+import { OptionsComponentExts, OptionsOverrides, OptionsTypeScriptParserOptions, TypedFlatConfigItem } from "../types.mjs";
+
+//#region src/configs/typescript.d.ts
+declare const typescript: ({
+  componentExts,
+  parserOptions,
+  overrides
+}?: OptionsTypeScriptParserOptions & OptionsComponentExts & OptionsOverrides) => Promise<TypedFlatConfigItem[]>;
+//#endregion
+export { typescript };

package/dist/configs/typescript.mjs

@@ -0,0 +1,232 @@
+import { GLOB_ASTRO_TS, GLOB_MARKDOWN_CODE, GLOB_TS, GLOB_TSX } from "../globs.mjs";
+import { renameRules } from "../utils.mjs";
+import { pluginImport } from "../plugins.mjs";
+import tseslint from "typescript-eslint";
+
+//#region src/configs/typescript.ts
+const typescript = async ({ componentExts = [], parserOptions, overrides } = {}) => [
+	{
+		name: "so1ve/typescript/setup",
+		plugins: {
+			import: pluginImport,
+			ts: tseslint.plugin
+		}
+	},
+	{
+		name: "so1ve/typescript/rules",
+		files: [
+			GLOB_TS,
+			GLOB_TSX,
+			...componentExts.map((ext) => `**/*.${ext}`)
+		],
+		languageOptions: {
+			parser: tseslint.parser,
+			parserOptions: {
+				sourceType: "module",
+				extraFileExtensions: componentExts.map((ext) => `.${ext}`),
+				...parserOptions
+			}
+		},
+		settings: { "import/resolver": {
+			node: { extensions: [
+				".js",
+				".jsx",
+				".mjs",
+				".ts",
+				".tsx",
+				".d.ts"
+			] },
+			typescript: { extensions: [
+				".js",
+				".jsx",
+				".mjs",
+				".ts",
+				".tsx",
+				".d.ts"
+			] }
+		} },
+		rules: {
+			...renameRules(tseslint.configs.eslintRecommended.rules, { "@typescript-eslint": "ts" }),
+			...renameRules(tseslint.configs.recommended.map((config) => config.rules).filter(Boolean).reduce((a, b) => ({
+				...a,
+				...b
+			}), {}), { "@typescript-eslint": "ts" }),
+			"import/named": "off",
+			"no-dupe-class-members": "off",
+			"no-invalid-this": "off",
+			"no-redeclare": "off",
+			"no-use-before-define": "off",
+			"no-useless-constructor": "off",
+			"object-curly-spacing": "off",
+			"so1ve/no-inline-type-modifier": "error",
+			"so1ve/prefer-ts-expect-error": "error",
+			"space-before-blocks": "off",
+			"space-before-function-paren": "off",
+			"ts/ban-ts-comment": ["error", { minimumDescriptionLength: 0 }],
+			"ts/ban-ts-ignore": "off",
+			"ts/brace-style": "off",
+			"ts/camelcase": "off",
+			"ts/comma-dangle": "off",
+			"ts/comma-spacing": "off",
+			"ts/consistent-indexed-object-style": ["error", "record"],
+			"ts/consistent-type-definitions": ["error", "interface"],
+			"ts/consistent-type-imports": ["error", {
+				disallowTypeAnnotations: false,
+				prefer: "type-imports"
+			}],
+			"ts/explicit-function-return-type": "off",
+			"ts/explicit-member-accessibility": ["error", {
+				accessibility: "explicit",
+				overrides: { constructors: "no-public" }
+			}],
+			"ts/explicit-module-boundary-types": "off",
+			"ts/func-call-spacing": "off",
+			"ts/indent": "off",
+			"ts/keyword-spacing": "off",
+			"ts/member-delimiter-style": "off",
+			"ts/method-signature-style": ["error", "property"],
+			"ts/no-dupe-class-members": "error",
+			"ts/no-duplicate-enum-values": "error",
+			"ts/no-empty-function": "off",
+			"ts/no-empty-interface": "off",
+			"ts/no-empty-object-type": "off",
+			"ts/no-explicit-any": "off",
+			"ts/no-extra-semi": "off",
+			"ts/no-invalid-this": "error",
+			"ts/no-non-null-asserted-nullish-coalescing": "error",
+			"ts/no-non-null-assertion": "off",
+			"ts/no-parameter-properties": "off",
+			"ts/no-redeclare": "error",
+			"ts/no-require-imports": "error",
+			"ts/no-restricted-types": ["error", { types: {
+				String: {
+					message: "Use `string` instead.",
+					fixWith: "string"
+				},
+				Number: {
+					message: "Use `number` instead.",
+					fixWith: "number"
+				},
+				Boolean: {
+					message: "Use `boolean` instead.",
+					fixWith: "boolean"
+				},
+				Symbol: {
+					message: "Use `symbol` instead.",
+					fixWith: "symbol"
+				},
+				BigInt: {
+					message: "Use `bigint` instead.",
+					fixWith: "bigint"
+				},
+				Function: {
+					message: "Use `(...args: any[]) => any` instead.",
+					fixWith: "(...args: any[]) => any"
+				}
+			} }],
+			"ts/no-unsafe-function-type": "error",
+			"ts/no-unused-vars": "off",
+			"ts/no-use-before-define": ["error", {
+				functions: false,
+				classes: false,
+				variables: true
+			}],
+			"ts/no-wrapper-object-types": "error",
+			"ts/prefer-for-of": "error",
+			"ts/quotes": "off",
+			"ts/semi": "off",
+			"ts/space-before-blocks": "off",
+			"ts/space-before-function-paren": "off",
+			"ts/triple-slash-reference": "off",
+			"ts/type-annotation-spacing": "off",
+			...overrides
+		}
+	},
+	{
+		name: "so1ve/typescript/rules/type-aware",
+		files: [
+			GLOB_TS,
+			GLOB_TSX,
+			...componentExts.map((ext) => `**/*.${ext}`)
+		],
+		ignores: [GLOB_MARKDOWN_CODE, GLOB_ASTRO_TS],
+		languageOptions: {
+			parser: tseslint.parser,
+			parserOptions: {
+				sourceType: "module",
+				projectService: true,
+				tsconfigRootDir: process.cwd()
+			}
+		},
+		settings: { "import/resolver": {
+			node: { extensions: [
+				".js",
+				".jsx",
+				".mjs",
+				".ts",
+				".tsx",
+				".d.ts"
+			] },
+			typescript: { extensions: [
+				".js",
+				".jsx",
+				".mjs",
+				".ts",
+				".tsx",
+				".d.ts"
+			] }
+		} },
+		rules: {
+			"dot-notation": "off",
+			"no-implied-eval": "off",
+			"no-throw-literal": "off",
+			"no-void": ["error", { allowAsStatement: true }],
+			"ts/array-type": ["error", {
+				default: "array",
+				readonly: "array"
+			}],
+			"ts/await-thenable": "error",
+			"ts/consistent-generic-constructors": "error",
+			"ts/consistent-type-assertions": ["error", {
+				assertionStyle: "as",
+				objectLiteralTypeAssertions: "allow"
+			}],
+			"ts/consistent-type-exports": "error",
+			"ts/dot-notation": ["error", { allowKeywords: true }],
+			"ts/no-for-in-array": "error",
+			"ts/no-implied-eval": "error",
+			"ts/no-unnecessary-type-arguments": "error",
+			"ts/no-unnecessary-type-assertion": "error",
+			"ts/non-nullable-type-assertion-style": "error",
+			"ts/only-throw-error": "error",
+			"ts/prefer-nullish-coalescing": "error",
+			"ts/prefer-optional-chain": "error",
+			"ts/prefer-return-this-type": "error",
+			"ts/restrict-template-expressions": ["error", {
+				allowAny: true,
+				allowNumber: true,
+				allowBoolean: true
+			}]
+		}
+	},
+	{
+		name: "so1ve/typescript/rules/dts",
+		files: ["**/*.d.ts"],
+		rules: {
+			"eslint-comments/no-unlimited-disable": "off",
+			"import/no-duplicates": "off",
+			"unused-imports/no-unused-vars": "off"
+		}
+	},
+	{
+		name: "so1ve/typescript/rules/js",
+		files: ["**/*.js", "**/*.cjs"],
+		rules: {
+			"ts/no-require-imports": "off",
+			"ts/no-var-requires": "off"
+		}
+	}
+];
+
+//#endregion
+export { typescript };

package/dist/configs/unicorn.d.mts

@@ -0,0 +1,6 @@
+import { TypedFlatConfigItem } from "../types.mjs";
+
+//#region src/configs/unicorn.d.ts
+declare const unicorn: () => TypedFlatConfigItem[];
+//#endregion
+export { unicorn };

package/dist/configs/unicorn.mjs

@@ -0,0 +1,61 @@
+import { pluginUnicorn } from "../plugins.mjs";
+
+//#region src/configs/unicorn.ts
+const unicorn = () => [{
+	name: "so1ve/unicorn/setup",
+	plugins: { unicorn: pluginUnicorn }
+}, {
+	name: "so1ve/unicorn/rules",
+	rules: {
+		"unicorn/consistent-assert": "error",
+		"unicorn/consistent-date-clone": "error",
+		"unicorn/consistent-empty-array-spread": "error",
+		"unicorn/consistent-existence-index-check": "error",
+		"unicorn/error-message": "error",
+		"unicorn/escape-case": "error",
+		"unicorn/explicit-length-check": "error",
+		"unicorn/new-for-builtins": "error",
+		"unicorn/no-array-for-each": "error",
+		"unicorn/no-await-in-promise-methods": "error",
+		"unicorn/no-for-loop": "error",
+		"unicorn/no-instanceof-builtins": "error",
+		"unicorn/no-lonely-if": "error",
+		"unicorn/no-negated-condition": "error",
+		"unicorn/no-new-array": "error",
+		"unicorn/no-new-buffer": "error",
+		"unicorn/no-useless-collection-argument": "error",
+		"unicorn/no-useless-spread": "error",
+		"unicorn/no-zero-fractions": "error",
+		"unicorn/numeric-separators-style": "error",
+		"unicorn/prefer-array-find": "error",
+		"unicorn/prefer-array-flat": "error",
+		"unicorn/prefer-array-index-of": "error",
+		"unicorn/prefer-array-some": "error",
+		"unicorn/prefer-class-fields": "error",
+		"unicorn/prefer-date-now": "error",
+		"unicorn/prefer-includes": "error",
+		"unicorn/prefer-json-parse-buffer": "error",
+		"unicorn/prefer-modern-dom-apis": "error",
+		"unicorn/prefer-modern-math-apis": "error",
+		"unicorn/prefer-negative-index": "error",
+		"unicorn/prefer-node-protocol": "error",
+		"unicorn/prefer-object-from-entries": "error",
+		"unicorn/prefer-optional-catch-binding": "error",
+		"unicorn/prefer-prototype-methods": "error",
+		"unicorn/prefer-query-selector": "error",
+		"unicorn/prefer-regexp-test": "error",
+		"unicorn/prefer-response-static-json": "error",
+		"unicorn/prefer-set-size": "error",
+		"unicorn/prefer-spread": "error",
+		"unicorn/prefer-string-slice": "error",
+		"unicorn/prefer-string-starts-ends-with": "error",
+		"unicorn/prefer-type-error": "error",
+		"unicorn/relative-url-style": ["error", "always"],
+		"unicorn/require-module-specifiers": "error",
+		"unicorn/switch-case-braces": "error",
+		"unicorn/throw-new-error": "error"
+	}
+}];
+
+//#endregion
+export { unicorn };

package/dist/configs/vue.d.mts

@@ -0,0 +1,9 @@
+import { OptionsHasTypeScript, OptionsOverrides, TypedFlatConfigItem } from "../types.mjs";
+
+//#region src/configs/vue.d.ts
+declare function vue({
+  overrides,
+  typescript
+}?: OptionsHasTypeScript & OptionsOverrides): Promise<TypedFlatConfigItem[]>;
+//#endregion
+export { vue };

package/dist/configs/vue.mjs

@@ -0,0 +1,194 @@
+import { GLOB_VUE } from "../globs.mjs";
+import { interopDefault } from "../utils.mjs";
+import tseslint from "typescript-eslint";
+
+//#region src/configs/vue.ts
+async function vue({ overrides, typescript } = {}) {
+	const [parserVue, pluginVue] = await Promise.all([interopDefault(import("vue-eslint-parser")), interopDefault(import("eslint-plugin-vue"))]);
+	return [{
+		name: "so1ve/vue/setup",
+		plugins: { vue: pluginVue }
+	}, {
+		name: "so1ve/vue/rules",
+		files: [GLOB_VUE],
+		languageOptions: {
+			parser: parserVue,
+			parserOptions: {
+				ecmaFeatures: { jsx: true },
+				extraFileExtensions: [".vue"],
+				parser: typescript ? tseslint.parser : null,
+				sourceType: "module"
+			}
+		},
+		processor: pluginVue.processors[".vue"],
+		rules: {
+			...pluginVue.configs.base.rules,
+			...pluginVue.configs.essential.rules,
+			...pluginVue.configs["strongly-recommended"].rules,
+			...pluginVue.configs.recommended.rules,
+			"no-undef": "off",
+			"no-unused-vars": "off",
+			"so1ve/vue-root-element-sort-attributes": "error",
+			"ts/no-unused-vars": "off",
+			"vue/array-bracket-spacing": "off",
+			"vue/arrow-spacing": "off",
+			"vue/attributes-order": ["error", {
+				order: [
+					"DEFINITION",
+					"LIST_RENDERING",
+					"CONDITIONALS",
+					"RENDER_MODIFIERS",
+					"TWO_WAY_BINDING",
+					"OTHER_DIRECTIVES",
+					["UNIQUE", "SLOT"],
+					"GLOBAL",
+					"OTHER_ATTR",
+					"EVENTS",
+					"CONTENT"
+				],
+				alphabetical: true
+			}],
+			"vue/block-lang": ["error", {
+				script: { lang: ["js", "ts"] },
+				template: { lang: [
+					"html",
+					"jade",
+					"pug",
+					"ejs"
+				] },
+				style: { lang: [
+					"css",
+					"sass",
+					"scss",
+					"less",
+					"stylus",
+					"postcss"
+				] }
+			}],
+			"vue/block-order": ["error", { order: [
+				"script:not([setup])",
+				"script[setup]",
+				"template",
+				"style"
+			] }],
+			"vue/block-spacing": "off",
+			"vue/brace-style": "off",
+			"vue/comma-dangle": "off",
+			"vue/comma-spacing": "off",
+			"vue/comma-style": "off",
+			"vue/component-api-style": ["error", ["script-setup", "composition"]],
+			"vue/component-name-in-template-casing": [
+				"error",
+				"PascalCase",
+				{ registeredComponentsOnly: false }
+			],
+			"vue/component-options-name-casing": ["error", "PascalCase"],
+			"vue/custom-event-name-casing": ["error", "camelCase"],
+			"vue/define-macros-order": ["error", { order: [
+				"defineOptions",
+				"defineEmits",
+				"defineProps",
+				"defineSlots"
+			] }],
+			"vue/dot-location": ["error", "property"],
+			"vue/dot-notation": ["error", { allowKeywords: true }],
+			"vue/eqeqeq": ["error", "smart"],
+			"vue/html-closing-bracket-spacing": "off",
+			"vue/html-comment-content-newline": ["error", {
+				singleline: "ignore",
+				multiline: "always"
+			}],
+			"vue/html-comment-content-spacing": [
+				"error",
+				"always",
+				{ exceptions: ["-"] }
+			],
+			"vue/html-comment-indent": ["error", "tab"],
+			"vue/html-indent": "off",
+			"vue/html-quotes": "off",
+			"vue/html-self-closing": ["error", {
+				html: {
+					void: "always",
+					normal: "always",
+					component: "always"
+				},
+				svg: "always",
+				math: "always"
+			}],
+			"vue/key-spacing": "off",
+			"vue/keyword-spacing": "off",
+			"vue/max-attributes-per-line": "off",
+			"vue/multi-word-component-names": "off",
+			"vue/multiline-html-element-content-newline": "off",
+			"vue/mustache-interpolation-spacing": "off",
+			"vue/no-console": ["error", { allow: [
+				"error",
+				"warn",
+				"table",
+				"time"
+			] }],
+			"vue/no-constant-condition": "error",
+			"vue/no-empty-pattern": "error",
+			"vue/no-irregular-whitespace": "error",
+			"vue/no-loss-of-precision": "error",
+			"vue/no-multi-spaces": "off",
+			"vue/no-multiple-template-root": "off",
+			"vue/no-restricted-syntax": [
+				"error",
+				"DebuggerStatement",
+				"LabeledStatement",
+				"WithStatement"
+			],
+			"vue/no-restricted-v-bind": ["error", "/^v-/"],
+			"vue/no-sparse-arrays": "error",
+			"vue/no-static-inline-styles": ["error", { allowBinding: true }],
+			"vue/no-unused-refs": "error",
+			"vue/no-useless-concat": "error",
+			"vue/no-useless-v-bind": ["error", { ignoreIncludesComment: true }],
+			"vue/no-v-html": "off",
+			"vue/no-v-text-v-html-on-component": "error",
+			"vue/object-curly-newline": ["error", {
+				multiline: true,
+				consistent: true
+			}],
+			"vue/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
+			"vue/object-shorthand": [
+				"error",
+				"always",
+				{
+					ignoreConstructors: false,
+					avoidQuotes: true
+				}
+			],
+			"vue/operator-linebreak": "off",
+			"vue/padding-line-between-blocks": ["error", "always"],
+			"vue/prefer-define-options": "error",
+			"vue/prefer-separate-static-class": "error",
+			"vue/prefer-template": "error",
+			"vue/prefer-true-attribute-shorthand": "error",
+			"vue/quote-props": ["error", "consistent-as-needed"],
+			"vue/require-default-prop": "off",
+			"vue/require-macro-variable-name": ["error", {
+				defineProps: "props",
+				defineEmits: "emit",
+				defineSlots: "slots",
+				useSlots: "slots",
+				useAttrs: "attrs"
+			}],
+			"vue/require-prop-types": "off",
+			"vue/require-typed-ref": "error",
+			"vue/singleline-html-element-content-newline": "off",
+			"vue/template-curly-spacing": "off",
+			"vue/v-bind-style": [
+				"error",
+				"shorthand",
+				{ sameNameShorthand: "always" }
+			],
+			"vue/v-for-delimiter-style": ["error", "in"],
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+export { vue };

package/dist/configs/yaml.d.mts

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

package/dist/configs/yaml.mjs

@@ -0,0 +1,25 @@
+import { GLOB_YAML } from "../globs.mjs";
+import { interopDefault, renameRules } from "../utils.mjs";
+
+//#region src/configs/yaml.ts
+async function yaml({ overrides } = {}) {
+	const [parserYaml, pluginYaml] = await Promise.all([interopDefault(import("yaml-eslint-parser")), interopDefault(import("eslint-plugin-yml"))]);
+	return [{
+		name: "so1ve/yaml/setup",
+		plugins: { yaml: pluginYaml }
+	}, {
+		name: "so1ve/yaml/rules",
+		languageOptions: { parser: parserYaml },
+		files: [GLOB_YAML],
+		rules: {
+			...renameRules(pluginYaml.configs.prettier.rules, { yml: "yaml" }),
+			...renameRules(pluginYaml.configs.recommended.rules, { yml: "yaml" }),
+			"style/spaced-comment": "off",
+			"yaml/no-empty-document": "off",
+			...overrides
+		}
+	}];
+}
+
+//#endregion
+export { yaml };