@ztd-me/eslint 0.0.0-stage → 0.1.1

package/dist/options.d.ts

@@ -0,0 +1,42 @@
+import type { OptionsConfig, StylisticConfig, TypedFlatConfigItem } from '@antfu/eslint-config';
+import type { Linter } from 'eslint';
+export interface TypeScriptOptions {
+    /** Default: tsconfig.json. Its resolved compiler options must enable strict and noUncheckedIndexedAccess. */
+    tsconfigPath?: string;
+    /** Absolute project root; defaults to process.cwd(). */
+    tsconfigRootDir?: string;
+}
+export interface ReactOptions {
+    /** Scope both antfu and strict React rules; defaults to JS/TS source extensions. */
+    files?: string[];
+    /** Additional official React Compiler checks. */
+    compiler?: boolean;
+    /** Opt in to the experimental fetch cleanup check. */
+    experimental?: boolean;
+    /** Explicit App Router integration. Defaults to framework-neutral React. */
+    framework?: 'next' | 'vinext';
+    /** Literal app directory relative to the config root. Default: app and src/app. Requires framework. */
+    appDir?: string;
+}
+export interface VueOptions {
+    /** Vue 3 SFCs. Default: **\/*.vue. */
+    files?: string[];
+}
+type RemovedOptions = 'typescript' | 'react' | 'vue' | 'jsx' | 'test' | 'autoRenamePlugins' | 'isInEditor' | 'antislop' | 'stylistic';
+type BaseOptions = Omit<OptionsConfig, RemovedOptions>;
+export interface ConfigOptions extends BaseOptions {
+    /** Stable formatting remains active because line limits and array policy require it. */
+    stylistic?: true | Omit<StylisticConfig, 'experimental'>;
+    /** Typed checking is enabled by default. Set false only for a JavaScript-only scope. */
+    typescript?: boolean | TypeScriptOptions;
+    /** Explicitly enable React. Default: false. */
+    react?: boolean | ReactOptions;
+    /** Explicitly enable Vue 3, including accessibility. Default: false. */
+    vue?: boolean | VueOptions;
+    /** Enable the researched Vitest checks only for Vitest projects. Default: false. */
+    test?: boolean;
+    /** Final, explicit project rule overrides. */
+    rules?: Linter.RulesRecord;
+}
+export type LocalConfig = TypedFlatConfigItem | Linter.Config;
+export {};

package/dist/options.js

@@ -0,0 +1 @@
+export {};

package/dist/rules/react.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare const reactRules: Linter.RulesRecord;

package/dist/rules/react.js

@@ -0,0 +1,55 @@
+export const reactRules = {
+    'react/exhaustive-deps': [
+        'error',
+        {
+            enableDangerousAutofixThisMayCauseInfiniteLoops: false,
+            requireExplicitEffectDeps: false,
+        },
+    ],
+    'react/no-array-index-key': 'error',
+    'react/purity': 'error',
+    'react/set-state-in-effect': 'error',
+    'react/web-api-no-leaked-event-listener': 'error',
+    'react/web-api-no-leaked-intersection-observer': 'error',
+    'react/web-api-no-leaked-interval': 'error',
+    'react/web-api-no-leaked-resize-observer': 'error',
+    'react/web-api-no-leaked-timeout': 'error',
+    'react/jsx-no-comment-textnodes': 'error',
+    'react/jsx-no-leaked-dollar': 'error',
+    'react/jsx-no-leaked-semicolon': 'error',
+    'react/dom-no-dangerously-set-innerhtml': 'error',
+    'react/dom-no-script-url': 'error',
+    'react/dom-no-unsafe-iframe-sandbox': 'error',
+    'react/use-state': [
+        'error',
+        {
+            enforceAssignment: true,
+            enforceLazyInitialization: true,
+            enforceSetterName: true,
+        },
+    ],
+    'react/no-unstable-context-value': 'error',
+    'react/no-unstable-default-props': [
+        'error',
+        {
+            safeDefaultProps: [],
+        },
+    ],
+    'react/dom-no-missing-button-type': 'error',
+    'react/dom-no-missing-iframe-sandbox': 'error',
+    'react/dom-no-unsafe-target-blank': 'error',
+    'react/rules-of-hooks': 'error',
+    'react/error-boundaries': 'error',
+    'react/no-missing-key': 'error',
+    'react/no-nested-component-definitions': 'error',
+    'react/no-nested-lazy-component-declarations': 'error',
+    'react/set-state-in-render': 'error',
+    'react/static-components': 'error',
+    'react/use-memo': 'error',
+    'react/dom-no-dangerously-set-innerhtml-with-children': 'error',
+    'react/dom-no-void-elements-with-children': 'error',
+    'react/no-leaked-conditional-rendering': 'error',
+    'react-hooks/globals': 'error',
+    'react-hooks/immutability': 'error',
+    'react-hooks/refs': 'error',
+};

