@50arms/ui 0.0.0-stage → 35.1.0

package/dist/components/graph-explorer/camera-math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-math.js","sources":["../../../src/components/graph-explorer/camera-math.ts"],"sourcesContent":["/* ============================================================================\n   CAMERA MATH — pure, no DOM. (DX-3376)\n\n   The camera is a transform applied to the content plane:\n   `translate(camera.x, camera.y) scale(camera.scale)`, origin at the plane's\n   own top-left. Every function here converts between three things: a point on\n   SCREEN (viewport-local pixels — (0,0) is the viewport's own top-left corner,\n   not the browser window), a point in CONTENT space (the coordinates\n   `layoutExplorerTree` already hands back), and the camera state that maps one\n   onto the other.\n\n   PURE ON PURPOSE — same reason `layout.ts` is pure: a camera reducer that\n   also touched the DOM could not be tested against its own arithmetic, only\n   against a screenshot. `use-camera.ts` is the only file that owns an element.\n   ========================================================================= */\n\nexport interface Point {\n  x: number;\n  y: number;\n}\n\nexport interface Box {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport interface Size {\n  width: number;\n  height: number;\n}\n\nexport interface CameraState {\n  x: number;\n  y: number;\n  scale: number;\n}\n\nexport interface ScaleBounds {\n  minScale?: number;\n  maxScale?: number;\n}\n\nexport const CAMERA_DEFAULTS = {\n  /* Below this a graph of any real size is an unreadable smear of lines.\n     Above the max, a single node fills more of the viewport than a \"you are\n     here\" highlight needs. Both are soft limits a caller can widen. */\n  minScale: 0.15,\n  maxScale: 3,\n  /* `fitAll` never zooms IN past 100% just because the graph is small — a\n     three-node tree filling the screen at 240% reads as broken, not helpful. */\n  fitMaxScale: 1,\n  /* Clear space around the drawing that `fitAll` leaves on every side, so the\n     outermost nodes are not pressed against the viewport's edge. */\n  fitPadding: 64,\n} as const;\n\nexport function clampScale(scale: number, bounds: ScaleBounds = {}): number {\n  const min = bounds.minScale ?? CAMERA_DEFAULTS.minScale;\n  const max = bounds.maxScale ?? CAMERA_DEFAULTS.maxScale;\n  return Math.min(Math.max(scale, min), max);\n}\n\n/** Screen point → the content point currently sitting under it. */\nexport function toContentPoint(camera: CameraState, screenPoint: Point): Point {\n  return {\n    x: (screenPoint.x - camera.x) / camera.scale,\n    y: (screenPoint.y - camera.y) / camera.scale,\n  };\n}\n\n/** Content point → where it currently sits on screen. */\nexport function toScreenPoint(camera: CameraState, contentPoint: Point): Point {\n  return {\n    x: camera.x + contentPoint.x * camera.scale,\n    y: camera.y + contentPoint.y * camera.scale,\n  };\n}\n\n/**\n * Zoom by `factor`, holding `screenPoint` fixed over the same content point it\n * covered before — the standard \"zoom toward the cursor\" behaviour a wheel or\n * a pinch both want. `factor` > 1 zooms in.\n */\nexport function zoomAtPoint(\n  camera: CameraState,\n  screenPoint: Point,\n  factor: number,\n  bounds: ScaleBounds = {},\n): CameraState {\n  const scale = clampScale(camera.scale * factor, bounds);\n  const content = toContentPoint(camera, screenPoint);\n  return {\n    scale,\n    x: screenPoint.x - content.x * scale,\n    y: screenPoint.y - content.y * scale,\n  };\n}\n\n/** A camera that puts `target`'s centre in the middle of `viewport`, at `scale`. */\nexport function centerOn(target: Box | Point, viewport: Size, scale: number): CameraState {\n  const center =\n    \"width\" in target\n      ? { x: target.x + target.width / 2, y: target.y + target.height / 2 }\n      : target;\n  return {\n    scale,\n    x: viewport.width / 2 - center.x * scale,\n    y: viewport.height / 2 - center.y * scale,\n  };\n}\n\nexport interface FitOptions extends ScaleBounds {\n  /** @default CAMERA_DEFAULTS.fitPadding */\n  padding?: number;\n  /** @default CAMERA_DEFAULTS.fitMaxScale — never zoom IN past this to fit a small box. */\n  maxScale?: number;\n}\n\n/**\n * The smallest box containing every one of `boxes` — how a camera \"frame\"\n * (e.g. a focused node plus its parent and children, DX-3401) is built from\n * several already-placed boxes without re-deriving a bounding-box formula at\n * every call site. `null` for an empty list — nothing to union.\n */\nexport function unionBox(boxes: readonly Box[]): Box | null {\n  if (boxes.length === 0) return null;\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (const box of boxes) {\n    minX = Math.min(minX, box.x);\n    minY = Math.min(minY, box.y);\n    maxX = Math.max(maxX, box.x + box.width);\n    maxY = Math.max(maxY, box.y + box.height);\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/** A camera that fits the whole of `box` inside `viewport`, centred, padded. */\nexport function fitBox(box: Box, viewport: Size, options: FitOptions = {}): CameraState {\n  const padding = options.padding ?? CAMERA_DEFAULTS.fitPadding;\n  const maxScale = options.maxScale ?? CAMERA_DEFAULTS.fitMaxScale;\n  const minScale = options.minScale ?? CAMERA_DEFAULTS.minScale;\n\n  const availableWidth = viewport.width - padding * 2;\n  const availableHeight = viewport.height - padding * 2;\n\n  if (box.width <= 0 || box.height <= 0 || availableWidth <= 0 || availableHeight <= 0) {\n    return centerOn(box, viewport, maxScale);\n  }\n\n  const scale = clampScale(Math.min(availableWidth / box.width, availableHeight / box.height), {\n    minScale,\n    maxScale,\n  });\n  return centerOn(box, viewport, scale);\n}\n\n/**\n * A camera that makes `content` exactly as wide as `viewport` and starts at its\n * top (DX-4398) — how a document page is read: the width fits, the length\n * scrolls, and the top is where a page starts. Horizontally centred, which only\n * shows once `bounds` clamp the page narrower than the viewport. Never an\n * unbounded scale: a 10px-wide page stops at `maxScale`, a 100000px-wide one at\n * `minScale`. Zero-size content (an image not measured yet) is a finite 100%\n * camera at the origin, never NaN.\n */\nexport function fitWidth(content: Size, viewport: Size, bounds: ScaleBounds = {}): CameraState {\n  if (content.width <= 0 || content.height <= 0 || viewport.width <= 0) {\n    return { scale: clampScale(1, bounds), x: 0, y: 0 };\n  }\n  const scale = clampScale(viewport.width / content.width, bounds);\n  return { scale, x: (viewport.width - content.width * scale) / 2, y: 0 };\n}\n\n/**\n * Which viewport edges have `box`'s content extending past them at `camera`'s\n * current position/scale — the input `fitBoxWithFloor` (below) needs to\n * report an overflow cue, factored out because a caller re-deriving it from\n * raw camera state would be a second, easily-drifting copy of this same\n * arithmetic (DX-3404). A small epsilon absorbs floating-point noise at an\n * edge that lands (by construction) exactly on the viewport boundary.\n */\nexport interface FrameOverflow {\n  left: boolean;\n  right: boolean;\n  top: boolean;\n  bottom: boolean;\n}\n\nconst OVERFLOW_EPSILON = 0.5;\n\nfunction frameOverflowOf(box: Box, viewport: Size, camera: CameraState): FrameOverflow {\n  const topLeft = toScreenPoint(camera, { x: box.x, y: box.y });\n  const bottomRight = toScreenPoint(camera, { x: box.x + box.width, y: box.y + box.height });\n  return {\n    left: topLeft.x < -OVERFLOW_EPSILON,\n    right: bottomRight.x > viewport.width + OVERFLOW_EPSILON,\n    top: topLeft.y < -OVERFLOW_EPSILON,\n    bottom: bottomRight.y > viewport.height + OVERFLOW_EPSILON,\n  };\n}\n\nexport interface FitWithFloorOptions extends FitOptions {\n  /**\n   * A SECOND, stricter lower bound on top of `minScale`/`fitBounds` (DX-3404)\n   * — readability-driven (\"titles at least ~13px on screen\"), not\n   * graph-legibility-driven the way `CAMERA_DEFAULTS.minScale` (0.15) is.\n   * `undefined` (the default) makes this behave exactly like `fitBox` — the\n   * floor is opt-in per call site, so `fitAll` (which never passes it) stays\n   * a manual control that may zoom out past readable text on purpose.\n   * When the ordinary fit-to-`box` scale would land BELOW this floor, the\n   * camera clamps to the floor and centres on `focusBox` instead of `box` —\n   * showing the focused target at a readable size and reaching the rest of\n   * `box` by panning, rather than shrinking everything to fit.\n   */\n  minReadableScale?: number;\n  /**\n   * What to centre on once `minReadableScale` clamps the scale — normally\n   * the focused node's own (small) box, not the whole (wide) `box` being\n   * framed. Defaults to `box` itself (so an omitted `focusBox` degrades to\n   * \"clamp the scale but still centre the frame\", never a crash).\n   */\n  focusBox?: Box;\n}\n\nexport interface FitWithFloorResult {\n  camera: CameraState;\n  /** Which sides of `box` extend past the viewport at the returned camera's\n      scale/position — all `false` whenever the floor didn't clamp, since an\n      ordinary `fitBox` result always contains the whole of `box` by\n      construction. */\n  overflow: FrameOverflow;\n}\n\n/**\n * `fitBox`, with an optional readable-text floor (DX-3404) — see\n * `FitWithFloorOptions.minReadableScale`'s own doc for the behaviour. Used\n * ONLY by `use-camera.ts`'s automatic frame-fit effect; `fitAll` keeps\n * calling `fitBox` directly so the manual \"fit everything\" control is never\n * affected by this floor (AC #2).\n */\nexport function fitBoxWithFloor(box: Box, viewport: Size, options: FitWithFloorOptions = {}): FitWithFloorResult {\n  const { minReadableScale, focusBox = box, ...fitOptions } = options;\n  const fitted = fitBox(box, viewport, fitOptions);\n\n  if (minReadableScale === undefined || fitted.scale >= minReadableScale) {\n    return { camera: fitted, overflow: frameOverflowOf(box, viewport, fitted) };\n  }\n\n  /* The whole frame can't fit at a readable scale — hold the floor.\n     DX-3405: only the HORIZONTAL axis is allowed to overflow (reached by\n     panning) — vertical clipping is never acceptable, since it hides an\n     entire rank (the parent or the children row), not just a sliver of\n     one. So the two axes are centred on DIFFERENT targets: horizontally on\n     the narrow `focusBox` (the pre-DX-3405 behaviour, which may push the\n     frame's far left/right edges off-screen exactly as designed), but\n     vertically on the FULL `box` (parent + focus + children) — so every\n     rank stays centred around the viewport's own vertical middle, by\n     construction, rather than around wherever the focused node happens to\n     sit within the frame. This still relies on the caller sizing its\n     viewport tall enough to hold `box`'s height at `minReadableScale`\n     (`MINIMAP_HEIGHT` in `GraphExplorer.tsx`) — this function has no\n     viewport-sizing lever of its own, only the centring choice. */\n  const scale = Math.max(minReadableScale, CAMERA_DEFAULTS.minScale);\n  const centerX = focusBox.x + focusBox.width / 2;\n  const centerY = box.y + box.height / 2;\n  const camera: CameraState = {\n    scale,\n    x: viewport.width / 2 - centerX * scale,\n    y: viewport.height / 2 - centerY * scale,\n  };\n  return { camera, overflow: frameOverflowOf(box, viewport, camera) };\n}\n"],"names":["CAMERA_DEFAULTS","clampScale","scale","bounds","min","max","toContentPoint","camera","screenPoint","toScreenPoint","contentPoint","zoomAtPoint","factor","content","centerOn","target","viewport","center","unionBox","boxes","minX","minY","maxX","maxY","box","fitBox","options","padding","maxScale","minScale","availableWidth","availableHeight","fitWidth","OVERFLOW_EPSILON","frameOverflowOf","topLeft","bottomRight","fitBoxWithFloor","minReadableScale","focusBox","fitOptions","fitted","centerX","centerY"],"mappings":"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"}

