@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/utils/diff/types.js

@@ -0,0 +1,38 @@
+//#region src/utils/diff/types.ts
+var DiffKind = {
+	table: "table",
+	column: "column",
+	index: "index",
+	foreignKey: "foreignKey",
+	memo: "memo",
+	tableGroup: "tableGroup"
+};
+var DiffStatus = {
+	added: "added",
+	modified: "modified",
+	deleted: "deleted",
+	renamed: "renamed"
+};
+var DiffField = {
+	name: "name",
+	comment: "comment",
+	dataType: "dataType",
+	default: "default",
+	autoIncrement: "autoIncrement",
+	primaryKey: "primaryKey",
+	unique: "unique",
+	notNull: "notNull",
+	order: "order",
+	tableGroup: "tableGroup",
+	position: "position",
+	size: "size",
+	color: "color",
+	members: "members",
+	columns: "columns",
+	relationshipType: "relationshipType",
+	onDelete: "onDelete",
+	onUpdate: "onUpdate",
+	value: "value"
+};
+//#endregion
+export { DiffField, DiffKind, DiffStatus };

package/dist/utils/domEvent.js

@@ -0,0 +1,55 @@
+import { toNumString } from "./validation.js";
+//#region src/utils/domEvent.ts
+function onNumberOnly(event) {
+	const input = event.target;
+	if (!input) return;
+	input.value = toNumString(input.value);
+}
+function onPrevent(event) {
+	event.preventDefault();
+}
+function onStop(event) {
+	event.stopPropagation();
+}
+function isMouseEvent(event) {
+	return event instanceof MouseEvent;
+}
+var SECONDARY_BUTTON = 2;
+function isSecondaryButtonPress(event) {
+	return isMouseEvent(event) && event.button === SECONDARY_BUTTON;
+}
+function isMultiTouch(event) {
+	return (event.touches?.length ?? 0) > 1;
+}
+var MAIN_BUTTON = 0;
+var MIDDLE_BUTTON = 1;
+function isMainButtonPress(event) {
+	return !isMouseEvent(event) || event.button === MAIN_BUTTON;
+}
+function isMiddleButtonPress(event) {
+	return isMouseEvent(event) && event.button === MIDDLE_BUTTON;
+}
+function preventMiddleLift() {
+	const release = () => {
+		window.removeEventListener("mouseup", handleMouseup, true);
+	};
+	const handleMouseup = (lift) => {
+		if (!isMiddleButtonPress(lift)) return;
+		lift.preventDefault();
+		release();
+	};
+	window.addEventListener("mouseup", handleMouseup, true);
+	return release;
+}
+function editorRootOf(el) {
+	return el.closest(".root") ?? el;
+}
+function suppressSelection(el) {
+	const previous = el.style.userSelect;
+	el.style.userSelect = "none";
+	return () => {
+		el.style.userSelect = previous;
+	};
+}
+//#endregion
+export { editorRootOf, isMainButtonPress, isMiddleButtonPress, isMouseEvent, isMultiTouch, isSecondaryButtonPress, onNumberOnly, onPrevent, onStop, preventMiddleLift, suppressSelection };

package/dist/utils/dragSelect.js

@@ -0,0 +1,9 @@
+//#region src/utils/dragSelect.ts
+function isInsideDragRect(dragRect, rect) {
+	return rect.x >= dragRect.x && rect.y >= dragRect.y && rect.x + rect.w <= dragRect.x + dragRect.w && rect.y + rect.h <= dragRect.y + dragRect.h;
+}
+function isOverlapPosition(dragRect, rect) {
+	return !(dragRect.x > rect.x + rect.w || dragRect.x + dragRect.w < rect.x || dragRect.y > rect.y + rect.h || dragRect.y + dragRect.h < rect.y);
+}
+//#endregion
+export { isInsideDragRect, isOverlapPosition };

package/dist/utils/draw-relationship/bezier.js

