sailfork / t3code-github / apps/ web/ src/ lib/ observeResize.ts

import { flushSync } from "react-dom";

type ResizeCallback = (entries: readonly ResizeObserverEntry[]) => void;

interface Subscription {
  readonly callback: ResizeCallback;
  active: boolean;
}

interface Target {
  readonly subscriptions: Set<Subscription>;
  waiting: Set<Subscription> | null;
  last: ResizeObserverEntry | null;
}

let observer: ResizeObserver | null = null;
const targets = new Map<Element, Target>();

function deliver(entries: readonly ResizeObserverEntry[]) {
  const batches = new Map<Subscription, ResizeObserverEntry[]>();
  for (const entry of entries) {
    const target = targets.get(entry.target);
    if (!target) continue;
    let recipients = target.subscriptions;
    if (target.waiting) {
      // Re-observing for a new subscriber redelivers an unchanged size to everyone else too.
      const previous = target.last?.contentRect;
      if (
        previous?.width === entry.contentRect.width &&
        previous.height === entry.contentRect.height
      ) {
        recipients = target.waiting;
      }
      target.waiting = null;
    }
    target.last = entry;
    for (const subscription of recipients) {
      const batch = batches.get(subscription);
      if (batch) batch.push(entry);
      else batches.set(subscription, [entry]);
    }
  }
  if (batches.size === 0) return;
  flushSync(() => {
    for (const [subscription, batch] of batches) {
      if (!subscription.active) continue;
      try {
        subscription.callback(batch);
      } catch (error) {
        queueMicrotask(() => {
          throw error;
        });
      }
    }
  });
}

/** Flushes callbacks together before paint; ordinary React updates would leave a stale frame. */
export function observeResize(
  elements: Element | readonly Element[],
  callback: ResizeCallback,
): () => void {
  if (typeof ResizeObserver === "undefined") return () => {};
  const shared = (observer ??= new ResizeObserver(deliver));
  const subscription: Subscription = { callback, active: true };
  const observed: readonly Element[] = Array.isArray(elements) ? elements : [elements as Element];
  for (const element of observed) {
    const target = targets.get(element);
    if (!target) {
      targets.set(element, { subscriptions: new Set([subscription]), waiting: null, last: null });
      shared.observe(element);
      continue;
    }
    target.subscriptions.add(subscription);
    if (!target.last) continue;
    (target.waiting ??= new Set()).add(subscription);
    shared.unobserve(element);
    shared.observe(element);
  }
  return () => {
    if (!subscription.active) return;
    subscription.active = false;
    const unobserved = observed.filter((element) => {
      const target = targets.get(element);
      if (!target?.subscriptions.delete(subscription)) return false;
      target.waiting?.delete(subscription);
      return target.subscriptions.size === 0 && targets.delete(element);
    });
    if (targets.size > 0) {
      for (const element of unobserved) shared.unobserve(element);
    } else {
      observer?.disconnect();
      observer = null;
    }
  };
}