@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/diagrams/ArchitectureRouter.js

@@ -0,0 +1,348 @@
+// src/charts/diagrams/ArchitectureRouter.ts
+var ArchitectureFlow = /* @__PURE__ */ function(ArchitectureFlow) {
+	ArchitectureFlow["Down"] = "down";
+	ArchitectureFlow["Right"] = "right";
+	ArchitectureFlow["None"] = "none";
+	return ArchitectureFlow;
+}({});
+var CLEAR = 6;
+var STUB = 12;
+var LANE = 22;
+var BEND = 14;
+var OVERLAP = 70;
+var CROSSING = 12;
+var TAKEN = 60;
+var OFF_FLOW = 26;
+var AGAINST_FLOW = 70;
+var EXPANSIONS = 15e4;
+var SKIRT = 5;
+var HUG = 70;
+/** Past these sizes a search costs seconds, so what remains is drawn straight. Only a diagram too dense to read gets here. */
+var MAX_GRID = 1e6;
+var BUDGET = 2e8;
+var STEPS = [
+	[1, 0],
+	[0, 1],
+	[-1, 0],
+	[0, -1]
+];
+/** Which way a port leaves each face: right, bottom, left, top. */
+var FACES = [
+	0,
+	1,
+	2,
+	3
+];
+var SPREAD = 8;
+var unique = (values) => [...new Set(values.map((value) => Math.round(value)))].sort((a, b) => a - b);
+/**
+* Orthogonal connector routing around rectangular obstacles (Wybrow, Marriott and Stuckey, 2009):
+* A* over a grid drawn from the obstacles' edges, costing length, bends, overlaps and crossings.
+*/
+var ArchitectureRouter = class ArchitectureRouter {
+	#xs;
+	#ys;
+	#across;
+	#along;
+	#hugAcross;
+	#hugAlong;
+	#spent = 0;
+	#taken = /* @__PURE__ */ new Map();
+	#options;
+	static route(requests, options) {
+		return new ArchitectureRouter(options).#all(requests);
+	}
+	constructor(options) {
+		this.#options = options;
+		const { rects, bounds } = options;
+		const lines = (start, size) => unique(rects.flatMap((rect) => {
+			const low = rect[start], high = low + rect[size];
+			return [
+				low - LANE,
+				low - STUB,
+				high + STUB,
+				high + LANE,
+				...ArchitectureRouter.#stops(rect[size]).map((at) => low + at)
+			];
+		})).filter((line) => !bounds || line >= bounds[start] && line <= bounds[start] + bounds[size]);
+		this.#xs = lines("x", "width");
+		this.#ys = lines("y", "height");
+		const nodes = this.#xs.length * this.#ys.length;
+		this.#spent = nodes > MAX_GRID ? BUDGET : 0;
+		const room = nodes > MAX_GRID ? 0 : nodes;
+		this.#across = new Uint8Array(room);
+		this.#along = new Uint8Array(room);
+		this.#hugAcross = new Uint8Array(room);
+		this.#hugAlong = new Uint8Array(room);
+		if (room) for (const rect of options.skirt ?? []) this.#mark(rect);
+	}
+	/** Flags grid runs that lie along an edge of `rect`. */
+	#mark(rect) {
+		const xs = this.#xs, ys = this.#ys, nx = xs.length;
+		const near = (value, a, b) => Math.abs(value - a) <= SKIRT || Math.abs(value - b) <= SKIRT;
+		const within = (value, low, size) => value >= low - SKIRT && value <= low + size + SKIRT;
+		ys.forEach((y, j) => xs.forEach((x, i) => {
+			if (near(x, rect.x, rect.x + rect.width) && within(y, rect.y, rect.height)) this.#hugAlong[j * nx + i] = 1;
+			if (near(y, rect.y, rect.y + rect.height) && within(x, rect.x, rect.width)) this.#hugAcross[j * nx + i] = 1;
+		}));
+	}
+	/** Ports along a face of `length`: always the middle, then outward as room allows. */
+	static #stops(length) {
+		const count = length >= 150 ? 5 : length >= 36 ? 3 : 1;
+		return Array.from({ length: count }, (_, i) => Math.round(length * (i + 1) / (count + 1)));
+	}
+	#all(requests) {
+		const out = new Array(requests.length);
+		const pairs = /* @__PURE__ */ new Map();
+		const pair = (request) => [ArchitectureRouter.#mid(request.from), ArchitectureRouter.#mid(request.to)].map((at) => `${at.x},${at.y}`).sort().join(">");
+		requests.forEach((request, i) => pairs.set(pair(request), [...pairs.get(pair(request)) ?? [], i]));
+		const pending = [];
+		requests.forEach((request, i) => {
+			const twins = pairs.get(pair(request)), shift = (twins.indexOf(i) - (twins.length - 1) / 2) * SPREAD;
+			const line = this.#options.direct ? ArchitectureRouter.#straight(request, shift) : null;
+			if (line && !request.blocks.some((rect) => rect !== request.from && rect !== request.to && ArchitectureRouter.#hits(line[0], line[1], rect))) out[i] = line;
+			else pending.push(i);
+		});
+		const span = (i) => {
+			const a = ArchitectureRouter.#mid(requests[i].from), b = ArchitectureRouter.#mid(requests[i].to);
+			return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+		};
+		for (const i of pending.sort((a, b) => span(a) - span(b) || a - b)) out[i] = this.#search(requests[i]) ?? ArchitectureRouter.#straight(requests[i], 0);
+		return out;
+	}
+	static #mid(rect) {
+		return {
+			x: rect.x + rect.width / 2,
+			y: rect.y + rect.height / 2
+		};
+	}
+	/** Where the line from inside `rect` towards `toward` leaves it. */
+	static #edge(from, toward, rect) {
+		const dx = toward.x - from.x, dy = toward.y - from.y;
+		const t = Math.min(dx ? Math.max((rect.x - from.x) / dx, (rect.x + rect.width - from.x) / dx) : Infinity, dy ? Math.max((rect.y - from.y) / dy, (rect.y + rect.height - from.y) / dy) : Infinity);
+		return Number.isFinite(t) ? {
+			x: from.x + dx * t,
+			y: from.y + dy * t
+		} : from;
+	}
+	static #straight({ from, to }, shift) {
+		const a = ArchitectureRouter.#mid(from), b = ArchitectureRouter.#mid(to);
+		const length = Math.hypot(b.x - a.x, b.y - a.y) || 1;
+		const nudge = {
+			x: -(b.y - a.y) / length * shift,
+			y: (b.x - a.x) / length * shift
+		};
+		const start = {
+			x: a.x + nudge.x,
+			y: a.y + nudge.y
+		}, end = {
+			x: b.x + nudge.x,
+			y: b.y + nudge.y
+		};
+		return [ArchitectureRouter.#edge(start, end, from), ArchitectureRouter.#edge(end, start, to)];
+	}
+	/** Liang-Barsky clip of a segment against `rect` grown by the clearance. */
+	static #hits(a, b, rect) {
+		let low = 0, high = 1;
+		const dx = b.x - a.x, dy = b.y - a.y;
+		const sides = [
+			[-dx, a.x - rect.x + CLEAR],
+			[dx, rect.x + rect.width + CLEAR - a.x],
+			[-dy, a.y - rect.y + CLEAR],
+			[dy, rect.y + rect.height + CLEAR - a.y]
+		];
+		for (const [p, q] of sides) {
+			if (p === 0) {
+				if (q < 0) return false;
+				continue;
+			}
+			const t = q / p;
+			if (p < 0) low = Math.max(low, t);
+			else high = Math.min(high, t);
+			if (low > high) return false;
+		}
+		return true;
+	}
+	#node(x, y) {
+		const i = this.#xs.indexOf(Math.round(x)), j = this.#ys.indexOf(Math.round(y));
+		return i < 0 || j < 0 ? -1 : j * this.#xs.length + i;
+	}
+	/** Each face offers its stops; the flow makes lines prefer to leave forward and arrive from behind. */
+	#ports(rect, leaving, flow) {
+		const forward = flow === "down" ? 1 : 0;
+		return FACES.flatMap((face) => {
+			const [dx, dy] = STEPS[face], along = dx !== 0;
+			const stops = ArchitectureRouter.#stops(along ? rect.height : rect.width);
+			const facing = flow === "none" ? 0 : face === (leaving ? forward : forward + 2) ? 0 : face === (leaving ? forward + 2 : forward) ? AGAINST_FLOW : OFF_FLOW;
+			return stops.flatMap((stop) => {
+				const x = Math.round(along ? dx > 0 ? rect.x + rect.width : rect.x : rect.x + stop);
+				const y = Math.round(along ? rect.y + stop : dy > 0 ? rect.y + rect.height : rect.y);
+				const node = this.#node(x + dx * STUB, y + dy * STUB);
+				if (node < 0) return [];
+				const centre = Math.abs(stop - (along ? rect.height : rect.width) / 2) * .15;
+				return [{
+					point: {
+						x,
+						y
+					},
+					node,
+					dir: leaving ? face : (face + 2) % 4,
+					cost: facing + centre + (this.#taken.get(`${x},${y}`) ?? 0) * TAKEN
+				}];
+			});
+		});
+	}
+	#blocked(rects) {
+		const xs = this.#xs, ys = this.#ys, blocked = new Uint8Array(xs.length * ys.length);
+		for (const rect of rects) for (let j = 0; j < ys.length; j++) {
+			if (ys[j] <= rect.y - CLEAR || ys[j] >= rect.y + rect.height + CLEAR) continue;
+			for (let i = 0; i < xs.length; i++) if (xs[i] > rect.x - CLEAR && xs[i] < rect.x + rect.width + CLEAR) blocked[j * xs.length + i] = 1;
+		}
+		return blocked;
+	}
+	#search(request) {
+		if (this.#spent >= BUDGET) return null;
+		const xs = this.#xs, ys = this.#ys, nx = xs.length, ny = ys.length, count = nx * ny;
+		this.#spent += count;
+		const blocked = this.#blocked([
+			...request.blocks,
+			request.from,
+			request.to
+		]), flow = request.flow ?? this.#options.flow;
+		const dist = new Float64Array(count * 4).fill(Infinity), prev = new Int32Array(count * 4).fill(-1);
+		const seeds = this.#ports(request.from, true, flow).filter((port) => !blocked[port.node]);
+		const goals = /* @__PURE__ */ new Map();
+		for (const port of this.#ports(request.to, false, flow)) if (!blocked[port.node]) goals.set(port.node, [...goals.get(port.node) ?? [], port]);
+		if (!seeds.length || !goals.size) return null;
+		const { to } = request;
+		const estimate = (node) => {
+			const x = xs[node % nx], y = ys[Math.floor(node / nx)];
+			return Math.max(to.x - x, 0, x - to.x - to.width) + Math.max(to.y - y, 0, y - to.y - to.height);
+		};
+		const heap = new MinHeap();
+		const starts = /* @__PURE__ */ new Map();
+		for (const port of seeds) {
+			const state = port.node * 4 + port.dir;
+			if (port.cost >= dist[state]) continue;
+			dist[state] = port.cost;
+			starts.set(state, port);
+			heap.push(port.cost + estimate(port.node), state);
+		}
+		let best = Infinity, end = -1, finish = null, steps = 0;
+		while (heap.size && steps++ < EXPANSIONS) {
+			const { key, value: state } = heap.pop();
+			if (key >= best) break;
+			const node = state >> 2, dir = state & 3, cost = dist[state];
+			if (key - estimate(node) > cost + 1e-6) continue;
+			for (const goal of goals.get(node) ?? []) {
+				const total = cost + goal.cost + (dir === goal.dir ? 0 : BEND);
+				if (total < best) {
+					best = total;
+					end = state;
+					finish = goal;
+				}
+			}
+			const i = node % nx, j = Math.floor(node / nx);
+			for (let turn = 0; turn < 4; turn++) {
+				if (turn === (dir + 2) % 4) continue;
+				const a = i + STEPS[turn][0], b = j + STEPS[turn][1];
+				if (a < 0 || b < 0 || a >= nx || b >= ny) continue;
+				const next = b * nx + a;
+				if (blocked[next]) continue;
+				const step = cost + Math.abs(xs[a] - xs[i]) + Math.abs(ys[b] - ys[j]) + (turn === dir ? 0 : BEND) + this.#penalty(node, next, a, b, turn);
+				const target = next * 4 + turn;
+				if (step >= dist[target]) continue;
+				dist[target] = step;
+				prev[target] = state;
+				heap.push(step + estimate(next), target);
+			}
+		}
+		if (end < 0) return null;
+		return this.#commit(end, prev, starts, finish);
+	}
+	#penalty(node, next, a, b, turn) {
+		const nx = this.#xs.length, flat = turn % 2 === 0;
+		const shared = (flat ? this.#across : this.#along)[Math.min(node, next)] ? OVERLAP : 0;
+		const crossing = flat ? this.#along[next] || b > 0 && this.#along[next - nx] : this.#across[next] || a > 0 && this.#across[next - 1];
+		const hug = flat ? this.#hugAcross : this.#hugAlong;
+		return shared + (crossing ? CROSSING : 0) + (hug[node] && hug[next] ? HUG : 0);
+	}
+	#commit(end, prev, starts, finish) {
+		const nx = this.#xs.length;
+		const nodes = [];
+		let state = end;
+		for (;;) {
+			nodes.unshift(state >> 2);
+			if (prev[state] === -1) break;
+			state = prev[state];
+		}
+		const start = starts.get(state);
+		nodes.forEach((node, i) => {
+			if (!i) return;
+			const low = Math.min(node, nodes[i - 1]);
+			(Math.abs(node - nodes[i - 1]) === 1 ? this.#across : this.#along)[low] = 1;
+		});
+		for (const { x, y } of [start.point, finish.point]) this.#taken.set(`${x},${y}`, (this.#taken.get(`${x},${y}`) ?? 0) + 1);
+		const points = [
+			start.point,
+			...nodes.map((node) => ({
+				x: this.#xs[node % nx],
+				y: this.#ys[Math.floor(node / nx)]
+			})),
+			finish.point
+		];
+		return points.filter((at, i) => {
+			const before = points[i - 1], after = points[i + 1];
+			if (!before || !after) return true;
+			return !(before.x === at.x && at.x === after.x || before.y === at.y && at.y === after.y);
+		});
+	}
+};
+/** Binary heap of number keys, for the search frontier. */
+var MinHeap = class {
+	#keys = [];
+	#values = [];
+	get size() {
+		return this.#keys.length;
+	}
+	push(key, value) {
+		const keys = this.#keys, values = this.#values;
+		let i = keys.length;
+		keys.push(key);
+		values.push(value);
+		while (i > 0) {
+			const up = i - 1 >> 1;
+			if (keys[up] <= key) break;
+			keys[i] = keys[up];
+			values[i] = values[up];
+			i = up;
+		}
+		keys[i] = key;
+		values[i] = value;
+	}
+	pop() {
+		const keys = this.#keys, values = this.#values;
+		const top = {
+			key: keys[0],
+			value: values[0]
+		};
+		const key = keys.pop(), value = values.pop();
+		const n = keys.length;
+		if (n) {
+			let i = 0;
+			for (;;) {
+				let child = 2 * i + 1;
+				if (child >= n) break;
+				if (child + 1 < n && keys[child + 1] < keys[child]) child++;
+				if (keys[child] >= key) break;
+				keys[i] = keys[child];
+				values[i] = values[child];
+				i = child;
+			}
+			keys[i] = key;
+			values[i] = value;
+		}
+		return top;
+	}
+};
+export { ArchitectureFlow, ArchitectureRouter };