@@ -0,0 +1,44 @@
+//#region src/utils/draw-relationship/bezier.ts
+var VIEW_CURVATURE = .25;
+var CURVATURE_SCALE = 25;
+function curveReach(gap) {
+	return VIEW_CURVATURE * CURVATURE_SCALE * Math.sqrt(Math.max(gap, 0));
+}
+function controlOffset(distance) {
+	return distance >= 0 ? distance / 2 : curveReach(-distance);
+}
+function control(from, outward, to) {
+	const offset = controlOffset((to.x - from.x) * outward.x + (to.y - from.y) * outward.y);
+	return {
+		x: from.x + outward.x * offset,
+		y: from.y + outward.y * offset
+	};
+}
+function bezierControls(from, fromOutward, to, toOutward) {
+	return [control(from, fromOutward, to), control(to, toOutward, from)];
+}
+function bezierPolyline(from, fromOutward, to, toOutward, segments = 24) {
+	const [first, second] = bezierControls(from, fromOutward, to, toOutward);
+	return cubicPolyline(from, first, second, to, segments);
+}
+function cubicPolyline(from, first, second, to, segments) {
+	const count = Math.max(1, Math.floor(segments));
+	const points = [{
+		x: from.x,
+		y: from.y
+	}];
+	for (let step = 1; step <= count; step++) {
+		const at = step / count;
+		points.push({
+			x: cubic(from.x, first.x, second.x, to.x, at),
+			y: cubic(from.y, first.y, second.y, to.y, at)
+		});
+	}
+	return points;
+}
+function cubic(p0, p1, p2, p3, at) {
+	const rest = 1 - at;
+	return rest * rest * rest * p0 + 3 * rest * rest * at * p1 + 3 * rest * at * at * p2 + at * at * at * p3;
+}
+//#endregion
+export { VIEW_CURVATURE, bezierControls, bezierPolyline, cubicPolyline, curveReach };

package/dist/utils/draw-relationship/calc.js

@@ -0,0 +1,91 @@
+import { Show } from "../../constants/schema.js";
+import { ShowMode } from "../../engine/modules/editor/state.js";
+import { getSourceView } from "../../engine/modules/editor/view.js";
+import { getTablePoint, getVisibleColumnIds } from "../../konva/scene/viewLayout.js";
+import { calcTableHeight, calcTableWidths, calcViewTableWidths, getWidthGeneration } from "../calcTable.js";
+//#region src/utils/draw-relationship/calc.ts
+var tableSizeCaches = {
+	document: /* @__PURE__ */ new WeakMap(),
+	flow: /* @__PURE__ */ new WeakMap()
+};
+function tableSize(state, table, source) {
+	const cache = tableSizeCaches[source];
+	const pending = source === "document" ? documentTableSize(state, table) : viewTableSize(state, table, source);
+	const cached = cache.get(table);
+	if (cached?.key === pending.key) return cached;
+	const size = pending.measure();
+	cache.set(table, size);
+	return size;
+}
+function documentTableSize(state, table) {
+	const { settings } = state;
+	const show = settings.show & ~(Show.hideReferentialAction | Show.hideTableGroup | Show.hideMemo);
+	const key = `${getWidthGeneration()}|${show}|${settings.maxWidthComment}|${settings.nameViewMode}|${table.ui.widthName}|${table.ui.widthLogicalName}|${table.ui.widthComment}|${table.columnIds.length}`;
+	return {
+		key,
+		measure: () => ({
+			key,
+			width: calcTableWidths(table, state).width,
+			height: calcTableHeight(table)
+		})
+	};
+}
+function viewTableSize(state, table, source) {
+	const { nameViewMode } = state.settings;
+	const showMode = getSourceView(state, source)?.showMode ?? ShowMode.allFields;
+	const columnIds = getVisibleColumnIds(state, table, source);
+	const key = `${getWidthGeneration()}|${nameViewMode}|${table.ui.widthName}|${table.ui.widthLogicalName}|${table.columnIds.length}|${showMode}|${columnIds.length}`;
+	return {
+		key,
+		measure: () => ({
+			key,
+			width: calcViewTableWidths(table, state, columnIds).width,
+			height: calcTableHeight(table, columnIds.length, source)
+		})
+	};
+}
+function tableToObjectPoint(state, table, source = "document") {
+	const { width, height } = tableSize(state, table, source);
+	const { x, y } = getTablePoint(state, table, source);
+	return {
+		width,
+		height,
+		top: {
+			x: x + width / 2,
+			y
+		},
+		bottom: {
+			x: x + width / 2,
+			y: y + height
+		},
+		left: {
+			x,
+			y: y + height / 2
+		},
+		right: {
+			x: x + width,
+			y: y + height / 2
+		},
+		lt: {
+			x,
+			y
+		},
+		rt: {
+			x: x + width,
+			y
+		},
+		lb: {
+			x,
+			y: y + height
+		},
+		rb: {
+			x: x + width,
+			y: y + height
+		}
+	};
+}
+function euclideanDistance(a, b) {
+	return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
+}
+//#endregion
+export { euclideanDistance, tableToObjectPoint };

