@neta-art/cohub 8.24.0 → 9.0.0

package/dist/board/core/connections.js

@@ -1,455 +0,0 @@
-import { degToRad, frameRect, rectCenter, rotatePointAround, worldPoint } from "../geometry.js";
-//#region src/board/core/connections.ts
-/**
-* Connection geometry — pure resolution of a relation into a drawable path.
-*
-* A `BoardConnection` stores no coordinates: it names two nodes, how it attaches
-* to each, and how the line should travel. Everything spatial is derived here from
-* the live node frames, which is what makes a connection incapable of going stale.
-* No PixiJS, no DOM, no editor state — so the editor, the far-LOD batch, the
-* headless exporter and the tests all resolve a connection the same way.
-*
-* The `auto` anchor is the interesting part: rather than storing a side, it picks
-* one per resolve from the relative position of the two frames, so a connection
-* keeps its shortest sensible route through any layout change. A stored side is
-* honoured exactly, because a user who pinned one is stating intent that geometry
-* must not override.
-*/
-/**
-* Gap between a node's edge and the line's endpoint, in world units.
-*
-* A connection that touches the border reads as part of the node; a small gap
-* makes the relation legible as its own object and keeps an arrowhead from being
-* swallowed by the card it points at.
-*/
-const CONNECTION_ENDPOINT_GAP = 4;
-/** Perpendicular fraction of the span used for an `orthogonal` elbow. */
-const ORTHOGONAL_SNAP = .5;
-const SIDE_NORMALS = {
-	top: {
-		x: 0,
-		y: -1
-	},
-	right: {
-		x: 1,
-		y: 0
-	},
-	bottom: {
-		x: 0,
-		y: 1
-	},
-	left: {
-		x: -1,
-		y: 0
-	}
-};
-/** Normalized position of a point on a frame side, as (nx, ny). */
-function sideAnchorPoint(side, offset) {
-	switch (side) {
-		case "top": return {
-			nx: offset,
-			ny: 0
-		};
-		case "bottom": return {
-			nx: offset,
-			ny: 1
-		};
-		case "left": return {
-			nx: 0,
-			ny: offset
-		};
-		default: return {
-			nx: 1,
-			ny: offset
-		};
-	}
-}
-/** Denormalize a (nx, ny) anchor to a world point on a possibly rotated frame. */
-function anchorToWorld(frame, nx, ny) {
-	const unrotated = worldPoint(frame.x + nx * frame.width, frame.y + ny * frame.height);
-	if (!frame.rotation) return unrotated;
-	return rotatePointAround(unrotated, rectCenter(frameRect(frame)), degToRad(frame.rotation));
-}
-/** Normalize a world point into a (nx, ny) anchor on a frame, clamped to it. */
-function worldToAnchor(frame, point) {
-	const local = frame.rotation ? rotatePointAround(point, rectCenter(frameRect(frame)), -degToRad(frame.rotation)) : point;
-	return {
-		nx: clamp01((local.x - frame.x) / Math.max(frame.width, 1e-4)),
-		ny: clamp01((local.y - frame.y) / Math.max(frame.height, 1e-4))
-	};
-}
-function clamp01(value) {
-	return Math.min(1, Math.max(0, value));
-}
-/**
-* Choose the side an `auto` anchor should use.
-*
-* The dominant axis of the center-to-center vector wins, weighted by the frame's
-* own proportions so a wide card prefers its long edges. Comparing raw dx/dy
-* instead would make a wide node attach to its short side for most angles, which
-* is the classic "line leaves from the corner" artifact.
-*/
-function autoConnectionSide(from, to) {
-	const a = rectCenter(frameRect(from));
-	const b = rectCenter(frameRect(to));
-	const dx = b.x - a.x;
-	const dy = b.y - a.y;
-	if (Math.abs(dx) / Math.max(from.width / 2, 1e-4) >= Math.abs(dy) / Math.max(from.height / 2, 1e-4)) return dx >= 0 ? "right" : "left";
-	return dy >= 0 ? "bottom" : "top";
-}
-/**
-* World point of an anchor on a frame, ignoring the gap and the facing node.
-*
-* For a live drag the other end is the pointer, not a node, so `auto` has no
-* frame to face: it resolves to the node's centre, which is the only honest
-* answer while the relation has nowhere to point yet.
-*/
-function anchorPointOnFrame(anchor, frame) {
-	if (anchor.kind === "fixed") return anchorToWorld(frame, anchor.nx, anchor.ny);
-	if (anchor.kind === "side") {
-		const point = sideAnchorPoint(anchor.side, anchor.offset);
-		return anchorToWorld(frame, point.nx, point.ny);
-	}
-	return anchorToWorld(frame, .5, .5);
-}
-/** Resolve one endpoint of a connection against its node frame. */
-function resolveEndpoint(anchor, frame, otherFrame, gap) {
-	let side;
-	let nx;
-	let ny;
-	if (anchor.kind === "fixed") {
-		nx = anchor.nx;
-		ny = anchor.ny;
-		side = nearestSide(nx, ny);
-	} else if (anchor.kind === "side") {
-		side = anchor.side;
-		const point = sideAnchorPoint(side, anchor.offset);
-		nx = point.nx;
-		ny = point.ny;
-	} else {
-		side = autoConnectionSide(frame, otherFrame);
-		const point = sideAnchorPoint(side, .5);
-		nx = point.nx;
-		ny = point.ny;
-	}
-	const base = anchorToWorld(frame, nx, ny);
-	const local = SIDE_NORMALS[side];
-	const normal = frame.rotation ? rotateVector(local, degToRad(frame.rotation)) : worldPoint(local.x, local.y);
-	return {
-		point: worldPoint(base.x + normal.x * gap, base.y + normal.y * gap),
-		normal,
-		side
-	};
-}
-function rotateVector(vector, angleRad) {
-	const cos = Math.cos(angleRad);
-	const sin = Math.sin(angleRad);
-	return worldPoint(vector.x * cos - vector.y * sin, vector.x * sin + vector.y * cos);
-}
-function nearestSide(nx, ny) {
-	const distances = [
-		["left", nx],
-		["right", 1 - nx],
-		["top", ny],
-		["bottom", 1 - ny]
-	];
-	distances.sort((a, b) => a[1] - b[1]);
-	return distances[0]?.[0] ?? "right";
-}
-/**
-* A self-loop's path: a lobe leaving and re-entering the same node.
-*
-* Handled separately because every straight/curve formula degenerates when both
-* endpoints coincide, and a self-relation is meaningful enough (a node that
-* depends on itself, a retry edge) that dropping it would lose real data.
-*/
-function selfLoopPath(frame, gap) {
-	const rect = frameRect(frame);
-	const size = Math.max(Math.min(rect.width, rect.height) * .45, 24);
-	const right = rect.x + rect.width + gap;
-	const top = rect.y - gap;
-	const midY = rect.y + rect.height * .3;
-	const midX = rect.x + rect.width * .7;
-	return [
-		worldPoint(midX, top),
-		worldPoint(midX, top - size),
-		worldPoint(right + size, top - size),
-		worldPoint(right + size, midY),
-		worldPoint(right, midY)
-	];
-}
-function quadraticPoint(start, control, end, t) {
-	const mt = 1 - t;
-	return worldPoint(mt * mt * start.x + 2 * mt * t * control.x + t * t * end.x, mt * mt * start.y + 2 * mt * t * control.y + t * t * end.y);
-}
-/** Sample a quadratic curve into a polyline. */
-function sampleQuadratic(start, control, end, segments) {
-	const out = [];
-	for (let index = 0; index <= segments; index += 1) out.push(quadraticPoint(start, control, end, index / segments));
-	return out;
-}
-/**
-* Build an orthogonal elbow between two endpoints, leaving each along its normal.
-*
-* The turn happens on the axis each endpoint exits by, so the line never starts
-* parallel to the edge it is attached to (which would read as touching the node
-* rather than leaving it).
-*/
-function orthogonalPath(source, target) {
-	const horizontalStart = Math.abs(source.normal.x) > Math.abs(source.normal.y);
-	const horizontalEnd = Math.abs(target.normal.x) > Math.abs(target.normal.y);
-	const a = source.point;
-	const b = target.point;
-	if (horizontalStart && horizontalEnd) {
-		const midX = a.x + (b.x - a.x) * ORTHOGONAL_SNAP;
-		return [
-			a,
-			worldPoint(midX, a.y),
-			worldPoint(midX, b.y),
-			b
-		];
-	}
-	if (!horizontalStart && !horizontalEnd) {
-		const midY = a.y + (b.y - a.y) * ORTHOGONAL_SNAP;
-		return [
-			a,
-			worldPoint(a.x, midY),
-			worldPoint(b.x, midY),
-			b
-		];
-	}
-	return horizontalStart ? [
-		a,
-		worldPoint(b.x, a.y),
-		b
-	] : [
-		a,
-		worldPoint(a.x, b.y),
-		b
-	];
-}
-/** Curve samples per connection. Enough to read as smooth at typical zoom. */
-const CURVE_SEGMENTS = 20;
-/**
-* Resolve a connection into world-space geometry, or null if either node is gone.
-*
-* A null result means "not drawable right now", never "delete this": the caller
-* may be looking at a viewport-culled read where an endpoint simply was not
-* fetched.
-*/
-function resolveConnection(connection, getFrame, options = {}) {
-	const sourceFrame = getFrame(connection.source.itemId);
-	const targetFrame = getFrame(connection.target.itemId);
-	if (!sourceFrame || !targetFrame) return null;
-	const gap = options.gap ?? 4;
-	if (connection.source.itemId === connection.target.itemId) {
-		const path = selfLoopPath(sourceFrame, gap);
-		const first = path[0];
-		const last = path[path.length - 1];
-		return {
-			source: {
-				point: first,
-				normal: worldPoint(0, -1),
-				side: "top"
-			},
-			target: {
-				point: last,
-				normal: worldPoint(1, 0),
-				side: "right"
-			},
-			path,
-			mid: path[Math.floor(path.length / 2)] ?? first
-		};
-	}
-	const source = resolveEndpoint(connection.source.anchor, sourceFrame, targetFrame, gap);
-	const target = resolveEndpoint(connection.target.anchor, targetFrame, sourceFrame, gap);
-	const waypoints = connection.routing.waypoints;
-	let path;
-	if (waypoints.length > 0) path = [
-		source.point,
-		...waypoints.map((point) => worldPoint(point.x, point.y)),
-		target.point
-	];
-	else if (connection.routing.kind === "orthogonal") path = orthogonalPath(source, target);
-	else if (connection.routing.kind === "straight" && !connection.routing.bend) path = [source.point, target.point];
-	else path = sampleQuadratic(source.point, curveControl(source, target, connection.routing.bend), target.point, CURVE_SEGMENTS);
-	return {
-		source,
-		target,
-		path,
-		mid: pathMidpoint(path)
-	};
-}
-/**
-* Control point for a curved connection.
-*
-* With no explicit bend the bow is derived from the endpoint normals, so the line
-* leaves each node perpendicular to its edge and reads as attached rather than
-* merely adjacent. An explicit bend is a user-set bow and takes over entirely.
-*/
-function curveControl(source, target, bend) {
-	const mid = worldPoint((source.point.x + target.point.x) / 2, (source.point.y + target.point.y) / 2);
-	const dx = target.point.x - source.point.x;
-	const dy = target.point.y - source.point.y;
-	const length = Math.hypot(dx, dy) || 1;
-	if (bend) {
-		const offset = bend * length;
-		return worldPoint(mid.x + -dy / length * offset, mid.y + dx / length * offset);
-	}
-	const nx = (source.normal.x + target.normal.x) / 2;
-	const ny = (source.normal.y + target.normal.y) / 2;
-	const magnitude = Math.hypot(nx, ny);
-	if (magnitude < 1e-4) return mid;
-	const strength = Math.min(length * .18, 96);
-	return worldPoint(mid.x + nx / magnitude * strength, mid.y + ny / magnitude * strength);
-}
-/** Midpoint by arc length, so a label sits visually centered on the line. */
-function pathMidpoint(path) {
-	if (path.length === 0) return worldPoint(0, 0);
-	if (path.length === 1) return path[0];
-	let total = 0;
-	for (let index = 0; index < path.length - 1; index += 1) {
-		const from = path[index];
-		const to = path[index + 1];
-		total += Math.hypot(to.x - from.x, to.y - from.y);
-	}
-	let travelled = 0;
-	const half = total / 2;
-	for (let index = 0; index < path.length - 1; index += 1) {
-		const from = path[index];
-		const to = path[index + 1];
-		const segment = Math.hypot(to.x - from.x, to.y - from.y);
-		if (travelled + segment >= half) {
-			const t = segment > 0 ? (half - travelled) / segment : 0;
-			return worldPoint(from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t);
-		}
-		travelled += segment;
-	}
-	return path[path.length - 1];
-}
-/** World bounds of a resolved connection, padded for its stroke. */
-function connectionBounds(resolved, strokeSize) {
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of resolved.path) {
-		minX = Math.min(minX, point.x);
-		minY = Math.min(minY, point.y);
-		maxX = Math.max(maxX, point.x);
-		maxY = Math.max(maxY, point.y);
-	}
-	const pad = Math.max(8, strokeSize * 2);
-	return {
-		x: minX - pad,
-		y: minY - pad,
-		width: Math.max(1, maxX - minX + pad * 2),
-		height: Math.max(1, maxY - minY + pad * 2)
-	};
-}
-function createConnectionGeometryCache() {
-	const entries = /* @__PURE__ */ new Map();
-	return {
-		get(connection, getFrame) {
-			const source = getFrame(connection.source.itemId);
-			const target = getFrame(connection.target.itemId);
-			if (!source || !target) {
-				entries.delete(connection.id);
-				return null;
-			}
-			const entry = entries.get(connection.id);
-			if (entry && entry.geometry.connection === connection && entry.source === source && entry.target === target) return entry.geometry;
-			const resolved = resolveConnection(connection, getFrame);
-			if (!resolved) {
-				entries.delete(connection.id);
-				return null;
-			}
-			const geometry = {
-				connection,
-				resolved,
-				bounds: connectionBounds(resolved, connection.style.size)
-			};
-			entries.set(connection.id, {
-				source,
-				target,
-				geometry
-			});
-			return geometry;
-		},
-		peek: (connectionId) => entries.get(connectionId)?.geometry ?? null,
-		retain(connections) {
-			if (entries.size === 0) return;
-			const live = new Set(connections.map((connection) => connection.id));
-			for (const id of entries.keys()) if (!live.has(id)) entries.delete(id);
-		},
-		clear: () => entries.clear()
-	};
-}
-/** Distance from a world point to a resolved connection's path. */
-function distanceToConnection(resolved, point) {
-	let min = Number.POSITIVE_INFINITY;
-	for (let index = 0; index < resolved.path.length - 1; index += 1) {
-		const from = resolved.path[index];
-		const to = resolved.path[index + 1];
-		if (!from || !to) continue;
-		const distance = segmentDistance(point, from, to);
-		if (distance < min) min = distance;
-	}
-	return min;
-}
-function segmentDistance(p, a, b) {
-	const dx = b.x - a.x;
-	const dy = b.y - a.y;
-	const lengthSq = dx * dx + dy * dy;
-	if (lengthSq === 0) return Math.hypot(p.x - a.x, p.y - a.y);
-	const t = Math.min(1, Math.max(0, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSq));
-	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
-}
-/** Hit test a connection with a zoom-independent screen-space tolerance. */
-function connectionHitTest(resolved, point, strokeSize) {
-	return distanceToConnection(resolved, point) <= connectionHitRadius(strokeSize);
-}
-function connectionHitRadius(strokeSize) {
-	return Math.max(8, strokeSize * 2.5);
-}
-/** Whether the connection draws an arrowhead at its source / target. */
-function connectionArrowheads(connection) {
-	switch (connection.direction) {
-		case "forward": return {
-			atSource: false,
-			atTarget: true
-		};
-		case "backward": return {
-			atSource: true,
-			atTarget: false
-		};
-		case "both": return {
-			atSource: true,
-			atTarget: true
-		};
-		default: return {
-			atSource: false,
-			atTarget: false
-		};
-	}
-}
-const NO_CONNECTIONS = [];
-function createConnectionIndex(connections) {
-	const byNode = /* @__PURE__ */ new Map();
-	const byId = /* @__PURE__ */ new Map();
-	for (const connection of connections) {
-		byId.set(connection.id, connection);
-		for (const nodeId of /* @__PURE__ */ new Set([connection.source.itemId, connection.target.itemId])) {
-			const list = byNode.get(nodeId);
-			if (list) list.push(connection.id);
-			else byNode.set(nodeId, [connection.id]);
-		}
-	}
-	return {
-		byNode: (nodeId) => byNode.get(nodeId) ?? NO_CONNECTIONS,
-		get: (connectionId) => byId.get(connectionId),
-		all: connections
-	};
-}
-//#endregion
-export { CONNECTION_ENDPOINT_GAP, anchorPointOnFrame, anchorToWorld, autoConnectionSide, connectionArrowheads, connectionBounds, connectionHitRadius, connectionHitTest, createConnectionGeometryCache, createConnectionIndex, distanceToConnection, pathMidpoint, resolveConnection, worldToAnchor };