package/dist/components/graph-explorer/tree-layout.js

@@ -0,0 +1,103 @@
+import { layoutGraph as u } from "../node-canvas/layout.js";
+import { edgePath as v } from "../node-canvas/layout.js";
+import { unionBox as l } from "./camera-math.js";
+function g(n) {
+  for (const i of n)
+    if (i.parentId === i.id)
+      throw new Error(`layoutExplorerTree: node "${i.id}" names itself as its own parent`);
+}
+function y(n) {
+  const i = new Map(n.map((o) => [o.id, o.parentId])), d = /* @__PURE__ */ new Map();
+  for (const o of n) {
+    if (d.get(o.id) === "done") continue;
+    const s = [];
+    let e = o.id;
+    for (; e !== null; ) {
+      const c = d.get(e);
+      if (c === "visiting")
+        throw new Error(
+          `layoutExplorerTree: cyclic parent chain: ${[...s, e].join(" -> ")}`
+        );
+      if (c === "done") break;
+      d.set(e, "visiting"), s.push(e), e = i.get(e) ?? null;
+    }
+    for (const c of s) d.set(c, "done");
+  }
+}
+function p(n, i) {
+  const d = n.x + n.width / 2, o = n.y + n.height / 2, s = i.x - d, e = i.y - o;
+  if (s === 0 && e === 0) return { x: d, y: o };
+  const c = n.width / 2, t = n.height / 2, h = s !== 0 ? c / Math.abs(s) : 1 / 0, r = e !== 0 ? t / Math.abs(e) : 1 / 0, a = Math.min(h, r);
+  return { x: d + s * a, y: o + e * a };
+}
+function w(n, i, d) {
+  const o = { x: n.x + n.width / 2, y: n.y + n.height / 2 }, s = { x: i.x + i.width / 2, y: i.y + i.height / 2 }, e = [p(n, s), p(i, o)];
+  return { from: n.id, to: i.id, kind: d, weight: 1, points: e };
+}
+function x(n, i = [], d = {}) {
+  g(n.nodes), y(n.nodes);
+  const o = new Set(n.nodes.map((r) => r.id)), s = [];
+  for (const r of n.nodes)
+    if (r.parentId !== null) {
+      if (!o.has(r.parentId))
+        throw new Error(
+          `layoutExplorerTree: node "${r.id}" names parent "${r.parentId}", which is not in this tree`
+        );
+      s.push({ from: r.parentId, to: r.id });
+    }
+  const e = { nodes: n.nodes, edges: s }, c = u(e, [], null, { orientation: "vertical", ...d }), t = new Map(c.nodes.map((r) => [r.id, r])), h = [];
+  for (const r of i) {
+    if (r.from === r.to) continue;
+    const a = t.get(r.from), f = t.get(r.to);
+    !a || !f || h.push(w(a, f, r.kind));
+  }
+  return {
+    nodes: c.nodes,
+    edges: c.edges,
+    crossLinks: h,
+    width: c.width,
+    height: c.height
+  };
+}
+function M(n, i) {
+  const d = new Map(n.nodes.map((a) => [a.id, a])), o = d.get(i);
+  if (!o) return null;
+  const s = [o];
+  for (const a of n.edges) {
+    if (a.from !== i) continue;
+    const f = d.get(a.to);
+    f && s.push(f);
+  }
+  const e = l(s), c = n.edges.find((a) => a.to === i)?.from, t = c ? d.get(c) : void 0;
+  if (!t) return e;
+  const h = Math.min(e.y, t.y), r = Math.max(e.y + e.height, t.y + t.height);
+  return { x: e.x, y: h, width: e.width, height: r - h };
+}
+function k(n, i) {
+  const d = new Map(n.nodes.map((t) => [t.id, t])), o = d.get(i);
+  if (!o) return null;
+  const s = /* @__PURE__ */ new Map();
+  s.set(o.id, o);
+  let e = o;
+  for (; e && e.parentId !== null; ) {
+    const t = d.get(e.parentId);
+    if (!t) break;
+    s.set(t.id, t), e = t;
+  }
+  if (o.parentId !== null)
+    for (const t of n.nodes)
+      t.parentId === o.parentId && s.set(t.id, t);
+  for (const t of n.nodes)
+    t.parentId === o.id && s.set(t.id, t);
+  return { nodes: [...s.values()].map((t) => ({
+    ...t,
+    parentId: t.parentId !== null && s.has(t.parentId) ? t.parentId : null
+  })) };
+}
+export {
+  v as edgePath,
+  M as frameBoxFor,
+  x as layoutExplorerTree,
+  k as neighbourhoodTree
+};
+//# sourceMappingURL=tree-layout.js.map

package/dist/components/graph-explorer/tree-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-layout.js","sources":["../../../src/components/graph-explorer/tree-layout.ts"],"sourcesContent":["import { edgePath, layoutGraph } from \"../node-canvas/layout\";\nimport type { CanvasEdge, CanvasGraph, CanvasPlacedEdge, LayoutOptions, PlacedNode } from \"../node-canvas/types\";\nimport { unionBox, type Box } from \"./camera-math\";\nimport type { CrossLink, ExplorerLayout, ExplorerTree, TreeNode } from \"./types\";\n\n/* ============================================================================\n   TREE LAYOUT — a parent-per-node backbone through `layoutGraph`, plus\n   cross-links drawn on top without ever reaching the layout engine. (DX-3376)\n\n   WHY THIS IS \"NO CONDENSATION\" BY CONSTRUCTION RATHER THAN BY A FLAG. A\n   parent-per-node backbone (every non-root node contributes exactly one\n   `parentId -> id` edge) is a tree, and a tree cannot contain a cycle — so\n   `layoutGraph`'s own Tarjan condensing pre-pass (see `node-canvas/layout.ts`)\n   never finds a strongly-connected component of size > 1 here and never\n   produces a `cycle:`-prefixed placed node. `assertAcyclicParents` below\n   exists only to make a MALFORMED input (a caller-supplied parent cycle) fail\n   loud at the boundary, rather than silently reaching dagre and producing\n   exactly the \"cyclic cluster\" box this component exists to never show.\n   ========================================================================= */\n\n/** Re-exported for a consumer drawing `edges`/`crossLinks` into an SVG. */\nexport { edgePath };\n\nfunction assertNoSelfParent<Extra>(nodes: readonly TreeNode<Extra>[]): void {\n  for (const node of nodes) {\n    if (node.parentId === node.id) {\n      throw new Error(`layoutExplorerTree: node \"${node.id}\" names itself as its own parent`);\n    }\n  }\n}\n\n/**\n * Fails loud on a cyclic parent chain (A's parent is B, B's parent is A, or\n * anything longer) — malformed input, not a shape this layout can draw.\n * Three-colour DFS over the parent pointers, O(n) total.\n */\nfunction assertAcyclicParents<Extra>(nodes: readonly TreeNode<Extra>[]): void {\n  const parentOf = new Map(nodes.map((node) => [node.id, node.parentId]));\n  const state = new Map<string, \"visiting\" | \"done\">();\n\n  for (const node of nodes) {\n    if (state.get(node.id) === \"done\") continue;\n    const chain: string[] = [];\n    let current: string | null = node.id;\n    while (current !== null) {\n      const seen = state.get(current);\n      if (seen === \"visiting\") {\n        throw new Error(\n          `layoutExplorerTree: cyclic parent chain: ${[...chain, current].join(\" -> \")}`,\n        );\n      }\n      if (seen === \"done\") break;\n      state.set(current, \"visiting\");\n      chain.push(current);\n      current = parentOf.get(current) ?? null;\n    }\n    for (const id of chain) state.set(id, \"done\");\n  }\n}\n\n/**\n * Where a ray from `box`'s centre toward `target` exits `box`'s rectangle —\n * the point a cross-link's line starts or ends at, so it touches the node's\n * edge rather than running through its centre and under its label.\n */\nfunction boundaryPoint(box: { x: number; y: number; width: number; height: number }, target: { x: number; y: number }): { x: number; y: number } {\n  const cx = box.x + box.width / 2;\n  const cy = box.y + box.height / 2;\n  const dx = target.x - cx;\n  const dy = target.y - cy;\n  if (dx === 0 && dy === 0) return { x: cx, y: cy };\n\n  const halfWidth = box.width / 2;\n  const halfHeight = box.height / 2;\n  const scaleX = dx !== 0 ? halfWidth / Math.abs(dx) : Infinity;\n  const scaleY = dy !== 0 ? halfHeight / Math.abs(dy) : Infinity;\n  const scale = Math.min(scaleX, scaleY);\n  return { x: cx + dx * scale, y: cy + dy * scale };\n}\n\nfunction crossLinkEdge<Extra>(\n  from: PlacedNode<Extra>,\n  to: PlacedNode<Extra>,\n  kind: string | undefined,\n): CanvasPlacedEdge {\n  const fromCenter = { x: from.x + from.width / 2, y: from.y + from.height / 2 };\n  const toCenter = { x: to.x + to.width / 2, y: to.y + to.height / 2 };\n  const points = [boundaryPoint(from, toCenter), boundaryPoint(to, fromCenter)];\n  return { from: from.id, to: to.id, kind, weight: 1, points };\n}\n\n/**\n * Lay out a tree, top to bottom, from a parent backbone alone. Ranked\n * vertically (dagre `rankdir: \"TB\"`) so SIBLINGS spread horizontally within a\n * rank — the sprawl DX-3401's card asks for. A tree this shallow-but-wide (a\n * handful of levels, many children per level) stacked its siblings into one\n * tall column under the previous `\"horizontal\"` (`LR`) default, which is\n * exactly backwards for that shape: `\"horizontal\"` ranks left to right, so\n * within-rank siblings stack along the CROSS axis (vertically) instead.\n * `options.orientation` still overrides this default for a caller with the\n * opposite shape (deep and narrow).\n *\n * `crossLinks` are resolved against the ALREADY-FIXED node positions and\n * returned separately (`ExplorerLayout.crossLinks`) — they never reach\n * `layoutGraph`, so they can never move a node and can never close a cycle\n * for the layout engine to condense. A cross-link naming an id not in the\n * tree, or naming a node as linked to itself, draws nothing — the same\n * \"dangling edge draws nothing\" rule `node-canvas/layout.ts#resolveScope`\n * uses for a group boundary.\n */\nexport function layoutExplorerTree<Extra>(\n  tree: ExplorerTree<Extra>,\n  crossLinks: readonly CrossLink[] = [],\n  options: LayoutOptions = {},\n): ExplorerLayout<Extra> {\n  assertNoSelfParent(tree.nodes);\n  assertAcyclicParents(tree.nodes);\n\n  const ids = new Set(tree.nodes.map((node) => node.id));\n  const backbone: CanvasEdge[] = [];\n  for (const node of tree.nodes) {\n    if (node.parentId === null) continue;\n    if (!ids.has(node.parentId)) {\n      throw new Error(\n        `layoutExplorerTree: node \"${node.id}\" names parent \"${node.parentId}\", which is not in this tree`,\n      );\n    }\n    backbone.push({ from: node.parentId, to: node.id });\n  }\n\n  const graph: CanvasGraph<Extra> = { nodes: tree.nodes, edges: backbone };\n  /* `groups: []`, scope `null` — a tree has no declared groups and only one\n     scope; both exist on `layoutGraph`'s signature for the general-graph case\n     `NodeCanvas` needs. `orientation` defaults to vertical here (top to\n     bottom, DX-3401) so a shallow-but-wide tree sprawls its siblings\n     horizontally instead of stacking them into one tall column — see this\n     function's own doc comment and `CanvasOrientation` in `types.ts`. */\n  const layout = layoutGraph(graph, [], null, { orientation: \"vertical\", ...options });\n\n  const byId = new Map(layout.nodes.map((placed) => [placed.id, placed]));\n  const placedCrossLinks: CanvasPlacedEdge[] = [];\n  for (const link of crossLinks) {\n    if (link.from === link.to) continue;\n    const from = byId.get(link.from);\n    const to = byId.get(link.to);\n    if (!from || !to) continue;\n    placedCrossLinks.push(crossLinkEdge(from, to, link.kind));\n  }\n\n  return {\n    nodes: layout.nodes,\n    edges: layout.edges,\n    crossLinks: placedCrossLinks,\n    width: layout.width,\n    height: layout.height,\n  };\n}\n\n/**\n * The box a camera should keep in frame around `focusId`: the focused node\n * itself and every one of its direct children (one rank down), with the\n * frame's vertical extent alone stretched to reach its parent's rank (one\n * rank up) — \"the minimap always frames the current node, its parent and its\n * children\" (DX-3401's fix for the minimap shrinking an entire tree to\n * specks, and for the full-screen explorer's initial view not opening\n * focused). Computed from an ALREADY-LAID-OUT tree, so it can never disagree\n * with what is actually on screen the way fitting a separately-computed\n * bounding box could. `null` when `focusId` isn't laid out at all — nothing\n * to frame (a stale id, or data still loading).\n *\n * THE PARENT'S X/WIDTH ARE DELIBERATELY NEVER UNIONED IN (DX-3401 follow-up).\n * An earlier version unioned the parent's whole box in, same as a child's.\n * dagre centres a parent horizontally over the barycenter of ALL its\n * children, not just the focused one — so a parent with many other children\n * spread wide (exactly the \"one system, ~15 areas\" shape this card exists to\n * fix) can sit far to one side of the union of `focus` + its own children.\n * Pulling that parent's x/width into the frame then stretches it to cover the\n * real horizontal gap between the parent and this one child, reproducing a\n * milder version of the original \"whole tree crushed to a strip\" bug for\n * this specific shape (confirmed live against the Ringlet demo: a `frameBox`\n * nearly as wide as the entire tree's `contentBox`). Only the parent's Y\n * range is folded in, so the frame reaches up far enough for the connecting\n * edge into the parent to be visible — a parent off to the side is reached by\n * panning, the same trade-off this function already makes for siblings\n * (drawn by `neighbourhoodTree` but never pulled into the frame's own box).\n */\nexport function frameBoxFor<Extra>(layout: ExplorerLayout<Extra>, focusId: string): Box | null {\n  const byId = new Map(layout.nodes.map((placed) => [placed.id, placed]));\n  const focus = byId.get(focusId);\n  if (!focus) return null;\n\n  const boxes: Box[] = [focus];\n  for (const edge of layout.edges) {\n    if (edge.from !== focusId) continue;\n    const child = byId.get(edge.to);\n    if (child) boxes.push(child);\n  }\n  const box = unionBox(boxes)!; // non-null: `boxes` always has at least `focus`\n\n  const parentId = layout.edges.find((edge) => edge.to === focusId)?.from;\n  const parent = parentId ? byId.get(parentId) : undefined;\n  if (!parent) return box;\n\n  const minY = Math.min(box.y, parent.y);\n  const maxY = Math.max(box.y + box.height, parent.y + parent.height);\n  return { x: box.x, y: minY, width: box.width, height: maxY - minY };\n}\n\n/**\n * The subtree a minimap draws: `focusId`'s ancestor chain up to its root,\n * `focusId`'s immediate siblings, and `focusId`'s immediate children — \"the\n * focused node's ancestors, siblings and children\" the card asks for, kept\n * small enough to read at the minimap's compact size. `focusId` itself is\n * always included. Parent links are REWRITTEN to stay inside this subset: the\n * topmost ancestor kept becomes a root (`parentId: null`) here even if its\n * real parent exists outside the shown set, so `layoutExplorerTree` never\n * sees a dangling parent reference. Returns `null` when `focusId` is not in\n * `tree` at all — nothing sensible to show.\n */\nexport function neighbourhoodTree<Extra>(tree: ExplorerTree<Extra>, focusId: string): ExplorerTree<Extra> | null {\n  const byId = new Map(tree.nodes.map((node) => [node.id, node]));\n  const focus = byId.get(focusId);\n  if (!focus) return null;\n\n  const kept = new Map<string, TreeNode<Extra>>();\n  kept.set(focus.id, focus);\n\n  let current: TreeNode<Extra> | undefined = focus;\n  while (current && current.parentId !== null) {\n    const parent = byId.get(current.parentId);\n    if (!parent) break;\n    kept.set(parent.id, parent);\n    current = parent;\n  }\n\n  if (focus.parentId !== null) {\n    for (const node of tree.nodes) {\n      if (node.parentId === focus.parentId) kept.set(node.id, node);\n    }\n  }\n\n  for (const node of tree.nodes) {\n    if (node.parentId === focus.id) kept.set(node.id, node);\n  }\n\n  const nodes: TreeNode<Extra>[] = [...kept.values()].map((node) => ({\n    ...node,\n    parentId: node.parentId !== null && kept.has(node.parentId) ? node.parentId : null,\n  }));\n  return { nodes };\n}\n"],"names":["assertNoSelfParent","nodes","node","assertAcyclicParents","parentOf","state","chain","current","seen","id","boundaryPoint","box","target","cx","cy","dx","dy","halfWidth","halfHeight","scaleX","scaleY","scale","crossLinkEdge","from","to","kind","fromCenter","toCenter","points","layoutExplorerTree","tree","crossLinks","options","ids","backbone","graph","layout","layoutGraph","byId","placed","placedCrossLinks","link","frameBoxFor","focusId","focus","boxes","edge","child","unionBox","parentId","parent","minY","maxY","neighbourhoodTree","kept"],"mappings":"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"}

package/dist/components/graph-explorer/use-camera.js

@@ -0,0 +1,82 @@
+import { useState as f, useRef as m, useCallback as c, useEffect as v } from "react";
+import { CAMERA_DEFAULTS as d, fitBox as U, fitBoxWithFloor as j, centerOn as q, zoomAtPoint as H } from "./camera-math.js";
+import { useViewportGesture as J } from "./viewport-gesture.js";
+const Q = { left: !1, right: !1, top: !1, bottom: !1 }, X = 520;
+function ee(y) {
+  const { contentBox: h, frameBox: p, frameKey: E, framePadding: b, minReadableScale: g, focusBox: T, boxOf: z, onClick: F, disabled: C, resetKey: M } = y, w = { minScale: d.minScale, maxScale: d.maxScale }, A = { minScale: d.minScale }, [u, x] = f({ x: 0, y: 0, scale: 1 }), [_, B] = f(!1), i = m({ width: 0, height: 0 }), [O, I] = f(!1), e = m({
+    contentBox: h,
+    frameBox: p,
+    framePadding: b,
+    minReadableScale: g,
+    focusBox: T,
+    boxOf: z,
+    camera: u,
+    zoomBounds: w,
+    fitBounds: A
+  });
+  e.current = {
+    contentBox: h,
+    frameBox: p,
+    framePadding: b,
+    minReadableScale: g,
+    focusBox: T,
+    boxOf: z,
+    camera: u,
+    zoomBounds: w,
+    fitBounds: A
+  };
+  const n = m(null), r = c((t) => {
+    n.current !== null && window.clearTimeout(n.current), B(!0), x(t), n.current = window.setTimeout(() => {
+      n.current = null, B(!1);
+    }, X);
+  }, []), P = c(() => {
+    n.current !== null && (window.clearTimeout(n.current), n.current = null), B(!1);
+  }, []), L = c(() => {
+    const t = i.current;
+    t.width === 0 || t.height === 0 || r(U(e.current.contentBox, t, e.current.fitBounds));
+  }, [r]), R = m(!1), [N, V] = f(Q);
+  v(() => {
+    if (!O) return;
+    const t = i.current, o = e.current.frameBox ?? e.current.contentBox, a = { ...e.current.fitBounds, padding: e.current.framePadding ?? d.fitPadding }, { camera: s, overflow: S } = j(o, t, {
+      ...a,
+      minReadableScale: e.current.minReadableScale,
+      focusBox: e.current.focusBox ?? o
+    });
+    V(S), R.current ? r(s) : (R.current = !0, x(s));
+  }, [O, M, E, r]);
+  const k = c(
+    (t, o) => {
+      const a = e.current.boxOf(t), s = i.current;
+      if (!a || s.width === 0) return;
+      const S = o ?? Math.max(e.current.camera.scale, 1);
+      r(q(a, s, S));
+    },
+    [r]
+  ), l = c(
+    (t) => {
+      const o = i.current, a = { x: o.width / 2, y: o.height / 2 };
+      r(H(e.current.camera, a, t, e.current.zoomBounds));
+    },
+    [r]
+  ), G = c(() => l(1.35), [l]), K = c(() => l(1 / 1.35), [l]), { panning: W, bindViewport: D } = J({
+    camera: u,
+    setCamera: x,
+    zoomBounds: w,
+    onGestureStart: P,
+    onClick: F,
+    onResize: (t) => {
+      i.current = t, I(!0);
+    },
+    disabled: C
+  });
+  return v(
+    () => () => {
+      n.current !== null && window.clearTimeout(n.current);
+    },
+    []
+  ), { camera: u, panning: W, animating: _, frameOverflow: N, bindViewport: D, zoomIn: G, zoomOut: K, fitAll: L, flyTo: k };
+}
+export {
+  ee as useCamera
+};
+//# sourceMappingURL=use-camera.js.map

