@curev/eslint-config 0.2.1 → 0.3.0

package/src/configs/test.ts

@@ -0,0 +1,54 @@
+import { interopDefault } from "../utils";
+import type { FlatConfigItem, OptionsFiles, OptionsIsInEditor, OptionsOverrides } from "../types";
+import { GLOB_TESTS } from "../globs";
+
+export async function test(
+  options: OptionsFiles & OptionsIsInEditor & OptionsOverrides = {}
+): Promise<FlatConfigItem[]> {
+  const {
+    files = GLOB_TESTS,
+    isInEditor = false,
+    overrides = {}
+  } = options;
+
+  const [
+    pluginVitest,
+    pluginNoOnlyTests
+  ] = await Promise.all([
+    interopDefault(import("eslint-plugin-vitest")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-no-only-tests"))
+  ] as const);
+
+  return [
+    {
+      name: "curev:test:setup",
+      plugins: {
+        test: {
+          ...pluginVitest,
+          rules: {
+            ...pluginVitest.rules,
+            // extend `test/no-only-tests` rule
+            ...pluginNoOnlyTests.rules
+          }
+        }
+      }
+    },
+    {
+      files,
+      name: "curev:test:rules",
+      rules: {
+        "node/prefer-global/process": "off",
+
+        "test/consistent-test-it": ["error", { fn: "it", withinDescribe: "it" }],
+        "test/no-identical-title": "error",
+        "test/no-import-node-test": "error",
+        "test/no-only-tests": isInEditor ? "off" : "error",
+        "test/prefer-hooks-in-order": "error",
+        "test/prefer-lowercase-title": "error",
+
+        ...overrides
+      }
+    }
+  ];
+}

package/src/configs/toml.ts

@@ -0,0 +1,72 @@
+import type { FlatConfigItem, OptionsFiles, OptionsOverrides, OptionsStylistic } from "../types";
+import { GLOB_TOML } from "../globs";
+import { interopDefault } from "../utils";
+
+export async function toml(
+  options: OptionsOverrides & OptionsStylistic & OptionsFiles = {}
+): Promise<FlatConfigItem[]> {
+  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"))
+  ] as const);
+
+  return [
+    {
+      name: "curev:toml:setup",
+      plugins: {
+        toml: pluginToml
+      }
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserToml
+      },
+      name: "curev:toml:rules",
+      rules: {
+        "style/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
+      }
+    }
+  ];
+}

package/src/configs/typescript.ts