package/dist/rules/shared.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare const sharedRules: Linter.RulesRecord;

package/dist/rules/shared.js

@@ -0,0 +1,120 @@
+export const sharedRules = {
+    'complexity': [
+        'error',
+        {
+            max: 10,
+            variant: 'classic',
+        },
+    ],
+    'sonarjs/cognitive-complexity': ['error', 15],
+    'max-depth': [
+        'error',
+        {
+            max: 4,
+        },
+    ],
+    'max-lines-per-function': [
+        'error',
+        {
+            max: 60,
+            skipBlankLines: true,
+            skipComments: true,
+            IIFEs: true,
+        },
+    ],
+    'max-lines': [
+        'error',
+        {
+            max: 300,
+            skipBlankLines: true,
+            skipComments: true,
+        },
+    ],
+    'max-params': [
+        'error',
+        {
+            max: 4,
+        },
+    ],
+    'style/max-len': [
+        'error',
+        {
+            code: 120,
+            comments: 120,
+            tabWidth: 2,
+            ignoreUrls: true,
+            ignoreStrings: false,
+            ignoreTemplateLiterals: false,
+            ignoreRegExpLiterals: false,
+            ignoreComments: false,
+            ignoreTrailingComments: false,
+        },
+    ],
+    'eqeqeq': ['error', 'always'],
+    'curly': ['error', 'all'],
+    'array-callback-return': [
+        'error',
+        {
+            allowImplicit: false,
+            checkForEach: true,
+            allowVoid: false,
+        },
+    ],
+    'no-empty': [
+        'error',
+        {
+            allowEmptyCatch: false,
+        },
+    ],
+    'no-shadow': [
+        'error',
+        {
+            builtinGlobals: false,
+            hoist: 'all',
+            ignoreOnInitialization: false,
+        },
+    ],
+    'no-nested-ternary': 'error',
+    'no-unused-expressions': [
+        'error',
+        {
+            allowShortCircuit: false,
+            allowTernary: false,
+            allowTaggedTemplates: true,
+            enforceForJSX: true,
+        },
+    ],
+    'eslint-comments/require-description': [
+        'error',
+        {
+            ignore: ['eslint-enable'],
+        },
+    ],
+    'unused-imports/no-unused-vars': [
+        'error',
+        {
+            args: 'all',
+            argsIgnorePattern: '^_',
+            caughtErrors: 'all',
+            caughtErrorsIgnorePattern: '^_',
+            vars: 'all',
+            varsIgnorePattern: '^_',
+            ignoreRestSiblings: true,
+            reportUsedIgnorePattern: true,
+        },
+    ],
+    'no-constant-binary-expression': 'error',
+    'no-unsafe-optional-chaining': [
+        'error',
+        {
+            disallowArithmeticOperators: true,
+        },
+    ],
+    'no-promise-executor-return': [
+        'error',
+        {
+            allowVoid: false,
+        },
+    ],
+    'no-setter-return': 'error',
+};

package/dist/rules/tests.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare const testsRules: Linter.RulesRecord;

package/dist/rules/tests.js

