@ocavue/eslint-config 2.16.0 → 2.17.0

package/dist/antfu.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function antfu(): Linter.Config[];

package/dist/antfu.js

@@ -0,0 +1,15 @@
+import antfuPlugin from 'eslint-plugin-antfu';
+export function antfu() {
+    return [
+        {
+            name: 'antfu',
+            plugins: {
+                antfu: antfuPlugin,
+            },
+            rules: {
+                'antfu/import-dedupe': 'error',
+                'antfu/top-level-function': 'error',
+            },
+        },
+    ];
+}

package/dist/basic.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function basic(): Linter.Config[];

package/dist/basic.js

@@ -0,0 +1,20 @@
+import { antfu } from './antfu.js';
+import { ignores } from './ignores.js';
+import { imports } from './imports.js';
+import { noOnlyTests } from './no-only-tests.js';
+import { packageJson } from './package-json.js';
+import { prettier } from './prettier.js';
+import { typescript } from './typescript.js';
+import { unicorn } from './unicorn.js';
+export function basic() {
+    return [
+        ...ignores(),
+        ...typescript(),
+        ...imports(),
+        ...packageJson(),
+        ...unicorn(),
+        ...antfu(),
+        ...noOnlyTests(),
+        ...prettier(),
+    ];
+}

package/dist/ignores.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function ignores(): Linter.Config[];

package/dist/ignores.js

@@ -0,0 +1,5 @@
+import gitignore from 'eslint-config-flat-gitignore';
+import { GLOB_EXCLUDE } from './shared.js';
+export function ignores() {
+    return [{ ignores: [...GLOB_EXCLUDE] }, gitignore()];
+}

package/dist/imports.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function imports(): Linter.Config[];

package/dist/imports.js

@@ -0,0 +1,49 @@
+import * as importPlugin from 'eslint-plugin-import-x';
+export function imports() {
+    return [
+        {
+            name: 'import',
+            plugins: {
+                // @ts-expect-error incorrect type
+                import: importPlugin,
+            },
+            settings: {
+                'import-x/resolver': {
+                    // You will also need to install and configure the TypeScript resolver
+                    // See also https://github.com/import-js/eslint-import-resolver-typescript#configuration
+                    typescript: true,
+                    node: true,
+                },
+            },
+            rules: {
+                // External modules must be declared in the package.json. Only enforced in CI.
+                'import/no-extraneous-dependencies': process.env.CI ? 'error' : 'off',
+                'import/first': 'warn',
+                'import/no-mutable-exports': 'warn',
+                'import/no-useless-path-segments': 'warn',
+                'import/newline-after-import': 'warn',
+                // Disable `no-duplicates` because of the following bug
+                // https://github.com/un-ts/eslint-plugin-import-x/issues/167
+                // 'import/no-duplicates': [
+                //   'warn',
+                //   { 'prefer-inline': true },
+                // ],
+                'import/order': [
+                    'warn',
+                    {
+                        'newlines-between': 'always',
+                        alphabetize: { order: 'asc' },
+                        groups: [
+                            'builtin',
+                            'external',
+                            'internal',
+                            'parent',
+                            'sibling',
+                            'index',
+                        ],
+                    },
+                ],
+            },
+        },
+    ];
+}

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-export * from "./src/typescript.js";
-export * from "./src/prettier.js";
-export * from "./src/basic.js";
-export * from "./src/markdown.js";
-export * from "./src/react.js";
-export * from "./src/vue.js";
-//# sourceMappingURL=index.d.ts.map
+export * from './typescript.js';
+export * from './prettier.js';
+export * from './basic.js';
+export * from './markdown.js';
+export * from './react.js';
+export * from './vue.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './typescript.js';
+export * from './prettier.js';
+export * from './basic.js';
+export * from './markdown.js';
+export * from './react.js';
+export * from './vue.js';

package/dist/markdown.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function markdown(): Linter.Config[];

package/dist/markdown.js

