@eslint-react/shared 5.24.0 → 5.24.2

package/dist/index.d.ts

@@ -166,6 +166,20 @@ export declare const normalizeSettings: ({ importSource, compilationMode, polymo
  * @returns The detected React version or the fallback version.
  */
 export declare function getReactVersion(fallback: string): string;
+/**
+ * Get the normalized ESLint React settings, memoized by the input settings object.
+ * @param settings The ESLint React settings to decode and normalize.
+ * @returns The normalized ESLint React settings.
+ */
+export declare const getNormalizedSettings: (ast: object) => {
+  readonly importSource: string;
+  readonly compilationMode: "infer" | "annotation" | "syntax" | "all" | "off";
+  readonly polymorphicPropName: string;
+  readonly version: string;
+  readonly additionalRefHooks: RegExpLike;
+  readonly additionalStateHooks: RegExpLike;
+  readonly additionalEffectHooks: RegExpLike;
+};
 /**
  * Get the normalized ESLint React settings from the rule context.
  * @param context The rule context.

package/dist/index.js

@@ -4,44 +4,6 @@ import { P, match } from "ts-pattern";
 import { z } from "zod/v4";
 
 //#region ../../.pkgs/eff/dist/index.js
-/**
-* Applies a `pipe` method's variadic arguments to an initial value from left
-* to right.
-*
-* **When to use**
-*
-* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
-* object.
-*
-* **Details**
-*
-* This helper is intended for implementing `Pipeable.pipe` methods that
-* receive JavaScript's `arguments` object. With no functions it returns the
-* original value; otherwise it feeds each result into the next function.
-*
-* **Example** (Implementing a pipe method)
-*
-* ```ts
-* import { Pipeable } from "effect"
-*
-* class NumberBox {
-*   constructor(readonly value: number) {}
-*
-*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
-*     return Pipeable.pipeArguments(this.value, arguments) as number
-*   }
-* }
-*
-* const result = new NumberBox(5).pipe(
-*   (n) => n + 2,
-*   (n) => n * 3
-* )
-* console.log(result) // 21
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const pipeArguments = (self, args) => {
 	switch (args.length) {
 		case 0: return self;
@@ -61,110 +23,14 @@ const pipeArguments = (self, args) => {
 		}
 	}
 };
-/**
-* Reusable prototype that implements `Pipeable.pipe`.
-*
-* **When to use**
-*
-* Use when classes or object prototypes can reuse this value when they need the
-* standard pipe implementation backed by `pipeArguments`.
-*
-* @category prototypes
-* @since 3.15.0
-*/
 const Prototype = { pipe() {
 	return pipeArguments(this, arguments);
 } };
-/**
-* Provides a base constructor whose instances implement the standard `Pipeable.pipe`
-* method.
-*
-* **When to use**
-*
-* Use when you need to define a class that supports Effect-style method
-* chaining through `.pipe(...)`.
-*
-* @category constructors
-* @since 3.15.0
-*/
 const Class = (function() {
 	function PipeableBase() {}
 	PipeableBase.prototype = Prototype;
 	return PipeableBase;
 })();
-/**
-* Provides small helpers for defining and reusing TypeScript functions.
-*
-* The main helpers are `pipe` and `flow` for left-to-right composition and
-* `dual` for APIs that support both direct and pipe-friendly call styles. The
-* module also contains small identity, constant, tuple, type-level, and
-* memoization helpers used across the library.
-*
-* @since 2.0.0
-*/
-/**
-* Creates a function that can be called in data-first style or data-last
-* (`pipe`-friendly) style.
-*
-* **When to use**
-*
-* Use to expose one implementation through both direct and `pipe`-friendly
-* call styles.
-*
-* **Details**
-*
-* Pass either the arity of the uncurried function or a predicate that decides
-* whether the current call is data-first. Arity is the common case. Use a
-* predicate when optional arguments make arity ambiguous.
-*
-* **Example** (Selecting data-first or data-last style by arity)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Defining overloads with call signatures)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = Function.dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Selecting data-first or data-last style with a predicate)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const dual = function(arity, body) {
 	if (typeof arity === "function") return function() {
 		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
@@ -193,466 +59,124 @@ const dual = function(arity, body) {
 		};
 	}
 };
-/**
-* Returns its input argument unchanged.
-*
-* **When to use**
-*
-* Use to return a value unchanged where a function is required.
-*
-* **Example** (Returning the same value)
-*
-* ```ts
-* import { identity } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(identity(5), 5)
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
 const identity = (a) => a;
-/**
-* Returns the input value with a different static type.
-*
-* **When to use**
-*
-* Use when you need an explicit type-level cast and accept that the value is
-* returned unchanged at runtime.
-*
-* **Gotchas**
-*
-* This is a type-level cast only; it performs no runtime validation or
-* conversion.
-*
-* @see {@link satisfies} for checking assignability without changing the resulting type
-*
-* @category utility types
-* @since 4.0.0
-*/
 const cast = identity;
-/**
-* Creates a zero-argument function that always returns the provided value.
-*
-* **When to use**
-*
-* Use when you need a thunk or callback that returns the same value on every
-* invocation.
-*
-* **Example** (Creating a constant thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* const constNull = Function.constant(null)
-*
-* assert.deepStrictEqual(constNull(), null)
-* assert.deepStrictEqual(constNull(), null)
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
 const constant = (value) => () => value;
-/**
-* Returns `true` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `true` on every invocation.
-*
-* **Example** (Returning true from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constTrue(), true)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constTrue = constant(true);
-/**
-* Returns `false` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `false` on every invocation.
-*
-* **Example** (Returning false from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constFalse(), false)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constFalse = constant(false);
-/**
-* Returns `null` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `null` on every invocation.
-*
-* **Example** (Returning null from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constNull(), null)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constNull = constant(null);
-/**
-* Returns `undefined` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `undefined` on every invocation.
-*
-* **Example** (Returning undefined from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constUndefined(), undefined)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
 const constUndefined = constant(void 0);
-/**
-* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
-* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
-*
-* **When to use**
-*
-* Use to compose exactly two unary functions into a reusable unary function.
-*
-* **Example** (Composing two functions)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* const increment = (n: number) => n + 1
-* const square = (n: number) => n * n
-*
-* assert.strictEqual(Function.compose(increment, square)(2), 9)
-* ```
-*
-* @see {@link flow} for composing a left-to-right sequence of functions
-* @see {@link pipe} for applying a value through a left-to-right sequence immediately
-*
-* @category combinators
-* @since 2.0.0
-*/
 const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-/**
-* Marks an impossible branch by accepting a `never` value and returning any
-* type.
-*
-* **When to use**
-*
-* Use when you need a return value in a branch that exhaustive checks prove
-* cannot be reached.
-*
-* **Gotchas**
-*
-* Calling `absurd` throws, because a value of type `never` should be
-* impossible at runtime.
-*
-* **Example** (Handling impossible values)
-*
-* ```ts
-* import { absurd } from "effect"
-*
-* const handleNever = (value: never) => {
-*   return absurd(value) // This will throw an error if called
-* }
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
 const absurd = (_) => {
 	throw new Error("Called `absurd` function which should be uncallable");
 };
-/**
-* Creates a compile-time placeholder for a value of any type.
-*
-* **When to use**
-*
-* Use as a temporary typed placeholder while developing incomplete code.
-*
-* **Gotchas**
-*
-* `hole` is intended for temporary development use. If the placeholder is
-* evaluated at runtime, it throws.
-*
-* **Example** (Creating a development placeholder)
-*
-* ```ts
-* import { hole } from "effect"
-*
-* // Intentionally not called: `hole` throws if the placeholder is evaluated.
-* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
-*   id,
-*   name: hole<string>()
-* })
-*
-* console.log(typeof buildUser) // "function"
-* ```
-*
-* @category utility types
-* @since 2.0.0
-*/
 const hole = cast(absurd);
-function getOrInsertComputed(map, key, callback) {
-	if (map.has(key)) return map.get(key);
-	const value = callback(key);
-	map.set(key, value);
-	return value;
+function memoize(f) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (a) => {
+		const cached = cache.get(a);
+		if (cached !== void 0) return cached;
+		const result = f(a);
+		cache.set(a, result);
+		return result;
+	};
+}
+const and = dual(2, (a, b) => (data) => a(data) && b(data));
+const or = dual(2, (a, b) => (data) => a(data) || b(data));
+const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
+const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
+const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
+const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
+const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
+function isFunction(input) {
+	return typeof input === "function";
+}
+function isObjectKeyword(input) {
+	return typeof input === "object" && input !== null || isFunction(input);
 }
-/**
-* Drops the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array without the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { dropWhile, pipe } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
-*
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
-* ```
-* @category array
-*/
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
+const dropWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(idx);
 });