package/dist/components/graph-explorer/use-camera.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-camera.js","sources":["../../../src/components/graph-explorer/use-camera.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\nimport {\n  CAMERA_DEFAULTS,\n  centerOn,\n  fitBox,\n  fitBoxWithFloor,\n  zoomAtPoint,\n  type Box,\n  type CameraState,\n  type FitOptions,\n  type FrameOverflow,\n  type ScaleBounds,\n  type Size,\n} from \"./camera-math\";\nimport { useViewportGesture, type ViewportClickEvent } from \"./viewport-gesture\";\n\nconst NO_FRAME_OVERFLOW: FrameOverflow = { left: false, right: false, top: false, bottom: false };\n\n/* ============================================================================\n   THE CAMERA. (DX-3376)\n\n   The graph explorer's camera: state, programmatic moves, the automatic frame\n   fit. The pointer session (click / pan / pinch / wheel) is NOT here — it is\n   `viewport-gesture.ts`, shared with the file viewer (DX-4398); read its module\n   doc for what a pointer session can be.\n\n   PROGRAMMATIC MOVES ANIMATE; DIRECT MANIPULATION NEVER DOES. `zoomIn`,\n   `zoomOut`, `fitAll` and `flyTo` are \"the camera decided to go somewhere\";\n   wheel, pinch and pan are \"a hand is moving it right now\". The CSS\n   transition that makes the first kind glide (`GraphExplorer.tsx`'s\n   `data-animating` attribute) would fight the second kind's need to track the\n   pointer with zero lag, so any new gesture starting cancels an in-flight\n   animation outright (`onGestureStart`).\n   ========================================================================= */\n\n/** How long the CSS fly-to transition (`--dur-slowest`) can possibly run, even\n    at full (non-reduced) motion — see `GraphExplorer.tsx`'s `data-animating`.\n    Clearing the flag after this is always safe; reduced motion only makes the\n    real transition finish sooner, never later. */\nconst ANIMATION_SETTLE_MS = 520;\n\nexport type CameraClickEvent = ViewportClickEvent;\n\nexport interface UseCameraOptions {\n  /** Content-space bounding box of the whole drawing. Drives `fitAll`. */\n  contentBox: Box;\n  /**\n   * The box the camera AUTOMATICALLY keeps in frame — on mount, and again\n   * whenever `frameKey` changes (DX-3401). Typically the focused node plus\n   * its parent and children, so the camera never zooms out further than the\n   * relevant neighbourhood just because the whole tree is big. `null`/\n   * `undefined` falls back to `contentBox` (fit the whole drawing) — the\n   * ordinary case when there is no focus yet.\n   */\n  frameBox?: Box | null;\n  /**\n   * A caller-chosen, STABLE value (e.g. the focused node's id) that changing\n   * re-runs the automatic frame fit even when `resetKey` hasn't changed —\n   * `frameBox` itself is deliberately NOT a dependency (see the frame-fit\n   * effect below for why), so this is the only reliable \"the frame target\n   * moved\" signal for a caller whose `resetKey` tracks something else (e.g.\n   * the explorer's own `resetKey` is the tree, not the focused node).\n   */\n  frameKey?: unknown;\n  /** Padding around the auto-fit target (`frameBox ?? contentBox`) — distinct\n      from `fitAll`'s always-`CAMERA_DEFAULTS.fitPadding`, since a compact\n      minimap strip wants much less breathing room than the full explorer.\n      @default CAMERA_DEFAULTS.fitPadding */\n  framePadding?: number;\n  /**\n   * A THIRD, stricter lower bound layered on top of `fitBounds`'s own\n   * `minScale`, applied ONLY to the automatic frame-fit effect below — NEVER\n   * to `fitAll` (which keeps calling `fitBox` directly with `fitBounds`) and\n   * NEVER to `zoomBounds` (wheel/pinch/+/-, which stay `CAMERA_DEFAULTS\n   * .minScale`..`maxScale`) (DX-3404). See `camera-math.ts`'s\n   * `FitWithFloorOptions.minReadableScale` for the full behaviour: below\n   * this scale, the automatic fit clamps here and centres on `focusBox`\n   * instead of shrinking `frameBox ?? contentBox` to fit — the rest is\n   * reached by panning. `undefined` (the default) reproduces the pre-DX-3404\n   * behaviour exactly (plain `fitBox`, no floor).\n   */\n  minReadableScale?: number;\n  /**\n   * What the automatic fit centres on once `minReadableScale` clamps the\n   * scale — normally the focused node's own (small) box, distinct from the\n   * wider `frameBox` (focus + parent + children) being framed. Defaults to\n   * `frameBox ?? contentBox` when omitted, matching `fitBoxWithFloor`'s own\n   * default. Ignored when `minReadableScale` is unset.\n   */\n  focusBox?: Box | null;\n  /** A node's content-space box, for `flyTo`. `null` for an id not laid out. */\n  boxOf: (id: string) => Box | null;\n  /** A press that released without travelling past `CLICK_DISTANCE`. */\n  onClick?: (event: CameraClickEvent) => void;\n  /** Nothing pans, zooms or clicks. Reading the plane still works. */\n  disabled?: boolean;\n  /** Changing this value re-fits the camera to `contentBox` — a new tree. */\n  resetKey?: unknown;\n}\n\nexport interface UseCameraResult {\n  camera: CameraState;\n  /** A pointer is actively panning or pinching right now. */\n  panning: boolean;\n  /** True for the duration of a programmatic move — see the module doc. */\n  animating: boolean;\n  /**\n   * Which sides of the automatic frame target (`frameBox ?? contentBox`)\n   * extend past the viewport at the CURRENT camera — all `false` unless\n   * `minReadableScale` actually clamped the last automatic fit (DX-3404).\n   * The one source of truth for an \"edge cue\" overlay, so a caller never\n   * re-derives this from raw `camera` state itself.\n   */\n  frameOverflow: FrameOverflow;\n  bindViewport: (node: HTMLElement | null) => (() => void) | undefined;\n  zoomIn: () => void;\n  zoomOut: () => void;\n  fitAll: () => void;\n  /** Animate the camera to centre node `id`. No-op if `id` isn't laid out yet. */\n  flyTo: (id: string, scale?: number) => void;\n}\n\nexport function useCamera(options: UseCameraOptions): UseCameraResult {\n  const { contentBox, frameBox, frameKey, framePadding, minReadableScale, focusBox, boxOf, onClick, disabled, resetKey } =\n    options;\n  /* TWO DIFFERENT BOUNDS, NOT ONE — a direct user zoom (wheel, pinch, the\n     +/- buttons) legitimately goes up to `CAMERA_DEFAULTS.maxScale`, but\n     `fitBox` has its OWN, much stricter ceiling (`fitMaxScale`, 1 — \"never\n     zoom IN past 100% just because the graph is small\", see `camera-math.ts`'s\n     module doc). Passing the general `zoomBounds` into a `fitBox` call would\n     silently widen that ceiling to `maxScale` and defeat the whole point of\n     `fitMaxScale` existing — `fitBounds` deliberately omits `maxScale` so\n     `fitBox`'s own default takes over. */\n  const zoomBounds: ScaleBounds = { minScale: CAMERA_DEFAULTS.minScale, maxScale: CAMERA_DEFAULTS.maxScale };\n  const fitBounds: ScaleBounds = { minScale: CAMERA_DEFAULTS.minScale };\n\n  const [camera, setCamera] = useState<CameraState>({ x: 0, y: 0, scale: 1 });\n  const [animating, setAnimating] = useState(false);\n\n  const size = useRef<Size>({ width: 0, height: 0 });\n  const [sizeReady, setSizeReady] = useState(false);\n\n  /* Read fresh inside listeners that outlive a render — same reasoning as\n     `node-canvas/use-canvas-gestures.ts`'s own `live` ref. */\n  const live = useRef({\n    contentBox,\n    frameBox,\n    framePadding,\n    minReadableScale,\n    focusBox,\n    boxOf,\n    camera,\n    zoomBounds,\n    fitBounds,\n  });\n  live.current = {\n    contentBox,\n    frameBox,\n    framePadding,\n    minReadableScale,\n    focusBox,\n    boxOf,\n    camera,\n    zoomBounds,\n    fitBounds,\n  };\n\n  const animationTimer = useRef<number | null>(null);\n  const animateTo = useCallback((next: CameraState) => {\n    if (animationTimer.current !== null) window.clearTimeout(animationTimer.current);\n    setAnimating(true);\n    setCamera(next);\n    animationTimer.current = window.setTimeout(() => {\n      animationTimer.current = null;\n      setAnimating(false);\n    }, ANIMATION_SETTLE_MS);\n  }, []);\n\n  const cancelAnimation = useCallback(() => {\n    if (animationTimer.current !== null) {\n      window.clearTimeout(animationTimer.current);\n      animationTimer.current = null;\n    }\n    setAnimating(false);\n  }, []);\n\n  const fitAll = useCallback(() => {\n    const viewport = size.current;\n    if (viewport.width === 0 || viewport.height === 0) return;\n    animateTo(fitBox(live.current.contentBox, viewport, live.current.fitBounds));\n  }, [animateTo]);\n\n  /* Re-fit on the FIRST measurement (mount) and on every `resetKey`/`frameKey`\n     change thereafter. The first fit is intentionally NOT animated — see\n     `GraphExplorer.tsx`'s `sizeReady`-gated visibility, which hides the plane\n     until this has run once, so there is nothing on screen yet for a\n     transition to animate away from.\n     Fits `frameBox ?? contentBox` — ONE calculation, used for both the mount\n     case and every subsequent change, which is what makes this the sole\n     writer of the automatic camera position (DX-3401). Previously a SECOND,\n     independent effect in `GraphExplorer.tsx` watched `focusId` and called\n     `flyTo` (a tight single-node centre) whenever it changed; because that\n     effect's `resetKey` here was ALSO keyed to focus (the minimap passes\n     `resetKey={focusId}`), both effects fired on the same focus change and\n     raced to write `camera` last — sometimes a single-node `flyTo` won\n     (clipping the node's own parent/children/siblings), sometimes this fit\n     won (showing the WHOLE tree, shrunk to specks). Deriving `frameBox` from\n     the same focus and calling this ONE effect for both triggers makes the\n     two callers agree on the destination by construction, so which one\n     \"wins\" no longer matters — there is only one. */\n  const didInitialFit = useRef(false);\n  const [frameOverflow, setFrameOverflow] = useState<FrameOverflow>(NO_FRAME_OVERFLOW);\n  useEffect(() => {\n    if (!sizeReady) return;\n    const viewport = size.current;\n    const box = live.current.frameBox ?? live.current.contentBox;\n    const bounds: FitOptions = { ...live.current.fitBounds, padding: live.current.framePadding ?? CAMERA_DEFAULTS.fitPadding };\n    const { camera: next, overflow } = fitBoxWithFloor(box, viewport, {\n      ...bounds,\n      minReadableScale: live.current.minReadableScale,\n      focusBox: live.current.focusBox ?? box,\n    });\n    setFrameOverflow(overflow);\n    if (!didInitialFit.current) {\n      didInitialFit.current = true;\n      setCamera(next);\n    } else {\n      animateTo(next);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- fires on resetKey/frameKey identity, not contentBox/frameBox (those change on every layout settle, e.g. a node's measured height correcting; resetKey/frameKey are the caller's deliberate \"re-fit\" signals)\n  }, [sizeReady, resetKey, frameKey, animateTo]);\n\n  const flyTo = useCallback(\n    (id: string, scale?: number) => {\n      const box = live.current.boxOf(id);\n      const viewport = size.current;\n      if (!box || viewport.width === 0) return;\n      const targetScale = scale ?? Math.max(live.current.camera.scale, 1);\n      animateTo(centerOn(box, viewport, targetScale));\n    },\n    [animateTo],\n  );\n\n  const zoomBy = useCallback(\n    (factor: number) => {\n      const viewport = size.current;\n      const center = { x: viewport.width / 2, y: viewport.height / 2 };\n      animateTo(zoomAtPoint(live.current.camera, center, factor, live.current.zoomBounds));\n    },\n    [animateTo],\n  );\n  const zoomIn = useCallback(() => zoomBy(1.35), [zoomBy]);\n  const zoomOut = useCallback(() => zoomBy(1 / 1.35), [zoomBy]);\n\n  /* The wheel / pan / pinch session is shared with the file viewer — see\n     `viewport-gesture.ts`. This hook keeps only what is the explorer's own: the\n     camera, its animated programmatic moves, and the frame fit. */\n  const { panning, bindViewport } = useViewportGesture({\n    camera,\n    setCamera,\n    zoomBounds,\n    onGestureStart: cancelAnimation,\n    onClick,\n    onResize: (next) => {\n      size.current = next;\n      setSizeReady(true);\n    },\n    disabled,\n  });\n\n  useEffect(\n    () => () => {\n      if (animationTimer.current !== null) window.clearTimeout(animationTimer.current);\n    },\n    [],\n  );\n\n  return { camera, panning, animating, frameOverflow, bindViewport, zoomIn, zoomOut, fitAll, flyTo };\n}\n"],"names":["NO_FRAME_OVERFLOW","ANIMATION_SETTLE_MS","useCamera","options","contentBox","frameBox","frameKey","framePadding","minReadableScale","focusBox","boxOf","onClick","disabled","resetKey","zoomBounds","CAMERA_DEFAULTS","fitBounds","camera","setCamera","useState","animating","setAnimating","size","useRef","sizeReady","setSizeReady","live","animationTimer","animateTo","useCallback","next","cancelAnimation","fitAll","viewport","fitBox","didInitialFit","frameOverflow","setFrameOverflow","useEffect","box","bounds","overflow","fitBoxWithFloor","flyTo","id","scale","targetScale","centerOn","zoomBy","factor","center","zoomAtPoint","zoomIn","zoomOut","panning","bindViewport","useViewportGesture"],"mappings":"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"}