@@ -0,0 +1,41 @@
+import markdownPlugin from '@eslint/markdown';
+import { GLOB_MARKDOWN, GLOB_SRC, GLOB_VUE } from './shared.js';
+export function markdown() {
+    const recommended = markdownPlugin.configs.processor;
+    const extra = {
+        files: [`${GLOB_MARKDOWN}/${GLOB_SRC}`, `${GLOB_MARKDOWN}/${GLOB_VUE}`],
+        languageOptions: {
+            parserOptions: {
+                projectService: null,
+            },
+        },
+        rules: {
+            // Disable type-aware TypeScript rules, because the code blocks are not
+            // part of a compilable `tsconfig.json` project.
+            '@typescript-eslint/no-redeclare': 'off',
+            '@typescript-eslint/no-unused-vars': 'off',
+            '@typescript-eslint/no-use-before-define': 'off',
+            '@typescript-eslint/no-var-requires': 'off',
+            '@typescript-eslint/restrict-plus-operands': 'off',
+            '@typescript-eslint/no-unsafe-call': 'off',
+            '@typescript-eslint/no-unsafe-return': 'off',
+            '@typescript-eslint/no-unsafe-argument': 'off',
+            '@typescript-eslint/no-unsafe-member-access': 'off',
+            '@typescript-eslint/no-unsafe-assignment': 'off',
+            '@typescript-eslint/no-floating-promises': 'off',
+            '@typescript-eslint/no-misused-promises': 'off',
+            '@typescript-eslint/await-thenable': 'off',
+            '@typescript-eslint/unbound-method': 'off',
+            '@typescript-eslint/require-await': 'off',
+            '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+            // Disable some import rules because they are not working well with
+            // twoslash ---cut--- imports.
+            'import/first': 'off',
+            'import/order': 'off',
+            'no-alert': 'off',
+            'no-console': 'off',
+            'no-restricted-imports': 'off',
+        },
+    };
+    return [...recommended, extra];
+}

package/dist/no-only-tests.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function noOnlyTests(): Linter.Config[];

package/dist/no-only-tests.js

@@ -0,0 +1,14 @@
+import plugin from 'eslint-plugin-no-only-tests';
+export function noOnlyTests() {
+    return [
+        {
+            name: 'no-only-tests',
+            plugins: {
+                'no-only-tests': plugin,
+            },
+            rules: {
+                'no-only-tests/no-only-tests': 'error',
+            },
+        },
+    ];
+}

package/dist/package-json.d.ts

@@ -0,0 +1,5 @@
+import type { Linter } from 'eslint';
+/**
+ * Sort package.json keys
+ */
+export declare function packageJson(): Linter.Config[];

package/dist/package-json.js

@@ -0,0 +1,70 @@
+import pkgJson from 'eslint-plugin-package-json';
+/**
+ * Sort package.json keys
+ */
+export function packageJson() {
+    const config = {
+        ...pkgJson.configs.recommended,
+        rules: {
+            ...pkgJson.configs.recommended.rules,
+            'package-json/no-empty-fields': 'off',
+            'package-json/valid-package-definition': 'off',
+            'package-json/require-description': 'warn',
+            'package-json/sort-collections': [
+                'warn',
+                [
+                    // 'scripts', // Don't sort scripts
+                    'devDependencies',
+                    'dependencies',
+                    'peerDependencies',
+                    'config',
+                    'exports',
+                ],
+            ],
+            'package-json/order-properties': [
+                'warn',
+                {
+                    order: [
+                        'name',
+                        'displayName',
+                        'publisher',
+                        'type',
+                        'version',
+                        'private',
+                        'packageManager',
+                        'description',
+                        'author',
+                        'license',
+                        'funding',
+                        'homepage',
+                        'repository',
+                        'bugs',
+                        'contributes',
+                        'keywords',
+                        'categories',
+                        'sideEffects',
+                        'main',
+                        'module',
+                        'types',
+                        'exports',
+                        'typesVersions',
+                        'bin',
+                        'icon',
+                        'files',
+                        'engines',
+                        'scripts',
+                        'dependencies',
+                        'peerDependencies',
+                        'peerDependenciesMeta',
+                        'optionalDependencies',
+                        'devDependencies',
+                        'publishConfig',
+                        'overrides',
+                        'resolutions',
+                    ],
+                },
+            ],
+        },
+    };
+    return [config];
+}