package/dist/utils/draw-relationship/corner.js

@@ -0,0 +1,60 @@
+//#region src/utils/draw-relationship/corner.ts
+var MIN_RADIUS = 2;
+function along(corner, toward, distance) {
+	return Math.abs(corner.x - toward.x) < .5 ? {
+		x: corner.x,
+		y: corner.y + Math.sign(toward.y - corner.y) * distance
+	} : {
+		x: corner.x + Math.sign(toward.x - corner.x) * distance,
+		y: corner.y
+	};
+}
+function arc(from, corner, to, chords) {
+	const centre = {
+		x: from.x + to.x - corner.x,
+		y: from.y + to.y - corner.y
+	};
+	const points = [from];
+	for (let step = 1; step < chords; step++) {
+		const angle = step / chords * (Math.PI / 2);
+		const cos = Math.cos(angle);
+		const sin = Math.sin(angle);
+		points.push({
+			x: centre.x + (from.x - centre.x) * cos + (to.x - centre.x) * sin,
+			y: centre.y + (from.y - centre.y) * cos + (to.y - centre.y) * sin
+		});
+	}
+	points.push(to);
+	return points;
+}
+function roundPolyline(points, radius) {
+	if (points.length < 3 || radius <= 0) return points;
+	const rounded = [points[0]];
+	const push = (point) => {
+		const last = rounded[rounded.length - 1];
+		if (Math.abs(last.x - point.x) < .5 && Math.abs(last.y - point.y) < .5) return;
+		rounded.push(point);
+	};
+	for (let index = 1; index < points.length - 1; index++) {
+		const previous = points[index - 1];
+		const corner = points[index];
+		const next = points[index + 1];
+		if (!(Math.abs(corner.x - previous.x) < .5 !== Math.abs(next.x - corner.x) < .5)) {
+			push(corner);
+			continue;
+		}
+		const back = Math.abs(corner.x - previous.x) + Math.abs(corner.y - previous.y);
+		const forward = Math.abs(next.x - corner.x) + Math.abs(next.y - corner.y);
+		const distance = Math.min(radius, back / 2, forward / 2);
+		if (distance < MIN_RADIUS) {
+			push(corner);
+			continue;
+		}
+		const chords = Math.min(6, Math.ceil(distance));
+		for (const point of arc(along(corner, previous, distance), corner, along(corner, next, distance), chords)) push(point);
+	}
+	push(points[points.length - 1]);
+	return rounded;
+}
+//#endregion
+export { roundPolyline };

package/dist/utils/draw-relationship/draw.js

