@likec4/diagram 1.59.3 → 1.60.0

package/dist/likec4diagram/state/machine.actions.js

@@ -1,787 +0,0 @@
-import "../../_virtual/_rolldown/runtime.js";
-import { Base } from "../../base/Base.js";
-import { findDiagramEdge, findDiagramNode, typedSystem, viewBounds } from "./utils.js";
-import { machine } from "./machine.setup.js";
-import { createLayoutConstraints } from "../useLayoutConstraints.js";
-import { focusNodesEdges, mergeXYNodesEdges, resetEdgeControlPoints } from "./assign.js";
-import { convertToXYFlow } from "../convert-to-xyflow.js";
-import { getAligner, toNodeRect } from "./aligners.js";
-import { assignViewportBefore, cancelFitDiagram, centerOnNodeOrEdge, fitDiagram, fitFocusedBounds, raiseFitDiagram, raiseSetViewport, raiseUpdateView, returnViewportBefore, setViewport, setViewportCenter } from "./machine.actions.layout.js";
-import { hasAtLeast, isTruthy, mapToObj } from "remeda";
-import { dynamicViewFlow, exact, invariant, isDynamicView, nonNullable, nonexhaustive } from "@likec4/core";
-import { BBox as BBox$1 } from "@likec4/core/geometry";
-import { difference as difference$1, isString as isString$1 } from "@likec4/core/utils";
-import { nodeToRect } from "@xyflow/system";
-import { assertEvent } from "xstate";
-import { produce } from "immer";
-//#region src/likec4diagram/state/machine.actions.ts
-var resetSelection = () => machine.raise({ type: "xyflow.resetSelection" });
-var disableCompareWithLatest = () => machine.assign(({ context }) => {
-	return {
-		toggledFeatures: {
-			...context.toggledFeatures,
-			enableCompareWithLatest: false
-		},
-		viewportOnAutoLayout: null,
-		viewportOnManualLayout: null
-	};
-});
-var onEdgeDoubleClick = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "xyflow.edgeDoubleClick");
-	if (!event.edge.data.controlPoints) return {};
-	const { nodeLookup } = context.xystore.getState();
-	return { xyedges: context.xyedges.map((e) => {
-		if (e.id !== event.edge.id) return e;
-		const controlPoints = resetEdgeControlPoints(nodeLookup, e);
-		const pt = controlPoints[0];
-		return {
-			...e,
-			data: {
-				...e.data,
-				controlPoints,
-				labelBBox: e.data.labelBBox ? {
-					...e.data.labelBBox,
-					...pt
-				} : null,
-				labelXY: null
-			}
-		};
-	}) };
-});
-var assignLastClickedNode = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "xyflow.nodeClick");
-	const { lastClickedNode } = context;
-	if (!lastClickedNode || lastClickedNode.id !== event.node.id) return { lastClickedNode: {
-		id: event.node.id,
-		clicks: 1,
-		timestamp: Date.now()
-	} };
-	return { lastClickedNode: {
-		id: lastClickedNode.id,
-		clicks: lastClickedNode.clicks + 1,
-		timestamp: Date.now()
-	} };
-});
-var assignFocusedNode = () => machine.assign(({ event }) => {
-	let focusedNode;
-	let autoUnfocusTimer = false;
-	switch (event.type) {
-		case "xyflow.nodeClick":
-			focusedNode = event.node.data.id;
-			break;
-		case "focus.node":
-			focusedNode = event.nodeId;
-			autoUnfocusTimer = event.autoUnfocus === true;
-			break;
-		default: throw new Error(`Unexpected event type: ${event.type} in action 'assign: focusedNode'`);
-	}
-	return {
-		focusedNode,
-		autoUnfocusTimer
-	};
-});
-var resetLastClickedNode = () => machine.assign(() => ({ lastClickedNode: null }));
-var updateFeatures = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "update.features");
-	return { features: {
-		...context.features,
-		...event.features
-	} };
-});
-var updateInputs = () => machine.assign(({ event }) => {
-	assertEvent(event, "update.inputs");
-	return exact({ ...event.inputs });
-});
-var assignXYDataFromView = (view) => machine.assign(({ context, event }) => {
-	let xydata;
-	if (view) xydata = convertToXYFlow({
-		currentViewId: context.view.id,
-		dynamicViewVariant: context.dynamicViewVariant,
-		view,
-		where: context.where,
-		collapsedSequenceFlows: context.collapsedSequenceFlows
-	});
-	else {
-		assertEvent(event, "update.view");
-		xydata = "xynodes" in event ? event : convertToXYFlow({
-			currentViewId: context.view.id,
-			dynamicViewVariant: context.dynamicViewVariant,
-			view: event.view,
-			where: context.where,
-			collapsedSequenceFlows: context.collapsedSequenceFlows
-		});
-	}
-	const update = mergeXYNodesEdges(context, xydata);
-	let { lastClickedNode, focusedNode, activeWalkthrough } = context;
-	if (lastClickedNode || focusedNode || activeWalkthrough) {
-		const nodeIds = new Set(update.xynodes.map((n) => n.id));
-		if (lastClickedNode && !nodeIds.has(lastClickedNode.id)) lastClickedNode = null;
-		if (focusedNode && !nodeIds.has(focusedNode)) focusedNode = null;
-		const stepId = activeWalkthrough?.stepId;
-		if (stepId && !update.xyedges.some((e) => e.id === stepId)) activeWalkthrough = null;
-		return {
-			...update,
-			lastClickedNode,
-			focusedNode,
-			activeWalkthrough
-		};
-	}
-	return update;
-});
-var focusOnNodesAndEdges = () => machine.enqueueActions(({ context, enqueue }) => {
-	const next = focusNodesEdges(context);
-	if (next) enqueue.assign(next);
-	else enqueue.raise({ type: "key.esc" });
-});
-var undimEverything = () => machine.assign(({ context }) => ({
-	xynodes: context.xynodes.map(Base.setDimmed(false)),
-	xyedges: context.xyedges.map(Base.setData({
-		dimmed: false,
-		active: false
-	}))
-}));
-var assignDynamicViewVariant = () => machine.assign(({ event }) => {
-	assertEvent(event, "switch.dynamicViewVariant");
-	return { dynamicViewVariant: event.variant };
-});
-var onNodeMouseEnter = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "xyflow.nodeMouseEnter");
-	const hoveredNodeId = isString$1(event.node) ? event.node : event.node.id;
-	return { xynodes: context.xynodes.map((n) => {
-		if (n.id === hoveredNodeId) return Base.setHovered(n, true);
-		return n;
-	}) };
-});
-var onNodeMouseLeave = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "xyflow.nodeMouseLeave");
-	const leftNodeId = isString$1(event.node) ? event.node : event.node.id;
-	return { xynodes: context.xynodes.map((n) => {
-		if (n.id === leftNodeId) return Base.setHovered(n, false);
-		return n;
-	}) };
-});
-var emitPaneClick = () => machine.emit(() => ({ type: "paneClick" }));
-var emitOpenSource = (params) => machine.emit(({ event }) => {
-	if (params) return {
-		type: "openSource",
-		params
-	};
-	assertEvent(event, "open.source");
-	return {
-		type: "openSource",
-		params: event
-	};
-});
-var emitOpenSourceOfView = () => machine.emit(({ context }) => ({
-	type: "openSource",
-	params: { view: context.view.id }
-}));
-var emitInitialized = () => machine.emit(({ context }) => {
-	invariant(context.xyflow, "XYFlow instance not found");
-	return {
-		type: "initialized",
-		instance: context.xyflow
-	};
-});
-var emitNodeClick = () => machine.enqueueActions(({ context, event, enqueue }) => {
-	assertEvent(event, "xyflow.nodeClick");
-	const node = findDiagramNode(context, event.node.id);
-	if (!node) return;
-	enqueue.emit({
-		type: "nodeClick",
-		node,
-		xynode: event.node
-	});
-});
-var emitNavigateTo = (params) => machine.emit(({ context }) => ({
-	type: "navigateTo",
-	viewId: params?.viewId ?? nonNullable(context.lastOnNavigate, "Invalid state, lastOnNavigate is null").toView
-}));
-var emitEdgeClick = () => machine.emit(({ context, event }) => {
-	assertEvent(event, "xyflow.edgeClick");
-	return {
-		type: "edgeClick",
-		edge: nonNullable(findDiagramEdge(context, event.edge.id), `Edge ${event.edge.id} not found in diagram`),
-		xyedge: event.edge
-	};
-});
-var triggerChange = (viewChange) => machine.enqueueActions(({ event, enqueue }) => {
-	let change;
-	if (viewChange) change = { ...viewChange };
-	else {
-		assertEvent(event, "trigger.change");
-		change = event.change;
-	}
-	enqueue.assign({ viewportChangedManually: true });
-	enqueue.sendTo(typedSystem.editorActor, {
-		type: "change.view",
-		change
-	});
-});
-var emitOnLayoutTypeChange = () => machine.enqueueActions(({ event, system, context, enqueue }) => {
-	if (!context.features.enableCompareWithLatest) {
-		console.warn("Layout type cannot be changed while CompareWithLatest feature is disabled");
-		return;
-	}
-	const currentLayoutType = context.view._layout;
-	let nextLayoutType = currentLayoutType === "auto" ? "manual" : "auto";
-	if (event.type === "emit.onLayoutTypeChange") nextLayoutType = event.layoutType;
-	if (currentLayoutType === nextLayoutType) {
-		console.warn("Ignoring layout type change event, layout type is already", currentLayoutType);
-		return;
-	}
-	if (context.toggledFeatures.enableCompareWithLatest === true) {
-		if (currentLayoutType === "manual" && nextLayoutType === "auto") typedSystem(system).editorActorRef?.send({ type: "cancel" });
-		const currentViewport = context.viewport;
-		if (currentLayoutType === "auto") enqueue.assign({ viewportOnAutoLayout: currentViewport });
-		if (currentLayoutType === "manual") enqueue.assign({ viewportOnManualLayout: currentViewport });
-	}
-	enqueue.emit({
-		type: "onLayoutTypeChange",
-		layoutType: nextLayoutType
-	});
-});
-var layoutAlign = (params) => machine.createAction(({ context, event }) => {
-	let mode;
-	if (params) mode = params.mode;
-	else {
-		assertEvent(event, "layout.align");
-		mode = event.mode;
-	}
-	const xystore = nonNullable(context.xystore, "xystore is not initialized");
-	const { nodeLookup, parentLookup } = xystore.getState();
-	const selectedNodes = new Set(nodeLookup.values().filter((n) => n.selected).map((n) => n.id));
-	const nodesToAlign = [...difference$1(selectedNodes, new Set(parentLookup.keys()))];
-	if (!hasAtLeast(nodesToAlign, 2)) {
-		console.warn("At least 2 nodes must be selected to align");
-		return;
-	}
-	const constraints = createLayoutConstraints(xystore, nodesToAlign);
-	const aligner = getAligner(mode);
-	const nodes = nodesToAlign.map((id) => ({
-		node: nonNullable(nodeLookup.get(id)),
-		rect: nonNullable(constraints.rects.get(id))
-	}));
-	aligner.computeLayout(nodes.map(({ node }) => toNodeRect(node)));
-	for (const { rect, node } of nodes) rect.positionAbsolute = {
-		...rect.positionAbsolute,
-		...aligner.applyPosition(toNodeRect(node))
-	};
-	constraints.updateXYFlow();
-});
-var resetEdgesControlPoints = () => machine.assign(({ context }) => {
-	const { nodeLookup } = context.xystore.getState();
-	return { xyedges: context.xyedges.map((edge) => {
-		if (!edge.data.controlPoints) return edge;
-		const controlPoints = resetEdgeControlPoints(nodeLookup, edge);
-		const pt = controlPoints[0];
-		return {
-			...edge,
-			data: {
-				...edge.data,
-				controlPoints,
-				labelBBox: edge.data.labelBBox ? {
-					...edge.data.labelBBox,
-					x: pt.x,
-					y: pt.y
-				} : null,
-				labelXY: edge.data.labelXY ? pt : null
-			}
-		};
-	}) };
-});
-var notationsHighlight = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "notations.highlight");
-	const { notation, kind } = event;
-	const targetKinds = kind ? [kind] : notation.kinds;
-	const shouldHighlight = (node) => node.notation === notation.title && node.shape === notation.shape && node.color === notation.color && targetKinds.includes(node.kind);
-	return {
-		xynodes: context.xynodes.map((n) => {
-			const node = findDiagramNode(context, n.id);
-			const highlighted = node && shouldHighlight(node);
-			return Base.setDimmed(n, highlighted ? false : "immediate");
-		}),
-		xyedges: context.xyedges.map((edge) => {
-			return Base.setDimmed(edge, true);
-		})
-	};
-});
-var tagHighlight = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "tag.highlight");
-	return { xynodes: context.xynodes.map((n) => {
-		if (n.data.tags?.includes(event.tag)) return Base.setDimmed(n, false);
-		return Base.setDimmed(n, true);
-	}) };
-});
-var highlightNodeOrEdge = () => machine.assign(({ context, event }) => {
-	assertEvent(event, ["highlight.edge", "highlight.node"]);
-	switch (event.type) {
-		case "highlight.node": {
-			const nodeId = event.nodeId;
-			if (!context.xynodes.find((n) => n.id === nodeId)) {
-				console.warn(`Node with id ${nodeId} not found for highlighting`);
-				return {};
-			}
-			return {
-				xynodes: context.xynodes.map((n) => {
-					return Base.setDimmed(n, n.id === nodeId ? false : true);
-				}),
-				xyedges: context.xyedges.map(Base.setData({
-					dimmed: true,
-					active: false
-				}))
-			};
-		}
-		case "highlight.edge": {
-			const edgeId = event.edgeId;
-			let edge = context.xyedges.find((e) => e.id === edgeId);
-			if (!edge) {
-				console.warn(`Edge with id ${edgeId} not found for highlighting`);
-				return {};
-			}
-			return {
-				xynodes: context.xynodes.map((n) => {
-					return Base.setDimmed(n, edge.source !== n.id && edge.target !== n.id);
-				}),
-				xyedges: context.xyedges.map((e) => {
-					return Base.setData(e, {
-						dimmed: e.id !== edgeId,
-						active: e.id === edgeId
-					});
-				})
-			};
-		}
-		default: nonexhaustive(event);
-	}
-});
-var assignToggledFeatures = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "toggle.feature");
-	const feature = `enable${event.feature}`;
-	const currentValue = context.toggledFeatures[feature] ?? context.features[feature];
-	const nextValue = event.forceValue ?? !currentValue;
-	return { toggledFeatures: {
-		...context.toggledFeatures,
-		[feature]: nextValue
-	} };
-});
-var closeAllOverlays = () => machine.sendTo(typedSystem.overlaysActor, { type: "close.all" });
-var stopEditorActor = () => machine.enqueueActions(({ enqueue, system }) => {
-	const actor = typedSystem(system).editorActorRef;
-	if (!actor) return;
-	enqueue.stopChild(actor);
-});
-/**
-* Ensure that the sync layout actor is running or stopped based on the read-only state
-*/
-var ensureEditorActor = () => machine.enqueueActions(({ enqueue, context, system, check }) => {
-	const hasEditor = check("enabled: Editor");
-	const editor = typedSystem(system).editorActorRef;
-	if (!hasEditor && editor) {
-		enqueue.stopChild(editor);
-		return;
-	}
-	if (hasEditor && !editor) enqueue.spawnChild("editor", {
-		id: "editor",
-		systemId: "editor",
-		input: { viewId: context.view.id },
-		syncSnapshot: true
-	});
-});
-var startEditing = (subject = "node") => machine.sendTo(typedSystem.editorActor, {
-	type: "edit.move.start",
-	subject
-});
-var sendSynced = () => {
-	return machine.sendTo(typedSystem.editorActor, { type: "view.synched" });
-};
-var stopEditing = (wasChanged = false) => machine.sendTo(typedSystem.editorActor, { type: wasChanged ? "edit.move.end" : "edit.move.cancel" });
-var cancelEditing = () => machine.sendTo(typedSystem.editorActor, { type: "cancel" });
-var hasModelFqn = (node) => "modelFqn" in node.data && isTruthy(node.data.modelFqn);
-var openElementDetails = (params) => machine.enqueueActions(({ context, event, enqueue }) => {
-	let initiatedFrom = null;
-	let fromNodeId;
-	let subject;
-	switch (true) {
-		case !!params:
-			subject = params.fqn;
-			fromNodeId = params.fromNode ?? context.view.nodes.find((n) => n.modelRef === params.fqn)?.id;
-			break;
-		case event.type === "xyflow.nodeClick":
-			if (!hasModelFqn(event.node)) {
-				console.warn("No modelFqn in clicked node data");
-				return;
-			}
-			subject = event.node.data.modelFqn;
-			fromNodeId = event.node.data.id;
-			break;
-		case event.type === "open.elementDetails":
-			subject = event.fqn;
-			fromNodeId = event.fromNode;
-			break;
-		default: {
-			if (!context.lastClickedNode) {
-				console.warn("No last clicked node");
-				return;
-			}
-			fromNodeId = context.lastClickedNode.id;
-			const node = context.xynodes.find((n) => n.id === fromNodeId);
-			if (!node || !hasModelFqn(node)) {
-				console.warn("No modelFqn in last clicked node");
-				return;
-			}
-			subject = node.data.modelFqn;
-			break;
-		}
-	}
-	const internalNode = fromNodeId ? context.xystore.getState().nodeLookup.get(fromNodeId) : null;
-	if (fromNodeId && internalNode) {
-		const nodeRect = nodeToRect(internalNode);
-		const zoom = context.xyflow.getZoom();
-		const clientRect = {
-			...context.xyflow.flowToScreenPosition(nodeRect),
-			width: nodeRect.width * zoom,
-			height: nodeRect.height * zoom
-		};
-		initiatedFrom = {
-			node: fromNodeId,
-			clientRect
-		};
-	}
-	enqueue.sendTo(typedSystem.overlaysActor, {
-		type: "open.elementDetails",
-		subject,
-		currentView: context.view,
-		...initiatedFrom && { initiatedFrom }
-	});
-});
-var openOverlay = () => machine.enqueueActions(({ context, event, enqueue, check }) => {
-	assertEvent(event, [
-		"open.relationshipsBrowser",
-		"open.relationshipDetails",
-		"open.elementDetails"
-	]);
-	if (!check("enabled: Overlays")) {
-		console.warn("Overlays feature is disabled");
-		return;
-	}
-	switch (event.type) {
-		case "open.elementDetails":
-			check("enabled: ElementDetails") ? enqueue(openElementDetails()) : console.warn("ElementDetails feature is disabled");
-			break;
-		case "open.relationshipsBrowser":
-			if (!context.features.enableRelationshipBrowser) {
-				console.warn("RelationshipBrowser feature is disabled");
-				return;
-			}
-			enqueue.sendTo(typedSystem.overlaysActor, {
-				type: "open.relationshipsBrowser",
-				subject: event.fqn,
-				viewId: context.view.id,
-				scope: "view",
-				closeable: true,
-				enableChangeScope: true,
-				enableSelectSubject: true
-			});
-			break;
-		case "open.relationshipDetails":
-			if (!context.features.enableRelationshipDetails) {
-				console.warn("RelationshipDetails feature is disabled");
-				return;
-			}
-			enqueue.sendTo(typedSystem.overlaysActor, {
-				type: "open.relationshipDetails",
-				viewId: context.view.id,
-				...event.params
-			});
-			break;
-		default: nonexhaustive(event);
-	}
-});
-var openSourceOfFocusedOrLastClickedNode = () => machine.enqueueActions(({ context, enqueue }) => {
-	const nodeId = context.focusedNode ?? context.lastClickedNode?.id;
-	if (!nodeId || !context.features.enableVscode) return;
-	const diagramNode = findDiagramNode(context, nodeId);
-	if (!diagramNode) return;
-	if (diagramNode.deploymentRef) enqueue.raise({
-		type: "open.source",
-		deployment: diagramNode.deploymentRef
-	});
-	else if (diagramNode.modelRef) enqueue.raise({
-		type: "open.source",
-		element: diagramNode.modelRef
-	});
-});
-/**
-* Ensure that the overlays actor is running or stopped based on the current feature flags
-*/
-var ensureOverlaysActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
-	const enabled = check("enabled: Overlays");
-	const running = typedSystem(system).overlaysActorRef;
-	if (enabled && !running) {
-		enqueue.spawnChild("overlays", {
-			id: "overlays",
-			systemId: "overlays",
-			syncSnapshot: true
-		});
-		return;
-	}
-	if (!enabled && running) {
-		enqueue.sendTo(running, { type: "close.all" });
-		enqueue.stopChild(running);
-	}
-});
-/**
-* Ensure that the navigation panel actor is running or stopped based on the current state
-*/
-var ensureNavigationPanelActor = () => machine.enqueueActions(({ enqueue, check, system, context }) => {
-	const enabled = check("enabled: NavigationPanel");
-	const running = typedSystem(system).navigationActorRef;
-	if (enabled && !running) {
-		enqueue.spawnChild("navigationPanel", {
-			id: "navigationPanel",
-			systemId: "navigationPanel",
-			input: {
-				view: context.view,
-				viewModel: null
-			},
-			syncSnapshot: true
-		});
-		return;
-	}
-	if (!enabled && running) enqueue.stopChild(running);
-});
-/**
-* Ensure that the search actor is running or stopped based on the current feature flags
-*/
-var ensureSearchActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
-	const enabled = check("enabled: Search");
-	const running = typedSystem(system).searchActorRef;
-	if (enabled && !running) {
-		enqueue.spawnChild("search", {
-			id: "search",
-			systemId: "search",
-			syncSnapshot: true
-		});
-		return;
-	}
-	if (!enabled && running) {
-		enqueue.sendTo(running, { type: "close" });
-		enqueue.stopChild(running);
-	}
-});
-var onEdgeMouseEnter = () => machine.enqueueActions(({ enqueue, context, event }) => {
-	assertEvent(event, "xyflow.edgeMouseEnter");
-	let edge = event.edge;
-	let parentFlow = edge.type === "seq-step" && edge.data.parentFlow;
-	enqueue.assign({
-		xyedges: context.xyedges.map((e) => {
-			if (e.id === event.edge.id) {
-				edge = Base.setHovered(e, true);
-				return edge;
-			}
-			return e;
-		}),
-		xynodes: parentFlow ? context.xynodes.map((n) => {
-			if (n.type === "seq-subflow" && n.data.flowId === parentFlow.id) return Base.setHovered(n, true);
-			return n;
-		}) : context.xynodes
-	});
-	enqueue.emit({
-		type: "edgeMouseEnter",
-		edge,
-		event: event.event
-	});
-});
-var onEdgeMouseLeave = () => machine.enqueueActions(({ enqueue, context, event }) => {
-	assertEvent(event, "xyflow.edgeMouseLeave");
-	let edge = event.edge;
-	let parentFlow = edge.type === "seq-step" && edge.data.parentFlow;
-	enqueue.assign({
-		xyedges: context.xyedges.map((e) => {
-			if (e.id === event.edge.id) {
-				edge = Base.setHovered(e, false);
-				return edge;
-			}
-			return e;
-		}),
-		xynodes: parentFlow ? context.xynodes.map((n) => {
-			if (n.type === "seq-subflow" && n.data.flowId === parentFlow.id) return Base.setHovered(n, false);
-			return n;
-		}) : context.xynodes
-	});
-	enqueue.emit({
-		type: "edgeMouseLeave",
-		edge,
-		event: event.event
-	});
-});
-var startHotKeyActor = () => machine.spawnChild("hotkey", {
-	id: "hotkey",
-	systemId: "hotkey",
-	syncSnapshot: true
-});
-var stopHotKeyActor = () => machine.stopChild("hotkey");
-/**
-* Auto-unfocus timer duration in milliseconds.
-* Set to 0 to disable auto-unfocus (focus remains until user clicks elsewhere).
-* Used for focusing nodes from search results.
-*/
-var AUTO_UNFOCUS_DELAY = 3e3;
-var startAutoUnfocusTimer = () => machine.enqueueActions(({ context, enqueue }) => {
-	if (context.autoUnfocusTimer && true) enqueue.raise({ type: "focus.autoUnfocus" }, {
-		delay: AUTO_UNFOCUS_DELAY,
-		id: "autoUnfocusTimer"
-	});
-});
-var cancelAutoUnfocusTimer = () => machine.cancel("autoUnfocusTimer");
-var handleNavigate = () => machine.enqueueActions(({ enqueue, context, event }) => {
-	assertEvent(event, [
-		"navigate.to",
-		"navigate.back",
-		"navigate.forward"
-	]);
-	const { view, focusedNode, activeWalkthrough, dynamicViewVariant, viewport, viewportChangedManually, viewportBefore, navigationHistory } = context;
-	let { currentIndex, history: _history } = navigationHistory;
-	let history = _history;
-	if (currentIndex < _history.length) {
-		const updatedEntry = produce(_history.at(currentIndex) ?? {}, (draft) => {
-			draft.viewport = { ...viewport };
-			draft.viewportChangedManually = viewportChangedManually;
-			draft.focusedNode = focusedNode;
-			if (view._type === "dynamic") {
-				draft.activeWalkthrough = activeWalkthrough?.stepId ?? null;
-				draft.dynamicViewVariant = dynamicViewVariant;
-			} else {
-				draft.activeWalkthrough = null;
-				draft.dynamicViewVariant = null;
-			}
-			if (viewportBefore) draft.viewportBefore = structuredClone(viewportBefore);
-			else delete draft.viewportBefore;
-		});
-		history = [..._history];
-		history[currentIndex] = updatedEntry;
-	}
-	switch (event.type) {
-		case "navigate.to":
-			enqueue.assign({
-				navigationHistory: {
-					currentIndex,
-					history
-				},
-				lastOnNavigate: {
-					fromView: context.view.id,
-					toView: event.viewId,
-					fromNode: event.fromNode ?? null,
-					focusOnElement: event.focusOnElement ?? null
-				}
-			});
-			enqueue(emitNavigateTo());
-			break;
-		case "navigate.back": {
-			invariant(currentIndex > 0, "Cannot navigate back");
-			const stepBack = history[currentIndex - 1];
-			enqueue.assign({
-				navigationHistory: {
-					currentIndex: currentIndex - 1,
-					history
-				},
-				lastOnNavigate: null
-			});
-			enqueue(emitNavigateTo({ viewId: stepBack.viewId }));
-			break;
-		}
-		case "navigate.forward": {
-			invariant(currentIndex < history.length - 1, "Cannot navigate forward");
-			const stepForward = history[currentIndex + 1];
-			enqueue.assign({
-				navigationHistory: {
-					currentIndex: currentIndex + 1,
-					history
-				},
-				lastOnNavigate: null
-			});
-			enqueue(emitNavigateTo({ viewId: stepForward.viewId }));
-			break;
-		}
-		default: nonexhaustive(event);
-	}
-});
-var updateView = () => machine.enqueueActions(({ enqueue, event, context }) => {
-	if (event.type !== "update.view") {
-		console.warn(`Ignoring unexpected event type: ${event.type} in action 'update.view'`);
-		return;
-	}
-	const nextView = event.view;
-	if (nextView.id !== context.view.id) {
-		console.warn("updateView called for another view - ignoring", { event });
-		return;
-	}
-	enqueue(assignXYDataFromView());
-	if (event.source === "editor") return;
-	enqueue(sendSynced());
-	if (context.toggledFeatures.enableCompareWithLatest === true && context.view._layout !== nextView._layout) {
-		if (nextView._layout === "auto" && context.viewportOnAutoLayout) {
-			enqueue(setViewport({
-				viewport: context.viewportOnAutoLayout,
-				duration: 0
-			}));
-			return;
-		}
-		if (nextView._layout === "manual" && context.viewportOnManualLayout) {
-			enqueue(setViewport({
-				viewport: context.viewportOnManualLayout,
-				duration: 0
-			}));
-			return;
-		}
-	}
-	let recenter = !context.viewportChangedManually && !context.focusedNode && !context.activeWalkthrough;
-	recenter = recenter || context.toggledFeatures.enableCompareWithLatest === true && !!nextView._layout && context.view._layout !== nextView._layout;
-	if (nextView._type === "dynamic" && context.view._type === "dynamic") {
-		if (nextView.variant === context.view.variant && nextView.variant !== context.dynamicViewVariant) {
-			const nextCenter = BBox$1.center(viewBounds(context, nextView));
-			enqueue(setViewportCenter(nextCenter));
-		}
-	}
-	if (recenter) {
-		enqueue(cancelFitDiagram());
-		enqueue(raiseFitDiagram());
-	}
-});
-/**
-* Ensures all child actors are started/stopped as needed
-*/
-var ensureAllActors = () => machine.enqueueActions(({ enqueue }) => {
-	enqueue(ensureEditorActor());
-	enqueue(ensureOverlaysActor());
-	enqueue(ensureSearchActor());
-	enqueue(ensureNavigationPanelActor());
-});
-var collapseOrExpandSequenceFlow = () => machine.enqueueActions(({ enqueue, event, context, check }) => {
-	assertEvent(event, ["sequence.flow.*"]);
-	invariant(isDynamicView(context.view));
-	const flowId = event.flowId;
-	const flow = dynamicViewFlow(context.view);
-	const subflow = flow.isSubflow(flowId) ? flow.lookup(flowId) : null;
-	if (!subflow) return;
-	let targets;
-	let isCollapsed;
-	if (flow.guards.isAltOrTry(subflow)) {
-		targets = flow.subflows(subflow).map((s) => s.id);
-		isCollapsed = targets.some((id) => context.collapsedSequenceFlows[id]);
-	} else {
-		targets = [flowId];
-		isCollapsed = context.collapsedSequenceFlows[flowId] ?? false;
-	}
-	if (isCollapsed && event.type === "sequence.flow.collapse" || !isCollapsed && event.type === "sequence.flow.expand") return;
-	enqueue.assign({ collapsedSequenceFlows: {
-		...context.collapsedSequenceFlows,
-		...mapToObj(targets, (id) => [id, !isCollapsed])
-	} });
-	if (check("is dynamic view in sequence variant")) {
-		enqueue(assignXYDataFromView(context.view));
-		if (!context.viewportChangedManually) enqueue(raiseFitDiagram());
-	}
-});
-//#endregion
-export { assignDynamicViewVariant, assignFocusedNode, assignLastClickedNode, assignToggledFeatures, assignViewportBefore, assignXYDataFromView, cancelAutoUnfocusTimer, cancelEditing, cancelFitDiagram, centerOnNodeOrEdge, closeAllOverlays, collapseOrExpandSequenceFlow, disableCompareWithLatest, emitEdgeClick, emitInitialized, emitNavigateTo, emitNodeClick, emitOnLayoutTypeChange, emitOpenSource, emitOpenSourceOfView, emitPaneClick, ensureAllActors, ensureEditorActor, ensureNavigationPanelActor, ensureOverlaysActor, ensureSearchActor, fitDiagram, fitFocusedBounds, focusOnNodesAndEdges, handleNavigate, highlightNodeOrEdge, layoutAlign, notationsHighlight, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseLeave, onNodeMouseEnter, onNodeMouseLeave, openElementDetails, openOverlay, openSourceOfFocusedOrLastClickedNode, raiseFitDiagram, raiseSetViewport, raiseUpdateView, resetEdgesControlPoints, resetLastClickedNode, resetSelection, returnViewportBefore, sendSynced, setViewport, setViewportCenter, startAutoUnfocusTimer, startEditing, startHotKeyActor, stopEditing, stopEditorActor, stopHotKeyActor, tagHighlight, triggerChange, undimEverything, updateFeatures, updateInputs, updateView };