package/dist/{src/prettier.d.ts → prettier.d.ts}

@@ -1,8 +1,8 @@
+import type { Linter } from 'eslint';
 /**
  * Turns off all rules that are unnecessary or might conflict with Prettier.
  *
  * Notice that this config does not run `prettier` as an ESLint rule, so you
  * have to run `pretter` separately for formatting.
  */
-export function prettier(): import("eslint").Linter.Config<import("eslint").Linter.RulesRecord>[];
-//# sourceMappingURL=prettier.d.ts.map
+export declare function prettier(): Linter.Config[];

package/{src → dist}/prettier.js

@@ -1,5 +1,4 @@
-import prettierConfig from 'eslint-config-prettier'
-
+import prettierConfig from 'eslint-config-prettier';
 /**
  * Turns off all rules that are unnecessary or might conflict with Prettier.
  *
@@ -7,15 +6,12 @@ import prettierConfig from 'eslint-config-prettier'
  * have to run `pretter` separately for formatting.
  */
 export function prettier() {
-  /** @type {import('eslint').Linter.Config[]} */
-  const config = [
-    {
-      name: 'prettier',
-      rules: {
-        ...prettierConfig.rules,
-      },
-    },
-  ]
-
-  return config
+    return [
+        {
+            name: 'prettier',
+            rules: {
+                ...prettierConfig.rules,
+            },
+        },
+    ];
 }

package/dist/react.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function react(): Linter.Config[];

package/dist/react.js

@@ -0,0 +1,34 @@
+import reactPlugin from 'eslint-plugin-react';
+import reactHooksPlugin from 'eslint-plugin-react-hooks';
+import { GLOB_TS, GLOB_TSX } from './shared.js';
+export function react() {
+    const reactRecommended = reactPlugin.configs.flat?.recommended || {};
+    return [
+        {
+            ...reactRecommended,
+            name: 'react',
+            files: [GLOB_TS, GLOB_TSX],
+            settings: {
+                react: {
+                    version: 'detect',
+                },
+            },
+            rules: {
+                ...reactRecommended.rules,
+                'react/prop-types': 'off',
+                'react/react-in-jsx-scope': 'off',
+            },
+        },
+        {
+            name: 'react-hooks',
+            files: [GLOB_TS, GLOB_TSX],
+            plugins: {
+                'react-hooks': reactHooksPlugin,
+            },
+            rules: {
+                'react-hooks/rules-of-hooks': 'error',
+                'react-hooks/exhaustive-deps': 'warn',
+            },
+        },
+    ];
+}

package/dist/shared.d.ts

@@ -0,0 +1,23 @@
+export declare const GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+export declare const GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+export declare const GLOB_JS = "**/*.?([cm])js";
+export declare const GLOB_JSX = "**/*.?([cm])jsx";
+export declare const GLOB_TS = "**/*.?([cm])ts";
+export declare const GLOB_TSX = "**/*.?([cm])tsx";
+export declare const GLOB_TEST = "**/*.(spec|test).?([cm])[jt]s?(x)";
+export declare const GLOB_STYLE = "**/*.{c,le,sc}ss";
+export declare const GLOB_CSS = "**/*.css";
+export declare const GLOB_LESS = "**/*.less";
+export declare const GLOB_SCSS = "**/*.scss";
+export declare const GLOB_JSON = "**/*.json";
+export declare const GLOB_JSON5 = "**/*.json5";
+export declare const GLOB_JSONC = "**/*.jsonc";
+export declare const GLOB_MARKDOWN = "**/*.md";
+export declare const GLOB_VUE = "**/*.vue";
+export declare const GLOB_YAML = "**/*.y?(a)ml";
+export declare const GLOB_HTML = "**/*.htm?(l)";
+export declare const GLOB_ALL_SRC: readonly ["**/*.?([cm])[jt]s?(x)", "**/*.{c,le,sc}ss", "**/*.json", "**/*.json5", "**/*.md", "**/*.vue", "**/*.y?(a)ml", "**/*.htm?(l)"];
+export declare const GLOB_NODE_MODULES: "**/node_modules";
+export declare const GLOB_LOCKFILE: readonly ["**/package-lock.json", "**/yarn.lock", "**/pnpm-lock.yaml"];
+export declare const GLOB_EXCLUDE: readonly ["**/node_modules", "**/package-lock.json", "**/yarn.lock", "**/pnpm-lock.yaml", "**/fixtures", "**/.changeset", "**/CHANGELOG*.md", "**/*.min.*", "**/LICENSE*", "**/__snapshots__", "**/.tsup"];
+export declare const EXTENSIONS: string[];