package/dist/charts/diagrams/ArchitectureSamples.js

@@ -0,0 +1,312 @@
+import { SampleData } from "../../data/SampleData.js";
+import { ArchitectureKind, NetworkDeviceKind } from "./architectureEnums.js";
+// src/charts/diagrams/ArchitectureSamples.ts
+var optional = (seed) => +SampleData.categories(seed, 1, 1)[0].value % 2 === 0;
+/** Synthetic examples for the diagrams: a fictional parcel carrier and a fictional office network. Nothing here describes a real system. */
+var ArchitectureSamples = class {
+	static parcelTracking(seed) {
+		const nodes = [
+			{
+				id: "carrier",
+				name: "Parcel carrier",
+				kind: ArchitectureKind.Boundary
+			},
+			{
+				id: "customer",
+				name: "Customer",
+				kind: ArchitectureKind.Person,
+				description: "Follows a parcel from order to doorstep."
+			},
+			{
+				id: "support",
+				name: "Support agent",
+				kind: ArchitectureKind.Person,
+				description: "Answers questions about late parcels."
+			},
+			{
+				id: "tracking",
+				name: "Tracking system",
+				kind: ArchitectureKind.System,
+				parent: "carrier",
+				description: "Shows where every parcel is."
+			},
+			{
+				id: "billing",
+				name: "Billing system",
+				kind: ArchitectureKind.System,
+				parent: "carrier",
+				description: "Invoices business customers."
+			},
+			{
+				id: "web",
+				name: "Web app",
+				kind: ArchitectureKind.Container,
+				parent: "tracking",
+				technology: "React",
+				description: "Tracking pages and the support console."
+			},
+			{
+				id: "api",
+				name: "Tracking API",
+				kind: ArchitectureKind.Container,
+				parent: "tracking",
+				technology: "Go",
+				description: "Serves parcel status over HTTPS."
+			},
+			{
+				id: "store",
+				name: "Parcel store",
+				kind: ArchitectureKind.Database,
+				parent: "tracking",
+				technology: "PostgreSQL",
+				description: "Holds parcels and scan events."
+			},
+			{
+				id: "routes",
+				name: "Parcel routes",
+				kind: ArchitectureKind.Component,
+				parent: "api",
+				technology: "chi",
+				description: "Handles lookups by tracking number."
+			},
+			{
+				id: "scans",
+				name: "Scan ingest",
+				kind: ArchitectureKind.Component,
+				parent: "api",
+				technology: "Go",
+				description: "Validates scans sent by carriers."
+			},
+			{
+				id: "notify",
+				name: "Notifier",
+				kind: ArchitectureKind.Component,
+				parent: "api",
+				technology: "Go",
+				description: "Emails customers when status changes."
+			},
+			{
+				id: "mail",
+				name: "Email service",
+				kind: ArchitectureKind.System,
+				external: true,
+				description: "Delivers transactional email."
+			},
+			{
+				id: "partner",
+				name: "Partner depots",
+				kind: ArchitectureKind.System,
+				external: true,
+				description: "Send a scan at every handover."
+			}
+		];
+		const links = [
+			{
+				source: "customer",
+				target: "web",
+				label: "Tracks parcels",
+				technology: "HTTPS"
+			},
+			{
+				source: "support",
+				target: "web",
+				label: "Looks up parcels",
+				technology: "HTTPS"
+			},
+			{
+				source: "web",
+				target: "routes",
+				label: "Requests status",
+				technology: "JSON/HTTPS"
+			},
+			{
+				source: "routes",
+				target: "store",
+				label: "Reads parcels",
+				technology: "SQL"
+			},
+			{
+				source: "partner",
+				target: "scans",
+				label: "Posts scans",
+				technology: "Webhook"
+			},
+			{
+				source: "scans",
+				target: "store",
+				label: "Writes events",
+				technology: "SQL"
+			},
+			{
+				source: "scans",
+				target: "notify",
+				label: "Signals a change"
+			},
+			{
+				source: "notify",
+				target: "mail",
+				label: "Sends email",
+				technology: "SMTP"
+			},
+			{
+				source: "customer",
+				target: "billing",
+				label: "Pays invoices",
+				technology: "HTTPS"
+			}
+		];
+		if (optional(seed)) {
+			nodes.push({
+				id: "reports",
+				name: "Reporting job",
+				kind: ArchitectureKind.Container,
+				parent: "tracking",
+				technology: "Python",
+				description: "Builds nightly delivery reports."
+			});
+			links.push({
+				source: "reports",
+				target: "store",
+				label: "Reads events",
+				technology: "SQL"
+			});
+		}
+		return {
+			nodes,
+			links
+		};
+	}
+	static officeNetwork(seed) {
+		const nodes = [
+			{
+				id: "wan",
+				name: "Internet",
+				kind: NetworkDeviceKind.Cloud
+			},
+			{
+				id: "edge-a",
+				name: "edge-a",
+				kind: NetworkDeviceKind.Router,
+				address: "192.0.2.1"
+			},
+			{
+				id: "edge-b",
+				name: "edge-b",
+				kind: NetworkDeviceKind.Router,
+				address: "192.0.2.2"
+			},
+			{
+				id: "core-a",
+				name: "core-a",
+				kind: NetworkDeviceKind.Switch,
+				address: "10.0.0.2"
+			},
+			{
+				id: "core-b",
+				name: "core-b",
+				kind: NetworkDeviceKind.Switch,
+				address: "10.0.0.3"
+			},
+			{
+				id: "access",
+				name: "access-1",
+				kind: NetworkDeviceKind.Switch,
+				address: "10.0.1.2"
+			},
+			{
+				id: "web",
+				name: "web-1",
+				kind: NetworkDeviceKind.Server,
+				address: "10.0.10.11"
+			},
+			{
+				id: "app",
+				name: "app-1",
+				kind: NetworkDeviceKind.Server,
+				address: "10.0.10.21"
+			},
+			{
+				id: "files",
+				name: "files-1",
+				kind: NetworkDeviceKind.Server,
+				address: "10.0.20.5"
+			},
+			{
+				id: "db",
+				name: "db-1",
+				kind: NetworkDeviceKind.Database,
+				address: "10.0.30.5"
+			}
+		];
+		const links = [
+			{
+				source: "wan",
+				target: "edge-a",
+				label: "1 Gbps"
+			},
+			{
+				source: "wan",
+				target: "edge-b",
+				label: "1 Gbps"
+			},
+			{
+				source: "edge-a",
+				target: "core-a",
+				label: "10 Gbps"
+			},
+			{
+				source: "edge-b",
+				target: "core-b",
+				label: "10 Gbps"
+			},
+			{
+				source: "core-a",
+				target: "core-b",
+				label: "LAG"
+			},
+			{
+				source: "core-a",
+				target: "web",
+				label: "VLAN 10"
+			},
+			{
+				source: "core-a",
+				target: "app",
+				label: "VLAN 10"
+			},
+			{
+				source: "core-b",
+				target: "access",
+				label: "10 Gbps"
+			},
+			{
+				source: "access",
+				target: "files",
+				label: "VLAN 20"
+			},
+			{
+				source: "access",
+				target: "db",
+				label: "VLAN 30"
+			}
+		];
+		if (optional(seed)) {
+			nodes.push({
+				id: "backup",
+				name: "backup-1",
+				kind: NetworkDeviceKind.Server,
+				address: "10.0.20.9"
+			});
+			links.push({
+				source: "access",
+				target: "backup",
+				label: "VLAN 20"
+			});
+		}
+		return {
+			nodes,
+			links
+		};
+	}
+};
+export { ArchitectureSamples };