@@ -0,0 +1,194 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { DirectionName, DirectionNameList } from "./index.js";
+import { euclideanDistance, tableToObjectPoint } from "./calc.js";
+//#region src/utils/draw-relationship/draw.ts
+function getDraw(state, draw) {
+	const drawPath = {
+		path: {
+			path: {
+				M: {
+					x: 0,
+					y: 0
+				},
+				L: {
+					x: 0,
+					y: 0
+				},
+				Q: {
+					x: 0,
+					y: 0
+				},
+				d() {
+					return `M ${this.M.x} ${this.M.y} L ${this.L.x} ${this.L.y}`;
+				}
+			},
+			line: { start: {
+				x1: 0,
+				y1: 0,
+				x2: 0,
+				y2: 0
+			} }
+		},
+		line: { start: {
+			base: {
+				x1: 0,
+				y1: 0,
+				x2: 0,
+				y2: 0
+			},
+			base2: {
+				x1: 0,
+				y1: 0,
+				x2: 0,
+				y2: 0
+			},
+			center: {
+				x1: 0,
+				y1: 0,
+				x2: 0,
+				y2: 0
+			},
+			center2: {
+				x1: 0,
+				y1: 0,
+				x2: 0,
+				y2: 0
+			}
+		} }
+	};
+	if (!draw.start) return drawPath;
+	const direction = getDrawDirection(state, draw);
+	drawPath.path = getDrawPath(direction, draw);
+	drawPath.line = getDrawLine(direction, draw);
+	return drawPath;
+}
+function getDrawDirection(state, draw) {
+	let direction = DirectionName.bottom;
+	if (!draw.start) return direction;
+	const table = query(state.collections).collection("tableEntities").selectById(draw.start.tableId);
+	if (!table) return direction;
+	const start = tableToObjectPoint(state, table);
+	let min = euclideanDistance(start.bottom, draw.end);
+	draw.start.x = start.bottom.x;
+	draw.start.y = start.bottom.y;
+	DirectionNameList.forEach((key) => {
+		const k = key;
+		const temp = euclideanDistance(start[k], draw.end);
+		if (min <= temp) return;
+		min = temp;
+		direction = k;
+		if (!draw.start) return;
+		draw.start.x = start[k].x;
+		draw.start.y = start[k].y;
+	});
+	return direction;
+}
+function getDrawPath(direction, draw) {
+	const line = { start: {
+		x1: 0,
+		y1: 0,
+		x2: 0,
+		y2: 0
+	} };
+	const path = {
+		M: {
+			x: 0,
+			y: 0
+		},
+		L: {
+			x: 0,
+			y: 0
+		},
+		Q: {
+			x: 0,
+			y: 0
+		},
+		d() {
+			return `M ${this.M.x} ${this.M.y} L ${this.L.x} ${this.L.y}`;
+		}
+	};
+	if (draw.start) {
+		line.start.x1 = draw.start.x;
+		line.start.y1 = draw.start.y;
+		line.start.x2 = draw.start.x;
+		line.start.y2 = draw.start.y;
+		let change = 1;
+		if (direction === DirectionName.left || direction === DirectionName.right) {
+			if (direction === DirectionName.left) change *= -1;
+			line.start.x2 = draw.start.x + change * 24;
+			line.start.x1 += change * 21;
+			path.M.x = line.start.x2;
+			path.M.y = draw.start.y;
+		} else if (direction === DirectionName.top || direction === DirectionName.bottom) {
+			if (direction === DirectionName.top) change *= -1;
+			line.start.y2 = draw.start.y + change * 24;
+			line.start.y1 += change * 21;
+			path.M.x = draw.start.x;
+			path.M.y = line.start.y2;
+		}
+	}
+	path.L.x = draw.end.x;
+	path.L.y = draw.end.y;
+	return {
+		path,
+		line
+	};
+}
+function getDrawLine(direction, draw) {
+	const line = { start: {
+		base: {
+			x1: 0,
+			y1: 0,
+			x2: 0,
+			y2: 0
+		},
+		base2: {
+			x1: 0,
+			y1: 0,
+			x2: 0,
+			y2: 0
+		},
+		center: {
+			x1: 0,
+			y1: 0,
+			x2: 0,
+			y2: 0
+		},
+		center2: {
+			x1: 0,
+			y1: 0,
+			x2: 0,
+			y2: 0
+		}
+	} };
+	if (!draw.start) return line;
+	line.start.base.x1 = line.start.base2.x1 = line.start.center.x1 = line.start.center2.x1 = draw.start.x;
+	line.start.base.x2 = line.start.base2.x2 = line.start.center.x2 = line.start.center2.x2 = draw.start.x;
+	line.start.base.y1 = line.start.base2.y1 = line.start.center.y1 = line.start.center2.y1 = draw.start.y;
+	line.start.base.y2 = line.start.base2.y2 = line.start.center.y2 = line.start.center2.y2 = draw.start.y;
+	let change = 1;
+	if (direction === DirectionName.left || direction === DirectionName.right) {
+		if (direction === DirectionName.left) change *= -1;
+		line.start.base.x1 = line.start.base.x2 += change * 9;
+		line.start.base2.x1 = line.start.base2.x2 += change * 15;
+		line.start.center.x1 = line.start.base.x1;
+		line.start.base.y1 -= 6;
+		line.start.base.y2 += 6;
+		line.start.base2.y1 -= 6;
+		line.start.base2.y2 += 6;
+		line.start.center2.x1 += change * 21;
+	} else if (direction === DirectionName.top || direction === DirectionName.bottom) {
+		if (direction === DirectionName.top) change *= -1;
+		line.start.base.y1 = line.start.base.y2 += change * 9;
+		line.start.base2.y1 = line.start.base2.y2 += change * 15;
+		line.start.center.y1 = line.start.base.y1;
+		line.start.base.x1 -= 6;
+		line.start.base.x2 += 6;
+		line.start.base2.x1 -= 6;
+		line.start.base2.x2 += 6;
+		line.start.center2.y1 += change * 21;
+	}
+	return line;
+}
+//#endregion
+export { getDraw };