@@ -0,0 +1,31 @@
+export const testsRules = {
+    'test/valid-expect': [
+        'error',
+        {
+            alwaysAwait: true,
+            minArgs: 1,
+            maxArgs: 1,
+        },
+    ],
+    'test/no-conditional-expect': [
+        'error',
+        {
+            expectAssertions: false,
+        },
+    ],
+    'test/no-conditional-tests': 'error',
+    'test/no-disabled-tests': 'error',
+    'test/expect-expect': [
+        'error',
+        {
+            assertFunctionNames: ['expect', 'assert'],
+            additionalTestBlockFunctions: [],
+        },
+    ],
+    'test/unbound-method': [
+        'error',
+        {
+            ignoreStatic: false,
+        },
+    ],
+};

package/dist/rules/ts-syntax.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare const tsSyntaxRules: Linter.RulesRecord;

package/dist/rules/ts-syntax.js

@@ -0,0 +1,88 @@
+export const tsSyntaxRules = {
+    'ts/no-explicit-any': [
+        'error',
+        {
+            fixToUnknown: false,
+            ignoreRestArgs: false,
+        },
+    ],
+    'ts/no-non-null-assertion': 'error',
+    'ts/no-empty-object-type': [
+        'error',
+        {
+            allowInterfaces: 'never',
+            allowObjectTypes: 'never',
+        },
+    ],
+    'ts/ban-ts-comment': [
+        'error',
+        {
+            'ts-ignore': true,
+            'ts-nocheck': true,
+            'ts-check': false,
+            'ts-expect-error': 'allow-with-description',
+            'minimumDescriptionLength': 10,
+        },
+    ],
+    'ts/consistent-type-assertions': [
+        'error',
+        {
+            assertionStyle: 'as',
+            objectLiteralTypeAssertions: 'never',
+            arrayLiteralTypeAssertions: 'never',
+        },
+    ],
+    'ts/explicit-module-boundary-types': [
+        'error',
+        {
+            allowArgumentsExplicitlyTypedAsAny: false,
+            allowDirectConstAssertionInArrowFunctions: false,
+            allowHigherOrderFunctions: false,
+            allowOverloadFunctions: false,
+            allowTypedFunctionExpressions: true,
+        },
+    ],
+    'ts/no-useless-constructor': 'error',
+    'ts/no-invalid-void-type': [
+        'error',
+        {
+            allowAsThisParameter: true,
+            allowInGenericTypeArguments: true,
+        },
+    ],
+    'ts/no-extraneous-class': [
+        'error',
+        {
+            allowConstructorOnly: false,
+            allowEmpty: false,
+            allowStaticOnly: false,
+            allowWithDecorator: true,
+        },
+    ],
+    'ts/max-params': [
+        'error',
+        {
+            max: 4,
+            countVoidThis: false,
+        },
+    ],
+    'ts/no-shadow': [
+        'error',
+        {
+            builtinGlobals: false,
+            hoist: 'functions-and-types',
+            ignoreOnInitialization: false,
+            ignoreTypeValueShadow: true,
+            ignoreFunctionTypeParameterNameValueShadow: true,
+        },
+    ],
+    'ts/no-unused-expressions': [
+        'error',
+        {
+            allowShortCircuit: false,
+            allowTernary: false,
+            allowTaggedTemplates: true,
+            enforceForJSX: true,
+        },
+    ],
+};

package/dist/rules/typed.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare const typedRules: Linter.RulesRecord;

package/dist/rules/typed.js

