first

packages/graph-engine/test/sigma-coordinates.test.ts

@@ -0,0 +1,50 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { GRAPH_WORLD_BOUNDS } from "../src/render/geometry";
+import { sigmaScreenPointToWorldPoint, sigmaWorldPointToScreenPoint } from "../src/render/sigma-coordinates";
+import type { SigmaGlobalSigmaLike } from "../src/render/sigma-global-types";
+
+type ProjectionOptions = Parameters<typeof sigmaWorldPointToScreenPoint>[2];
+
+const options = {
+  viewportSize: { width: 800, height: 600 },
+  adapterData: { renderable: { worldBounds: GRAPH_WORLD_BOUNDS } }
+} as unknown as ProjectionOptions;
+
+function sigmaWith(overrides: Partial<SigmaGlobalSigmaLike>): SigmaGlobalSigmaLike {
+  return overrides as SigmaGlobalSigmaLike;
+}
+
+describe("sigma coordinate transforms", () => {
+  it("prefers sigma.graphToViewport for world to screen", () => {
+    const sigma = sigmaWith({ graphToViewport: (p) => ({ x: p.x + 10, y: p.y + 20 }) });
+    assert.deepEqual(sigmaWorldPointToScreenPoint(sigma, { x: 1, y: 2 }, options), { x: 11, y: 22 });
+  });
+
+  it("prefers sigma.viewportToGraph for screen to world", () => {
+    const sigma = sigmaWith({ viewportToGraph: (p) => ({ x: p.x - 10, y: p.y - 20 }) });
+    assert.deepEqual(sigmaScreenPointToWorldPoint(sigma, { x: 11, y: 22 }, options), { x: 1, y: 2 });
+  });
+
+  it("round-trips world -> screen -> world through invertible projection", () => {
+    const sigma = sigmaWith({
+      graphToViewport: (p) => ({ x: p.x * 2, y: p.y * 2 }),
+      viewportToGraph: (p) => ({ x: p.x / 2, y: p.y / 2 })
+    });
+    const world = { x: 3, y: 7 };
+    const screen = sigmaWorldPointToScreenPoint(sigma, world, options);
+    assert.deepEqual(sigmaScreenPointToWorldPoint(sigma, screen, options), world);
+  });
+
+  it("falls back to world-bounds math when sigma has no projection", () => {
+    const screen = sigmaWorldPointToScreenPoint(sigmaWith({}), { x: 0, y: 0 }, options);
+    assert.ok(Number.isFinite(screen.x) && Number.isFinite(screen.y));
+  });
+
+  it("falls back when the sigma projection returns non-finite values", () => {
+    const sigma = sigmaWith({ graphToViewport: () => ({ x: Number.NaN, y: Number.NaN }) });
+    const screen = sigmaWorldPointToScreenPoint(sigma, { x: 0, y: 0 }, options);
+    assert.ok(Number.isFinite(screen.x) && Number.isFinite(screen.y));
+  });
+});