@eslint-react/core 1.28.0-beta.1 → 1.28.0-beta.6

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var AST9 = require('@eslint-react/ast');
+var AST8 = require('@eslint-react/ast');
 var eff = require('@eslint-react/eff');
 var JSX3 = require('@eslint-react/jsx');
 var shared = require('@eslint-react/shared');
@@ -29,27 +29,489 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var AST9__namespace = /*#__PURE__*/_interopNamespace(AST9);
+var AST8__namespace = /*#__PURE__*/_interopNamespace(AST8);
 var JSX3__namespace = /*#__PURE__*/_interopNamespace(JSX3);
 var VAR__namespace = /*#__PURE__*/_interopNamespace(VAR);
 var birecord__default = /*#__PURE__*/_interopDefault(birecord);
 
 // src/component/component-collector.ts
-var DISPLAY_NAME_ASSIGNMENT_SELECTOR = [
-  "AssignmentExpression",
-  "[type]",
-  "[operator='=']",
-  "[left.type='MemberExpression']",
-  "[left.property.name='displayName']"
-].join("");
-function isDisplayNameAssignment(node) {
-  if (node == null) return false;
-  return node.type === types.AST_NODE_TYPES.AssignmentExpression && node.operator === "=" && node.left.type === types.AST_NODE_TYPES.MemberExpression && node.left.property.type === types.AST_NODE_TYPES.Identifier && node.left.property.name === "displayName";
+
+// ../../node_modules/.pnpm/valibot@1.0.0-rc.2_typescript@5.8.1-rc/node_modules/valibot/dist/index.js
+var store;
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config2) {
+  return {
+    lang: config2?.lang ?? store?.lang,
+    message: config2?.message,
+    abortEarly: config2?.abortEarly ?? store?.abortEarly,
+    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+  };
+}
+var store2;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store2?.get(lang);
+}
+var store3;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store3?.get(lang);
+}
+var store4;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  return store4?.get(reference)?.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") {
+    return `"${input}"`;
+  }
+  if (type === "number" || type === "bigint" || type === "boolean") {
+    return `${input}`;
+  }
+  if (type === "object" || type === "function") {
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  }
+  return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config2.lang,
+    abortEarly: config2.abortEarly,
+    abortPipeEarly: config2.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message) {
+    issue.message = typeof message === "function" ? (
+      // @ts-expect-error
+      message(issue)
+    ) : message;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value2) {
+      return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+    }
+  };
+}
+var ValiError = class extends Error {
+  /**
+   * Creates a Valibot error with useful information.
+   *
+   * @param issues The error issues.
+   */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema, dataset, config2) {
+  return typeof schema.fallback === "function" ? (
+    // @ts-expect-error
+    schema.fallback(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.fallback
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value2 = input[key];
+          const itemDataset = this.item["~run"]({ value: value2 }, config2);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value2
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) {
+                issue.path.unshift(pathItem);
+              } else {
+                issue.path = [pathItem];
+              }
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) {
+              dataset.issues = itemDataset.issues;
+            }
+            if (config2.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) {
+            dataset.typed = false;
+          }
+          dataset.value.push(itemDataset.value);
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries, message) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && // @ts-expect-error
+          valueSchema.default !== void 0) {
+            const value2 = key in input ? (
+              // @ts-expect-error
+              input[key]
+            ) : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value2
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) {
+              dataset.typed = false;
+            }
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) {
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config2, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [
+                {
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  // @ts-expect-error
+                  value: input[key]
+                }
+              ]
+            });
+            if (config2.abortEarly) {
+              break;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
 }
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) {
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config2);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function parse(schema, input, config2) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+  if (dataset.issues) {
+    throw new ValiError(dataset.issues);
+  }
+  return dataset.value;
+}
+
+// ../shared/src/schemas.ts
+var CustomComponentPropSchema = object({
+  /**
+   * The name of the prop in the user-defined component.
+   * @example
+   * "to"
+   */
+  name: string(),
+  /**
+   * The name of the prop in the built-in component.
+   * @example
+   * "href"
+   */
+  as: optional(string()),
+  /**
+   * Whether the prop is controlled or not in the user-defined component.
+   * @example
+   * `true`
+   */
+  controlled: optional(boolean()),
+  /**
+   * The default value of the prop in the user-defined component.
+   * @example
+   * `"/"`
+   */
+  defaultValue: optional(string())
+});
+var CustomComponentSchema = object({
+  /**
+   * The name of the user-defined component.
+   * @example
+   * "Link"
+   */
+  name: string(),
+  /**
+   * The name of the built-in component that the user-defined component represents.
+   * @example
+   * "a"
+   */
+  as: optional(string()),
+  /**
+   * Attributes mapping between the user-defined component and the built-in component.
+   * @example
+   * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
+   */
+  attributes: optional(array(CustomComponentPropSchema)),
+  /**
+   * The ESQuery selector to select the component precisely.
+   * @internal
+   * @example
+   * `JSXElement:has(JSXAttribute[name.name='component'][value.value='a'])`
+   */
+  selector: optional(string())
+});
+var CustomHooksSchema = object({
+  use: optional(array(string())),
+  useActionState: optional(array(string())),
+  useCallback: optional(array(string())),
+  useContext: optional(array(string())),
+  useDebugValue: optional(array(string())),
+  useDeferredValue: optional(array(string())),
+  useEffect: optional(array(string())),
+  useFormStatus: optional(array(string())),
+  useId: optional(array(string())),
+  useImperativeHandle: optional(array(string())),
+  useInsertionEffect: optional(array(string())),
+  useLayoutEffect: optional(array(string())),
+  useMemo: optional(array(string())),
+  useOptimistic: optional(array(string())),
+  useReducer: optional(array(string())),
+  useRef: optional(array(string())),
+  useState: optional(array(string())),
+  useSyncExternalStore: optional(array(string())),
+  useTransition: optional(array(string()))
+});
+var ESLintReactSettingsSchema = object({
+  /**
+   * The source where React is imported from.
+   * @description This allows to specify a custom import location for React when not using the official distribution.
+   * @default `"react"`
+   * @example `"@pika/react"`
+   */
+  importSource: optional(string()),
+  /**
+   * The identifier that’s used for JSX Element creation.
+   * @default `"createElement"`
+   * @deprecated
+   */
+  jsxPragma: optional(string()),
+  /**
+   * The identifier that’s used for JSX fragment elements.
+   * @description This should not be a member expression (i.e. use "Fragment" instead of "React.Fragment").
+   * @default `"Fragment"`
+   * @deprecated
+   */
+  jsxPragmaFrag: optional(string()),
+  /**
+   * The name of the prop that is used for polymorphic components.
+   * @description This is used to determine the type of the component.
+   * @example `"as"`
+   */
+  polymorphicPropName: optional(string()),
+  /**
+   * @internal
+   */
+  strict: optional(boolean(), false),
+  /**
+   * Check both the shape and the import to determine if an API is from React.
+   * @description This can prevent false positives when using a irrelevant third-party library that has similar APIs to React.
+   * @default `true`
+   */
+  skipImportCheck: optional(boolean(), true),
+  /**
+   * React version to use, "detect" means auto detect React version from the project’s dependencies.
+   * If `importSource` is specified, an equivalent version of React should be provided here.
+   * @example `"18.3.1"`
+   * @default `"detect"`
+   */
+  version: optional(string()),
+  /**
+   * A object to define additional hooks that are equivalent to the built-in React Hooks.
+   * @description ESLint React will recognize these aliases as equivalent to the built-in hooks in all its rules.
+   * @example `{ useEffect: ["useIsomorphicLayoutEffect"] }`
+   */
+  additionalHooks: optional(CustomHooksSchema),
+  /**
+   * An array of user-defined components
+   * @description This is used to inform the ESLint React plugins how to treat these components during checks.
+   * @example `[{ name: "Link", as: "a", attributes: [{ name: "to", as: "href" }, { name: "rel", defaultValue: "noopener noreferrer" }] }]`
+   */
+  additionalComponents: optional(array(CustomComponentSchema))
+});
+var DEFAULT_ESLINT_REACT_SETTINGS = {
+  ...parse(ESLintReactSettingsSchema, {}),
+  importSource: "react"};
 function getRequireExpressionArguments(node) {
   return tsPattern.match(node).with({ type: types.AST_NODE_TYPES.CallExpression, arguments: tsPattern.P.select(), callee: { type: types.AST_NODE_TYPES.Identifier, name: "require" } }, eff.identity).with({ type: types.AST_NODE_TYPES.MemberExpression, object: tsPattern.P.select() }, getRequireExpressionArguments).otherwise(() => eff._);
 }
