@eslint-react/kit 2.1.2-next.1 → 4.0.0-beta.1

package/README.md

@@ -0,0 +1,381 @@
+# @eslint-react/kit
+
+ESLint React's toolkit for building custom React lint rules right inside your `eslint.config.ts`.
+
+## Index
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [API Reference](#api-reference)
+  - [`defineConfig` (default export)](#defineconfig-default-export)
+  - [`merge`](#merge)
+  - [`Kit` — the toolkit object](#kit--the-toolkit-object)
+    - [`kit.collect`](#kitcollect) — Semantic collectors
+    - [`kit.is`](#kitis) — Predicates
+    - [`kit.hint`](#kithint) — Detection hint bit-flags
+    - [`kit.flag`](#kitflag) — Component characteristic flags
+- [Examples](#examples)
+  - [Simple: Ban `forwardRef`](#simple-ban-forwardref)
+  - [Component: Destructure component props](#component-destructure-component-props)
+  - [Hooks: Warn on custom hooks that don't call other hooks](#hooks-warn-on-custom-hooks-that-dont-call-other-hooks)
+  - [Multiple Collectors: No component/hook factories](#multiple-collectors-no-componenthook-factories)
+- [More Examples](#more-examples)
+
+## Installation
+
+```sh
+npm install --save-dev @eslint-react/kit
+```
+
+## Quick Start
+
+```ts
+import eslintReact from "@eslint-react/eslint-plugin";
+import eslintReactKit, { merge } from "@eslint-react/kit";
+import eslintJs from "@eslint/js";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
+
+export default defineConfig(
+  {
+    files: ["**/*.{ts,tsx}"],
+    extends: [
+      eslintJs.configs.recommended,
+      tseslint.configs.recommended,
+      eslintReact.configs["recommended-typescript"],
+      eslintReactKit(
+        {
+          name: "function-component-definition",
+          make: (context, { collect }) => {
+            const { query, visitor } = collect.components(context);
+
+            return merge(
+              visitor,
+              {
+                "Program:exit"(program) {
+                  for (const { node } of query.all(program)) {
+                    if (node.type === "FunctionDeclaration") continue;
+                    context.report({
+                      node,
+                      message: "Function components must be defined with function declarations.",
+                    });
+                  }
+                },
+              },
+            );
+          },
+        },
+      ),
+    ],
+    rules: {
+      "@eslint-react/kit/function-component-definition": "error",
+    },
+  },
+);
+```
+
+## API Reference
+
+### `defineConfig` (default export)
+
+```ts
+import defineReactConfig from "@eslint-react/kit";
+
+defineReactConfig(...rules: RuleDefinition[]): Linter.Config
+```
+
+Creates an ESLint flat-config object from one or more custom rule definitions. Rules are registered under the `@eslint-react/kit` plugin namespace and enabled at `"error"` severity by default.
+
+**`RuleDefinition`:**
+
+| Field  | Type                             | Description                                                                      |
+| ------ | -------------------------------- | -------------------------------------------------------------------------------- |
+| `name` | `string`                         | Unique rule name. Used as `@eslint-react/kit/<name>` in config.                  |
+| `make` | `(context, kit) => RuleListener` | Rule factory. Receives the ESLint rule context and the structured `Kit` toolkit. |
+
+### `merge`
+
+```ts
+import { merge } from "@eslint-react/kit";
+
+merge(...listeners: RuleListener[]): RuleListener
+```
+
+Merges multiple `RuleListener` (visitor) objects into a single listener. When two or more listeners define the same visitor key, the handlers are chained and execute in order.
+
+This is essential for combining a collector's `visitor` with your own inspection logic.
+
+### Kit — the toolkit object
+
+The second argument to `make` is a structured `Kit` object:
+
+```
+kit
+├── collect            -> Semantic collectors (components, hooks)
+├── is                 -> All predicates (component, hook, React API, import source)
+├── hint               -> Detection hint bit-flags
+├── flag               -> Component characteristic bit-flags
+```
+
+---
+
+#### `kit.collect`
+
+Collector factories create a `{ query, visitor }` pair. The `visitor` must be merged into your rule listener via `merge()`. After traversal completes, `query.all(program)` yields all detected semantic nodes.
+
+| Method                          | Returns                                               | Description                                                                             |
+| ------------------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `components(context, options?)` | `CollectorWithContext<FunctionComponentSemanticNode>` | Detects function components. Options: `{ hint?: bigint, collectDisplayName?: boolean }` |
+| `hooks(context)`                | `CollectorWithContext<HookSemanticNode>`              | Detects custom hook definitions.                                                        |
+
+**`CollectorWithContext`** extends `Collector` with contextual queries:
+
+| Query                | Description                               |
+| -------------------- | ----------------------------------------- |
+| `query.all(program)` | All collected semantic nodes in the file. |
+
+---
+
+#### `kit.is`
+
+All predicates live under `kit.is` — organized into four sub-sections.
+
+##### Component
+
+| Predicate                   | Signature                 | Description                                                                 |
+| --------------------------- | ------------------------- | --------------------------------------------------------------------------- |
+| `componentDefinition`       | `(node, hint) -> boolean` | Whether a function node is a component definition. (context pre-bound)      |
+| `componentName`             | `(name) -> boolean`       | Strict PascalCase component name check.                                     |
+| `componentNameLoose`        | `(name) -> boolean`       | Loose component name check.                                                 |
+| `componentWrapperCall`      | `(node) -> boolean`       | Whether a node is a `memo(…)` or `forwardRef(…)` call. (context pre-bound)  |
+| `componentWrapperCallLoose` | `(node) -> boolean`       | Like above, but also matches `useCallback(…)`. (context pre-bound)          |
+| `componentWrapperCallback`  | `(node) -> boolean`       | Whether a function is the callback passed to a wrapper. (context pre-bound) |
+
+##### Hook
+
+General hook predicates:
+
+| Predicate                  | Signature                             | Description                                                  |
+| -------------------------- | ------------------------------------- | ------------------------------------------------------------ |
+| `hook`                     | `(node) -> boolean`                   | Whether a function node is a hook (by name).                 |
+| `hookCall`                 | `(node) -> boolean`                   | Whether a node is a hook call.                               |
+| `hookName`                 | `(name) -> boolean`                   | Whether a string matches the `use[A-Z]` convention.          |
+| `useEffectLikeCall`        | `(node, additionalHooks?) -> boolean` | Whether a node is a `useEffect`/`useLayoutEffect`-like call. |
+| `useStateLikeCall`         | `(node, additionalHooks?) -> boolean` | Whether a node is a `useState`-like call.                    |
+| `useEffectSetupCallback`   | `(node) -> boolean`                   | Whether a node is a useEffect setup function.                |
+| `useEffectCleanupCallback` | `(node) -> boolean`                   | Whether a node is a useEffect cleanup function.              |
+
+##### React API
+
+Factory functions (context pre-bound):
+
+| Predicate      | Signature                        | Description                                                                  |
+| -------------- | -------------------------------- | ---------------------------------------------------------------------------- |
+| `reactAPI`     | `(apiName) -> (node) -> boolean` | Factory: creates a predicate for a React API identifier. (context pre-bound) |
+| `reactAPICall` | `(apiName) -> (node) -> boolean` | Factory: creates a predicate for a React API call. (context pre-bound)       |
+
+Pre-built identifier predicates (context pre-bound):
+
+`captureOwnerStack`, `childrenCount`, `childrenForEach`, `childrenMap`, `childrenOnly`, `childrenToArray`, `cloneElement`, `createContext`, `createElement`, `forwardRef`, `memo`, `lazy`
+
+Pre-built call predicates (context pre-bound):
+
+`captureOwnerStackCall`, `childrenCountCall`, `childrenForEachCall`, `childrenMapCall`, `childrenOnlyCall`, `childrenToArrayCall`, `cloneElementCall`, `createContextCall`, `createElementCall`, `forwardRefCall`, `memoCall`, `lazyCall`
+
+All React API predicates and factories have `context` pre-bound — no need to pass the rule context manually:
+
+```ts
+// Direct check
+is.memo(node);
+is.memoCall(node);
+
+// Useful in filter/find
+nodes.filter(is.memoCall);
+
+// Factory for any API name
+const isCreateRefCall = is.reactAPICall("createRef");
+isCreateRefCall(node);
+```
+
+##### Import source
+
+| Predicate                    | Signature                                 | Description                                          |
+| ---------------------------- | ----------------------------------------- | ---------------------------------------------------- |
+| `initializedFromReact`       | `(name, scope, importSource?) -> boolean` | Whether a variable comes from a React import.        |
+| `initializedFromReactNative` | `(name, scope, importSource?) -> boolean` | Whether a variable comes from a React Native import. |
+
+---
+
+#### `kit.hint`
+
+Bit-flags that control what the component collector considers a "component". Combine with bitwise OR (`|`) and remove with bitwise AND-NOT (`& ~`).
+
+```ts
+// The default hint used when none is specified
+hint.component.Default;
+
+// All available flags
+hint.component.DoNotIncludeFunctionDefinedAsObjectMethod;
+hint.component.DoNotIncludeFunctionDefinedAsClassMethod;
+hint.component.DoNotIncludeFunctionDefinedAsArrayMapCallback;
+hint.component.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback;
+// … and more (inherits all JsxDetectionHint flags)
+```
+
+**Customization example:**
+
+```ts
+const { query, visitor } = collect.components(context, {
+  // Also treat object methods as components (remove the exclusion flag)
+  hint: hint.component.Default & ~hint.component.DoNotIncludeFunctionDefinedAsObjectMethod,
+});
+```
+
+---
+
+#### `kit.flag`
+
+Bit-flags indicating component characteristics. Check with bitwise AND (`&`).
+
+```ts
+flag.component.None; // 0n — no flags
+flag.component.Memo; // wrapped in React.memo
+flag.component.ForwardRef; // wrapped in React.forwardRef
+```
+
+**Usage:**
+
+```ts
+for (const component of query.all(program)) {
+  if (component.flag & flag.component.Memo) {
+    // This component is memoized
+  }
+}
+```
+
+## Examples
+
+### Simple: Ban `forwardRef`
+
+This is a simplified kit reimplementation of the built-in [`react-x/no-forwardRef`](https://eslint-react.xyz/docs/rules/no-forwardRef) rule.
+
+```ts
+defineReactConfig({
+  name: "no-forward-ref",
+  make: (context, { is }) => ({
+    CallExpression(node) {
+      if (is.forwardRefCall(node)) {
+        context.report({ node, message: "forwardRef is deprecated in React 19. Pass ref as a prop instead." });
+      }
+    },
+  }),
+});
+```
+
+### Component: Destructure component props
+
+This is a simplified kit reimplementation of the built-in [`react-x/prefer-destructuring-assignment`](https://eslint-react.xyz/docs/rules/prefer-destructuring-assignment) rule.
+
+```ts
+defineReactConfig({
+  name: "destructure-component-props",
+  make: (context, { collect }) => {
+    const { query, visitor } = collect.components(context);
+
+    return merge(visitor, {
+      "Program:exit"(program) {
+        for (const { node } of query.all(program)) {
+          const [props] = node.params;
+          if (props == null) continue;
+          if (props.type !== AST.Identifier) continue;
+          const propName = props.name;
+          const propVariable = context.sourceCode.getScope(node).variables.find((v) => v.name === propName);
+          const propReferences = propVariable?.references ?? [];
+          for (const ref of propReferences) {
+            const { parent } = ref.identifier;
+            if (parent.type !== AST.MemberExpression) continue;
+            context.report({
+              message: "Use destructuring assignment for component props.",
+              node: parent,
+            });
+          }
+        }
+      },
+    });
+  },
+});
+```
+
+### Hooks: Warn on custom hooks that don't call other hooks
+
+This is a simplified kit reimplementation of the built-in [`react-x/no-unnecessary-use-prefix`](https://eslint-react.xyz/docs/rules/no-unnecessary-use-prefix) rule.
+
+```ts
+defineReactConfig({
+  name: "no-unnecessary-use-prefix",
+  make: (context, { collect }) => {
+    const { query, visitor } = collect.hooks(context);
+
+    return merge(visitor, {
+      "Program:exit"(program) {
+        for (const { node, hookCalls } of query.all(program)) {
+          if (hookCalls.length === 0) {
+            context.report({
+              node,
+              message: "A custom hook should use at least one hook, otherwise it's just a regular function.",
+            });
+          }
+        }
+      },
+    });
+  },
+});
+```
+
+### Multiple Collectors: No component/hook factories
+
+Disallow defining components or hooks inside other functions (factory pattern).
+This is a simplified kit reimplementation of the built-in [`react-x/component-hook-factories`](https://eslint-react.xyz/docs/rules/component-hook-factories) rule.
+
+```ts
+defineReactConfig({
+  name: "component-hook-factories",
+  make: (context, { collect }) => {
+    const fc = collect.components(context);
+    const hk = collect.hooks(context);
+    return merge(
+      fc.visitor,
+      hk.visitor,
+      {
+        "Program:exit"(program) {
+          const comps = fc.query.all(program);
+          const hooks = hk.query.all(program);
+          for (const { name, node, kind } of [...comps, ...hooks]) {
+            if (name == null) continue;
+            if (findParent(node, isFunction) == null) continue;
+            context.report({
+              node,
+              message: `Don't define ${kind} "${name}" inside a function. Move it to the module level.`,
+            });
+          }
+        },
+      },
+    );
+  },
+});
+
+function findParent({ parent }: TSESTree.Node, test: (n: TSESTree.Node) => boolean): TSESTree.Node | null {
+  if (parent == null) return null;
+  if (test(parent)) return parent;
+  if (parent.type === "Program") return null;
+  return findParent(parent, test);
+}
+
+function isFunction({ type }: TSESTree.Node) {
+  return type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression";
+}
+```
+
+## More Examples
+
+Please check the [Rule Recipes](https://eslint-react.xyz/docs/configuration/configure-custom-rules#rule-recipes) in the documentation site.

package/dist/index.d.ts

@@ -1,161 +1,128 @@
-import { unit } from "@eslint-react/eff";
-import * as tseslint from "@typescript-eslint/utils/ts-eslint";
-import { ReportDescriptor } from "@typescript-eslint/utils/ts-eslint";
+import * as core from "@eslint-react/core";
+import { TSESTreeFunction } from "@eslint-react/ast";
+import { TSESTree } from "@typescript-eslint/utils";
+import { RuleContext, RuleFix, RuleFixer, RuleListener } from "@typescript-eslint/utils/ts-eslint";
+import { Linter } from "eslint";
 
-//#region src/constants.d.ts
-/**
- * Regular expressions for matching a HTML tag name
- */
-declare const RE_HTML_TAG: RegExp;
-/**
- * Regular expression for matching a TypeScript file extension.
- */
-declare const RE_TS_EXT: RegExp;
-/**
- * Regular expression for matching a JavaScript file extension.
- */
-declare const RE_JS_EXT: RegExp;
-/**
- * Regular expression for matching a PascalCase string.
- */
-declare const RE_PASCAL_CASE: RegExp;
-/**
- * Regular expression for matching a camelCase string.
- */
-declare const RE_CAMEL_CASE: RegExp;
-/**
- * Regular expression for matching a kebab-case string.
- */
-declare const RE_KEBAB_CASE: RegExp;
-/**
- * Regular expression for matching a snake_case string.
- */
-declare const RE_SNAKE_CASE: RegExp;
-/**
- * Regular expression for matching a CONSTANT_CASE string.
- */
-declare const RE_CONSTANT_CASE: RegExp;
-declare const RE_JAVASCRIPT_PROTOCOL: RegExp;
-/**
- * Regular expression for matching a valid JavaScript identifier.
- */
-declare const RE_JS_IDENTIFIER: RegExp;
-/**
- * Regular expression for matching a RegExp string.
- */
-declare const RE_REGEXP_STR: RegExp;
-/**
- * Regular expression for matching a `@jsx` annotation comment.
- */
-declare const RE_ANNOTATION_JSX: RegExp;
-/**
- * Regular expression for matching a `@jsxFrag` annotation comment.
- */
-declare const RE_ANNOTATION_JSX_FRAG: RegExp;
-/**
- * Regular expression for matching a `@jsxRuntime` annotation comment.
- */
-declare const RE_ANNOTATION_JSX_RUNTIME: RegExp;
-/**
- * Regular expression for matching a `@jsxImportSource` annotation comment.
- */
-declare const RE_ANNOTATION_JSX_IMPORT_SOURCE: RegExp;
-/**
- * Regular expression for matching a React component name.
- */
-declare const RE_COMPONENT_NAME: RegExp;
-/**
- * Regular expression for matching a React component name (loose).
- */
-declare const RE_COMPONENT_NAME_LOOSE: RegExp;
-/**
- * Regular expression for matching a React Hook name.
- */
-declare const RE_HOOK_NAME: RegExp;
-//#endregion
-//#region src/types/index.d.ts
-/**
- * Rule severity.
- * @since 0.0.1
- */
-type SeverityName = "off" | "warn" | "error";
-/**
- * The numeric severity level for a rule.
- *
- * - `0` means off.
- * - `1` means warn.
- * - `2` means error.
- */
-type SeverityLevel = 0 | 1 | 2;
-/**
- * The severity of a rule in a configuration.
- */
-type Severity = SeverityName | SeverityLevel;
-/**
- * Rule declaration.
- * @internal
- * @since 0.0.1
- */
-type RuleConfig<RuleOptions extends unknown[] = unknown[]> = Severity | [Severity, ...Partial<RuleOptions>];
-/**
- * Rule context.
- * @since 0.0.1
- */
-type RuleContext<MessageIds extends string = string, Options extends readonly unknown[] = readonly unknown[]> = tseslint.RuleContext<MessageIds, Options>;
-/**
- * Rule feature.
- * @since 1.20.0
- */
-type RuleFeature = "CFG" | "DBG" | "FIX" | "MOD" | "TSC" | "EXP";
-type RulePolicy = number;
-type RuleSuggest<MessageIds extends string = string> = {
-  messageId: MessageIds;
-  data?: Record<string, unknown>;
-  fix: tseslint.ReportFixFunction;
-};
-/**
- * A collection of settings.
- */
-interface SettingsConfig {
-  [key: string]: unknown;
+//#region src/index.d.ts
+interface Collector<T> {
+  query: {
+    all(program: TSESTree.Program): T[];
+  };
+  visitor: RuleListener;
 }
-interface CompatibleRule {
-  meta: Record<string, any>;
-  create: (...args: any[]) => any;
+interface CollectorWithContext<T, E> extends Collector<T> {
+  query: {
+    all(program: TSESTree.Program): T[];
+  };
 }
-interface CompatiblePlugin {
-  meta: {
-    name: string;
-    version: string;
+declare function components(ctx: RuleContext<string, unknown[]>, options?: {
+  collectDisplayName?: boolean;
+  hint?: bigint;
+}): CollectorWithContext<core.FunctionComponentSemanticNode, core.FunctionComponentSemanticNode>;
+declare function hooks(ctx: RuleContext<string, unknown[]>): CollectorWithContext<core.HookSemanticNode, {
+  key: string;
+  node: TSESTree.Node;
+}>;
+interface RuleToolkit {
+  is: {
+    componentDefinition: (node: TSESTreeFunction, hint: bigint) => boolean;
+    componentName: typeof core.isComponentName;
+    componentNameLoose: typeof core.isComponentNameLoose;
+    componentWrapperCall: (node: TSESTree.Node) => boolean;
+    componentWrapperCallLoose: (node: TSESTree.Node) => boolean;
+    componentWrapperCallback: (node: TSESTree.Node) => boolean;
+    hook: typeof core.isHook;
+    hookCall: typeof core.isHookCall;
+    hookName: typeof core.isHookName;
+    useEffectLikeCall: typeof core.isUseEffectLikeCall;
+    useStateLikeCall: typeof core.isUseStateLikeCall;
+    useEffectSetupCallback: typeof core.isUseEffectSetupCallback;
+    useEffectCleanupCallback: typeof core.isUseEffectCleanupCallback;
+    useCall: typeof core.isUseCall;
+    useActionStateCall: typeof core.isUseActionStateCall;
+    useCallbackCall: typeof core.isUseCallbackCall;
+    useContextCall: typeof core.isUseContextCall;
+    useDebugValueCall: typeof core.isUseDebugValueCall;
+    useDeferredValueCall: typeof core.isUseDeferredValueCall;
+    useEffectCall: typeof core.isUseEffectCall;
+    useFormStatusCall: typeof core.isUseFormStatusCall;
+    useIdCall: typeof core.isUseIdCall;
+    useImperativeHandleCall: typeof core.isUseImperativeHandleCall;
+    useInsertionEffectCall: typeof core.isUseInsertionEffectCall;
+    useLayoutEffectCall: typeof core.isUseLayoutEffectCall;
+    useMemoCall: typeof core.isUseMemoCall;
+    useOptimisticCall: typeof core.isUseOptimisticCall;
+    useReducerCall: typeof core.isUseReducerCall;
+    useRefCall: typeof core.isUseRefCall;
+    useStateCall: typeof core.isUseStateCall;
+    useSyncExternalStoreCall: typeof core.isUseSyncExternalStoreCall;
+    useTransitionCall: typeof core.isUseTransitionCall;
+    reactAPI: (api: string) => (node: null | TSESTree.Node) => boolean;
+    reactAPICall: (api: string) => (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    captureOwnerStack: (node: null | TSESTree.Node) => boolean;
+    childrenCount: (node: null | TSESTree.Node) => boolean;
+    childrenForEach: (node: null | TSESTree.Node) => boolean;
+    childrenMap: (node: null | TSESTree.Node) => boolean;
+    childrenOnly: (node: null | TSESTree.Node) => boolean;
+    childrenToArray: (node: null | TSESTree.Node) => boolean;
+    cloneElement: (node: null | TSESTree.Node) => boolean;
+    createContext: (node: null | TSESTree.Node) => boolean;
+    createElement: (node: null | TSESTree.Node) => boolean;
+    createRef: (node: null | TSESTree.Node) => boolean;
+    forwardRef: (node: null | TSESTree.Node) => boolean;
+    memo: (node: null | TSESTree.Node) => boolean;
+    lazy: (node: null | TSESTree.Node) => boolean;
+    captureOwnerStackCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenCountCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenForEachCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenMapCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenOnlyCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenToArrayCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    cloneElementCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    createContextCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    createElementCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    createRefCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    forwardRefCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    memoCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    lazyCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    initializedFromReact: typeof core.isInitializedFromReact;
+    initializedFromReactNative: typeof core.isInitializedFromReactNative;
+  };
+  hint: {
+    component: typeof core.ComponentDetectionHint & {
+      Default: bigint;
+    };
+  };
+  flag: {
+    component: typeof core.ComponentFlag;
+  };
+  collect: {
+    components: typeof components;
+    hooks: typeof hooks;
   };
-  rules: Record<string, CompatibleRule>;
 }
-interface CompatibleConfig {
-  name?: string;
-  rules?: Record<string, RuleConfig>;
-  settings?: SettingsConfig;
+interface RuleDefinition {
+  name: string;
+  make(ctx: RuleContext<string, unknown[]>, kit: RuleToolkit): RuleListener;
+}
+declare function defineConfig(...rules: RuleDefinition[]): Linter.Config;
+declare function merge(...listeners: RuleListener[]): RuleListener;
+declare module "@typescript-eslint/utils/ts-eslint" {
+  interface RuleContext<MessageIds extends string, Options extends readonly unknown[]> {
+    report(descriptor: {
+      readonly data?: Readonly<Record<string, unknown>>;
+      readonly fix?: ((fixer: RuleFixer) => IterableIterator<RuleFix> | readonly RuleFix[] | RuleFix | null) | null;
+      readonly loc?: Readonly<TSESTree.SourceLocation> | Readonly<TSESTree.Position>;
+      readonly message: string;
+      readonly node: TSESTree.Node;
+      readonly suggest?: readonly {
+        readonly data?: Readonly<Record<string, unknown>>;
+        readonly desc: string;
+        readonly fix: (fixer: RuleFixer) => IterableIterator<RuleFix> | readonly RuleFix[] | RuleFix | null;
+      }[] | null;
+    }): void;
+  }
 }
 //#endregion
-//#region src/utils/regexp.d.ts
-/**
- * Convert a string to the `RegExp`.
- * Normal strings (e.g. `"foo"`) is converted to `/^foo$/` of `RegExp`.
- * Strings like `"/^foo/i"` are converted to `/^foo/i` of `RegExp`.
- * @see https://github.com/sveltejs/eslint-plugin-svelte/blob/main/packages/eslint-plugin-svelte/src/utils/regexp.ts
- * @param string The string to convert.
- * @returns Returns the `RegExp`.
- */
-declare function toRegExp(string: string): {
-  test(s: string): boolean;
-};
-/**
- * Checks whether given string is regexp string
- * @param string The string to check
- * @returns boolean
- */
-declare function isRegExp(string: string): boolean;
-//#endregion
-//#region src/utils/reporting.d.ts
-declare function report(context: RuleContext): (descriptor: unit | null | ReportDescriptor<string>) => void;
-//#endregion
-export { CompatibleConfig, CompatiblePlugin, CompatibleRule, RE_ANNOTATION_JSX, RE_ANNOTATION_JSX_FRAG, RE_ANNOTATION_JSX_IMPORT_SOURCE, RE_ANNOTATION_JSX_RUNTIME, RE_CAMEL_CASE, RE_COMPONENT_NAME, RE_COMPONENT_NAME_LOOSE, RE_CONSTANT_CASE, RE_HOOK_NAME, RE_HTML_TAG, RE_JAVASCRIPT_PROTOCOL, RE_JS_EXT, RE_JS_IDENTIFIER, RE_KEBAB_CASE, RE_PASCAL_CASE, RE_REGEXP_STR, RE_SNAKE_CASE, RE_TS_EXT, RuleConfig, RuleContext, RuleFeature, RulePolicy, RuleSuggest, SettingsConfig, Severity, SeverityLevel, SeverityName, isRegExp, report, toRegExp };
+export { Collector, CollectorWithContext, type RuleContext, RuleToolkit, defineConfig as default, defineConfig, merge };

package/dist/index.js

@@ -1,108 +1,140 @@
-import "@eslint-react/eff";
+import * as core from "@eslint-react/core";
 
-//#region src/constants.ts
-/**
-* Regular expressions for matching a HTML tag name
-*/
-const RE_HTML_TAG = /^[a-z][^-]*$/u;
-/**
-* Regular expression for matching a TypeScript file extension.
-*/
-const RE_TS_EXT = /^[cm]?tsx?$/u;
-/**
-* Regular expression for matching a JavaScript file extension.
-*/
-const RE_JS_EXT = /^[cm]?jsx?$/u;
-/**
-* Regular expression for matching a PascalCase string.
-*/
-const RE_PASCAL_CASE = /^[A-Z][\dA-Za-z]*$/u;
-/**
-* Regular expression for matching a camelCase string.
-*/
-const RE_CAMEL_CASE = /^[a-z][\dA-Za-z]*$/u;
-/**
-* Regular expression for matching a kebab-case string.
-*/
-const RE_KEBAB_CASE = /^[a-z][\d\-a-z]*$/u;
-/**
-* Regular expression for matching a snake_case string.
-*/
-const RE_SNAKE_CASE = /^[a-z][\d_a-z]*$/u;
-/**
-* Regular expression for matching a CONSTANT_CASE string.
-*/
-const RE_CONSTANT_CASE = /^[A-Z][\d_A-Z]*$/u;
-const RE_JAVASCRIPT_PROTOCOL = /^[\u0000-\u001F ]*j[\t\n\r]*a[\t\n\r]*v[\t\n\r]*a[\t\n\r]*s[\t\n\r]*c[\t\n\r]*r[\t\n\r]*i[\t\n\r]*p[\t\n\r]*t[\t\n\r]*:/iu;
-/**
-* Regular expression for matching a valid JavaScript identifier.
-*/
-const RE_JS_IDENTIFIER = /^[_$a-z][\w$]*$/i;
-/**
-* Regular expression for matching a RegExp string.
-*/
-const RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u;
-/**
-* Regular expression for matching a `@jsx` annotation comment.
-*/
-const RE_ANNOTATION_JSX = /@jsx\s+(\S+)/u;
-/**
-* Regular expression for matching a `@jsxFrag` annotation comment.
-*/
-const RE_ANNOTATION_JSX_FRAG = /@jsxFrag\s+(\S+)/u;
-/**
-* Regular expression for matching a `@jsxRuntime` annotation comment.
-*/
-const RE_ANNOTATION_JSX_RUNTIME = /@jsxRuntime\s+(\S+)/u;
-/**
-* Regular expression for matching a `@jsxImportSource` annotation comment.
-*/
-const RE_ANNOTATION_JSX_IMPORT_SOURCE = /@jsxImportSource\s+(\S+)/u;
-/**
-* Regular expression for matching a React component name.
-*/
-const RE_COMPONENT_NAME = /^[A-Z]/u;
-/**
-* Regular expression for matching a React component name (loose).
-*/
-const RE_COMPONENT_NAME_LOOSE = /^_?[A-Z]/u;
-/**
-* Regular expression for matching a React Hook name.
-*/
-const RE_HOOK_NAME = /^use/u;
+//#region package.json
+var name = "@eslint-react/kit";
+var version = "4.0.0-beta.1";
 
 //#endregion
-//#region src/utils/regexp.ts
-/**
-* Convert a string to the `RegExp`.
-* Normal strings (e.g. `"foo"`) is converted to `/^foo$/` of `RegExp`.
-* Strings like `"/^foo/i"` are converted to `/^foo/i` of `RegExp`.
-* @see https://github.com/sveltejs/eslint-plugin-svelte/blob/main/packages/eslint-plugin-svelte/src/utils/regexp.ts
-* @param string The string to convert.
-* @returns Returns the `RegExp`.
-*/
-function toRegExp(string) {
-	const [, pattern, flags = "u"] = RE_REGEXP_STR.exec(string) ?? [];
-	if (pattern != null) return new RegExp(pattern, flags);
-	return { test: (s) => s === string };
+//#region src/index.ts
+function components(ctx, options) {
+	const { api, visitor } = core.getComponentCollector(ctx, options);
+	return {
+		query: { all: (program) => api.getAllComponents(program) },
+		visitor
+	};
 }
-/**
-* Checks whether given string is regexp string
-* @param string The string to check
-* @returns boolean
-*/
-function isRegExp(string) {
-	return RE_REGEXP_STR.test(string);
+function hooks(ctx) {
+	const { api, visitor } = core.getHookCollector(ctx);
+	return {
+		query: { all: (program) => api.getAllHooks(program) },
+		visitor
+	};
 }
-
-//#endregion
-//#region src/utils/reporting.ts
-function report(context) {
-	return (descriptor) => {
-		if (descriptor == null) return;
-		return context.report(descriptor);
+function createKit(ctx) {
+	return {
+		is: {
+			componentDefinition: (node, hint) => core.isComponentDefinition(ctx, node, hint),
+			componentName: core.isComponentName,
+			componentNameLoose: core.isComponentNameLoose,
+			componentWrapperCall: (node) => core.isComponentWrapperCall(ctx, node),
+			componentWrapperCallLoose: (node) => core.isComponentWrapperCallLoose(ctx, node),
+			componentWrapperCallback: (node) => core.isComponentWrapperCallback(ctx, node),
+			hook: core.isHook,
+			hookCall: core.isHookCall,
+			hookName: core.isHookName,
+			useEffectLikeCall: core.isUseEffectLikeCall,
+			useStateLikeCall: core.isUseStateLikeCall,
+			useEffectSetupCallback: core.isUseEffectSetupCallback,
+			useEffectCleanupCallback: core.isUseEffectCleanupCallback,
+			useCall: core.isUseCall,
+			useActionStateCall: core.isUseActionStateCall,
+			useCallbackCall: core.isUseCallbackCall,
+			useContextCall: core.isUseContextCall,
+			useDebugValueCall: core.isUseDebugValueCall,
+			useDeferredValueCall: core.isUseDeferredValueCall,
+			useEffectCall: core.isUseEffectCall,
+			useFormStatusCall: core.isUseFormStatusCall,
+			useIdCall: core.isUseIdCall,
+			useImperativeHandleCall: core.isUseImperativeHandleCall,
+			useInsertionEffectCall: core.isUseInsertionEffectCall,
+			useLayoutEffectCall: core.isUseLayoutEffectCall,
+			useMemoCall: core.isUseMemoCall,
+			useOptimisticCall: core.isUseOptimisticCall,
+			useReducerCall: core.isUseReducerCall,
+			useRefCall: core.isUseRefCall,
+			useStateCall: core.isUseStateCall,
+			useSyncExternalStoreCall: core.isUseSyncExternalStoreCall,
+			useTransitionCall: core.isUseTransitionCall,
+			reactAPI: (api) => core.isReactAPI(api)(ctx),
+			reactAPICall: (api) => core.isReactAPICall(api)(ctx),
+			captureOwnerStack: core.isCaptureOwnerStack(ctx),
+			childrenCount: core.isChildrenCount(ctx),
+			childrenForEach: core.isChildrenForEach(ctx),
+			childrenMap: core.isChildrenMap(ctx),
+			childrenOnly: core.isChildrenOnly(ctx),
+			childrenToArray: core.isChildrenToArray(ctx),
+			cloneElement: core.isCloneElement(ctx),
+			createContext: core.isCreateContext(ctx),
+			createElement: core.isCreateElement(ctx),
+			createRef: core.isCreateRef(ctx),
+			forwardRef: core.isForwardRef(ctx),
+			memo: core.isMemo(ctx),
+			lazy: core.isLazy(ctx),
+			captureOwnerStackCall: core.isCaptureOwnerStackCall(ctx),
+			childrenCountCall: core.isChildrenCountCall(ctx),
+			childrenForEachCall: core.isChildrenForEachCall(ctx),
+			childrenMapCall: core.isChildrenMapCall(ctx),
+			childrenOnlyCall: core.isChildrenOnlyCall(ctx),
+			childrenToArrayCall: core.isChildrenToArrayCall(ctx),
+			cloneElementCall: core.isCloneElementCall(ctx),
+			createContextCall: core.isCreateContextCall(ctx),
+			createElementCall: core.isCreateElementCall(ctx),
+			createRefCall: core.isCreateRefCall(ctx),
+			forwardRefCall: core.isForwardRefCall(ctx),
+			memoCall: core.isMemoCall(ctx),
+			lazyCall: core.isLazyCall(ctx),
+			initializedFromReact: core.isInitializedFromReact,
+			initializedFromReactNative: core.isInitializedFromReactNative
+		},
+		hint: { component: {
+			...core.ComponentDetectionHint,
+			Default: core.DEFAULT_COMPONENT_DETECTION_HINT
+		} },
+		flag: { component: core.ComponentFlag },
+		collect: {
+			components,
+			hooks
+		}
 	};
 }
+function defineConfig(...rules) {
+	return {
+		files: ["**/*.ts", "**/*.tsx"],
+		plugins: { [name]: {
+			meta: {
+				name,
+				version
+			},
+			rules: rules.reduce((acc, { name, make }) => {
+				Reflect.set(acc, name, {
+					meta: {
+						fixable: "code",
+						hasSuggestions: true
+					},
+					create(ctx) {
+						return make(ctx, createKit(ctx));
+					}
+				});
+				return acc;
+			}, {})
+		} },
+		rules: rules.reduce((acc, { name: name$1 }) => {
+			acc[`${name}/${name$1}`] = "error";
+			return acc;
+		}, {})
+	};
+}
+function merge(...listeners) {
+	const [base = {}, ...rest] = listeners;
+	for (const r of rest) for (const key in r) {
+		const existing = base[key];
+		base[key] = existing ? (...args) => {
+			existing(...args);
+			r[key]?.(...args);
+		} : r[key];
+	}
+	return base;
+}
 
 //#endregion
-export { RE_ANNOTATION_JSX, RE_ANNOTATION_JSX_FRAG, RE_ANNOTATION_JSX_IMPORT_SOURCE, RE_ANNOTATION_JSX_RUNTIME, RE_CAMEL_CASE, RE_COMPONENT_NAME, RE_COMPONENT_NAME_LOOSE, RE_CONSTANT_CASE, RE_HOOK_NAME, RE_HTML_TAG, RE_JAVASCRIPT_PROTOCOL, RE_JS_EXT, RE_JS_IDENTIFIER, RE_KEBAB_CASE, RE_PASCAL_CASE, RE_REGEXP_STR, RE_SNAKE_CASE, RE_TS_EXT, isRegExp, report, toRegExp };
+export { defineConfig as default, defineConfig, merge };

package/package.json

@@ -1,7 +1,13 @@
 {
   "name": "@eslint-react/kit",
-  "version": "2.1.2-next.1",
-  "description": "ESLint React's plugin kit for building plugins and rules.",
+  "version": "4.0.0-beta.1",
+  "description": "ESLint React's utility module for building custom rules.",
+  "keywords": [
+    "react",
+    "eslint",
+    "eslint-react",
+    "@eslint-react/kit"
+  ],
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
     "url": "https://github.com/Rel1cx/eslint-react/issues"
@@ -12,7 +18,7 @@
     "directory": "packages/utilities/kit"
   },
   "license": "MIT",
-  "author": "Rel1cx<rel1cx@proton.me>",
+  "author": "Rel1cx",
   "sideEffects": false,
   "type": "module",
   "exports": {
@@ -22,26 +28,41 @@
     },
     "./package.json": "./package.json"
   },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/utils": "^8.46.0",
-    "@eslint-react/eff": "2.1.2-next.1"
+    "@typescript-eslint/utils": "^8.57.2",
+    "@eslint-react/ast": "4.0.0-beta.1",
+    "@eslint-react/core": "4.0.0-beta.1"
   },
   "devDependencies": {
-    "@tsconfig/node22": "^22.0.2",
-    "tsdown": "^0.15.6",
+    "eslint": "^10.1.0",
+    "tsdown": "^0.21.4",
+    "@local/eff": "3.0.0-beta.72",
     "@local/configs": "0.0.0"
   },
+  "peerDependencies": {
+    "eslint": "^10.0.0",
+    "typescript": "*"
+  },
   "engines": {
-    "node": ">=20.19.0"
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "inlinedDependencies": {
+    "@local/eff": "workspace:*"
   },
   "scripts": {
-    "build": "tsdown --dts-resolve",
+    "build": "tsdown",
     "build:docs": "typedoc",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }