@neta-art/cohub 5.3.3 → 5.4.1

package/dist/board/codec.d.ts

@@ -1,3 +1,4 @@
+import { BoardConnectionRecord } from "../protocol/dist/board-connection.js";
 import { BoardManifest, BoardNodeInput, BoardNodeRecord, BoardRecord, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest } from "../protocol/dist/board.js";
 import "../protocol/dist/index.js";
 import { BoardAppearance, BoardDocument, BoardItem } from "../protocol/dist/board-document.js";
@@ -20,6 +21,7 @@ declare function boardNodeToItem(node: BoardNodeRecord): BoardItem;
 declare function boardBootstrapToDocument(input: {
   board: BoardRecord;
   nodes: BoardNodeRecord[];
+  connections?: BoardConnectionRecord[];
 }): BoardDocument;
 //#endregion
 export { BOARD_NODE_SOURCE, type BoardManifest, type BoardNodeRecord, type BoardRecord, DEFAULT_BOARD_APPEARANCE, ITEM_BASE_KEYS, InvalidBoardFileError, WireBackedBoardItem, boardBootstrapToDocument, boardNodeToItem, isBoardPath, isRecord, nodeInputFromRecord, parseBoardManifest, serializeBoardManifest, sourceForItem };

package/dist/board/codec.js

@@ -1,5 +1,5 @@
 import { BOARD_DOCUMENT_KIND, InvalidBoardFileError, isBoardPath, parseBoardManifest, serializeBoardManifest } from "../protocol/dist/board.js";
-import { BoardAppearanceSchema, BoardDocumentSchema, BoardFileSnapshotSchema, UNKNOWN_BOARD_ITEM_TYPE } from "../protocol/dist/board-document.js";
+import { BoardAppearanceSchema, BoardFileSnapshotSchema, UNKNOWN_BOARD_ITEM_TYPE, parseBoardDocument } from "../protocol/dist/board-document.js";
 import { TEXT_FONT_SIZE, clampBoardTextFontSize } from "./core/text-metrics.js";
 import "../protocol/dist/index.js";
 //#region src/board/codec.ts
@@ -72,6 +72,17 @@ function spaceFilePathFromNode(node) {
 	if (typeof node.refPath === "string" && node.refPath) return node.refPath;
 	return null;
 }
