Moodboard: viewport state, recenter indicator, shortcut cheatsheet, canvas perf

Lifts `viewport` (zoom/pan) and `canvasSize` into the moodboard store so
overlays and a future minimap can read the camera without drilling refs.
Adds a recenter pill in the bottom-right that appears when nothing in the
current viewport intersects any content, and a translucent shortcut
cheatsheet that appears after holding Ctrl/Cmd alone for 3s.

New Figma-style shortcuts: V/L/T tool switches, Cmd/Ctrl+A select all,
Cmd/Ctrl+G group, Cmd/Ctrl+Shift+G ungroup, Shift+1 zoom-to-fit.

Consolidates all previously-duplicated rect / AABB / clamp / viewport math
into `layout/geometry.ts` (removes private copies from useSelection,
useViewportControls, MoodboardStore, and packCollage). Exports include
`computeContentBounds`, `computeVisibleRect`, `anyContentVisible`,
`fitViewportToBounds`, `panToCenterOn`, `ZOOM_MIN/MAX` — everything a
future minimap overlay will need.

Canvas perf pass:
- Level-of-detail dotted grid (doubles effective spacing as you zoom out
  so dot count stays bounded; dot radius tracks screen pixels).
- React.memo on ImageNode, TextNode, GroupNode, MoodboardBackground.
- Stable onSelect contract (children receive (id, e) and call a single
  parent callback, letting memo skip children on camera/selection-only
  renders).
- GroupNode subscribes only to its own children via useShallow, not the
  full nodes map.
- TextNode's editingTextId selector collapsed to a per-node boolean.
- MoodboardStage's transient subscription narrowed to {marquee, lassoPath}
  so setIsPanning / setEditingText don't churn the whole Stage.
- visibleViewport memoized so marquee/lasso drags don't force the
  background sceneFunc to re-run.
This commit is contained in:
Tanish Manku committed 2026-04-20 23:24:38 -07:00
1 parent a24b154d52
commit 982f3ad78d
17 files changed
+718 -172

No files matched your search

