@likec4/diagram 1.44.0 → 1.45.0

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

@@ -1,121 +1,16 @@
-import { BBox, invariant, nonNullable, nonexhaustive } from '@likec4/core';
-import { getViewportForBounds } from '@xyflow/react';
+import { nonNullable, nonexhaustive, invariant } from '@likec4/core';
 import { nodeToRect } from '@xyflow/system';
-import { isNumber, isTruthy, hasAtLeast } from 'remeda';
+import { produce } from 'immer';
+import { isTruthy, hasAtLeast } from 'remeda';
 import { assertEvent } from 'xstate';
 import { createLayoutConstraints } from '../useLayoutConstraints.js';
 import { getAligner, toNodeRect } from './aligners.js';
-import { mergeXYNodesEdges, resetEdgeControlPoints, updateActiveWalkthrough, focusNodesEdges } from './assign.js';
+import { resetEdgeControlPoints, mergeXYNodesEdges, focusNodesEdges } from './assign.js';
 import { createViewChange } from './createViewChange.js';
 import { machine } from './machine.setup.js';
-import { typedSystem, activeSequenceBounds, focusedBounds, findDiagramEdge, findDiagramNode } from './utils.js';
-import { MinZoom } from '../../base/const.js';
+import { typedSystem, findDiagramEdge, findDiagramNode } from './utils.js';
 import { Base } from '../../base/Base.js';
 
-function nodeRef(node) {
-  switch (node.type) {
-    case "element":
-    case "compound-element":
-    case "seq-actor":
-      return node.data.modelFqn;
-    case "deployment":
-    case "compound-deployment":
-      return node.data.modelFqn ?? node.data.deploymentFqn;
-    case "seq-parallel":
-    case "view-group":
-      return null;
-    default:
-      nonexhaustive(node);
-  }
-}
-function findCorrespondingNode(context, event) {
-  const fromNodeId = context.lastOnNavigate?.fromNode;
-  const fromNode = fromNodeId && context.xynodes.find((n) => n.id === fromNodeId);
-  const fromRef = fromNode && nodeRef(fromNode);
-  const toNode = fromRef && event.xynodes.find((n) => nodeRef(n) === fromRef);
-  return { fromNode, toNode };
-}
-const trigger = {
-  navigateTo: () => machine.emit(({ context }) => ({
-    type: "navigateTo",
-    viewId: nonNullable(context.lastOnNavigate, "Invalid state, lastOnNavigate is null").toView
-  }))
-};
-const xyflow = {
-  fitDiagram: (params) => machine.createAction(({ context, event }) => {
-    params ??= event.type === "fitDiagram" ? event : {};
-    const {
-      bounds = context.view.bounds,
-      duration = 450
-    } = params;
-    const { width, height, panZoom, transform } = nonNullable(context.xystore).getState();
-    const maxZoom = Math.max(1, transform[2]);
-    const viewport = getViewportForBounds(
-      bounds,
-      width,
-      height,
-      MinZoom,
-      maxZoom,
-      context.fitViewPadding
-    );
-    viewport.x = Math.round(viewport.x);
-    viewport.y = Math.round(viewport.y);
-    panZoom?.setViewport(viewport, duration > 0 ? { duration, interpolate: "smooth" } : void 0).catch(
-      console.error
-    );
-  }),
-  fitFocusedBounds: () => machine.createAction(({ context }) => {
-    const isActiveSequenceWalkthrough = !!context.activeWalkthrough && context.dynamicViewVariant === "sequence";
-    const { bounds, duration = 450 } = isActiveSequenceWalkthrough ? activeSequenceBounds({ context }) : focusedBounds({ context });
-    const { width, height, panZoom, transform } = nonNullable(context.xystore).getState();
-    const maxZoom = Math.max(1, transform[2]);
-    const viewport = getViewportForBounds(
-      bounds,
-      width,
-      height,
-      MinZoom,
-      maxZoom,
-      context.fitViewPadding
-    );
-    viewport.x = Math.round(viewport.x);
-    viewport.y = Math.round(viewport.y);
-    panZoom?.setViewport(viewport, duration > 0 ? { duration, interpolate: "smooth" } : void 0);
-  }),
-  alignNodeFromToAfterNavigate: (params) => machine.createAction(({ context }) => {
-    const xyflow2 = nonNullable(context.xyflow, "xyflow is not initialized");
-    const elFrom = xyflow2.getInternalNode(params.fromNode);
-    if (!elFrom) return;
-    const fromPos = xyflow2.flowToScreenPosition({
-      x: elFrom.internals.positionAbsolute.x,
-      y: elFrom.internals.positionAbsolute.y
-    }), toPos = xyflow2.flowToScreenPosition(params.toPosition), diff = {
-      x: Math.round(fromPos.x - toPos.x),
-      y: Math.round(fromPos.y - toPos.y)
-    };
-    context.xystore.getState().panBy(diff);
-  }),
-  setViewportCenter: (params) => machine.createAction(({ context, event }) => {
-    let center;
-    if (params) {
-      center = params;
-    } else if (event.type === "update.view") {
-      center = BBox.center(event.view.bounds);
-    } else {
-      center = BBox.center(context.view.bounds);
-    }
-    invariant(context.xyflow, "xyflow is not initialized");
-    const zoom = context.xyflow.getZoom();
-    context.xyflow.setCenter(Math.round(center.x), Math.round(center.y), { zoom });
-  }),
-  setViewport: (params) => machine.createAction(({ context }) => {
-    const {
-      viewport,
-      duration = 350
-    } = params;
-    const panZoom = context.xystore?.getState().panZoom;
-    panZoom?.setViewport(viewport, duration > 0 ? { duration, interpolate: "smooth" } : void 0);
-  })
-};
 const disableCompareWithLatest = () => machine.assign(({ context }) => {
   return {
     toggledFeatures: {
@@ -143,7 +38,7 @@ const onEdgeDoubleClick = () => machine.assign(({ context, event }) => {
             ...e.data,
             controlPoints,
             labelBBox: e.data.labelBBox ? { ...e.data.labelBBox, ...pt } : null,
-            labelXY: e.data.labelXY ? pt : null
+            labelXY: null
           }
         };
       }
@@ -151,60 +46,6 @@ const onEdgeDoubleClick = () => machine.assign(({ context, event }) => {
     })
   };
 });