package/dist/shared.js

@@ -0,0 +1,49 @@
+export const GLOB_SRC_EXT = '?([cm])[jt]s?(x)';
+export const GLOB_SRC = '**/*.?([cm])[jt]s?(x)';
+export const GLOB_JS = '**/*.?([cm])js';
+export const GLOB_JSX = '**/*.?([cm])jsx';
+export const GLOB_TS = '**/*.?([cm])ts';
+export const GLOB_TSX = '**/*.?([cm])tsx';
+export const GLOB_TEST = '**/*.(spec|test).?([cm])[jt]s?(x)';
+export const GLOB_STYLE = '**/*.{c,le,sc}ss';
+export const GLOB_CSS = '**/*.css';
+export const GLOB_LESS = '**/*.less';
+export const GLOB_SCSS = '**/*.scss';
+export const GLOB_JSON = '**/*.json';
+export const GLOB_JSON5 = '**/*.json5';
+export const GLOB_JSONC = '**/*.jsonc';
+export const GLOB_MARKDOWN = '**/*.md';
+export const GLOB_VUE = '**/*.vue';
+export const GLOB_YAML = '**/*.y?(a)ml';
+export const GLOB_HTML = '**/*.htm?(l)';
+export const GLOB_ALL_SRC = [
+    GLOB_SRC,
+    GLOB_STYLE,
+    GLOB_JSON,
+    GLOB_JSON5,
+    GLOB_MARKDOWN,
+    GLOB_VUE,
+    GLOB_YAML,
+    GLOB_HTML,
+];
+export const GLOB_NODE_MODULES = '**/node_modules';
+export const GLOB_LOCKFILE = [
+    '**/package-lock.json',
+    '**/yarn.lock',
+    '**/pnpm-lock.yaml',
+];
+export const GLOB_EXCLUDE = [
+    GLOB_NODE_MODULES,
+    ...GLOB_LOCKFILE,
+    '**/fixtures',
+    '**/.changeset',
+    '**/CHANGELOG*.md',
+    '**/*.min.*',
+    '**/LICENSE*',
+    '**/__snapshots__',
+    '**/.tsup',
+];
+export const EXTENSIONS = ['ts', 'js']
+    .flatMap((ext) => [ext, ext + 'x'])
+    .flatMap((ext) => [ext, 'm' + ext, 'c' + ext])
+    .flatMap((ext) => [ext, 'd.' + ext]);

package/dist/typescript.d.ts

@@ -0,0 +1,4 @@
+import type { Linter } from 'eslint';
+import tseslint from 'typescript-eslint';
+export { tseslint };
+export declare function typescript(): Linter.Config[];

package/dist/typescript.js