-function isInitializedFromReact(name, source, initialScope) {
+function isInitializedFromReact(name, importSource, initialScope) {
   if (name.toLowerCase() === "react") return true;
   const latestDef = VAR__namespace.findVariable(name, initialScope)?.defs.at(-1);
   if (latestDef == null) return false;
@@ -57,81 +519,101 @@ function isInitializedFromReact(name, source, initialScope) {
   if (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init != null) {
     const { init } = node;
     if (init.type === types.AST_NODE_TYPES.MemberExpression && init.object.type === types.AST_NODE_TYPES.Identifier) {
-      return isInitializedFromReact(init.object.name, source, initialScope);
+      return isInitializedFromReact(init.object.name, importSource, initialScope);
     }
     if (init.type === types.AST_NODE_TYPES.Identifier) {
-      return isInitializedFromReact(init.name, source, initialScope);
+      return isInitializedFromReact(init.name, importSource, initialScope);
     }
     const args = getRequireExpressionArguments(init);
     const arg0 = args?.[0];
-    if (arg0 == null || !AST9__namespace.isStringLiteral(arg0)) {
+    if (arg0 == null || !AST8__namespace.isKindOfLiteral(arg0, "string")) {
       return false;
     }
-    return arg0.value === source || arg0.value.startsWith(`${source}/`);
+    return arg0.value === importSource || arg0.value.startsWith(`${importSource}/`);
   }
-  return parent?.type === types.AST_NODE_TYPES.ImportDeclaration && parent.source.value === source;
+  return parent?.type === types.AST_NODE_TYPES.ImportDeclaration && parent.source.value === importSource;
 }
 
 // src/utils/is-from-react.ts
+var defaultImportSource = shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource;
+function isFromReactLoose(node, name) {
+  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;
+  }
+  return node.name === name;
+}
+function isFromReactStrict(node, name, importSource, initialScope) {
+  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, importSource, initialScope);
+  }
+  if (node.name === name) {
+    return isInitializedFromReact(name, importSource, initialScope);
+  }
+  return false;
+}
 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;
