@ztd-me/eslint 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,117 @@
-# Temporary Holding Version
+# @ztd-me/eslint
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Strict, typed ESLint flat configs built on `@antfu/eslint-config`. The standard is defined independently of existing projects. Every selected research rule is an error; existing antfu opinions keep their upstream severities.
+
+```sh
+pnpm add -D @ztd-me/eslint eslint@^10.11.0 typescript@~6.0.3
+```
+
+Requires Node >=22.14, ESLint 10.11 or later in major 10, and TypeScript >=5.4 <6.1. The tested versions and all 198 research entries are documented in [rule coverage](docs/rule-coverage.md) and the [machine-readable catalog](docs/rule-catalog.json).
+
+```js
+// eslint.config.js (ESM)
+import ztd from '@ztd-me/eslint'
+
+export default ztd({
+  typescript: { tsconfigPath: 'tsconfig.json' },
+  react: true,
+  ignores: ['dist/**'],
+})
+```
+
+The default export and named `createConfig` are the same asynchronous function and return a Promise of flat configs. The declarations export `ConfigOptions`, `TypeScriptOptions`, `ReactOptions`, `VueOptions`, and `LocalConfig`. This API accepts explicit final overrides:
+
+```js
+import { createConfig } from '@ztd-me/eslint'
+
+export default createConfig({
+  vue: true,
+  typescript: {
+    tsconfigPath: 'tsconfig.json',
+    tsconfigRootDir: import.meta.dirname,
+  },
+}, {
+  name: 'project/cli-output',
+  files: ['cli/**'],
+  rules: { 'no-console': 'off' },
+})
+```
+
+Framework dependencies used by this package are included: enabling a supported profile does not prompt to install a plugin. React and Vue default to `false`; enable only the frameworks used by the project. Both can be enabled with independent `files` globs in a mixed repository. Vue targets Vue 3; Vue 2 is outside this profile.
+
+## TypeScript
+
+Type-aware checking is on by default, using `tsconfig.json`. Supply an existing project config with `strict: true` (including `strictNullChecks`) and `noUncheckedIndexedAccess: true`. Inherited compiler options are resolved; missing configs and unsafe compiler options fail explicitly. The selected TS config must include every linted TS/TSX file, including handwritten configuration and test files. For solution-style project references, point to the actual linted project's config.
+
+The parser uses the explicit TS project, with `.vue` as an extra file extension and `vue-eslint-parser` as the SFC outer parser. Typed rules cover Vue scripts as well as TS and TSX. Vue template expressions use Vue rules and the custom array visitor; TypeScript rules do not type-check template expressions.
+
+For a JavaScript-only scope, use `typescript: false`. This turns off TypeScript parsing and rules; it does not lower JS complexity, length, or correctness standards. There is no syntax-only TypeScript or `strictTypes: false` mode. Run `tsc --noEmit` as a separate compiler gate; `exactOptionalPropertyTypes`, `noPropertyAccessFromIndexSignature`, and `useUnknownInCatchVariables` are also recommended compiler settings.
+
+## Framework options
+
+| Option | Default | Behavior |
+| --- | --- | --- |
+| `react` | `false` | `true`, or `{ files, compiler, experimental }`; includes hooks in `.ts` as well as JSX |
+| `react.compiler` | `false` | Adds four official React Compiler checks |
+| `react.experimental` | `false` | Adds experimental fetch cleanup checking |
+| `vue` | `false` | `true`, or `{ files }`; Vue 3 correctness and accessibility are strict |
+| `test` | `false` | Explicitly enable the researched Vitest profile; do not enable for Node test or Jest |
+| `rules` | `{}` | Deliberate final overrides; subsequent flat configs run last |
+
+JSX accessibility is disabled and `eslint-plugin-jsx-a11y` is not installed: its 6.10.2 peer range excludes ESLint 10. This is the user-authorized compatibility exception, not an accessibility certification. Vue accessibility remains enabled. JSX syntax and React correctness remain enabled when React is selected.
+
+The selected React Hooks checks use one owner per behavior: `react/*` for hooks and effects, `react-hooks/*` only for globals, immutability, refs, and optional Compiler checks. The experimental fetch rule is off until explicitly selected. React version migration opinions are inherited from antfu rather than strengthened as correctness rules.
+
+## Limits and arrays
+
+| Measure | Inclusive maximum / threshold |
+| --- | --- |
+| Classic cyclomatic complexity | 10 |
+| Cognitive complexity | 15 |
+| Control-flow nesting | 4 |
+| Function length | 60 effective lines, including IIFEs and nested function text |
+| File length | 300 effective lines; SFCs include script, template and style |
+| Code and comments per line | 120 characters, tab width 2 |
+| Function parameters | 4; TS `this: void` is not counted |
+| Vue block lines | script 200, template 200, style 150; blank lines excluded, comments counted |
+| Vue template nesting | 5 |
+| Array literals | 3 or more elements expand, including exactly 3 |
+
+These are researched defaults, not empirically optimal constants. Function/file counts exclude blank lines and comments. Line-width rules only exempt lines containing URLs; strings, regexes, templates and comments remain checked. Width rules report violations without unsafe automatic wrapping.
+
+`ztd/array-layout` implements the complete array policy in JS, TS, JSX, Vue scripts and Vue templates:
+
+- Empty arrays and simple arrays of 1–2 elements use one line when the complete surrounding line fits 120 characters.
+- Arrays with at least 3 elements, complex/nested elements, multiline elements, or over-wide simple pairs expand: bracket boundaries and each element have separate lines. Antfu supplies indentation and multiline trailing commas.
+- Simple elements are primitives, identifiers, unary operations on primitives, simple noncomputed property chains, and their TS/chain wrappers. Objects, arrays, calls, functions, spreads, and conditional expressions are complex.
+- Comments retain their association. A fix that would cross a comment is withheld for manual editing; comments prevent short-array collapsing. CRLF is preserved.
+- Spreads count as one syntax element; holes remain prohibited by sparse-array rules. Destructuring and tuple types use their existing consistency policy rather than the literal threshold. Tuple values and `as const` arrays use the literal policy.
+
+```ts
+const pair = [first, second]
+const ids = [
+  first,
+  second,
+  third,
+]
+const users = [
+  { id: 1 },
+  { id: 2 },
+]
+const [red, green, blue] = rgb
+```
+
+The custom rule replaces the four transitional array rules from the research. Antfu's ArrayExpression consistency visitor is disabled; object/import/parameter consistency stays enabled. Stable stylistic formatting stays active. Disabling it or enabling its experimental list formatter is rejected; explicit final rule overrides remain available.
+
+## Validation and release
+
+```sh
+pnpm install --frozen-lockfile
+pnpm run check
+```
+
+The checks build JS/declarations, type-check the public API, self-lint source/tests/scripts, exercise real TS/React/Vue fixtures, check all numeric boundaries and all selected catalog options, and install/import/type-check an independently packed artifact with pnpm. Negative fixtures are checked by the test harness, not included in ordinary self-lint. The test modules have reasoned local exceptions for Node's asynchronous ESM setup and imports of the distribution being tested; safety and size limits remain active.
+
+[Publishing instructions](docs/publishing.md) describe the stage-only GitHub workflow and the user-controlled promotion. Staging is not a public release. After promotion, run `node scripts/registry-smoke.mjs 0.1.0` to install the exact public version in a fresh pnpm project and verify imports, declarations and lint behavior. Registry installation follows pnpm's supply-chain policies; a policy rejection is a blocker, not permission to disable the policy.
+
+The repository has not granted an open-source license; package metadata is `UNLICENSED` pending that separate decision.