@@ -0,0 +1,112 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import { GLOB_JS, GLOB_JSX, GLOB_TEST, GLOB_TS, GLOB_TSX } from './shared.js';
+export { tseslint };
+export function typescript() {
+    const rules = [...tseslint.configs.recommended, ...tseslint.configs.stylistic]
+        .map((config) => config.rules || {})
+        .reduce((acc, cur) => ({ ...acc, ...cur }), {});
+    const config = [
+        eslint.configs.recommended,
+        {
+            name: 'typescript',
+            files: [GLOB_TS, GLOB_TSX, GLOB_JS, GLOB_JSX],
+            languageOptions: {
+                parser: tseslint.parser,
+                parserOptions: {
+                    projectService: true,
+                    sourceType: 'module',
+                    ecmaVersion: 'latest',
+                },
+            },
+            plugins: {
+                '@typescript-eslint': tseslint.plugin,
+            },
+            rules: {
+                ...rules,
+                '@typescript-eslint/consistent-type-definitions': 'off',
+                '@typescript-eslint/prefer-optional-chain': 'off',
+                '@typescript-eslint/prefer-nullish-coalescing': 'off',
+                '@typescript-eslint/consistent-indexed-object-style': 'off',
+                '@typescript-eslint/array-type': 'off',
+                '@typescript-eslint/dot-notation': 'off',
+                '@typescript-eslint/triple-slash-reference': 'off',
+                '@typescript-eslint/consistent-type-imports': [
+                    'warn',
+                    {
+                        // Allow type imports in type annotations (e.g. `type T = import('Foo').Foo`)
+                        disallowTypeAnnotations: false,
+                    },
+                ],
+                '@typescript-eslint/no-import-type-side-effects': 'warn',
+                '@typescript-eslint/no-unnecessary-type-assertion': 'warn',
+                '@typescript-eslint/no-unnecessary-parameter-property-assignment': 'warn',
+                '@typescript-eslint/restrict-plus-operands': 'warn',
+                '@typescript-eslint/no-unsafe-call': 'warn',
+                '@typescript-eslint/no-unsafe-return': 'warn',
+                '@typescript-eslint/no-unsafe-argument': 'warn',
+                '@typescript-eslint/no-unsafe-member-access': 'warn',
+                '@typescript-eslint/no-unsafe-assignment': 'warn',
+                '@typescript-eslint/no-floating-promises': 'warn',
+                '@typescript-eslint/no-explicit-any': 'warn',
+                '@typescript-eslint/explicit-module-boundary-types': 'off',
+                '@typescript-eslint/no-non-null-assertion': 'off',
+                '@typescript-eslint/restrict-template-expressions': 'off',
+                '@typescript-eslint/no-unused-vars': [
+                    'error',
+                    {
+                        argsIgnorePattern: '^_',
+                        varsIgnorePattern: '^_',
+                        caughtErrorsIgnorePattern: '^_',
+                    },
+                ],
+                '@typescript-eslint/no-extra-semi': 'off',
+                '@typescript-eslint/prefer-function-type': 'warn',
+                '@typescript-eslint/no-misused-promises': [
+                    'error',
+                    { checksVoidReturn: false },
+                ],
+                '@typescript-eslint/await-thenable': 'error',
+                '@typescript-eslint/unbound-method': 'error',
+                // `type T1 = T0` and `interface T2 extends T0 {}` have the same meaning
+                // but different behavior in TypeScript type checking. `T1` and `T0` are
+                // the same type, while `T2` is different than `T0`. We allow `interface
+                // T2 extends T0 {}` explicitly.
+                '@typescript-eslint/no-empty-object-type': [
+                    'error',
+                    {
+                        allowInterfaces: 'with-single-extends',
+                    },
+                ],
+                // Turn off this rule because it's incompatible with the `--isolatedDeclarations` compiler option.
+                '@typescript-eslint/no-inferrable-types': 'off',
+                // TODO: We should set the rule below to error in the future
+                '@typescript-eslint/require-await': 'warn',
+            },
+        },
+        {
+            name: 'typescript-js',
+            files: [GLOB_JS, GLOB_JSX],
+            rules: {
+                '@typescript-eslint/no-require-imports': 'off',
+                '@typescript-eslint/no-var-requires': 'off',
+            },
+        },
+        {
+            name: 'typescript-test',
+            files: [GLOB_TEST],
+            rules: {
+                '@typescript-eslint/no-unsafe-call': 'warn',
+                '@typescript-eslint/no-unsafe-return': 'warn',
+                '@typescript-eslint/no-unsafe-argument': 'warn',
+                '@typescript-eslint/no-unsafe-member-access': 'warn',
+                '@typescript-eslint/no-unsafe-assignment': 'warn',
+                '@typescript-eslint/no-explicit-any': 'off',
+                '@typescript-eslint/no-empty-function': 'off',
+            },
+        },
+    ];
+    // @ts-expect-error: unmatched type
+    const configTyped = config;
+    return configTyped;
+}