-const emitOnChange = () => machine.enqueueActions(({ event, enqueue }) => {
-  assertEvent(event, "emit.onChange");
-  enqueue.assign({
-    viewportChangedManually: true
-  });
-  enqueue.emit({
-    type: "onChange",
-    change: event.change
-  });
-});
-const 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") {
-      const syncLayoutActor = typedSystem(system).syncLayoutActorRef;
-      const syncState = syncLayoutActor?.getSnapshot().value;
-      const isPending = syncLayoutActor && (syncState === "pending" || syncState === "paused");
-      if (isPending) {
-        enqueue.sendTo(syncLayoutActor, { type: "cancel" });
-        enqueue.emit({
-          type: "onChange",
-          change: createViewChange(context)
-        });
-      }
-    }
-    const currentViewport = context.viewport;
-    if (currentLayoutType === "auto") {
-      enqueue.assign({
-        viewportOnAutoLayout: currentViewport
-      });
-    }
-    if (currentLayoutType === "manual") {
-      enqueue.assign({
-        viewportOnManualLayout: currentViewport
-      });
-    }
-  }
-  enqueue.emit({
-    type: "onLayoutTypeChange",
-    layoutType: nextLayoutType
-  });
-});
 const assignLastClickedNode = () => machine.assign(({ context, event }) => {
   assertEvent(event, "xyflow.nodeClick");
   const { lastClickedNode } = context;
@@ -256,10 +97,23 @@ const updateInputs = () => machine.assign(({ event }) => {
 });
 const updateXYNodesEdges = () => machine.assign(({ context, event }) => {
   assertEvent(event, "update.view");
-  return {
-    ...mergeXYNodesEdges({ context, event }),
-    lastClickedNode: null
-  };
+  const update = mergeXYNodesEdges(context, event);
+  let { lastClickedNode, focusedNode } = context;
+  if (lastClickedNode || focusedNode) {
+    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;
+    }
+    return {
+      ...update,
+      lastClickedNode,
+      focusedNode
+    };
+  }
+  return update;
 });
 const focusOnNodesAndEdges = () => machine.assign(focusNodesEdges);
 const undimEverything = () => machine.assign(({ context }) => ({
@@ -269,7 +123,6 @@ const undimEverything = () => machine.assign(({ context }) => ({
     active: false
   }))
 }));
-const updateActiveWalkthroughState = () => machine.assign(updateActiveWalkthrough);
 const assignDynamicViewVariant = () => machine.assign(({ event }) => {
   assertEvent(event, "switch.dynamicViewVariant");
   return {
@@ -306,9 +159,6 @@ const onNodeMouseLeave = (params) => machine.assign(({ context, event }) => {
     })
   };
 });
-const emitWalkthroughStopped = () => machine.emit(() => ({
-  type: "walkthroughStopped"
-}));
 const emitPaneClick = () => machine.emit(() => ({
   type: "paneClick"
 }));
@@ -341,6 +191,10 @@ const emitNodeClick = () => machine.emit(({ context, event }) => {
     xynode: event.node
   };
 });
