@cocorof/graphier 1.4.0 → 1.4.2

package/README.md

@@ -39,12 +39,14 @@ const ref = useRef<NetworkGraph3DRef>(null);
 <GraphMinimap graphRef={ref} width={200} height={140} />
 ```
 
-- `layout.dimensions: 2` — simulation runs in 2D (z locked to 0); camera locks to pan/zoom (drag pans, wheel/pinch zooms, rotation off).
+- `layout.dimensions: 2` — flat Obsidian-style plane: simulation runs in 2D (z locked to 0). Left-drag pans, right-drag tilts/orbits the world, wheel/pinch zooms, arrows/WASD pan and z/x zoom (v1.4.1).
+- `enableNodeDrag={false}` — left-drag always reaches the camera even over nodes; essential for dense graphs (v1.4.1).
 - `layout.clusterBy: "type" | "group"` + `clusterStrength` — pulls same-key nodes toward a shared centroid so categories form visible clusters.
 - `linkVisibility={(link) => bool}` — reheat-free per-edge filter (e.g. hide a link type).
 - `visibleNodeIds` — client-side filter; hidden nodes/edges/labels vanish via per-instance scale + collapsed segments. Positions are preserved: toggling filters never reheats the simulation.
 - `hoverHighlight` / `hoverHighlightHops` — Obsidian-style neighborhood emphasis on hover (selection wins while active).
 - `theme="paper"` — light background preset; edge blending switches to normal automatically (additive lines vanish on white) and highlight/dim directions invert.
+- `renderer.navigation` — remap pointer/keyboard navigation per consumer, e.g. `{ leftButton: "pan", rightButton: "rotate", keyboard: "pan" }` for pan-first 3D graphs (v1.4.2).
 - `GraphMinimap` — 2D-canvas overview (no second WebGL context): draws all visible nodes + the camera viewport rectangle, click/drag to pan. Powered by `ref.getGraphSnapshot()` / `ref.getViewportRect()` / `ref.panTo(x, y)`.
 
 ## Install

package/dist/index.cjs

@@ -2049,6 +2049,45 @@ const _right = new THREE__namespace.Vector3();
 const _q = new THREE__namespace.Quaternion();
 const _dir = new THREE__namespace.Vector3();
 const _worldUp = new THREE__namespace.Vector3(0, 1, 0);
+const PAN_SPEED = 0.02;
+const PAN_ZOOM_FACTOR = 0.02;
+function createPanUpdate(camera, controls, keys) {
+  const _panRight = new THREE__namespace.Vector3();
+  const _panUp = new THREE__namespace.Vector3();
+  const _panOffset = new THREE__namespace.Vector3();
+  return function update() {
+    let dx = 0;
+    let dy = 0;
+    if (keys["ArrowLeft"] || keys["a"] || keys["A"]) dx -= 1;
+    if (keys["ArrowRight"] || keys["d"] || keys["D"]) dx += 1;
+    if (keys["ArrowUp"] || keys["w"] || keys["W"]) dy += 1;
+    if (keys["ArrowDown"] || keys["s"] || keys["S"]) dy -= 1;
+    const zoomIn = keys["z"] || keys["Z"] || keys["+"] || keys["="];
+    const zoomOut = keys["x"] || keys["X"] || keys["-"] || keys["_"];
+    if (!dx && !dy && !zoomIn && !zoomOut) return false;
+    const target = controls.target;
+    const dist = camera.position.distanceTo(target);
+    if (dx || dy) {
+      const step = Math.max(dist, 50) * PAN_SPEED;
+      _panRight.setFromMatrixColumn(camera.matrix, 0);
+      _panUp.setFromMatrixColumn(camera.matrix, 1);
+      _panOffset.set(0, 0, 0).addScaledVector(_panRight, dx * step).addScaledVector(_panUp, dy * step);
+      camera.position.add(_panOffset);
+      target.add(_panOffset);
+    }
+    if (zoomIn || zoomOut) {
+      const factor = zoomIn ? -PAN_ZOOM_FACTOR : PAN_ZOOM_FACTOR;
+      _panOffset.copy(camera.position).sub(target);
+      const newLen = Math.max(
+        controls.minDistance,
+        Math.min(controls.maxDistance, _panOffset.length() * (1 + factor))
+      );
+      _panOffset.setLength(newLen);
+      camera.position.copy(target).add(_panOffset);
+    }
+    return true;
+  };
+}
 function createOrbitUpdate(camera, controls, keys) {
   return function update() {
     let zoom = 0;
@@ -2148,8 +2187,13 @@ function setupKeyboardControls(camera, controls, container, mode = "fly", flySpe
   container.addEventListener("keyup", onKeyUp);
   container.addEventListener("blur", onBlur);
   let enabled = true;
-  const innerUpdate = mode === "fly" ? createFlyUpdate(camera, controls, keys, state) : createOrbitUpdate(camera, controls, keys);
-  const updateFn = () => enabled ? innerUpdate() : false;
+  let currentMode = mode;
+  const updaters = {
+    fly: createFlyUpdate(camera, controls, keys, state),
+    orbit: createOrbitUpdate(camera, controls, keys),
+    pan: createPanUpdate(camera, controls, keys)
+  };
+  const updateFn = () => enabled ? updaters[currentMode]() : false;
   function cleanup() {
     container.removeEventListener("keydown", onKeyDown2);
     container.removeEventListener("keyup", onKeyUp);
@@ -2162,7 +2206,11 @@ function setupKeyboardControls(camera, controls, container, mode = "fly", flySpe
     enabled = on;
     if (!on) for (const k of Object.keys(keys)) keys[k] = false;
   }
-  return { update: updateFn, cleanup, setFlySpeed, setEnabled };
+  function setMode(m2) {
+    currentMode = m2;
+    for (const k of Object.keys(keys)) keys[k] = false;
+  }
+  return { update: updateFn, cleanup, setFlySpeed, setEnabled, setMode };
 }
 function createScene(container, backgroundColor, style, rendererConfig) {
   const scene = new THREE__namespace.Scene();
@@ -2202,7 +2250,10 @@ function createScene(container, backgroundColor, style, rendererConfig) {
   const cameraMode = (rendererConfig == null ? void 0 : rendererConfig.cameraMode) ?? "fly";
   const keyboard = setupKeyboardControls(camera, controls, container, cameraMode, style.flySpeed ?? 1);
   controls.enableZoom = false;
-  const flags = { is2D: false };
+  const flags = {
+    is2D: false,
+    keyboardMode3D: cameraMode
+  };
   const _wheelDir = new THREE__namespace.Vector3();
   const onWheel = (e) => {
     if (flags.is2D) return;
@@ -2233,33 +2284,38 @@ function createScene(container, backgroundColor, style, rendererConfig) {
     flags
   };
 }
-function applyCameraMode2D(state, is2D) {
+const MOUSE_ACTION = {
+  rotate: THREE__namespace.MOUSE.ROTATE,
+  pan: THREE__namespace.MOUSE.PAN
+};
+function applyNavigationMode(state, is2D, nav) {
   const { controls, camera, keyboard } = state;
   state.flags.is2D = is2D;
-  controls.enableRotate = !is2D;
+  const left = (nav == null ? void 0 : nav.leftButton) ?? (is2D ? "pan" : "rotate");
+  const right = (nav == null ? void 0 : nav.rightButton) ?? (is2D ? "rotate" : "pan");
+  controls.mouseButtons = {
+    LEFT: MOUSE_ACTION[left],
+    MIDDLE: THREE__namespace.MOUSE.DOLLY,
+    RIGHT: MOUSE_ACTION[right]
+  };
+  controls.enableRotate = left === "rotate" || right === "rotate";
+  controls.touches = left === "pan" ? { ONE: THREE__namespace.TOUCH.PAN, TWO: THREE__namespace.TOUCH.DOLLY_PAN } : { ONE: THREE__namespace.TOUCH.ROTATE, TWO: THREE__namespace.TOUCH.DOLLY_PAN };
   controls.enableZoom = is2D;
   controls.screenSpacePanning = is2D;
-  keyboard.setEnabled(!is2D);
+  const kb = (nav == null ? void 0 : nav.keyboard) ?? (is2D ? "pan" : state.flags.keyboardMode3D);
+  if (kb === "off") {
+    keyboard.setEnabled(false);
+  } else {
+    keyboard.setEnabled(true);
+    keyboard.setMode(kb);
+  }
   if (is2D) {
-    controls.mouseButtons = {
-      LEFT: THREE__namespace.MOUSE.PAN,
-      MIDDLE: THREE__namespace.MOUSE.DOLLY,
-      RIGHT: THREE__namespace.MOUSE.PAN
-    };
-    controls.touches = { ONE: THREE__namespace.TOUCH.PAN, TWO: THREE__namespace.TOUCH.DOLLY_PAN };
     const t = controls.target;
     const dist = Math.max(camera.position.distanceTo(t), 50);
     t.z = 0;
     camera.up.set(0, 1, 0);
     camera.position.set(t.x, t.y, dist);
     camera.lookAt(t);
-  } else {
-    controls.mouseButtons = {
-      LEFT: THREE__namespace.MOUSE.ROTATE,
-      MIDDLE: THREE__namespace.MOUSE.DOLLY,
-      RIGHT: THREE__namespace.MOUSE.PAN
-    };
-    controls.touches = { ONE: THREE__namespace.TOUCH.ROTATE, TWO: THREE__namespace.TOUCH.DOLLY_PAN };
   }
   controls.update();
 }
@@ -2622,11 +2678,12 @@ function setupInteraction(canvas, camera, controls, getNodesMesh, getNodes, call
   const dragPlane = new THREE__namespace.Plane();
   const dragIntersect = new THREE__namespace.Vector3();
   function onPointerDown2(e) {
+    var _a;
     mouseDownPos = { x: e.clientX, y: e.clientY };
     if (container && document.activeElement !== container) {
       container.focus({ preventScroll: true });
     }
-    if (callbacks.onNodeDrag) {
+    if (callbacks.onNodeDrag && (((_a = options == null ? void 0 : options.getNodeDragEnabled) == null ? void 0 : _a.call(options)) ?? true)) {
       const nodesMesh = getNodesMesh();
       if (nodesMesh) {
         const rect = canvas.getBoundingClientRect();
@@ -2938,6 +2995,7 @@ function NetworkGraph3DInner(props, ref) {
     nodeValueAccessor,
     visibleNodeIds,
     linkVisibility,
+    enableNodeDrag = true,
     clickToFocus = true,
     hoverHighlight = false,
     hoverHighlightHops = 1
@@ -2978,6 +3036,7 @@ function NetworkGraph3DInner(props, ref) {
   const labelFormatterRef = react.useRef(labelFormatter);
   const highlightSetRef = react.useRef(null);
   const clickToFocusRef = react.useRef(clickToFocus);
+  const enableNodeDragRef = react.useRef(enableNodeDrag);
   const hoverHighlightRef = react.useRef(hoverHighlight);
   const hoverHighlightHopsRef = react.useRef(hoverHighlightHops);
   const adjacencyMapRef = react.useRef(/* @__PURE__ */ new Map());
@@ -2999,6 +3058,7 @@ function NetworkGraph3DInner(props, ref) {
   selectedNodeIdRef.current = selectedNodeId;
   labelFormatterRef.current = labelFormatter;
   clickToFocusRef.current = clickToFocus;
+  enableNodeDragRef.current = enableNodeDrag;
   hoverHighlightRef.current = hoverHighlight;
   hoverHighlightHopsRef.current = hoverHighlightHops;
   const is2D = (layoutProp == null ? void 0 : layoutProp.dimensions) === 2;
@@ -3181,7 +3241,8 @@ function NetworkGraph3DInner(props, ref) {
       },
       {
         getClickToFocus: () => clickToFocusRef.current,
-        getIs2D: () => is2DRef.current
+        getIs2D: () => is2DRef.current,
+        getNodeDragEnabled: () => enableNodeDragRef.current
       }
     );
     return () => {
@@ -3461,10 +3522,11 @@ function NetworkGraph3DInner(props, ref) {
       );
     }
   }, [visibleSet, linkVisibility, mergedData]);
+  const navKey = JSON.stringify((rendererProp == null ? void 0 : rendererProp.navigation) ?? null);
   react.useEffect(() => {
     const s = sceneRef.current;
-    if (s) applyCameraMode2D(s, is2D);
-  }, [is2D]);
+    if (s) applyNavigationMode(s, is2D, rendererProp == null ? void 0 : rendererProp.navigation);
+  }, [is2D, navKey]);
   react.useEffect(() => {
     const gObj = graphObjRef.current;
     const sceneState = sceneRef.current;
@@ -3716,11 +3778,12 @@ function NetworkGraph3DInner(props, ref) {
       const s = sceneRef.current;
       if (!s) return null;
       const cam = s.camera;
-      const dist = Math.abs(cam.position.z);
+      const t = s.controls.target;
+      const dist = Math.max(cam.position.distanceTo(t), 1);
       const halfH = Math.tan(cam.fov * Math.PI / 360) * dist;
       return {
-        cx: cam.position.x,
-        cy: cam.position.y,
+        cx: t.x,
+        cy: t.y,
         halfW: halfH * cam.aspect,
         halfH
       };