-      }
-      return node.name === name;
-    }
-    const importSource = settings.importSource ?? shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource;
-    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, importSource, initialScope);
-    }
-    if (node.name === name) {
-      return isInitializedFromReact(name, importSource, initialScope);
-    }
-    return false;
+  return (context, node) => {
+    const { importSource = defaultImportSource, skipImportCheck = true } = shared.unsafeDecodeSettings(context.settings);
+    if (skipImportCheck) return isFromReactLoose(node, name);
+    return isFromReactStrict(node, name, importSource, context.sourceCode.getScope(node));
   };
 }
-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) {
-        return node.object.property.name === memberName;
-      }
-      return false;
-    }
-    const importSource = settings.importSource ?? shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource;
-    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) {
-      return isInitializedFromReact(node.object.name, importSource, initialScope);
-    }
-    if (node.object.type === types.AST_NODE_TYPES.MemberExpression && node.object.object.type === types.AST_NODE_TYPES.Identifier && isInitializedFromReact(node.object.object.name, importSource, initialScope) && node.object.property.type === types.AST_NODE_TYPES.Identifier) {
-      return node.object.property.name === memberName;
-    }
+function isFromReactMemberLoose(node, memberName, name) {
+  const { object: object2, property } = node;
+  if (property.type !== types.AST_NODE_TYPES.Identifier || property.name !== name) return false;
+  if (object2.type === types.AST_NODE_TYPES.Identifier && object2.name === memberName) return true;
+  if (object2.type === types.AST_NODE_TYPES.MemberExpression && object2.object.type === types.AST_NODE_TYPES.Identifier && object2.property.type === types.AST_NODE_TYPES.Identifier) {
+    return object2.property.name === memberName;
+  }
+  return false;
+}
+function isFromReactMemberStrict(node, memberName, name, importSource, initialScope) {
+  const { object: object2, property } = node;
+  if (property.type !== types.AST_NODE_TYPES.Identifier || property.name !== name) {
     return false;
+  }
+  if (object2.type === types.AST_NODE_TYPES.Identifier && object2.name === memberName) {
+    return isInitializedFromReact(object2.name, importSource, initialScope);
+  }
+  if (object2.type === types.AST_NODE_TYPES.MemberExpression && object2.object.type === types.AST_NODE_TYPES.Identifier && isInitializedFromReact(object2.object.name, importSource, initialScope) && object2.property.type === types.AST_NODE_TYPES.Identifier) {
+    return object2.property.name === memberName;
+  }
+  return false;
+}
+function isFromReactMember(memberName, name) {
+  return (context, node) => {
+    const { importSource = defaultImportSource, skipImportCheck = true } = shared.unsafeDecodeSettings(context.settings);
+    if (skipImportCheck) return isFromReactMemberLoose(node, memberName, name);
+    return isFromReactMemberStrict(node, memberName, name, importSource, context.sourceCode.getScope(node));
   };
 }