package/dist/utils/draw-relationship/incremental.d.ts

@@ -26,6 +26,7 @@ export type RouteEntry = {
     pristine: Point[];
     /** What was finally drawn, which is what a reused group is put back onto. */
     nudged: Point[];
+    /** Where every table the route depends on lies: its reach, from routeWithReach. */
     bounds: DirtyBox;
 };
 export type SortCache = {
@@ -38,11 +39,10 @@ export type SortCache = {
  * of the same tables, and a diff across them would re-route everything each turn.
  */
 export declare function getSortCache(state: RootState, source?: GeometrySource): SortCache;
-export declare function boundsOfPoints(points: Point[]): DirtyBox;
+export declare function union(a: DirtyBox, b: DirtyBox): DirtyBox;
 /**
- * Whether a moved table can change a route. The bounding box rather than the
- * runs inside it: the router picks its lanes from every table reaching into the
- * band between the two anchors, not only from the ones the route passes.
+ * Whether a moved table can change a route: whether it comes within touch of
+ * the route's reach, not only of the route itself.
  */
 export declare function routeTouches(bounds: DirtyBox, boxes: DirtyBox[]): boolean;
 /**

package/dist/utils/draw-relationship/incremental.js

@@ -0,0 +1,135 @@
+//#region src/utils/draw-relationship/incremental.ts
+var ROUTE_TOUCH = 40;
+var LANE_INFLUENCE = 64;
+var EXTENT_SLACK = 16;
+var BUCKET = 64;
+var MAX_MOVED_TABLES = 64;
+var caches = /* @__PURE__ */ new WeakMap();
+var createSortCache = () => ({
+	boxes: /* @__PURE__ */ new Map(),
+	entries: /* @__PURE__ */ new Map()
+});
+function getSortCache(state, source = "document") {
+	let record = caches.get(state);
+	if (!record) {
+		record = {
+			document: createSortCache(),
+			flow: createSortCache()
+		};
+		caches.set(state, record);
+	}
+	return record[source];
+}
+function boxOf(obstacles, index) {
+	return {
+		left: obstacles.left[index],
+		top: obstacles.top[index],
+		right: obstacles.right[index],
+		bottom: obstacles.bottom[index]
+	};
+}
+function union(a, b) {
+	return {
+		left: Math.min(a.left, b.left),
+		top: Math.min(a.top, b.top),
+		right: Math.max(a.right, b.right),
+		bottom: Math.max(a.bottom, b.bottom)
+	};
+}
+function same(a, b) {
+	return a.left === b.left && a.top === b.top && a.right === b.right && a.bottom === b.bottom;
+}
+function overlaps(a, b) {
+	return a.left <= b.right && a.right >= b.left && a.top <= b.bottom && a.bottom >= b.top;
+}
+function routeTouches(bounds, boxes) {
+	const reach = {
+		left: bounds.left - ROUTE_TOUCH,
+		top: bounds.top - ROUTE_TOUCH,
+		right: bounds.right + ROUTE_TOUCH,
+		bottom: bounds.bottom + ROUTE_TOUCH
+	};
+	for (const box of boxes) if (overlaps(reach, box)) return true;
+	return false;
+}
+function createDirtyLanes() {
+	const verticalLanes = /* @__PURE__ */ new Map();
+	const horizontalLanes = /* @__PURE__ */ new Map();
+	const markSpan = (vertical, from, to, low, high) => {
+		const bucket = vertical ? verticalLanes : horizontalLanes;
+		const first = Math.floor(Math.min(from, to) / BUCKET);
+		const last = Math.floor(Math.max(from, to) / BUCKET);
+		for (let key = first; key <= last; key++) {
+			const list = bucket.get(key);
+			if (list) list.push(from, to, low, high);
+			else bucket.set(key, [
+				from,
+				to,
+				low,
+				high
+			]);
+		}
+	};
+	return {
+		markSpan,
+		markBox(box) {
+			markSpan(true, box.left, box.right, box.top, box.bottom);
+			markSpan(false, box.top, box.bottom, box.left, box.right);
+		},
+		hits(vertical, from, to, low, high) {
+			const bucket = vertical ? verticalLanes : horizontalLanes;
+			if (!bucket.size) return false;
+			const near = Math.min(from, to) - LANE_INFLUENCE;
+			const far = Math.max(from, to) + LANE_INFLUENCE;
+			const first = Math.floor(near / BUCKET);
+			const last = Math.floor(far / BUCKET);
+			for (let key = first; key <= last; key++) {
+				const list = bucket.get(key);
+				if (!list) continue;
+				for (let index = 0; index < list.length; index += 4) {
+					if (list[index + 1] < near || list[index] > far) continue;
+					if (list[index + 3] < low - EXTENT_SLACK) continue;
+					if (list[index + 2] > high + EXTENT_SLACK) continue;
+					return true;
+				}
+			}
+			return false;
+		}
+	};
+}
+function markRoute(lanes, points) {
+	for (let index = 1; index < points.length; index++) {
+		const a = points[index - 1];
+		const b = points[index];
+		if (Math.abs(a.x - b.x) < .5) lanes.markSpan(true, a.x, b.x, Math.min(a.y, b.y), Math.max(a.y, b.y));
+		else lanes.markSpan(false, a.y, b.y, Math.min(a.x, b.x), Math.max(a.x, b.x));
+	}
+}
+function diffTableBoxes(cache, obstacles) {
+	const previous = cache.boxes;
+	const next = /* @__PURE__ */ new Map();
+	const dirty = [];
+	let full = false;
+	for (let index = 0; index < obstacles.ids.length; index++) {
+		const id = obstacles.ids[index];
+		const box = boxOf(obstacles, index);
+		next.set(id, box);
+		if (full) continue;
+		const was = previous.get(id);
+		if (!was) dirty.push(box);
+		else if (!same(was, box)) dirty.push(union(was, box));
+		if (dirty.length > MAX_MOVED_TABLES) full = true;
+	}
+	if (!full) for (const [id, box] of previous) {
+		if (next.has(id)) continue;
+		dirty.push(box);
+		if (dirty.length > MAX_MOVED_TABLES) {
+			full = true;
+			break;
+		}
+	}
+	cache.boxes = next;
+	return full || previous.size === 0 ? null : dirty;
+}
+//#endregion
+export { createDirtyLanes, diffTableBoxes, getSortCache, markRoute, routeTouches, union };

package/dist/utils/draw-relationship/index.d.ts

@@ -1,3 +1,4 @@
+import { RootState } from '../../engine/state';
 import { Point, Relationship, RelationshipPoint, ValuesType } from '../../internal-types';
 import { GeometrySource } from './geometrySource';
 export declare const DirectionName: {
@@ -145,6 +146,16 @@ export type Anchors = {
     end: Anchor;
 };
 export declare function copyAnchor({ tableId, x, y, direction }: Anchor): Anchor;
+/**
+ * Holds back, until releaseRouteRedraws, the redraw of each document route a
+ * sort of this store changes. A static connector redrawn on each drag frame
+ * repaints the layer every static table sits in, which the drag never touches.
+ */
+export declare function holdRouteRedraws(state: RootState): void;
+/** Redraws, once, every route the store's hold kept back, and lets the hold go. */
+export declare function releaseRouteRedraws(state: RootState): void;
+/** The redraws a sort of this store keeps back while a drag holds them, if one does. */
+export declare function heldRouteRedraws(state: RootState): Set<Relationship> | undefined;
 /**
  * Forgets what a source's sorts wrote for these connectors, so a reader sees a
  * source that never sorted them. Per connector, never the whole channel: the
@@ -154,7 +165,11 @@ export declare function clearSortChannel(relationships: Iterable<Relationship>,
 export declare function setStubSlots(relationship: Relationship, slots: readonly [number, number], source?: GeometrySource): void;
 /** Falls back to slot zero, which reproduces the pre-stagger geometry. */
 export declare function getStubSlots(relationship: Relationship, source?: GeometrySource): readonly [number, number];
-export declare function setRoute(relationship: Relationship, points: Point[], source?: GeometrySource): void;
+/**
+ * Writes a connector's route and wakes whoever read it, only when it changed.
+ * The document's wake waits in held while a drag of its store holds it.
+ */
+export declare function setRoute(relationship: Relationship, points: Point[], source?: GeometrySource, held?: Set<Relationship>): void;
 export declare function getRoute(relationship: Relationship, source?: GeometrySource): Point[] | undefined;
 /**
  * How far a connector reaches past its anchor, whichever decoration is furthest