@eslint-react/core 1.24.0-beta.1 → 1.24.0-beta.18

package/dist/index.d.ts

@@ -1,18 +1,17 @@
 import * as AST from '@eslint-react/ast';
-import * as _eslint_react_eff from '@eslint-react/eff';
-import { _ } from '@eslint-react/eff';
+import * as _eslint_react_shared from '@eslint-react/shared';
+import { RuleContext } from '@eslint-react/shared';
 import { TSESTree } from '@typescript-eslint/types';
-import * as _eslint_react_types from '@eslint-react/types';
-import { RuleContext } from '@eslint-react/types';
+import { _ } from '@eslint-react/eff';
 import { TSESTree as TSESTree$1 } from '@typescript-eslint/utils';
-import { CustomComponentNormalized } from '@eslint-react/shared';
+import * as birecord from 'birecord';
 import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
 import { Scope } from '@typescript-eslint/scope-manager';
 import { SyntaxKind } from 'typescript';
 
 interface ERSemanticNode {
-    _: string;
     id: _ | TSESTree.Identifier | TSESTree.Identifier[];
+    key: string;
     kind: string;
     name: _ | string;
     node: TSESTree.Node;
@@ -74,12 +73,23 @@ interface ERClassComponent extends ERSemanticNode {
     node: AST.TSESTreeClass;
     flag: ERClassComponentFlag;
     hint: ERComponentHint;
-    methods: Array<TSESTree.MethodDefinition | TSESTree.PropertyDefinition>;
+    methods: AST.TSESTreeMethodOrProperty[];
     displayName: _ | TSESTree.Expression;
 }
 type ERComponent = ERClassComponent | ERFunctionComponent;
 
-declare function useComponentCollector(context: RuleContext, hint?: bigint): {
+interface ComponentCollectorOptions {
+    collectDisplayName?: boolean;
+    collectHookCalls?: boolean;
+}
+/**
+ * Get a ctx and listeners for the rule to collect function components
+ * @param context The ESLint rule context
+ * @param hint The hint to use
+ * @param options The options to use
+ * @returns The component collector
+ */
+declare function useComponentCollector(context: RuleContext, hint?: bigint, options?: ComponentCollectorOptions): {
     readonly ctx: {
         readonly getAllComponents: (node: TSESTree.Program) => Map<string, ERFunctionComponent>;
         readonly getCurrentEntries: () => {
@@ -96,6 +106,8 @@ declare function useComponentCollector(context: RuleContext, hint?: bigint): {
         } | undefined;
     };
     readonly listeners: {
+        readonly "ReturnStatement[type]": (node: TSESTree.ReturnStatement) => void;
+        readonly "CallExpression[type]:exit"?: (node: TSESTree.CallExpression) => void;
         readonly ":function[type]": (node: AST.TSESTreeFunction) => void;
         readonly ":function[type]:exit": () => {
             key: string;
@@ -104,14 +116,13 @@ declare function useComponentCollector(context: RuleContext, hint?: bigint): {
             isComponent: boolean;
         } | undefined;
         readonly "ArrowFunctionExpression[type][body.type!='BlockStatement']": () => void;
-        readonly "AssignmentExpression[type][operator='='][left.type='MemberExpression'][left.property.name='displayName']": (node: TSESTree.AssignmentExpression & {
-            left: TSESTree.MemberExpression;
-        }) => void;
-        readonly "CallExpression[type]:exit": (node: TSESTree.CallExpression) => void;
-        readonly "ReturnStatement[type]": (node: TSESTree.ReturnStatement) => void;
     };
 };
 
+/**
+ * Get a ctx and listeners for the rule to collect class components
+ * @returns The context and listeners for the rule
+ */
 declare function useComponentCollectorLegacy(): {
     readonly ctx: {
         readonly getAllComponents: (node: TSESTree$1.Program) => Map<string, ERClassComponent>;
@@ -122,18 +133,29 @@ declare function useComponentCollectorLegacy(): {
     };
 };
 
+/**
+ * The ESQuery selector for a component display name assignment expression
+ */
+declare const COMPONENT_DISPLAY_NAME_ASSIGNMENT_SELECTOR: string;
+/**
+ * Check if the node is a component display name assignment expression
+ * @param node The AST node
+ * @returns `true` if the node is a component display name assignment
+ */
+declare function isComponentDisplayNameAssignment(node: TSESTree.Node | _): node is TSESTree.AssignmentExpression;
+
 declare function getFunctionComponentIdentifier(node: AST.TSESTreeFunction, context: RuleContext): TSESTree.Identifier | TSESTree.Identifier[] | _;
 
 type ERComponentKind = "classComponent" | "functionComponent";
 
-type EREffectMethodKind = "useEffect" | "useInsertionEffect" | "useLayoutEffect";
-type ERLifecycleMethodKind = "componentDidMount" | "componentWillUnmount";
-
-declare const RE_COMPONENT_NAME: RegExp;
-declare function getComponentNameFromIdentifier(node: TSESTree.Identifier | TSESTree.Identifier[] | _): string | undefined;
-declare function isComponentName(name: string): boolean;
-
-declare function isRenderMethodLike(node: TSESTree$1.Node): node is TSESTree$1.MethodDefinition | TSESTree$1.PropertyDefinition;
+declare function isComponentDidMount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
+declare function isComponentWillUnmount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
+declare function isComponentDidCatch(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
+declare function isGetDerivedStateFromError(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
+declare function isGetDerivedStateFromProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
+declare function isFunctionOfComponentDidMount(node: TSESTree.Node): boolean;
+declare function isFunctionOfComponentWillUnmount(node: TSESTree.Node): boolean;
+declare function isRenderMethodLike(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
 declare function isFunctionOfRenderMethod(node: AST.TSESTreeFunction): boolean;
 /**
  * Check whether given node is declared inside class component's render block
@@ -150,7 +172,77 @@ declare function isFunctionOfRenderMethod(node: AST.TSESTreeFunction): boolean;
  * @param node The AST node being checked
  * @returns `true` if node is inside class component's render block, `false` if not
  */
-declare function isInsideRenderMethod(node: TSESTree$1.Node): boolean;
+declare function isInsideRenderMethod(node: TSESTree.Node): boolean;
+
+declare const RE_COMPONENT_NAME: RegExp;
+declare function getComponentNameFromIdentifier(node: TSESTree.Identifier | TSESTree.Identifier[] | _): string | undefined;
+declare function isComponentName(name: string): boolean;
+declare function hasNoneOrValidComponentName(node: AST.TSESTreeFunction, context: RuleContext): boolean;
+
+type EREffectPhaseKind = "cleanup" | "setup";
+type ERLifecyclePhaseKind = "mount" | "unmount";
+type ERPhaseKind = EREffectPhaseKind | ERLifecyclePhaseKind;
+declare const ERPhaseRelevance: birecord.BiRecord<{
+    readonly mount: "unmount";
+    readonly setup: "cleanup";
+}>;
+declare const isInversePhase: {
+    (a: ERPhaseKind): (b: ERPhaseKind) => boolean;
+    (a: ERPhaseKind, b: ERPhaseKind): boolean;
+};
+
+/**
+ * Unsafe check whether given node is a render function
+ * ```jsx
+ * const renderRow = () => <div />
+ * `                 ^^^^^^^^^^^^`
+ * _ = <Component renderRow={() => <div />} />
+ * `                         ^^^^^^^^^^^^^   `
+ * ```
+ * @param node The AST node to check
+ * @param context The rule context
+ * @returns `true` if node is a render function, `false` if not
+ */
+declare function isRenderFunctionLoose(node: AST.TSESTreeFunction, context: RuleContext): boolean;
+/**
+ * Unsafe check whether given JSXAttribute is a render prop
+ * ```jsx
+ * _ = <Component renderRow={() => <div />} />
+ * `              ^^^^^^^^^^^^^^^^^^^^^^^^^  `
+ * ```
+ * @param node The AST node to check
+ * @param context The rule context
+ * @returns `true` if node is a render prop, `false` if not
+ */
+declare function isRenderPropLoose(node: TSESTree.JSXAttribute, context: RuleContext): boolean;
+/**
+ * Unsafe check whether given node is declared directly inside a render property
+ * ```jsx
+ * const rows = { render: () => <div /> }
+ * `                      ^^^^^^^^^^^^^ `
+ * _ = <Component rows={ [{ render: () => <div /> }] } />
+ * `                                ^^^^^^^^^^^^^       `
+ *  ```
+ * @internal
+ * @param node The AST node to check
+ * @returns `true` if component is declared inside a render property, `false` if not
+ */
+declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolean;
+/**
+ * Unsafe check whether given node is declared inside a render prop
+ * ```jsx
+ * _ = <Component renderRow={"node"} />
+ * `                         ^^^^^^   `
+ * _ = <Component rows={ [{ render: "node" }] } />
+ * `                                ^^^^^^       `
+ * ```
+ * @param node The AST node to check
+ * @returns `true` if component is declared inside a render prop, `false` if not
+ */
+declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
+
+type ERStateKind = "actionState" | "state";
+declare function isThisSetState(node: TSESTree.CallExpression): boolean;
 
 /**
  * Check if a node is a React class component
@@ -165,14 +257,10 @@ declare function isClassComponent(node: TSESTree.Node): node is AST.TSESTreeClas
  */
 declare function isPureComponent(node: TSESTree.Node): boolean;
 
-declare function hasNoneOrValidComponentName(node: AST.TSESTreeFunction, context: RuleContext): boolean;
-
-type EREffectKind = "effect" | "insertionEffect" | "layoutEffect";
-
-declare function isSetupFunction(node: TSESTree.Node | _): boolean | undefined;
-declare function isCleanupFunction(node: TSESTree.Node): boolean | undefined;
+type EREffectKind = "useEffect" | "useLayoutEffect" | "useInsertionEffect";
 
-declare function getElementNameAndRepresentName(node: TSESTree.JSXOpeningElement, context: RuleContext, polymorphicPropName?: string, additionalComponents?: CustomComponentNormalized[]): [string, string];
+declare function isFunctionOfUseEffectSetup(node: TSESTree.Node | _): boolean | undefined;
+declare function isFunctionOfUseEffectCleanup(node: TSESTree.Node): boolean | undefined;
 
 /**
  * Determines whether inside `createElement`'s props.
@@ -242,87 +330,11 @@ declare const isUseStateCall: (node: TSESTree.CallExpression | undefined, contex
 declare const isUseSyncExternalStoreCall: (node: TSESTree.CallExpression | undefined, context: Readonly<_typescript_eslint_utils_ts_eslint.RuleContext<string, readonly unknown[]>>) => boolean;
 declare const isUseTransitionCall: (node: TSESTree.CallExpression | undefined, context: Readonly<_typescript_eslint_utils_ts_eslint.RuleContext<string, readonly unknown[]>>) => boolean;
 
-declare function isComponentDidMount(node: TSESTree.Node): node is TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
-declare function isComponentWillUnmount(node: TSESTree.Node): node is TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
-declare function isComponentDidMountFunction(node: TSESTree.Node): boolean;
-declare function isComponentWillUnmountFunction(node: TSESTree.Node): boolean;
-
-declare const ERPhaseRelevance: _eslint_react_eff.BiRecord<{
-    readonly mount: "unmount";
-    readonly setup: "cleanup";
-}>;
-
-type EREffectPhaseKind = "cleanup" | "setup";
-type ERLifecyclePhaseKind = "mount" | "unmount";
-type ERPhaseKind = EREffectPhaseKind | ERLifecyclePhaseKind;
-
-declare const isInversePhase: {
-    (a: ERPhaseKind): (b: ERPhaseKind) => boolean;
-    (a: ERPhaseKind, b: ERPhaseKind): boolean;
-};
-
-/**
- * Unsafe check whether given node is declared directly inside a render property
- * ```jsx
- * const rows = { render: () => <div /> }
- * `                      ^^^^^^^^^^^^^ `
- * _ = <Component rows={ [{ render: () => <div /> }] } />
- * `                                ^^^^^^^^^^^^^       `
- *  ```
- * @internal
- * @param node The AST node to check
- * @returns `true` if component is declared inside a render property, `false` if not
- */
-declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolean;
-/**
- * Unsafe check whether given node is declared inside a render prop
- * ```jsx
- * _ = <Component renderRow={"node"} />
- * `                         ^^^^^^   `
- * _ = <Component rows={ [{ render: "node" }] } />
- * `                                ^^^^^^       `
- * ```
- * @param node The AST node to check
- * @returns `true` if component is declared inside a render prop, `false` if not
- */
-declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
-
-/**
- * Unsafe check whether given node is a render function
- * ```jsx
- * const renderRow = () => <div />
- * `                 ^^^^^^^^^^^^`
- * _ = <Component renderRow={() => <div />} />
- * `                         ^^^^^^^^^^^^^   `
- * ```
- * @param node The AST node to check
- * @param context The rule context
- * @returns `true` if node is a render function, `false` if not
- */
-declare function isRenderFunctionLoose(node: AST.TSESTreeFunction, context: RuleContext): boolean;
-/**
- * Unsafe check whether given JSXAttribute is a render prop
- * ```jsx
- * _ = <Component renderRow={() => <div />} />
- * `              ^^^^^^^^^^^^^^^^^^^^^^^^^  `
- * ```
- * @param node The AST node to check
- * @param context The rule context
- * @returns `true` if node is a render prop, `false` if not
- */
-declare function isRenderPropLoose(node: TSESTree.JSXAttribute, context: RuleContext): boolean;
-
 interface ERSemanticEntry {
     node: TSESTree.Node;
     phase: ERPhaseKind;
 }
 
-declare function isThisSetState(node: TSESTree.CallExpression): boolean;
-
-type ERStateKind = "actionState" | "state";
-
-declare const getId: () => string;
-
 /**
  * Checks if the given node is a call expression to the given function or method of the pragma
  * @param name The name of the function or method to check
@@ -351,7 +363,7 @@ type IsCallFromReactMember = {
 };
 declare function isCallFromReactMember(pragmaMemberName: string, name: string): IsCallFromReactMember;
 
-declare function isInitializedFromReact(name: string, initialScope: Scope, importSource?: string): boolean;
+declare function isInitializedFromReact(name: string, importSource: string, initialScope: Scope): boolean;
 
 /**********************************************
  *      DO NOT MODIFY THIS FILE MANUALLY      *
@@ -2499,80 +2511,80 @@ declare function isReactAPIWithName(name: string): ReturnType<typeof isFromReact
 declare function isReactAPIWithName(name: string, member: string): ReturnType<typeof isFromReactMember>;
 declare function isReactAPICallWithName(name: string): ReturnType<typeof isCallFromReact>;
 declare function isReactAPICallWithName(name: string, member: string): ReturnType<typeof isCallFromReactMember>;
-declare const isChildrenCount: (node: MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isChildrenForEach: (node: MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isChildrenMap: (node: MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isChildrenOnly: (node: MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isChildrenToArray: (node: MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isCloneElement: (node: Identifier | MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isCreateContext: (node: Identifier | MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isCreateElement: (node: Identifier | MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isCreateRef: (node: Identifier | MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isForwardRef: (node: Identifier | MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
-declare const isMemo: (node: Identifier | MemberExpression, context: _eslint_react_types.RuleContext) => boolean;
+declare const isChildrenCount: (node: MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isChildrenForEach: (node: MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isChildrenMap: (node: MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isChildrenOnly: (node: MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isChildrenToArray: (node: MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isCloneElement: (node: Identifier | MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isCreateContext: (node: Identifier | MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isCreateElement: (node: Identifier | MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isCreateRef: (node: Identifier | MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isForwardRef: (node: Identifier | MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
+declare const isMemo: (node: Identifier | MemberExpression, context: _eslint_react_shared.RuleContext) => boolean;
 declare const isChildrenCountCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression & {
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression & {
         callee: MemberExpression;
     };
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression & {
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression & {
         callee: MemberExpression;
     };
 };
 declare const isChildrenForEachCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression & {
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression & {
         callee: MemberExpression;
     };
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression & {
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression & {
         callee: MemberExpression;
     };
 };
 declare const isChildrenMapCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression & {
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression & {
         callee: MemberExpression;
     };
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression & {
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression & {
         callee: MemberExpression;
     };
 };
 declare const isChildrenOnlyCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression & {
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression & {
         callee: MemberExpression;
     };
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression & {
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression & {
         callee: MemberExpression;
     };
 };
 declare const isChildrenToArrayCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression & {
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression & {
         callee: MemberExpression;
     };
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression & {
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression & {
         callee: MemberExpression;
     };
 };
 declare const isCloneElementCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression;
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression;
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression;
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression;
 };
 declare const isCreateContextCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression;
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression;
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression;
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression;
 };
 declare const isCreateElementCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression;
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression;
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression;
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression;
 };
 declare const isCreateRefCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression;
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression;
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression;
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression;
 };
 declare const isForwardRefCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression;
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression;
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression;
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression;
 };
 declare const isMemoCall: {
-    (context: _eslint_react_types.RuleContext): (node: Node) => node is CallExpression;
-    (node: Node, context: _eslint_react_types.RuleContext): node is CallExpression;
+    (context: _eslint_react_shared.RuleContext): (node: Node) => node is CallExpression;
+    (node: Node, context: _eslint_react_shared.RuleContext): node is CallExpression;
 };
 
-export { DEFAULT_COMPONENT_HINT, type ERClassComponent, ERClassComponentFlag, type ERComponent, ERComponentHint, type ERComponentKind, type EREffectKind, type EREffectMethodKind, type EREffectPhaseKind, type ERFunctionComponent, ERFunctionComponentFlag, type ERHook, type ERHookKind, type ERLifecycleMethodKind, type ERLifecyclePhaseKind, type ERPhaseKind, ERPhaseRelevance, type ERSemanticEntry, type ERSemanticNode, type ERStateKind, RE_COMPONENT_NAME, RE_HOOK_NAME, getComponentNameFromIdentifier, getElementNameAndRepresentName, getFunctionComponentIdentifier, getId, hasNoneOrValidComponentName, isCallFromReact, isCallFromReactMember, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCleanupFunction, isCloneElement, isCloneElementCall, isComponentDidMount, isComponentDidMountFunction, isComponentName, isComponentWillUnmount, isComponentWillUnmountFunction, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFromReact, isFromReactMember, isFunctionOfRenderMethod, isInitializedFromReact, isInsideCreateElementProps, isInsideReactHook, isInsideRenderMethod, isInversePhase, isMemo, isMemoCall, isPureComponent, isReactAPICallWithName, isReactAPIWithName, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookName, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isSetupFunction, isThisSetState, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { COMPONENT_DISPLAY_NAME_ASSIGNMENT_SELECTOR, type ComponentCollectorOptions, DEFAULT_COMPONENT_HINT, type ERClassComponent, ERClassComponentFlag, type ERComponent, ERComponentHint, type ERComponentKind, type EREffectKind, type EREffectPhaseKind, type ERFunctionComponent, ERFunctionComponentFlag, type ERHook, type ERHookKind, type ERLifecyclePhaseKind, type ERPhaseKind, ERPhaseRelevance, type ERSemanticEntry, type ERSemanticNode, type ERStateKind, RE_COMPONENT_NAME, RE_HOOK_NAME, getComponentNameFromIdentifier, getFunctionComponentIdentifier, hasNoneOrValidComponentName, isCallFromReact, isCallFromReactMember, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDisplayNameAssignment, isComponentName, isComponentWillUnmount, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFromReact, isFromReactMember, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, isGetDerivedStateFromError, isGetDerivedStateFromProps, isInitializedFromReact, isInsideCreateElementProps, isInsideReactHook, isInsideRenderMethod, isInversePhase, isMemo, isMemoCall, isPureComponent, isReactAPICallWithName, isReactAPIWithName, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookName, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isThisSetState, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, useComponentCollector, useComponentCollectorLegacy, useHookCollector };