package/dist/unicorn.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function unicorn(): Linter.Config[];

package/dist/unicorn.js

@@ -0,0 +1,71 @@
+import plugin from 'eslint-plugin-unicorn';
+export function unicorn() {
+    return [
+        {
+            name: 'unicorn',
+            plugins: {
+                unicorn: plugin,
+            },
+            rules: {
+                // Pass error message when throwing errors
+                'unicorn/error-message': 'error',
+                // Uppercase regex escapes
+                'unicorn/escape-case': 'error',
+                // Array.isArray instead of instanceof etc
+                'unicorn/no-instanceof-builtins': 'error',
+                // Prevent deprecated `new Buffer()`
+                'unicorn/no-new-buffer': 'error',
+                // Keep regex literals safe!
+                'unicorn/no-unsafe-regex': 'off',
+                // Lowercase number formatting for octal, hex, binary (0x1'error' instead of 0X1'error')
+                'unicorn/number-literal-case': 'error',
+                // includes over indexOf when checking for existence
+                'unicorn/prefer-includes': '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',
+                // Prefer using the node: protocol
+                'unicorn/prefer-node-protocol': 'error',
+                // Enforce explicitly comparing the length or size property of a value
+                'unicorn/explicit-length-check': 'error',
+                // Prefer `.flatMap(…)` over `.map(…).flat()`
+                'unicorn/prefer-array-index-of': 'error',
+                // Improve regexes
+                'unicorn/better-regex': 'error',
+                // Enforce combining multiple `Array#push()` into one call.
+                'unicorn/prefer-single-call': 'warn',
+                // Do not use a `for` loop that can be replaced with a `for-of` loop.
+                'unicorn/no-for-loop': 'error',
+                // Disallow eslint-disable comments without specific rule names
+                'unicorn/no-abusive-eslint-disable': 'error',
+                // Prefer `.addEventListener()` and `.removeEventListener()` over `on`-functions.
+                'unicorn/prefer-add-event-listener': 'error',
+                // Prefer `.find(…)` and `.findLast(…)` over the first or last element from
+                'unicorn/prefer-array-find': 'error',
+                // Prefer `.flatMap(…)` over `.map(…).flat()`.
+                'unicorn/prefer-array-flat-map': 'error',
+                // Prefer `.some(…)` over `.filter(…).length` check
+                'unicorn/prefer-array-some': 'error',
+                // Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`
+                'unicorn/prefer-keyboard-event-key': 'error',
+                // Enforce the use of `Math.trunc` instead of bitwise operators.
+                'unicorn/prefer-math-trunc': 'error',
+                // Prefer negative index over `.length - index` when possible
+                'unicorn/prefer-negative-index': 'error',
+                // Prefer `Number` static properties over global ones.
+                'unicorn/prefer-number-properties': 'warn',
+                // Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`
+                'unicorn/prefer-regexp-test': 'warn',
+                // Prefer using `structuredClone` to create a deep clone
+                'unicorn/prefer-structured-clone': 'warn',
+                // Prefer using the `String.raw` tag to avoid escaping `\`
+                'unicorn/prefer-string-raw': 'warn',
+                // Prefer `import.meta.dirname` over `path.dirname(fileURLToPath(import.meta.url))`
+                'unicorn/prefer-import-meta-properties': 'warn',
+            },
+        },
+    ];
+}

package/dist/vue.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare function vue(): Linter.Config[];