@eslint-react/kit 4.0.0-beta.2 → 4.0.1-beta.0

package/README.md

@@ -7,7 +7,9 @@ ESLint React's toolkit for building custom React lint rules right inside your `e
 - [Installation](#installation)
 - [Quick Start](#quick-start)
 - [API Reference](#api-reference)
-  - [`defineConfig` (default export)](#defineconfig-default-export)
+  - [`eslintReactKit` (default export)](#eslintreactkit-default-export)
+  - [`RuleDefinition`](#ruledefinition)
+  - [`KitBuilder`](#kitbuilder)
   - [`merge`](#merge)
   - [`Kit` — the toolkit object](#kit--the-toolkit-object)
     - [`kit.collect`](#kitcollect) — Semantic collectors
@@ -25,7 +27,7 @@ ESLint React's toolkit for building custom React lint rules right inside your `e
 ## Installation
 
 ```sh
-npm install --save-dev @eslint-react/kit
+npm install --save-dev @eslint-react/kit@beta
 ```
 
 ## Quick Start
@@ -33,10 +35,32 @@ npm install --save-dev @eslint-react/kit
 ```ts
 import eslintReact from "@eslint-react/eslint-plugin";
 import eslintReactKit, { merge } from "@eslint-react/kit";
+import type { RuleDefinition } from "@eslint-react/kit";
 import eslintJs from "@eslint/js";
 import { defineConfig } from "eslint/config";
 import tseslint from "typescript-eslint";
 
+/** Enforce function declarations for function components. */
+function functionComponentDefinition(): RuleDefinition {
+  return (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.",
+            });
+          }
+        },
+      },
+    );
+  };
+}
+
 export default defineConfig(
   {
     files: ["**/*.{ts,tsx}"],
@@ -44,55 +68,75 @@ export default defineConfig(
       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.",
-                    });
-                  }
-                },
-              },
-            );
-          },
-        },
-      ),
+      eslintReactKit()
+        .use(functionComponentDefinition)
+        .getConfig(),
     ],
-    rules: {
-      "@eslint-react/kit/function-component-definition": "error",
-    },
   },
 );
 ```
 
+The rule name is derived automatically from the function name (`functionComponentDefinition` → `function-component-definition`), and registered as `@eslint-react/kit/function-component-definition` at `"error"` severity.
+
 ## API Reference
 
-### `defineConfig` (default export)
+### `eslintReactKit` (default export)
+
+```ts
+import eslintReactKit from "@eslint-react/kit";
+
+eslintReactKit(): KitBuilder
+```
+
+Creates a `KitBuilder` instance for registering custom rules via the chainable `.use()` API.
+
+### `RuleDefinition`
+
+```ts
+import type { RuleDefinition } from "@eslint-react/kit";
+
+type RuleDefinition = (ctx: RuleContext, kit: RuleToolkit) => RuleListener;
+```
+
+A rule definition is a function that receives the ESLint rule context and the structured `Kit` toolkit, and returns a `RuleListener` (AST visitor object).
+
+Rules are defined as **named functions** that return a `RuleDefinition`. The function name is automatically converted to kebab-case and used as the rule name under the `@eslint-react/kit` plugin namespace.
 
 ```ts
-import defineReactConfig from "@eslint-react/kit";
+// Function name `noForwardRef` → rule name `no-forward-ref`
+// Registered as `@eslint-react/kit/no-forward-ref`
+function noForwardRef(): RuleDefinition {
+  return (context, { is }) => ({ ... });
+}
 
-defineReactConfig(...rules: RuleDefinition[]): Linter.Config
+// Functions that accept options work the same way
+function forbidElements({ forbidden }: ForbidElementsOptions): RuleDefinition {
+  return (context) => ({ ... });
+}
 ```
 
-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.
+### `KitBuilder`
 
-**`RuleDefinition`:**
+```ts
+interface KitBuilder {
+  use<F extends (...args: any[]) => RuleDefinition>(factory: F, ...args: Parameters<F>): KitBuilder;
+  getConfig(): Linter.Config;
+}
+```
+
+A chainable builder for registering custom rules.
 
-| 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. |
+| Method      | Description                                                                                                                |
+| ----------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `use`       | Registers a rule factory. The rule name is `kebabCase(factory.name)`. Options type is inferred from the factory signature. |
+| `getConfig` | Returns a `Linter.Config` with all registered rules enabled at `"error"` severity.                                         |
+
+```ts
+eslintReactKit()
+  .use(noForwardRef) // no-arg factory
+  .use(forbidElements, { forbidden: new Map() }) // factory with inferred options
+  .getConfig();
+```
 
 ### `merge`
 
@@ -108,7 +152,7 @@ This is essential for combining a collector's `visitor` with your own inspection
 
 ### Kit — the toolkit object
 
-The second argument to `make` is a structured `Kit` object:
+The second argument passed to the `RuleDefinition` function is a structured `Kit` object:
 
 ```
 kit
@@ -273,9 +317,8 @@ Exposes the normalized `react-x` settings from the ESLint shared configuration (
 **Usage:**
 
 ```ts
-defineReactConfig({
-  name: "require-react-19",
-  make: (context, { settings }) => ({
+function requireReact19(): RuleDefinition {
+  return (context, { settings }) => ({
     Program(program) {
       if (!settings.version.startsWith("19.")) {
         context.report({
@@ -284,8 +327,8 @@ defineReactConfig({
         });
       }
     },
-  }),
-});
+  });
+}
 ```
 
 ---
@@ -294,29 +337,32 @@ defineReactConfig({
 
 ### 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.
+This is a simplified kit reimplementation of the built-in [`react-x/no-forwardRef`](https://beta.eslint-react.xyz/docs/rules/no-forward-ref) rule.
 
 ```ts
-defineReactConfig({
-  name: "no-forward-ref",
-  make: (context, { is }) => ({
+function noForwardRef(): RuleDefinition {
+  return (context, { is }) => ({
     CallExpression(node) {
       if (is.forwardRefCall(node)) {
         context.report({ node, message: "forwardRef is deprecated in React 19. Pass ref as a prop instead." });
       }
     },
-  }),
-});
+  });
+}
+
+// Usage
+eslintReactKit()
+  .use(noForwardRef)
+  .getConfig();
 ```
 
 ### 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.
+This is a simplified kit reimplementation of the built-in [`react-x/prefer-destructuring-assignment`](https://beta.eslint-react.xyz/docs/rules/prefer-destructuring-assignment) rule.
 
 ```ts
-defineReactConfig({
-  name: "destructure-component-props",
-  make: (context, { collect }) => {
+function destructureComponentProps(): RuleDefinition {
+  return (context, { collect }) => {
     const { query, visitor } = collect.components(context);
 
     return merge(visitor, {
@@ -339,18 +385,22 @@ defineReactConfig({
         }
       },
     });
-  },
-});
+  };
+}
+
+// Usage
+eslintReactKit()
+  .use(destructureComponentProps)
+  .getConfig();
 ```
 
 ### 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.
+This is a simplified kit reimplementation of the built-in [`react-x/no-unnecessary-use-prefix`](https://beta.eslint-react.xyz/docs/rules/no-unnecessary-use-prefix) rule.
 
 ```ts
-defineReactConfig({
-  name: "no-unnecessary-use-prefix",
-  make: (context, { collect }) => {
+function noUnnecessaryUsePrefix(): RuleDefinition {
+  return (context, { collect }) => {
     const { query, visitor } = collect.hooks(context);
 
     return merge(visitor, {
@@ -365,19 +415,34 @@ defineReactConfig({
         }
       },
     });
-  },
-});
+  };
+}
+
+// Usage
+eslintReactKit()
+  .use(noUnnecessaryUsePrefix)
+  .getConfig();
 ```
 
 ### 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.
+This is a simplified kit reimplementation of the built-in [`react-x/component-hook-factories`](https://beta.eslint-react.xyz/docs/rules/component-hook-factories) rule.
 
 ```ts
-defineReactConfig({
-  name: "component-hook-factories",
-  make: (context, { collect }) => {
+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";
+}
+
+function componentHookFactories(): RuleDefinition {
+  return (context, { collect }) => {
     const fc = collect.components(context);
     const hk = collect.hooks(context);
     return merge(
@@ -398,21 +463,15 @@ defineReactConfig({
         },
       },
     );
-  },
-});
-
-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";
-}
+// Usage
+eslintReactKit()
+  .use(componentHookFactories)
+  .getConfig();
 ```
 
 ## More Examples
 
-Please check the [Rule Recipes](https://eslint-react.xyz/docs/configuration/configure-custom-rules#rule-recipes) in the documentation site.
+Please check the [Rule Recipes](https://beta.eslint-react.xyz/docs/configuration/configure-custom-rules#rule-recipes) in the documentation site.

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as core from "@eslint-react/core";
-import { ESLintReactSettingsNormalized } from "@eslint-react/shared";
+import { ESLintReactSettingsNormalized, RuleFix, RuleFixer, RuleListener, defineRuleListener as merge } from "@eslint-react/shared";
 import { TSESTreeFunction } from "@eslint-react/ast";
 import { TSESTree } from "@typescript-eslint/utils";
-import { RuleContext, RuleFix, RuleFixer, RuleListener } from "@typescript-eslint/utils/ts-eslint";
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
 import { Linter } from "eslint";
 
 //#region src/index.d.ts
@@ -17,33 +17,79 @@ interface CollectorWithContext<T> extends Collector<T> {
     all(program: TSESTree.Program): T[];
   };
 }
-declare function components(ctx: RuleContext<string, unknown[]>, options?: {
-  collectDisplayName?: boolean;
-  hint?: bigint;
-}): CollectorWithContext<core.FunctionComponentSemanticNode>;
-declare function hooks(ctx: RuleContext<string, unknown[]>): CollectorWithContext<core.HookSemanticNode>;
+type RuleDefinition = (ctx: RuleContext, kit: RuleToolkit) => RuleListener;
+interface KitBuilder {
+  getConfig(args?: {
+    files?: string[];
+  }): Linter.Config;
+  use<F extends (...args: any[]) => RuleDefinition>(factory: F, ...args: Parameters<F>): KitBuilder;
+}
 interface RuleToolkit {
+  collect: {
+    components(ctx: RuleContext, options?: {
+      collectDisplayName?: boolean;
+      hint?: bigint;
+    }): CollectorWithContext<core.FunctionComponentSemanticNode>;
+    hooks(ctx: RuleContext): CollectorWithContext<core.HookSemanticNode>;
+  };
+  flag: {
+    component: typeof core.ComponentFlag;
+  };
+  hint: {
+    component: typeof core.ComponentDetectionHint & {
+      Default: bigint;
+    };
+  };
   is: {
+    captureOwnerStack: (node: null | TSESTree.Node) => boolean;
+    captureOwnerStackCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenCount: (node: null | TSESTree.Node) => boolean;
+    childrenCountCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenForEach: (node: null | TSESTree.Node) => boolean;
+    childrenForEachCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenMap: (node: null | TSESTree.Node) => boolean;
+    childrenMapCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenOnly: (node: null | TSESTree.Node) => boolean;
+    childrenOnlyCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    childrenToArray: (node: null | TSESTree.Node) => boolean;
+    childrenToArrayCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    cloneElement: (node: null | TSESTree.Node) => boolean;
+    cloneElementCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
     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;
+    componentWrapperCallLoose: (node: TSESTree.Node) => boolean;
+    createContext: (node: null | TSESTree.Node) => boolean;
+    createContextCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    createElement: (node: null | TSESTree.Node) => boolean;
+    createElementCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    createRef: (node: null | TSESTree.Node) => boolean;
+    createRefCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    forwardRef: (node: null | TSESTree.Node) => boolean;
+    forwardRefCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
     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;
+    initializedFromReact: typeof core.isInitializedFromReact;
+    initializedFromReactNative: typeof core.isInitializedFromReactNative;
+    lazy: (node: null | TSESTree.Node) => boolean;
+    lazyCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    memo: (node: null | TSESTree.Node) => boolean;
+    memoCall: (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
+    reactAPI: (api: string) => (node: null | TSESTree.Node) => boolean;
+    reactAPICall: (api: string) => (node: null | TSESTree.Node) => node is TSESTree.CallExpression;
     useActionStateCall: typeof core.isUseActionStateCall;
+    useCall: typeof core.isUseCall;
     useCallbackCall: typeof core.isUseCallbackCall;
     useContextCall: typeof core.isUseContextCall;
     useDebugValueCall: typeof core.isUseDebugValueCall;
     useDeferredValueCall: typeof core.isUseDeferredValueCall;
     useEffectCall: typeof core.isUseEffectCall;
+    useEffectCleanupCallback: typeof core.isUseEffectCleanupCallback;
+    useEffectLikeCall: typeof core.isUseEffectLikeCall;
+    useEffectSetupCallback: typeof core.isUseEffectSetupCallback;
     useFormStatusCall: typeof core.isUseFormStatusCall;
     useIdCall: typeof core.isUseIdCall;
     useImperativeHandleCall: typeof core.isUseImperativeHandleCall;
@@ -54,61 +100,15 @@ interface RuleToolkit {
     useReducerCall: typeof core.isUseReducerCall;
     useRefCall: typeof core.isUseRefCall;
     useStateCall: typeof core.isUseStateCall;
+    useStateLikeCall: typeof core.isUseStateLikeCall;
     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;
   };
   settings: ESLintReactSettingsNormalized;
 }
-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 function eslintReactKit(): KitBuilder;
 declare module "@typescript-eslint/utils/ts-eslint" {
-  interface RuleContext<MessageIds extends string, Options extends readonly unknown[]> {
+  interface RuleContext<MessageIds extends string = string, Options extends readonly unknown[] = readonly unknown[]> {
     report(descriptor: {
       readonly data?: Readonly<Record<string, unknown>>;
       readonly fix?: ((fixer: RuleFixer) => IterableIterator<RuleFix> | readonly RuleFix[] | RuleFix | null) | null;
@@ -124,4 +124,4 @@ declare module "@typescript-eslint/utils/ts-eslint" {
   }
 }
 //#endregion
-export { Collector, CollectorWithContext, type RuleContext, RuleToolkit, defineConfig as default, defineConfig, merge };
+export { Collector, CollectorWithContext, KitBuilder, RuleDefinition, type RuleFix, type RuleFixer, type RuleListener, eslintReactKit as default, merge };

package/dist/index.js

@@ -1,49 +1,90 @@
 import * as core from "@eslint-react/core";
-import { getSettingsFromContext } from "@eslint-react/shared";
+import { IdGenerator, defineRuleListener as merge, getSettingsFromContext } from "@eslint-react/shared";
+import { kebabCase } from "string-ts";
 
 //#region package.json
 var name = "@eslint-react/kit";
-var version = "4.0.0-beta.2";
+var version = "4.0.1-beta.0";
 
 //#endregion
 //#region src/index.ts
-function components(ctx, options) {
-	const { api, visitor } = core.getComponentCollector(ctx, options);
-	return {
-		query: { all: (program) => api.getAllComponents(program) },
-		visitor
-	};
-}
-function hooks(ctx) {
-	const { api, visitor } = core.getHookCollector(ctx);
-	return {
-		query: { all: (program) => api.getAllHooks(program) },
-		visitor
-	};
-}
 function createKit(ctx) {
 	return {
+		collect: {
+			components(ctx, options) {
+				const { api, visitor } = core.getComponentCollector(ctx, options);
+				return {
+					query: { all(program) {
+						return api.getAllComponents(program);
+					} },
+					visitor
+				};
+			},
+			hooks(ctx) {
+				const { api, visitor } = core.getHookCollector(ctx);
+				return {
+					query: { all(program) {
+						return api.getAllHooks(program);
+					} },
+					visitor
+				};
+			}
+		},
+		flag: { component: core.ComponentFlag },
+		hint: { component: {
+			...core.ComponentDetectionHint,
+			Default: core.DEFAULT_COMPONENT_DETECTION_HINT
+		} },
 		is: {
+			captureOwnerStack: core.isCaptureOwnerStack(ctx),
+			captureOwnerStackCall: core.isCaptureOwnerStackCall(ctx),
+			childrenCount: core.isChildrenCount(ctx),
+			childrenCountCall: core.isChildrenCountCall(ctx),
+			childrenForEach: core.isChildrenForEach(ctx),
+			childrenForEachCall: core.isChildrenForEachCall(ctx),
+			childrenMap: core.isChildrenMap(ctx),
+			childrenMapCall: core.isChildrenMapCall(ctx),
+			childrenOnly: core.isChildrenOnly(ctx),
+			childrenOnlyCall: core.isChildrenOnlyCall(ctx),
+			childrenToArray: core.isChildrenToArray(ctx),
+			childrenToArrayCall: core.isChildrenToArrayCall(ctx),
+			cloneElement: core.isCloneElement(ctx),
+			cloneElementCall: core.isCloneElementCall(ctx),
 			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),
+			componentWrapperCallLoose: (node) => core.isComponentWrapperCallLoose(ctx, node),
+			createContext: core.isCreateContext(ctx),
+			createContextCall: core.isCreateContextCall(ctx),
+			createElement: core.isCreateElement(ctx),
+			createElementCall: core.isCreateElementCall(ctx),
+			createRef: core.isCreateRef(ctx),
+			createRefCall: core.isCreateRefCall(ctx),
+			forwardRef: core.isForwardRef(ctx),
+			forwardRefCall: core.isForwardRefCall(ctx),
 			hook: core.isHook,
 			hookCall: core.isHookCall,
 			hookName: core.isHookName,
-			useEffectLikeCall: core.isUseEffectLikeCall,
-			useStateLikeCall: core.isUseStateLikeCall,
-			useEffectSetupCallback: core.isUseEffectSetupCallback,
-			useEffectCleanupCallback: core.isUseEffectCleanupCallback,
-			useCall: core.isUseCall,
+			initializedFromReact: core.isInitializedFromReact,
+			initializedFromReactNative: core.isInitializedFromReactNative,
+			lazy: core.isLazy(ctx),
+			lazyCall: core.isLazyCall(ctx),
+			memo: core.isMemo(ctx),
+			memoCall: core.isMemoCall(ctx),
+			reactAPI: (api) => core.isReactAPI(api)(ctx),
+			reactAPICall: (api) => core.isReactAPICall(api)(ctx),
 			useActionStateCall: core.isUseActionStateCall,
+			useCall: core.isUseCall,
 			useCallbackCall: core.isUseCallbackCall,
 			useContextCall: core.isUseContextCall,
 			useDebugValueCall: core.isUseDebugValueCall,
 			useDeferredValueCall: core.isUseDeferredValueCall,
 			useEffectCall: core.isUseEffectCall,
+			useEffectCleanupCallback: core.isUseEffectCleanupCallback,
+			useEffectLikeCall: core.isUseEffectLikeCall,
+			useEffectSetupCallback: core.isUseEffectSetupCallback,
 			useFormStatusCall: core.isUseFormStatusCall,
 			useIdCall: core.isUseIdCall,
 			useImperativeHandleCall: core.isUseImperativeHandleCall,
@@ -54,89 +95,55 @@ function createKit(ctx) {
 			useReducerCall: core.isUseReducerCall,
 			useRefCall: core.isUseRefCall,
 			useStateCall: core.isUseStateCall,
+			useStateLikeCall: core.isUseStateLikeCall,
 			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
+			useTransitionCall: core.isUseTransitionCall
 		},
 		settings: getSettingsFromContext(ctx)
 	};
 }
-function defineConfig(...rules) {
-	return {
-		files: ["**/*.ts", "**/*.tsx"],
-		plugins: { [name]: {
-			meta: {
-				name,
-				version
-			},
-			rules: rules.reduce((acc, { name, make }) => {
-				Reflect.set(acc, name, {
+function eslintReactKit() {
+	const idGen = new IdGenerator();
+	const rules = [];
+	const builder = {
+		getConfig({ files = ["**/*.ts", "**/*.tsx"] } = {}) {
+			return {
+				files,
+				plugins: { [name]: {
 					meta: {
-						fixable: "code",
-						hasSuggestions: true
+						name,
+						version
 					},
-					create(ctx) {
-						return make(ctx, createKit(ctx));
-					}
-				});
-				return acc;
-			}, {})
-		} },
-		rules: rules.reduce((acc, { name: name$1 }) => {
-			acc[`${name}/${name$1}`] = "error";
-			return acc;
-		}, {})
+					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;
+				}, {})
+			};
+		},
+		use(factory, ...args) {
+			const name = kebabCase(factory.name === "" ? idGen.next() : factory.name);
+			rules.push({
+				name,
+				make: factory(...args)
+			});
+			return builder;
+		}
 	};
-}
-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;
+	return builder;
 }
 
 //#endregion
-export { defineConfig as default, defineConfig, merge };
+export { eslintReactKit as default, merge };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/kit",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.1-beta.0",
   "description": "ESLint React's utility module for building custom rules.",
   "keywords": [
     "react",
@@ -37,13 +37,14 @@
   ],
   "dependencies": {
     "@typescript-eslint/utils": "^8.57.2",
-    "@eslint-react/ast": "4.0.0-beta.2",
-    "@eslint-react/shared": "4.0.0-beta.2",
-    "@eslint-react/core": "4.0.0-beta.2"
+    "string-ts": "^2.3.1",
+    "@eslint-react/core": "4.0.1-beta.0",
+    "@eslint-react/shared": "4.0.1-beta.0",
+    "@eslint-react/ast": "4.0.1-beta.0"
   },
   "devDependencies": {
     "eslint": "^10.1.0",
-    "tsdown": "^0.21.5",
+    "tsdown": "^0.21.6",
     "@local/configs": "0.0.0",
     "@local/eff": "3.0.0-beta.72"
   },