Skip to content

Free open-source image editor for the browser

8.4 KB
Raw Blame
import {
  type MouseEvent,
  type PointerEvent,
  useCallback,
  useEffect,
  useEffectEvent,
  useLayoutEffect,
  useRef,
  useState,
} from "react";

import { useStore } from "zustand";
import { createStore } from "zustand/vanilla";
import type { Point } from "@/core/image/frame";
import type { View } from "@/core/renderer";
import { containsTarget, isTyping } from "@/lib/dom";

const fit: View = { zoom: 1, pan: [0, 0] };
export const createCamera = () => createStore<View>(() => fit);
export type Camera = ReturnType<typeof createCamera>;
const maxZoom = 8;

function measureGesture(points: Iterable<Point>) {
  const [first, second = first] = points;
  return {
    center: [(first[0] + second[0]) / 2, (first[1] + second[1]) / 2] as const,
    distance: Math.hypot(second[0] - first[0], second[1] - first[1]),
  };
}

function pan(view: View, x: number, y: number): View {
  return { ...view, pan: [view.pan[0] + x, view.pan[1] + y] };
}

/** Keeps the content point under `focal` fixed while changing zoom. */
function zoomAt(view: View, focal: Point, zoom: number, minimum = 1): View {
  const ratio = Math.min(Math.max(zoom, minimum), maxZoom) / view.zoom;
  return {
    ...view,
    zoom: view.zoom * ratio,
    pan: [
      focal[0] + (view.pan[0] - focal[0]) * ratio,
      focal[1] + (view.pan[1] - focal[1]) * ratio,
    ],
  };
}

export function fitScale(content: Point, viewport: Point) {
  return Math.min(
    viewport[0] / content[0],
    viewport[1] / content[1],
    2 / devicePixelRatio,
  );
}

/** Axes smaller than the viewport stay centered; larger ones cannot pan past their edge. */
function clamp(view: View, content: Point, viewport: Point): View {
  const scale = fitScale(content, viewport) * view.zoom;
  const axis = (i: 0 | 1) => {
    const room = Math.max(0, (content[i] * scale - viewport[i]) / 2);
    return Math.min(room, Math.max(-room, view.pan[i]));
  };
  return {
    zoom: view.zoom,
    pan: [axis(0), axis(1)],
  };
}

function inset(size: Point, padding: number): Point {
  return [
    Math.max(0, size[0] - padding * 2),
    Math.max(0, size[1] - padding * 2),
  ];
}

/**
 * Pan and zoom over `content` inside the element given `ref`.
 * Zoom 1 is the initial fit: contain, but capped at 200%. `pan` is in CSS px from the viewport center.
 * Wheel/drag pans, ctrl/cmd+wheel zooms at the cursor, two pointers pinch and pan, double-click resets.
 */
