npm - @eslint-react/core - Versions diffs - 1.24.0-beta.3 → 1.24.0-beta.8 - Mend

@eslint-react/core 1.24.0-beta.3 → 1.24.0-beta.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.d.mts CHANGED Viewed

@@ -1,11 +1,10 @@
 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, CustomComponentNormalized } 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';
@@ -130,14 +129,11 @@ declare function getFunctionComponentIdentifier(node: AST.TSESTreeFunction, cont
 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 TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
+declare function isComponentWillUnmount(node: TSESTree.Node): node is TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
+declare function isFunctionOfComponentDidMount(node: TSESTree.Node): boolean;
+declare function isFunctionOfComponentWillUnmount(node: TSESTree.Node): boolean;
+declare function isRenderMethodLike(node: TSESTree.Node): node is TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
 declare function isFunctionOfRenderMethod(node: AST.TSESTreeFunction): boolean;
 /**
  * Check whether given node is declared inside class component's render block
@@ -154,7 +150,80 @@ 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;
+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 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
@@ -169,14 +238,12 @@ 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;
+declare function isFunctionOfUseEffectSetup(node: TSESTree.Node | _): boolean | undefined;
+declare function isFunctionOfUseEffectCleanup(node: TSESTree.Node): boolean | undefined;
-declare function getElementNameAndRepresentName(node: TSESTree.JSXOpeningElement, context: RuleContext, polymorphicPropName?: string, additionalComponents?: CustomComponentNormalized[]): [string, string];
+declare function getElementNameOnJsxAndHtml(node: TSESTree.JSXOpeningElement, context: RuleContext, polymorphicPropName?: string, additionalComponents?: CustomComponentNormalized[]): [string, string];
 /**
  * Determines whether inside `createElement`'s props.
@@ -246,85 +313,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;
 /**
@@ -2503,80 +2496,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 { type ComponentCollectorOptions, 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 { type ComponentCollectorOptions, 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, getElementNameOnJsxAndHtml, getFunctionComponentIdentifier, getId, hasNoneOrValidComponentName, isCallFromReact, isCallFromReactMember, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidMount, isComponentName, isComponentWillUnmount, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFromReact, isFromReactMember, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, 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 };

package/dist/index.d.ts CHANGED Viewed

@@ -1,11 +1,10 @@
 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, CustomComponentNormalized } 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';
@@ -130,14 +129,11 @@ declare function getFunctionComponentIdentifier(node: AST.TSESTreeFunction, cont
 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 TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
+declare function isComponentWillUnmount(node: TSESTree.Node): node is TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
+declare function isFunctionOfComponentDidMount(node: TSESTree.Node): boolean;
+declare function isFunctionOfComponentWillUnmount(node: TSESTree.Node): boolean;
+declare function isRenderMethodLike(node: TSESTree.Node): node is TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
 declare function isFunctionOfRenderMethod(node: AST.TSESTreeFunction): boolean;
 /**
  * Check whether given node is declared inside class component's render block
@@ -154,7 +150,80 @@ 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;
+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 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
@@ -169,14 +238,12 @@ 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;
+declare function isFunctionOfUseEffectSetup(node: TSESTree.Node | _): boolean | undefined;
+declare function isFunctionOfUseEffectCleanup(node: TSESTree.Node): boolean | undefined;
-declare function getElementNameAndRepresentName(node: TSESTree.JSXOpeningElement, context: RuleContext, polymorphicPropName?: string, additionalComponents?: CustomComponentNormalized[]): [string, string];
+declare function getElementNameOnJsxAndHtml(node: TSESTree.JSXOpeningElement, context: RuleContext, polymorphicPropName?: string, additionalComponents?: CustomComponentNormalized[]): [string, string];
 /**
  * Determines whether inside `createElement`'s props.
@@ -246,85 +313,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;
 /**
@@ -2503,80 +2496,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 { type ComponentCollectorOptions, 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 { type ComponentCollectorOptions, 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, getElementNameOnJsxAndHtml, getFunctionComponentIdentifier, getId, hasNoneOrValidComponentName, isCallFromReact, isCallFromReactMember, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidMount, isComponentName, isComponentWillUnmount, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFromReact, isFromReactMember, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, 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 };

package/dist/index.js CHANGED Viewed

@@ -6,6 +6,9 @@ var JSX4 = require('@eslint-react/jsx');
 var types = require('@typescript-eslint/types');
 var VAR = require('@eslint-react/var');
 var shared = require('@eslint-react/shared');
+var birecord = require('birecord');
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -28,24 +31,25 @@ function _interopNamespace(e) {
 var AST8__namespace = /*#__PURE__*/_interopNamespace(AST8);
 var JSX4__namespace = /*#__PURE__*/_interopNamespace(JSX4);
 var VAR__namespace = /*#__PURE__*/_interopNamespace(VAR);
+var birecord__default = /*#__PURE__*/_interopDefault(birecord);
 // src/component/component-collector.ts
-function getElementNameAndRepresentName(node, context, polymorphicPropName, additionalComponents = []) {
+function getElementNameOnJsxAndHtml(node, context, polymorphicPropName, additionalComponents = []) {
   const name = JSX4__namespace.getElementName(node);
   if (name === name.toLowerCase()) return [name, name];
   const component = additionalComponents.findLast((c) => c.name === name || c.re.test(name));
   if (component != null) return [name, component.as];
   if (polymorphicPropName == null) return [name, name];
   const initialScope = context.sourceCode.getScope(node);
-  const polymorphicProp = JSX4__namespace.findPropInAttributes(
+  const attributeNode = JSX4__namespace.getAttributeNode(
     polymorphicPropName,
     initialScope,
     node.attributes
   );
-  if (polymorphicProp == null) return [name, name];
-  const polymorphicName = VAR__namespace.toResolved(JSX4__namespace.getPropValue(polymorphicProp, initialScope)).value;
-  if (typeof polymorphicName === "string") {
-    return [name, polymorphicName];
+  if (attributeNode == null) return [name, name];
+  const polymorphicPropValue = VAR__namespace.toResolved(JSX4__namespace.getAttributeStaticValue(attributeNode, initialScope)).value;
+  if (typeof polymorphicPropValue === "string") {
+    return [name, polymorphicPropValue];
   }
   return [name, name];
 }
@@ -389,14 +393,6 @@ function getFunctionComponentIdentifier(node, context) {
   }
   return eff._;
 }
-var RE_COMPONENT_NAME = /^_?[A-Z]/u;
-function getComponentNameFromIdentifier(node) {
-  if (node == null) return eff._;
-  return Array.isArray(node) ? node.map((n) => n.name).join(".") : node.name;
-}
-function isComponentName(name) {
-  return RE_COMPONENT_NAME.test(name);
-}
 function isClassComponent(node) {
   if ("superClass" in node && node.superClass != null) {
     const re = /^(?:Pure)?Component$/u;
@@ -422,7 +418,19 @@ function isPureComponent(node) {
   return false;
 }
-// src/component/component-render-method.ts
+// src/component/component-lifecycle.ts
+function isComponentDidMount(node) {
+  return AST8__namespace.isOneOf([types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+}
+function isComponentWillUnmount(node) {
+  return AST8__namespace.isOneOf([types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
+}
+function isFunctionOfComponentDidMount(node) {
+  return AST8__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+}
+function isFunctionOfComponentWillUnmount(node) {
+  return AST8__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+}
 function isRenderMethodLike(node) {
   return (node.type === types.AST_NODE_TYPES.MethodDefinition || node.type === types.AST_NODE_TYPES.PropertyDefinition) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
 }
@@ -435,8 +443,14 @@ function isFunctionOfRenderMethod(node) {
 function isInsideRenderMethod(node) {
   return AST8__namespace.findParentNode(node, (node2) => isRenderMethodLike(node2) && isClassComponent(node2.parent.parent)) != null;
 }
-// src/component/misc.ts
+var RE_COMPONENT_NAME = /^_?[A-Z]/u;
+function getComponentNameFromIdentifier(node) {
+  if (node == null) return eff._;
+  return Array.isArray(node) ? node.map((n) => n.name).join(".") : node.name;
+}
+function isComponentName(name) {
+  return RE_COMPONENT_NAME.test(name);
+}
 function hasNoneOrValidComponentName(node, context) {
   const id2 = getFunctionComponentIdentifier(node, context);
   if (id2 == null) return true;
@@ -639,49 +653,11 @@ function useComponentCollectorLegacy() {
   };
   return { ctx, listeners };
 }
-function isSetupFunction(node) {
-  if (node == null) return eff._;
-  return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === types.AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
-}
-function isCleanupFunction(node) {
-  const nearReturn = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
-  const nearFunction = AST8__namespace.findParentNode(node, AST8__namespace.isFunction);
-  const nearFunctionOfReturn = AST8__namespace.findParentNode(nearReturn, AST8__namespace.isFunction);
-  return nearFunction === nearFunctionOfReturn && isSetupFunction(nearFunction);
-}
-function isComponentDidMount(node) {
-  return AST8__namespace.isOneOf([types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
-}
-function isComponentWillUnmount(node) {
-  return AST8__namespace.isOneOf([types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
-}
-function isComponentDidMountFunction(node) {
-  return AST8__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
-}
-function isComponentWillUnmountFunction(node) {
-  return AST8__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
-}
-var ERPhaseRelevance = eff.birecord({
+var ERPhaseRelevance = birecord__default.default({
   mount: "unmount",
   setup: "cleanup"
 });
 var isInversePhase = eff.dual(2, (a, b) => ERPhaseRelevance.get(a) === b);
-function isDirectValueOfRenderPropertyLoose(node) {
-  const matching = (node2) => {
-    return node2.type === types.AST_NODE_TYPES.Property && node2.key.type === types.AST_NODE_TYPES.Identifier && node2.key.name.startsWith("render");
-  };
-  return matching(node) || node.parent != null && matching(node.parent);
-}
-function isDeclaredInRenderPropLoose(node) {
-  if (isDirectValueOfRenderPropertyLoose(node)) {
-    return true;
-  }
-  const parent = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
-  if (parent?.type !== types.AST_NODE_TYPES.JSXAttribute) {
-    return false;
-  }
-  return parent.name.type === types.AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
-}
 function isRenderFunctionLoose(node, context) {
   const { body, parent } = node;
   if (AST8__namespace.getFunctionIdentifier(node)?.name.startsWith("render")) {
@@ -701,10 +677,36 @@ function isRenderPropLoose(node, context) {
   }
   return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST8__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(node.value.expression, context);
 }
+function isDirectValueOfRenderPropertyLoose(node) {
+  const matching = (node2) => {
+    return node2.type === types.AST_NODE_TYPES.Property && node2.key.type === types.AST_NODE_TYPES.Identifier && node2.key.name.startsWith("render");
+  };
+  return matching(node) || node.parent != null && matching(node.parent);
+}
+function isDeclaredInRenderPropLoose(node) {
+  if (isDirectValueOfRenderPropertyLoose(node)) {
+    return true;
+  }
+  const parent = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
+  if (parent?.type !== types.AST_NODE_TYPES.JSXAttribute) {
+    return false;
+  }
+  return parent.name.type === types.AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
+}
 function isThisSetState(node) {
   const { callee } = node;
   return callee.type === types.AST_NODE_TYPES.MemberExpression && AST8__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
+function isFunctionOfUseEffectSetup(node) {
+  if (node == null) return eff._;
+  return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === types.AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
+}
+function isFunctionOfUseEffectCleanup(node) {
+  const nearReturn = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
+  const nearFunction = AST8__namespace.findParentNode(node, AST8__namespace.isFunction);
+  const nearFunctionOfReturn = AST8__namespace.findParentNode(nearReturn, AST8__namespace.isFunction);
+  return nearFunction === nearFunctionOfReturn && isFunctionOfUseEffectSetup(nearFunction);
+}
 exports.DEFAULT_COMPONENT_HINT = DEFAULT_COMPONENT_HINT;
 exports.ERClassComponentFlag = ERClassComponentFlag;
@@ -714,7 +716,7 @@ exports.ERPhaseRelevance = ERPhaseRelevance;
 exports.RE_COMPONENT_NAME = RE_COMPONENT_NAME;
 exports.RE_HOOK_NAME = RE_HOOK_NAME;
 exports.getComponentNameFromIdentifier = getComponentNameFromIdentifier;
-exports.getElementNameAndRepresentName = getElementNameAndRepresentName;
+exports.getElementNameOnJsxAndHtml = getElementNameOnJsxAndHtml;
 exports.getFunctionComponentIdentifier = getFunctionComponentIdentifier;
 exports.getId = getId;
 exports.hasNoneOrValidComponentName = hasNoneOrValidComponentName;
@@ -732,14 +734,11 @@ exports.isChildrenOnlyCall = isChildrenOnlyCall;
 exports.isChildrenToArray = isChildrenToArray;
 exports.isChildrenToArrayCall = isChildrenToArrayCall;
 exports.isClassComponent = isClassComponent;
-exports.isCleanupFunction = isCleanupFunction;
 exports.isCloneElement = isCloneElement;
 exports.isCloneElementCall = isCloneElementCall;
 exports.isComponentDidMount = isComponentDidMount;
-exports.isComponentDidMountFunction = isComponentDidMountFunction;
 exports.isComponentName = isComponentName;
 exports.isComponentWillUnmount = isComponentWillUnmount;
-exports.isComponentWillUnmountFunction = isComponentWillUnmountFunction;
 exports.isCreateContext = isCreateContext;
 exports.isCreateContextCall = isCreateContextCall;
 exports.isCreateElement = isCreateElement;
@@ -752,7 +751,11 @@ exports.isForwardRef = isForwardRef;
 exports.isForwardRefCall = isForwardRefCall;
 exports.isFromReact = isFromReact;
 exports.isFromReactMember = isFromReactMember;
+exports.isFunctionOfComponentDidMount = isFunctionOfComponentDidMount;
+exports.isFunctionOfComponentWillUnmount = isFunctionOfComponentWillUnmount;
 exports.isFunctionOfRenderMethod = isFunctionOfRenderMethod;
+exports.isFunctionOfUseEffectCleanup = isFunctionOfUseEffectCleanup;
+exports.isFunctionOfUseEffectSetup = isFunctionOfUseEffectSetup;
 exports.isInitializedFromReact = isInitializedFromReact;
 exports.isInsideCreateElementProps = isInsideCreateElementProps;
 exports.isInsideReactHook = isInsideReactHook;
@@ -772,7 +775,6 @@ exports.isReactHookName = isReactHookName;
 exports.isRenderFunctionLoose = isRenderFunctionLoose;
 exports.isRenderMethodLike = isRenderMethodLike;
 exports.isRenderPropLoose = isRenderPropLoose;
-exports.isSetupFunction = isSetupFunction;
 exports.isThisSetState = isThisSetState;
 exports.isUseCallbackCall = isUseCallbackCall;
 exports.isUseContextCall = isUseContextCall;

package/dist/index.mjs CHANGED Viewed

@@ -1,27 +1,28 @@
 import * as AST8 from '@eslint-react/ast';
-import { flip, birecord, dual, _, returnFalse } from '@eslint-react/eff';
+import { flip, dual, _, returnFalse } from '@eslint-react/eff';
 import * as JSX4 from '@eslint-react/jsx';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import * as VAR from '@eslint-react/var';
 import { unsafeDecodeSettings } from '@eslint-react/shared';
+import birecord from 'birecord';
 // src/component/component-collector.ts
-function getElementNameAndRepresentName(node, context, polymorphicPropName, additionalComponents = []) {
+function getElementNameOnJsxAndHtml(node, context, polymorphicPropName, additionalComponents = []) {
   const name = JSX4.getElementName(node);
   if (name === name.toLowerCase()) return [name, name];
   const component = additionalComponents.findLast((c) => c.name === name || c.re.test(name));
   if (component != null) return [name, component.as];
   if (polymorphicPropName == null) return [name, name];
   const initialScope = context.sourceCode.getScope(node);
-  const polymorphicProp = JSX4.findPropInAttributes(
+  const attributeNode = JSX4.getAttributeNode(
     polymorphicPropName,
     initialScope,
     node.attributes
   );
-  if (polymorphicProp == null) return [name, name];
-  const polymorphicName = VAR.toResolved(JSX4.getPropValue(polymorphicProp, initialScope)).value;
-  if (typeof polymorphicName === "string") {
-    return [name, polymorphicName];
+  if (attributeNode == null) return [name, name];
+  const polymorphicPropValue = VAR.toResolved(JSX4.getAttributeStaticValue(attributeNode, initialScope)).value;
+  if (typeof polymorphicPropValue === "string") {
+    return [name, polymorphicPropValue];
   }
   return [name, name];
 }
@@ -365,14 +366,6 @@ function getFunctionComponentIdentifier(node, context) {
   }
   return _;
 }
-var RE_COMPONENT_NAME = /^_?[A-Z]/u;
-function getComponentNameFromIdentifier(node) {
-  if (node == null) return _;
-  return Array.isArray(node) ? node.map((n) => n.name).join(".") : node.name;
-}
-function isComponentName(name) {
-  return RE_COMPONENT_NAME.test(name);
-}
 function isClassComponent(node) {
   if ("superClass" in node && node.superClass != null) {
     const re = /^(?:Pure)?Component$/u;
@@ -398,7 +391,19 @@ function isPureComponent(node) {
   return false;
 }
-// src/component/component-render-method.ts
+// src/component/component-lifecycle.ts
+function isComponentDidMount(node) {
+  return AST8.isOneOf([AST_NODE_TYPES.MethodDefinition, AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+}
+function isComponentWillUnmount(node) {
+  return AST8.isOneOf([AST_NODE_TYPES.MethodDefinition, AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
+}
+function isFunctionOfComponentDidMount(node) {
+  return AST8.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+}
+function isFunctionOfComponentWillUnmount(node) {
+  return AST8.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+}
 function isRenderMethodLike(node) {
   return (node.type === AST_NODE_TYPES.MethodDefinition || node.type === AST_NODE_TYPES.PropertyDefinition) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
 }
@@ -411,8 +416,14 @@ function isFunctionOfRenderMethod(node) {
 function isInsideRenderMethod(node) {
   return AST8.findParentNode(node, (node2) => isRenderMethodLike(node2) && isClassComponent(node2.parent.parent)) != null;
 }
-// src/component/misc.ts
+var RE_COMPONENT_NAME = /^_?[A-Z]/u;
+function getComponentNameFromIdentifier(node) {
+  if (node == null) return _;
+  return Array.isArray(node) ? node.map((n) => n.name).join(".") : node.name;
+}
+function isComponentName(name) {
+  return RE_COMPONENT_NAME.test(name);
+}
 function hasNoneOrValidComponentName(node, context) {
   const id2 = getFunctionComponentIdentifier(node, context);
   if (id2 == null) return true;
@@ -615,49 +626,11 @@ function useComponentCollectorLegacy() {
   };
   return { ctx, listeners };
 }
-function isSetupFunction(node) {
-  if (node == null) return _;
-  return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
-}
-function isCleanupFunction(node) {
-  const nearReturn = AST8.findParentNode(node, AST8.is(AST_NODE_TYPES.ReturnStatement));
-  const nearFunction = AST8.findParentNode(node, AST8.isFunction);
-  const nearFunctionOfReturn = AST8.findParentNode(nearReturn, AST8.isFunction);
-  return nearFunction === nearFunctionOfReturn && isSetupFunction(nearFunction);
-}
-function isComponentDidMount(node) {
-  return AST8.isOneOf([AST_NODE_TYPES.MethodDefinition, AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
-}
-function isComponentWillUnmount(node) {
-  return AST8.isOneOf([AST_NODE_TYPES.MethodDefinition, AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
-}
-function isComponentDidMountFunction(node) {
-  return AST8.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
-}
-function isComponentWillUnmountFunction(node) {
-  return AST8.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
-}
 var ERPhaseRelevance = birecord({
   mount: "unmount",
   setup: "cleanup"
 });
 var isInversePhase = dual(2, (a, b) => ERPhaseRelevance.get(a) === b);
-function isDirectValueOfRenderPropertyLoose(node) {
-  const matching = (node2) => {
-    return node2.type === AST_NODE_TYPES.Property && node2.key.type === AST_NODE_TYPES.Identifier && node2.key.name.startsWith("render");
-  };
-  return matching(node) || node.parent != null && matching(node.parent);
-}
-function isDeclaredInRenderPropLoose(node) {
-  if (isDirectValueOfRenderPropertyLoose(node)) {
-    return true;
-  }
-  const parent = AST8.findParentNode(node, AST8.is(AST_NODE_TYPES.JSXExpressionContainer))?.parent;
-  if (parent?.type !== AST_NODE_TYPES.JSXAttribute) {
-    return false;
-  }
-  return parent.name.type === AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
-}
 function isRenderFunctionLoose(node, context) {
   const { body, parent } = node;
   if (AST8.getFunctionIdentifier(node)?.name.startsWith("render")) {
@@ -677,9 +650,35 @@ function isRenderPropLoose(node, context) {
   }
   return node.name.name.startsWith("render") && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && AST8.isFunction(node.value.expression) && isRenderFunctionLoose(node.value.expression, context);
 }
+function isDirectValueOfRenderPropertyLoose(node) {
+  const matching = (node2) => {
+    return node2.type === AST_NODE_TYPES.Property && node2.key.type === AST_NODE_TYPES.Identifier && node2.key.name.startsWith("render");
+  };
+  return matching(node) || node.parent != null && matching(node.parent);
+}
+function isDeclaredInRenderPropLoose(node) {
+  if (isDirectValueOfRenderPropertyLoose(node)) {
+    return true;
+  }
+  const parent = AST8.findParentNode(node, AST8.is(AST_NODE_TYPES.JSXExpressionContainer))?.parent;
+  if (parent?.type !== AST_NODE_TYPES.JSXAttribute) {
+    return false;
+  }
+  return parent.name.type === AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
+}
 function isThisSetState(node) {
   const { callee } = node;
   return callee.type === AST_NODE_TYPES.MemberExpression && AST8.isThisExpression(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
+function isFunctionOfUseEffectSetup(node) {
+  if (node == null) return _;
+  return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
+}
+function isFunctionOfUseEffectCleanup(node) {
+  const nearReturn = AST8.findParentNode(node, AST8.is(AST_NODE_TYPES.ReturnStatement));
+  const nearFunction = AST8.findParentNode(node, AST8.isFunction);
+  const nearFunctionOfReturn = AST8.findParentNode(nearReturn, AST8.isFunction);
+  return nearFunction === nearFunctionOfReturn && isFunctionOfUseEffectSetup(nearFunction);
+}
-export { DEFAULT_COMPONENT_HINT, ERClassComponentFlag, ERComponentHint, ERFunctionComponentFlag, ERPhaseRelevance, 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 { DEFAULT_COMPONENT_HINT, ERClassComponentFlag, ERComponentHint, ERFunctionComponentFlag, ERPhaseRelevance, RE_COMPONENT_NAME, RE_HOOK_NAME, getComponentNameFromIdentifier, getElementNameOnJsxAndHtml, getFunctionComponentIdentifier, getId, hasNoneOrValidComponentName, isCallFromReact, isCallFromReactMember, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidMount, isComponentName, isComponentWillUnmount, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFromReact, isFromReactMember, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, 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 };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "1.24.0-beta.3",
+  "version": "1.24.0-beta.8",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and Patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -33,17 +33,17 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.19.1",
-    "@typescript-eslint/type-utils": "^8.19.1",
-    "@typescript-eslint/types": "^8.19.1",
-    "@typescript-eslint/utils": "^8.19.1",
+    "@typescript-eslint/scope-manager": "^8.20.0",
+    "@typescript-eslint/type-utils": "^8.20.0",
+    "@typescript-eslint/types": "^8.20.0",
+    "@typescript-eslint/utils": "^8.20.0",
+    "birecord": "^0.1.1",
     "ts-pattern": "^5.6.0",
-    "@eslint-react/eff": "1.24.0-beta.3",
-    "@eslint-react/jsx": "1.24.0-beta.3",
-    "@eslint-react/shared": "1.24.0-beta.3",
-    "@eslint-react/types": "1.24.0-beta.3",
-    "@eslint-react/var": "1.24.0-beta.3",
-    "@eslint-react/ast": "1.24.0-beta.3"
+    "@eslint-react/ast": "1.24.0-beta.8",
+    "@eslint-react/jsx": "1.24.0-beta.8",
+    "@eslint-react/shared": "1.24.0-beta.8",
+    "@eslint-react/eff": "1.24.0-beta.8",
+    "@eslint-react/var": "1.24.0-beta.8"
   },
   "devDependencies": {
     "tsup": "^8.3.5",