@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,294 @@
+import { isHorizontal, outwardSign } from "./stub.js";
+//#region src/utils/draw-relationship/search.ts
+var SEARCH_MARGIN = 240;
+var MAX_SEARCH_POINTS = 4096;
+var STEP_X = [
+	1,
+	-1,
+	0,
+	0
+];
+var STEP_Y = [
+	0,
+	0,
+	1,
+	-1
+];
+function headingOf(direction, sign = 1) {
+	const outward = outwardSign(direction) * sign;
+	if (isHorizontal(direction)) return outward > 0 ? 0 : 1;
+	return outward > 0 ? 2 : 3;
+}
+var pointBlocked = /* @__PURE__ */ new Uint8Array(0);
+var acrossBlocked = /* @__PURE__ */ new Uint8Array(0);
+var downBlocked = /* @__PURE__ */ new Uint8Array(0);
+var spentTo = /* @__PURE__ */ new Float64Array(0);
+var cameFrom = /* @__PURE__ */ new Int32Array(0);
+function reserve(points) {
+	if (pointBlocked.length < points) {
+		pointBlocked = new Uint8Array(points);
+		acrossBlocked = new Uint8Array(points);
+		downBlocked = new Uint8Array(points);
+		spentTo = new Float64Array(points * 4);
+		cameFrom = new Int32Array(points * 4);
+	}
+	pointBlocked.fill(0, 0, points);
+	acrossBlocked.fill(0, 0, points);
+	downBlocked.fill(0, 0, points);
+	spentTo.fill(Infinity, 0, points * 4);
+	cameFrom.fill(-1, 0, points * 4);
+}
+function uniqueSorted(values) {
+	values.sort((a, b) => a - b);
+	const out = [];
+	for (const value of values) {
+		if (out.length && value - out[out.length - 1] < .5) continue;
+		out.push(value);
+	}
+	return out;
+}
+function lowerBound(sorted, value) {
+	let low = 0;
+	let high = sorted.length;
+	while (low < high) {
+		const middle = low + high >> 1;
+		if (sorted[middle] < value) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+}
+function upperBound(sorted, value) {
+	let low = 0;
+	let high = sorted.length;
+	while (low < high) {
+		const middle = low + high >> 1;
+		if (sorted[middle] <= value) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+}
+function createQueue() {
+	const costs = [];
+	const states = [];
+	const less = (a, b) => costs[a] < costs[b] || costs[a] === costs[b] && states[a] < states[b];
+	const swap = (a, b) => {
+		[costs[a], costs[b]] = [costs[b], costs[a]];
+		[states[a], states[b]] = [states[b], states[a]];
+	};
+	return {
+		get size() {
+			return costs.length;
+		},
+		push(cost, state) {
+			costs.push(cost);
+			states.push(state);
+			let index = costs.length - 1;
+			while (index > 0) {
+				const parent = index - 1 >> 1;
+				if (!less(index, parent)) break;
+				swap(index, parent);
+				index = parent;
+			}
+		},
+		pop() {
+			const top = [costs[0], states[0]];
+			const lastCost = costs.pop();
+			const lastState = states.pop();
+			if (costs.length) {
+				costs[0] = lastCost;
+				states[0] = lastState;
+				let index = 0;
+				for (;;) {
+					const left = index * 2 + 1;
+					const right = left + 1;
+					let next = index;
+					if (left < costs.length && less(left, next)) next = left;
+					if (right < costs.length && less(right, next)) next = right;
+					if (next === index) break;
+					swap(index, next);
+					index = next;
+				}
+			}
+			return top;
+		}
+	};
+}
+function searchRoute(m, mDirection, l, lDirection, obstacles, startTableId, endTableId, clearance, bendCost) {
+	const region = {
+		left: Math.min(m.x, l.x) - SEARCH_MARGIN,
+		top: Math.min(m.y, l.y) - SEARCH_MARGIN,
+		right: Math.max(m.x, l.x) + SEARCH_MARGIN,
+		bottom: Math.max(m.y, l.y) + SEARCH_MARGIN
+	};
+	const inside = [];
+	const xs = [
+		m.x,
+		l.x,
+		region.left,
+		region.right
+	];
+	const ys = [
+		m.y,
+		l.y,
+		region.top,
+		region.bottom
+	];
+	for (let index = 0; index < obstacles.ids.length; index++) {
+		if (obstacles.right[index] < region.left || obstacles.left[index] > region.right || obstacles.bottom[index] < region.top || obstacles.top[index] > region.bottom) continue;
+		inside.push(index);
+		xs.push(obstacles.left[index] - clearance, obstacles.right[index] + clearance);
+		ys.push(obstacles.top[index] - clearance, obstacles.bottom[index] + clearance);
+	}
+	const nearEnd = (value, a, b) => value !== a && value !== b && (Math.abs(value - a) < 1 || Math.abs(value - b) < 1);
+	const columns = uniqueSorted(xs.filter((x) => x >= region.left && x <= region.right && !nearEnd(x, m.x, l.x)));
+	const rows = uniqueSorted(ys.filter((y) => y >= region.top && y <= region.bottom && !nearEnd(y, m.y, l.y)));
+	const width = columns.length;
+	const height = rows.length;
+	if (width * height > MAX_SEARCH_POINTS) return {
+		points: null,
+		region
+	};
+	reserve(width * height);
+	const point = pointBlocked;
+	const across = acrossBlocked;
+	const down = downBlocked;
+	for (const index of inside) {
+		const left = obstacles.left[index];
+		const right = obstacles.right[index];
+		const top = obstacles.top[index];
+		const bottom = obstacles.bottom[index];
+		const firstColumn = lowerBound(columns, left);
+		const firstRow = lowerBound(rows, top);
+		for (let row = firstRow; row < height && rows[row] <= bottom; row++) for (let column = Math.max(0, firstColumn - 1); column < width && columns[column] <= right; column++) {
+			const at = row * width + column;
+			if (columns[column] >= left) point[at] = 1;
+			if (column + 1 < width && columns[column + 1] >= left) across[at] = 1;
+		}
+		for (let column = firstColumn; column < width && columns[column] <= right; column++) for (let row = Math.max(0, firstRow - 1); row < height && rows[row] <= bottom; row++) if (row + 1 < height && rows[row + 1] >= top) down[row * width + column] = 1;
+	}
+	const rowOf = (y) => upperBound(rows, y - .5);
+	const columnOf = (x) => upperBound(columns, x - .5);
+	const start = rowOf(m.y) * width + columnOf(m.x);
+	const goal = rowOf(l.y) * width + columnOf(l.x);
+	if (point[start] || point[goal]) return {
+		points: null,
+		region
+	};
+	const close = (at) => {
+		if (at !== start && at !== goal) point[at] = 1;
+	};
+	const closeStub = (end, direction, tableId) => {
+		const index = obstacles.ids.indexOf(tableId);
+		if (index < 0) return;
+		const sign = outwardSign(direction);
+		if (isHorizontal(direction)) {
+			const edge = sign > 0 ? obstacles.right[index] : obstacles.left[index];
+			const row = rowOf(end.y);
+			for (let column = 0; column < width; column++) {
+				const x = columns[column];
+				if ((x - edge) * sign > 0 && (end.x - x) * sign > .5) close(row * width + column);
+			}
+		} else {
+			const edge = sign > 0 ? obstacles.bottom[index] : obstacles.top[index];
+			const column = columnOf(end.x);
+			for (let row = 0; row < height; row++) {
+				const y = rows[row];
+				if ((y - edge) * sign > 0 && (end.y - y) * sign > .5) close(row * width + column);
+			}
+		}
+	};
+	closeStub(m, mDirection, startTableId);
+	closeStub(l, lDirection, endTableId);
+	const startHeading = headingOf(mDirection);
+	const away = headingOf(lDirection);
+	const arrive = headingOf(lDirection, -1);
+	const best = spentTo;
+	const parent = cameFrom;
+	const queue = createQueue();
+	const estimate = (at) => Math.abs(columns[at % width] - l.x) + Math.abs(rows[Math.floor(at / width)] - l.y);
+	const first = start * 4 + startHeading;
+	best[first] = 0;
+	queue.push(estimate(start), first);
+	let found = -1;
+	let foundCost = Infinity;
+	while (queue.size) {
+		const [cost, state] = queue.pop();
+		if (cost >= foundCost) break;
+		const at = state >> 2;
+		const heading = state & 3;
+		const spent = best[state];
+		if (cost > spent + estimate(at)) continue;
+		if (at === goal) {
+			const total = spent + (heading === arrive ? 0 : bendCost);
+			if (heading !== away && total < foundCost) {
+				foundCost = total;
+				found = state;
+			}
+			continue;
+		}
+		const column = at % width;
+		const row = (at - column) / width;
+		for (let next = 0; next < 4; next++) {
+			if (STEP_X[next] === -STEP_X[heading] && STEP_Y[next] === -STEP_Y[heading]) continue;
+			const nextColumn = column + STEP_X[next];
+			const nextRow = row + STEP_Y[next];
+			if (nextColumn < 0 || nextColumn >= width) continue;
+			if (nextRow < 0 || nextRow >= height) continue;
+			const target = nextRow * width + nextColumn;
+			if (point[target]) continue;
+			if (next < 2 && across[row * width + Math.min(column, nextColumn)]) continue;
+			if (next >= 2 && down[Math.min(row, nextRow) * width + column]) continue;
+			const total = spent + (Math.abs(columns[nextColumn] - columns[column]) + Math.abs(rows[nextRow] - rows[row])) + (next === heading ? 0 : bendCost);
+			const nextState = target * 4 + next;
+			if (total >= best[nextState]) continue;
+			best[nextState] = total;
+			parent[nextState] = state;
+			queue.push(total + estimate(target), nextState);
+		}
+	}
+	if (found < 0) return {
+		points: null,
+		region
+	};
+	const path = [];
+	for (let state = found; state >= 0; state = parent[state]) {
+		const at = state >> 2;
+		path.push({
+			x: columns[at % width],
+			y: rows[Math.floor(at / width)]
+		});
+	}
+	path.reverse();
+	path[0] = {
+		x: m.x,
+		y: m.y
+	};
+	path[path.length - 1] = {
+		x: l.x,
+		y: l.y
+	};
+	return {
+		points: straighten(path),
+		region
+	};
+}
+function straighten(points) {
+	const out = [];
+	for (const current of points) {
+		const last = out[out.length - 1];
+		if (last && Math.abs(last.x - current.x) < .5 && Math.abs(last.y - current.y) < .5) continue;
+		if (out.length >= 2) {
+			const before = out[out.length - 2];
+			const upright = Math.abs(before.x - last.x) < .5 && Math.abs(last.x - current.x) < .5;
+			const level = Math.abs(before.y - last.y) < .5 && Math.abs(last.y - current.y) < .5;
+			if (upright || level) {
+				out[out.length - 1] = current;
+				continue;
+			}
+		}
+		out.push(current);
+	}
+	return out;
+}
+//#endregion
+export { searchRoute };

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

@@ -0,0 +1,370 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { Direction } from "../../constants/schema.js";
+import { arrayHas } from "../arrayHas.js";
+import { DirectionName, DirectionNameList, copyAnchor, heldRouteRedraws, nextSortEpoch, setAnchors, setRoute, setStubSlots } from "./index.js";
+import { getVisibleIds } from "../../konva/scene/viewLayout.js";
+import { euclideanDistance, tableToObjectPoint } from "./calc.js";
+import { createDirtyLanes, diffTableBoxes, getSortCache, markRoute, routeTouches } from "./incremental.js";
+import { stubEnds } from "./stub.js";
+import { collectObstacles, routeWithReach } from "./route.js";
+import { nudgeRoutes } from "./nudge.js";
+//#region src/utils/draw-relationship/sort.ts
+var directionNameToDirection = {
+	[DirectionName.top]: Direction.top,
+	[DirectionName.bottom]: Direction.bottom,
+	[DirectionName.left]: Direction.left,
+	[DirectionName.right]: Direction.right
+};
+var TAU = Math.PI * 2;
+var SELF_CORNER_OFFSET = 20;
+var SELF_CORNER_STRIDE = 18;
+var SELF_CLEARANCE = 8;
+var SQUEEZED_PITCH = 12;
+var SIDE_START_ANGLE = {
+	[DirectionName.top]: -Math.PI,
+	[DirectionName.right]: -Math.PI / 2,
+	[DirectionName.bottom]: 0,
+	[DirectionName.left]: Math.PI / 2
+};
+var WALKS_BACKWARDS = {
+	[DirectionName.top]: false,
+	[DirectionName.right]: false,
+	[DirectionName.bottom]: true,
+	[DirectionName.left]: true
+};
+function relationshipSort(state, source = "document", { route = true } = {}) {
+	nextSortEpoch(source);
+	const { tableIds, relationshipIds } = getVisibleIds(state, source);
+	const { collections } = state;
+	const isTableIds = arrayHas(tableIds);
+	const tableCollection = query(collections).collection("tableEntities");
+	const relationships = query(collections).collection("relationshipEntities").selectByIds(relationshipIds).filter(({ start, end }) => isTableIds(start.tableId) && isTableIds(end.tableId));
+	const graphMap = /* @__PURE__ */ new Map();
+	const changeMap = /* @__PURE__ */ new Map();
+	const slotMap = /* @__PURE__ */ new Map();
+	const pairs = pairIndexes(relationships);
+	for (const relationship of relationships) {
+		const relationshipShape = createChangeRelationship(relationship);
+		const { start, end } = relationshipShape;
+		const startTable = tableCollection.selectById(start.tableId);
+		const endTable = tableCollection.selectById(end.tableId);
+		if (!startTable || !endTable) continue;
+		changeMap.set(relationship, relationshipShape);
+		slotMap.set(relationshipShape.id, [0, 0]);
+		if (start.tableId === end.tableId) getOrCreateGraph(state, graphMap, startTable, source).loops.push(relationshipShape);
+		else {
+			const startGraph = getOrCreateGraph(state, graphMap, startTable, source);
+			const endGraph = getOrCreateGraph(state, graphMap, endTable, source);
+			const [startDirection, endDirection] = getAndSetDirection(startGraph.objectPoint, endGraph.objectPoint, relationshipShape, source);
+			startGraph[startDirection].push({
+				id: relationshipShape.id,
+				isStart: true,
+				point: start,
+				angle: orderAngle(startDirection, startGraph, endGraph),
+				tie: pairs.tieAt(relationshipShape.id, start.tableId, end.tableId)
+			});
+			endGraph[endDirection].push({
+				id: relationshipShape.id,
+				isStart: false,
+				point: end,
+				angle: orderAngle(endDirection, endGraph, startGraph),
+				tie: pairs.tieAt(relationshipShape.id, end.tableId, start.tableId)
+			});
+		}
+	}
+	for (const graph of graphMap.values()) {
+		placeLoops(graph);
+		for (const key of DirectionNameList) placeSide(key, graph, slotMap);
+	}
+	for (const [origin, change] of changeMap.entries()) {
+		setStubSlots(origin, slotMap.get(change.id) ?? [0, 0], source);
+		setAnchors(origin, change, source);
+	}
+	if (source === "document") {
+		if (route) routeRelationships(state, changeMap, slotMap);
+	} else stubRelationships(changeMap, slotMap, source);
+}
+function stubRelationships(changeMap, slotMap, source) {
+	for (const [origin, change] of changeMap.entries()) {
+		const { id, start, end } = change;
+		if (start.tableId === end.tableId) continue;
+		const { m, l } = stubEnds(change, slotMap.get(id) ?? [0, 0]);
+		setRoute(origin, [m, l], source);
+	}
+}
+function routeRelationships(state, changeMap, slotMap) {
+	const obstacles = collectObstacles(state);
+	const cache = getSortCache(state);
+	const moved = diffTableBoxes(cache, obstacles);
+	const previous = cache.entries;
+	const entries = /* @__PURE__ */ new Map();
+	const dirty = /* @__PURE__ */ new Set();
+	const lanes = createDirtyLanes();
+	if (moved) for (const box of moved) lanes.markBox(box);
+	const routes = /* @__PURE__ */ new Map();
+	const endpoints = /* @__PURE__ */ new Map();
+	const origins = /* @__PURE__ */ new Map();
+	for (const [origin, change] of changeMap.entries()) {
+		const { id, start, end } = change;
+		if (start.tableId === end.tableId) continue;
+		const { m, l } = stubEnds(change, slotMap.get(id) ?? [0, 0]);
+		const was = previous.get(id);
+		let pristine;
+		let points;
+		let bounds;
+		if (moved !== null && was !== void 0 && sameRouteInputs(was, m, l, start, end) && !routeTouches(was.bounds, moved)) {
+			pristine = was.pristine;
+			points = clonePoints(pristine);
+			bounds = was.bounds;
+		} else {
+			const routed = routeWithReach(m, start.direction, l, end.direction, obstacles, start.tableId, end.tableId);
+			points = routed.points;
+			bounds = routed.reach;
+			pristine = clonePoints(points);
+			dirty.add(id);
+			if (was) markRoute(lanes, was.nudged);
+			markRoute(lanes, pristine);
+		}
+		routes.set(id, points);
+		endpoints.set(id, [start.tableId, end.tableId]);
+		origins.set(id, origin);
+		entries.set(id, {
+			mx: m.x,
+			my: m.y,
+			mDirection: start.direction,
+			lx: l.x,
+			ly: l.y,
+			lDirection: end.direction,
+			startTableId: start.tableId,
+			endTableId: end.tableId,
+			pristine,
+			nudged: points,
+			bounds
+		});
+	}
+	if (moved) {
+		for (const [id, entry] of previous) if (!entries.has(id)) markRoute(lanes, entry.nudged);
+	}
+	nudgeRoutes(routes, obstacles, endpoints, moved === null ? void 0 : createMemo(previous, dirty, lanes));
+	const held = heldRouteRedraws(state);
+	for (const [id, points] of routes) {
+		const origin = origins.get(id);
+		if (origin) setRoute(origin, points, "document", held);
+	}
+	cache.entries = entries;
+}
+function clonePoints(points) {
+	return points.map(({ x, y }) => ({
+		x,
+		y
+	}));
+}
+function createMemo(previous, dirty, lanes) {
+	return {
+		dirty,
+		lanes,
+		coordinate(relationshipId, index, vertical) {
+			const point = previous.get(relationshipId)?.nudged[index];
+			if (!point) return void 0;
+			return vertical ? point.x : point.y;
+		}
+	};
+}
+function sameRouteInputs(was, m, l, start, end) {
+	return was.mx === m.x && was.my === m.y && was.lx === l.x && was.ly === l.y && was.mDirection === start.direction && was.lDirection === end.direction && was.startTableId === start.tableId && was.endTableId === end.tableId;
+}
+function getOrCreateGraph(state, graphMap, table, source) {
+	let graph = graphMap.get(table.id);
+	if (!graph) {
+		const objectPoint = tableToObjectPoint(state, table, source);
+		graph = {
+			tableId: table.id,
+			centerX: objectPoint.top.x,
+			centerY: objectPoint.left.y,
+			objectPoint,
+			loops: [],
+			top: [],
+			bottom: [],
+			left: [],
+			right: []
+		};
+		graphMap.set(table.id, graph);
+	}
+	return graph;
+}
+function placeLoops(graph) {
+	const { rt } = graph.objectPoint;
+	const offsets = loopOffsets(graph);
+	graph.loops.forEach((relationship, index) => {
+		const offset = offsets[index];
+		relationship.start.direction = Direction.top;
+		relationship.start.x = rt.x - offset;
+		relationship.start.y = rt.y;
+		relationship.end.direction = Direction.right;
+		relationship.end.x = rt.x;
+		relationship.end.y = rt.y + offset;
+	});
+}
+function loopOffsets(graph) {
+	const { width, height } = graph.objectPoint;
+	const count = graph.loops.length;
+	const room = Math.max(0, Math.min(width, height) - 6);
+	const first = Math.min(SELF_CORNER_OFFSET, room);
+	const stride = count > 1 ? Math.min(SELF_CORNER_STRIDE, (room - first) / (count - 1)) : 0;
+	return graph.loops.map((_, index) => first + index * stride);
+}
+function selfReserve(graph) {
+	const offsets = loopOffsets(graph);
+	if (!offsets.length) return 0;
+	return offsets[offsets.length - 1] + SELF_CLEARANCE;
+}
+function createChangeRelationship({ id, start, end }) {
+	return {
+		id,
+		start: copyAnchor(start),
+		end: copyAnchor(end)
+	};
+}
+function pairIndexes(relationships) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const { id, start, end } of relationships) {
+		const key = pairKey(start.tableId, end.tableId);
+		const group = groups.get(key);
+		if (group) group.push(id);
+		else groups.set(key, [id]);
+	}
+	const indexById = /* @__PURE__ */ new Map();
+	const sizeById = /* @__PURE__ */ new Map();
+	let anyShared = false;
+	for (const group of groups.values()) {
+		if (group.length < 2) continue;
+		anyShared = true;
+		group.sort();
+		group.forEach((id, index) => {
+			indexById.set(id, index);
+			sizeById.set(id, group.length);
+		});
+	}
+	return { tieAt(id, ownTableId, otherTableId) {
+		if (!anyShared) return 0;
+		const index = indexById.get(id) ?? 0;
+		if (ownTableId <= otherTableId) return index;
+		return (sizeById.get(id) ?? 1) - 1 - index;
+	} };
+}
+function pairKey(a, b) {
+	return a < b ? `${a}|${b}` : `${b}|${a}`;
+}
+function normalizeAngle(angle) {
+	const value = angle % TAU;
+	return value < 0 ? value + TAU : value;
+}
+function orderAngle(direction, own, other) {
+	return normalizeAngle(Math.atan2(other.centerY - own.centerY, other.centerX - own.centerX) - SIDE_START_ANGLE[direction]);
+}
+var OUTWARD = {
+	[DirectionName.left]: {
+		x: -1,
+		y: 0
+	},
+	[DirectionName.right]: {
+		x: 1,
+		y: 0
+	},
+	[DirectionName.top]: {
+		x: 0,
+		y: -1
+	},
+	[DirectionName.bottom]: {
+		x: 0,
+		y: 1
+	}
+};
+function stubsFace(start, startSide, end, endSide) {
+	if (startSide === endSide) return false;
+	const a = OUTWARD[startSide];
+	const b = OUTWARD[endSide];
+	const mx = start[startSide].x + a.x * 24;
+	const my = start[startSide].y + a.y * 24;
+	const lx = end[endSide].x + b.x * 24;
+	const ly = end[endSide].y + b.y * 24;
+	return (lx - mx) * a.x + (ly - my) * a.y >= 0 && (mx - lx) * b.x + (my - ly) * b.y >= 0;
+}
+function nearestSides(start, end, accept) {
+	let nearest = accept ? null : [DirectionName.bottom, DirectionName.bottom];
+	let min = accept ? Infinity : euclideanDistance(start.bottom, end.bottom);
+	for (const key of DirectionNameList) for (const key2 of DirectionNameList) {
+		const k = key;
+		const k2 = key2;
+		const distance = euclideanDistance(start[k], end[k2]);
+		if (min <= distance) continue;
+		if (accept && !accept(k, k2)) continue;
+		min = distance;
+		nearest = [k, k2];
+	}
+	return nearest;
+}
+function getAndSetDirection(start, end, relationship, source) {
+	let direction = nearestSides(start, end);
+	const [startSide, endSide] = direction;
+	if (source === "document" && !stubsFace(start, startSide, end, endSide)) direction = nearestSides(start, end, (k, k2) => stubsFace(start, k, end, k2)) ?? direction;
+	const [k, k2] = direction;
+	relationship.start.x = start[k].x;
+	relationship.start.y = start[k].y;
+	relationship.start.direction = directionNameToDirection[k];
+	relationship.end.x = end[k2].x;
+	relationship.end.y = end[k2].y;
+	relationship.end.direction = directionNameToDirection[k2];
+	return direction;
+}
+function placeSide(direction, graph, slotMap) {
+	const entries = graph[direction];
+	if (!entries.length) return;
+	entries.sort((a, b) => a.angle - b.angle || a.tie - b.tie || (a.id < b.id ? -1 : 1));
+	const { objectPoint } = graph;
+	const isX = direction === DirectionName.top || direction === DirectionName.bottom;
+	let low = (isX ? objectPoint.lt.x : objectPoint.lt.y) + 12;
+	let high = (isX ? objectPoint.rb.x : objectPoint.rb.y) - 12;
+	const reserve = selfReserve(graph);
+	if (reserve) {
+		if (direction === DirectionName.top) high -= reserve;
+		else if (direction === DirectionName.right) low += reserve;
+	}
+	const needed = (entries.length - 1) * SQUEEZED_PITCH;
+	if (reserve && high - low < needed) {
+		const edgeLow = isX ? objectPoint.lt.x : objectPoint.lt.y;
+		const edgeHigh = isX ? objectPoint.rb.x : objectPoint.rb.y;
+		if (direction === DirectionName.right) {
+			low = Math.min(edgeLow + reserve, edgeHigh);
+			if (high - low < needed) high = edgeHigh;
+		} else if (direction === DirectionName.top) {
+			high = Math.max(edgeHigh - reserve, edgeLow);
+			if (high - low < needed) low = edgeLow;
+		}
+	}
+	if (high < low) {
+		const middle = (low + high) / 2;
+		low = middle;
+		high = middle;
+	}
+	const available = high - low;
+	const center = (low + high) / 2;
+	const count = entries.length;
+	const pitch = count > 1 ? Math.min(available / (count - 1), 120) : 0;
+	const first = center - pitch * (count - 1) / 2;
+	entries.forEach((entry, index) => {
+		const step = WALKS_BACKWARDS[direction] ? count - 1 - index : index;
+		const position = first + step * pitch;
+		if (isX) {
+			entry.point.x = position;
+			entry.point.y = direction === DirectionName.top ? objectPoint.top.y : objectPoint.bottom.y;
+		} else {
+			entry.point.y = position;
+			entry.point.x = direction === DirectionName.left ? objectPoint.left.x : objectPoint.right.x;
+		}
+		const slots = slotMap.get(entry.id);
+		if (slots) slots[entry.isStart ? 0 : 1] = index;
+	});
+}
+//#endregion
+export { relationshipSort };

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

