@eslint-react/core 1.46.1-next.0 → 1.47.0-beta.2

package/dist/index.mjs

@@ -1,10 +1,9 @@
-import * as AST6 from '@eslint-react/ast';
-import { flip, dual, constFalse, identity, _ } from '@eslint-react/eff';
-import * as JSX3 from '@eslint-react/jsx';
+import * as AST8 from '@eslint-react/ast';
+import { flip, dual, constFalse, identity, constTrue, _ } from '@eslint-react/eff';
 import { RE, SEL } from '@eslint-react/kit';
 import { DEFAULT_ESLINT_REACT_SETTINGS as DEFAULT_ESLINT_REACT_SETTINGS$1, unsafeDecodeSettings, getId } from '@eslint-react/shared';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import * as VAR from '@eslint-react/var';
+import * as VAR3 from '@eslint-react/var';
 import { isMatching, P, match } from 'ts-pattern';
 import birecord from 'birecord';
 
@@ -1402,7 +1401,7 @@ function getRequireExpressionArguments(node) {
 }
 function isInitializedFromReact(name, importSource, initialScope) {
   if (name.toLowerCase() === "react") return true;
-  const latestDef = VAR.findVariable(name, initialScope)?.defs.at(-1);
+  const latestDef = VAR3.findVariable(name, initialScope)?.defs.at(-1);
   if (latestDef == null) return false;
   const { node, parent } = latestDef;
   if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init != null) {
@@ -1415,7 +1414,7 @@ function isInitializedFromReact(name, importSource, initialScope) {
     }
     const args = getRequireExpressionArguments(init);
     const arg0 = args?.[0];
-    if (arg0 == null || !AST6.isLiteral(arg0, "string")) {
+    if (arg0 == null || !AST8.isLiteral(arg0, "string")) {
       return false;
     }
     return arg0.value === importSource || arg0.value.startsWith(`${importSource}/`);
@@ -1480,7 +1479,7 @@ function isCallFromReactObject(objectName, propertyName) {
   });
 }
 function isInstanceIdEqual(context, a, b) {
-  return AST6.isNodeEqual(a, b) || VAR.isNodeValueEqual(a, b, [
+  return AST8.isNodeEqual(a, b) || VAR3.isNodeValueEqual(a, b, [
     context.sourceCode.getScope(a),
     context.sourceCode.getScope(b)
   ]);
@@ -1525,10 +1524,10 @@ function isReactHookName(name) {
   return name === "use" || /^use[A-Z0-9]/.test(name);
 }
 
-// src/hook/is.ts
+// src/hook/hook-is.ts
 function isReactHook(node) {
   if (node == null) return false;
-  const id = AST6.getFunctionIdentifier(node);
+  const id = AST8.getFunctionIdentifier(node);
   return id?.name != null && isReactHookName(id.name);
 }
 function isReactHookCall(node) {
@@ -1626,23 +1625,12 @@ var isUseStateCall = flip(isReactHookCallWithName)("useState");
 var isUseSyncExternalStoreCall = flip(isReactHookCallWithName)("useSyncExternalStore");
 var isUseTransitionCall = flip(isReactHookCallWithName)("useTransition");
 
-// src/hook/hierarchy.ts
-function isFunctionOfUseEffectSetup(node) {
-  if (node == null) return false;
-  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) {
-  if (node == null) return false;
-  const returnStatement = AST6.findParentNode(node, AST6.is(AST_NODE_TYPES.ReturnStatement));
-  const enclosingFunction = AST6.findParentNode(node, AST6.isFunction);
-  const functionOfReturnStatement = AST6.findParentNode(returnStatement, AST6.isFunction);
-  return enclosingFunction === functionOfReturnStatement && isFunctionOfUseEffectSetup(enclosingFunction);
-}
+// src/hook/hook-collector.ts
 function useHookCollector() {
   const hooks = /* @__PURE__ */ new Map();
   const functionEntries = [];
   const onFunctionEnter = (node) => {
-    const id = AST6.getFunctionIdentifier(node);
+    const id = AST8.getFunctionIdentifier(node);
     const key = getId();
     const name = id?.name;
     if (name != null && isReactHookName(name)) {
@@ -1690,11 +1678,256 @@ function useHookCollector() {
   };
   return { ctx, listeners };
 }
+function isFunctionOfUseEffectSetup(node) {
+  if (node == null) return false;
+  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) {
+  if (node == null) return false;
+  const returnStatement = AST8.findParentNode(node, AST8.is(AST_NODE_TYPES.ReturnStatement));
+  const enclosingFunction = AST8.findParentNode(node, AST8.isFunction);
+  const functionOfReturnStatement = AST8.findParentNode(returnStatement, AST8.isFunction);
+  return enclosingFunction === functionOfReturnStatement && isFunctionOfUseEffectSetup(enclosingFunction);
+}
+function stringifyJsx(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.JSXIdentifier:
+      return node.name;
+    case AST_NODE_TYPES.JSXNamespacedName:
+      return `${node.namespace.name}:${node.name.name}`;
+    case AST_NODE_TYPES.JSXMemberExpression:
+      return `${stringifyJsx(node.object)}.${stringifyJsx(node.property)}`;
+    case AST_NODE_TYPES.JSXText:
+      return node.value;
+    case AST_NODE_TYPES.JSXOpeningElement:
+      return `<${stringifyJsx(node.name)}>`;
+    case AST_NODE_TYPES.JSXClosingElement:
+      return `</${stringifyJsx(node.name)}>`;
+    case AST_NODE_TYPES.JSXOpeningFragment:
+      return "<>";
+    case AST_NODE_TYPES.JSXClosingFragment:
+      return "</>";
+  }
+}
+
+// src/jsx/jsx-attribute-name.ts
+function getAttributeName(context, node) {
+  return stringifyJsx(node.name);
+}
+
+// src/jsx/jsx-attribute.ts
+function getAttribute(context, name, attributes, initialScope) {
+  return attributes.findLast((attr) => {
+    if (attr.type === AST_NODE_TYPES.JSXAttribute) {
+      return getAttributeName(context, attr) === name;
+    }
+    if (initialScope == null) return false;
+    switch (attr.argument.type) {
+      case AST_NODE_TYPES.Identifier: {
+        const variable = VAR3.findVariable(attr.argument.name, initialScope);
+        const variableNode = VAR3.getVariableInitNode(variable, 0);
+        if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) {
+          return VAR3.findPropertyInProperties(name, variableNode.properties, initialScope) != null;
+        }
+        return false;
+      }
+      case AST_NODE_TYPES.ObjectExpression:
+        return VAR3.findPropertyInProperties(name, attr.argument.properties, initialScope) != null;
+    }
+    return false;
+  });
+}
+function getAttributeValue(context, node, name) {
+  const initialScope = context.sourceCode.getScope(node);
+  switch (node.type) {
+    case AST_NODE_TYPES.JSXAttribute:
+      if (node.value?.type === AST_NODE_TYPES.Literal) {
+        return {
+          kind: "some",
+          node: node.value,
+          initialScope,
+          value: node.value.value
+        };
+      }
+      if (node.value?.type === AST_NODE_TYPES.JSXExpressionContainer) {
+        return VAR3.toStaticValue({
+          kind: "lazy",
+          node: node.value.expression,
+          initialScope
+        });
+      }
+      return { kind: "none", node, initialScope };
+    case AST_NODE_TYPES.JSXSpreadAttribute: {
+      const staticValue = VAR3.toStaticValue({
+        kind: "lazy",
+        node: node.argument,
+        initialScope
+      });
+      if (staticValue.kind === "none") {
+        return staticValue;
+      }
+      return match(staticValue.value).with({ [name]: P.select(P.any) }, (value) => ({
+        kind: "some",
+        node: node.argument,
+        initialScope,
+        value
+      })).otherwise(() => ({ kind: "none", node, initialScope }));
+    }
+    default:
+      return { kind: "none", node, initialScope };
+  }
+}
+
+// src/jsx/jsx-detection-hint.ts
+var JSXDetectionHint = {
+  None: 0n,
+  SkipUndefined: 1n << 0n,
+  SkipNullLiteral: 1n << 1n,
+  SkipBooleanLiteral: 1n << 2n,
+  SkipStringLiteral: 1n << 3n,
+  SkipNumberLiteral: 1n << 4n,
+  SkipBigIntLiteral: 1n << 5n,
+  SkipEmptyArray: 1n << 6n,
+  SkipCreateElement: 1n << 7n,
+  StrictArray: 1n << 8n,
+  StrictLogical: 1n << 9n,
+  StrictConditional: 1n << 10n
+};
+var DEFAULT_JSX_DETECTION_HINT = 0n | JSXDetectionHint.SkipUndefined | JSXDetectionHint.SkipBooleanLiteral;
+
+// src/jsx/jsx-detection.ts
+function isJsxText(node) {
+  if (node == null) return false;
+  return node.type === AST_NODE_TYPES.JSXText || node.type === AST_NODE_TYPES.Literal;
+}
+function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
+  if (node == null) return false;
+  if (AST8.isJSX(node)) return true;
+  switch (node.type) {
+    case AST_NODE_TYPES.Literal: {
+      switch (typeof node.value) {
+        case "boolean":
+          return !(hint & JSXDetectionHint.SkipBooleanLiteral);
+        case "string":
+          return !(hint & JSXDetectionHint.SkipStringLiteral);
+        case "number":
+          return !(hint & JSXDetectionHint.SkipNumberLiteral);
+        case "bigint":
+          return !(hint & JSXDetectionHint.SkipBigIntLiteral);
+      }
+      if (node.value == null) {
+        return !(hint & JSXDetectionHint.SkipNullLiteral);
+      }
+      return false;
+    }
+    case AST_NODE_TYPES.TemplateLiteral: {
+      return !(hint & JSXDetectionHint.SkipStringLiteral);
+    }
+    case AST_NODE_TYPES.ArrayExpression: {
+      if (hint & JSXDetectionHint.StrictArray) {
+        return node.elements.every((n) => isJsxLike(code, n, hint));
+      }
+      return node.elements.some((n) => isJsxLike(code, n, hint));
+    }
+    case AST_NODE_TYPES.LogicalExpression: {
+      if (hint & JSXDetectionHint.StrictLogical) {
+        return isJsxLike(code, node.left, hint) && isJsxLike(code, node.right, hint);
+      }
+      return isJsxLike(code, node.left, hint) || isJsxLike(code, node.right, hint);
+    }
+    case AST_NODE_TYPES.ConditionalExpression: {
+      let leftHasJSX2 = function(node2) {
+        if (Array.isArray(node2.consequent)) {
+          if (node2.consequent.length === 0) {
+            return !(hint & JSXDetectionHint.SkipEmptyArray);
+          }
+          if (hint & JSXDetectionHint.StrictArray) {
+            return node2.consequent.every((n) => isJsxLike(code, n, hint));
+          }
+          return node2.consequent.some((n) => isJsxLike(code, n, hint));
+        }
+        return isJsxLike(code, node2.consequent, hint);
+      }, rightHasJSX2 = function(node2) {
+        return isJsxLike(code, node2.alternate, hint);
+      };
+      if (hint & JSXDetectionHint.StrictConditional) {
+        return leftHasJSX2(node) && rightHasJSX2(node);
+      }
+      return leftHasJSX2(node) || rightHasJSX2(node);
+    }
+    case AST_NODE_TYPES.SequenceExpression: {
+      const exp = node.expressions.at(-1);
+      return isJsxLike(code, exp, hint);
+    }
+    case AST_NODE_TYPES.CallExpression: {
+      if (hint & JSXDetectionHint.SkipCreateElement) {
+        return false;
+      }
+      switch (node.callee.type) {
+        case AST_NODE_TYPES.Identifier:
+          return node.callee.name === "createElement";
+        case AST_NODE_TYPES.MemberExpression:
+          return node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "createElement";
+      }
+      return false;
+    }
+    case AST_NODE_TYPES.Identifier: {
+      const { name } = node;
+      if (name === "undefined") {
+        return !(hint & JSXDetectionHint.SkipUndefined);
+      }
+      if (AST8.isJSXTagNameExpression(node)) {
+        return true;
+      }
+      const variable = VAR3.findVariable(name, code.getScope(node));
+      const variableNode = variable && VAR3.getVariableInitNode(variable, 0);
+      return !!variableNode && isJsxLike(code, variableNode, hint);
+    }
+  }
+  return false;
+}
+function getElementType(context, node) {
+  if (node.type === AST_NODE_TYPES.JSXFragment) {
+    return "";
+  }
+  return stringifyJsx(node.openingElement.name);
+}
+
+// src/jsx/jsx-has.ts
+function hasAttribute(context, name, attributes, initialScope) {
+  return getAttribute(context, name, attributes, initialScope) != null;
+}
+function hasAnyAttribute(context, names, attributes, initialScope) {
+  return names.some((n) => hasAttribute(context, n, attributes, initialScope));
+}
+function hasEveryAttribute(context, names, attributes, initialScope) {
+  return names.every((n) => hasAttribute(context, n, attributes, initialScope));
+}
+function findParentAttribute(node, test = constTrue) {
+  const guard = (node2) => {
+    return node2.type === AST_NODE_TYPES.JSXAttribute && test(node2);
+  };
+  return AST8.findParentNode(node, guard);
+}
+function isHostElement(context, node) {
+  return node.type === AST_NODE_TYPES.JSXElement && node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
+}
+function isKeyedElement(context, node, initialScope) {
+  return node.type === AST_NODE_TYPES.JSXElement && hasAttribute(context, "key", node.openingElement.attributes, initialScope);
+}
+function isFragmentElement(context, node, allowJSXFragment = false) {
+  if (node == null) return false;
+  if (node.type !== AST_NODE_TYPES.JSXElement && node.type !== AST_NODE_TYPES.JSXFragment) return false;
+  if (node.type === AST_NODE_TYPES.JSXFragment) return allowJSXFragment;
+  return getElementType(context, node).split(".").at(-1) === "Fragment";
+}
+
+// src/component/component-detection-hint.ts
 var ComponentDetectionHint = {
   /**
    * 1n << 0n - 1n << 63n are reserved for JSXDetectionHint
    */
-  ...JSX3.JSXDetectionHint,
+  ...JSXDetectionHint,
   /**
    * Skip function component created by React.memo
    */
@@ -1721,85 +1954,83 @@ var ComponentDetectionHint = {
   SkipClassProperty: 1n << 69n
 };
 var DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.SkipBooleanLiteral | ComponentDetectionHint.SkipEmptyArray | ComponentDetectionHint.SkipArrayMapArgument | ComponentDetectionHint.SkipNumberLiteral | ComponentDetectionHint.SkipStringLiteral | ComponentDetectionHint.SkipUndefined | ComponentDetectionHint.StrictArray | ComponentDetectionHint.StrictConditional | ComponentDetectionHint.StrictLogical;
+function isClassComponent(node) {
+  if ("superClass" in node && node.superClass != null) {
+    const re = /^(?:Pure)?Component$/u;
+    switch (true) {
+      case node.superClass.type === AST_NODE_TYPES.Identifier:
+        return re.test(node.superClass.name);
+      case (node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier):
+        return re.test(node.superClass.property.name);
+    }
+  }
+  return false;
+}
+function isPureComponent(node) {
+  if ("superClass" in node && node.superClass != null) {
+    const re = /^PureComponent$/u;
+    switch (true) {
+      case node.superClass.type === AST_NODE_TYPES.Identifier:
+        return re.test(node.superClass.name);
+      case (node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier):
+        return re.test(node.superClass.property.name);
+    }
+  }
+  return false;
+}
 function isComponentDidCatch(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
 }
 function isComponentDidMount(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
 }
 function isComponentDidUpdate(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
 }
 function isComponentWillMount(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
 }
 function isComponentWillReceiveProps(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
 }
 function isComponentWillUnmount(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
 }
 function isComponentWillUpdate(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
 }
 function isGetChildContext(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
 }
 function isGetDefaultProps(node) {
-  return AST6.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
+  return AST8.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
 }
 function isGetInitialState(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
 }
 function isGetSnapshotBeforeUpdate(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
 }
 function isShouldComponentUpdate(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
 function isUnsafeComponentWillMount(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
 }
 function isUnsafeComponentWillReceiveProps(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
 }
 function isUnsafeComponentWillUpdate(node) {
-  return AST6.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
+  return AST8.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
 }
 function isGetDerivedStateFromProps(node) {
-  return AST6.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
+  return AST8.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
 }
 function isGetDerivedStateFromError(node) {
-  return AST6.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
+  return AST8.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
 }
-function isClassComponent(node) {
-  if ("superClass" in node && node.superClass != null) {
-    const re = /^(?:Pure)?Component$/u;
-    switch (true) {
-      case node.superClass.type === AST_NODE_TYPES.Identifier:
-        return re.test(node.superClass.name);
-      case (node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier):
-        return re.test(node.superClass.property.name);
-    }
-  }
-  return false;
-}
-function isPureComponent(node) {
-  if ("superClass" in node && node.superClass != null) {
-    const re = /^PureComponent$/u;
-    switch (true) {
-      case node.superClass.type === AST_NODE_TYPES.Identifier:
-        return re.test(node.superClass.name);
-      case (node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier):
-        return re.test(node.superClass.property.name);
-    }
-  }
-  return false;
-}
-
-// src/component/component-render.ts
 function isRenderLike(node) {
-  return AST6.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
+  return AST8.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
 }
 function isFunctionOfRender(node) {
   if (!isRenderLike(node.parent)) {
@@ -1808,10 +2039,10 @@ function isFunctionOfRender(node) {
   return isClassComponent(node.parent.parent.parent);
 }
 function isRenderMethodLike(node) {
-  return AST6.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
+  return AST8.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
 }
 
-// src/component/hierarchy.ts
+// src/component/component-hierarchy.ts
 function isChildrenOfCreateElement(context, node) {
   const parent = node.parent;
   if (parent == null || parent.type !== AST_NODE_TYPES.CallExpression) return false;
@@ -1819,13 +2050,13 @@ function isChildrenOfCreateElement(context, node) {
   return parent.arguments.slice(2).some((arg) => arg === node);
 }
 function isInsideRenderMethod(node) {
-  return AST6.findParentNode(node, (n) => isRenderLike(n) && isClassComponent(n.parent.parent)) != null;
+  return AST8.findParentNode(node, (n) => isRenderLike(n) && isClassComponent(n.parent.parent)) != null;
 }
 function isFunctionOfComponentDidMount(node) {
-  return AST6.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+  return AST8.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
 }
 function isFunctionOfComponentWillUnmount(node) {
-  return AST6.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+  return AST8.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
 }
 function isFunctionOfRenderMethod(node) {
   if (!isRenderMethodLike(node.parent)) {
@@ -1865,12 +2096,12 @@ function isValidComponentDefinition(context, node, hint) {
   if (hint & ComponentDetectionHint.SkipClassProperty && isFunctionOfClassProperty(node.parent)) {
     return false;
   }
-  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST6.isArrayMapCall(node.parent)) {
+  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST8.isArrayMapCall(node.parent)) {
     return false;
   }
-  const significantParent = AST6.findParentNode(
+  const significantParent = AST8.findParentNode(
     node,
-    AST6.isOneOf([
+    AST8.isOneOf([
       AST_NODE_TYPES.JSXExpressionContainer,
       AST_NODE_TYPES.ArrowFunctionExpression,
       AST_NODE_TYPES.FunctionExpression,
@@ -1891,7 +2122,7 @@ function isComponentWrapperCallLoose(context, node) {
 
 // src/component/component-id.ts
 function getFunctionComponentId(context, node) {
-  const functionId = AST6.getFunctionIdentifier(node);
+  const functionId = AST8.getFunctionIdentifier(node);
   if (functionId != null) {
     return functionId;
   }
@@ -1918,10 +2149,10 @@ var ComponentFlag = {
 // src/component/component-init-path.ts
 function getComponentFlagFromInitPath(initPath) {
   let flag = ComponentFlag.None;
-  if (initPath != null && AST6.hasCallInFunctionInitPath("memo", initPath)) {
+  if (initPath != null && AST8.hasCallInFunctionInitPath("memo", initPath)) {
     flag |= ComponentFlag.Memo;
   }
-  if (initPath != null && AST6.hasCallInFunctionInitPath("forwardRef", initPath)) {
+  if (initPath != null && AST8.hasCallInFunctionInitPath("forwardRef", initPath)) {
     flag |= ComponentFlag.ForwardRef;
   }
   return flag;
@@ -1961,8 +2192,8 @@ function useComponentCollector(context, options = {}) {
     const entry = functionEntries.at(-1);
     if (entry == null) return;
     if (!entry.isComponent) return functionEntries.pop();
-    const shouldDrop = AST6.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
-      return context.sourceCode.getScope(r).block === entry.node && r.argument != null && !JSX3.isJsxLike(context.sourceCode, r.argument, hint);
+    const shouldDrop = AST8.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
+      return context.sourceCode.getScope(r).block === entry.node && r.argument != null && !isJsxLike(context.sourceCode, r.argument, hint);
     });
     if (shouldDrop) {
       components.delete(entry.key);
@@ -1986,9 +2217,9 @@ function useComponentCollector(context, options = {}) {
       const entry = getCurrentEntry();
       if (entry == null) return;
       const { body } = entry.node;
-      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && JSX3.isJsxLike(context.sourceCode, body, hint) && isValidComponentDefinition(context, entry.node, hint);
+      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, body, hint) && isValidComponentDefinition(context, entry.node, hint);
       if (!isComponent) return;
-      const initPath = AST6.getFunctionInitPath(entry.node);
+      const initPath = AST8.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
       const key = getId();
@@ -2026,10 +2257,10 @@ function useComponentCollector(context, options = {}) {
     "ReturnStatement[type]"(node) {
       const entry = getCurrentEntry();
       if (entry == null) return;
-      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && JSX3.isJsxLike(context.sourceCode, node.argument, hint) && isValidComponentDefinition(context, entry.node, hint);
+      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, node.argument, hint) && isValidComponentDefinition(context, entry.node, hint);
       if (!isComponent) return;
       entry.isComponent = true;
-      const initPath = AST6.getFunctionInitPath(entry.node);
+      const initPath = AST8.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
       components.set(entry.key, {
@@ -2060,7 +2291,7 @@ function useComponentCollectorLegacy() {
     if (!isClassComponent(node)) {
       return;
     }
-    const id = AST6.getClassIdentifier(node);
+    const id = AST8.getClassIdentifier(node);
     const key = getId();
     const flag = isPureComponent(node) ? ComponentFlag.PureComponent : ComponentFlag.None;
     components.set(
@@ -2093,20 +2324,20 @@ var ComponentPhaseRelevance = birecord({
 var isInversePhase = dual(2, (a, b) => ComponentPhaseRelevance.get(a) === b);
 function isRenderFunctionLoose(context, node) {
   const { body, parent } = node;
-  if (AST6.getFunctionIdentifier(node)?.name.startsWith("render")) {
+  if (AST8.getFunctionIdentifier(node)?.name.startsWith("render")) {
     return parent.type === AST_NODE_TYPES.JSXExpressionContainer && parent.parent.type === AST_NODE_TYPES.JSXAttribute && parent.parent.name.type === AST_NODE_TYPES.JSXIdentifier && parent.parent.name.name.startsWith("render");
   }
-  return JSX3.isJsxLike(
+  return isJsxLike(
     context.sourceCode,
     body,
-    JSX3.JSXDetectionHint.SkipNullLiteral | JSX3.JSXDetectionHint.SkipUndefined | JSX3.JSXDetectionHint.StrictLogical | JSX3.JSXDetectionHint.StrictConditional
+    JSXDetectionHint.SkipNullLiteral | JSXDetectionHint.SkipUndefined | JSXDetectionHint.StrictLogical | JSXDetectionHint.StrictConditional
   );
 }
 function isRenderPropLoose(context, node) {
   if (node.name.type !== AST_NODE_TYPES.JSXIdentifier) {
     return false;
   }
-  return node.name.name.startsWith("render") && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && AST6.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
+  return node.name.name.startsWith("render") && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && AST8.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
 }
 function isDirectValueOfRenderPropertyLoose(node) {
   const matching = (node2) => {
@@ -2118,7 +2349,7 @@ function isDeclaredInRenderPropLoose(node) {
   if (isDirectValueOfRenderPropertyLoose(node)) {
     return true;
   }
-  const parent = AST6.findParentNode(node, AST6.is(AST_NODE_TYPES.JSXExpressionContainer))?.parent;
+  const parent = AST8.findParentNode(node, AST8.is(AST_NODE_TYPES.JSXExpressionContainer))?.parent;
   if (parent?.type !== AST_NODE_TYPES.JSXAttribute) {
     return false;
   }
@@ -2126,11 +2357,11 @@ function isDeclaredInRenderPropLoose(node) {
 }
 function isThisSetState(node) {
   const { callee } = node;
-  return callee.type === AST_NODE_TYPES.MemberExpression && AST6.isThisExpression(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
+  return callee.type === AST_NODE_TYPES.MemberExpression && AST8.isThisExpression(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
 function isAssignmentToThisState(node) {
   const { left } = node;
-  return left.type === AST_NODE_TYPES.MemberExpression && AST6.isThisExpression(left.object) && AST6.getPropertyName(left.property) === "state";
+  return left.type === AST_NODE_TYPES.MemberExpression && AST8.isThisExpression(left.object) && AST8.getPropertyName(left.property) === "state";
 }
 
-export { ComponentDetectionHint, ComponentFlag, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, getComponentFlagFromInitPath, getComponentNameFromId, getFunctionComponentId, getInstanceId, hasNoneOrLooseComponentName, isAssignmentToThisState, isCallFromReact, isCallFromReactObject, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFromReact, isFromReactLoose, isFromReactObject, isFromReactStrict, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRender, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isInitializedFromReact, isInsideRenderMethod, isInstanceIdEqual, isInversePhase, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookName, isRenderFunctionLoose, isRenderLike, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, isValidComponentDefinition, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ComponentDetectionHint, ComponentFlag, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JSXDetectionHint, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAssignmentToThisState, isCallFromReact, isCallFromReactObject, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFragmentElement, isFromReact, isFromReactLoose, isFromReactObject, isFromReactStrict, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRender, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInsideRenderMethod, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isKeyedElement, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookName, isRenderFunctionLoose, isRenderLike, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, isValidComponentDefinition, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "1.46.1-next.0",
+  "version": "1.47.0-beta.2",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -41,12 +41,11 @@
     "@typescript-eslint/utils": "^8.29.1",
     "birecord": "^0.1.1",
     "ts-pattern": "^5.7.0",
-    "@eslint-react/ast": "1.46.1-next.0",
-    "@eslint-react/eff": "1.46.1-next.0",
-    "@eslint-react/jsx": "1.46.1-next.0",
-    "@eslint-react/shared": "1.46.1-next.0",
-    "@eslint-react/kit": "1.46.1-next.0",
-    "@eslint-react/var": "1.46.1-next.0"
+    "@eslint-react/kit": "1.47.0-beta.2",
+    "@eslint-react/shared": "1.47.0-beta.2",
+    "@eslint-react/ast": "1.47.0-beta.2",
+    "@eslint-react/eff": "1.47.0-beta.2",
+    "@eslint-react/var": "1.47.0-beta.2"
   },
   "devDependencies": {
     "tsup": "^8.4.0",