@eslint-react/core 5.16.0 → 5.17.0

package/dist/index.d.ts

@@ -13,9 +13,9 @@ declare namespace isAPI {
   };
 }
 /**
- * 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.
  */
 declare function isAPI(api: string): isAPI.ReturnType;
 declare namespace isAPICall {
@@ -25,9 +25,9 @@ declare namespace isAPICall {
   };
 }
 /**
- * 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.
  */
 declare function isAPICall(api: string): isAPICall.ReturnType;
 declare const isCaptureOwnerStack: isAPI.ReturnType;
@@ -97,53 +97,53 @@ declare const isUseTransitionCall: isAPICall.ReturnType;
 //#endregion
 //#region src/class.d.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.
  */
 declare function getClassId(node: TSESTreeClass): TSESTree.BindingName | null;
 //#endregion
 //#region src/semantic.d.ts
 /**
- * Represents a semantic node in the AST
- * This is the base interface for all semantic nodes in the React semantic analysis
+ * Represents a semantic node in the AST.
+ * This is the base interface for all semantic nodes in the React semantic analysis.
  */
 interface SemanticNode {
-  /** The identifier of the node */
+  /** The identifier of the node. */
   id: null | TSESTree.Node;
-  /** The unique key of the node */
+  /** The unique key of the node. */
   key: string;
-  /** The kind of the node */
+  /** The kind of the node. */
   kind: string;
-  /** The name of the node */
+  /** The name of the node. */
   name: null | string;
-  /** The flag of the node */
+  /** The flag of the node. */
   flag: bigint;
-  /** The hint of the node */
+  /** The hint of the node. */
   hint: bigint;
-  /** The AST node */
+  /** The AST node. */
   node: TSESTree.Node;
 }
 /**
- * Represents a semantic function node in the AST
- * This interface extends SemanticNode and provides additional properties for function analysis
+ * Represents a semantic function node in the AST.
+ * This interface extends SemanticNode and provides additional properties for function analysis.
  */
 interface SemanticFunc extends SemanticNode {
-  /** The identifier of the function */
+  /** The identifier of the function. */
   id: null | TSESTree.Node;
-  /** The AST node of the function */
+  /** The AST node of the function. */
   node: TSESTreeFunction;
-  /** The name of the function */
+  /** The name of the function. */
   name: string | null;
-  /** The return type annotation of the function */
+  /** The return type annotation of the function. */
   type: TSESTree.TSTypeAnnotation | null;
-  /** The body of the function */
+  /** The body of the function. */
   body: TSESTree.BlockStatement | TSESTree.Expression;
-  /** The directives of the function (ex: "use strict", "use client", "use server", etc.) */
+  /** The directives of the function (ex: "use strict", "use client", "use server", etc.). */
   directives: TSESTreeDirective[];
-  /** The parameters of the function */
+  /** The parameters of the function. */
   parameters: TSESTree.Parameter[];
-  /** The type parameters of the function */
+  /** The type parameters of the function. */
   typeParameters: TSESTree.TSTypeParameterDeclaration | null;
 }
 //#endregion
@@ -284,29 +284,29 @@ type FunctionSemanticNode = ClientFunctionSemanticNode | ServerFunctionSemanticN
  *
  * 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.
  */
 declare function getFunctionId(node: TSESTree.Expression | TSESTreeFunction): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpressionWithBlockBody | TSESTree.ArrowFunctionExpressionWithExpressionBody | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.TemplateLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldNoStarExpression | TSESTree.YieldStarExpression | TSESTree.PrivateIdentifier | null;
 /**
  * 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.
  */
 declare function getFunctionInitPath(node: TSESTreeFunction): null | FunctionInitPath;
 /**
  * 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.
  */
 declare function isFunctionHasCallInInitPath(callName: string, initPath: FunctionInitPath): boolean;
 /**
  * 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.
  */
 declare function isFunctionEmpty(node: TSESTreeFunction): boolean;
@@ -314,8 +314,8 @@ declare function getFunctionDirectives(node: TSESTreeFunction): TSESTreeDirectiv
 /**
  * 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.
  */
 declare function isFunctionHasDirective(node: TSESTreeFunction, name: string): boolean;
