useIntersectionObserver — Observa cuándo los elementos entran o salen de la ventana gráfica

import { useState, useEffect, useRef, useCallback } from "react";
 
interface UseIntersectionObserverOptions {
  /** Elemento que se usa como ventana gráfica. Predeterminado: ventana gráfica del navegador */
  root?: Element | null;
  /** Margen alrededor de la raíz. Predeterminado: "0px" */
  rootMargin?: string;
  /** Porcentaje del elemento visible para disparar. 0-1 o array. Predeterminado: 0 */
  threshold?: number | number[];
  /** Solo disparar una vez (p. ej., para lazy loading). Predeterminado: false */
  triggerOnce?: boolean;
  /** Comenzar a observar inmediatamente. Predeterminado: true */
  enabled?: boolean;
}
 
interface UseIntersectionObserverReturn {
  /** Ref para adjuntar al elemento de destino */
  ref: (node: Element | null) => void;
  /** La última entrada de IntersectionObserverEntry */
  entry: IntersectionObserverEntry | null;
  /** Si el elemento está intersecando actualmente */
  isIntersecting: boolean;
}
 
function useIntersectionObserver(
  options: UseIntersectionObserverOptions = {}
): UseIntersectionObserverReturn {
  const {
    root = null,
    rootMargin = "0px",
    threshold = 0,
    triggerOnce = false,
    enabled = true,
  } = options;
 
  const [entry, setEntry] = useState<IntersectionObserverEntry | null>(null);
  const observerRef = useRef<IntersectionObserver | null>(null);
  const nodeRef = useRef<Element | null>(null);
  const frozenRef = useRef(false);
 
  const cleanup = useCallback(() => {
    if (observerRef.current) {
      observerRef.current.disconnect();
      observerRef.current = null;
    }
  }, []);
 
  // Patrón de callback ref para dirigirse flexiblemente a elementos
  const ref = useCallback(
    (node: Element | null) => {
      // Limpiar observer anterior
      cleanup();
      nodeRef.current = node;
 
      if (!node || !enabled || frozenRef.current) return;
 
      if (typeof IntersectionObserver === "undefined") return;
 
      observerRef.current = new IntersectionObserver(
        ([observedEntry]) => {
          setEntry(observedEntry);
 
          if (triggerOnce && observedEntry.isIntersecting) {
            frozenRef.current = true;
            cleanup();
          }
        },
        { root, rootMargin, threshold }
      );
 
      observerRef.current.observe(node);
    },
    [root, rootMargin, threshold, triggerOnce, enabled, cleanup]
  );
 
  // Limpieza al desmontar
  useEffect(() => {
    return cleanup;
  }, [cleanup]);
 
  return {
    ref,
    entry,
    isIntersecting: entry?.isIntersecting ?? false,
  };
}

"use client";
 
// Imagen cargada perezosamente
function LazyImage({ src, alt }: { src: string; alt: string }) {
  const { ref, isIntersecting } = useIntersectionObserver({
    triggerOnce: true,
    rootMargin: "200px", // Comenzar a cargar 200px antes de ser visible
  });
 
  return (
    <div ref={ref} style={{ minHeight: 200, background: "#f0f0f0" }}>
      {isIntersecting ? (
        <img src={src} alt={alt} style={{ width: "100%" }} />
      ) : (
        <div style={{ padding: 20, color: "#999" }}>Cargando...</div>
      )}
    </div>
  );
}
 
// Disparador de scroll infinito
function InfiniteList() {
  const [items, setItems] = useState<number[]>([1, 2, 3, 4, 5]);
  const [loading, setLoading] = useState(false);
 
  const { ref, isIntersecting } = useIntersectionObserver({
    threshold: 1.0,
  });
 
  useEffect(() => {
    if (!isIntersecting || loading) return;
    setLoading(true);
 
    // Simular llamada a API
    setTimeout(() => {
      setItems((prev) => [
        ...prev,
        ...Array.from({ length: 5 }, (_, i) => prev.length + i + 1),
      ]);
      setLoading(false);
    }, 500);
  }, [isIntersecting, loading]);
 
  return (
    <div>
      {items.map((item) => (
        <div key={item} style={{ padding: 24, borderBottom: "1px solid #eee" }}>
          Elemento {item}
        </div>
      ))}
      <div ref={ref} style={{ padding: 20, textAlign: "center" }}>
        {loading ? "Cargando más..." : "Desplázate para más"}
      </div>
    </div>
  );
}
 
// Animar al desplazarse
function AnimatedSection({ children }: { children: React.ReactNode }) {
  const { ref, isIntersecting } = useIntersectionObserver({
    threshold: 0.2,
    triggerOnce: true,
  });
 
  return (
    <div
      ref={ref}
      style={{
        opacity: isIntersecting ? 1 : 0,
        transform: isIntersecting ? "translateY(0)" : "translateY(20px)",
        transition: "opacity 0.6s ease, transform 0.6s ease",
      }}
    >
      {children}
    </div>
  );
}

function useIntersectionObserverMultiple(
  options: IntersectionObserverInit = {}
) {
  const [entries, setEntries] = useState<Map<Element, IntersectionObserverEntry>>(new Map());
  const observer = useRef<IntersectionObserver | null>(null);
 
  const observe = useCallback((node: Element) => {
    if (!observer.current) {
      observer.current = new IntersectionObserver((observed) => {
        setEntries((prev) => {
          const next = new Map(prev);
          observed.forEach((e) => next.set(e.target, e));
          return next;
        });
      }, options);
    }
    observer.current.observe(node);
  }, [options]);
 
  return { observe, entries };
}

const { entry } = useIntersectionObserver({
  threshold: Array.from({ length: 101 }, (_, i) => i / 100),
});
const ratio = entry?.intersectionRatio ?? 0; // 0.0 a 1.0