+const emitNavigateTo = (params) => machine.emit(({ context }) => ({
+  type: "navigateTo",
+  viewId: params?.viewId ?? nonNullable(context.lastOnNavigate, "Invalid state, lastOnNavigate is null").toView
+}));
 const emitEdgeClick = () => machine.emit(({ context, event }) => {
   assertEvent(event, "xyflow.edgeClick");
   const edge = nonNullable(findDiagramEdge(context, event.edge.id), `Edge ${event.edge.id} not found in diagram`);
@@ -350,21 +204,59 @@ const emitEdgeClick = () => machine.emit(({ context, event }) => {
     xyedge: event.edge
   };
 });
-const emitWalkthroughStarted = () => machine.emit(({ context }) => {
-  const edge = context.xyedges.find((x) => x.id === context.activeWalkthrough?.stepId);
-  invariant(edge, "Invalid walkthrough state");
-  return {
-    type: "walkthroughStarted",
-    edge
-  };
+const emitOnChange = () => machine.enqueueActions(({ event, enqueue }) => {
+  assertEvent(event, "emit.onChange");
+  enqueue.assign({
+    viewportChangedManually: true
+  });
+  enqueue.emit({
+    type: "onChange",
+    change: event.change
+  });
 });
-const emitWalkthroughStep = () => machine.emit(({ context }) => {
-  const edge = context.xyedges.find((x) => x.id === context.activeWalkthrough?.stepId);
-  invariant(edge, "Invalid walkthrough state");
-  return {
-    type: "walkthroughStep",
-    edge
-  };
+const 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") {
+      const syncLayoutActor = typedSystem(system).syncLayoutActorRef;
+      const syncState = syncLayoutActor?.getSnapshot().value;
+      const isPending = syncLayoutActor && (syncState === "pending" || syncState === "paused");
+      if (isPending) {
+        enqueue.sendTo(syncLayoutActor, { type: "cancel" });
+        enqueue.emit({
+          type: "onChange",
+          change: createViewChange(context)
+        });
+      }
+    }
+    const currentViewport = context.viewport;
+    if (currentLayoutType === "auto") {
+      enqueue.assign({
+        viewportOnAutoLayout: currentViewport
+      });
+    }
+    if (currentLayoutType === "manual") {
+      enqueue.assign({
+        viewportOnManualLayout: currentViewport
+      });
+    }
+  }
+  enqueue.emit({
+    type: "onLayoutTypeChange",
+    layoutType: nextLayoutType
+  });
 });
 const layoutAlign = (params) => machine.createAction(({ context, event }) => {
   let mode;
@@ -448,7 +340,7 @@ const tagHighlight = () => machine.assign(({ context, event }) => {
     })
   };
 });