@@ -332,20 +332,20 @@ declare const SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT: string;
 //#endregion
 //#region src/hook.d.ts
 /**
- * Represents a semantic hook node in the AST
+ * Represents a semantic hook node in the AST.
  */
 interface HookSemanticNode extends SemanticNode {
-  /** The identifier of the hook */
+  /** The identifier of the hook. */
   id: FunctionID;
-  /** The AST node of the hook */
+  /** The AST node of the hook. */
   node: TSESTreeFunction;
-  /** The kind of hook */
+  /** The kind of hook. */
   kind: "hook";
-  /** List of expressions returned by the hook */
+  /** List of expressions returned by the hook. */
   rets: TSESTree.ReturnStatement["argument"][];
-  /** The other hooks called by the hook */
+  /** The other hooks called by the hook. */
   hookCalls: HookCall[];
-  /** The directives used in the function (ex: "use strict", "use client", etc.) */
+  /** The directives used in the function (ex: "use strict", "use client", etc.). */
   directives: TSESTreeDirective[];
 }
 type HookCall = TSESTree.CallExpression | TSESTree.TaggedTemplateExpression;
@@ -358,21 +358,21 @@ declare const REACT_BUILTIN_HOOK_NAMES: readonly ["use", "useActionState", "useC
  */
 declare function isHookName(name: string): boolean;
 /**
- * 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.
  */
 declare function isHookId(id: TSESTree.Node): id is TSESTree.Identifier | TSESTree.MemberExpression;
 /**
  * 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.
  */
 declare function isHookTag(tag: TSESTree.Node | null): boolean;
 /**
  * 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.
  */
 declare function isHookDefinition(node: TSESTreeFunction | null): boolean;
 /**
@@ -382,148 +382,148 @@ declare function isHookDefinition(node: TSESTreeFunction | null): boolean;
  */
 declare function isHookCall(node: TSESTree.Node | null): node is TSESTree.CallExpression;
 /**
- * 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.
  */
 declare function isUseEffectLikeCall(node: TSESTree.Node | null, additionalEffectHooks?: RegExpLike): node is TSESTree.CallExpression;
 /**
- * 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.
  */
 declare function isUseStateLikeCall(node: TSESTree.Node | null, additionalStateHooks?: RegExpLike): node is TSESTree.CallExpression;
 /**
- * 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.
  */
 declare function isUseEffectSetupCallback(node: TSESTree.Node | null): boolean;
 /**
- * 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.
  */
 declare function isUseEffectCleanupCallback(node: TSESTree.Node | null): boolean;
 //#endregion
 //#region src/function-component.d.ts
 /**
- * Represents a React Function Component
+ * Represents a React Function Component.
  */
 interface FunctionComponentSemanticNode extends SemanticNode {
   /**
-   * The identifier or identifier sequence of the component
+   * The identifier or identifier sequence of the component.
    */
   id: FunctionID;
   /**
-   * The kind of component
+   * The kind of component.
    */
   kind: "component";
   /**
-   * The AST node of the function
+   * The AST node of the function.
    */
   node: TSESTreeFunction;
   /**
-   * Flags describing the component's characteristics
+   * Flags describing the component's characteristics.
    */
   flag: bigint;
   /**
-   * Hint for how the component was detected
+   * Hint for how the component was detected.
    */
   hint: bigint;
   /**
-   * List of expressions returned by the component
+   * List of expressions returned by the component.
    */
   rets: TSESTree.ReturnStatement["argument"][];
   /**
-   * The initialization path of the function
+   * The initialization path of the function.
    */
   initPath: null | FunctionInitPath;
   /**
-   * Indicates if the component is inside an export default declaration
+   * Indicates if the component is inside an export default declaration.
    */
   isExportDefault: boolean;
   /**
-   * Indicates if the component is itself an export default declaration
+   * Indicates if the component is itself an export default declaration.
    */
   isExportDefaultDeclaration: boolean;
   /**
-   * List of hook calls within the component
+   * List of hook calls within the component.
    */
   hookCalls: HookCall[];
   /**
-   * The display name of the component
+   * The display name of the component.
    */
   displayName: null | TSESTree.Expression;
   /**
-   * The directives used in the function (ex: "use strict", "use client", etc.)
+   * The directives used in the function (ex: "use strict", "use client", etc.).
    */
   directives: TSESTreeDirective[];
 }
 /**
- * Component flag constants
+ * Component flag constants.
  */
 declare const FunctionComponentFlag: {
-  /** No flags set */
+  /** No flags set. */
   None: bigint;
-  /** Indicates the component is a pure component (ex: extends PureComponent) */
+  /** Indicates the component is a pure component (ex: extends PureComponent). */
   PureComponent: bigint;
-  /** Indicates the component creates elements using `createElement` instead of JSX */
+  /** Indicates the component creates elements using `createElement` instead of JSX. */
   CreateElement: bigint;
-  /** Indicates the component is memoized (ex: React.memo) */
+  /** Indicates the component is memoized (ex: React.memo). */
   Memo: bigint;
-  /** Indicates the component forwards a ref (ex: React.forwardRef) */
+  /** Indicates the component forwards a ref (ex: React.forwardRef). */
   ForwardRef: bigint;
 };
 /**
- * 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
  */
 declare function getFunctionComponentFlagFromInitPath(initPath: FunctionComponentSemanticNode["initPath"]): bigint;
 /**
- * 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.
  */
 declare function isFunctionComponentWrapperCall(context: RuleContext, node: TSESTree.Node): boolean;
 /**
- * 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.
  */
 declare function isFunctionComponentWrapperCallback(context: RuleContext, node: TSESTree.Node): boolean;
 /**
- * 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
  */
 declare function getFunctionComponentId(context: RuleContext, node: TSESTreeFunction): FunctionID;
 /**
- * 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.
  */
 declare function isFunctionComponentName(name: string): boolean;
 /**
- * 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.
  */
 declare function isFunctionComponentNameLoose(name: string): boolean;
 /**
- * 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.
  */
 declare function isFunctionWithLooseComponentName(context: RuleContext, fn: TSESTreeFunction, allowNone?: boolean): boolean;
 type FunctionComponentDetectionHint = bigint;
 /**
- * Hints for component collector
+ * Hints for component collector.
  */
 declare const FunctionComponentDetectionHint: {
   readonly DoNotIncludeFunctionDefinedAsClassMethod: bigint;
@@ -548,16 +548,16 @@ declare const FunctionComponentDetectionHint: {
   readonly RequireBothBranchesOfConditionalExpressionToBeJsx: bigint;
 };
 /**
- * Default component detection hint
+ * Default component detection hint.
  */
 declare const DEFAULT_COMPONENT_DETECTION_HINT: bigint;
 /**
- * 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.
  */
 declare function isFunctionComponentDefinition(context: RuleContext, node: TSESTreeFunction, hint: bigint): boolean;
 //#endregion
@@ -575,10 +575,10 @@ declare namespace getFunctionComponentCollector {
   };
 }
 /**
- * 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.
  */
 declare function getFunctionComponentCollector(context: RuleContext, options?: getFunctionComponentCollector.Options): getFunctionComponentCollector.ReturnType;
 //#endregion
@@ -592,9 +592,9 @@ declare namespace getHookCollector {
   };
 }
 /**
- * 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.
  */
 declare function getHookCollector(context: RuleContext): getHookCollector.ReturnType;
 //#endregion
