@eslint-react/kit 5.0.0-beta.0 → 5.0.1-beta.0

package/README.md

@@ -24,7 +24,7 @@ ESLint React's toolkit for building custom React rules with JavasSript functions
   - [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)
-  - [Override Config: Using spread syntax with `getConfig`](#Override-config-using-spread-syntax-with-getconfig)
+  - [Override Config: Using spread syntax with `getConfig`](#override-config-using-spread-syntax-with-getconfig)
   - [Advanced Config: Using `getPlugin` for custom plugin namespace](#advanced-config-using-getplugin-for-custom-plugin-namespace)
 - [More Examples](#more-examples)
 
@@ -102,7 +102,7 @@ import type { RuleFunction } from "@eslint-react/kit";
 type RuleFunction = (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).
+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 `RuleFunction`. The function name is automatically converted to kebab-case and used as the rule name under the `@eslint-react/kit` plugin namespace.
 
@@ -119,6 +119,75 @@ function forbidElements({ forbidden }: ForbidElementsOptions): RuleFunction {
 }
 ```
 
+#### Anonymous Rules
+
+When you use an **anonymous function** (arrow function without a name) with `.use()`, a random ULID is automatically generated as the rule name:
+
+```ts
+// Anonymous rule → random ULID name like "01KNE2WSJ8011D2HXE3A6H717C"
+// Registered as `@eslint-react/kit/01KNE2WSJ8011D2HXE3A6H717C`
+esslintReactKit().use(() => (context) => ({
+  JSXOpeningElement(node) {
+    // Critical check that cannot be easily disabled
+  },
+}));
+```
+
+> **Note:** The rule names are ULIDs generated randomly on each ESLint run. The examples above illustrate the format — actual values will differ every time.
+
+##### Characteristics of Anonymous Rules
+
+| Feature            | Description                                                                                                                                |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Random name**    | A unique ULID is generated for each rule on every lint run                                                                                 |
+| **Non-disablable** | Cannot be disabled via `{ rules: { <rule-name>: "off" } }` or `// eslint-disable-next-line <rule-name>` because the name changes each time |
+| **Use case**       | Critical checks that must never be bypassed                                                                                                |
+
+Anonymous rules are ideal for checks that are **critical to code quality or security** and should never be bypassed via disable comments:
+
+```ts
+// This critical security check cannot be easily disabled by developers
+eslintReactKit().use(() => (context, { is }) => ({
+  CallExpression(node) {
+    // Prevent dangerous API calls that could lead to XSS
+    if (is.createElement(node) && isUnsafeArguments(node.arguments)) {
+      context.report({
+        node,
+        message: "Potential XSS vulnerability detected. This issue must be fixed.",
+      });
+    }
+  },
+}));
+```
+
+**Note:** Since the rule name is random and changes on every ESLint run, developers cannot use standard rules configs or disable comments like:
+
+```ts
+// This will NOT work - the rule name is random!
+{ rules: { "01KNE2WSJ8011D2HXE3A6H717C": "off" } }
+
+// This will NOT work - the rule name is random!
+// eslint-disable-next-line 01KNE2WSJ8011D2HXE3A6H717C
+```
+
+To disable an anonymous rule, developers must modify the ESLint configuration file directly, which provides an audit trail for policy violations.
+
+##### Debugging Anonymous Rules
+
+For debugging purposes, you can [set a `displayName`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/displayName#setting_a_displayname) on an anonymous function. The display name will be used as a label in various places. This helps identify the rule, while the actual registered rule name remains a random ULID:
+
+```ts
+import { defineRule } from "@eslint-react/kit";
+
+const myRule = defineRule(() => (context) => ({}));
+
+myRule.displayName = "my-rule";
+
+eslintReactKit().use(myRule);
+```
+
+> **Note:** This feature is currently under development and may not be available in the current release.
+
 ### `Builder`
 
 ```ts
@@ -257,21 +326,6 @@ Factory functions (context pre-bound):
 | `API`     | `(apiName) -> (node) -> boolean` | Factory: creates a predicate for a React API identifier. (context pre-bound) |
 | `APICall` | `(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`
@@ -291,7 +345,6 @@ All React API predicates and factories have `context` pre-bound — no need to p
 
 ```ts
 // Direct check
-is.memo(node);
 is.memoCall(node);
 
 // Useful in filter/find
@@ -304,10 +357,10 @@ 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. |
+| Predicate            | Signature                                 | Description                                          |
+| -------------------- | ----------------------------------------- | ---------------------------------------------------- |
+| `APIFromReact`       | `(name, scope, importSource?) -> boolean` | Whether a variable comes from a React import.        |
+| `APIFromReactNative` | `(name, scope, importSource?) -> boolean` | Whether a variable comes from a React Native import. |
 
 ---
 

package/dist/index.d.ts

@@ -2362,41 +2362,28 @@ interface RuleToolkit {
   is: {
     API: (api: string) => (node: null | Node) => boolean;
     APICall: (api: string) => (node: null | Node) => node is CallExpression;
-    captureOwnerStack: (node: null | Node) => boolean;
+    APIFromReact: typeof core.isAPIFromReact;
+    APIFromReactNative: typeof core.isAPIFromReactNative;
     captureOwnerStackCall: (node: null | Node) => node is CallExpression;
-    childrenCount: (node: null | Node) => boolean;
     childrenCountCall: (node: null | Node) => node is CallExpression;
-    childrenForEach: (node: null | Node) => boolean;
     childrenForEachCall: (node: null | Node) => node is CallExpression;
-    childrenMap: (node: null | Node) => boolean;
     childrenMapCall: (node: null | Node) => node is CallExpression;
-    childrenOnly: (node: null | Node) => boolean;
     childrenOnlyCall: (node: null | Node) => node is CallExpression;
-    childrenToArray: (node: null | Node) => boolean;
     childrenToArrayCall: (node: null | Node) => node is CallExpression;
-    cloneElement: (node: null | Node) => boolean;
     cloneElementCall: (node: null | Node) => node is CallExpression;
     componentDecl: (node: TSESTreeFunction, hint: bigint) => boolean;
     componentName: typeof core.isFunctionComponentName;
     componentNameLoose: typeof core.isFunctionComponentNameLoose;
     componentWrapperCall: (node: Node) => boolean;
     componentWrapperCallback: (node: Node) => boolean;
-    createContext: (node: null | Node) => boolean;
     createContextCall: (node: null | Node) => node is CallExpression;
-    createElement: (node: null | Node) => boolean;
     createElementCall: (node: null | Node) => node is CallExpression;
-    createRef: (node: null | Node) => boolean;
     createRefCall: (node: null | Node) => node is CallExpression;
-    forwardRef: (node: null | Node) => boolean;
     forwardRefCall: (node: null | Node) => node is CallExpression;
     hookCall: typeof core.isHookCall;
     hookDecl: typeof core.isHookDefinition;
     hookName: typeof core.isHookName;
-    initializedFromReact: typeof core.isAPIFromReact;
-    initializedFromReactNative: typeof core.isAPIFromReactNative;
-    lazy: (node: null | Node) => boolean;
     lazyCall: (node: null | Node) => node is CallExpression;
-    memo: (node: null | Node) => boolean;
     memoCall: (node: null | Node) => node is CallExpression;
     useActionStateCall: (node: null | Node) => node is CallExpression;
     useCall: (node: null | Node) => node is CallExpression;
@@ -2425,10 +2412,6 @@ interface RuleToolkit {
   settings: ESLintReactSettingsNormalized;
 }
 type RuleFunction = (context: RuleContext, toolkit: RuleToolkit) => RuleListener;
-/**
- * @deprecated Use `RuleFunction` instead.
- */
-type RuleDefinition = RuleFunction;
 interface Builder {
   getConfig(): Linter.Config;
   getPlugin(): ESLint.Plugin;
@@ -2452,4 +2435,4 @@ declare module "@typescript-eslint/utils/ts-eslint" {
   }
 }
 //#endregion
-export { Builder, Collector, CollectorWithContext, RuleDefinition, type RuleFix, type RuleFixer, RuleFunction, type RuleListener, build as default, merge };
+export { Builder, Collector, CollectorWithContext, type RuleFix, type RuleFixer, RuleFunction, type RuleListener, build as default, merge };

package/dist/index.js

@@ -1,10 +1,11 @@
 import * as core from "@eslint-react/core";
-import { IdGenerator, defineRuleListener as merge, getSettingsFromContext } from "@eslint-react/shared";
+import { defineRuleListener as merge, getSettingsFromContext } from "@eslint-react/shared";
 import { kebabCase } from "string-ts";
+import { ulid } from "ulid";
 
 //#region package.json
 var name = "@eslint-react/kit";
-var version = "5.0.0-beta.0";
+var version = "5.0.1-beta.0";
 
 //#endregion
 //#region src/index.ts
@@ -38,41 +39,28 @@ function makeRuleToolkit(context) {
 		is: {
 			API: (api) => core.isAPI(api)(context),
 			APICall: (api) => core.isAPICall(api)(context),
-			captureOwnerStack: core.isCaptureOwnerStack(context),
+			APIFromReact: core.isAPIFromReact,
+			APIFromReactNative: core.isAPIFromReactNative,
 			captureOwnerStackCall: core.isCaptureOwnerStackCall(context),
-			childrenCount: core.isChildrenCount(context),
 			childrenCountCall: core.isChildrenCountCall(context),
-			childrenForEach: core.isChildrenForEach(context),
 			childrenForEachCall: core.isChildrenForEachCall(context),
-			childrenMap: core.isChildrenMap(context),
 			childrenMapCall: core.isChildrenMapCall(context),
-			childrenOnly: core.isChildrenOnly(context),
 			childrenOnlyCall: core.isChildrenOnlyCall(context),
-			childrenToArray: core.isChildrenToArray(context),
 			childrenToArrayCall: core.isChildrenToArrayCall(context),
-			cloneElement: core.isCloneElement(context),
 			cloneElementCall: core.isCloneElementCall(context),
 			componentDecl: (node, hint) => core.isFunctionComponentDefinition(context, node, hint),
 			componentName: core.isFunctionComponentName,
 			componentNameLoose: core.isFunctionComponentNameLoose,
 			componentWrapperCall: (node) => core.isFunctionComponentWrapperCall(context, node),
 			componentWrapperCallback: (node) => core.isFunctionComponentWrapperCallback(context, node),
-			createContext: core.isCreateContext(context),
 			createContextCall: core.isCreateContextCall(context),
-			createElement: core.isCreateElement(context),
 			createElementCall: core.isCreateElementCall(context),
-			createRef: core.isCreateRef(context),
 			createRefCall: core.isCreateRefCall(context),
-			forwardRef: core.isForwardRef(context),
 			forwardRefCall: core.isForwardRefCall(context),
 			hookCall: core.isHookCall,
 			hookDecl: core.isHookDefinition,
 			hookName: core.isHookName,
-			initializedFromReact: core.isAPIFromReact,
-			initializedFromReactNative: core.isAPIFromReactNative,
-			lazy: core.isLazy(context),
 			lazyCall: core.isLazyCall(context),
-			memo: core.isMemo(context),
 			memoCall: core.isMemoCall(context),
 			useActionStateCall: core.isUseActionStateCall(context),
 			useCall: core.isUseCall(context),
@@ -102,7 +90,6 @@ function makeRuleToolkit(context) {
 	};
 }
 function build() {
-	const idGen = new IdGenerator();
 	const rules = {};
 	const builder = {
 		getConfig() {
@@ -126,7 +113,7 @@ function build() {
 			};
 		},
 		use(make, ...args) {
-			const name = kebabCase(make.name === "" ? idGen.next() : make.name);
+			const name = make.name === "" ? ulid() : kebabCase(make.name);
 			Reflect.set(rules, name, {
 				meta: {
 					fixable: "code",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/kit",
-  "version": "5.0.0-beta.0",
+  "version": "5.0.1-beta.0",
   "description": "ESLint React's utility module for building custom React rules with JavasSript functions.",
   "keywords": [
     "react",
@@ -38,9 +38,10 @@
   "dependencies": {
     "@typescript-eslint/utils": "^8.58.0",
     "string-ts": "^2.3.1",
-    "@eslint-react/ast": "5.0.0-beta.0",
-    "@eslint-react/core": "5.0.0-beta.0",
-    "@eslint-react/shared": "5.0.0-beta.0"
+    "ulid": "^3.0.2",
+    "@eslint-react/ast": "5.0.1-beta.0",
+    "@eslint-react/shared": "5.0.1-beta.0",
+    "@eslint-react/core": "5.0.1-beta.0"
   },
   "devDependencies": {
     "eslint": "^10.2.0",