-const toggleFeature = () => machine.assign(({ context, event }) => {
+const assignToggledFeatures = () => machine.assign(({ context, event }) => {
   assertEvent(event, "toggle.feature");
   const currentValue = context.toggledFeatures[`enable${event.feature}`] ?? context.features[`enable${event.feature}`];
   const nextValue = event.forceValue ?? !currentValue;
@@ -471,29 +363,28 @@ const closeAllOverlays = () => machine.sendTo(
     type: "close.all"
   }
 );
-const isReadOnly = (context) => context.features.enableReadOnly || context.toggledFeatures.enableReadOnly === true;
 const stopSyncLayout = () => machine.enqueueActions(({ enqueue, system }) => {
   const syncLayoutActor = typedSystem(system).syncLayoutActorRef;
   if (!syncLayoutActor) return;
   enqueue.stopChild(syncLayoutActor);
 });
-const ensureSyncLayout = () => machine.enqueueActions(({ context, enqueue, system }) => {
+const ensureSyncLayoutActor = () => machine.enqueueActions(({ context, enqueue, system, check }) => {
+  const isReadOnly = check("enabled: Readonly");
   const syncLayoutActor = typedSystem(system).syncLayoutActorRef;
-  if (isReadOnly(context)) {
-    if (syncLayoutActor) {
-      enqueue.stopChild(syncLayoutActor);
-    }
+  if (isReadOnly && syncLayoutActor) {
+    enqueue.stopChild(syncLayoutActor);
     return;
   }
-  if (syncLayoutActor) return;
-  enqueue.spawnChild("syncManualLayoutActorLogic", {
-    id: "syncLayout",
-    systemId: "syncLayout",
-    input: {
-      viewId: context.view.id
-    },
-    syncSnapshot: true
-  });
+  if (!isReadOnly && !syncLayoutActor) {
+    enqueue.spawnChild("syncManualLayoutActorLogic", {
+      id: "syncLayout",
+      systemId: "syncLayout",
+      input: {
+        viewId: context.view.id
+      },
+      syncSnapshot: true
+    });
+  }
 });
 const startEditing = (subject = "node") => machine.sendTo(
   ({ system }) => typedSystem(system).syncLayoutActorRef,
@@ -502,6 +393,12 @@ const startEditing = (subject = "node") => machine.sendTo(
     subject
   }
 );
+const sendSynced = () => machine.sendTo(
+  ({ system }) => typedSystem(system).syncLayoutActorRef,
+  {
+    type: "synced"
+  }
+);
 const stopEditing = (wasChanged = true) => machine.sendTo(
   ({ system }) => typedSystem(system).syncLayoutActorRef,
   {
@@ -509,6 +406,12 @@ const stopEditing = (wasChanged = true) => machine.sendTo(
     wasChanged
   }
 );
+const cancelEditing = () => machine.sendTo(
+  ({ system }) => typedSystem(system).syncLayoutActorRef,
+  {
+    type: "cancel"
+  }
+);
 const hasModelFqn = (node) => "modelFqn" in node.data && isTruthy(node.data.modelFqn);
 const openElementDetails = (params) => machine.enqueueActions(({ context, event, enqueue, system }) => {
   let initiatedFrom = null;
@@ -584,8 +487,8 @@ const openSourceOfFocusedOrLastClickedNode = () => machine.enqueueActions(({ con
     enqueue.raise({ type: "open.source", element: diagramNode.modelRef });
   }
 });
-const ensureOverlaysActorState = () => machine.enqueueActions(({ enqueue, context: { features }, system }) => {
-  const enableOverlays = features.enableElementDetails || features.enableRelationshipDetails || features.enableRelationshipBrowser;
+const ensureOverlaysActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
+  const enableOverlays = check("enabled: Overlays");
   const hasRunning = typedSystem(system).overlaysActorRef;
   if (enableOverlays && !hasRunning) {
     enqueue.spawnChild("overlaysActorLogic", { id: "overlays", systemId: "overlays" });
@@ -598,7 +501,7 @@ const ensureOverlaysActorState = () => machine.enqueueActions(({ enqueue, contex
     enqueue.stopChild("overlays");
   }
 });
-const ensureSearchActorState = () => machine.enqueueActions(({ enqueue, context: { features: { enableSearch } }, system }) => {
+const ensureSearchActor = () => machine.enqueueActions(({ enqueue, context: { features: { enableSearch } }, system }) => {
   const hasRunning = typedSystem(system).searchActorRef;
   if (enableSearch && !hasRunning) {
     enqueue.spawnChild("searchActorLogic", { id: "search", systemId: "search" });
@@ -647,89 +550,95 @@ const onEdgeMouseLeave = () => machine.enqueueActions(({ enqueue, context, event
     event: event.event
   });
 });
-const cancelFitDiagram = () => machine.cancel("fitDiagram");
-const raiseFitDiagram = (params) => machine.enqueueActions(({ enqueue }) => {
-  enqueue.cancel("fitDiagram");
-  enqueue.raise(
-    {
-      type: "fitDiagram",
-      ...isNumber(params?.duration) ? { duration: params.duration } : {}
-    },
-    {
-      id: "fitDiagram",
-      ...isNumber(params?.delay) ? { delay: params.delay } : {}
+const startHotKeyActor = () => machine.spawnChild("hotkeyActorLogic", { id: "hotkey" });
+const stopHotKeyActor = () => machine.stopChild("hotkey");
+const handleNavigate = () => machine.enqueueActions(({ enqueue, context, event }) => {
+  assertEvent(event, ["navigate.to", "navigate.back", "navigate.forward"]);
+  console.log(`Handle ${event.type}`);
+  const {
+    view,
+    focusedNode,
+    activeWalkthrough,
+    dynamicViewVariant,
+    viewport,
+    viewportChangedManually,
+    viewportBefore,
+    navigationHistory: {
+      currentIndex,
+      history: _history
     }
-  );
-});
-const updateView = () => machine.enqueueActions(
-  ({ enqueue, event, check, context, system }) => {
-    assertEvent(event, "update.view");
-    const isAnotherView = check("is another view");
-    enqueue(cancelFitDiagram());
-    if (isAnotherView) {
-      enqueue(stopSyncLayout());
-      enqueue(closeAllOverlays());
-      enqueue(closeSearch());
-      enqueue.assign({
-        focusedNode: null
-      });
-      enqueue(disableCompareWithLatest());
-      const { fromNode, toNode } = findCorrespondingNode(context, event);
-      if (fromNode && toNode) {
-        enqueue(xyflow.alignNodeFromToAfterNavigate({
-          fromNode: fromNode.id,
-          toPosition: {
-            x: toNode.data.x,
-            y: toNode.data.y
-          }
-        }));
-        enqueue(raiseFitDiagram({ delay: 80 }));
+  } = context;
+  let history = [..._history];
+  if (currentIndex < _history.length) {
+    const updatedEntry = produce(_history[currentIndex], (draft) => {
+      draft.viewport = { ...viewport };
+      draft.viewportChangedManually = viewportChangedManually;
+      draft.focusedNode = focusedNode;
+      if (view._type === "dynamic") {
+        draft.activeWalkthrough = activeWalkthrough?.stepId ?? null;
+        draft.dynamicViewVariant = dynamicViewVariant;
       } else {
-        enqueue(
-          xyflow.setViewportCenter()
-        );
-        enqueue(raiseFitDiagram({ duration: 200, delay: 25 }));
-      }
-      enqueue(updateXYNodesEdges());
-      enqueue(ensureSyncLayout());
-      return;
-    }
-    enqueue(updateXYNodesEdges());
-    const syncLayoutActor = typedSystem(system).syncLayoutActorRef;
-    if (syncLayoutActor) {
-      enqueue.sendTo(syncLayoutActor, { type: "synced" });
-    }
-    const nextView = event.view;
-    if (context.toggledFeatures.enableCompareWithLatest === true && context.view._layout !== nextView._layout) {
-      if (nextView._layout === "auto" && context.viewportOnAutoLayout) {
-        enqueue(
-          xyflow.setViewport({
-            viewport: context.viewportOnAutoLayout,
-            duration: 0
-          })
-        );
-        return;
+        draft.activeWalkthrough = null;
+        draft.dynamicViewVariant = null;
       }
-      if (nextView._layout === "manual" && context.viewportOnManualLayout) {
-        enqueue(
-          xyflow.setViewport({
-            viewport: context.viewportOnManualLayout,
-            duration: 0
-          })
-        );
-        return;
+      if (viewportBefore) {
+        draft.viewportBefore = viewportBefore;
+      } else {
+        delete draft.viewportBefore;
       }
+    });
+    history = [..._history];
+    history[currentIndex] = updatedEntry;
+    console.log("Update current history entry", {
+      before: _history[currentIndex],
+      after: updatedEntry
+    });
+  }
+  switch (event.type) {
+    case "navigate.to": {
+      enqueue.assign({
+        navigationHistory: {
+          currentIndex,
+          history
+        },
+        lastOnNavigate: {
+          fromView: context.view.id,
+          toView: event.viewId,
+          fromNode: event.fromNode ?? null
+        }
+      });
+      enqueue(emitNavigateTo());
+      break;
     }
-    let recenter = !context.viewportChangedManually;
-    recenter = recenter || nextView._type === "dynamic" && context.view._type === "dynamic" && nextView.variant !== context.view.variant;
-    recenter = recenter || context.toggledFeatures.enableCompareWithLatest === true && !!nextView._layout && context.view._layout !== nextView._layout;
-    if (recenter) {
-      enqueue(
-        xyflow.setViewportCenter(BBox.center(nextView.bounds))
-      );
-      enqueue(raiseFitDiagram({ delay: 50 }));
+    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);
   }
-);
+});
 
-export { assignDynamicViewVariant, assignFocusedNode, assignLastClickedNode, cancelFitDiagram, closeAllOverlays, closeSearch, disableCompareWithLatest, emitEdgeClick, emitInitialized, emitNodeClick, emitOnChange, emitOnLayoutTypeChange, emitOpenSource, emitPaneClick, emitWalkthroughStarted, emitWalkthroughStep, emitWalkthroughStopped, ensureOverlaysActorState, ensureSearchActorState, ensureSyncLayout, findCorrespondingNode, focusOnNodesAndEdges, layoutAlign, nodeRef, notationsHighlight, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseLeave, onNodeMouseEnter, onNodeMouseLeave, openElementDetails, openSourceOfFocusedOrLastClickedNode, raiseFitDiagram, resetEdgesControlPoints, resetLastClickedNode, startEditing, stopEditing, stopSyncLayout, tagHighlight, toggleFeature, trigger, undimEverything, updateActiveWalkthroughState, updateFeatures, updateInputs, updateView, updateXYNodesEdges, xyflow };
+export { assignDynamicViewVariant, assignFocusedNode, assignLastClickedNode, assignToggledFeatures, cancelEditing, closeAllOverlays, closeSearch, disableCompareWithLatest, emitEdgeClick, emitInitialized, emitNavigateTo, emitNodeClick, emitOnChange, emitOnLayoutTypeChange, emitOpenSource, emitPaneClick, ensureOverlaysActor, ensureSearchActor, ensureSyncLayoutActor, focusOnNodesAndEdges, handleNavigate, layoutAlign, notationsHighlight, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseLeave, onNodeMouseEnter, onNodeMouseLeave, openElementDetails, openSourceOfFocusedOrLastClickedNode, resetEdgesControlPoints, resetLastClickedNode, sendSynced, startEditing, startHotKeyActor, stopEditing, stopHotKeyActor, stopSyncLayout, tagHighlight, undimEverything, updateFeatures, updateInputs, updateXYNodesEdges };