@@ -609,10 +609,9 @@ declare function getHookCollector(context: RuleContext): getHookCollector.Return
  * 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
@@ -644,7 +643,7 @@ interface JsxConfig {
  * 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.
  */
 declare function getJsxConfigFromCompilerOptions(context: RuleContext): Required<JsxConfig>;
@@ -655,7 +654,7 @@ declare function getJsxConfigFromCompilerOptions(context: RuleContext): Required
  * 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.
  */
 declare function getJsxConfigFromAnnotation(context: RuleContext): JsxConfig;
@@ -667,7 +666,7 @@ declare function getJsxConfigFromAnnotation(context: RuleContext): JsxConfig;
  *
  * 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`.
  */
 declare function getJsxConfig(context: RuleContext): Required<JsxConfig>;
@@ -782,20 +781,20 @@ declare const isUnknownType: (type: ts.Type) => boolean;
 //#endregion
 //#region src/type-name.d.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.
  */
 declare function getFullyQualifiedNameEx(checker: ts.TypeChecker, symbol: ts.Symbol): string;
 //#endregion
 //#region src/type-variant.d.ts
 type TypeVariant = "any" | "bigint" | "boolean" | "enum" | "never" | "nullish" | "number" | "object" | "string" | "unknown" | "falsy bigint" | "falsy boolean" | "falsy number" | "falsy string" | "truthy bigint" | "truthy boolean" | "truthy number" | "truthy string";
 /**
- * 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
  */
 declare function getTypeVariants(types: ts.Type[]): Set<TypeVariant>;