@@ -0,0 +1,170 @@
+export const typedRules = {
+    'ts/strict-boolean-expressions': [
+        'error',
+        {
+            allowAny: false,
+            allowNumber: false,
+            allowString: false,
+            allowNullableBoolean: false,
+            allowNullableEnum: false,
+            allowNullableNumber: false,
+            allowNullableObject: false,
+            allowNullableString: false,
+        },
+    ],
+    'ts/no-floating-promises': [
+        'error',
+        {
+            checkThenables: true,
+            ignoreVoid: false,
+            ignoreIIFE: false,
+            allowForKnownSafeCalls: [],
+            allowForKnownSafePromises: [],
+        },
+    ],
+    'ts/no-misused-promises': [
+        'error',
+        {
+            checksConditionals: {
+                flagUnions: 'all',
+            },
+            checksSpreads: true,
+            checksVoidReturn: true,
+        },
+    ],
+    'ts/restrict-plus-operands': [
+        'error',
+        {
+            allowAny: false,
+            allowBoolean: false,
+            allowNullish: false,
+            allowNumberAndString: false,
+            allowRegExp: false,
+            skipCompoundAssignments: false,
+        },
+    ],
+    'ts/restrict-template-expressions': [
+        'error',
+        {
+            allow: [],
+            allowAny: false,
+            allowArray: false,
+            allowBoolean: false,
+            allowNullish: false,
+            allowNumber: true,
+            allowRegExp: false,
+            allowNever: false,
+        },
+    ],
+    'ts/return-await': ['error', 'always'],
+    'ts/switch-exhaustiveness-check': [
+        'error',
+        {
+            allowDefaultCaseForExhaustiveSwitch: true,
+            considerDefaultExhaustiveForUnions: false,
+            requireDefaultForNonUnion: true,
+        },
+    ],
+    'ts/only-throw-error': [
+        'error',
+        {
+            allow: [],
+            allowRethrowing: true,
+            allowThrowingAny: false,
+            allowThrowingUnknown: false,
+        },
+    ],
+    'ts/no-unsafe-type-assertion': 'error',
+    'ts/use-unknown-in-catch-callback-variable': 'error',
+    'ts/no-unnecessary-condition': [
+        'error',
+        {
+            allowConstantLoopConditions: 'only-allowed-literals',
+            checkTypePredicates: true,
+        },
+    ],
+    'ts/no-base-to-string': [
+        'error',
+        {
+            checkUnknown: true,
+            ignoredTypeNames: [
+                'Error',
+                'RegExp',
+                'URL',
+                'URLSearchParams',
+            ],
+        },
+    ],
+    'ts/no-misused-spread': [
+        'error',
+        {
+            allow: [],
+        },
+    ],
+    'ts/no-unsafe-enum-comparison': 'error',
+    'ts/no-deprecated': [
+        'error',
+        {
+            allow: [],
+        },
+    ],
+    'ts/consistent-type-exports': [
+        'error',
+        {
+            fixMixedExportsWithInlineTypeSpecifier: false,
+        },
+    ],
+    'ts/prefer-readonly': [
+        'error',
+        {
+            onlyInlineLambdas: false,
+        },
+    ],
+    'ts/require-array-sort-compare': [
+        'error',
+        {
+            ignoreStringArrays: true,
+        },
+    ],
+    'ts/require-await': 'error',
+    'ts/prefer-nullish-coalescing': [
+        'error',
+        {
+            ignoreConditionalTests: true,
+            ignoreMixedLogicalExpressions: false,
+            ignorePrimitives: {
+                bigint: false,
+                boolean: false,
+                number: false,
+                string: false,
+            },
+        },
+    ],
+    'ts/prefer-optional-chain': [
+        'error',
+        {
+            requireNullish: true,
+            allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
+        },
+    ],
+    'ts/no-array-delete': 'error',
+    'ts/no-unsafe-unary-minus': 'error',
+    'ts/prefer-promise-reject-errors': [
+        'error',
+        {
+            allowEmptyReject: false,
+            allowThrowingAny: false,
+            allowThrowingUnknown: false,
+        },
+    ],
+    'ts/await-thenable': 'error',
+    'ts/no-for-in-array': 'error',
+    'ts/no-implied-eval': '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/unbound-method': 'error',
+};

package/dist/rules/vue-a11y.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare const vueA11yRules: Linter.RulesRecord;

package/dist/rules/vue-a11y.js

