ref.ts

/* eslint-disable no-param-reassign */
import type * as React from 'react';
import type { ReactNode } from 'react';
import { isValidElement } from 'react';
import { isForwardRef, isFragment, isMemo } from 'react-is';
import useMemo from './hooks/useMemo';

export function fillRef<T>(ref: React.Ref<T>, node: T) {
  if (typeof ref === 'function') {
    ref(node);
  } else if (typeof ref === 'object' && ref && 'current' in ref) {
    (ref as any).current = node;
  }
}

/**
 * Merge refs into one ref function to support ref passing.
 */
export function composeRef<T>(...refs: React.Ref<T>[]): React.Ref<T> {
  const refList = refs.filter(ref => ref);
  if (refList.length <= 1) {
    return refList[0];
  }

  return (node: T) => {
    refs.forEach(ref => {
      fillRef(ref, node);
    });
  };
}

export function useComposeRef<T>(...refs: React.Ref<T>[]): React.Ref<T> {
  return useMemo(
    () => composeRef(...refs),
    refs,
    (prev, next) =>
      prev.length !== next.length || prev.every((ref, i) => ref !== next[i]),
  );
}

export const supportRef = <T>(value: any): value is React.RefAttributes<T> => {
  if (isFragment(value)) {
    return false;
  }
  if (isForwardRef(value)) {
    return true;
  }
  const type = isMemo(value) ? value.type.type : value.type;

  // Function component node
  if (typeof type === 'function' && !type.prototype?.render) {
    return false;
  }

  // Class component
  if (typeof value === 'function' && !value.prototype?.render) {
    return false;
  }

  return true;
};

export function supportNodeRef(node: ReactNode): boolean {
  if (!isValidElement(node)) {
    return false;
  }

  if (isFragment(node)) {
    return false;
  }

  return supportRef(node);
}
/* eslint-enable */