+
+// src/utils/is-call-from-react.ts
 function isCallFromReact(name) {
-  return eff.dual(2, (node, context) => {
+  return eff.dual(2, (context, node) => {
     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;
-    return isFromReact(name)(node.callee, context);
+    if (!AST8__namespace.isOneOf([types.AST_NODE_TYPES.Identifier, types.AST_NODE_TYPES.MemberExpression])(node.callee)) return false;
+    return isFromReact(name)(context, node.callee);
   });
 }
 function isCallFromReactMember(pragmaMemberName, name) {
-  return eff.dual(2, (node, context) => {
+  return eff.dual(2, (context, node) => {
     if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
-    if (!AST9__namespace.is(types.AST_NODE_TYPES.MemberExpression)(node.callee)) return false;
-    return isFromReactMember(pragmaMemberName, name)(node.callee, context);
+    if (!AST8__namespace.is(types.AST_NODE_TYPES.MemberExpression)(node.callee)) return false;
+    return isFromReactMember(pragmaMemberName, name)(context, node.callee);
   });
 }
+var DISPLAY_NAME_ASSIGNMENT_SELECTOR = [
+  "AssignmentExpression",
+  "[type]",
+  "[operator='=']",
+  "[left.type='MemberExpression']",
+  "[left.property.name='displayName']"
+].join("");
+function isDisplayNameAssignment(node) {
+  if (node == null) return false;
+  return node.type === types.AST_NODE_TYPES.AssignmentExpression && node.operator === "=" && node.left.type === types.AST_NODE_TYPES.MemberExpression && node.left.property.type === types.AST_NODE_TYPES.Identifier && node.left.property.name === "displayName";
+}
 
 // src/utils/is-react-api.ts
 function isReactAPIWithName(name, member) {
@@ -163,21 +645,6 @@ var isCreateRefCall = isReactAPICallWithName("createRef");
 var isForwardRefCall = isReactAPICallWithName("forwardRef");
 var isMemoCall = isReactAPICallWithName("memo");
 
-// src/element/hierarchy.ts
-function isInsideCreateElementProps(node, context) {
-  const call = AST9__namespace.findParentNode(node, isCreateElementCall(context));
-  if (call == null) return false;
-  const prop = AST9__namespace.findParentNode(node, AST9__namespace.is(types.AST_NODE_TYPES.ObjectExpression));
-  if (prop == null) return false;
-  return prop === call.arguments[1];
-}
-function isChildrenOfCreateElement(node, context) {
-  const parent = node.parent;
-  if (parent == null || parent.type !== types.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
 var RE_HOOK_NAME = /^use[A-Z\d]/u;
 function isReactHookName(name) {
@@ -187,7 +654,7 @@ function isReactHookName(name) {
 // src/hook/is.ts
 function isReactHook(node) {
   if (node == null) return eff._;
-  const id = AST9__namespace.getFunctionIdentifier(node);
+  const id = AST8__namespace.getFunctionIdentifier(node);
   return id?.name != null && isReactHookName(id.name);
 }
 function isReactHookCall(node) {
@@ -203,17 +670,19 @@ function isReactHookCall(node) {
   }
   return false;
 }
-function isReactHookCallWithName(node, context) {
+function isReactHookCallWithName(context, node) {
   if (node == null) return eff.constFalse;
-  const settings = shared.unsafeDecodeSettings(context.settings);
-  const importSource = settings.importSource ?? "react";
+  const {
+    importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
+    skipImportCheck = true
+  } = shared.unsafeDecodeSettings(context.settings);
   const initialScope = context.sourceCode.getScope(node);
   return (name) => {
     switch (true) {
       case (node.callee.type === types.AST_NODE_TYPES.Identifier && node.callee.name === name):
-        return !settings.strictImportCheck || isInitializedFromReact(name, importSource, initialScope);
+        return skipImportCheck || isInitializedFromReact(name, importSource, initialScope);
       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):
-        return !settings.strictImportCheck || isInitializedFromReact(node.callee.object.name, importSource, initialScope);
+        return skipImportCheck || isInitializedFromReact(node.callee.object.name, importSource, initialScope);
       default:
         return false;
     }
@@ -232,16 +701,18 @@ function isReactHookCallWithNameLoose(node) {
     }
   };
 }
-function isReactHookCallWithNameAlias(name, context, alias) {
-  const settings = shared.unsafeDecodeSettings(context);
-  const importSource = settings.importSource ?? "react";
+function isReactHookCallWithNameAlias(context, name, alias) {
+  const {
+    importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
+    skipImportCheck = true
+  } = shared.unsafeDecodeSettings(context.settings);
   return (node) => {
     const initialScope = context.sourceCode.getScope(node);
     switch (true) {
       case (node.callee.type === types.AST_NODE_TYPES.Identifier && node.callee.name === name):
-        return !settings.strictImportCheck || isInitializedFromReact(name, importSource, initialScope);
+        return skipImportCheck || isInitializedFromReact(name, importSource, initialScope);
       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):
-        return !settings.strictImportCheck || isInitializedFromReact(node.callee.object.name, importSource, initialScope);
+        return skipImportCheck || isInitializedFromReact(node.callee.object.name, importSource, initialScope);
       default:
         return alias.some(isReactHookCallWithNameLoose(node));
     }
@@ -279,13 +750,13 @@ var isUseTransitionCall = eff.flip(isReactHookCallWithName)("useTransition");
 
 // src/hook/hierarchy.ts
 function isInsideReactHook(node) {
-  return isReactHook(AST9__namespace.findParentNode(node, AST9__namespace.isFunction));
+  return isReactHook(AST8__namespace.findParentNode(node, AST8__namespace.isFunction));
 }
 function useHookCollector() {
   const hooks = /* @__PURE__ */ new Map();
   const functionEntries = [];
   const onFunctionEnter = (node) => {
-    const id = AST9__namespace.getFunctionIdentifier(node);
+    const id = AST8__namespace.getFunctionIdentifier(node);
     const key = shared.getId();
     const name = id?.name;
     if (name != null && isReactHookName(name)) {
@@ -374,26 +845,53 @@ var ERComponentFlag = {
   ForwardRef: 1n << 3n,
   Async: 1n << 4n
 };
-function isComponentWrapperCall(node, context) {
+function isComponentWrapperCall(context, node) {
   if (node.type !== types.AST_NODE_TYPES.CallExpression) {
     return false;
   }
-  return isMemoCall(node, context) || isForwardRefCall(node, context) || isReactHookCallWithNameLoose(node)("useCallback");
+  return isMemoCall(context, node) || isForwardRefCall(context, node) || isReactHookCallWithNameLoose(node)("useCallback");
 }
-function getFunctionComponentIdentifier(node, context) {
-  const functionId = AST9__namespace.getFunctionIdentifier(node);
+function getFunctionComponentIdentifier(context, node) {
+  const functionId = AST8__namespace.getFunctionIdentifier(node);
   if (functionId != null) {
     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.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(context, parent) && parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator && parent.parent.id.type === types.AST_NODE_TYPES.Identifier) {
     return 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.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(context, parent) && parent.parent.type === types.AST_NODE_TYPES.CallExpression && isComponentWrapperCall(context, parent.parent) && parent.parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator && parent.parent.parent.id.type === types.AST_NODE_TYPES.Identifier) {
     return parent.parent.parent.id;
   }
   return eff._;
 }
+var RE_COMPONENT_NAME = /^_?[A-Z]/u;
+function getComponentNameFromIdentifier(node) {
+  if (node == null) return eff._;
+  return Array.isArray(node) ? node.map((n) => n.name).join(".") : node.name;
+}
+function isComponentName(name) {
+  return RE_COMPONENT_NAME.test(name);
+}
+function hasNoneOrValidComponentName(context, node) {
+  const id = getFunctionComponentIdentifier(context, node);
+  if (id == null) return true;
+  const name = Array.isArray(id) ? id.at(-1)?.name : id.name;
+  return name != null && isComponentName(name);
+}
+function isInsideCreateElementProps(context, node) {
+  const call = AST8__namespace.findParentNode(node, isCreateElementCall(context));
+  if (call == null) return false;
+  const prop = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.ObjectExpression));
+  if (prop == null) return false;
+  return prop === call.arguments[1];
+}
+function isChildrenOfCreateElement(context, node) {
+  const parent = node.parent;
+  if (parent == null || parent.type !== types.AST_NODE_TYPES.CallExpression) return false;
+  if (!isCreateElementCall(context, parent)) return false;
+  return parent.arguments.slice(2).some((arg) => arg === node);
+}
 function isClassComponent(node) {
   if ("superClass" in node && node.superClass != null) {
     const re = /^(?:Pure)?Component$/u;
@@ -421,28 +919,28 @@ function isPureComponent(node) {
 
 // src/component/component-lifecycle.ts
 function isComponentDidMount(node) {
-  return AST9__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+  return AST8__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
 }
 function isComponentWillUnmount(node) {
-  return AST9__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
+  return AST8__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
 }
 function isComponentDidCatch(node) {
-  return AST9__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
 }
 function isGetDerivedStateFromError(node) {
-  return AST9__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
+  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
 }
 function isGetDerivedStateFromProps(node) {
-  return AST9__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
+  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
 }
 function isFunctionOfComponentDidMount(node) {
-  return AST9__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+  return AST8__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
 }
 function isFunctionOfComponentWillUnmount(node) {
-  return AST9__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+  return AST8__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
 }
 function isRenderMethodLike(node) {
-  return AST9__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
+  return AST8__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
 }
 function isFunctionOfRenderMethod(node) {
   if (!isRenderMethodLike(node.parent)) {
@@ -451,21 +949,46 @@ function isFunctionOfRenderMethod(node) {
   return isClassComponent(node.parent.parent.parent);
 }
 function isInsideRenderMethod(node) {
-  return AST9__namespace.findParentNode(node, (node2) => isRenderMethodLike(node2) && isClassComponent(node2.parent.parent)) != null;
+  return AST8__namespace.findParentNode(node, (node2) => isRenderMethodLike(node2) && isClassComponent(node2.parent.parent)) != null;
 }
-var RE_COMPONENT_NAME = /^_?[A-Z]/u;
-function getComponentNameFromIdentifier(node) {
-  if (node == null) return eff._;
-  return Array.isArray(node) ? node.map((n) => n.name).join(".") : node.name;
+
+// src/component/hierarchy.ts
+function hasValidHierarchy(context, node, hint) {
+  if (isChildrenOfCreateElement(context, node) || isFunctionOfRenderMethod(node)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipMapCallback && AST8__namespace.isMapCallLoose(node.parent)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipObjectMethod && isFunctionOfObjectMethod(node.parent)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipClassMethod && isFunctionOfClassMethod(node.parent)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipClassProperty && isFunctionOfClassProperty(node.parent)) {
+    return false;
+  }
+  const boundaryNode = AST8__namespace.findParentNode(
+    node,
+    AST8__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
+    ])
+  );
+  return boundaryNode == null || boundaryNode.type !== types.AST_NODE_TYPES.JSXExpressionContainer;
 }
-function isComponentName(name) {
-  return RE_COMPONENT_NAME.test(name);
+function isFunctionOfClassMethod(node) {
+  return (node.type === types.AST_NODE_TYPES.FunctionExpression || node.type === types.AST_NODE_TYPES.ArrowFunctionExpression) && node.parent.type === types.AST_NODE_TYPES.MethodDefinition;
 }
-function hasNoneOrValidComponentName(node, context) {
-  const id = getFunctionComponentIdentifier(node, context);
-  if (id == null) return true;
-  const name = Array.isArray(id) ? id.at(-1)?.name : id.name;
-  return name != null && isComponentName(name);
+function isFunctionOfClassProperty(node) {
+  return (node.type === types.AST_NODE_TYPES.FunctionExpression || node.type === types.AST_NODE_TYPES.ArrowFunctionExpression) && node.parent.type === types.AST_NODE_TYPES.Property;
+}
+function isFunctionOfObjectMethod(node) {
+  return (node.type === types.AST_NODE_TYPES.FunctionExpression || node.type === types.AST_NODE_TYPES.ArrowFunctionExpression) && node.parent.type === types.AST_NODE_TYPES.Property && node.parent.parent.type === types.AST_NODE_TYPES.ObjectExpression;
 }
 
 // src/component/component-collector.ts
@@ -483,7 +1006,7 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT, options =
     const entry = functionEntries.at(-1);
     if (entry == null) return;
     if (!entry.isComponent) return functionEntries.pop();
-    const shouldDrop = AST9__namespace.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
+    const shouldDrop = AST8__namespace.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
       return context.sourceCode.getScope(r).block === entry.node && r.argument != null && !JSX3__namespace.isJSXValue(r.argument, jsxCtx, hint);
     });
     if (shouldDrop) {
@@ -508,10 +1031,10 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT, options =
       const entry = getCurrentEntry();
       if (entry == null) return;
       const { body } = entry.node;
-      const isComponent = hasNoneOrValidComponentName(entry.node, context) && JSX3__namespace.isJSXValue(body, jsxCtx, hint) && hasValidHierarchy(entry.node, context, hint);
+      const isComponent = hasNoneOrValidComponentName(context, entry.node) && JSX3__namespace.isJSXValue(body, jsxCtx, hint) && hasValidHierarchy(context, entry.node, hint);
       if (!isComponent) return;
-      const initPath = AST9__namespace.getFunctionInitPath(entry.node);
-      const id = getFunctionComponentIdentifier(entry.node, context);
+      const initPath = AST8__namespace.getFunctionInitPath(entry.node);
+      const id = getFunctionComponentIdentifier(context, entry.node);
       const name = getComponentNameFromIdentifier(id);
       const key = shared.getId();
       components.set(key, {
@@ -548,11 +1071,11 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT, options =
     "ReturnStatement[type]"(node) {
       const entry = getCurrentEntry();
       if (entry == null) return;
-      const isComponent = hasNoneOrValidComponentName(entry.node, context) && JSX3__namespace.isJSXValue(node.argument, jsxCtx, hint) && hasValidHierarchy(entry.node, context, hint);
+      const isComponent = hasNoneOrValidComponentName(context, entry.node) && JSX3__namespace.isJSXValue(node.argument, jsxCtx, hint) && hasValidHierarchy(context, entry.node, hint);
       if (!isComponent) return;
       entry.isComponent = true;
-      const initPath = AST9__namespace.getFunctionInitPath(entry.node);
-      const id = getFunctionComponentIdentifier(entry.node, context);
+      const initPath = AST8__namespace.getFunctionInitPath(entry.node);
+      const id = getFunctionComponentIdentifier(context, entry.node);
       const name = getComponentNameFromIdentifier(id);
       components.set(entry.key, {
         id,
@@ -570,40 +1093,12 @@ function useComponentCollector(context, hint = DEFAULT_COMPONENT_HINT, options =
   };
   return { ctx, listeners };
 }
-function hasValidHierarchy(node, context, hint) {
-  if (isChildrenOfCreateElement(node, context) || isFunctionOfRenderMethod(node)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipMapCallback && AST9__namespace.isMapCallLoose(node.parent)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipObjectMethod && AST9__namespace.isFunctionOfObjectMethod(node.parent)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipClassMethod && AST9__namespace.isFunctionOfClassMethod(node.parent)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipClassProperty && AST9__namespace.isFunctionOfClassProperty(node.parent)) {
-    return false;
-  }
-  const boundaryNode = AST9__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
-    ])
-  );
-  return boundaryNode == null || boundaryNode.type !== types.AST_NODE_TYPES.JSXExpressionContainer;
-}
 function getComponentFlag(initPath) {
   let flag = ERComponentFlag.None;
-  if (initPath != null && AST9__namespace.hasCallInFunctionInitPath("memo", initPath)) {
+  if (initPath != null && AST8__namespace.hasCallInFunctionInitPath("memo", initPath)) {
     flag |= ERComponentFlag.Memo;
   }
-  if (initPath != null && AST9__namespace.hasCallInFunctionInitPath("forwardRef", initPath)) {
+  if (initPath != null && AST8__namespace.hasCallInFunctionInitPath("forwardRef", initPath)) {
     flag |= ERComponentFlag.ForwardRef;
   }
   return flag;
@@ -620,7 +1115,7 @@ function useComponentCollectorLegacy() {
     if (!isClassComponent(node)) {
       return;
     }
-    const id = AST9__namespace.getClassIdentifier(node);
+    const id = AST8__namespace.getClassIdentifier(node);
     const key = shared.getId();
     const flag = isPureComponent(node) ? ERComponentFlag.PureComponent : ERComponentFlag.None;
     components.set(
@@ -651,9 +1146,9 @@ var ERPhaseRelevance = birecord__default.default({
   setup: "cleanup"
 });
 var isInversePhase = eff.dual(2, (a, b) => ERPhaseRelevance.get(a) === b);
-function isRenderFunctionLoose(node, context) {
+function isRenderFunctionLoose(context, node) {
   const { body, parent } = node;
-  if (AST9__namespace.getFunctionIdentifier(node)?.name.startsWith("render")) {
+  if (AST8__namespace.getFunctionIdentifier(node)?.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");
   }
   return JSX3__namespace.isJSXValue(
@@ -664,11 +1159,11 @@ function isRenderFunctionLoose(node, context) {
     JSX3__namespace.JSXValueHint.SkipNullLiteral | JSX3__namespace.JSXValueHint.SkipUndefined | JSX3__namespace.JSXValueHint.StrictLogical | JSX3__namespace.JSXValueHint.StrictConditional
   );
 }
-function isRenderPropLoose(node, context) {
+function isRenderPropLoose(context, node) {
   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);
+  return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST8__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
 }
 function isDirectValueOfRenderPropertyLoose(node) {
   const matching = (node2) => {
@@ -680,7 +1175,7 @@ function isDeclaredInRenderPropLoose(node) {
   if (isDirectValueOfRenderPropertyLoose(node)) {
     return true;
   }
-  const parent = AST9__namespace.findParentNode(node, AST9__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
+  const parent = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
   if (parent?.type !== types.AST_NODE_TYPES.JSXAttribute) {
     return false;
   }
@@ -688,16 +1183,16 @@ function isDeclaredInRenderPropLoose(node) {
 }
 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.AST_NODE_TYPES.MemberExpression && AST8__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
 function isFunctionOfUseEffectSetup(node) {
   if (node == null) return eff._;
   return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === types.AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
 }
 function isFunctionOfUseEffectCleanup(node) {
-  const nearReturn = AST9__namespace.findParentNode(node, AST9__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
-  const nearFunction = AST9__namespace.findParentNode(node, AST9__namespace.isFunction);
-  const nearFunctionOfReturn = AST9__namespace.findParentNode(nearReturn, AST9__namespace.isFunction);
+  const nearReturn = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
+  const nearFunction = AST8__namespace.findParentNode(node, AST8__namespace.isFunction);
+  const nearFunctionOfReturn = AST8__namespace.findParentNode(nearReturn, AST8__namespace.isFunction);
   return nearFunction === nearFunctionOfReturn && isFunctionOfUseEffectSetup(nearFunction);
 }
 
@@ -711,6 +1206,7 @@ exports.RE_HOOK_NAME = RE_HOOK_NAME;
 exports.getComponentNameFromIdentifier = getComponentNameFromIdentifier;
 exports.getFunctionComponentIdentifier = getFunctionComponentIdentifier;
 exports.hasNoneOrValidComponentName = hasNoneOrValidComponentName;
+exports.hasValidHierarchy = hasValidHierarchy;
 exports.isCallFromReact = isCallFromReact;
 exports.isCallFromReactMember = isCallFromReactMember;
 exports.isChildrenCount = isChildrenCount;
@@ -743,7 +1239,11 @@ exports.isDisplayNameAssignment = isDisplayNameAssignment;
 exports.isForwardRef = isForwardRef;
 exports.isForwardRefCall = isForwardRefCall;
 exports.isFromReact = isFromReact;
+exports.isFromReactLoose = isFromReactLoose;
 exports.isFromReactMember = isFromReactMember;
+exports.isFromReactMemberLoose = isFromReactMemberLoose;
+exports.isFromReactMemberStrict = isFromReactMemberStrict;
+exports.isFromReactStrict = isFromReactStrict;
 exports.isFunctionOfComponentDidMount = isFunctionOfComponentDidMount;
 exports.isFunctionOfComponentWillUnmount = isFunctionOfComponentWillUnmount;
 exports.isFunctionOfRenderMethod = isFunctionOfRenderMethod;