-/**
-* Takes the longest prefix of elements from an array that satisfy the given predicate.
-*
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
-*
-* @param pred - The predicate to test each element with.
-* @returns A new array containing only the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { pipe, takeWhile } from "@local/eff"
-*
-* // data-first
-* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
-*
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
-* ```
-* @category array
-*/
-const takeWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+const takeWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(0, idx);
 });
 
 //#endregion
 //#region src/regexp.ts
-/** Regular expression for matching an 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;
-/**
-* Regular expression for matching the `javascript:` protocol.
-* @see https://github.com/facebook/react/blob/6db7f4209e6f32ebde298a0b7451710dd6aa3e19/packages/react-dom-bindings/src/shared/sanitizeURL.js#L22
-*/
 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;
-/**
-* Convert a string to a `RegExpLike` object.
-*
-* Normal strings (ex: `"foo"`) are converted to `/^foo$/`.
-* RegExp strings (ex: `"/^foo/i"`) are converted to `/^foo/i`.
-* @param string The string to convert.
-* @returns The converted `RegExpLike` object.
-* @see https://github.com/sveltejs/eslint-plugin-svelte/blob/main/packages/eslint-plugin-svelte/src/utils/regexp.ts
-*/
 function toRegExp(string) {
 	if (string == null) return { test: constFalse };
 	const [, pattern, flags = "u"] = RE_REGEXP_STR.exec(string) ?? [];
 	if (pattern != null) return new RegExp(pattern, flags);
 	return { test: (s) => s === string };
 }
