@eslint-react/core 5.16.1 → 5.17.1

package/dist/index.js

@@ -9,28 +9,124 @@ import { P, isMatching, match } from "ts-pattern";
 
 //#region ../../.pkgs/eff/dist/index.js
 /**
-* Creates a function that can be used in a data-last (aka `pipe`able) or
-* data-first style.
+* Applies a `pipe` method's variadic arguments to an initial value from left
+* to right.
 *
-* The first parameter to `dual` is either the arity of the uncurried function
-* or a predicate that determines if the function is being used in a data-first
-* or data-last style.
+* **When to use**
 *
-* Using the arity is the most common use case, but there are some cases where
-* you may want to use a predicate. For example, if you have a function that
-* takes an optional argument, you can use a predicate to determine if the
-* function is being used in a data-first or data-last style.
+* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
+* object.
 *
-* You can pass either the arity of the uncurried function or a predicate
-* which determines if the function is being used in a data-first or
-* data-last style.
+* **Details**
 *
-* **Example** (Using arity to determine data-first or data-last style)
+* 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 { dual, pipe } from "effect/Function"
+* 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;
+		case 1: return args[0](self);
+		case 2: return args[1](args[0](self));
+		case 3: return args[2](args[1](args[0](self)));
+		case 4: return args[3](args[2](args[1](args[0](self))));
+		case 5: return args[4](args[3](args[2](args[1](args[0](self)))));
+		case 6: return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+		case 7: return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+		case 8: return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+		case 9: return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+		default: {
+			let ret = self;
+			for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret);
+			return ret;
+		}
+	}
+};
+/**
+* Reusable prototype that implements `Pipeable.pipe`.
+*
+* **When to use**
 *
-* const sum = dual<
+* 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)
@@ -39,26 +135,26 @@ import { P, isMatching, match } from "ts-pattern";
 * console.log(pipe(2, sum(3))) // 5
 * ```
 *
-* **Example** (Using call signatures to define the overloads)
+* **Example** (Defining overloads with call signatures)
 *
 * ```ts
-* import { dual, pipe } from "effect/Function"
+* import { Function, pipe } from "effect"
 *
 * const sum: {
 *   (that: number): (self: number) => number
 *   (self: number, that: number): number
-* } = dual(2, (self: number, that: number): number => self + that)
+* } = Function.dual(2, (self: number, that: number): number => self + that)
 *
 * console.log(sum(2, 3)) // 5
 * console.log(pipe(2, sum(3))) // 5
 * ```
 *
-* **Example** (Using a predicate to determine data-first or data-last style)
+* **Example** (Selecting data-first or data-last style with a predicate)
 *
 * ```ts
-* import { dual, pipe } from "effect/Function"
+* import { Function, pipe } from "effect"
 *
-* const sum = dual<
+* const sum = Function.dual<
 *   (that: number) => (self: number) => number,
 *   (self: number, that: number) => number
 * >(
@@ -70,9 +166,8 @@ import { P, isMatching, match } from "ts-pattern";
 * console.log(pipe(2, sum(3))) // 5
 * ```
 *
-* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
-* @param body - The function to be curried.
-* @since 1.0.0
+* @category combinators
+* @since 2.0.0
 */
 const dual = function(arity, body) {
 	if (typeof arity === "function") return function() {
@@ -103,41 +198,294 @@ const dual = function(arity, body) {
 	}
 };
 /**
-* Do nothing and return `false`.
+* 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"
 *
-* @returns false
+* assert.deepStrictEqual(identity(5), 5)
+* ```
+*
+* @category combinators
+* @since 2.0.0
 */
-function constFalse() {
-	return false;
-}
+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`.
 *
-* @param self - The first function to apply (or the composed function in data-last style).
-* @param bc - The second function to apply.
-* @returns A composed function that applies both functions in sequence.
-* @example
+* **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"
-* import { compose } from "effect/Function"
 *
-* const increment = (n: number) => n + 1;
-* const square = (n: number) => n * n;
+* const increment = (n: number) => n + 1
+* const square = (n: number) => n * n
 *
-* assert.strictEqual(compose(increment, square)(2), 9);
+* assert.strictEqual(Function.compose(increment, square)(2), 9)
 * ```
 *
-* @since 1.0.0
+* @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);
+/**
+* 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;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.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;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.slice(0, idx);
+});
 
 //#endregion
 //#region src/api.ts
 /**
-* Check if the node is a React API identifier or member expression
-* @param api The React API name to check against (ex: "useState", "React.memo")
-* @returns A predicate function to check if a node matches the API
+* Check if the node is a React API identifier or member expression.
+* @param api The React API name to check against (ex: "useState", "React.memo").
+* @returns A predicate function to check if a node matches the API.
 */
 function isAPI(api) {
 	const func = (context, node) => {
@@ -152,9 +500,9 @@ function isAPI(api) {
 	return dual(2, func);
 }
 /**
-* Check if the node is a call expression to a specific React API
-* @param api The React API name to check against
-* @returns A predicate function to check if a node is a call to the API
+* Check if the node is a call expression to a specific React API.
+* @param api The React API name to check against.
+* @returns A predicate function to check if a node is a call to the API.
 */
 function isAPICall(api) {
 	const func = (context, node) => {
@@ -232,9 +580,9 @@ const isUseTransitionCall = isAPICall("useTransition");
 //#endregion
 //#region src/class.ts
 /**
-* Get the class identifier of a class node
-* @param node The class node to get the identifier from
-* @returns The class identifier or null if not found
+* Get the class identifier of a class node.
+* @param node The class node to get the identifier from.
+* @returns The class identifier or null if not found.
 */
 function getClassId(node) {
 	if (node.id != null) return node.id;
@@ -393,7 +741,7 @@ function getClassComponentCollector(context) {
 *
 * Ported from {@link https://github.com/facebook/react/blob/bb8a76c6cc77ea2976d690ea09f5a1b3d9b1792a/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts#L860 | RulesOfHooks.ts}
 *
-* @param node - The function node to analyze.
+* @param node The function node to analyze.
 * @returns The identifier node if found, `null` otherwise.
 */
 function getFunctionId(node) {
@@ -412,7 +760,7 @@ function getFunctionId(node) {
 /**
 * Identifies the initialization path of a function node in the AST.
 *
-* @param node - The function node to analyze.
+* @param node The function node to analyze.
 * @returns The function initialization path or `null` if not identifiable.
 */
 function getFunctionInitPath(node) {
@@ -463,8 +811,8 @@ function getFunctionInitPath(node) {
 /**
 * Checks if a specific function call exists in the function initialization path.
 *
-* @param callName - The name of the call to check for (e.g., "memo", "forwardRef").
-* @param initPath - The function initialization path to search in.
+* @param callName The name of the call to check for (e.g., "memo", "forwardRef").
+* @param initPath The function initialization path to search in.
 * @returns `true` if the call exists in the path, `false` otherwise.
 */
 function isFunctionHasCallInInitPath(callName, initPath) {
@@ -479,7 +827,7 @@ function isFunctionHasCallInInitPath(callName, initPath) {
 /**
 * Checks if a function is empty.
 *
-* @param node - The function node to check.
+* @param node The function node to check.
 * @returns `true` if the function is empty, `false` otherwise.
 */
 function isFunctionEmpty(node) {
@@ -500,8 +848,8 @@ function getFunctionDirectives(node) {
 /**
 * Checks if a directive with the given name exists in the function directives.
 *
-* @param node - The function AST node.
-* @param name - The directive name to check (e.g., "use memo", "use no memo").
+* @param node The function AST node.
+* @param name The directive name to check (e.g., "use memo", "use no memo").
 * @returns `true` if the directive exists, `false` otherwise.
 */
 function isFunctionHasDirective(node, name) {
@@ -517,24 +865,24 @@ const SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT = [
 //#endregion
 //#region src/function-component.ts
 /**
-* Component flag constants
+* Component flag constants.
 */
 const FunctionComponentFlag = {
-	/** No flags set */
+	/** No flags set. */
 	None: 0n,
-	/** Indicates the component is a pure component (ex: extends PureComponent) */
+	/** Indicates the component is a pure component (ex: extends PureComponent). */
 	PureComponent: 1n << 0n,
-	/** Indicates the component creates elements using `createElement` instead of JSX */
+	/** Indicates the component creates elements using `createElement` instead of JSX. */
 	CreateElement: 1n << 1n,
-	/** Indicates the component is memoized (ex: React.memo) */
+	/** Indicates the component is memoized (ex: React.memo). */
 	Memo: 1n << 2n,
-	/** Indicates the component forwards a ref (ex: React.forwardRef) */
+	/** Indicates the component forwards a ref (ex: React.forwardRef). */
 	ForwardRef: 1n << 3n
 };
 /**
-* Get component flag from init path
-* @param initPath The init path of the function component
-* @returns The component flag
+* Get component flag from init path.
+* @param initPath The init path of the function component.
+* @returns The component flag.
 * @internal
 */
 function getFunctionComponentFlagFromInitPath(initPath) {
@@ -544,20 +892,20 @@ function getFunctionComponentFlagFromInitPath(initPath) {
 	return flag;
 }
 /**
-* Check if the node is a call expression for a component wrapper
-* @param context The ESLint rule context
-* @param node The node to check
-* @returns `true` if the node is a call expression for a component wrapper
+* Check if the node is a call expression for a component wrapper.
+* @param context The ESLint rule context.
+* @param node The node to check.
+* @returns `true` if the node is a call expression for a component wrapper.
 */
 function isFunctionComponentWrapperCall(context, node) {
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
 	return isMemoCall(context, node) || isForwardRefCall(context, node);
 }
 /**
-* Check if the node is a callback function passed to a component wrapper
-* @param context The ESLint rule context
-* @param node The node to check
-* @returns `true` if the node is a callback function passed to a component wrapper
+* Check if the node is a callback function passed to a component wrapper.
+* @param context The ESLint rule context.
+* @param node The node to check.
+* @returns `true` if the node is a callback function passed to a component wrapper.
 */
 function isFunctionComponentWrapperCallback(context, node) {
 	if (!Check.isFunction(node)) return false;
@@ -567,9 +915,9 @@ function isFunctionComponentWrapperCallback(context, node) {
 	return isFunctionComponentWrapperCall(context, parent);
 }
 /**
-* Get function component identifier from `const Component = memo(() => {});`
-* @param context The rule context
-* @param node The AST node to get the function component identifier from
+* Get function component identifier from `const Component = memo(() => {});`.
+* @param context The rule context.
+* @param node The AST node to get the function component identifier from.
 * @internal
 */
 function getFunctionComponentId(context, node) {
@@ -584,25 +932,25 @@ function getFunctionComponentId(context, node) {
 	}
 }
 /**
-* Check if a string matches the strict component name pattern
-* @param name The name to check
+* Check if a string matches the strict component name pattern.
+* @param name The name to check.
 */
 function isFunctionComponentName(name) {
 	return RE_COMPONENT_NAME.test(name);
 }
 /**
-* Check if a string matches the loose component name pattern
-* @param name The name to check
+* Check if a string matches the loose component name pattern.
+* @param name The name to check.
 */
 function isFunctionComponentNameLoose(name) {
 	return RE_COMPONENT_NAME_LOOSE.test(name);
 }
 /**
-* Check if a function has a loose component name
-* @param context The rule context
-* @param fn The function to check
-* @param allowNone Whether to allow no name
-* @returns Whether the function has a loose component name
+* Check if a function has a loose component name.
+* @param context The rule context.
+* @param fn The function to check.
+* @param allowNone Whether to allow no name.
+* @returns Whether the function has a loose component name.
 */
 function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
 	const id = getFunctionComponentId(context, fn);
@@ -612,7 +960,7 @@ function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
 	return false;
 }
 /**
-* Hints for component collector
+* Hints for component collector.
 */
 const FunctionComponentDetectionHint = {
 	...JsxDetectionHint,
@@ -626,16 +974,16 @@ const FunctionComponentDetectionHint = {
 	DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback: 1n << 18n
 };
 /**
-* Default component detection hint
+* Default component detection hint.
 */
 const DEFAULT_COMPONENT_DETECTION_HINT = 0n | FunctionComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithNumberValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithStringValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement | FunctionComponentDetectionHint.RequireAllArrayElementsToBeJsx | FunctionComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | FunctionComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
 /**
-* Determine if a function node represents a valid React component definition
+* Determine if a function node represents a valid React component definition.
 *
-* @param context The rule context
-* @param node The function node to analyze
-* @param hint Component detection hints (bit flags) to customize detection logic
-* @returns `true` if the node is considered a component definition
+* @param context The rule context.
+* @param node The function node to analyze.
+* @param hint Component detection hints (bit flags) to customize detection logic.
+* @returns `true` if the node is considered a component definition.
 */
 function isFunctionComponentDefinition(context, node, hint) {
 	if (!isFunctionWithLooseComponentName(context, node, true)) return false;
@@ -724,9 +1072,9 @@ function isHookName(name) {
 	return name === "use" || /^use[A-Z0-9]/.test(name);
 }
 /**
-* Checks if the given node is a hook identifier
-* @param id The AST node to check
-* @returns `true` if the node is a hook identifier or member expression with hook name, `false` otherwise
+* Checks if the given node is a hook identifier.
+* @param id The AST node to check.
+* @returns `true` if the node is a hook identifier or member expression with hook name, `false` otherwise.
 */
 function isHookId(id) {
 	switch (id.type) {
@@ -737,8 +1085,8 @@ function isHookId(id) {
 }
 /**
 * Checks if the given expression is a hook tag (callee / tagged template tag).
-* @param tag The expression node to check
-* @returns `true` if the expression is a hook identifier or member expression with hook name, `false` otherwise
+* @param tag The expression node to check.
+* @returns `true` if the expression is a hook identifier or member expression with hook name, `false` otherwise.
 */
 function isHookTag(tag) {
 	if (tag == null) return false;
@@ -746,8 +1094,8 @@ function isHookTag(tag) {
 }
 /**
 * Determine if a function node is a React Hook based on its name.
-* @param node The function node to check
-* @returns True if the function is a React Hook, false otherwise
+* @param node The function node to check.
+* @returns True if the function is a React Hook, false otherwise.
 */
 function isHookDefinition(node) {
 	if (node == null) return false;
@@ -771,10 +1119,10 @@ function isHookCall(node) {
 	return isHookName(name);
 }
 /**
-* Detect useEffect calls and variations (useLayoutEffect, etc.) using a regex pattern
-* @param node The AST node to check
-* @param additionalEffectHooks Regex pattern matching custom hooks that should be treated as effect hooks
-* @returns True if the node is a useEffect-like call
+* Detect useEffect calls and variations (useLayoutEffect, etc.) using a regex pattern.
+* @param node The AST node to check.
+* @param additionalEffectHooks Regex pattern matching custom hooks that should be treated as effect hooks.
+* @returns True if the node is a useEffect-like call.
 */
 function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse }) {
 	if (node == null) return false;
@@ -784,10 +1132,10 @@ function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse })
 	return /^use\w*Effect$/u.test(name) || additionalEffectHooks.test(name);
 }
 /**
-* Detect useState calls and variations using a regex pattern
-* @param node The AST node to check
-* @param additionalStateHooks Regex pattern matching custom hooks that should be treated as state hooks
-* @returns True if the node is a useState-like call
+* Detect useState calls and variations using a regex pattern.
+* @param node The AST node to check.
+* @param additionalStateHooks Regex pattern matching custom hooks that should be treated as state hooks.
+* @returns True if the node is a useState-like call.
 */
 function isUseStateLikeCall(node, additionalStateHooks = { test: constFalse }) {
 	if (node == null) return false;
@@ -797,8 +1145,8 @@ function isUseStateLikeCall(node, additionalStateHooks = { test: constFalse }) {
 	return name === "useState" || additionalStateHooks.test(name);
 }
 /**
-* Determine if a node is the setup function passed to a useEffect-like hook
-* @param node The AST node to check
+* Determine if a node is the setup function passed to a useEffect-like hook.
+* @param node The AST node to check.
 */
 function isUseEffectSetupCallback(node) {
 	if (node == null) return false;
@@ -806,8 +1154,8 @@ function isUseEffectSetupCallback(node) {
 	return expr.parent?.type === AST_NODE_TYPES.CallExpression && expr.parent.arguments.at(0) === expr && isUseEffectLikeCall(expr.parent);
 }
 /**
-* Determine if a node is the cleanup function returned by a useEffect-like hook's setup function
-* @param node The AST node to check
+* Determine if a node is the cleanup function returned by a useEffect-like hook's setup function.
+* @param node The AST node to check.
 */
 function isUseEffectCleanupCallback(node) {
 	if (node == null) return false;
@@ -830,10 +1178,9 @@ function isUseEffectCleanupCallback(node) {
 * circular definitions (e.g. `var a = b; var b = a;`) are detected and
 * treated as not JSX-like instead of recursing indefinitely.
 *
-* @param context - The ESLint rule context (needed for variable resolution).
-* @param node    - The AST node to analyse.
-* @param hint    - Optional bit-flags to adjust detection behaviour.
-*                  Defaults to {@link DEFAULT_JSX_DETECTION_HINT}.
+* @param context The ESLint rule context (needed for variable resolution).
+* @param node The AST node to analyse.
+* @param hint Optional bit-flags to adjust detection behaviour. Defaults to {@link DEFAULT_JSX_DETECTION_HINT}.
 * @returns Whether the node is considered JSX-like.
 *
 * @example
@@ -887,10 +1234,10 @@ function isJsxLike(context, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 //#endregion
 //#region src/function-component-collector.ts
 /**
-* Get an api and visitor object for the rule to collect function components
-* @param context The ESLint rule context
-* @param options The options to use
-* @returns The api and visitor of the collector
+* Get an api and visitor object for the rule to collect function components.
+* @param context The ESLint rule context.
+* @param options The options to use.
+* @returns The api and visitor of the collector.
 */
 function getFunctionComponentCollector(context, options = {}) {
 	const { collectDisplayName = false, hint = DEFAULT_COMPONENT_DETECTION_HINT } = options;
@@ -988,9 +1335,9 @@ function getFunctionComponentCollector(context, options = {}) {
 //#endregion
 //#region src/hook-collector.ts
 /**
-* Get an api and visitor object for the rule to collect hooks
-* @param context The ESLint rule context
-* @returns The api and visitor of the collector
+* Get an api and visitor object for the rule to collect hooks.
+* @param context The ESLint rule context.
+* @returns The api and visitor of the collector.
 */
 function getHookCollector(context) {
 	const hooks = /* @__PURE__ */ new Map();
@@ -1073,7 +1420,7 @@ const mergedCache = /* @__PURE__ */ new WeakMap();
 * Falls back to sensible React defaults when no compiler options are
 * available (e.g. when the file is parsed without type information).
 *
-* @param context - The ESLint rule context.
+* @param context The ESLint rule context.
 * @returns Fully‑populated `JsxConfig` derived from compiler options.
 */
 function getJsxConfigFromCompilerOptions(context) {
@@ -1092,7 +1439,7 @@ function getJsxConfigFromCompilerOptions(context) {
 * The result is cached per `sourceCode` instance via a `WeakMap` so that
 * repeated calls from different rules analysing the same file are free.
 *
-* @param context - The ESLint rule context.
+* @param context The ESLint rule context.
 * @returns Partial `JsxConfig` containing only the values found in pragmas.
 */
 function getJsxConfigFromAnnotation(context) {
@@ -1126,7 +1473,7 @@ function getJsxConfigFromAnnotation(context) {
 *
 * This is the main entry‑point most consumers should use.
 *
-* @param context - The ESLint rule context.
+* @param context The ESLint rule context.
 * @returns Fully‑populated, merged `JsxConfig`.
 */
 function getJsxConfig(context) {
@@ -1192,10 +1539,10 @@ const isUnknownType = (type) => isTypeFlagSet(type, ts.TypeFlags.Unknown);
 //#endregion
 //#region src/type-name.ts
 /**
-* An enhanced version of getFullyQualifiedName that handles cases that original function does not handle
-* @param checker TypeScript type checker
-* @param symbol Symbol to get fully qualified name for
-* @returns Fully qualified name of the symbol
+* An enhanced version of getFullyQualifiedName that handles cases that original function does not handle.
+* @param checker The TypeScript type checker.
+* @param symbol The symbol to get fully qualified name for.
+* @returns The fully qualified name of the symbol.
 */
 function getFullyQualifiedNameEx(checker, symbol) {
 	let name = symbol.name;
@@ -1245,10 +1592,10 @@ function getFullyQualifiedNameEx(checker, symbol) {
 //#endregion
 //#region src/type-variant.ts
 /**
-* Ported from https://github.com/typescript-eslint/typescript-eslint/blob/eb736bbfc22554694400e6a4f97051d845d32e0b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts#L826 with some enhancements
+* Ported from https://github.com/typescript-eslint/typescript-eslint/blob/eb736bbfc22554694400e6a4f97051d845d32e0b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts#L826 with some enhancements.
 * Get the variants of an array of types.
-* @param types The types to get the variants of
-* @returns The variants of the types
+* @param types The types to get the variants of.
+* @returns The variants of the types.
 * @internal
 */
 function getTypeVariants(types) {