@@ -0,0 +1,171 @@
+import process from "node:process";
+import { GLOB_SRC, GLOB_TS, GLOB_TSX } from "../globs";
+import type { FlatConfigItem, OptionsComponentExts, OptionsFiles, OptionsOverrides, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes } from "../types";
+import { pluginAntfu } from "../plugins";
+import { interopDefault, renameRules, toArray } from "../utils";
+
+export async function typescript(
+  options: OptionsFiles & OptionsComponentExts & OptionsOverrides & OptionsTypeScriptWithTypes & OptionsTypeScriptParserOptions = {}
+): Promise<FlatConfigItem[]> {
+  const {
+    componentExts = [],
+    overrides = {},
+    parserOptions = {}
+  } = options;
+
+  const files = options.files ?? [
+    GLOB_SRC,
+    ...componentExts.map(ext => `**/*.${ext}`)
+  ];
+
+  const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
+  const tsconfigPath = options?.tsconfigPath
+    ? toArray(options.tsconfigPath)
+    : undefined;
+  const isTypeAware = !!tsconfigPath;
+
+  const typeAwareRules: FlatConfigItem["rules"] = {
+    "dot-notation": "off",
+    "no-implied-eval": "off",
+    "no-throw-literal": "off",
+    "ts/await-thenable": "error",
+    "ts/dot-notation": ["error", { allowKeywords: true }],
+    "ts/no-floating-promises": "error",
+    "ts/no-for-in-array": "error",
+    "ts/no-implied-eval": "error",
+    "ts/no-misused-promises": "error",
+    "ts/no-throw-literal": "error",
+    "ts/no-unnecessary-type-assertion": "error",
+    "ts/no-unsafe-argument": "error",
+    "ts/no-unsafe-assignment": "error",
+    "ts/no-unsafe-call": "error",
+    "ts/no-unsafe-member-access": "error",
+    "ts/no-unsafe-return": "error",
+    "ts/restrict-plus-operands": "error",
+    "ts/restrict-template-expressions": "error",
+    "ts/unbound-method": "error"
+  };
+
+  const [
+    pluginTs,
+    parserTs
+  ] = await Promise.all([
+    interopDefault(import("@typescript-eslint/eslint-plugin")),
+    interopDefault(import("@typescript-eslint/parser"))
+  ] as const);
+
+  function makeParser(typeAware: boolean, files: string[], ignores?: string[]): FlatConfigItem {
+    return {
+      files,
+      ...ignores ? { ignores } : {},
+      languageOptions: {
+        parser: parserTs,
+        parserOptions: {
+          extraFileExtensions: componentExts.map(ext => `.${ext}`),
+          sourceType: "module",
+          ...typeAware
+            ? {
+                project: tsconfigPath,
+                tsconfigRootDir: process.cwd()
+              }
+            : {},
+          ...parserOptions as any
+        }
+      },
+      name: `curev:typescript:${typeAware ? "type-aware-parser" : "parser"}`
+    };
+  }
+
+  return [
+    {
+      // Install the plugins without globs, so they can be configured separately.
+      name: "curev:typescript:setup",
+      plugins: {
+        curev: pluginAntfu,
+        ts: pluginTs as any
+      }
+    },
+    // assign type-aware parser for type-aware files and type-unaware parser for the rest
+    ...isTypeAware
+      ? [
+          makeParser(true, filesTypeAware),
+          makeParser(false, files, filesTypeAware)
+        ]
+      : [makeParser(false, files)],
+    {
+      files,
+      name: "curev:typescript:rules",
+      rules: {
+        ...renameRules(
+          pluginTs.configs["eslint-recommended"].overrides![0].rules!,
+          "@typescript-eslint/",
+          "ts/"
+        ),
+        ...renameRules(
+          pluginTs.configs.strict.rules!,
+          "@typescript-eslint/",
+          "ts/"
+        ),
+        "no-dupe-class-members": "off",
+        "no-loss-of-precision": "off",
+        "no-redeclare": "off",
+        "no-use-before-define": "off",
+        "no-useless-constructor": "off",
+        "ts/ban-ts-comment": ["error", { "ts-ignore": "allow-with-description" }],
+        "ts/ban-types": ["error", { types: { Function: false } }],
+        "ts/consistent-type-definitions": ["error", "interface"],
+        "ts/consistent-type-imports": ["error", { disallowTypeAnnotations: false, prefer: "type-imports" }],
+        "ts/no-dupe-class-members": "error",
+        "ts/no-dynamic-delete": "off",
+        "ts/no-explicit-any": "off",
+        "ts/no-extraneous-class": "off",
+        "ts/no-import-type-side-effects": "error",
+        "ts/no-invalid-void-type": "off",
+        "ts/no-loss-of-precision": "error",
+        "ts/no-non-null-assertion": "off",
+        "ts/no-redeclare": "error",
+        "ts/no-require-imports": "error",
+        "ts/no-unused-vars": "off",
+        "ts/no-use-before-define": ["error", { classes: false, functions: false, variables: true }],
+        "ts/no-useless-constructor": "off",
+        "ts/prefer-ts-expect-error": "error",
+        "ts/triple-slash-reference": "off",
+        "ts/unified-signatures": "off",
+        ...overrides
+      }
+    },
+    {
+      files: filesTypeAware,
+      name: "curev:typescript:rules-type-aware",
+      rules: {
+        ...tsconfigPath ? typeAwareRules : {},
+        ...overrides
+      }
+    },
+    {
+      files: ["**/*.d.ts"],
+      name: "curev:typescript:dts-overrides",
+      rules: {
+        "eslint-comments/no-unlimited-disable": "off",
+        "import/no-duplicates": "off",
+        "no-restricted-syntax": "off",
+        "unused-imports/no-unused-vars": "off"
+      }
+    },
+    {
+      files: ["**/*.{test,spec}.ts?(x)"],
+      name: "curev:typescript:tests-overrides",
+      rules: {
+        "no-unused-expressions": "off"
+      }
+    },
+    {
+      files: ["**/*.js", "**/*.cjs"],
+      name: "curev:typescript:javascript-overrides",
+      rules: {
+        "ts/no-require-imports": "off",
+        "ts/no-var-requires": "off"
+      }
+    }
+  ];
+}