-/**
-* Check if the string is a RegExp string.
-* @param string The string to check.
-* @returns `true` if the string is a RegExp string.
-*/
 function isRegExp(string) {
 	return RE_REGEXP_STR.test(string);
 }
 
 //#endregion
 //#region src/settings.ts
-/**
-* The zod schema for the ESLint React settings.
-* @internal
-*/
 const ESLintReactSettingsSchema = z.object({
-	/**
-	* The source where React is imported from.
-	* Allows specifying a custom import location for React.
-	* @default "react"
-	* @example "@pika/react"
-	*/
 	importSource: z.optional(z.string()),
-	/**
-	* The React Compiler compilationMode that the project is using.
-	* Used to inform the rule about how components and hooks will be picked up by the compiler.
-	* @example "infer"
-	*/
 	compilationMode: z.optional(z.enum([
 		"infer",
 		"annotation",
 		"syntax",
 		"all"
 	])),
-	/**
-	* The prop name used for polymorphic components.
-	* Used to determine the component's type.
-	* @example "as"
-	*/
 	polymorphicPropName: z.optional(z.string()),
-	/**
-	* React version to use.
-	* "detect" means auto-detect React version from project dependencies.
-	* @example "18.3.1"
-	* @default "detect"
-	*/
 	version: z.optional(z.string()),
-	/**
-	* Regex pattern matching custom hooks that should be treated as ref hooks.
-	* @example "useMyRef|useCustomRef"
-	*/
 	additionalRefHooks: z.optional(z.string()),
-	/**
-	* Regex pattern matching custom hooks that should be treated as state hooks.
-	* @example "useMyState|useCustomState"
-	*/
 	additionalStateHooks: z.optional(z.string()),
-	/**
-	* Regex pattern matching custom hooks that should be treated as effect hooks.
-	* @example "useMyEffect|useCustomEffect"
-	*/
 	additionalEffectHooks: z.optional(z.string())
 });
-/**
-* The zod schema for the ESLint settings.
-* @internal
-*/
 const ESLintSettingsSchema = z.optional(z.object({ "react-x": z.optional(z.unknown()) }));
-/** The default ESLint React settings. */
 const DEFAULT_ESLINT_REACT_SETTINGS = {
 	version: "detect",
 	importSource: "react",
 	polymorphicPropName: "as"
 };
-/** The default ESLint settings. */
 const DEFAULT_ESLINT_SETTINGS = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
-/**
-* Check if the value is valid ESLint settings.
-* @param settings The value to check.
-* @returns `true` if the value is valid ESLint settings.
-*/
 function isESLintSettings(settings) {
 	return ESLintSettingsSchema.safeParse(settings).success;
 }