+/** Read a stored world point, defaulting to the origin when absent. */
+function pointFromData(value) {
+	if (isRecord(value) && typeof value.x === "number" && typeof value.y === "number") return {
+		x: value.x,
+		y: value.y
+	};
+	return {
+		x: 0,
+		y: 0
+	};
+}
 function boardNodeToItemValue(node) {
 	const frame = frameFromNode(node);
 	const style = styleFromNode(node);
@@ -112,16 +123,8 @@ function boardNodeToItemValue(node) {
 		case "arrow": return {
 			id: node.nodeId,
 			type: "arrow",
-			start: data.start ?? {
-				kind: "point",
-				x: 0,
-				y: 0
-			},
-			end: data.end ?? {
-				kind: "point",
-				x: 0,
-				y: 0
-			},
+			start: pointFromData(data.start),
+			end: pointFromData(data.end),
 			bend: typeof data.bend === "number" ? data.bend : 0,
 			color: typeof data.color === "string" ? data.color : "brand",
 			size: typeof data.size === "number" ? data.size : 2.5,
@@ -219,7 +222,8 @@ function boardNodeToItem(node) {
 }
 function boardBootstrapToDocument(input) {
 	const appearance = BoardAppearanceSchema.safeParse(input.board.metadata.appearance);
-	const document = BoardDocumentSchema.parse({
+	const connections = (input.connections ?? []).map(({ boardId: _boardId, revision: _revision, createdAt: _createdAt, updatedAt: _updatedAt, ...connection }) => connection);
+	const document = parseBoardDocument({
 		kind: BOARD_DOCUMENT_KIND,
 		version: 1,
 		appearance: appearance.success ? appearance.data : DEFAULT_BOARD_APPEARANCE,
@@ -228,7 +232,8 @@ function boardBootstrapToDocument(input) {
 			y: 0,
 			zoom: 1
 		},
-		items: input.nodes.map(boardNodeToItem)
+		items: input.nodes.map(boardNodeToItem),
+		connections
 	});
 	const sources = new Map(input.nodes.map((node) => [node.nodeId, nodeInputFromRecord(node)]));
 	return {

package/dist/board/core/arrow-geometry.d.ts

@@ -0,0 +1,23 @@
+import { BoardArrowItem, BoardFrame } from "../../protocol/dist/board-document.js";
+import { Rect, WorldPoint } from "../geometry.js";
+//#region src/board/core/arrow-geometry.d.ts
+type ResolvedArrow = {
+  start: WorldPoint;
+  end: WorldPoint;
+  /** Quadratic control point (already bent); the midpoint when bend is 0. */
+  control: WorldPoint;
+};
+/** Resolve an arrow's endpoints and its bent control point. */
+declare function resolveArrow(item: BoardArrowItem): ResolvedArrow;
+/** Sample an arrow's quadratic curve into world points. */
+declare function sampleArrow(resolved: ResolvedArrow, segments: number): WorldPoint[];
+/** World bounds of an arrow, padded for its stroke. */
+declare function arrowBounds(item: BoardArrowItem): Rect;
+/** The frame an arrow should carry, derived from its endpoints. */
+declare function arrowFrame(item: BoardArrowItem): BoardFrame;
+/** Distance from a world point to an arrow's curve (hit testing). */
+declare function distanceToArrow(item: BoardArrowItem, point: WorldPoint): number;
+/** Translate an arrow by a delta, keeping its frame consistent. */
+declare function translateArrow(item: BoardArrowItem, dx: number, dy: number): BoardArrowItem;
+//#endregion
+export { ResolvedArrow, arrowBounds, arrowFrame, distanceToArrow, resolveArrow, sampleArrow, translateArrow };

package/dist/board/core/arrow-geometry.js

@@ -0,0 +1,109 @@
+import { worldPoint } from "../geometry.js";
+//#region src/board/core/arrow-geometry.ts
+/**
+* Free-arrow geometry.
+*
+* An arrow is a standalone annotation stroke between two world points — it does
+* not relate nodes. Node relations are `BoardConnection`s, which resolve their
+* geometry from the nodes they join (see ./connections). Keeping the two apart is
+* what makes each one simple: an arrow owns absolute coordinates and needs no
+* lookup, while a connection owns no coordinates at all.
+*/
+/** Resolve an arrow's endpoints and its bent control point. */
+function resolveArrow(item) {
+	const start = worldPoint(item.start.x, item.start.y);
+	const end = worldPoint(item.end.x, item.end.y);
+	const mid = worldPoint((start.x + end.x) / 2, (start.y + end.y) / 2);
+	if (!item.bend) return {
+		start,
+		end,
+		control: mid
+	};
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	const length = Math.hypot(dx, dy) || 1;
+	const offset = item.bend * length;
+	return {
+		start,
+		end,
+		control: worldPoint(mid.x + -dy / length * offset, mid.y + dx / length * offset)
+	};
+}
+/** Sample an arrow's quadratic curve into world points. */
+function sampleArrow(resolved, segments) {
+	const { start, control, end } = resolved;
+	const out = [];
+	for (let index = 0; index <= segments; index += 1) {
+		const t = index / segments;
+		const mt = 1 - t;
+		out.push(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));
+	}
+	return out;
+}
+/** World bounds of an arrow, padded for its stroke. */
+function arrowBounds(item) {
+	const samples = sampleArrow(resolveArrow(item), 12);
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of samples) {
+		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, item.size * 2);
+	return {
+		x: minX - pad,
+		y: minY - pad,
+		width: Math.max(1, maxX - minX + pad * 2),
+		height: Math.max(1, maxY - minY + pad * 2)
+	};
+}
+/** The frame an arrow should carry, derived from its endpoints. */
+function arrowFrame(item) {
+	return {
+		...arrowBounds(item),
+		rotation: 0
+	};
+}
+/** Distance from a world point to an arrow's curve (hit testing). */
+function distanceToArrow(item, point) {
+	const samples = sampleArrow(resolveArrow(item), 16);
+	let min = Number.POSITIVE_INFINITY;
+	for (let index = 0; index < samples.length - 1; index += 1) {
+		const from = samples[index];
+		const to = samples[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));
+}
+/** Translate an arrow by a delta, keeping its frame consistent. */
+function translateArrow(item, dx, dy) {
+	const move = (point) => ({
+		x: point.x + dx,
+		y: point.y + dy
+	});
+	const next = {
+		...item,
+		start: move(item.start),
+		end: move(item.end)
+	};
+	return {
+		...next,
+		frame: arrowFrame(next)
+	};
+}
+//#endregion
+export { arrowBounds, arrowFrame, distanceToArrow, resolveArrow, sampleArrow, translateArrow };

package/dist/board/core/connections.d.ts

@@ -0,0 +1,91 @@
+import { BoardConnection, BoardConnectionAnchor, BoardConnectionSide } from "../../protocol/dist/board-connection.js";
+import { BoardFrame } from "../../protocol/dist/board-document.js";
+import { Rect, WorldPoint } from "../geometry.js";
+//#region src/board/core/connections.d.ts
+type FrameLookup = (id: string) => BoardFrame | undefined;
+/**
+ * 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.
+ */
+declare const CONNECTION_ENDPOINT_GAP = 4;
+type ResolvedConnectionEndpoint = {
+  point: WorldPoint;
+  /** Outward normal at the attachment, used to aim arrowheads and elbows. */
+  normal: WorldPoint;
+  side: BoardConnectionSide;
+};
+type ResolvedConnection = {
+  source: ResolvedConnectionEndpoint;
+  target: ResolvedConnectionEndpoint;
+  /** Sampled world-space path, always at least two points. */
+  path: WorldPoint[];
+  /** Midpoint of the path, for labels and the drag handle. */
+  mid: WorldPoint;
+};
+/** Denormalize a (nx, ny) anchor to a world point on a possibly rotated frame. */
+declare function anchorToWorld(frame: BoardFrame, nx: number, ny: number): WorldPoint;
+/** Normalize a world point into a (nx, ny) anchor on a frame, clamped to it. */
+declare function worldToAnchor(frame: BoardFrame, point: WorldPoint): {
+  nx: number;
+  ny: number;
+};
+/**
+ * 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.
+ */
+declare function autoConnectionSide(from: BoardFrame, to: BoardFrame): BoardConnectionSide;
+/**
+ * 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.
+ */
+declare function anchorPointOnFrame(anchor: BoardConnectionAnchor, frame: BoardFrame): WorldPoint;
+/**
+ * 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.
+ */
+declare function resolveConnection(connection: BoardConnection, getFrame: FrameLookup, options?: {
+  gap?: number;
+}): ResolvedConnection | null;
+/** Midpoint by arc length, so a label sits visually centered on the line. */
+declare function pathMidpoint(path: WorldPoint[]): WorldPoint;
+/** World bounds of a resolved connection, padded for its stroke. */
+declare function connectionBounds(resolved: ResolvedConnection, strokeSize: number): Rect;
+/** Distance from a world point to a resolved connection's path. */
+declare function distanceToConnection(resolved: ResolvedConnection, point: WorldPoint): number;
+/** Hit test a connection with a zoom-independent screen-space tolerance. */
+declare function connectionHitTest(resolved: ResolvedConnection, point: WorldPoint, strokeSize: number): boolean;
+/** Whether the connection draws an arrowhead at its source / target. */
+declare function connectionArrowheads(connection: BoardConnection): {
+  atSource: boolean;
+  atTarget: boolean;
+};
+/**
+ * Index of connections by the nodes they touch.
+ *
+ * Built once per document revision and consulted per gesture frame: moving a node
+ * must cost its own degree, not a scan of every connection on the board. Without
+ * this, dragging one node in a densely connected board is O(connections) per
+ * frame, which is exactly the cost that shows up as drag lag.
+ */
+type ConnectionIndex = {
+  /** Connection ids touching a node (either endpoint). */
+  byNode: (nodeId: string) => readonly string[];
+  get: (connectionId: string) => BoardConnection | undefined;
+  readonly all: readonly BoardConnection[];
+};
+declare function createConnectionIndex(connections: readonly BoardConnection[]): ConnectionIndex;
+//#endregion
+export { CONNECTION_ENDPOINT_GAP, ConnectionIndex, FrameLookup, ResolvedConnection, ResolvedConnectionEndpoint, anchorPointOnFrame, anchorToWorld, autoConnectionSide, connectionArrowheads, connectionBounds, connectionHitTest, createConnectionIndex, distanceToConnection, pathMidpoint, resolveConnection, worldToAnchor };