@@ -7,6 +7,10 @@ import { useMoodboardStore } from "./MoodboardStore";
import { useUndoRedo } from "./interactions/useUndoRedo";
import { usePasteHandler } from "./interactions/usePasteHandler";
import { useGalleryDropEvent } from "./interactions/useGalleryDropEvent";
import { useKeyboardShortcuts } from "./interactions/useKeyboardShortcuts";
import { useShortcutCheatsheet } from "./interactions/useShortcutCheatsheet";
import { RecenterIndicator } from "./overlays/RecenterIndicator";
import { ShortcutCheatsheet } from "./overlays/ShortcutCheatsheet";
export const Moodboard = () => {
const containerRef = useRef<HTMLDivElement | null>(null);
@@ -18,6 +22,8 @@ export const Moodboard = () => {
useUndoRedo(true);
usePasteHandler(true, stageRef);
useGalleryDropEvent(true, stageRef);
useKeyboardShortcuts(true);
const cheatsheetVisible = useShortcutCheatsheet();
// Delete / Backspace removes the current selection. Skip when typing in
// an input or while a text node is in edit mode.
@@ -44,6 +50,8 @@ export const Moodboard = () => {
<div ref={containerRef} className="relative flex-1 overflow-hidden">
<MoodboardStage containerRef={containerRef} stageRef={stageRef} />
<TextEditOverlay containerRef={containerRef} />
<RecenterIndicator />
<ShortcutCheatsheet visible={cheatsheetVisible} />
</div>
</div>
);
@@ -1,3 +1,4 @@
import { memo } from "react";
import { Shape } from "react-konva";
import Konva from "konva";
import { Rect } from "./types";
@@ -6,35 +7,53 @@ interface Props {
// Visible region in stage (document) coordinates. Driven by pan/zoom.
viewport: Rect;
spacing: number;
zoom: number;
dotColor?: string;
dotRadius?: number;
// On-screen radius in CSS pixels. Converted to stage units so dots stay
// the same visual size regardless of zoom.
dotRadiusPx?: number;
}
// Minimum on-screen gap between dots before we drop to a coarser grid.
// At zoom 1× with spacing 32, dots are 32px apart; as you zoom out, the
// LOD step doubles `spacing` so density never drops below this bound.
const MIN_SCREEN_SPACING = 16;
// Vector dotted grid that follows the visible viewport. Dots stay anchored
// at fixed stage coords (multiples of `spacing`); panning reveals more,
// zooming in spaces them apart on screen.
export const MoodboardBackground = ({
// at fixed stage coords (multiples of the effective spacing); zooming out
// coarsens the grid in powers of 2 so we never draw tens of thousands of
// arcs per frame.
const MoodboardBackgroundInner = ({
viewport,
spacing,
zoom,
dotColor = "rgba(255,255,255,0.18)",
dotRadius = 1.2,
dotRadiusPx = 1.2,
}: Props) => {
const baseOnScreen = spacing * zoom;
const lodStep =
baseOnScreen >= MIN_SCREEN_SPACING
? 0
: Math.ceil(Math.log2(MIN_SCREEN_SPACING / Math.max(baseOnScreen, 1e-6)));
const effectiveSpacing = spacing * Math.pow(2, lodStep);
const radius = dotRadiusPx / Math.max(zoom, 1e-6);
return (
<Shape
x={0}
y={0}
listening={false}
sceneFunc={(ctx: Konva.Context, shape) => {
const startX = Math.floor(viewport.x / spacing) * spacing;
const startY = Math.floor(viewport.y / spacing) * spacing;
const startX = Math.floor(viewport.x / effectiveSpacing) * effectiveSpacing;
const startY = Math.floor(viewport.y / effectiveSpacing) * effectiveSpacing;
const endX = viewport.x + viewport.width;
const endY = viewport.y + viewport.height;
ctx.fillStyle = dotColor;
ctx.beginPath();
for (let x = startX; x <= endX; x += spacing) {
for (let y = startY; y <= endY; y += spacing) {
ctx.moveTo(x + dotRadius, y);
ctx.arc(x, y, dotRadius, 0, Math.PI * 2);
for (let x = startX; x <= endX; x += effectiveSpacing) {
for (let y = startY; y <= endY; y += effectiveSpacing) {
ctx.moveTo(x + radius, y);
ctx.arc(x, y, radius, 0, Math.PI * 2);
}
}
ctx.fill();
@@ -43,3 +62,5 @@ export const MoodboardBackground = ({
/>
);
};
export const MoodboardBackground = memo(MoodboardBackgroundInner);
@@ -1,6 +1,7 @@
import { useEffect, useRef, useState } from "react";
import { useCallback, useEffect, useMemo } from "react";
import Konva from "konva";
import { Stage, Layer, Rect, Line, Group, Transformer } from "react-konva";
import { useShallow } from "zustand/react/shallow";
import { useMoodboardStore } from "./MoodboardStore";
import { MoodboardBackground } from "./MoodboardBackground";
import { ImageNode } from "./nodes/ImageNode";
@@ -10,7 +11,6 @@ import { useSelection } from "./interactions/useSelection";
import { useTransformer } from "./interactions/useTransformer";
import { useViewportControls } from "./interactions/useViewportControls";
import { stagePointerPos } from "./interactions/useStagePointer";
import { Vec2 } from "./types";
interface Props {
containerRef: React.RefObject<HTMLDivElement | null>;
@@ -20,40 +20,48 @@ interface Props {
export const MoodboardStage = ({ containerRef, stageRef }: Props) => {
const transformerRef = useTransformer(stageRef);
const [size, setSize] = useState({ width: 800, height: 600 });
const [zoom, setZoom] = useState(1);
const [pan, setPan] = useState<Vec2>({ x: 0, y: 0 });
const zoomRef = useRef(zoom);
const panRef = useRef(pan);
zoomRef.current = zoom;
panRef.current = pan;
const nodes = useMoodboardStore((s) => s.nodes);
const rootOrder = useMoodboardStore((s) => s.rootOrder);
const selectedIds = useMoodboardStore((s) => s.selectedIds);
const tool = useMoodboardStore((s) => s.tool);
const gridSpacing = useMoodboardStore((s) => s.gridSpacing);
const transient = useMoodboardStore((s) => s.transient);
// Only subscribe to the transient fields this component actually renders
// (marquee + lasso). Skips re-renders on `editingTextId` and `isPanning`
// toggles, which don't affect Stage JSX.
const { marquee, lassoPath } = useMoodboardStore(
useShallow((s) => ({
marquee: s.transient.marquee,
lassoPath: s.transient.lassoPath,
})),
);
const viewport = useMoodboardStore((s) => s.viewport);
const canvasSize = useMoodboardStore((s) => s.canvasSize);
const setLastDropPoint = useMoodboardStore((s) => s.setLastDropPoint);
const setCanvasSize = useMoodboardStore((s) => s.setCanvasSize);
const toggleInSelection = useMoodboardStore((s) => s.toggleInSelection);
const setEditingText = useMoodboardStore((s) => s.setEditingText);
const addText = useMoodboardStore((s) => s.addText);
const zoom = viewport.zoom;
const pan = viewport.pan;
// Track wrapper size with ResizeObserver so the Stage fills its container.
// The size lives in the store so overlays (recenter indicator, future
// minimap) can read it without drilling refs through the tree.
useEffect(() => {
const el = containerRef.current;
if (!el) return undefined;
const updateSize = () => {
setSize({ width: el.clientWidth, height: el.clientHeight });
setCanvasSize({ width: el.clientWidth, height: el.clientHeight });
};
updateSize();
const ro = new ResizeObserver(updateSize);
ro.observe(el);
return () => ro.disconnect();
}, [containerRef]);
}, [containerRef, setCanvasSize]);
useSelection(stageRef);
useViewportControls(stageRef, { zoomRef, panRef, setZoom, setPan });
useViewportControls(stageRef);
// Update lastDropPoint as the cursor moves across the stage so external
// drops (uploads, paste fallbacks) land near the cursor.
@@ -70,14 +78,17 @@ export const MoodboardStage = ({ containerRef, stageRef }: Props) => {
};
}, [setLastDropPoint, stageRef]);
const handleNodeSelect = (
id: string,
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => {
const evt = e.evt as MouseEvent | TouchEvent;
const additive = "shiftKey" in evt && evt.shiftKey;
toggleInSelection(id, additive);
};
// Stable across renders so memoized node children see an unchanged
// onSelect prop and skip re-render when only camera/selection state
// changes. Depends only on a Zustand action, which itself is stable.
const handleNodeSelect = useCallback(
(id: string, e: Konva.KonvaEventObject<MouseEvent | TouchEvent>) => {
const evt = e.evt as MouseEvent | TouchEvent;
const additive = "shiftKey" in evt && evt.shiftKey;
toggleInSelection(id, additive);
},
[toggleInSelection],
);
const handleStageClick = (e: Konva.KonvaEventObject<MouseEvent>) => {
if (e.target !== stageRef.current) return;
@@ -95,20 +106,26 @@ export const MoodboardStage = ({ containerRef, stageRef }: Props) => {
// Visible region in stage coords; drives the dotted background grid so
// it follows pan/zoom rather than rendering a fixed (0,0,w,h) block.
const visibleViewport = {
x: -pan.x / zoom,
y: -pan.y / zoom,
width: size.width / zoom,
height: size.height / zoom,
};
// Memoized so transient store updates (marquee, lasso, isPanning) don't
// churn its identity and force `MoodboardBackground` to re-run sceneFunc
// every frame of a marquee drag.
const visibleViewport = useMemo(
() => ({
x: -pan.x / zoom,
y: -pan.y / zoom,
width: canvasSize.width / zoom,
height: canvasSize.height / zoom,
}),
[pan.x, pan.y, zoom, canvasSize.width, canvasSize.height],
);
return (
<Stage
ref={(s) => {
stageRef.current = s;
}}
width={size.width}
height={size.height}
width={canvasSize.width}
height={canvasSize.height}
x={pan.x}
y={pan.y}
scaleX={zoom}
@@ -125,24 +142,26 @@ export const MoodboardStage = ({ containerRef, stageRef }: Props) => {
height={visibleViewport.height}
fill="#0f0f12"
/>
<MoodboardBackground viewport={visibleViewport} spacing={gridSpacing} />
<MoodboardBackground
viewport={visibleViewport}
spacing={gridSpacing}
zoom={zoom}
/>
</Layer>
<Layer>
{rootOrder.map((id) => {
const n = nodes[id];
if (!n) return null;
const selected = selectedIds.has(id);
const onSelect = (
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => handleNodeSelect(id, e);
const draggable = tool === "select";
if (n.kind === "image") {
return (
<ImageNode
key={id}
node={n}
draggable={tool === "select"}
draggable={draggable}
selected={selected}
onSelect={onSelect}
onSelect={handleNodeSelect}
/>
);
}
@@ -151,9 +170,9 @@ export const MoodboardStage = ({ containerRef, stageRef }: Props) => {
<TextNode
key={id}
node={n}
draggable={tool === "select"}
draggable={draggable}
selected={selected}
onSelect={onSelect}
onSelect={handleNodeSelect}
/>
);
}
@@ -163,7 +182,7 @@ export const MoodboardStage = ({ containerRef, stageRef }: Props) => {
key={id}
node={n}
selected={selected}
onSelect={onSelect}
onSelect={handleNodeSelect}
/>
);
}
@@ -233,21 +252,21 @@ export const MoodboardStage = ({ containerRef, stageRef }: Props) => {
/>
);
})}
{transient.marquee && (
{marquee && (
<Rect
x={transient.marquee.x}
y={transient.marquee.y}
width={transient.marquee.width}
height={transient.marquee.height}
x={marquee.x}
y={marquee.y}
width={marquee.width}
height={marquee.height}
stroke="#3b82f6"
strokeWidth={1 / zoom}
dash={[4 / zoom, 4 / zoom]}
fill="rgba(59,130,246,0.08)"
/>
)}
{transient.lassoPath && transient.lassoPath.length >= 2 && (
{lassoPath && lassoPath.length >= 2 && (
<Line
points={transient.lassoPath.flatMap((p) => [p.x, p.y])}
points={lassoPath.flatMap((p) => [p.x, p.y])}
stroke="#3b82f6"
strokeWidth={1 / zoom}
dash={[4 / zoom, 4 / zoom]}
@@ -11,6 +11,13 @@ import {
Vec2,
} from "./types";
import { useMoodboardHistoryStore } from "./MoodboardHistoryStore";
import {
CanvasSize,
Viewport,
computeAABBById,
computeContentBounds,
fitViewportToBounds,
} from "./layout/geometry";
interface Transient {
marquee: Rect | null;
@@ -26,10 +33,18 @@ interface MoodboardState {
tool: Tool;
gridSpacing: number;
lastDropPoint: Vec2;
viewport: Viewport;
canvasSize: CanvasSize;
transient: Transient;
setTool: (t: Tool) => void;
setLastDropPoint: (p: Vec2) => void;
setZoom: (z: number) => void;
setPan: (p: Vec2) => void;
setCanvasSize: (s: CanvasSize) => void;
resetViewport: () => void;
fitToContent: (padding?: number) => void;
selectAll: () => void;
addImage: (
src: string,
@@ -90,6 +105,8 @@ export const useMoodboardStore = create<MoodboardState>((set, get) => ({
tool: "select",
gridSpacing: 32,
lastDropPoint: { x: 200, y: 200 },
viewport: { zoom: 1, pan: { x: 0, y: 0 } },
canvasSize: { width: 800, height: 600 },
transient: {
marquee: null,
lassoPath: null,
@@ -99,6 +116,22 @@ export const useMoodboardStore = create<MoodboardState>((set, get) => ({
setTool: (t) => set({ tool: t }),
setLastDropPoint: (p) => set({ lastDropPoint: p }),
setZoom: (z) => set((s) => ({ viewport: { ...s.viewport, zoom: z } })),
setPan: (p) => set((s) => ({ viewport: { ...s.viewport, pan: p } })),
setCanvasSize: (sz) => set({ canvasSize: sz }),
resetViewport: () =>
set({ viewport: { zoom: 1, pan: { x: 0, y: 0 } } }),
fitToContent: (padding = 48) => {
const { nodes, rootOrder, canvasSize } = get();
const bounds = computeContentBounds(nodes, rootOrder);
if (!bounds) return;
set({ viewport: fitViewportToBounds(bounds, canvasSize, padding) });
},
selectAll: () => {
const { rootOrder } = get();
if (rootOrder.length === 0) return;
set({ selectedIds: new Set(rootOrder) });
},
addImage: (src, pos, naturalW, naturalH, mediaId = null) => {
get().pushHistory();
@@ -242,7 +275,7 @@ export const useMoodboardStore = create<MoodboardState>((set, get) => ({
get().pushHistory();
const groupId = uuidv4();
const aabb = computeAABB(nodes, topLevelIds);
const aabb = computeAABBById(nodes, topLevelIds);
if (!aabb) return null;
const groupNode: GroupNode = {
@@ -301,7 +334,7 @@ export const useMoodboardStore = create<MoodboardState>((set, get) => ({
return n && n.parentId === null;
});
if (topLevelIds.length < 2) continue;
const aabb = computeAABB(newNodes, topLevelIds);
const aabb = computeAABBById(newNodes, topLevelIds);
if (!aabb) continue;
const groupId = uuidv4();
const groupNode: GroupNode = {
@@ -440,6 +473,7 @@ export const useMoodboardStore = create<MoodboardState>((set, get) => ({
selectedIds: new Set(),
tool: "select",
lastDropPoint: { x: 200, y: 200 },
viewport: { zoom: 1, pan: { x: 0, y: 0 } },
transient: {
marquee: null,
lassoPath: null,
@@ -484,27 +518,6 @@ const stripAncestorsAndDescendants = (
return result;
};
const computeAABB = (
nodes: Record<string, MoodboardNode>,
ids: string[],
): Rect | null => {
if (ids.length === 0) return null;
let minX = Infinity;
let minY = Infinity;
let maxX = -Infinity;
let maxY = -Infinity;
for (const id of ids) {
const n = nodes[id];
if (!n) continue;
minX = Math.min(minX, n.x);
minY = Math.min(minY, n.y);
maxX = Math.max(maxX, n.x + n.width);
maxY = Math.max(maxY, n.y + n.height);
}
if (!isFinite(minX)) return null;
return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
};
// Maps a group-local point to stage-local coords using the group's transform.
const applyGroupTransform = (local: Vec2, g: GroupNode): Vec2 => {
const rad = (g.rotation * Math.PI) / 180;
@@ -0,0 +1,77 @@
import { useEffect } from "react";
import { useMoodboardStore } from "../MoodboardStore";
const isEditableTarget = (target: EventTarget | null): boolean => {
const el = target as HTMLElement | null;
if (!el) return false;
if (/input|textarea/i.test(el.tagName)) return true;
if (el.isContentEditable) return true;
return false;
};
// Figma-style shortcuts that aren't already wired elsewhere.
// Cmd+Z / Cmd+Shift+Z live in useUndoRedo; Cmd+0 + Space-pan live in
// useViewportControls; Delete / Escape live in Moodboard.tsx.
export const useKeyboardShortcuts = (active: boolean) => {
const setTool = useMoodboardStore((s) => s.setTool);
const selectAll = useMoodboardStore((s) => s.selectAll);
const group = useMoodboardStore((s) => s.group);
const ungroup = useMoodboardStore((s) => s.ungroup);
const fitToContent = useMoodboardStore((s) => s.fitToContent);
useEffect(() => {
if (!active) return undefined;
const isMac = /Mac|iPod|iPhone|iPad/.test(navigator.platform);
const handler = (e: KeyboardEvent) => {
if (isEditableTarget(e.target)) return;
// Skip while typing in the text-edit overlay (covered by isEditableTarget
// too, but belt-and-suspenders in case the overlay loses target focus).
if (useMoodboardStore.getState().transient.editingTextId) return;
const mod = isMac ? e.metaKey : e.ctrlKey;
const k = e.key.toLowerCase();
// Modifier combos
if (mod && !e.shiftKey && k === "a") {
e.preventDefault();
selectAll();
return;
}
if (mod && !e.shiftKey && k === "g") {
e.preventDefault();
group();
return;
}
if (mod && e.shiftKey && k === "g") {
e.preventDefault();
ungroup();
return;
}
// Shift-only combos
if (e.shiftKey && !mod && !e.altKey && k === "1") {
e.preventDefault();
fitToContent();
return;
}
// Plain (no modifiers) tool switches — skip if any modifier is held
// so Cmd+V (paste) etc. never triggers the Text tool.
if (mod || e.shiftKey || e.altKey) return;
if (k === "v") {
e.preventDefault();
setTool("select");
} else if (k === "l") {
e.preventDefault();
setTool("lasso");
} else if (k === "t") {
e.preventDefault();
setTool("text");
}
};
document.addEventListener("keydown", handler);
return () => document.removeEventListener("keydown", handler);
}, [active, setTool, selectAll, group, ungroup, fitToContent]);
};
@@ -1,10 +1,11 @@
import { useEffect, useRef } from "react";
import Konva from "konva";
import { useMoodboardStore } from "../MoodboardStore";
import { Rect, Vec2 } from "../types";
import { Vec2 } from "../types";
import { stagePointerPos } from "./useStagePointer";
import { pointInPolygon } from "../layout/pointInPolygon";
import { polygonIntersectsRect } from "../layout/segmentsIntersect";
import { rectCorners, rectFromPoints, rectsIntersect } from "../layout/geometry";
const MIN_DRAG = 4; // screen px before a press becomes a drag
@@ -15,31 +16,6 @@ interface DragState {
mode: "rect" | "lasso" | null;
}
const rectFromPoints = (a: Vec2, b: Vec2): Rect => ({
x: Math.min(a.x, b.x),
y: Math.min(a.y, b.y),
width: Math.abs(b.x - a.x),
height: Math.abs(b.y - a.y),
});
const aabbCorners = (n: { x: number; y: number; width: number; height: number }): Vec2[] => [
{ x: n.x, y: n.y },
{ x: n.x + n.width, y: n.y },
{ x: n.x + n.width, y: n.y + n.height },
{ x: n.x, y: n.y + n.height },
];
const intersectsRect = (
n: { x: number; y: number; width: number; height: number },
r: Rect,
) =>
!(
n.x + n.width < r.x ||
n.x > r.x + r.width ||
n.y + n.height < r.y ||
n.y > r.y + r.height
);
// Selection state machine for rectangle marquee (Select tool) and free-form
// lasso (Lasso tool). Pan gestures (middle-mouse, spacebar+left) are owned
// by `useViewportControls` and stop the event at the capture phase, so
@@ -110,7 +86,12 @@ export const useSelection = (
setSelection([]);
} else {
const hit = candidates
.filter((n) => intersectsRect(n, rect))
.filter((n) =>
rectsIntersect(
{ x: n.x, y: n.y, width: n.width, height: n.height },
rect,
),
)
.map((n) => n.id);
setSelection(hit);
}
@@ -123,7 +104,7 @@ export const useSelection = (
const closed = [...path, path[0]];
const hit = candidates
.filter((n) => {
const corners = aabbCorners(n);
const corners = rectCorners(n);
if (corners.some((c) => pointInPolygon(c, closed))) return true;
if (polygonIntersectsRect(closed, n)) return true;
return false;
@@ -0,0 +1,74 @@
import { useEffect, useState } from "react";
const HOLD_MS = 3000;
// Shows the cheatsheet when the user holds Ctrl (or Cmd on Mac) alone for
// HOLD_MS with no other key pressed. Any other keydown cancels the timer,
// so a real `Ctrl+C` / `Cmd+X` never trips it. Releasing the modifier hides
// the cheatsheet immediately.
export const useShortcutCheatsheet = (): boolean => {
const [visible, setVisible] = useState(false);
useEffect(() => {
const isMac = /Mac|iPod|iPhone|iPad/.test(navigator.platform);
const modKey = isMac ? "Meta" : "Control";
let timer: ReturnType<typeof setTimeout> | null = null;
let modHeld = false;
const clearTimer = () => {
if (timer !== null) {
clearTimeout(timer);
timer = null;
}
};
const hide = () => {
setVisible((v) => (v ? false : v));
};
const onKeyDown = (e: KeyboardEvent) => {
if (e.key === modKey) {
// Ignore auto-repeat keydown while already held.
if (modHeld) return;
modHeld = true;
clearTimer();
timer = setTimeout(() => {
timer = null;
setVisible(true);
}, HOLD_MS);
return;
}
// Any non-modifier key press while the modifier is held cancels the
// planned cheatsheet — the user is running a real combo.
clearTimer();
hide();
};
const onKeyUp = (e: KeyboardEvent) => {
if (e.key === modKey) {
modHeld = false;
clearTimer();
hide();
}
};
// Losing focus while holding the key should also cancel.
const onBlur = () => {
modHeld = false;
clearTimer();
hide();
};
document.addEventListener("keydown", onKeyDown);
document.addEventListener("keyup", onKeyUp);
window.addEventListener("blur", onBlur);
return () => {
document.removeEventListener("keydown", onKeyDown);
document.removeEventListener("keyup", onKeyUp);
window.removeEventListener("blur", onBlur);
clearTimer();
};
}, []);
return visible;
};
@@ -2,20 +2,9 @@ import { useEffect, useRef } from "react";
import Konva from "konva";
import { useMoodboardStore } from "../MoodboardStore";
import { Vec2 } from "../types";
import { ZOOM_MAX, ZOOM_MIN, clamp } from "../layout/geometry";
const ZOOM_STEP = 1.1;
const MIN_ZOOM = 0.1;
const MAX_ZOOM = 8;
interface ViewportSetters {
zoomRef: React.MutableRefObject<number>;
panRef: React.MutableRefObject<Vec2>;
setZoom: (z: number) => void;
setPan: (p: Vec2) => void;
}
const clamp = (v: number, lo: number, hi: number) =>
Math.max(lo, Math.min(hi, v));
const isEditableTarget = (target: EventTarget | null): boolean => {
const el = target as HTMLElement | null;
@@ -26,14 +15,16 @@ const isEditableTarget = (target: EventTarget | null): boolean => {
};
// Centralizes wheel-zoom and three pan gestures (drag-empty, spacebar+drag,
// middle-click drag) for the moodboard canvas. Owns no state of its own —
// reads zoom/pan from refs (live values) and writes through the provided
// setters so React state stays in sync.
// middle-click drag) for the moodboard canvas. Reads/writes viewport from
// the store directly — no more ref props, which keeps a future minimap or
// other camera-driving UI (recenter button, Shift+1 fit, etc.) able to
// co-exist with these gestures.
export const useViewportControls = (
stageRef: React.RefObject<Konva.Stage | null>,
setters: ViewportSetters,
) => {
const { zoomRef, panRef, setZoom, setPan } = setters;
const setZoom = useMoodboardStore((s) => s.setZoom);
const setPan = useMoodboardStore((s) => s.setPan);
const resetViewport = useMoodboardStore((s) => s.resetViewport);
const setIsPanning = useMoodboardStore((s) => s.setIsPanning);
// Track spacebar so any subsequent mousedown becomes a pan, not a select.
@@ -60,10 +51,11 @@ export const useViewportControls = (
// Ignore zoom if the user is typing in the text-edit overlay or an input.
if (isEditableTarget(document.activeElement)) return;
e.preventDefault();
const oldScale = zoomRef.current;
const { viewport } = useMoodboardStore.getState();
const oldScale = viewport.zoom;
const pointer = stage.getPointerPosition();
if (!pointer) return;
const stagePos = panRef.current;
const stagePos = viewport.pan;
const mousePointTo = {
x: (pointer.x - stagePos.x) / oldScale,
y: (pointer.y - stagePos.y) / oldScale,
@@ -71,8 +63,8 @@ export const useViewportControls = (
const direction = e.deltaY > 0 ? -1 : 1;
const newScale = clamp(
direction > 0 ? oldScale * ZOOM_STEP : oldScale / ZOOM_STEP,
MIN_ZOOM,
MAX_ZOOM,
ZOOM_MIN,
ZOOM_MAX,
);
const newPan = {
x: pointer.x - mousePointTo.x * newScale,
@@ -86,7 +78,7 @@ export const useViewportControls = (
return () => {
container.removeEventListener("wheel", handleWheel);
};
}, [stageRef, zoomRef, panRef, setZoom, setPan]);
}, [stageRef, setZoom, setPan]);
// Pan gestures: middle-mouse drag, or spacebar+left-drag. Plain left
// click is reserved for selection (clicking nodes, lasso, future marquee)
@@ -100,7 +92,7 @@ export const useViewportControls = (
panState.current = {
active: true,
startScreen: { x: clientX, y: clientY },
startPan: { ...panRef.current },
startPan: { ...useMoodboardStore.getState().viewport.pan },
};
setIsPanning(true);
container.style.cursor = "grabbing";
@@ -156,8 +148,7 @@ export const useViewportControls = (
const mod = isMac ? e.metaKey : e.ctrlKey;
if (mod && e.key === "0") {
e.preventDefault();
setZoom(1);
setPan({ x: 0, y: 0 });
resetViewport();
}
};
@@ -186,5 +177,5 @@ export const useViewportControls = (
document.removeEventListener("keyup", handleKeyUp);
container.style.cursor = "";
};
}, [stageRef, panRef, setPan, setZoom, setIsPanning]);
}, [stageRef, setPan, resetViewport, setIsPanning]);
};
@@ -0,0 +1,174 @@
import { MoodboardNode, Rect, Vec2 } from "../types";
export interface Viewport {
zoom: number;
pan: Vec2;
}
export interface CanvasSize {
width: number;
height: number;
}
// Global zoom clamps — shared by gesture handlers, fit-to-content, and any
// future minimap so the camera can never land outside a consistent range.
export const ZOOM_MIN = 0.1;
export const ZOOM_MAX = 8;
// ---------- scalar + rect primitives ----------
export const clamp = (v: number, lo: number, hi: number): number =>
Math.max(lo, Math.min(hi, v));
export const rectFromPoints = (a: Vec2, b: Vec2): Rect => ({
x: Math.min(a.x, b.x),
y: Math.min(a.y, b.y),
width: Math.abs(b.x - a.x),
height: Math.abs(b.y - a.y),
});
export const rectCorners = (r: {
x: number;
y: number;
width: number;
height: number;
}): Vec2[] => [
{ x: r.x, y: r.y },
{ x: r.x + r.width, y: r.y },
{ x: r.x + r.width, y: r.y + r.height },
{ x: r.x, y: r.y + r.height },
];
export const rectsIntersect = (a: Rect, b: Rect): boolean =>
!(
a.x + a.width < b.x ||
a.x > b.x + b.width ||
a.y + a.height < b.y ||
a.y > b.y + b.height
);
// ---------- AABB over a set of nodes ----------
export const computeAABB = (nodes: MoodboardNode[]): Rect | null => {
if (nodes.length === 0) return null;
let minX = Infinity;
let minY = Infinity;
let maxX = -Infinity;
let maxY = -Infinity;
for (const n of nodes) {
minX = Math.min(minX, n.x);
minY = Math.min(minY, n.y);
maxX = Math.max(maxX, n.x + n.width);
maxY = Math.max(maxY, n.y + n.height);
}
if (!Number.isFinite(minX)) return null;
return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
};
export const computeAABBById = (
nodes: Record<string, MoodboardNode>,
ids: string[],
): Rect | null => {
const picked: MoodboardNode[] = [];
for (const id of ids) {
const n = nodes[id];
if (n) picked.push(n);
}
return computeAABB(picked);
};
// AABB of every top-level node. Treats rotated nodes as their own
// (x, y, w, h) rect for simplicity — fine for "is content on screen?"
// checks and minimap overviews.
export const computeContentBounds = (
nodes: Record<string, MoodboardNode>,
rootOrder: string[],
): Rect | null => computeAABBById(nodes, rootOrder);
// ---------- viewport math ----------
// Visible stage-coord rect = what the camera currently sees.
// canvas_px = pan + stage_coord * zoom, so the visible stage region maps to
// (-pan / zoom) .. (-pan / zoom + canvas / zoom).
export const computeVisibleRect = (
viewport: Viewport,
canvas: CanvasSize,
): Rect => ({
x: -viewport.pan.x / viewport.zoom,
y: -viewport.pan.y / viewport.zoom,
width: canvas.width / viewport.zoom,
height: canvas.height / viewport.zoom,
});
// True if any top-level node's AABB intersects the visible viewport.
// Used by the recenter indicator; a minimap can use this to style the
// viewport rectangle differently when off-content.
export const anyContentVisible = (
nodes: Record<string, MoodboardNode>,
rootOrder: string[],
viewport: Viewport,
canvas: CanvasSize,
): boolean => {
const visible = computeVisibleRect(viewport, canvas);
for (const id of rootOrder) {
const n = nodes[id];
if (!n) continue;
if (
rectsIntersect(
{ x: n.x, y: n.y, width: n.width, height: n.height },
visible,
)
) {
return true;
}
}
return false;
};
// Returns the viewport that frames `bounds` inside `canvas` with `padding`
// screen pixels of margin on all sides, clamped to [ZOOM_MIN, ZOOM_MAX].
// Degenerate bounds (zero width/height) fall back to zoom=1 centered on
// the point.
export const fitViewportToBounds = (
bounds: Rect,
canvas: CanvasSize,
padding: number,
): Viewport => {
if (bounds.width <= 0 || bounds.height <= 0) {
return {
zoom: 1,
pan: {
x: canvas.width / 2 - bounds.x,
y: canvas.height / 2 - bounds.y,
},
};
}
const availW = Math.max(canvas.width - 2 * padding, 1);
const availH = Math.max(canvas.height - 2 * padding, 1);
const zoom = clamp(
Math.min(availW / bounds.width, availH / bounds.height),
ZOOM_MIN,
ZOOM_MAX,
);
const centerX = bounds.x + bounds.width / 2;
const centerY = bounds.y + bounds.height / 2;
return {
zoom,
pan: {
x: canvas.width / 2 - centerX * zoom,
y: canvas.height / 2 - centerY * zoom,
},
};
};
// Returns the pan that centers the viewport on a given stage-coord point
// at the current zoom. Handy for minimap drag-to-navigate: stage point
// under the minimap cursor → pan such that it lands in the canvas center.
export const panToCenterOn = (
stagePoint: Vec2,
zoom: number,
canvas: CanvasSize,
): Vec2 => ({
x: canvas.width / 2 - stagePoint.x * zoom,
y: canvas.height / 2 - stagePoint.y * zoom,
});
@@ -8,21 +8,6 @@ export interface PackOptions {
const DEFAULTS: PackOptions = { rowHeight: 180, gap: 8 };
export const computeAABB = (nodes: MoodboardNode[]): Rect | null => {
if (nodes.length === 0) return null;
let minX = Infinity;
let minY = Infinity;
let maxX = -Infinity;
let maxY = -Infinity;
for (const n of nodes) {
minX = Math.min(minX, n.x);
minY = Math.min(minY, n.y);
maxX = Math.max(maxX, n.x + n.width);
maxY = Math.max(maxY, n.y + n.height);
}
return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
};
export const computePackPatches = (
nodes: MoodboardNode[],
bounds: Rect,
@@ -1,5 +1,7 @@
import { memo } from "react";
import Konva from "konva";
import { Group, Rect } from "react-konva";
import { useShallow } from "zustand/react/shallow";
import { GroupNode as GroupNodeData, MoodboardNode } from "../types";
import { useMoodboardStore } from "../MoodboardStore";
import { ImageNode } from "./ImageNode";
@@ -8,17 +10,37 @@ import { TextNode } from "./TextNode";
interface Props {
node: GroupNodeData;
selected: boolean;
onSelect: (e: Konva.KonvaEventObject<MouseEvent | TouchEvent>) => void;
onSelect: (
id: string,
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => void;
}
export const GroupNode = ({ node, selected, onSelect }: Props) => {
const nodes = useMoodboardStore((s) => s.nodes);
// Shared no-op for child renders: the group absorbs all clicks, so child
// nodes never fire `onSelect`. Using a module-level constant keeps the
// reference stable across renders, which lets the memoized child nodes
// skip work when nothing else about them changed.
const NO_OP_SELECT = () => {};
const GroupNodeInner = ({ node, selected, onSelect }: Props) => {
const updateNode = useMoodboardStore((s) => s.updateNode);
const pushHistory = useMoodboardStore((s) => s.pushHistory);
const children: MoodboardNode[] = node.childIds
.map((id) => nodes[id])
.filter((n): n is MoodboardNode => Boolean(n));
// Subscribe only to this group's own children, with a shallow compare on
// the returned array. Avoids re-rendering every group whenever any node
// anywhere in the board updates (which would otherwise mutate the whole
// `nodes` map reference).
const children = useMoodboardStore(
useShallow((s) =>
node.childIds
.map((id) => s.nodes[id])
.filter((n): n is MoodboardNode => Boolean(n)),
),
);
const handleSelect = (
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => onSelect(node.id, e);
return (
<Group
@@ -29,8 +51,8 @@ export const GroupNode = ({ node, selected, onSelect }: Props) => {
height={node.height}
rotation={node.rotation}
draggable
onMouseDown={onSelect}
onTouchStart={onSelect}
onMouseDown={handleSelect}
onTouchStart={handleSelect}
onDragStart={() => {
pushHistory();
}}
@@ -58,7 +80,7 @@ export const GroupNode = ({ node, selected, onSelect }: Props) => {
node={child}
draggable={false}
selected={false}
onSelect={() => {}}
onSelect={NO_OP_SELECT}
/>
);
}
@@ -69,7 +91,7 @@ export const GroupNode = ({ node, selected, onSelect }: Props) => {
node={child}
draggable={false}
selected={false}
onSelect={() => {}}
onSelect={NO_OP_SELECT}
/>
);
}
@@ -80,7 +102,7 @@ export const GroupNode = ({ node, selected, onSelect }: Props) => {
key={child.id}
node={child}
selected={false}
onSelect={() => {}}
onSelect={NO_OP_SELECT}
/>
);
}
@@ -89,3 +111,5 @@ export const GroupNode = ({ node, selected, onSelect }: Props) => {
</Group>
);
};
export const GroupNode = memo(GroupNodeInner);
@@ -1,4 +1,4 @@
import { useEffect, useRef, useState } from "react";
import { memo, useEffect, useRef, useState } from "react";
import Konva from "konva";
import { Image as KonvaImage, Rect } from "react-konva";
import { ImageNode as ImageNodeData } from "../types";
@@ -8,10 +8,15 @@ interface Props {
node: ImageNodeData;
draggable: boolean;
selected: boolean;
onSelect: (e: Konva.KonvaEventObject<MouseEvent | TouchEvent>) => void;
// Receives the node id so parents can pass one stable callback to every
// sibling rather than allocating a per-item closure on each render.
onSelect: (
id: string,
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => void;
}
export const ImageNode = ({ node, draggable, selected, onSelect }: Props) => {
const ImageNodeInner = ({ node, draggable, selected, onSelect }: Props) => {
const updateNode = useMoodboardStore((s) => s.updateNode);
const pushHistory = useMoodboardStore((s) => s.pushHistory);
const ref = useRef<Konva.Image | null>(null);
@@ -27,6 +32,10 @@ export const ImageNode = ({ node, draggable, selected, onSelect }: Props) => {
};
}, [node.src]);
const handleSelect = (
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => onSelect(node.id, e);
return (
<>
{!img && (
@@ -53,8 +62,8 @@ export const ImageNode = ({ node, draggable, selected, onSelect }: Props) => {
height={node.height}
rotation={node.rotation}
draggable={draggable}
onMouseDown={onSelect}
onTouchStart={onSelect}
onMouseDown={handleSelect}
onTouchStart={handleSelect}
onDragStart={() => {
pushHistory();
}}
@@ -65,3 +74,5 @@ export const ImageNode = ({ node, draggable, selected, onSelect }: Props) => {
</>
);
};
export const ImageNode = memo(ImageNodeInner);
@@ -1,3 +1,4 @@
import { memo } from "react";
import Konva from "konva";
import { Text as KonvaText } from "react-konva";
import { TextNode as TextNodeData } from "../types";
@@ -7,15 +8,25 @@ interface Props {
node: TextNodeData;
draggable: boolean;
selected: boolean;
onSelect: (e: Konva.KonvaEventObject<MouseEvent | TouchEvent>) => void;
onSelect: (
id: string,
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => void;
}
export const TextNode = ({ node, draggable, selected, onSelect }: Props) => {
const TextNodeInner = ({ node, draggable, selected, onSelect }: Props) => {
const updateNode = useMoodboardStore((s) => s.updateNode);
const pushHistory = useMoodboardStore((s) => s.pushHistory);
const setEditingText = useMoodboardStore((s) => s.setEditingText);
const editingTextId = useMoodboardStore((s) => s.transient.editingTextId);
const isEditing = editingTextId === node.id;
// Selector compares a single id — only the TextNode whose isEditing
// actually flips will re-render when someone enters/exits text edit.
const isEditing = useMoodboardStore(
(s) => s.transient.editingTextId === node.id,
);
const handleSelect = (
e: Konva.KonvaEventObject<MouseEvent | TouchEvent>,
) => onSelect(node.id, e);
return (
<KonvaText
@@ -30,8 +41,8 @@ export const TextNode = ({ node, draggable, selected, onSelect }: Props) => {
fill={node.color}
padding={6}
draggable={draggable}
onMouseDown={onSelect}
onTouchStart={onSelect}
onMouseDown={handleSelect}
onTouchStart={handleSelect}
onDblClick={() => setEditingText(node.id)}
onDblTap={() => setEditingText(node.id)}
onDragStart={() => {
@@ -45,3 +56,5 @@ export const TextNode = ({ node, draggable, selected, onSelect }: Props) => {
/>
);
};
export const TextNode = memo(TextNodeInner);
@@ -0,0 +1,32 @@
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import { faCompress } from "@fortawesome/pro-solid-svg-icons";
import { useMoodboardStore } from "../MoodboardStore";
import { anyContentVisible } from "../layout/geometry";
// Small pill button in the bottom-right that appears when the user has
// panned or zoomed so far that no content is on screen. Clicking it calls
// `fitToContent` to frame all nodes back into view. Hidden on an empty
// board (nothing to recenter on) and whenever any node intersects the
// visible viewport.
export const RecenterIndicator = () => {
const nodes = useMoodboardStore((s) => s.nodes);
const rootOrder = useMoodboardStore((s) => s.rootOrder);
const viewport = useMoodboardStore((s) => s.viewport);
const canvasSize = useMoodboardStore((s) => s.canvasSize);
const fitToContent = useMoodboardStore((s) => s.fitToContent);
if (rootOrder.length === 0) return null;
if (anyContentVisible(nodes, rootOrder, viewport, canvasSize)) return null;
return (
<button
type="button"
onClick={() => fitToContent()}
title="Zoom to fit (Shift+1)"
className="pointer-events-auto absolute bottom-4 right-4 z-20 flex items-center gap-2 rounded-full border border-white/20 bg-black/70 px-3 py-2 text-sm text-white/90 shadow-lg backdrop-blur-sm transition-colors hover:bg-black/80"
>
<FontAwesomeIcon icon={faCompress} />
<span>Content off-screen — recenter</span>
</button>
);
};
@@ -0,0 +1,76 @@
import { SHORTCUTS, ShortcutRow } from "./shortcuts";
interface Props {
visible: boolean;
}
const SECTION_ORDER: ShortcutRow["section"][] = [
"Tools",
"Selection",
"Editing",
"Viewport",
"History",
];
// Translucent, non-interactive overlay that lists all keyboard shortcuts.
// Shown while the user holds Ctrl/Cmd alone for 3 s (see
// `useShortcutCheatsheet.ts`). `pointer-events: none` so it never steals
// focus — the user can keep panning / zooming / typing while it's visible.
export const ShortcutCheatsheet = ({ visible }: Props) => {
if (!visible) return null;
// Group rows by section, preserving declaration order within each.
const bySection = new Map<ShortcutRow["section"], ShortcutRow[]>();
for (const row of SHORTCUTS) {
const arr = bySection.get(row.section) ?? [];
arr.push(row);
bySection.set(row.section, arr);
}
return (
<div
aria-hidden
className="pointer-events-none absolute inset-0 z-30 flex items-center justify-center"
>
<div className="max-h-[80%] w-[min(640px,90%)] overflow-auto rounded-xl border border-white/15 bg-black/70 p-6 text-white/90 shadow-2xl backdrop-blur-sm">
<div className="mb-3 text-xs uppercase tracking-widest text-white/50">
Keyboard shortcuts
</div>
<div className="grid grid-cols-1 gap-x-8 gap-y-6 sm:grid-cols-2">
{SECTION_ORDER.map((section) => {
const rows = bySection.get(section);
if (!rows) return null;
return (
<div key={section}>
<div className="mb-2 text-xs font-semibold uppercase tracking-wider text-white/60">
{section}
</div>
<ul className="flex flex-col gap-1.5">
{rows.map((row) => (
<li
key={row.label}
className="flex items-center justify-between gap-3 text-sm"
>
<span className="text-white/80">{row.label}</span>
<span className="flex items-center gap-1">
{row.keys.map((k, i) => (
<Key key={`${row.label}-${i}`} label={k} />
))}
</span>
</li>
))}
</ul>
</div>
);
})}
</div>
</div>
</div>
);
};
const Key = ({ label }: { label: string }) => (
<kbd className="rounded border border-white/20 bg-white/10 px-1.5 py-0.5 font-mono text-[11px] text-white/90">
{label}
</kbd>
);
@@ -0,0 +1,46 @@
// Single source of truth for moodboard keyboard shortcuts. Consumed by
// `ShortcutCheatsheet.tsx` (rendering) and indirectly by
// `useKeyboardShortcuts.ts` (wiring). The `keys` array is the label shown
// to the user; the actual matching logic lives in the hook because some
// shortcuts are modifier-sensitive and platform-specific.
export interface ShortcutRow {
label: string;
keys: string[];
section: "Tools" | "Selection" | "Editing" | "Viewport" | "History";
}
const isMac =
typeof navigator !== "undefined" &&
/Mac|iPod|iPhone|iPad/.test(navigator.platform);
export const MOD = isMac ? "⌘" : "Ctrl";
export const SHORTCUTS: ShortcutRow[] = [
// Tools
{ section: "Tools", label: "Select tool", keys: ["V"] },
{ section: "Tools", label: "Lasso tool", keys: ["L"] },
{ section: "Tools", label: "Text tool", keys: ["T"] },
// Selection
{ section: "Selection", label: "Select all", keys: [MOD, "A"] },
{ section: "Selection", label: "Clear selection", keys: ["Esc"] },
{ section: "Selection", label: "Add / remove from selection", keys: ["Shift", "Click"] },
// Editing
{ section: "Editing", label: "Delete selection", keys: ["Delete"] },
{ section: "Editing", label: "Group selection", keys: [MOD, "G"] },
{ section: "Editing", label: "Ungroup selection", keys: [MOD, "Shift", "G"] },
{ section: "Editing", label: "Paste image", keys: [MOD, "V"] },
// Viewport
{ section: "Viewport", label: "Pan", keys: ["Middle-click", "drag"] },
{ section: "Viewport", label: "Pan (alt)", keys: ["Space", "drag"] },
{ section: "Viewport", label: "Zoom", keys: ["Scroll"] },
{ section: "Viewport", label: "Reset zoom", keys: [MOD, "0"] },
{ section: "Viewport", label: "Zoom to fit", keys: ["Shift", "1"] },
// History
{ section: "History", label: "Undo", keys: [MOD, "Z"] },
{ section: "History", label: "Redo", keys: [MOD, "Shift", "Z"] },
];
@@ -1,4 +1,5 @@
import { computeAABB, computePackPatches } from "~/pages/PageMoodboard/layout/packCollage";
import { computeAABB } from "~/pages/PageMoodboard/layout/geometry";
import { computePackPatches } from "~/pages/PageMoodboard/layout/packCollage";
import { MoodboardNode } from "~/pages/PageMoodboard/types";
const img = (