package/dist/array-layout.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const arrayLayout: Rule.RuleModule;

package/dist/array-layout.js

@@ -0,0 +1,103 @@
+import { isRecord, isSimple } from './array-simple.js';
+function fitsLine(source, node, text, tokens) {
+    const start = tokens.getFirstToken(node);
+    const end = tokens.getLastToken(node);
+    if (start === null || end === null) {
+        return false;
+    }
+    const prefix = source.lines[start.loc.start.line - 1]?.slice(0, start.loc.start.column) ?? '';
+    const suffix = source.lines[end.loc.end.line - 1]?.slice(end.loc.end.column) ?? '';
+    return Array.from(`${prefix}${text}${suffix}`.replaceAll('\t', '  ')).length <= 120;
+}
+function hasTemplateVisitor(value) {
+    return isRecord(value) && typeof value.defineTemplateBodyVisitor === 'function'
+        && typeof value.getTemplateBodyTokenStore === 'function';
+}
+function gapBefore(source, token) {
+    if (token === null) {
+        return [];
+    }
+    const previous = source.getTokenBefore(token);
+    if (previous === null || previous.loc.end.line !== token.loc.start.line) {
+        return [];
+    }
+    return [
+        [
+            previous.range[1],
+            token.range[0],
+        ],
+    ];
+}
+function expand(context, node, elements, tokens) {
+    const source = context.sourceCode;
+    const open = tokens.getFirstToken(node);
+    const close = tokens.getLastToken(node);
+    if (open === null || close === null) {
+        return;
+    }
+    const ranges = elements.flatMap(element => gapBefore(tokens, tokens.getFirstToken(element)));
+    ranges.push(...gapBefore(tokens, close));
+    if (ranges.length === 0) {
+        return;
+    }
+    const indent = source.lines[open.loc.start.line - 1]?.match(/^\s*/u)?.[0] ?? '';
+    const newline = source.text.includes('\r\n') ? '\r\n' : '\n';
+    context.report({
+        node,
+        messageId: 'expand',
+        fix(fixer) {
+            // Comments remain in place; a non-whitespace gap requires a manual layout edit.
+            if (ranges.some(([start, end]) => /\S/u.test(source.text.slice(start, end)))) {
+                return null;
+            }
+            return ranges.map(range => fixer.replaceTextRange(range, `${newline}${indent}${range[1] === close.range[0] ? '' : '  '}`));
+        },
+    });
+}
+function createVisitor(context, tokens) {
+    return {
+        ArrayExpression(node) {
+            const elements = node.elements.filter(element => element !== null);
+            if (elements.length !== node.elements.length) {
+                return;
+            }
+            const source = context.sourceCode;
+            const complex = elements.some(element => !isSimple(element) || /[\r\n]/u.test(source.getText(element)));
+            if (elements.length >= 3 || complex) {
+                expand(context, node, elements, tokens);
+                return;
+            }
+            if (tokens.getCommentsInside(node).length > 0) {
+                return;
+            }
+            const compact = `[${elements.map(element => source.getText(element)).join(', ')}]`;
+            if (elements.length > 0 && !fitsLine(source, node, compact, tokens)) {
+                expand(context, node, elements, tokens);
+                return;
+            }
+            if (/[\r\n]/u.test(source.getText(node)) && fitsLine(source, node, compact, tokens)) {
+                context.report({ node, messageId: 'collapse', fix: fixer => fixer.replaceText(node, compact) });
+            }
+        },
+    };
+}
+export const arrayLayout = {
+    meta: {
+        type: 'layout',
+        docs: { description: 'Expand arrays of at least three items or complex items; collapse safe short arrays' },
+        fixable: 'whitespace',
+        schema: [],
+        messages: {
+            expand: 'Use separate bracket and element lines for arrays with at least 3 items or complex/multiline items.',
+            collapse: 'Keep a simple array with fewer than 3 items on one line when the complete line fits 120 characters.',
+        },
+    },
+    create(context) {
+        const script = createVisitor(context, context.sourceCode);
+        const services = context.sourceCode.parserServices;
+        if (hasTemplateVisitor(services)) {
+            return services.defineTemplateBodyVisitor(createVisitor(context, services.getTemplateBodyTokenStore()), script);
+        }
+        return script;
+    },
+};