export function usePanZoom(
  state: Camera,
  content: Point,
  { constrain = true, padding = 0 } = {},
) {
  const ref = useRef<HTMLDivElement>(null);
  const pointers = useRef(new Map<number, Point>());
  const boundedDrag = useRef(true);
  const fitZoom = useRef(1);
  const view = useStore(state);
  const [viewport, setViewport] = useState<Point>([0, 0]);
  const [panMode, setPanMode] = useState(false);

  useEffect(() => {
    const controller = new AbortController();
    const { signal } = controller;
    function keyDown(event: KeyboardEvent) {
      if (
        event.code !== "Space" ||
        event.ctrlKey ||
        event.metaKey ||
        event.altKey
      ) {
        return;
      }
      if (isTyping(event.target)) {
        return;
      }
      event.preventDefault();
      setPanMode(true);
    }
    function keyUp(event: KeyboardEvent) {
      if (event.code === "Space") {
        setPanMode(false);
      }
    }
    function blur() {
      setPanMode(false);
      pointers.current.clear();
    }
    window.addEventListener("keydown", keyDown, { signal });
    window.addEventListener("keyup", keyUp, { signal });
    window.addEventListener("blur", blur, { signal });
    return () => controller.abort();
  }, []);

  const update = useCallback(
    (next: (view: View) => View, bounded = constrain) => {
      const element = ref.current;
      if (element) {
        const viewport: Point = [element.clientWidth, element.clientHeight];
        state.setState((view) => {
          const result = next(view);
          return bounded
            ? clamp(result, content, inset(viewport, padding))
            : result;
        }, true);
      }
    },
    [state, content, constrain, padding],
  );

  useLayoutEffect(() => update((view) => view), [update, viewport]);

  const wheel = useEffectEvent((event: WheelEvent) => {
    event.preventDefault();
    const element = ref.current;
    if (!element) {
      return;
    }
    const { left, top, width, height } = element.getBoundingClientRect();
    const focal: Point = [
      event.clientX - left - width / 2,
      event.clientY - top - height / 2,
    ];
    update((view) => {
      if (event.ctrlKey || event.metaKey) {
        return zoomAt(
          view,
          focal,
          view.zoom * Math.exp(-event.deltaY / 100),
          constrain ? 1 : fitZoom.current * 0.1,
        );
      }
      return pan(view, -event.deltaX, -event.deltaY);
    }, constrain && !panMode);
  });

  // One listener and observer per element; the wheel handler reads the latest content and bounds.
  useLayoutEffect(() => {
    const element = ref.current;
    if (!element) {
      return;
    }
    const measure = () => {
      setViewport([element.clientWidth, element.clientHeight]);
    };
    measure();
    const observer = new ResizeObserver(measure);
    observer.observe(element);
    const controller = new AbortController();
    element.addEventListener("wheel", wheel, {
      passive: false,
      signal: controller.signal,
    });
    return () => {
      observer.disconnect();
      controller.abort();
    };
  }, []);

  const release = (event: PointerEvent<HTMLElement>) =>
    pointers.current.delete(event.pointerId);
  const resetView = (next = fit) => {
    fitZoom.current = next.zoom;
    state.setState(next, true);
  };
  const zoomBy = (factor: number) =>
    update((view) =>
      zoomAt(
        view,
        [0, 0],
        view.zoom * factor,
        constrain ? 1 : fitZoom.current * 0.1,
      ),
    );
  /** An exact zoom may go below fit, as 100% does for a small image on a dense display. */
  const zoomTo = (zoom: number) =>
    update((view) => zoomAt(view, [0, 0], zoom, zoom));
  function track(pointerId: number, position: Point, element: Element) {
    if (pointers.current.size === 0) {
      boundedDrag.current = constrain && !panMode;
    }
    pointers.current.set(pointerId, position);
    element.setPointerCapture(pointerId);
  }
  function startDrag(event: PointerEvent<HTMLElement>) {
    if (
      !containsTarget(event) ||
      event.button !== 0 ||
      pointers.current.size === 2
    ) {
      return;
    }
    track(event.pointerId, [event.clientX, event.clientY], event.currentTarget);
  }
  /** Takes over a pointer a tool was tracking, so a second finger turns its stroke into a pinch. */
  function adopt(pointerId: number, position: Point) {
    if (ref.current && pointers.current.size < 2) {
      track(pointerId, position, ref.current);
    }
  }
  const handlers = {
    onPointerDownCapture: (event: PointerEvent<HTMLElement>) => {
      if (panMode && event.button === 0 && containsTarget(event)) {
        event.preventDefault();
        event.stopPropagation();
        startDrag(event);
      }
    },
    onPointerDown: startDrag,
    onPointerMove: (event: PointerEvent<HTMLElement>) => {
      const points = pointers.current;
      if (!points.has(event.pointerId)) {
        return;
      }
      const previous = measureGesture(points.values());
      points.set(event.pointerId, [event.clientX, event.clientY]);
      const next = measureGesture(points.values());
      const { left, top, width, height } =
        event.currentTarget.getBoundingClientRect();
      const focal: Point = [
        previous.center[0] - left - width / 2,
        previous.center[1] - top - height / 2,
      ];
      const ratio =
        previous.distance > 0 ? next.distance / previous.distance : 1;
      update((view) => {
        const zoomed = zoomAt(
          view,
          focal,
          view.zoom * ratio,
          constrain ? 1 : fitZoom.current * 0.1,
        );
        return pan(
          zoomed,
          next.center[0] - previous.center[0],
          next.center[1] - previous.center[1],
        );
      }, boundedDrag.current);
    },
    onPointerUp: release,
    onPointerCancel: release,
    onLostPointerCapture: release,
    onDoubleClick: (event: MouseEvent<HTMLElement>) => {
      if (containsTarget(event)) resetView();
    },
  };

  return {
    ref,
    adopt,
    view,
    viewport,
    handlers,
    resetView,
    zoomBy,
    zoomTo,
    panMode,
    scale: fitScale(content, inset(viewport, padding)) * view.zoom,
  };
}