package/src/configs/unicorn.ts

@@ -0,0 +1,41 @@
+import type { FlatConfigItem } from "../types";
+import { pluginUnicorn } from "../plugins";
+
+export async function unicorn(): Promise<FlatConfigItem[]> {
+  return [
+    {
+      name: "curev:unicorn",
+      plugins: {
+        unicorn: pluginUnicorn
+      },
+      rules: {
+        // Pass error message when throwing errors
+        "unicorn/error-message": "error",
+        // Uppercase regex escapes
+        "unicorn/escape-case": "error",
+        // Array.isArray instead of instanceof
+        "unicorn/no-instanceof-array": "error",
+        // Ban `new Array` as `Array` constructor's params are ambiguous
+        "unicorn/no-new-array": "error",
+        // Prevent deprecated `new Buffer()`
+        "unicorn/no-new-buffer": "error",
+        // Lowercase number formatting for octal, hex, binary (0x1'error' instead of 0X1'error')
+        "unicorn/number-literal-case": "error",
+        // textContent instead of innerText
+        "unicorn/prefer-dom-node-text-content": "error",
+        // includes over indexOf when checking for existence
+        "unicorn/prefer-includes": "error",
+        // Prefer using the node: protocol
+        "unicorn/prefer-node-protocol": "error",
+        // Prefer using number properties like `Number.isNaN` rather than `isNaN`
+        "unicorn/prefer-number-properties": "error",
+        // String methods startsWith/endsWith instead of more complicated stuff
+        "unicorn/prefer-string-starts-ends-with": "error",
+        // Enforce throwing type error when throwing error while checking typeof
+        "unicorn/prefer-type-error": "error",
+        // Use new when throwing error
+        "unicorn/throw-new-error": "error"
+      }
+    }
+  ];
+}

package/src/configs/unocss.ts

@@ -0,0 +1,43 @@
+import { ensurePackages, interopDefault } from "../utils";
+import type { FlatConfigItem, OptionsUnoCSS } from "../types";
+
+export async function unocss(
+  options: OptionsUnoCSS = {}
+): Promise<FlatConfigItem[]> {
+  const {
+    attributify = true,
+    strict = false
+  } = options;
+
+  await ensurePackages([
+    "@unocss/eslint-plugin"
+  ]);
+
+  const [
+    pluginUnoCSS
+  ] = await Promise.all([
+    interopDefault(import("@unocss/eslint-plugin"))
+  ] as const);
+
+  return [
+    {
+      name: "curev:unocss",
+      plugins: {
+        unocss: pluginUnoCSS
+      },
+      rules: {
+        "unocss/order": "warn",
+        ...attributify
+          ? {
+              "unocss/order-attributify": "warn"
+            }
+          : {},
+        ...strict
+          ? {
+              "unocss/blocklist": "error"
+            }
+          : {}
+      }
+    }
+  ];
+}

package/src/configs/vue.ts

