@stuly/anode 0.1.0

package/dist/core/context.js

@@ -0,0 +1,863 @@
+import { Entity, Group, Link, LinkKind, Socket, SocketKind, Vec2 } from "./elements.js";
+import { QuadTree, Rect } from "./layout.js";
+import { HistoryManager } from "./history.js";
+
+//#region src/core/context.ts
+var Context = class {
+	eid = 0;
+	lid = 0;
+	sid = 0;
+	gid = 0;
+	freeEids = [];
+	freeLids = [];
+	freeSids = [];
+	freeGids = [];
+	callbackIds = 0;
+	freeCallbackIds = [];
+	entityCreateCallbacks = /* @__PURE__ */ new Map();
+	entityDropCallbacks = /* @__PURE__ */ new Map();
+	entityMoveCallbacks = /* @__PURE__ */ new Map();
+	socketMoveCallbacks = /* @__PURE__ */ new Map();
+	socketValueCallbacks = /* @__PURE__ */ new Map();
+	linkCreateCallbacks = /* @__PURE__ */ new Map();
+	linkDropCallbacks = /* @__PURE__ */ new Map();
+	linkUpdateCallbacks = /* @__PURE__ */ new Map();
+	socketCreateCallbacks = /* @__PURE__ */ new Map();
+	socketDropCallbacks = /* @__PURE__ */ new Map();
+	groupCreateCallbacks = /* @__PURE__ */ new Map();
+	groupDropCallbacks = /* @__PURE__ */ new Map();
+	bulkChangeCallbacks = /* @__PURE__ */ new Map();
+	entities = /* @__PURE__ */ new Map();
+	links = /* @__PURE__ */ new Map();
+	sockets = /* @__PURE__ */ new Map();
+	groups = /* @__PURE__ */ new Map();
+	quadTree = new QuadTree(new Rect(-1e5, -1e5, 2e5, 2e5));
+	history = new HistoryManager();
+	isApplyingHistory = false;
+	currentBatch = null;
+	currentUndoBatch = null;
+	isBatchingQuadTree = false;
+	getNextEid() {
+		return this.freeEids.pop() ?? this.eid++;
+	}
+	getNextLid() {
+		return this.freeLids.pop() ?? this.lid++;
+	}
+	getNextSid() {
+		return this.freeSids.pop() ?? this.sid++;
+	}
+	getNextGid() {
+		return this.freeGids.pop() ?? this.gid++;
+	}
+	getNextCallbackHandle() {
+		return this.freeCallbackIds.pop() ?? this.callbackIds++;
+	}
+	setupEntity(entity) {
+		entity.onMove((pos) => {
+			this.updateQuadTree();
+			for (const cb of this.entityMoveCallbacks.values()) try {
+				cb(entity, this.getWorldPosition(entity.id));
+			} catch (err) {
+				console.error(err);
+			}
+		});
+	}
+	notifyBulkChange() {
+		for (const cb of this.bulkChangeCallbacks.values()) try {
+			cb();
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	registerBulkChangeListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.bulkChangeCallbacks.set(handle, cb);
+		return handle;
+	}
+	setSocketValue(socketId, value) {
+		const socket = this.sockets.get(socketId);
+		if (!socket) return;
+		socket.value = value;
+		for (const cb of this.socketValueCallbacks.values()) cb(socket, value);
+		if (socket.kind === SocketKind.OUTPUT) {
+			for (const link of this.links.values()) if (link.from === socketId) this.setSocketValue(link.to, value);
+		}
+	}
+	registerSocketValueListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.socketValueCallbacks.set(handle, cb);
+		return handle;
+	}
+	record(doActions, undoActions, label) {
+		if (this.isApplyingHistory) return;
+		if (this.currentBatch) return;
+		const das = Array.isArray(doActions) ? doActions : [doActions];
+		const uas = Array.isArray(undoActions) ? undoActions : [undoActions];
+		this.history.push({
+			do: das,
+			undo: uas,
+			label: label ?? "Action",
+			timestamp: Date.now()
+		});
+	}
+	batch(fn, label) {
+		if (this.currentBatch) {
+			fn();
+			return;
+		}
+		const oldApplying = this.isApplyingHistory;
+		const oldBatchingQT = this.isBatchingQuadTree;
+		const beforeState = this.toJSON();
+		try {
+			this.isApplyingHistory = true;
+			this.isBatchingQuadTree = true;
+			fn();
+			this.isBatchingQuadTree = oldBatchingQT;
+			this.updateQuadTree();
+			const afterState = this.toJSON();
+			this.history.push({
+				do: [{
+					type: "FROM_JSON",
+					data: afterState
+				}],
+				undo: [{
+					type: "FROM_JSON",
+					data: beforeState
+				}],
+				label: label ?? "Batch Action",
+				timestamp: Date.now()
+			});
+		} finally {
+			this.isApplyingHistory = oldApplying;
+			this.isBatchingQuadTree = oldBatchingQT;
+		}
+	}
+	undo() {
+		const cmd = this.history.undoStack.pop();
+		if (!cmd) return;
+		this.isApplyingHistory = true;
+		this.isBatchingQuadTree = true;
+		try {
+			for (let i = cmd.undo.length - 1; i >= 0; i--) this.applyAction(cmd.undo[i]);
+			this.isBatchingQuadTree = false;
+			this.updateQuadTree();
+			this.notifyBulkChange();
+			this.history.redoStack.push(cmd);
+		} finally {
+			this.isApplyingHistory = false;
+			this.isBatchingQuadTree = false;
+		}
+	}
+	redo() {
+		const cmd = this.history.redoStack.pop();
+		if (!cmd) return;
+		this.isApplyingHistory = true;
+		this.isBatchingQuadTree = true;
+		try {
+			for (const action of cmd.do) this.applyAction(action);
+			this.isBatchingQuadTree = false;
+			this.updateQuadTree();
+			this.notifyBulkChange();
+			this.history.undoStack.push(cmd);
+		} finally {
+			this.isApplyingHistory = false;
+			this.isBatchingQuadTree = false;
+		}
+	}
+	applyAction(action) {
+		switch (action.type) {
+			case "FROM_JSON":
+				this.fromJSON(action.data);
+				break;
+			case "MOVE_ENTITY": {
+				const entity = this.entities.get(action.id);
+				if (entity) {
+					entity.position.set(action.to.x, action.to.y);
+					for (const cb of this.entityMoveCallbacks.values()) cb(entity, this.getWorldPosition(entity.id));
+					this.updateQuadTree();
+				}
+				break;
+			}
+			case "MOVE_GROUP": {
+				const group = this.groups.get(action.id);
+				if (group) {
+					const dx = action.to.x - action.from.x;
+					const dy = action.to.y - action.from.y;
+					const oldApplying = this.isApplyingHistory;
+					this.isApplyingHistory = true;
+					try {
+						this.moveGroup(group, dx, dy);
+					} finally {
+						this.isApplyingHistory = oldApplying;
+					}
+				}
+				break;
+			}
+			case "CREATE_ENTITY": {
+				const entity = new Entity(action.id, action.inner);
+				entity.position.set(action.position.x, action.position.y);
+				this.entities.set(entity.id, entity);
+				this.eid = Math.max(this.eid, entity.id + 1);
+				this.setupEntity(entity);
+				if (action.parentId !== null) this.addToGroup(action.parentId, entity.id);
+				for (const cb of this.entityCreateCallbacks.values()) cb(entity);
+				this.updateQuadTree();
+				break;
+			}
+			case "DROP_ENTITY": {
+				const entity = this.entities.get(action.id);
+				if (entity) {
+					const oldApplying = this.isApplyingHistory;
+					this.isApplyingHistory = true;
+					try {
+						this.dropEntity(entity);
+					} finally {
+						this.isApplyingHistory = oldApplying;
+					}
+				}
+				break;
+			}
+			case "CREATE_LINK": {
+				const from = this.sockets.get(action.from);
+				const to = this.sockets.get(action.to);
+				if (from && to) {
+					const link = new Link(action.id, from.id, to.id, action.kind, action.inner);
+					this.links.set(link.id, link);
+					this.lid = Math.max(this.lid, link.id + 1);
+					for (const cb of this.linkCreateCallbacks.values()) cb(link);
+				}
+				break;
+			}
+			case "DROP_LINK": {
+				const link = this.links.get(action.id);
+				if (link) {
+					const oldApplying = this.isApplyingHistory;
+					this.isApplyingHistory = true;
+					try {
+						this.dropLink(link);
+					} finally {
+						this.isApplyingHistory = oldApplying;
+					}
+				}
+				break;
+			}
+			case "UPDATE_LINK": {
+				const link = this.links.get(action.id);
+				if (link) {
+					link.from = action.from.new;
+					link.to = action.to.new;
+					if (action.waypoints) link.waypoints = action.waypoints.new.map((p) => new Vec2(p.x, p.y));
+					for (const cb of this.linkUpdateCallbacks.values()) cb(link);
+				}
+				break;
+			}
+			case "ADD_TO_GROUP":
+				this.addToGroup(action.groupId, action.entityId);
+				break;
+			case "REMOVE_FROM_GROUP":
+				this.removeFromGroup(action.groupId, action.entityId);
+				break;
+			case "CREATE_SOCKET": {
+				const entity = this.entities.get(action.entityId);
+				if (entity) {
+					const socket = new Socket(action.id, entity.id, action.kind, action.name);
+					socket.offset.set(action.offset.x, action.offset.y);
+					this.sockets.set(socket.id, socket);
+					entity.sockets.set(socket.id, socket);
+					this.sid = Math.max(this.sid, socket.id + 1);
+					for (const cb of this.socketCreateCallbacks.values()) cb(socket);
+				}
+				break;
+			}
+			case "DROP_SOCKET": {
+				const socket = this.sockets.get(action.id);
+				if (socket) {
+					const oldApplying = this.isApplyingHistory;
+					this.isApplyingHistory = true;
+					try {
+						this.dropSocket(socket);
+					} finally {
+						this.isApplyingHistory = oldApplying;
+					}
+				}
+				break;
+			}
+		}
+	}
+	registerEntityCreateListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.entityCreateCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerEntityDropListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.entityDropCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerEntityMoveListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.entityMoveCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerSocketMoveListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.socketMoveCallbacks.set(handle, cb);
+		return handle;
+	}
+	notifySocketMove(socket) {
+		for (const cb of this.socketMoveCallbacks.values()) try {
+			cb(socket);
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	registerLinkCreateListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.linkCreateCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerLinkDropListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.linkDropCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerLinkUpdateListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.linkUpdateCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerSocketCreateListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.socketCreateCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerSocketDropListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.socketDropCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerGroupCreateListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.groupCreateCallbacks.set(handle, cb);
+		return handle;
+	}
+	registerGroupDropListener(cb) {
+		const handle = this.getNextCallbackHandle();
+		this.groupDropCallbacks.set(handle, cb);
+		return handle;
+	}
+	unregisterListener(handle) {
+		if (this.linkCreateCallbacks.delete(handle) || this.linkDropCallbacks.delete(handle) || this.linkUpdateCallbacks.delete(handle) || this.entityCreateCallbacks.delete(handle) || this.entityDropCallbacks.delete(handle) || this.entityMoveCallbacks.delete(handle) || this.socketCreateCallbacks.delete(handle) || this.socketDropCallbacks.delete(handle) || this.socketMoveCallbacks.delete(handle) || this.groupCreateCallbacks.delete(handle) || this.groupDropCallbacks.delete(handle) || this.bulkChangeCallbacks.delete(handle)) {
+			this.freeCallbackIds.push(handle);
+			return true;
+		}
+		return false;
+	}
+	newGroup(name = "") {
+		const group = new Group(this.getNextGid(), name);
+		this.groups.set(group.id, group);
+		for (const cb of this.groupCreateCallbacks.values()) try {
+			cb(group);
+		} catch (err) {
+			console.error(err);
+		}
+		return group;
+	}
+	dropGroup(group) {
+		if (this.groups.delete(group.id)) {
+			if (group.parentId !== null) this.removeGroupFromGroup(group.parentId, group.id);
+			for (const eid of group.entities) {
+				const entity = this.entities.get(eid);
+				if (entity) entity.parentId = null;
+			}
+			for (const gid of group.groups) {
+				const childGroup = this.groups.get(gid);
+				if (childGroup) childGroup.parentId = null;
+			}
+			this.freeGids.push(group.id);
+			for (const cb of this.groupDropCallbacks.values()) try {
+				cb(group);
+			} catch (err) {
+				console.error(err);
+			}
+			this.updateQuadTree();
+		}
+	}
+	getWorldPosition(entityId) {
+		const entity = this.entities.get(entityId);
+		if (!entity) return new Vec2();
+		const pos = entity.position.clone();
+		let currentParentId = entity.parentId;
+		while (currentParentId !== null) {
+			const parent = this.groups.get(currentParentId);
+			if (!parent) break;
+			pos.x += parent.position.x;
+			pos.y += parent.position.y;
+			currentParentId = parent.parentId;
+		}
+		return pos;
+	}
+	getGroupWorldPosition(groupId) {
+		const group = this.groups.get(groupId);
+		if (!group) return new Vec2();
+		const pos = group.position.clone();
+		let currentParentId = group.parentId;
+		while (currentParentId !== null) {
+			const parent = this.groups.get(currentParentId);
+			if (!parent) break;
+			pos.x += parent.position.x;
+			pos.y += parent.position.y;
+			currentParentId = parent.parentId;
+		}
+		return pos;
+	}
+	moveGroup(group, dx, dy) {
+		const oldBatching = this.isBatchingQuadTree;
+		this.isBatchingQuadTree = true;
+		group.position.x += dx;
+		group.position.y += dy;
+		const notifyRecursive = (g) => {
+			for (const eid of g.entities) {
+				const entity = this.entities.get(eid);
+				if (entity) for (const cb of this.entityMoveCallbacks.values()) cb(entity, this.getWorldPosition(eid));
+			}
+			for (const gid of g.groups) {
+				const childGroup = this.groups.get(gid);
+				if (childGroup) notifyRecursive(childGroup);
+			}
+		};
+		try {
+			notifyRecursive(group);
+		} finally {
+			this.isBatchingQuadTree = oldBatching;
+			this.updateQuadTree();
+		}
+	}
+	addToGroup(groupId, entityId) {
+		const group = this.groups.get(groupId);
+		const entity = this.entities.get(entityId);
+		if (group && entity) {
+			if (entity.parentId !== null) this.removeFromGroup(entity.parentId, entityId);
+			group.add(entityId);
+			entity.parentId = groupId;
+			this.updateQuadTree();
+		}
+	}
+	removeFromGroup(groupId, entityId) {
+		const group = this.groups.get(groupId);
+		const entity = this.entities.get(entityId);
+		if (group && entity) {
+			group.remove(entityId);
+			entity.parentId = null;
+			this.updateQuadTree();
+		}
+	}
+	addGroupToGroup(parentGroupId, childGroupId) {
+		const parent = this.groups.get(parentGroupId);
+		const child = this.groups.get(childGroupId);
+		if (parent && child && parentGroupId !== childGroupId) {
+			if (child.parentId !== null) this.removeGroupFromGroup(child.parentId, childGroupId);
+			parent.addGroup(childGroupId);
+			child.parentId = parentGroupId;
+			this.updateQuadTree();
+		}
+	}
+	removeGroupFromGroup(parentGroupId, childGroupId) {
+		const parent = this.groups.get(parentGroupId);
+		const child = this.groups.get(childGroupId);
+		if (parent && child) {
+			parent.removeGroup(childGroupId);
+			child.parentId = null;
+			this.updateQuadTree();
+		}
+	}
+	updateQuadTree() {
+		if (this.isBatchingQuadTree) return;
+		this.quadTree.clear();
+		for (const entity of this.entities.values()) {
+			const entityWorldPos = this.getWorldPosition(entity.id);
+			this.quadTree.insert(entityWorldPos, entity.id);
+			for (const socket of entity.sockets.values()) this.quadTree.insert(new Vec2(entityWorldPos.x + socket.offset.x, entityWorldPos.y + socket.offset.y), entity.id);
+		}
+	}
+	newEntity(inner, forcedId) {
+		const ett = new Entity(forcedId ?? this.getNextEid(), inner);
+		this.entities.set(ett.id, ett);
+		if (forcedId !== void 0) this.eid = Math.max(this.eid, forcedId + 1);
+		this.setupEntity(ett);
+		if (!this.isApplyingHistory) this.record({
+			type: "CREATE_ENTITY",
+			id: ett.id,
+			inner: ett.inner,
+			position: { ...ett.position },
+			parentId: ett.parentId
+		}, {
+			type: "DROP_ENTITY",
+			id: ett.id,
+			inner: ett.inner,
+			position: { ...ett.position },
+			parentId: ett.parentId
+		}, "Create Entity");
+		for (const cb of this.entityCreateCallbacks.values()) try {
+			cb(ett);
+		} catch (err) {
+			console.error(err);
+		}
+		this.updateQuadTree();
+		return ett;
+	}
+	dropEntity(entity) {
+		if (this.entities.has(entity.id)) this.batch(() => {
+			this.record({
+				type: "DROP_ENTITY",
+				id: entity.id,
+				inner: entity.inner,
+				position: { ...entity.position },
+				parentId: entity.parentId
+			}, {
+				type: "CREATE_ENTITY",
+				id: entity.id,
+				inner: entity.inner,
+				position: { ...entity.position },
+				parentId: entity.parentId
+			}, "Drop Entity");
+			if (entity.parentId !== null) this.removeFromGroup(entity.parentId, entity.id);
+			this.entities.delete(entity.id);
+			for (const socket of entity.sockets.values()) this.dropSocket(socket);
+			this.freeEids.push(entity.id);
+			for (const cb of this.entityDropCallbacks.values()) try {
+				cb(entity);
+			} catch (err) {
+				console.error(err);
+			}
+			this.updateQuadTree();
+		}, "Drop Entity");
+	}
+	newSocket(entity, kind, name = "", forcedId) {
+		const socket = new Socket(forcedId ?? this.getNextSid(), entity.id, kind, name);
+		this.sockets.set(socket.id, socket);
+		entity.sockets.set(socket.id, socket);
+		if (forcedId !== void 0) this.sid = Math.max(this.sid, forcedId + 1);
+		if (!this.isApplyingHistory) this.record({
+			type: "CREATE_SOCKET",
+			id: socket.id,
+			entityId: entity.id,
+			kind,
+			name,
+			offset: { ...socket.offset }
+		}, {
+			type: "DROP_SOCKET",
+			id: socket.id,
+			entityId: entity.id,
+			kind,
+			name,
+			offset: { ...socket.offset }
+		}, "Create Socket");
+		for (const cb of this.socketCreateCallbacks.values()) try {
+			cb(socket);
+		} catch (err) {
+			console.error(err);
+		}
+		return socket;
+	}
+	dropSocket(socket) {
+		if (this.sockets.delete(socket.id)) {
+			if (!this.isApplyingHistory) this.record({
+				type: "DROP_SOCKET",
+				id: socket.id,
+				entityId: socket.entityId,
+				kind: socket.kind,
+				name: socket.name,
+				offset: { ...socket.offset }
+			}, {
+				type: "CREATE_SOCKET",
+				id: socket.id,
+				entityId: socket.entityId,
+				kind: socket.kind,
+				name: socket.name,
+				offset: { ...socket.offset }
+			}, "Drop Socket");
+			const entity = this.entities.get(socket.entityId);
+			if (entity) entity.sockets.delete(socket.id);
+			for (const link of this.links.values()) if (link.from === socket.id || link.to === socket.id) this.dropLink(link);
+			this.freeSids.push(socket.id);
+			for (const cb of this.socketDropCallbacks.values()) try {
+				cb(socket);
+			} catch (err) {
+				console.error(err);
+			}
+		}
+	}
+	newLink(from, to, kind = LinkKind.BEZIER, forcedId, inner = {}) {
+		if (!this.canLink(from, to)) return null;
+		const link = new Link(forcedId ?? this.getNextLid(), from.id, to.id, kind, inner);
+		this.links.set(link.id, link);
+		if (forcedId !== void 0) this.lid = Math.max(this.lid, forcedId + 1);
+		if (!this.isApplyingHistory) this.record({
+			type: "CREATE_LINK",
+			id: link.id,
+			from: link.from,
+			to: link.to,
+			kind: link.kind,
+			inner: link.inner
+		}, {
+			type: "DROP_LINK",
+			id: link.id,
+			from: link.from,
+			to: link.to,
+			kind: link.kind,
+			inner: link.inner
+		}, "Create Link");
+		if (from.value !== null) this.setSocketValue(to.id, from.value);
+		for (const cb of this.linkCreateCallbacks.values()) try {
+			cb(link);
+		} catch (err) {
+			console.error(err);
+		}
+		return link;
+	}
+	updateLink(link, fromId, toId) {
+		const oldFrom = link.from;
+		const oldTo = link.to;
+		const newFrom = fromId ?? oldFrom;
+		const newTo = toId ?? oldTo;
+		if (oldFrom === newFrom && oldTo === newTo) return;
+		const fromSocket = this.sockets.get(newFrom);
+		const toSocket = this.sockets.get(newTo);
+		if (!fromSocket || !toSocket || !this.canLink(fromSocket, toSocket)) return;
+		const oldWaypoints = link.waypoints.map((p) => ({
+			x: p.x,
+			y: p.y
+		}));
+		if (!this.isApplyingHistory) this.record({
+			type: "UPDATE_LINK",
+			id: link.id,
+			from: {
+				old: oldFrom,
+				new: newFrom
+			},
+			to: {
+				old: oldTo,
+				new: newTo
+			},
+			waypoints: {
+				old: oldWaypoints,
+				new: oldWaypoints
+			}
+		}, {
+			type: "UPDATE_LINK",
+			id: link.id,
+			from: {
+				old: newFrom,
+				new: oldFrom
+			},
+			to: {
+				old: newTo,
+				new: oldTo
+			},
+			waypoints: {
+				old: oldWaypoints,
+				new: oldWaypoints
+			}
+		}, "Update Link");
+		link.from = newFrom;
+		link.to = newTo;
+		for (const cb of this.linkUpdateCallbacks.values()) try {
+			cb(link);
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	setLinkWaypoints(link, waypoints) {
+		const oldWaypoints = link.waypoints.map((p) => ({
+			x: p.x,
+			y: p.y
+		}));
+		const newWaypoints = waypoints.map((p) => ({
+			x: p.x,
+			y: p.y
+		}));
+		if (!this.isApplyingHistory) this.record({
+			type: "UPDATE_LINK",
+			id: link.id,
+			from: {
+				old: link.from,
+				new: link.from
+			},
+			to: {
+				old: link.to,
+				new: link.to
+			},
+			waypoints: {
+				old: oldWaypoints,
+				new: newWaypoints
+			}
+		}, {
+			type: "UPDATE_LINK",
+			id: link.id,
+			from: {
+				old: link.from,
+				new: link.from
+			},
+			to: {
+				old: link.to,
+				new: link.to
+			},
+			waypoints: {
+				old: newWaypoints,
+				new: oldWaypoints
+			}
+		}, "Update Link Routing");
+		link.waypoints = waypoints.map((p) => p.clone());
+		for (const cb of this.linkUpdateCallbacks.values()) try {
+			cb(link);
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	canLink(from, to) {
+		if (from.id === to.id) return false;
+		if (from.entityId === to.entityId) return false;
+		if (from.kind === to.kind) return false;
+		for (const link of this.links.values()) if (link.from === from.id && link.to === to.id || link.from === to.id && link.to === from.id) return false;
+		if (this.detectCycle(from, to)) return false;
+		return true;
+	}
+	detectCycle(from, to) {
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [to.entityId];
+		while (stack.length > 0) {
+			const currentEntityId = stack.pop();
+			if (currentEntityId === from.entityId) return true;
+			if (visited.has(currentEntityId)) continue;
+			visited.add(currentEntityId);
+			const entity = this.entities.get(currentEntityId);
+			if (!entity) continue;
+			for (const socket of entity.sockets.values()) if (socket.kind === SocketKind.OUTPUT) {
+				for (const link of this.links.values()) if (link.from === socket.id) {
+					const targetSocket = this.sockets.get(link.to);
+					if (targetSocket) stack.push(targetSocket.entityId);
+				}
+			}
+		}
+		return false;
+	}
+	dropLink(link) {
+		if (this.links.delete(link.id)) {
+			if (!this.isApplyingHistory) this.record({
+				type: "DROP_LINK",
+				id: link.id,
+				from: link.from,
+				to: link.to,
+				kind: link.kind,
+				inner: link.inner
+			}, {
+				type: "CREATE_LINK",
+				id: link.id,
+				from: link.from,
+				to: link.to,
+				kind: link.kind,
+				inner: link.inner
+			}, "Drop Link");
+			this.freeLids.push(link.id);
+			for (const cb of this.linkDropCallbacks.values()) try {
+				cb(link);
+			} catch (err) {
+				console.error(err);
+			}
+		}
+	}
+	toJSON() {
+		return {
+			entities: Array.from(this.entities.values()).map((e) => ({
+				id: e.id,
+				position: {
+					x: e.position.x,
+					y: e.position.y
+				},
+				inner: e.inner,
+				parentId: e.parentId,
+				sockets: Array.from(e.sockets.values()).map((s) => ({
+					id: s.id,
+					kind: s.kind,
+					name: s.name,
+					offset: {
+						x: s.offset.x,
+						y: s.offset.y
+					}
+				}))
+			})),
+			links: Array.from(this.links.values()).map((l) => ({
+				id: l.id,
+				from: l.from,
+				to: l.to,
+				kind: l.kind,
+				waypoints: l.waypoints.map((p) => ({
+					x: p.x,
+					y: p.y
+				})),
+				inner: l.inner
+			})),
+			groups: Array.from(this.groups.values()).map((g) => ({
+				id: g.id,
+				name: g.name,
+				entities: Array.from(g.entities),
+				groups: Array.from(g.groups),
+				position: {
+					x: g.position.x,
+					y: g.position.y
+				},
+				parentId: g.parentId
+			}))
+		};
+	}
+	fromJSON(data) {
+		this.entities.clear();
+		this.links.clear();
+		this.sockets.clear();
+		this.groups.clear();
+		this.eid = 0;
+		this.lid = 0;
+		this.sid = 0;
+		this.gid = 0;
+		this.freeEids = [];
+		this.freeLids = [];
+		this.freeSids = [];
+		this.freeGids = [];
+		for (const eData of data.entities) {
+			const entity = new Entity(eData.id, eData.inner);
+			entity.position.set(eData.position.x, eData.position.y);
+			entity.parentId = eData.parentId;
+			this.entities.set(entity.id, entity);
+			this.eid = Math.max(this.eid, entity.id + 1);
+			this.setupEntity(entity);
+			for (const sData of eData.sockets) {
+				const socket = new Socket(sData.id, entity.id, sData.kind, sData.name);
+				socket.offset.set(sData.offset.x, sData.offset.y);
+				this.sockets.set(socket.id, socket);
+				entity.sockets.set(socket.id, socket);
+				this.sid = Math.max(this.sid, socket.id + 1);
+			}
+		}
+		for (const lData of data.links) {
+			const link = new Link(lData.id, lData.from, lData.to, lData.kind, lData.inner);
+			if (lData.waypoints) link.waypoints = lData.waypoints.map((p) => new Vec2(p.x, p.y));
+			this.links.set(link.id, link);
+			this.lid = Math.max(this.lid, link.id + 1);
+		}
+		if (data.groups) for (const gData of data.groups) {
+			const group = new Group(gData.id, gData.name);
+			group.position.set(gData.position.x, gData.position.y);
+			group.parentId = gData.parentId;
+			for (const eid of gData.entities) group.add(eid);
+			if (gData.groups) for (const gid of gData.groups) group.addGroup(gid);
+			this.groups.set(group.id, group);
+			this.gid = Math.max(this.gid, group.id + 1);
+		}
+		this.updateQuadTree();
+	}
+};
+
+//#endregion
+export { Context };
+//# sourceMappingURL=context.js.map