@eslint-react/core 1.23.3-next.8 → 1.24.0-beta.0

package/dist/index.mjs

@@ -1,30 +1,29 @@
 import * as AST8 from '@eslint-react/ast';
-import { F, isString, O } from '@eslint-react/eff';
+import { flip, birecord, dual, _, returnFalse } from '@eslint-react/eff';
 import * as JSX4 from '@eslint-react/jsx';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import { match } from 'ts-pattern';
-import { getSettingsFromContext, unsafeDecodeSettings } from '@eslint-react/shared';
 import * as VAR from '@eslint-react/var';
-import { birecord } from '@eslint-react/types';
+import { unsafeDecodeSettings } from '@eslint-react/shared';
 
 // src/component/component-collector.ts
-function getElementRepresentName(node, context) {
-  const rawElementName = JSX4.getElementName(node);
-  if (rawElementName === rawElementName.toLowerCase()) {
-    return rawElementName;
-  }
-  const { components, polymorphicPropName } = getSettingsFromContext(context);
-  const asElementName = components.get(rawElementName);
-  if (isString(asElementName)) {
-    return asElementName;
-  }
-  return F.pipe(
-    O.fromNullable(polymorphicPropName),
-    O.flatMap(JSX4.findPropInAttributes(node.attributes, context.sourceCode.getScope(node))),
-    O.flatMap((attr) => JSX4.getPropValue(attr, context.sourceCode.getScope(attr))),
-    O.filter(isString),
-    O.getOrElse(() => rawElementName)
+function getElementNameAndRepresentName(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 !== _) return [name, component.as];
+  if (polymorphicPropName == null) return [name, name];
+  const initialScope = context.sourceCode.getScope(node);
+  const polymorphicProp = JSX4.findPropInAttributes(
+    polymorphicPropName,
+    initialScope,
+    node.attributes
   );
+  if (polymorphicProp === _) return [name, name];
+  const polymorphicName = VAR.toResolved(JSX4.getPropValue(polymorphicProp, initialScope)).value;
+  if (typeof polymorphicName === "string") {
+    return [name, polymorphicName];
+  }
+  return [name, name];
 }
 
 // src/utils/get-id.ts
@@ -87,7 +86,7 @@ function isFromReactMember(memberName, name) {
   };
 }
 function isCallFromReact(name) {
-  return F.dual(2, (node, context) => {
+  return dual(2, (node, context) => {
     if (node.type !== AST_NODE_TYPES.CallExpression) {
       return false;
     }
@@ -98,7 +97,7 @@ function isCallFromReact(name) {
   });
 }
 function isCallFromReactMember(pragmaMemberName, name) {
-  return F.dual(2, (node, context) => {
+  return dual(2, (node, context) => {
     if (node.type !== AST_NODE_TYPES.CallExpression) {
       return false;
     }
@@ -111,10 +110,10 @@ function isCallFromReactMember(pragmaMemberName, name) {
 
 // src/utils/is-react-api.ts
 function isReactAPIWithName(name, member) {
-  return member == null ? isFromReact(name) : isFromReactMember(name, member);
+  return member != null ? isFromReactMember(name, member) : isFromReact(name);
 }
 function isReactAPICallWithName(name, member) {
-  return member == null ? isCallFromReact(name) : isCallFromReactMember(name, member);
+  return member != null ? isCallFromReactMember(name, member) : isCallFromReact(name);
 }
 var isChildrenCount = isReactAPIWithName("Children", "count");
 var isChildrenForEach = isReactAPIWithName("Children", "forEach");
@@ -141,23 +140,17 @@ var isMemoCall = isReactAPICallWithName("memo");
 
 // src/element/hierarchy.ts
 function isInsideCreateElementProps(node, context) {
-  return F.pipe(
-    O.Do,
-    O.bind("call", () => AST8.findParentNodeGuard(node, isCreateElementCall(context))),
-    O.bind("prop", () => AST8.findParentNodeGuard(node, AST8.is(AST_NODE_TYPES.ObjectExpression))),
-    O.bind("arg1", ({ call }) => O.fromNullable(call.arguments[1])),
-    O.exists(({ arg1, prop }) => prop === arg1)
-  );
+  const call = AST8.findParentNodeGuard(node, isCreateElementCall(context));
+  if (!call) return false;
+  const prop = AST8.findParentNodeGuard(node, AST8.is(AST_NODE_TYPES.ObjectExpression));
+  if (!prop) return false;
+  return prop === call.arguments[1];
 }
 function isChildrenOfCreateElement(node, context) {
-  return F.pipe(
-    O.fromNullable(node.parent),
-    O.filter(AST8.is(AST_NODE_TYPES.CallExpression)),
-    O.filter(isCreateElementCall(context)),
-    O.exists(
-      (n) => n.arguments.slice(2).some((arg) => arg === node)
-    )
-  );
+  const parent = node.parent;
+  if (!parent || parent.type !== AST_NODE_TYPES.CallExpression) return false;
+  if (!isCreateElementCall(parent, context)) return false;
+  return parent.arguments.slice(2).some((arg) => arg === node);
 }
 
 // src/hook/hook-name.ts
@@ -168,13 +161,12 @@ function isReactHookName(name) {
 
 // src/hook/is.ts
 function isReactHook(node) {
-  return F.pipe(
-    AST8.getFunctionIdentifier(node),
-    O.flatMapNullable((id2) => id2.name),
-    O.exists(isReactHookName)
-  );
+  if (node === _) return _;
+  const id2 = AST8.getFunctionIdentifier(node);
+  return id2?.name !== _ && isReactHookName(id2.name);
 }
 function isReactHookCall(node) {
+  if (node === _) return false;
   if (node.type !== AST_NODE_TYPES.CallExpression) {
     return false;
   }
@@ -187,6 +179,7 @@ function isReactHookCall(node) {
   return false;
 }
 function isReactHookCallWithName(node, context) {
+  if (node === _) return returnFalse;
   const settings = unsafeDecodeSettings(context.settings);
   return (name) => {
     const initialScope = context.sourceCode.getScope(node);
@@ -201,6 +194,7 @@ function isReactHookCallWithName(node, context) {
   };
 }
 function isReactHookCallWithNameLoose(node) {
+  if (node === _) return returnFalse;
   return (name) => {
     switch (node.callee.type) {
       case AST_NODE_TYPES.Identifier:
@@ -227,6 +221,7 @@ function isReactHookCallWithNameAlias(name, context, alias) {
   };
 }
 function isUseEffectCallLoose(node) {
+  if (node === _) return false;
   if (node.type !== AST_NODE_TYPES.CallExpression) {
     return false;
   }
@@ -239,35 +234,35 @@ function isUseEffectCallLoose(node) {
       return false;
   }
 }
-var isUseCallbackCall = F.flip(isReactHookCallWithName)("useCallback");
-var isUseContextCall = F.flip(isReactHookCallWithName)("useContext");
-var isUseDebugValueCall = F.flip(isReactHookCallWithName)("useDebugValue");
-var isUseDeferredValueCall = F.flip(isReactHookCallWithName)("useDeferredValue");
-var isUseEffectCall = F.flip(isReactHookCallWithName)("useEffect");
-var isUseIdCall = F.flip(isReactHookCallWithName)("useId");
-var isUseImperativeHandleCall = F.flip(isReactHookCallWithName)("useImperativeHandle");
-var isUseInsertionEffectCall = F.flip(isReactHookCallWithName)("useInsertionEffect");
-var isUseLayoutEffectCall = F.flip(isReactHookCallWithName)("useLayoutEffect");
-var isUseMemoCall = F.flip(isReactHookCallWithName)("useMemo");
-var isUseReducerCall = F.flip(isReactHookCallWithName)("useReducer");
-var isUseRefCall = F.flip(isReactHookCallWithName)("useRef");
-var isUseStateCall = F.flip(isReactHookCallWithName)("useState");
-var isUseSyncExternalStoreCall = F.flip(isReactHookCallWithName)("useSyncExternalStore");
-var isUseTransitionCall = F.flip(isReactHookCallWithName)("useTransition");
+var isUseCallbackCall = flip(isReactHookCallWithName)("useCallback");
+var isUseContextCall = flip(isReactHookCallWithName)("useContext");
+var isUseDebugValueCall = flip(isReactHookCallWithName)("useDebugValue");
+var isUseDeferredValueCall = flip(isReactHookCallWithName)("useDeferredValue");
+var isUseEffectCall = flip(isReactHookCallWithName)("useEffect");
+var isUseIdCall = flip(isReactHookCallWithName)("useId");
+var isUseImperativeHandleCall = flip(isReactHookCallWithName)("useImperativeHandle");
+var isUseInsertionEffectCall = flip(isReactHookCallWithName)("useInsertionEffect");
+var isUseLayoutEffectCall = flip(isReactHookCallWithName)("useLayoutEffect");
+var isUseMemoCall = flip(isReactHookCallWithName)("useMemo");
+var isUseReducerCall = flip(isReactHookCallWithName)("useReducer");
+var isUseRefCall = flip(isReactHookCallWithName)("useRef");
+var isUseStateCall = flip(isReactHookCallWithName)("useState");
+var isUseSyncExternalStoreCall = flip(isReactHookCallWithName)("useSyncExternalStore");
+var isUseTransitionCall = flip(isReactHookCallWithName)("useTransition");
 
 // src/hook/hierarchy.ts
 function isInsideReactHook(node) {
-  return O.exists(AST8.findParentNodeGuard(node, AST8.isFunction), isReactHook);
+  return isReactHook(AST8.findParentNodeGuard(node, AST8.isFunction));
 }
 function useHookCollector() {
   const hooks = /* @__PURE__ */ new Map();
-  const fStack = [];
+  const fEntries = [];
   const onFunctionEnter = (node) => {
     const id2 = AST8.getFunctionIdentifier(node);
-    const name = O.flatMapNullable(id2, (id3) => id3.name);
-    if (O.isSome(id2) && O.isSome(name) && isReactHookName(name.value)) {
+    const name = id2?.name;
+    if (name !== _ && isReactHookName(name)) {
       const key = getId();
-      fStack.push([node, O.some(key)]);
+      fEntries.push({ key, node });
       hooks.set(key, {
         _: key,
         id: id2,
@@ -280,13 +275,14 @@ function useHookCollector() {
       });
       return;
     }
-    fStack.push([node, O.none()]);
+    fEntries.push({ key: _, node });
   };
   const onFunctionExit = () => {
-    fStack.pop();
+    fEntries.pop();
   };
   const ctx = {
-    getAllHooks(_) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getAllHooks(node) {
       return hooks;
     },
     getCurrentHooks() {
@@ -300,24 +296,21 @@ function useHookCollector() {
       if (!isReactHookCall(node)) {
         return;
       }
-      const [fNode, hookId] = fStack.at(-1) ?? [];
-      if (fNode == null || hookId == null) {
+      const fEntry = fEntries.at(-1);
+      if (fEntry?.key === _) {
+        return;
+      }
+      const hook = hooks.get(fEntry.key);
+      if (hook === _) {
         return;
       }
-      F.pipe(
-        O.Do,
-        O.bind("id", () => hookId),
-        O.bind("hook", ({ id: id2 }) => O.fromNullable(hooks.get(id2))),
-        O.map(({ id: id2, hook }) => {
-          hooks.set(id2, {
-            ...hook,
-            hookCalls: [
-              ...hook.hookCalls,
-              node
-            ]
-          });
-        })
-      );
+      hooks.set(hook._, {
+        ...hook,
+        hookCalls: [
+          ...hook.hookCalls,
+          node
+        ]
+      });
     }
   };
   return { ctx, listeners };
@@ -366,17 +359,17 @@ function isComponentWrapperCall(node, context) {
 }
 function getFunctionComponentIdentifier(node, context) {
   const functionId = AST8.getFunctionIdentifier(node);
-  if (O.isSome(functionId)) {
+  if (functionId) {
     return functionId;
   }
   const { parent } = node;
   if (parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent, context) && parent.parent.type === AST_NODE_TYPES.VariableDeclarator && parent.parent.id.type === AST_NODE_TYPES.Identifier) {
-    return O.some(parent.parent.id);
+    return parent.parent.id;
   }
   if (parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent, context) && parent.parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent.parent, context) && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator && parent.parent.parent.id.type === AST_NODE_TYPES.Identifier) {
-    return O.some(parent.parent.parent.id);
+    return parent.parent.parent.id;
   }
-  return O.none();
+  return _;
 }
 
 // src/component/component-name.ts
@@ -388,7 +381,7 @@ function isComponentName(name) {
   return RE_COMPONENT_NAME.test(name);
 }
 function isClassComponent(node) {
-  if ("superClass" in node && node.superClass != null) {
+  if ("superClass" in node && node.superClass) {
     const re = /^(?:Pure)?Component$/u;
     switch (true) {
       case node.superClass.type === AST_NODE_TYPES.Identifier:
@@ -400,7 +393,7 @@ function isClassComponent(node) {
   return false;
 }
 function isPureComponent(node) {
-  if ("superClass" in node && node.superClass != null) {
+  if ("superClass" in node && node.superClass) {
     const re = /^PureComponent$/u;
     switch (true) {
       case node.superClass.type === AST_NODE_TYPES.Identifier:
@@ -423,14 +416,13 @@ function isFunctionOfRenderMethod(node) {
   return isClassComponent(node.parent.parent.parent);
 }
 function isInsideRenderMethod(node) {
-  return O.isSome(AST8.findParentNode(node, (node2) => isRenderMethodLike(node2) && isClassComponent(node2.parent.parent)));
+  return !!AST8.findParentNode(node, (node2) => isRenderMethodLike(node2) && isClassComponent(node2.parent.parent));
 }
+
+// src/component/misc.ts
 function hasNoneOrValidComponentName(node, context) {
-  const mbIdentifier = getFunctionComponentIdentifier(node, context);
-  if (O.isNone(mbIdentifier)) {
-    return true;
-  }
-  const id2 = mbIdentifier.value;
+  const id2 = getFunctionComponentIdentifier(node, context);
+  if (!id2) return true;
   const name = Array.isArray(id2) ? id2.at(-1)?.name : id2.name;
   return name != null && isComponentName(name);
 }
@@ -452,26 +444,24 @@ function hasValidHierarchy(node, context, hint) {
   if (hint & ERComponentHint.SkipClassProperty && AST8.isFunctionOfClassProperty(node.parent)) {
     return false;
   }
-  return !O.exists(
-    AST8.findParentNode(
-      node,
-      AST8.isOneOf([
-        AST_NODE_TYPES.JSXExpressionContainer,
-        AST_NODE_TYPES.ArrowFunctionExpression,
-        AST_NODE_TYPES.FunctionExpression,
-        AST_NODE_TYPES.Property,
-        AST_NODE_TYPES.ClassBody
-      ])
-    ),
-    AST8.is(AST_NODE_TYPES.JSXExpressionContainer)
+  const boundaryNode = AST8.findParentNode(
+    node,
+    AST8.isOneOf([
+      AST_NODE_TYPES.JSXExpressionContainer,
+      AST_NODE_TYPES.ArrowFunctionExpression,
+      AST_NODE_TYPES.FunctionExpression,
+      AST_NODE_TYPES.Property,
+      AST_NODE_TYPES.ClassBody
+    ])
   );
+  return !boundaryNode || boundaryNode.type !== AST_NODE_TYPES.JSXExpressionContainer;
 }
 function getComponentFlag(initPath) {
   let flag = ERFunctionComponentFlag.None;
-  if (AST8.hasCallInFunctionInitPath("memo")(initPath)) {
+  if (initPath && AST8.hasCallInFunctionInitPath("memo")(initPath)) {
     flag |= ERFunctionComponentFlag.Memo;
   }
-  if (AST8.hasCallInFunctionInitPath("forwardRef")(initPath)) {
+  if (initPath && AST8.hasCallInFunctionInitPath("forwardRef")(initPath)) {
     flag |= ERFunctionComponentFlag.ForwardRef;
   }
   return flag;
@@ -480,18 +470,19 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
   const jsxCtx = { getScope: (node) => context.sourceCode.getScope(node) };
   const components = /* @__PURE__ */ new Map();
   const functionEntries = [];
-  const getCurrentFunction = () => O.fromNullable(functionEntries.at(-1));
+  const getCurrentEntry = () => functionEntries.at(-1);
   const onFunctionEnter = (node) => {
     const key = getId();
     functionEntries.push({ key, node, hookCalls: [], isComponent: false });
   };
   const onFunctionExit = () => {
     const entry = functionEntries.at(-1);
-    if (!entry?.isComponent) {
+    if (!entry) return;
+    if (!entry.isComponent) {
       return functionEntries.pop();
     }
     const shouldDrop = AST8.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
-      return context.sourceCode.getScope(r).block === entry.node && r.argument != null && !JSX4.isJSXValue(r.argument, jsxCtx, hint);
+      return context.sourceCode.getScope(r).block === entry.node && !!r.argument && !JSX4.isJSXValue(r.argument, jsxCtx, hint);
     });
     if (shouldDrop) {
       components.delete(entry.key);
@@ -499,23 +490,23 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
     return functionEntries.pop();
   };
   const ctx = {
-    getAllComponents(_) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getAllComponents(node) {
       return components;
     },
-    getCurrentFunction,
-    getCurrentFunctionStack() {
+    getCurrentEntries() {
       return [...functionEntries];
-    }
+    },
+    getCurrentEntry
   };
   const listeners = {
     ":function[type]": onFunctionEnter,
     ":function[type]:exit": onFunctionExit,
     "ArrowFunctionExpression[type][body.type!='BlockStatement']"() {
-      const mbEntry = getCurrentFunction();
-      if (O.isNone(mbEntry)) {
+      const entry = getCurrentEntry();
+      if (!entry) {
         return;
       }
-      const entry = mbEntry.value;
       const { body } = entry.node;
       const isComponent = hasNoneOrValidComponentName(entry.node, context) && JSX4.isJSXValue(body, jsxCtx, hint) && hasValidHierarchy(entry.node, context, hint);
       if (!isComponent) {
@@ -523,7 +514,7 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
       }
       const initPath = AST8.getFunctionInitPath(entry.node);
       const id2 = getFunctionComponentIdentifier(entry.node, context);
-      const name = O.flatMapNullable(id2, getComponentNameFromIdentifier);
+      const name = id2 && getComponentNameFromIdentifier(id2);
       const key = getId();
       components.set(key, {
         _: key,
@@ -531,7 +522,7 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
         kind: "function",
         name,
         node: entry.node,
-        displayName: O.none(),
+        displayName: _,
         flag: getComponentFlag(initPath),
         hint,
         hookCalls: entry.hookCalls,
@@ -540,38 +531,32 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
     },
     "AssignmentExpression[type][operator='='][left.type='MemberExpression'][left.property.name='displayName']"(node) {
       const { left, right } = node;
-      const mbComponentName = match(left.object).with({ type: AST_NODE_TYPES.Identifier }, (n) => O.some(n.name)).otherwise(O.none);
-      if (O.isNone(mbComponentName)) {
-        return;
-      }
-      const componentName = mbComponentName.value;
-      const component = Array.from(components.values()).findLast(({ name }) => O.exists(name, (n) => n === componentName));
-      if (component == null) {
+      const componentName = left.object.type === AST_NODE_TYPES.Identifier ? left.object.name : _;
+      const component = [...components.values()].findLast(({ name }) => name != null && name === componentName);
+      if (!component) {
         return;
       }
       components.set(component._, {
         ...component,
-        displayName: O.some(right)
+        displayName: right
       });
     },
     "CallExpression[type]:exit"(node) {
       if (!isReactHookCall(node)) {
         return;
       }
-      const mbEntry = getCurrentFunction();
-      if (O.isNone(mbEntry)) {
+      const entry = getCurrentEntry();
+      if (!entry) {
         return;
       }
-      const entry = mbEntry.value;
       functionEntries.pop();
       functionEntries.push({ ...entry, hookCalls: [...entry.hookCalls, node] });
     },
     "ReturnStatement[type]"(node) {
-      const mbEntry = getCurrentFunction();
-      if (O.isNone(mbEntry)) {
+      const entry = getCurrentEntry();
+      if (!entry) {
         return;
       }
-      const entry = mbEntry.value;
       const isComponent = hasNoneOrValidComponentName(entry.node, context) && JSX4.isJSXValue(node.argument, jsxCtx, hint) && hasValidHierarchy(entry.node, context, hint);
       if (!isComponent) {
         return;
@@ -580,14 +565,14 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
       functionEntries.push({ ...entry, isComponent });
       const initPath = AST8.getFunctionInitPath(entry.node);
       const id2 = getFunctionComponentIdentifier(entry.node, context);
-      const name = O.flatMapNullable(id2, getComponentNameFromIdentifier);
+      const name = id2 && getComponentNameFromIdentifier(id2);
       components.set(entry.key, {
         _: entry.key,
         id: id2,
         kind: "function",
         name,
         node: entry.node,
-        displayName: O.none(),
+        displayName: _,
         flag: getComponentFlag(initPath),
         hint,
         hookCalls: entry.hookCalls,
@@ -600,7 +585,8 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
 function useComponentCollectorLegacy() {
   const components = /* @__PURE__ */ new Map();
   const ctx = {
-    getAllComponents(_) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getAllComponents(node) {
       return components;
     }
   };
@@ -617,10 +603,10 @@ function useComponentCollectorLegacy() {
         _: key,
         id: id2,
         kind: "class",
-        name: O.flatMapNullable(id2, (n) => n.name),
+        name: id2?.name,
         node,
         // TODO: Get displayName of class component
-        displayName: O.none(),
+        displayName: _,
         flag,
         hint: 0n,
         // TODO: Get methods of class component
@@ -635,18 +621,14 @@ function useComponentCollectorLegacy() {
   return { ctx, listeners };
 }
 function isSetupFunction(node) {
+  if (node === _) 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) {
-  return F.pipe(
-    O.Do,
-    O.bind("nearReturn", () => AST8.findParentNodeGuard(node, AST8.is(AST_NODE_TYPES.ReturnStatement))),
-    O.bind("nearFunction", () => AST8.findParentNodeGuard(node, AST8.isFunction)),
-    O.bind("nearFunctionOfReturn", ({ nearReturn }) => AST8.findParentNodeGuard(nearReturn, AST8.isFunction)),
-    O.exists(
-      ({ nearFunction, nearFunctionOfReturn }) => nearFunction === nearFunctionOfReturn && isSetupFunction(nearFunction)
-    )
-  );
+  const nearReturn = AST8.findParentNodeGuard(node, AST8.is(AST_NODE_TYPES.ReturnStatement));
+  const nearFunction = AST8.findParentNodeGuard(node, AST8.isFunction);
+  const nearFunctionOfReturn = AST8.findParentNodeGuard(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";
@@ -664,30 +646,26 @@ var ERPhaseRelevance = birecord({
   mount: "unmount",
   setup: "cleanup"
 });
-var isInversePhase = F.dual(2, (a, b) => ERPhaseRelevance.get(a) === b);
+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);
+  return matching(node) || !!node.parent && matching(node.parent);
 }
 function isDeclaredInRenderPropLoose(node) {
   if (isDirectValueOfRenderPropertyLoose(node)) {
     return true;
   }
-  return F.pipe(
-    AST8.findParentNodeGuard(node, AST8.is(AST_NODE_TYPES.JSXExpressionContainer)),
-    O.flatMapNullable((c) => c.parent),
-    O.filter(AST8.is(AST_NODE_TYPES.JSXAttribute)),
-    O.flatMapNullable((a) => a.name),
-    O.exists(
-      (n) => n.type === AST_NODE_TYPES.JSXIdentifier && n.name.startsWith("render")
-    )
-  );
+  const parent = AST8.findParentNodeGuard(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 (O.exists(AST8.getFunctionIdentifier(node), (id2) => id2.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 JSX4.isJSXValue(
@@ -709,4 +687,4 @@ function isThisSetState(node) {
   return callee.type === AST_NODE_TYPES.MemberExpression && AST8.isThisExpression(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
 
-export { DEFAULT_COMPONENT_HINT, ERClassComponentFlag, ERComponentHint, ERFunctionComponentFlag, ERPhaseRelevance, RE_COMPONENT_NAME, RE_HOOK_NAME, getComponentNameFromIdentifier, getElementRepresentName, 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, 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 };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@eslint-react/core",
-  "version": "1.23.3-next.8",
+  "version": "1.24.0-beta.0",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and Patterns.",
-  "homepage": "https://github.com/rEl1cx/eslint-react",
+  "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
-    "url": "https://github.com/rEl1cx/eslint-react/issues"
+    "url": "https://github.com/Rel1cx/eslint-react/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/rEl1cx/eslint-react.git",
+    "url": "git+https://github.com/Rel1cx/eslint-react.git",
     "directory": "packages/core"
   },
   "license": "MIT",
@@ -38,12 +38,12 @@
     "@typescript-eslint/types": "^8.19.1",
     "@typescript-eslint/utils": "^8.19.1",
     "ts-pattern": "^5.6.0",
-    "@eslint-react/ast": "1.23.3-next.8",
-    "@eslint-react/eff": "1.23.3-next.8",
-    "@eslint-react/shared": "1.23.3-next.8",
-    "@eslint-react/types": "1.23.3-next.8",
-    "@eslint-react/jsx": "1.23.3-next.8",
-    "@eslint-react/var": "1.23.3-next.8"
+    "@eslint-react/ast": "1.24.0-beta.0",
+    "@eslint-react/eff": "1.24.0-beta.0",
+    "@eslint-react/jsx": "1.24.0-beta.0",
+    "@eslint-react/shared": "1.24.0-beta.0",
+    "@eslint-react/types": "1.24.0-beta.0",
+    "@eslint-react/var": "1.24.0-beta.0"
   },
   "devDependencies": {
     "tsup": "^8.3.5",