package/dist/components/graph-explorer/viewport-gesture.js

@@ -0,0 +1,107 @@
+import { useState as b, useRef as w, useCallback as E } from "react";
+import { isInteractiveTarget as A } from "../../lib/interactive-target.js";
+import { zoomAtPoint as P } from "./camera-math.js";
+const _ = 5, L = 240, B = 1.0025;
+function D(c, a) {
+  return Math.hypot(c.x - a.x, c.y - a.y);
+}
+function z(c, a) {
+  return { x: (c.x + a.x) / 2, y: (c.y + a.y) / 2 };
+}
+function Y(c) {
+  const [a, h] = b(!1), o = w(c);
+  o.current = c;
+  const d = w({
+    pointers: /* @__PURE__ */ new Map(),
+    mode: "idle",
+    frame: null,
+    originPoint: null,
+    originCamera: null,
+    pinchDistance: null,
+    pinchMidpoint: null,
+    travelled: 0,
+    downTarget: null
+  }), m = E((r) => {
+    const p = d.current.frame;
+    return p ? { x: r.x - p.left, y: r.y - p.top } : r;
+  }, []), T = E(
+    (r) => {
+      if (!r) return;
+      const p = new ResizeObserver((n) => {
+        const t = n[0];
+        t && o.current.onResize?.({ width: t.contentRect.width, height: t.contentRect.height });
+      });
+      p.observe(r);
+      const g = (n) => {
+        if (o.current.disabled) return;
+        n.preventDefault(), o.current.onGestureStart?.();
+        const t = r.getBoundingClientRect(), e = { x: n.clientX - t.left, y: n.clientY - t.top }, s = Math.max(-L, Math.min(L, n.deltaY)), i = Math.pow(B, -s);
+        o.current.setCamera((l) => P(l, e, i, o.current.zoomBounds));
+      };
+      r.addEventListener("wheel", g, { passive: !1 });
+      const y = (n, t) => {
+        const e = d.current;
+        if (!e.pointers.has(n)) return;
+        const s = e.mode === "pan", i = e.downTarget, l = e.travelled;
+        if (e.pointers.delete(n), r.hasPointerCapture(n) && r.releasePointerCapture(n), e.pointers.size === 0)
+          e.mode = "idle", e.originPoint = null, e.originCamera = null, e.pinchDistance = null, e.pinchMidpoint = null, e.downTarget = null, e.frame = null, h(!1), !t && s && l < _ && i && !o.current.disabled && o.current.onClick?.({ target: i });
+        else {
+          const [[, u]] = e.pointers;
+          e.mode = "pan", e.originPoint = u, e.originCamera = o.current.camera, e.pinchDistance = null, e.pinchMidpoint = null, e.travelled = 1 / 0;
+        }
+      }, v = (n) => {
+        const t = d.current;
+        if (!t.pointers.has(n.pointerId)) return;
+        const e = m({ x: n.clientX, y: n.clientY });
+        if (t.pointers.set(n.pointerId, e), t.mode === "pan" && t.originPoint && t.originCamera) {
+          const s = e.x - t.originPoint.x, i = e.y - t.originPoint.y;
+          t.travelled = Math.max(t.travelled, Math.hypot(s, i)), o.current.setCamera({ scale: t.originCamera.scale, x: t.originCamera.x + s, y: t.originCamera.y + i });
+        } else if (t.mode === "pinch") {
+          const s = [...t.pointers.values()];
+          if (s.length < 2) return;
+          const i = D(s[0], s[1]), l = z(s[0], s[1]), u = t.pinchMidpoint;
+          if (t.pinchDistance && t.pinchDistance > 0 && u) {
+            const I = i / t.pinchDistance;
+            o.current.setCamera((R) => {
+              const f = P(R, u, I, o.current.zoomBounds);
+              return {
+                scale: f.scale,
+                x: f.x + (l.x - u.x),
+                y: f.y + (l.y - u.y)
+              };
+            });
+          }
+          t.pinchDistance = i, t.pinchMidpoint = l, t.travelled = 1 / 0;
+        }
+      }, x = (n) => y(n.pointerId, !1), C = (n) => y(n.pointerId, !0), M = (n) => {
+        if (o.current.disabled || n.pointerType === "mouse" && n.button !== 0) return;
+        const t = n.target;
+        if (A(t)) return;
+        o.current.onGestureStart?.();
+        const e = d.current;
+        if (e.pointers.size === 0) {
+          const i = r.getBoundingClientRect();
+          e.frame = { left: i.left, top: i.top };
+        }
+        const s = m({ x: n.clientX, y: n.clientY });
+        if (r.setPointerCapture(n.pointerId), e.pointers.set(n.pointerId, s), e.pointers.size === 1)
+          e.mode = "pan", e.originPoint = s, e.originCamera = o.current.camera, e.travelled = 0, e.downTarget = t, h(!0);
+        else if (e.pointers.size === 2) {
+          e.mode = "pinch";
+          const i = [...e.pointers.values()];
+          e.pinchDistance = D(i[0], i[1]), e.pinchMidpoint = z(i[0], i[1]), e.travelled = 1 / 0;
+        }
+      };
+      return r.addEventListener("pointerdown", M), r.addEventListener("pointermove", v), r.addEventListener("pointerup", x), r.addEventListener("pointercancel", C), () => {
+        p.disconnect(), r.removeEventListener("wheel", g), r.removeEventListener("pointerdown", M), r.removeEventListener("pointermove", v), r.removeEventListener("pointerup", x), r.removeEventListener("pointercancel", C);
+      };
+    },
+    [m]
+  );
+  return { panning: a, bindViewport: T };
+}
+export {
+  _ as CLICK_DISTANCE,
+  Y as useViewportGesture
+};
+//# sourceMappingURL=viewport-gesture.js.map