@@ -0,0 +1,46 @@
+import { Direction } from "../../constants/schema.js";
+//#region src/utils/draw-relationship/stub.ts
+function stubFor(slot) {
+	return 24 + slot % 4 * 8;
+}
+function facingGap(start, end) {
+	if (start.tableId === end.tableId) return null;
+	if (start.direction === Direction.right && end.direction === Direction.left) return end.x - start.x;
+	if (start.direction === Direction.left && end.direction === Direction.right) return start.x - end.x;
+	if (start.direction === Direction.bottom && end.direction === Direction.top) return end.y - start.y;
+	if (start.direction === Direction.top && end.direction === Direction.bottom) return start.y - end.y;
+	return null;
+}
+function clampStub(stub, gap) {
+	if (gap === null || gap <= 0) return stub;
+	return Math.max(24, Math.min(stub, gap / 2 - 1));
+}
+function isHorizontal(direction) {
+	return direction === Direction.left || direction === Direction.right;
+}
+function outwardSign(direction) {
+	return direction === Direction.right || direction === Direction.bottom ? 1 : -1;
+}
+function offsetFrom(point, direction, distance) {
+	const sign = outwardSign(direction);
+	return isHorizontal(direction) ? {
+		x: point.x + sign * distance,
+		y: point.y
+	} : {
+		x: point.x,
+		y: point.y + sign * distance
+	};
+}
+function stubEnds({ start, end }, [startSlot, endSlot]) {
+	const gap = facingGap(start, end);
+	const startStub = clampStub(stubFor(startSlot), gap);
+	const endStub = clampStub(stubFor(endSlot), gap);
+	return {
+		m: offsetFrom(start, start.direction, startStub),
+		l: offsetFrom(end, end.direction, endStub),
+		startStub,
+		endStub
+	};
+}
+//#endregion
+export { clampStub, facingGap, isHorizontal, outwardSign, stubEnds, stubFor };