@@ -0,0 +1,170 @@
+import { mergeProcessors } from "eslint-merge-processors";
+import { interopDefault } from "../utils";
+import type { FlatConfigItem, OptionsFiles, OptionsHasTypeScript, OptionsOverrides, OptionsStylistic, OptionsVue } from "../types";
+import { GLOB_VUE } from "../globs";
+
+export async function vue(
+  options: OptionsVue & OptionsHasTypeScript & OptionsOverrides & OptionsStylistic & OptionsFiles = {}
+): Promise<FlatConfigItem[]> {
+  const {
+    files = [GLOB_VUE],
+    overrides = {},
+    stylistic = true,
+    vueVersion = 3
+  } = options;
+
+  const sfcBlocks = options.sfcBlocks === true
+    ? {}
+    : options.sfcBlocks ?? {};
+
+  const {
+    indent = 2
+  } = typeof stylistic === "boolean" ? {} : stylistic;
+
+  const [
+    pluginVue,
+    parserVue,
+    processorVueBlocks
+  ] = await Promise.all([
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-vue")),
+    interopDefault(import("vue-eslint-parser")),
+    interopDefault(import("eslint-processor-vue-blocks"))
+  ] as const);
+
+  return [
+    {
+      name: "curev:vue:setup",
+      plugins: {
+        vue: pluginVue
+      }
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserVue,
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          extraFileExtensions: [".vue"],
+          parser: options.typescript
+            ? await interopDefault(import("@typescript-eslint/parser")) as any
+            : null,
+          sourceType: "module"
+        }
+      },
+      name: "curev:vue:rules",
+      processor: sfcBlocks === false
+        ? pluginVue.processors[".vue"]
+        : mergeProcessors([
+          pluginVue.processors[".vue"],
+          processorVueBlocks({
+            ...sfcBlocks,
+            blocks: {
+              styles: true,
+              ...sfcBlocks.blocks
+            }
+          })
+        ]),
+      rules: {
+        ...pluginVue.configs.base.rules as any,
+
+        ...vueVersion === 2
+          ? {
+              ...pluginVue.configs.essential.rules as any,
+              ...pluginVue.configs["strongly-recommended"].rules as any,
+              ...pluginVue.configs.recommended.rules as any
+            }
+          : {
+              ...pluginVue.configs["vue3-essential"].rules as any,
+              ...pluginVue.configs["vue3-strongly-recommended"].rules as any,
+              ...pluginVue.configs["vue3-recommended"].rules as any
+            },
+
+        "node/prefer-global/process": "off",
+        "vue/block-order": ["error", {
+          order: ["script", "template", "style"]
+        }],
+
+        "vue/component-name-in-template-casing": ["error", "PascalCase"],
+        "vue/component-options-name-casing": ["error", "PascalCase"],
+        // this is deprecated
+        "vue/component-tags-order": "off",
+        "vue/custom-event-name-casing": ["error", "camelCase"],
+        "vue/define-macros-order": ["error", {
+          order: ["defineOptions", "defineProps", "defineEmits", "defineSlots"]
+        }],
+        "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-pattern": "error",
+        "vue/no-irregular-whitespace": "error",
+        "vue/no-loss-of-precision": "error",
+        "vue/no-restricted-syntax": [
+          "error",
+          "DebuggerStatement",
+          "LabeledStatement",
+          "WithStatement"
+        ],
+        "vue/no-restricted-v-bind": ["error", "/^v-/"],
+        "vue/no-setup-props-reactivity-loss": "off",
+        "vue/no-sparse-arrays": "error",
+        "vue/no-unused-refs": "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/prop-name-casing": ["error", "camelCase"],
+        "vue/require-default-prop": "off",
+        "vue/require-prop-types": "off",
+        "vue/space-infix-ops": "error",
+        "vue/space-unary-ops": ["error", { nonwords: false, words: true }],
+
+        ...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", "stroustrup", { 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", { allowMultiplePropertiesPerLine: 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"
+            }
+          : {},
+
+        ...overrides
+      }
+    }
+  ];
+}

package/src/configs/yaml.ts

@@ -0,0 +1,72 @@
+import type { FlatConfigItem, OptionsFiles, OptionsOverrides, OptionsStylistic } from "../types";
+import { GLOB_YAML } from "../globs";
+import { interopDefault } from "../utils";
+
+export async function yaml(
+  options: OptionsOverrides & OptionsStylistic & OptionsFiles = {}
+): Promise<FlatConfigItem[]> {
+  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"))
+  ] as const);
+
+  return [
+    {
+      name: "curev:yaml:setup",
+      plugins: {
+        yaml: pluginYaml
+      }
+    },
+    {
+      files,
+      languageOptions: {
+        parser: parserYaml
+      },
+      name: "curev:yaml:rules",
+      rules: {
+        "style/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: false, prefer: quotes }],
+              "yaml/spaced-comment": "error"
+            }
+          : {},
+
+        ...overrides
+      }
+    }
+  ];
+}