Method reactComponentHoc

src/extraction/tree-sitter.ts:1625–1651

* Detect a React component declared via an HOC wrapper whose result is itself a * component: `forwardRef(...)`, `memo(...)`, `React.forwardRef/memo(...)`, and * styled-components / emotion `styled.tag\`…\`` / `styled(Base)\`…\``. These * initializers are a call / tagged-template (not a bare

(valueNode: SyntaxNode)

   * `undefined` when this initializer is not a recognized component wrapper.
   */
  private reactComponentHoc(valueNode: SyntaxNode): { inner: SyntaxNode | null } | undefined {
    if (valueNode.type !== 'call_expression') return undefined;
    const callee = getChildByField(valueNode, 'function');
    if (!callee) return undefined;
    const calleeText = getNodeText(callee, this.source);
    // styled-components / emotion: `styled.button\`…\`` / `styled(Base)\`…\``.
    // tree-sitter models these tagged templates as a call_expression whose callee
    // is the `styled.x` / `styled(Base)` tag (\b avoids matching `styledFoo`).
    // No inline render fn — the argument is the CSS template.
    if (/^styled\b/.test(calleeText)) return { inner: null };
    // React HOCs: `forwardRef`/`memo`/`React.forwardRef`/`React.memo`.
    if (!REACT_COMPONENT_HOCS.has(calleeText)) return undefined;
    // The first arrow / function-expression argument is the render fn (if inline;
    // `memo(Imported)` passes a bare identifier and has none).
    const args = getChildByField(valueNode, 'arguments');
    let inner: SyntaxNode | null = null;
    if (args) {
      for (let i = 0; i < args.namedChildCount; i++) {
        const a = args.namedChild(i);
        if (a && (a.type === 'arrow_function' || a.type === 'function_expression')) {
          inner = a;
          break;
        }
      }
    }
    return { inner };
  }

  /**
   * Emit a `component` node for an HOC-wrapped React component declaration (see