@eslint-react/core 1.23.2 → 1.23.3-beta.5

package/dist/index.js

@@ -1,13 +1,13 @@
 'use strict';
 
-var AST9 = require('@eslint-react/ast');
+var AST8 = require('@eslint-react/ast');
 var eff = require('@eslint-react/eff');
 var JSX4 = require('@eslint-react/jsx');
-var types = require('@typescript-eslint/types');
+var types$1 = require('@typescript-eslint/types');
 var tsPattern = require('ts-pattern');
 var shared = require('@eslint-react/shared');
 var VAR = require('@eslint-react/var');
-var types$1 = require('@eslint-react/types');
+var types = require('@eslint-react/types');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -27,17 +27,21 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var AST9__namespace = /*#__PURE__*/_interopNamespace(AST9);
+var AST8__namespace = /*#__PURE__*/_interopNamespace(AST8);
 var JSX4__namespace = /*#__PURE__*/_interopNamespace(JSX4);
 var VAR__namespace = /*#__PURE__*/_interopNamespace(VAR);
 
 // src/component/component-collector.ts
 function getElementRepresentName(node, context) {
   const rawElementName = JSX4__namespace.getElementName(node);
-  if (rawElementName === rawElementName.toLowerCase()) return rawElementName;
+  if (rawElementName === rawElementName.toLowerCase()) {
+    return rawElementName;
+  }
   const { components, polymorphicPropName } = shared.getSettingsFromContext(context);
   const asElementName = components.get(rawElementName);
-  if (eff.isString(asElementName)) return asElementName;
+  if (eff.isString(asElementName)) {
+    return asElementName;
+  }
   return eff.F.pipe(
     eff.O.fromNullable(polymorphicPropName),
     eff.O.flatMap(JSX4__namespace.findPropInAttributes(node.attributes, context.sourceCode.getScope(node))),
@@ -63,14 +67,14 @@ function isFromReact(name) {
   return (node, context) => {
     const settings = shared.unsafeDecodeSettings(context.settings);
     if (!settings.strictImportCheck) {
-      if (node.type === types.AST_NODE_TYPES.MemberExpression) {
-        return node.object.type === types.AST_NODE_TYPES.Identifier && node.property.type === types.AST_NODE_TYPES.Identifier && node.property.name === name;
+      if (node.type === types$1.AST_NODE_TYPES.MemberExpression) {
+        return node.object.type === types$1.AST_NODE_TYPES.Identifier && node.property.type === types$1.AST_NODE_TYPES.Identifier && node.property.name === name;
       }
       return node.name === name;
     }
     const initialScope = context.sourceCode.getScope(node);
-    if (node.type === types.AST_NODE_TYPES.MemberExpression) {
-      return node.object.type === types.AST_NODE_TYPES.Identifier && node.property.type === types.AST_NODE_TYPES.Identifier && node.property.name === name && isInitializedFromReact(node.object.name, initialScope, settings.importSource);
+    if (node.type === types$1.AST_NODE_TYPES.MemberExpression) {
+      return node.object.type === types$1.AST_NODE_TYPES.Identifier && node.property.type === types$1.AST_NODE_TYPES.Identifier && node.property.name === name && isInitializedFromReact(node.object.name, initialScope, settings.importSource);
     }
     if (node.name === name) {
       return isInitializedFromReact(name, initialScope, settings.importSource);
@@ -82,19 +86,25 @@ function isFromReactMember(memberName, name) {
   return (node, context) => {
     const settings = shared.unsafeDecodeSettings(context.settings);
     if (!settings.strictImportCheck) {
-      if (node.property.type !== types.AST_NODE_TYPES.Identifier || node.property.name !== name) return false;
-      if (node.object.type === types.AST_NODE_TYPES.Identifier && node.object.name === memberName) return true;
-      if (node.object.type === types.AST_NODE_TYPES.MemberExpression && node.object.object.type === types.AST_NODE_TYPES.Identifier && node.object.property.type === types.AST_NODE_TYPES.Identifier) {
+      if (node.property.type !== types$1.AST_NODE_TYPES.Identifier || node.property.name !== name) {
+        return false;
+      }
+      if (node.object.type === types$1.AST_NODE_TYPES.Identifier && node.object.name === memberName) {
+        return true;
+      }
+      if (node.object.type === types$1.AST_NODE_TYPES.MemberExpression && node.object.object.type === types$1.AST_NODE_TYPES.Identifier && node.object.property.type === types$1.AST_NODE_TYPES.Identifier) {
         return node.object.property.name === memberName;
       }
       return false;
     }
     const initialScope = context.sourceCode.getScope(node);
-    if (node.property.type !== types.AST_NODE_TYPES.Identifier || node.property.name !== name) return false;
-    if (node.object.type === types.AST_NODE_TYPES.Identifier && node.object.name === memberName) {
+    if (node.property.type !== types$1.AST_NODE_TYPES.Identifier || node.property.name !== name) {
+      return false;
+    }
+    if (node.object.type === types$1.AST_NODE_TYPES.Identifier && node.object.name === memberName) {
       return isInitializedFromReact(node.object.name, initialScope, settings.importSource);
     }
-    if (node.object.type === types.AST_NODE_TYPES.MemberExpression && node.object.object.type === types.AST_NODE_TYPES.Identifier && isInitializedFromReact(node.object.object.name, initialScope, settings.importSource) && node.object.property.type === types.AST_NODE_TYPES.Identifier) {
+    if (node.object.type === types$1.AST_NODE_TYPES.MemberExpression && node.object.object.type === types$1.AST_NODE_TYPES.Identifier && isInitializedFromReact(node.object.object.name, initialScope, settings.importSource) && node.object.property.type === types$1.AST_NODE_TYPES.Identifier) {
       return node.object.property.name === memberName;
     }
     return false;
@@ -102,15 +112,23 @@ function isFromReactMember(memberName, name) {
 }
 function isCallFromReact(name) {
   return eff.F.dual(2, (node, context) => {
-    if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
-    if (!AST9__namespace.isOneOf([types.AST_NODE_TYPES.Identifier, types.AST_NODE_TYPES.MemberExpression])(node.callee)) return false;
+    if (node.type !== types$1.AST_NODE_TYPES.CallExpression) {
+      return false;
+    }
+    if (!AST8__namespace.isOneOf([types$1.AST_NODE_TYPES.Identifier, types$1.AST_NODE_TYPES.MemberExpression])(node.callee)) {
+      return false;
+    }
     return isFromReact(name)(node.callee, context);
   });
 }
 function isCallFromReactMember(pragmaMemberName, name) {
   return eff.F.dual(2, (node, context) => {
-    if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
-    if (!AST9__namespace.is(types.AST_NODE_TYPES.MemberExpression)(node.callee)) return false;
+    if (node.type !== types$1.AST_NODE_TYPES.CallExpression) {
+      return false;
+    }
+    if (!AST8__namespace.is(types$1.AST_NODE_TYPES.MemberExpression)(node.callee)) {
+      return false;
+    }
     return isFromReactMember(pragmaMemberName, name)(node.callee, context);
   });
 }
@@ -149,8 +167,8 @@ var isMemoCall = isReactAPICallWithName("memo");
 function isInsideCreateElementProps(node, context) {
   return eff.F.pipe(
     eff.O.Do,
-    eff.O.bind("call", () => AST9__namespace.findParentNodeGuard(node, isCreateElementCall(context))),
-    eff.O.bind("prop", () => AST9__namespace.findParentNodeGuard(node, AST9__namespace.is(types.AST_NODE_TYPES.ObjectExpression))),
+    eff.O.bind("call", () => AST8__namespace.findParentNodeGuard(node, isCreateElementCall(context))),
+    eff.O.bind("prop", () => AST8__namespace.findParentNodeGuard(node, AST8__namespace.is(types$1.AST_NODE_TYPES.ObjectExpression))),
     eff.O.bind("arg1", ({ call }) => eff.O.fromNullable(call.arguments[1])),
     eff.O.exists(({ arg1, prop }) => prop === arg1)
   );
@@ -158,7 +176,7 @@ function isInsideCreateElementProps(node, context) {
 function isChildrenOfCreateElement(node, context) {
   return eff.F.pipe(
     eff.O.fromNullable(node.parent),
-    eff.O.filter(AST9__namespace.is(types.AST_NODE_TYPES.CallExpression)),
+    eff.O.filter(AST8__namespace.is(types$1.AST_NODE_TYPES.CallExpression)),
     eff.O.filter(isCreateElementCall(context)),
     eff.O.exists(
       (n) => n.arguments.slice(2).some((arg) => arg === node)
@@ -175,16 +193,20 @@ function isReactHookName(name) {
 // src/hook/is.ts
 function isReactHook(node) {
   return eff.F.pipe(
-    AST9__namespace.getFunctionIdentifier(node),
+    AST8__namespace.getFunctionIdentifier(node),
     eff.O.flatMapNullable((id2) => id2.name),
     eff.O.exists(isReactHookName)
   );
 }
 function isReactHookCall(node) {
-  if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
-  if (node.callee.type === types.AST_NODE_TYPES.Identifier) return isReactHookName(node.callee.name);
-  if (node.callee.type === types.AST_NODE_TYPES.MemberExpression) {
-    return node.callee.property.type === types.AST_NODE_TYPES.Identifier && isReactHookName(node.callee.property.name);
+  if (node.type !== types$1.AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
+  if (node.callee.type === types$1.AST_NODE_TYPES.Identifier) {
+    return isReactHookName(node.callee.name);
+  }
+  if (node.callee.type === types$1.AST_NODE_TYPES.MemberExpression) {
+    return node.callee.property.type === types$1.AST_NODE_TYPES.Identifier && isReactHookName(node.callee.property.name);
   }
   return false;
 }
@@ -193,9 +215,9 @@ function isReactHookCallWithName(node, context) {
   return (name) => {
     const initialScope = context.sourceCode.getScope(node);
     switch (true) {
-      case (node.callee.type === types.AST_NODE_TYPES.Identifier && node.callee.name === name):
+      case (node.callee.type === types$1.AST_NODE_TYPES.Identifier && node.callee.name === name):
         return !settings.strictImportCheck || isInitializedFromReact(name, initialScope, settings.importSource);
-      case (node.callee.type === types.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
+      case (node.callee.type === types$1.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types$1.AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
         return !settings.strictImportCheck || isInitializedFromReact(node.callee.object.name, initialScope, settings.importSource);
       default:
         return false;
@@ -205,10 +227,10 @@ function isReactHookCallWithName(node, context) {
 function isReactHookCallWithNameLoose(node) {
   return (name) => {
     switch (node.callee.type) {
-      case types.AST_NODE_TYPES.Identifier:
+      case types$1.AST_NODE_TYPES.Identifier:
         return node.callee.name === name;
-      case types.AST_NODE_TYPES.MemberExpression:
-        return node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === name;
+      case types$1.AST_NODE_TYPES.MemberExpression:
+        return node.callee.property.type === types$1.AST_NODE_TYPES.Identifier && node.callee.property.name === name;
       default:
         return false;
     }
@@ -219,9 +241,9 @@ function isReactHookCallWithNameAlias(name, context, alias) {
   return (node) => {
     const initialScope = context.sourceCode.getScope(node);
     switch (true) {
-      case (node.callee.type === types.AST_NODE_TYPES.Identifier && node.callee.name === name):
+      case (node.callee.type === types$1.AST_NODE_TYPES.Identifier && node.callee.name === name):
         return !settings.strictImportCheck || isInitializedFromReact(name, initialScope, settings.importSource);
-      case (node.callee.type === types.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
+      case (node.callee.type === types$1.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types$1.AST_NODE_TYPES.Identifier && node.callee.property.name === name && "name" in node.callee.object):
         return !settings.strictImportCheck || isInitializedFromReact(node.callee.object.name, initialScope, settings.importSource);
       default:
         return alias.some(isReactHookCallWithNameLoose(node));
@@ -229,12 +251,14 @@ function isReactHookCallWithNameAlias(name, context, alias) {
   };
 }
 function isUseEffectCallLoose(node) {
-  if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== types$1.AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
   switch (node.callee.type) {
-    case types.AST_NODE_TYPES.Identifier:
+    case types$1.AST_NODE_TYPES.Identifier:
       return /^use\w*Effect$/u.test(node.callee.name);
-    case types.AST_NODE_TYPES.MemberExpression:
-      return node.callee.property.type === types.AST_NODE_TYPES.Identifier && /^use\w*Effect$/u.test(node.callee.property.name);
+    case types$1.AST_NODE_TYPES.MemberExpression:
+      return node.callee.property.type === types$1.AST_NODE_TYPES.Identifier && /^use\w*Effect$/u.test(node.callee.property.name);
     default:
       return false;
   }
@@ -257,13 +281,13 @@ var isUseTransitionCall = eff.F.flip(isReactHookCallWithName)("useTransition");
 
 // src/hook/hierarchy.ts
 function isInsideReactHook(node) {
-  return eff.O.exists(AST9__namespace.findParentNodeGuard(node, AST9__namespace.isFunction), isReactHook);
+  return eff.O.exists(AST8__namespace.findParentNodeGuard(node, AST8__namespace.isFunction), isReactHook);
 }
 function useHookCollector() {
   const hooks = /* @__PURE__ */ new Map();
   const fStack = [];
   const onFunctionEnter = (node) => {
-    const id2 = AST9__namespace.getFunctionIdentifier(node);
+    const id2 = AST8__namespace.getFunctionIdentifier(node);
     const name = eff.O.flatMapNullable(id2, (id3) => id3.name);
     if (eff.O.isSome(id2) && eff.O.isSome(name) && isReactHookName(name.value)) {
       const key = getId();
@@ -297,9 +321,13 @@ function useHookCollector() {
     ":function[type]": onFunctionEnter,
     ":function[type]:exit": onFunctionExit,
     "CallExpression[type]"(node) {
-      if (!isReactHookCall(node)) return;
+      if (!isReactHookCall(node)) {
+        return;
+      }
       const [fNode, hookId] = fStack.at(-1) ?? [];
-      if (!fNode || !hookId) return;
+      if (!fNode || !hookId) {
+        return;
+      }
       eff.F.pipe(
         eff.O.Do,
         eff.O.bind("id", () => hookId),
@@ -334,7 +362,7 @@ var ERComponentHint = {
   // Skip function component defined on class property
   SkipClassProperty: 1n << 69n
 };
-var DEFAULT_COMPONENT_HINT = 0n | ERComponentHint.SkipBooleanLiteral | ERComponentHint.SkipMapCallback | ERComponentHint.SkipNumberLiteral | ERComponentHint.SkipStringLiteral | ERComponentHint.SkipUndefinedLiteral | ERComponentHint.SkipEmptyArray | ERComponentHint.StrictArray | ERComponentHint.StrictConditional | ERComponentHint.StrictLogical;
+var DEFAULT_COMPONENT_HINT = 0n | ERComponentHint.SkipBooleanLiteral | ERComponentHint.SkipMapCallback | ERComponentHint.SkipNumberLiteral | ERComponentHint.SkipStringLiteral | ERComponentHint.SkipUndefined | ERComponentHint.SkipEmptyArray | ERComponentHint.StrictArray | ERComponentHint.StrictConditional | ERComponentHint.StrictLogical;
 
 // src/component/component-flag.ts
 var ERClassComponentFlag = {
@@ -355,17 +383,21 @@ var ERFunctionComponentFlag = {
   // Async: 1n << 4n,
 };
 function isComponentWrapperCall(node, context) {
-  if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== types$1.AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
   return isMemoCall(node, context) || isForwardRefCall(node, context) || isReactHookCallWithNameLoose(node)("useCallback");
 }
 function getFunctionComponentIdentifier(node, context) {
-  const functionId = AST9__namespace.getFunctionIdentifier(node);
-  if (eff.O.isSome(functionId)) return functionId;
+  const functionId = AST8__namespace.getFunctionIdentifier(node);
+  if (eff.O.isSome(functionId)) {
+    return functionId;
+  }
   const { parent } = node;
-  if (parent.type === types.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent, context) && parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator && parent.parent.id.type === types.AST_NODE_TYPES.Identifier) {
+  if (parent.type === types$1.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent, context) && parent.parent.type === types$1.AST_NODE_TYPES.VariableDeclarator && parent.parent.id.type === types$1.AST_NODE_TYPES.Identifier) {
     return eff.O.some(parent.parent.id);
   }
-  if (parent.type === types.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent, context) && parent.parent.type === types.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent.parent, context) && parent.parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator && parent.parent.parent.id.type === types.AST_NODE_TYPES.Identifier) {
+  if (parent.type === types$1.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent, context) && parent.parent.type === types$1.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(parent.parent, context) && parent.parent.parent.type === types$1.AST_NODE_TYPES.VariableDeclarator && parent.parent.parent.id.type === types$1.AST_NODE_TYPES.Identifier) {
     return eff.O.some(parent.parent.parent.id);
   }
   return eff.O.none();
@@ -380,98 +412,42 @@ function isComponentName(name) {
   return !!name && RE_COMPONENT_NAME.test(name);
 }
 function isClassComponent(node) {
-  if (!("superClass" in node && node.superClass)) return false;
-  const { superClass } = node;
-  return tsPattern.match(superClass).with({
-    type: types.AST_NODE_TYPES.Identifier,
-    name: tsPattern.P.string
-  }, ({ name }) => /^(?:Pure)?Component$/u.test(name)).with({
-    type: types.AST_NODE_TYPES.MemberExpression,
-    property: { name: tsPattern.P.string }
-  }, ({ property }) => /^(?:Pure)?Component$/u.test(property.name)).otherwise(() => false);
-}
-function isPureComponent(node) {
   if ("superClass" in node && node.superClass) {
-    return tsPattern.match(node.superClass).with({
-      type: types.AST_NODE_TYPES.Identifier,
-      name: tsPattern.P.string
-    }, ({ name }) => /^PureComponent$/u.test(name)).with({
-      type: types.AST_NODE_TYPES.MemberExpression,
-      property: { name: tsPattern.P.string }
-    }, ({ property }) => /^PureComponent$/u.test(property.name)).otherwise(() => false);
+    const re = /^(?:Pure)?Component$/u;
+    switch (true) {
+      case node.superClass.type === types$1.AST_NODE_TYPES.Identifier:
+        return re.test(node.superClass.name);
+      case (node.superClass.type === types$1.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types$1.AST_NODE_TYPES.Identifier):
+        return re.test(node.superClass.property.name);
+    }
   }
   return false;
 }
-function isComponentDidMount(node) {
-  return AST9__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 AST9__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 AST9__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
-}
-function isComponentWillUnmountFunction(node) {
-  return AST9__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
-}
-function useComponentCollectorLegacy() {
-  const components = /* @__PURE__ */ new Map();
-  const ctx = {
-    getAllComponents(_) {
-      return components;
+function isPureComponent(node) {
+  if ("superClass" in node && node.superClass) {
+    const re = /^PureComponent$/u;
+    switch (true) {
+      case node.superClass.type === types$1.AST_NODE_TYPES.Identifier:
+        return re.test(node.superClass.name);
+      case (node.superClass.type === types$1.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types$1.AST_NODE_TYPES.Identifier):
+        return re.test(node.superClass.property.name);
     }
-  };
-  const collect = (node) => {
-    if (!isClassComponent(node)) return;
-    const id2 = AST9__namespace.getClassIdentifier(node);
-    const key = getId();
-    const flag = isPureComponent(node) ? ERClassComponentFlag.PureComponent : ERClassComponentFlag.None;
-    components.set(
-      key,
-      {
-        _: key,
-        id: id2,
-        kind: "class",
-        name: eff.O.flatMapNullable(id2, (n) => n.name),
-        node,
-        // TODO: Get displayName of class component
-        displayName: eff.O.none(),
-        flag,
-        hint: 0n,
-        // TODO: Get methods of class component
-        methods: []
-      }
-    );
-  };
-  const listeners = {
-    "ClassDeclaration[type]": collect,
-    "ClassExpression[type]": collect
-  };
-  return { ctx, listeners };
+  }
+  return false;
 }
 
 // src/component/component-render-method.ts
-var isRenderMethodLike = tsPattern.isMatching({
-  key: {
-    type: types.AST_NODE_TYPES.Identifier,
-    name: "render"
-  },
-  type: tsPattern.P.union(types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition),
-  parent: {
-    type: types.AST_NODE_TYPES.ClassBody,
-    parent: {
-      type: types.AST_NODE_TYPES.ClassDeclaration
-    }
-  }
-});
+function isRenderMethodLike(node) {
+  return (node.type === types$1.AST_NODE_TYPES.MethodDefinition || node.type === types$1.AST_NODE_TYPES.PropertyDefinition) && node.key.type === types$1.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types$1.AST_NODE_TYPES.ClassDeclaration;
+}
 function isFunctionOfRenderMethod(node) {
-  if (!isRenderMethodLike(node.parent)) return false;
+  if (!isRenderMethodLike(node.parent)) {
+    return false;
+  }
   return isClassComponent(node.parent.parent.parent);
 }
 function isInsideRenderMethod(node) {
-  return eff.O.isSome(AST9__namespace.findParentNode(node, (node2) => {
-    return isRenderMethodLike(node2) && isClassComponent(node2.parent.parent);
-  }));
+  return eff.O.isSome(AST8__namespace.findParentNode(node, (node2) => isRenderMethodLike(node2) && isClassComponent(node2.parent.parent)));
 }
 function hasNoneOrValidComponentName(node, context) {
   const mbIdentifier = getFunctionComponentIdentifier(node, context);
@@ -488,38 +464,38 @@ function hasValidHierarchy(node, context, hint) {
   if (isChildrenOfCreateElement(node, context) || isFunctionOfRenderMethod(node)) {
     return false;
   }
-  if (hint & ERComponentHint.SkipMapCallback && AST9__namespace.isMapCallLoose(node.parent)) {
+  if (hint & ERComponentHint.SkipMapCallback && AST8__namespace.isMapCallLoose(node.parent)) {
     return false;
   }
-  if (hint & ERComponentHint.SkipObjectMethod && AST9__namespace.isFunctionOfObjectMethod(node.parent)) {
+  if (hint & ERComponentHint.SkipObjectMethod && AST8__namespace.isFunctionOfObjectMethod(node.parent)) {
     return false;
   }
-  if (hint & ERComponentHint.SkipClassMethod && AST9__namespace.isFunctionOfClassMethod(node.parent)) {
+  if (hint & ERComponentHint.SkipClassMethod && AST8__namespace.isFunctionOfClassMethod(node.parent)) {
     return false;
   }
-  if (hint & ERComponentHint.SkipClassProperty && AST9__namespace.isFunctionOfClassProperty(node.parent)) {
+  if (hint & ERComponentHint.SkipClassProperty && AST8__namespace.isFunctionOfClassProperty(node.parent)) {
     return false;
   }
   return !eff.O.exists(
-    AST9__namespace.findParentNode(
+    AST8__namespace.findParentNode(
       node,
-      AST9__namespace.isOneOf([
-        types.AST_NODE_TYPES.JSXExpressionContainer,
-        types.AST_NODE_TYPES.ArrowFunctionExpression,
-        types.AST_NODE_TYPES.FunctionExpression,
-        types.AST_NODE_TYPES.Property,
-        types.AST_NODE_TYPES.ClassBody
+      AST8__namespace.isOneOf([
+        types$1.AST_NODE_TYPES.JSXExpressionContainer,
+        types$1.AST_NODE_TYPES.ArrowFunctionExpression,
+        types$1.AST_NODE_TYPES.FunctionExpression,
+        types$1.AST_NODE_TYPES.Property,
+        types$1.AST_NODE_TYPES.ClassBody
       ])
     ),
-    AST9__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)
+    AST8__namespace.is(types$1.AST_NODE_TYPES.JSXExpressionContainer)
   );
 }
 function getComponentFlag(initPath) {
   let flag = ERFunctionComponentFlag.None;
-  if (AST9__namespace.hasCallInFunctionInitPath("memo")(initPath)) {
+  if (AST8__namespace.hasCallInFunctionInitPath("memo")(initPath)) {
     flag |= ERFunctionComponentFlag.Memo;
   }
-  if (AST9__namespace.hasCallInFunctionInitPath("forwardRef")(initPath)) {
+  if (AST8__namespace.hasCallInFunctionInitPath("forwardRef")(initPath)) {
     flag |= ERFunctionComponentFlag.ForwardRef;
   }
   return flag;
@@ -534,12 +510,16 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
     functionEntries.push({ key, node, hookCalls: [], isComponent: false });
   };
   const onFunctionExit = () => {
-    const { key, node, isComponent } = functionEntries.at(-1) ?? {};
-    if (!key || !node || !isComponent) return functionEntries.pop();
-    const shouldDrop = AST9__namespace.getNestedReturnStatements(node.body).slice().reverse().some((r) => {
-      return context.sourceCode.getScope(r).block === node && r.argument !== null && !JSX4__namespace.isJSXValue(r.argument, jsxCtx, hint);
+    const entry = functionEntries.at(-1);
+    if (!entry?.isComponent) {
+      return functionEntries.pop();
+    }
+    const shouldDrop = AST8__namespace.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
+      return context.sourceCode.getScope(r).block === entry.node && r.argument !== null && !JSX4__namespace.isJSXValue(r.argument, jsxCtx, hint);
     });
-    if (shouldDrop) components.delete(key);
+    if (shouldDrop) {
+      components.delete(entry.key);
+    }
     return functionEntries.pop();
   };
   const ctx = {
@@ -556,12 +536,16 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
     ":function[type]:exit": onFunctionExit,
     "ArrowFunctionExpression[type][body.type!='BlockStatement']"() {
       const mbEntry = getCurrentFunction();
-      if (eff.O.isNone(mbEntry)) return;
+      if (eff.O.isNone(mbEntry)) {
+        return;
+      }
       const entry = mbEntry.value;
       const { body } = entry.node;
       const isComponent = hasNoneOrValidComponentName(entry.node, context) && JSX4__namespace.isJSXValue(body, jsxCtx, hint) && hasValidHierarchy(entry.node, context, hint);
-      if (!isComponent) return;
-      const initPath = AST9__namespace.getFunctionInitPath(entry.node);
+      if (!isComponent) {
+        return;
+      }
+      const initPath = AST8__namespace.getFunctionInitPath(entry.node);
       const id2 = getFunctionComponentIdentifier(entry.node, context);
       const name = eff.O.flatMapNullable(id2, getComponentNameFromIdentifier);
       const key = getId();
@@ -580,33 +564,45 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
     },
     "AssignmentExpression[type][operator='='][left.type='MemberExpression'][left.property.name='displayName']"(node) {
       const { left, right } = node;
-      const mbComponentName = tsPattern.match(left.object).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => eff.O.some(n.name)).otherwise(eff.O.none);
-      if (eff.O.isNone(mbComponentName)) return;
+      const mbComponentName = tsPattern.match(left.object).with({ type: types$1.AST_NODE_TYPES.Identifier }, (n) => eff.O.some(n.name)).otherwise(eff.O.none);
+      if (eff.O.isNone(mbComponentName)) {
+        return;
+      }
       const componentName = mbComponentName.value;
       const component = Array.from(components.values()).findLast(({ name }) => eff.O.exists(name, (n) => n === componentName));
-      if (!component) return;
+      if (!component) {
+        return;
+      }
       components.set(component._, {
         ...component,
         displayName: eff.O.some(right)
       });
     },
     "CallExpression[type]:exit"(node) {
-      if (!isReactHookCall(node)) return;
+      if (!isReactHookCall(node)) {
+        return;
+      }
       const mbEntry = getCurrentFunction();
-      if (eff.O.isNone(mbEntry)) return;
+      if (eff.O.isNone(mbEntry)) {
+        return;
+      }
       const entry = mbEntry.value;
       functionEntries.pop();
       functionEntries.push({ ...entry, hookCalls: [...entry.hookCalls, node] });
     },
     "ReturnStatement[type]"(node) {
       const mbEntry = getCurrentFunction();
-      if (eff.O.isNone(mbEntry)) return;
+      if (eff.O.isNone(mbEntry)) {
+        return;
+      }
       const entry = mbEntry.value;
       const isComponent = hasNoneOrValidComponentName(entry.node, context) && JSX4__namespace.isJSXValue(node.argument, jsxCtx, hint) && hasValidHierarchy(entry.node, context, hint);
-      if (!isComponent) return;
+      if (!isComponent) {
+        return;
+      }
       functionEntries.pop();
       functionEntries.push({ ...entry, isComponent });
-      const initPath = AST9__namespace.getFunctionInitPath(entry.node);
+      const initPath = AST8__namespace.getFunctionInitPath(entry.node);
       const id2 = getFunctionComponentIdentifier(entry.node, context);
       const name = eff.O.flatMapNullable(id2, getComponentNameFromIdentifier);
       components.set(entry.key, {
@@ -625,18 +621,71 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT) {
   };
   return { ctx, listeners };
 }
+function useComponentCollectorLegacy() {
+  const components = /* @__PURE__ */ new Map();
+  const ctx = {
+    getAllComponents(_) {
+      return components;
+    }
+  };
+  const collect = (node) => {
+    if (!isClassComponent(node)) {
+      return;
+    }
+    const id2 = AST8__namespace.getClassIdentifier(node);
+    const key = getId();
+    const flag = isPureComponent(node) ? ERClassComponentFlag.PureComponent : ERClassComponentFlag.None;
+    components.set(
+      key,
+      {
+        _: key,
+        id: id2,
+        kind: "class",
+        name: eff.O.flatMapNullable(id2, (n) => n.name),
+        node,
+        // TODO: Get displayName of class component
+        displayName: eff.O.none(),
+        flag,
+        hint: 0n,
+        // TODO: Get methods of class component
+        methods: []
+      }
+    );
+  };
+  const listeners = {
+    "ClassDeclaration[type]": collect,
+    "ClassExpression[type]": collect
+  };
+  return { ctx, listeners };
+}
 function isSetupFunction(node) {
-  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);
+  return node.parent?.type === types$1.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === types$1.AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
 }
 function isCleanupFunction(node) {
-  const nearestRet = eff.O.getOrNull(AST9__namespace.findParentNodeGuard(node, AST9__namespace.is(types.AST_NODE_TYPES.ReturnStatement)));
-  if (!nearestRet) return false;
-  const nearestFunction = eff.O.getOrNull(AST9__namespace.findParentNodeGuard(node, AST9__namespace.isFunction));
-  const nearestFunctionOfRet = eff.O.getOrNull(AST9__namespace.findParentNodeGuard(nearestRet, AST9__namespace.isFunction));
-  if (!nearestFunction || !nearestFunctionOfRet) return false;
+  const nearestRet = eff.O.getOrNull(AST8__namespace.findParentNodeGuard(node, AST8__namespace.is(types$1.AST_NODE_TYPES.ReturnStatement)));
+  if (!nearestRet) {
+    return false;
+  }
+  const nearestFunction = eff.O.getOrNull(AST8__namespace.findParentNodeGuard(node, AST8__namespace.isFunction));
+  const nearestFunctionOfRet = eff.O.getOrNull(AST8__namespace.findParentNodeGuard(nearestRet, AST8__namespace.isFunction));
+  if (!nearestFunction || !nearestFunctionOfRet) {
+    return false;
+  }
   return nearestFunction === nearestFunctionOfRet && isSetupFunction(nearestFunction);
 }
-var ERPhaseRelevance = types$1.birecord({
+function isComponentDidMount(node) {
+  return AST8__namespace.isOneOf([types$1.AST_NODE_TYPES.MethodDefinition, types$1.AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === types$1.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+}
+function isComponentWillUnmount(node) {
+  return AST8__namespace.isOneOf([types$1.AST_NODE_TYPES.MethodDefinition, types$1.AST_NODE_TYPES.PropertyDefinition])(node) && node.key.type === types$1.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 = types.birecord({
   mount: "unmount",
   setup: "cleanup"
 });
@@ -644,10 +693,10 @@ var isInversePhase = eff.F.dual(2, (a, b) => ERPhaseRelevance.get(a) === b);
 function isDirectValueOfRenderPropertyLoose(node) {
   const matching = tsPattern.isMatching({
     key: {
-      type: types.AST_NODE_TYPES.Identifier,
+      type: types$1.AST_NODE_TYPES.Identifier,
       name: tsPattern.P.string.startsWith("render")
     },
-    type: types.AST_NODE_TYPES.Property
+    type: types$1.AST_NODE_TYPES.Property
   });
   return matching(node) || matching(node.parent);
 }
@@ -656,36 +705,38 @@ function isDeclaredInRenderPropLoose(node) {
     return true;
   }
   return eff.F.pipe(
-    AST9__namespace.findParentNodeGuard(node, AST9__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)),
+    AST8__namespace.findParentNodeGuard(node, AST8__namespace.is(types$1.AST_NODE_TYPES.JSXExpressionContainer)),
     eff.O.flatMapNullable((c) => c.parent),
-    eff.O.filter(AST9__namespace.is(types.AST_NODE_TYPES.JSXAttribute)),
+    eff.O.filter(AST8__namespace.is(types$1.AST_NODE_TYPES.JSXAttribute)),
     eff.O.flatMapNullable((a) => a.name),
     eff.O.exists(tsPattern.isMatching({
-      type: types.AST_NODE_TYPES.JSXIdentifier,
+      type: types$1.AST_NODE_TYPES.JSXIdentifier,
       name: tsPattern.P.string.startsWith("render")
     }))
   );
 }
 function isRenderFunctionLoose(node, context) {
   const { body, parent } = node;
-  if (eff.O.exists(AST9__namespace.getFunctionIdentifier(node), (id2) => id2.name.startsWith("render"))) {
-    return parent.type === types.AST_NODE_TYPES.JSXExpressionContainer && parent.parent.type === types.AST_NODE_TYPES.JSXAttribute && parent.parent.name.type === types.AST_NODE_TYPES.JSXIdentifier && parent.parent.name.name.startsWith("render");
+  if (eff.O.exists(AST8__namespace.getFunctionIdentifier(node), (id2) => id2.name.startsWith("render"))) {
+    return parent.type === types$1.AST_NODE_TYPES.JSXExpressionContainer && parent.parent.type === types$1.AST_NODE_TYPES.JSXAttribute && parent.parent.name.type === types$1.AST_NODE_TYPES.JSXIdentifier && parent.parent.name.name.startsWith("render");
   }
   return JSX4__namespace.isJSXValue(
     body,
     {
       getScope: (node2) => context.sourceCode.getScope(node2)
     },
-    JSX4__namespace.JSXValueHint.SkipNullLiteral | JSX4__namespace.JSXValueHint.SkipUndefinedLiteral | JSX4__namespace.JSXValueHint.StrictLogical | JSX4__namespace.JSXValueHint.StrictConditional
+    JSX4__namespace.JSXValueHint.SkipNullLiteral | JSX4__namespace.JSXValueHint.SkipUndefined | JSX4__namespace.JSXValueHint.StrictLogical | JSX4__namespace.JSXValueHint.StrictConditional
   );
 }
 function isRenderPropLoose(node, context) {
-  if (node.name.type !== types.AST_NODE_TYPES.JSXIdentifier) return false;
-  return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST9__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(node.value.expression, context);
+  if (node.name.type !== types$1.AST_NODE_TYPES.JSXIdentifier) {
+    return false;
+  }
+  return node.name.name.startsWith("render") && node.value?.type === types$1.AST_NODE_TYPES.JSXExpressionContainer && AST8__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(node.value.expression, context);
 }
 function isThisSetState(node) {
   const { callee } = node;
-  return callee.type === types.AST_NODE_TYPES.MemberExpression && AST9__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
+  return callee.type === types$1.AST_NODE_TYPES.MemberExpression && AST8__namespace.isThisExpression(callee.object) && callee.property.type === types$1.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
 
 exports.DEFAULT_COMPONENT_HINT = DEFAULT_COMPONENT_HINT;
@@ -752,6 +803,7 @@ exports.isReactHookCallWithNameAlias = isReactHookCallWithNameAlias;
 exports.isReactHookCallWithNameLoose = isReactHookCallWithNameLoose;
 exports.isReactHookName = isReactHookName;
 exports.isRenderFunctionLoose = isRenderFunctionLoose;
+exports.isRenderMethodLike = isRenderMethodLike;
 exports.isRenderPropLoose = isRenderPropLoose;
 exports.isSetupFunction = isSetupFunction;
 exports.isThisSetState = isThisSetState;