package/dist/board/mutation.d.ts

@@ -1,6 +0,0 @@
-import { BoardAppearance } from "../protocol/dist/board-document.js";
-//#region src/board/mutation.d.ts
-/** Merge Board appearance fields while preserving nested background/grid defaults. */
-declare function patchBoardAppearance(current: BoardAppearance, patch: Partial<BoardAppearance>): BoardAppearance;
-//#endregion
-export { patchBoardAppearance };

package/dist/board/mutation.js

@@ -1,14 +0,0 @@
-import { BoardAppearanceSchema } from "../protocol/dist/board-document.js";
-//#region src/board/mutation.ts
-/** Merge Board appearance fields while preserving nested background/grid defaults. */
-function patchBoardAppearance(current, patch) {
-	return BoardAppearanceSchema.parse({
-		...current,
-		...patch,
-		background: patch.background ?? current.background,
-		grid: patch.grid ?? current.grid,
-		...Object.hasOwn(patch, "motion") ? { motion: patch.motion } : current.motion ? { motion: current.motion } : {}
-	});
-}
-//#endregion
-export { patchBoardAppearance };

package/dist/board/render/connection-layer.d.ts

@@ -1,53 +0,0 @@
-import { BoardConnection } from "../../protocol/dist/board-connection.js";
-import { BoardFrame } from "../../protocol/dist/board-document.js";
-import { Rect } from "../geometry.js";
-import { FrameLookup, ResolvedConnection } from "../core/connections.js";
-import { BoardShapeColors } from "../core/palette.js";
-import { Container } from "pixi.js";
-//#region src/board/render/connection-layer.d.ts
-type ConnectionRenderInput = {
-  connections: readonly BoardConnection[];
-  getFrame: FrameLookup;
-  colors: BoardShapeColors;
-  colorScheme: "dark" | "light";
-  zoom: number;
-  /** Connections drawn in their selected state. */
-  selectedIds?: ReadonlySet<string>;
-  /** Connection under the pointer, if any. */
-  hoveredId?: string | null;
-  /**
-   * Ids to skip because the host is drawing them itself this frame (e.g. a live
-   * drag preview on the interaction overlay). Skipping avoids the doubled stroke
-   * of a preview drawn over its own committed geometry.
-   */
-  skipIds?: ReadonlySet<string>;
-  /** Cull and dash-clip rect; use `stableCullRect` so small pans keep the cache. */
-  cullRect?: Rect | null;
-  /** Nodes being manipulated; their relations are drawn on the live layer. */
-  liveNodeIds?: ReadonlySet<string>;
-};
-type ConnectionLayer = {
-  /** Draw the connection set; only changed layers re-tessellate. */
-  sync: (input: ConnectionRenderInput) => void;
-  /** Resolved geometry from the last sync, for hit testing and overlays. */
-  resolved: (connectionId: string) => ResolvedConnection | null;
-  /**
-   * The display objects this layer owns, so a host can place them in its own
-   * z-ordering scheme without the layer needing to know about it.
-   */
-  readonly children: readonly Container[];
-  destroy: () => void;
-};
-declare function createConnectionLayer(options: {
-  /** World-space container the layer attaches to. */
-  parent: Container;
-  /** zIndex applied to the layer's display objects once they exist. */
-  zIndex?: number;
-}): ConnectionLayer;
-/** Frame lookup over a plain item list, for hosts without an index. */
-declare function framesFromItems(items: readonly {
-  id: string;
-  frame: BoardFrame;
-}[]): FrameLookup;
-//#endregion
-export { ConnectionLayer, ConnectionRenderInput, createConnectionLayer, framesFromItems };