@@ -0,0 +1,32 @@
+export const vueA11yRules = {
+    'vue-a11y/alt-text': 'error',
+    'vue-a11y/anchor-has-content': 'error',
+    'vue-a11y/aria-props': 'error',
+    'vue-a11y/aria-role': 'error',
+    'vue-a11y/aria-unsupported-elements': 'error',
+    'vue-a11y/click-events-have-key-events': 'error',
+    'vue-a11y/form-control-has-label': 'error',
+    'vue-a11y/heading-has-content': 'error',
+    'vue-a11y/iframe-has-title': 'error',
+    'vue-a11y/interactive-supports-focus': 'error',
+    'vue-a11y/label-has-for': [
+        'error',
+        {
+            required: {
+                some: ['nesting', 'id'],
+            },
+            allowChildren: false,
+        },
+    ],
+    'vue-a11y/media-has-caption': 'error',
+    'vue-a11y/mouse-events-have-key-events': 'error',
+    'vue-a11y/no-access-key': 'error',
+    'vue-a11y/no-aria-hidden-on-focusable': 'error',
+    'vue-a11y/no-autofocus': 'error',
+    'vue-a11y/no-distracting-elements': 'error',
+    'vue-a11y/no-redundant-roles': 'error',
+    'vue-a11y/no-role-presentation-on-focusable': 'error',
+    'vue-a11y/no-static-element-interactions': 'error',
+    'vue-a11y/role-has-required-aria-props': 'error',
+    'vue-a11y/tabindex-no-positive': 'error',
+};

package/dist/rules/vue.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export declare const vueRules: Linter.RulesRecord;

package/dist/rules/vue.js

@@ -0,0 +1,90 @@
+export const vueRules = {
+    'vue/no-dupe-keys': 'error',
+    'vue/no-v-html': 'error',
+    'vue/no-setup-props-reactivity-loss': 'error',
+    'vue/no-ref-object-reactivity-loss': 'error',
+    'vue/no-mutating-props': [
+        'error',
+        {
+            shallowOnly: false,
+        },
+    ],
+    'vue/require-explicit-emits': [
+        'error',
+        {
+            allowProps: false,
+        },
+    ],
+    'vue/require-explicit-slots': 'error',
+    'vue/require-prop-types': 'error',
+    'vue/no-undef-components': [
+        'error',
+        {
+            ignorePatterns: [],
+        },
+    ],
+    'vue/no-undef-directives': [
+        'error',
+        {
+            ignore: [],
+        },
+    ],
+    'vue/no-unused-emit-declarations': 'error',
+    'vue/html-button-has-type': [
+        'error',
+        {
+            button: true,
+            submit: true,
+            reset: true,
+        },
+    ],
+    'vue/no-template-target-blank': [
+        'error',
+        {
+            allowReferrer: false,
+            enforceDynamicLinks: 'always',
+        },
+    ],
+    'vue/eqeqeq': ['error', 'always'],
+    'vue/max-lines-per-block': [
+        'error',
+        {
+            script: 200,
+            template: 200,
+            style: 150,
+            skipBlankLines: true,
+        },
+    ],
+    'vue/max-template-depth': [
+        'error',
+        {
+            maxDepth: 5,
+        },
+    ],
+    'vue/max-len': [
+        'error',
+        {
+            code: 120,
+            template: 120,
+            comments: 120,
+            tabWidth: 2,
+            ignoreUrls: true,
+            ignoreStrings: false,
+            ignoreTemplateLiterals: false,
+            ignoreRegExpLiterals: false,
+            ignoreHTMLAttributeValues: false,
+            ignoreHTMLTextContents: false,
+        },
+    ],
+    'vue/no-template-shadow': 'error',
+    'vue/one-component-per-file': 'error',
+    'vue/no-required-prop-with-default': 'error',
+    'vue/html-end-tags': 'error',
+    'vue/no-async-in-computed-properties': 'error',
+    'vue/no-side-effects-in-computed-properties': 'error',
+    'vue/no-use-v-if-with-v-for': 'error',
+    'vue/require-v-for-key': 'error',
+    'vue/no-watch-after-await': 'error',
+    'vue/no-lifecycle-after-await': 'error',
+    'vue/no-expose-after-await': 'error',
+};

package/dist/typescript.d.ts

@@ -0,0 +1,9 @@
+import type { TypeScriptOptions } from './options.js';
+export declare function resolveTypeScript(options: boolean | TypeScriptOptions): {
+    tsconfigPath: string;
+    parserOptions: {
+        tsconfigRootDir: string;
+        projectService: false;
+        project: string;
+    };
+};