package/dist/components/graph-explorer/viewport-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewport-gesture.js","sources":["../../../src/components/graph-explorer/viewport-gesture.ts"],"sourcesContent":["import { useCallback, useRef, useState } from \"react\";\nimport { isInteractiveTarget } from \"../../lib/interactive-target\";\nimport { zoomAtPoint, type CameraState, type Point, type ScaleBounds, type Size } from \"./camera-math\";\n\n/* ============================================================================\n   THE VIEWPORT GESTURE. (DX-3376, extracted for the file viewer by DX-4398)\n\n   ONE pointer session — wheel, drag-pan, two-finger pinch — shared by every\n   component that moves a CAMERA (`CameraState`, see `camera-math.ts`) over a\n   fixed-size, clipping viewport: `useCamera` (the graph explorer) and the file\n   viewer's zoom hook. It was `useCamera`'s `bindViewport`; a second copy in the\n   viewer would drift the first time one of them learned something (the\n   `pointercancel` handling and the interactive-target guard are exactly the two\n   things the gpt-manager page viewer's own copy lacked).\n\n   NOT `useCanvasGestures` (`node-canvas/use-canvas-gestures.ts`), AND NOT BUILT\n   ON `attachPointerGesture` (`lib/dnd/sensors/gesture.ts`) EITHER — both track\n   exactly ONE active pointer, which is correct for \"drag one card\" and wrong for\n   \"pinch with two fingers\". This module owns pointer capture and the pointer map\n   itself, at one level lower than either existing gesture layer.\n\n   ONE VIEWPORT, THREE THINGS A POINTER SESSION CAN BE:\n     - ONE pointer, travel below the click threshold at release  -> a CLICK.\n       Forwarded with the element actually under the pointer, so the caller can\n       tell a node click from a background click without this module knowing\n       what a \"node\" is.\n     - ONE pointer, travel over the threshold  -> a PAN. The camera's translation\n       follows the pointer 1:1 — no clamping, no easing, because a hand that\n       stops moving must stop the content moving in the same frame.\n     - TWO pointers  -> a PINCH. Distance between them drives scale; the content\n       point under their midpoint is held fixed (`zoomAtPoint`) and then carried\n       along with the midpoint's own travel, step by step, so a simultaneous\n       two-finger pan (the midpoint drifting while the fingers also spread) is\n       both a zoom and a pan.\n\n   A press that starts ON A REAL CONTROL is let through untouched: capturing the\n   pointer here would take the click away from the control before it ever sees\n   it (the browser retargets the matching pointerup, and the click it\n   synthesises, at the CAPTOR).\n\n   COORDINATES ARE VIEWPORT-LOCAL THROUGHOUT (an event's `clientX/Y` minus the\n   viewport's own `getBoundingClientRect()` origin) — the frame `camera.x`/`y`\n   are defined in. The frame is measured once per gesture, not on every move: the\n   viewport is a fixed-size, non-scrolling box, so its own screen position only\n   changes from an ANCESTOR scrolling or the window resizing.\n   ========================================================================= */\n\n/** How far a pointer may travel and still resolve to a click on release — below\n    the jitter of a resting hand, above the travel of a deliberate press. */\nexport const CLICK_DISTANCE = 5;\n\n/** The most a single wheel tick may count for: a fast trackpad can report a\n    `deltaY` in the hundreds on one event, which would otherwise jump several zoom\n    levels in a single frame. */\nconst WHEEL_MAX_DELTA = 240;\n\n/** Zoom factor per wheel delta unit: exponential, so a notch feels the same at\n    every magnification (linear steps crawl when zoomed in and leap when out). */\nconst WHEEL_ZOOM_RATE = 1.0025;\n\nfunction distance(a: Point, b: Point): number {\n  return Math.hypot(a.x - b.x, a.y - b.y);\n}\n\nfunction midpoint(a: Point, b: Point): Point {\n  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };\n}\n\nexport interface ViewportClickEvent {\n  /** The element under the pointer at release, for the caller to hit-test. */\n  target: HTMLElement;\n}\n\nexport interface UseViewportGestureOptions {\n  /** The camera right now. Read at the start of a pan and on every resume. */\n  camera: CameraState;\n  /** Wheel, pan and pinch write the camera through this. Wheel and pinch use\n      the updater form: they compound on whatever is current. */\n  setCamera: (next: CameraState | ((current: CameraState) => CameraState)) => void;\n  /** Wheel and pinch never leave these. */\n  zoomBounds: ScaleBounds;\n  /** A new gesture is starting: stop any programmatic move in flight. */\n  onGestureStart?: () => void;\n  /** A press that released without travelling past `CLICK_DISTANCE`. */\n  onClick?: (event: ViewportClickEvent) => void;\n  /** The viewport's content-box size, on observe and on every change. */\n  onResize?: (size: Size) => void;\n  /** Nothing pans, zooms or clicks. */\n  disabled?: boolean;\n}\n\nexport interface UseViewportGestureResult {\n  /** A pointer is actively panning or pinching right now. */\n  panning: boolean;\n  /** Callback ref for the clipping viewport element. */\n  bindViewport: (node: HTMLElement | null) => (() => void) | undefined;\n}\n\ninterface Session {\n  pointers: Map<number, Point>;\n  mode: \"idle\" | \"pan\" | \"pinch\";\n  frame: { left: number; top: number } | null;\n  originPoint: Point | null;\n  originCamera: CameraState | null;\n  pinchDistance: number | null;\n  pinchMidpoint: Point | null;\n  travelled: number;\n  downTarget: HTMLElement | null;\n}\n\nexport function useViewportGesture(options: UseViewportGestureOptions): UseViewportGestureResult {\n  const [panning, setPanning] = useState(false);\n\n  /* Read fresh inside listeners that outlive a render. */\n  const live = useRef(options);\n  live.current = options;\n\n  const session = useRef<Session>({\n    pointers: new Map(),\n    mode: \"idle\",\n    frame: null,\n    originPoint: null,\n    originCamera: null,\n    pinchDistance: null,\n    pinchMidpoint: null,\n    travelled: 0,\n    downTarget: null,\n  });\n\n  const toLocal = useCallback((clientPoint: Point): Point => {\n    const frame = session.current.frame;\n    if (!frame) return clientPoint;\n    return { x: clientPoint.x - frame.left, y: clientPoint.y - frame.top };\n  }, []);\n\n  const bindViewport = useCallback(\n    (node: HTMLElement | null) => {\n      if (!node) return;\n\n      const resizeObserver = new ResizeObserver((entries) => {\n        const entry = entries[0];\n        if (!entry) return;\n        live.current.onResize?.({ width: entry.contentRect.width, height: entry.contentRect.height });\n      });\n      resizeObserver.observe(node);\n\n      const onWheel = (event: WheelEvent) => {\n        if (live.current.disabled) return;\n        event.preventDefault();\n        live.current.onGestureStart?.();\n        const rect = node.getBoundingClientRect();\n        const point = { x: event.clientX - rect.left, y: event.clientY - rect.top };\n        const delta = Math.max(-WHEEL_MAX_DELTA, Math.min(WHEEL_MAX_DELTA, event.deltaY));\n        const factor = Math.pow(WHEEL_ZOOM_RATE, -delta);\n        live.current.setCamera((current) => zoomAtPoint(current, point, factor, live.current.zoomBounds));\n      };\n      node.addEventListener(\"wheel\", onWheel, { passive: false });\n\n      /* A CANCELLED pointer is the browser taking the gesture back (a scroll, a\n         system gesture), not a person releasing: it ends the session but is\n         never a click. */\n      const endPointer = (pointerId: number, cancelled: boolean) => {\n        const s = session.current;\n        if (!s.pointers.has(pointerId)) return;\n        const wasPanning = s.mode === \"pan\";\n        const clickTarget = s.downTarget;\n        const travelled = s.travelled;\n        s.pointers.delete(pointerId);\n        if (node.hasPointerCapture(pointerId)) node.releasePointerCapture(pointerId);\n\n        if (s.pointers.size === 0) {\n          s.mode = \"idle\";\n          s.originPoint = null;\n          s.originCamera = null;\n          s.pinchDistance = null;\n          s.pinchMidpoint = null;\n          s.downTarget = null;\n          s.frame = null;\n          setPanning(false);\n          if (!cancelled && wasPanning && travelled < CLICK_DISTANCE && clickTarget && !live.current.disabled) {\n            live.current.onClick?.({ target: clickTarget });\n          }\n        } else {\n          /* Dropped from two pointers to one: resume as a fresh pan from\n             wherever the remaining finger is, never resolving to a click —\n             a pinch that ends with one finger still down was never \"a tap\". */\n          const [[, remaining]] = s.pointers;\n          s.mode = \"pan\";\n          s.originPoint = remaining;\n          s.originCamera = live.current.camera;\n          s.pinchDistance = null;\n          s.pinchMidpoint = null;\n          s.travelled = Infinity;\n        }\n      };\n\n      const onPointerMove = (event: PointerEvent) => {\n        const s = session.current;\n        if (!s.pointers.has(event.pointerId)) return;\n        const point = toLocal({ x: event.clientX, y: event.clientY });\n        s.pointers.set(event.pointerId, point);\n\n        if (s.mode === \"pan\" && s.originPoint && s.originCamera) {\n          const dx = point.x - s.originPoint.x;\n          const dy = point.y - s.originPoint.y;\n          s.travelled = Math.max(s.travelled, Math.hypot(dx, dy));\n          live.current.setCamera({ scale: s.originCamera.scale, x: s.originCamera.x + dx, y: s.originCamera.y + dy });\n        } else if (s.mode === \"pinch\") {\n          const points = [...s.pointers.values()];\n          if (points.length < 2) return;\n          const nextDistance = distance(points[0]!, points[1]!);\n          const nextMidpoint = midpoint(points[0]!, points[1]!);\n          const previousMidpoint = s.pinchMidpoint;\n          if (s.pinchDistance && s.pinchDistance > 0 && previousMidpoint) {\n            const factor = nextDistance / s.pinchDistance;\n            /* Zoom about where the midpoint WAS (that content point stays under\n               it), then carry the content along with the midpoint's own travel:\n               the spread zooms, the drift pans. */\n            live.current.setCamera((current) => {\n              const zoomed = zoomAtPoint(current, previousMidpoint, factor, live.current.zoomBounds);\n              return {\n                scale: zoomed.scale,\n                x: zoomed.x + (nextMidpoint.x - previousMidpoint.x),\n                y: zoomed.y + (nextMidpoint.y - previousMidpoint.y),\n              };\n            });\n          }\n          s.pinchDistance = nextDistance;\n          s.pinchMidpoint = nextMidpoint;\n          s.travelled = Infinity;\n        }\n      };\n\n      const onPointerUp = (event: PointerEvent) => endPointer(event.pointerId, false);\n      const onPointerCancel = (event: PointerEvent) => endPointer(event.pointerId, true);\n\n      const onPointerDown = (event: PointerEvent) => {\n        if (live.current.disabled) return;\n        if (event.pointerType === \"mouse\" && event.button !== 0) return;\n        const target = event.target as HTMLElement | null;\n        if (isInteractiveTarget(target)) return;\n\n        live.current.onGestureStart?.();\n        const s = session.current;\n        if (s.pointers.size === 0) {\n          const rect = node.getBoundingClientRect();\n          s.frame = { left: rect.left, top: rect.top };\n        }\n        const point = toLocal({ x: event.clientX, y: event.clientY });\n        node.setPointerCapture(event.pointerId);\n        s.pointers.set(event.pointerId, point);\n\n        if (s.pointers.size === 1) {\n          s.mode = \"pan\";\n          s.originPoint = point;\n          s.originCamera = live.current.camera;\n          s.travelled = 0;\n          s.downTarget = target;\n          setPanning(true);\n        } else if (s.pointers.size === 2) {\n          s.mode = \"pinch\";\n          const points = [...s.pointers.values()];\n          s.pinchDistance = distance(points[0]!, points[1]!);\n          s.pinchMidpoint = midpoint(points[0]!, points[1]!);\n          s.travelled = Infinity;\n        }\n      };\n      node.addEventListener(\"pointerdown\", onPointerDown);\n      node.addEventListener(\"pointermove\", onPointerMove);\n      node.addEventListener(\"pointerup\", onPointerUp);\n      node.addEventListener(\"pointercancel\", onPointerCancel);\n\n      return () => {\n        resizeObserver.disconnect();\n        node.removeEventListener(\"wheel\", onWheel);\n        node.removeEventListener(\"pointerdown\", onPointerDown);\n        node.removeEventListener(\"pointermove\", onPointerMove);\n        node.removeEventListener(\"pointerup\", onPointerUp);\n        node.removeEventListener(\"pointercancel\", onPointerCancel);\n      };\n    },\n    [toLocal],\n  );\n\n  return { panning, bindViewport };\n}\n"],"names":["CLICK_DISTANCE","WHEEL_MAX_DELTA","WHEEL_ZOOM_RATE","distance","a","b","midpoint","useViewportGesture","options","panning","setPanning","useState","live","useRef","session","toLocal","useCallback","clientPoint","frame","bindViewport","node","resizeObserver","entries","entry","onWheel","event","rect","point","delta","factor","current","zoomAtPoint","endPointer","pointerId","cancelled","s","wasPanning","clickTarget","travelled","remaining","onPointerMove","dx","dy","points","nextDistance","nextMidpoint","previousMidpoint","zoomed","onPointerUp","onPointerCancel","onPointerDown","target","isInteractiveTarget"],"mappings":"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"}