-/**
-* Check if the value is valid ESLint React settings.
-* @param settings The value to check.
-* @returns `true` if the value is valid ESLint React settings.
-*/
 function isESLintReactSettings(settings) {
 	return ESLintReactSettingsSchema.safeParse(settings).success;
 }
-/**
-* Decode the ESLint settings, falling back to the defaults when invalid.
-* @param settings The value to decode.
-* @returns The decoded ESLint settings.
-*/
 const decodeESLintSettings = (settings) => {
 	if (isESLintSettings(settings)) return settings;
 	return DEFAULT_ESLINT_SETTINGS;
 };
-/**
-* Decode the ESLint React settings, falling back to the defaults when invalid.
-* @param settings The value to decode.
-* @returns The decoded ESLint React settings.
-*/
 const decodeSettings = (settings) => {
 	if (isESLintReactSettings(settings)) return settings;
 	return DEFAULT_ESLINT_REACT_SETTINGS;
 };
-/**
-* Normalize the ESLint React settings to the form used by rules.
-* @param settings The ESLint React settings to normalize.
-* @returns The normalized ESLint React settings.
-*/
 const normalizeSettings = ({ importSource = "react", compilationMode, polymorphicPropName = "as", version, additionalRefHooks, additionalStateHooks, additionalEffectHooks, ...rest }) => {
 	return {
 		...rest,
@@ -665,12 +189,6 @@ const normalizeSettings = ({ importSource = "react", compilationMode, polymorphi
 		additionalEffectHooks: toRegExp(additionalEffectHooks)
 	};
 };
-const cache = /* @__PURE__ */ new Map();
-/**
-* Get the React version from the project's dependencies.
-* @param fallback The fallback version to return if React is not found.
-* @returns The detected React version or the fallback version.
-*/
 function getReactVersion(fallback) {
 	try {
 		return match(module.createRequire(process.cwd() + path.sep)("react")).with({ version: P.select(P.string) }, identity).otherwise(() => fallback);
@@ -678,15 +196,11 @@ function getReactVersion(fallback) {
 		return fallback;
 	}
 }
-/**
-* Get the normalized ESLint React settings from the rule context.
-* @param context The rule context.
-* @returns The normalized ESLint React settings.
-*/
+const getNormalizedSettings = memoize((settings) => normalizeSettings(decodeSettings(settings)));
 function getSettingsFromContext(context) {
 	const settings = context.settings["react-x"];
-	return getOrInsertComputed(cache, settings, () => normalizeSettings(decodeSettings(settings)));
+	return getNormalizedSettings(isObjectKeyword(settings) ? settings : DEFAULT_ESLINT_REACT_SETTINGS);
 }
 
 //#endregion
-export { DEFAULT_ESLINT_REACT_SETTINGS, DEFAULT_ESLINT_SETTINGS, ESLintReactSettingsSchema, ESLintSettingsSchema, 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, decodeESLintSettings, decodeSettings, getReactVersion, getSettingsFromContext, isESLintReactSettings, isESLintSettings, isRegExp, normalizeSettings, toRegExp };
+export { DEFAULT_ESLINT_REACT_SETTINGS, DEFAULT_ESLINT_SETTINGS, ESLintReactSettingsSchema, ESLintSettingsSchema, 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, decodeESLintSettings, decodeSettings, getNormalizedSettings, getReactVersion, getSettingsFromContext, isESLintReactSettings, isESLintSettings, isRegExp, normalizeSettings, toRegExp };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/shared",
-  "version": "5.24.0",
+  "version": "5.24.2",
   "description": "ESLint React's Shared constants and functions.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/eslint": "5.24.0",
+    "@eslint-react/eslint": "5.24.2",
     "@typescript-eslint/utils": "^8.71.0",
     "ts-pattern": "^5.9.0",
     "zod": "^3.25.0 || ^4.0.0"
@@ -40,7 +40,8 @@
     "@tsconfig/node24": "^24.0.5",
     "@types/node": "^26.6.4",
     "@types/picomatch": "^4.0.3",
-    "eslint": "^10.11.0",
+    "eslint": "^10.12.0",
+    "tinybench": "6.1.4",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3"
   },
@@ -63,6 +64,7 @@
     "@local/eff": "workspace:*"
   },
   "scripts": {
+    "bench": "nub ./benchmarks/settings.bench.ts",
     "build": "tsdown",
     "build:docs": "typedoc",
     "lint:publish": "publint",