package/dist/array-simple.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isSimple(node: unknown): boolean;

package/dist/array-simple.js

@@ -0,0 +1,42 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isLiteral(node) {
+    return isRecord(node) && node.type === 'Literal';
+}
+function isAccess(node) {
+    if (node.computed !== false || !isRecord(node.property) || node.property.type !== 'Identifier') {
+        return false;
+    }
+    if (!isRecord(node.object)) {
+        return false;
+    }
+    return node.object.type === 'Identifier'
+        || (node.object.type === 'MemberExpression' && isAccess(node.object));
+}
+function isWrapper(node) {
+    const wrappers = [
+        'TSAsExpression',
+        'TSSatisfiesExpression',
+        'TSNonNullExpression',
+        'ChainExpression',
+    ];
+    return typeof node.type === 'string' && wrappers.includes(node.type) && isSimple(node.expression);
+}
+export function isSimple(node) {
+    if (!isRecord(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case 'Identifier':
+            return true;
+        case 'Literal':
+            return node.value === null || typeof node.value !== 'object';
+        case 'UnaryExpression':
+            return isLiteral(node.argument) && isSimple(node.argument);
+        case 'MemberExpression':
+            return isAccess(node);
+        default:
+            return isWrapper(node);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigOptions, LocalConfig } from './options.js';
+import antfu from '@antfu/eslint-config';
+export type { ConfigOptions, LocalConfig, ReactOptions, TypeScriptOptions, VueOptions } from './options.js';
+/** Strict flat configs. Project overrides are deliberately last and reviewable. */
+export declare function createConfig(options?: ConfigOptions, ...localConfigs: LocalConfig[]): Promise<Awaited<ReturnType<typeof antfu>>>;
+export default createConfig;

package/dist/index.js

@@ -0,0 +1,201 @@
+import antfu, { GLOB_SRC, GLOB_TESTS, GLOB_TS, GLOB_TSX } from '@antfu/eslint-config';
+import hooks from 'eslint-plugin-react-hooks';
+import sonar from 'eslint-plugin-sonarjs';
+import { arrayLayout } from './array-layout.js';
+import { isRecord } from './array-simple.js';
+import { reactRules } from './rules/react.js';
+import { sharedRules } from './rules/shared.js';
+import { testsRules } from './rules/tests.js';
+import { tsSyntaxRules } from './rules/ts-syntax.js';
+import { typedRules } from './rules/typed.js';
+import { vueA11yRules } from './rules/vue-a11y.js';
+import { vueRules } from './rules/vue.js';
+import { resolveTypeScript } from './typescript.js';
+function shared(sfcFiles) {
+    return {
+        name: 'ztd/shared',
+        files: [
+            GLOB_SRC,
+            ...sfcFiles,
+        ],
+        plugins: { sonarjs: sonar, ztd: { rules: { 'array-layout': arrayLayout } } },
+        linterOptions: { reportUnusedDisableDirectives: 'error' },
+        rules: {
+            ...sharedRules,
+            'ztd/array-layout': 'error',
+            'antfu/curly': 'off',
+            'antfu/if-newline': 'off',
+            'antfu/consistent-list-newline': [
+                'error',
+                { ArrayExpression: false },
+            ],
+            'style/array-bracket-newline': 'off',
+            'style/array-element-newline': 'off',
+            'no-unused-vars': 'off',
+            'eslint-comments/no-unlimited-disable': 'error',
+        },
+    };
+}
+function typed(files) {
+    return [
+        {
+            name: 'ztd/typescript-syntax',
+            files,
+            rules: {
+                ...tsSyntaxRules,
+                'max-params': 'off',
+                'no-shadow': 'off',
+                'no-unused-expressions': 'off',
+                'no-useless-constructor': 'off',
+                'no-setter-return': 'off',
+                'ts/no-unused-vars': 'off',
+                'ts/explicit-function-return-type': 'off',
+            },
+        },
+        {
+            name: 'ztd/typescript-typed',
+            files,
+            ignores: ['**/*.md/**', '**/*.astro/*.ts'],
+            rules: {
+                ...typedRules,
+                'require-await': 'off',
+                'no-throw-literal': 'off',
+                'prefer-promise-reject-errors': 'off',
+                'no-constant-binary-expression': 'off',
+            },
+        },
+    ];
+}
+function react(options) {
+    if (options === false || options === undefined) {
+        return [];
+    }
+    const settings = typeof options === 'object' ? options : {};
+    const { 'react/no-leaked-conditional-rendering': _typedRule, ...rules } = reactRules;
+    return [
+        {
+            name: 'ztd/react',
+            files: settings.files ?? [GLOB_SRC],
+            plugins: { 'react-hooks': hooks },
+            rules: {
+                ...rules,
+                'react/web-api-no-leaked-fetch': settings.experimental === true ? 'error' : 'off',
+                ...Object.fromEntries([
+                    'config',
+                    'gating',
+                    'incompatible-library',
+                    'preserve-manual-memoization',
+                ].map(rule => [
+                    `react-hooks/${rule}`,
+                    settings.compiler === true ? 'error' : 'off',
+                ])),
+            },
+        },
+    ];
+}
+function vue(options) {
+    if (options === false || options === undefined) {
+        return [];
+    }
+    const files = typeof options === 'object' ? options.files ?? ['**/*.vue'] : ['**/*.vue'];
+    return [
+        {
+            name: 'ztd/vue',
+            files,
+            rules: {
+                ...vueRules,
+                ...vueA11yRules,
+                'style/max-len': 'off',
+                'vue/array-bracket-newline': 'off',
+                'vue/array-element-newline': 'off',
+            },
+        },
+    ];
+}
+function vitest(enabled, tsFiles) {
+    if (!enabled) {
+        return [];
+    }
+    const { 'test/unbound-method': _unbound, ...syntaxTests } = testsRules;
+    const configs = [
+        {
+            name: 'ztd/vitest',
+            files: GLOB_TESTS,
+            rules: { ...syntaxTests, 'test/no-only-tests': 'error' },
+        },
+    ];
+    if (tsFiles.length > 0) {
+        configs.push({
+            name: 'ztd/vitest-typed',
+            files: tsFiles.flatMap(file => GLOB_TESTS.map(testFile => [file, testFile])),
+            rules: { 'ts/unbound-method': 'off', 'test/unbound-method': [
+                    'error',
+                    { ignoreStatic: false },
+                ] },
+        });
+    }
+    return configs;
+}
+function vueFiles(options) {
+    if (options === false || options === undefined) {
+        return [];
+    }
+    return typeof options === 'object' ? options.files ?? ['**/*.vue'] : ['**/*.vue'];
+}
+function antfuReact(options, tsFiles) {
+    if (options === false || options === undefined) {
+        return false;
+    }
+    const files = typeof options === 'object' ? options.files ?? [GLOB_SRC] : [GLOB_SRC];
+    return { files, filesTypeAware: files.flatMap(file => tsFiles.map(tsFile => [file, tsFile])), overrides: {} };
+}
+function antfuVue(files) {
+    return files.length === 0 ? false : { a11y: true, vueVersion: 3, files };
+}
+function resolveDefaults(options) {
+    return {
+        ...options,
+        typescript: options.typescript ?? true,
+        react: options.react ?? false,
+        vue: options.vue ?? false,
+        test: options.test ?? false,
+        rules: options.rules ?? {},
+    };
+}
+function validateFormatting(settings) {
+    if (settings === false || (isRecord(settings) && settings.experimental === true)) {
+        throw new Error('@ztd-me/eslint: stable stylistic formatting is required; '
+            + 'disable competing experimental list rules');
+    }
+}
+/** Strict flat configs. Project overrides are deliberately last and reviewable. */
+export async function createConfig(options = {}, ...localConfigs) {
+    validateFormatting(options.stylistic);
+    const { typescript, react: enableReact, vue: enableVue, test, rules, ...base } = resolveDefaults(options);
+    const tsOptions = typescript === false ? false : resolveTypeScript(typescript);
+    const sfcFiles = vueFiles(enableVue);
+    const tsFiles = [
+        GLOB_TS,
+        GLOB_TSX,
+        ...sfcFiles,
+    ];
+    const strict = [
+        shared(sfcFiles),
+        ...react(enableReact),
+        ...vue(enableVue),
+        ...(typescript === false ? [] : typed(tsFiles)),
+        ...vitest(test, typescript === false ? [] : tsFiles),
+    ];
+    return await antfu({
+        ...base,
+        typescript: tsOptions === false ? false : { ...tsOptions, filesTypeAware: tsFiles },
+        react: antfuReact(enableReact, tsFiles),
+        vue: antfuVue(sfcFiles),
+        test,
+        jsx: { a11y: false },
+        autoRenamePlugins: true,
+        isInEditor: false,
+        antislop: false,
+    }, ...strict, { name: 'ztd/project-rules', rules }, ...localConfigs);
+}
+export default createConfig;

package/dist/options.d.ts

@@ -0,0 +1,38 @@
+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;
+}
+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;