@likec4/diagram 1.45.0 → 1.46.2

package/dist/editor/editorActor.actions.js

@@ -0,0 +1,149 @@
+import { last, filter, isNot, omit } from 'remeda';
+import { createViewChange } from '../likec4diagram/state/createViewChange.js';
+import { machine } from './editorActor.js';
+
+const diagramActorRef = function(system) {
+  return system.get("diagram");
+};
+const getDiagramContext = function(system) {
+  return system.get("diagram").getSnapshot().context;
+};
+const raiseSync = () => machine.raise({ type: "sync" }, { delay: 200, id: "sync" });
+const cancelSync = () => machine.cancel("sync");
+const reschedule = (delay = 50) => machine.raise(({ event }) => event, { delay });
+const isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
+const withoutSnapshotChanges = filter(isNot(isLayoutChange));
+const saveStateBeforeEdit = () => machine.assign(({ system }) => {
+  const parentContext = getDiagramContext(system);
+  return {
+    beforeEditing: {
+      xynodes: parentContext.xynodes.map(
+        ({ measured, ...n }) => ({
+          ...omit(n, ["selected", "dragging", "resizing"]),
+          data: omit(n.data, ["dimmed", "hovered"]),
+          measured,
+          initialWidth: measured?.width ?? n.width ?? n.initialWidth,
+          initialHeight: measured?.height ?? n.height ?? n.initialHeight
+        })
+      ),
+      xyedges: parentContext.xyedges.map(
+        (e) => ({
+          ...omit(e, ["selected"]),
+          data: omit(e.data, ["active", "dimmed", "hovered"])
+        })
+      ),
+      change: createViewChange(parentContext),
+      view: parentContext.view,
+      synched: false
+    }
+  };
+});
+const startEditing = () => machine.enqueueActions(({ enqueue, event }) => {
+  enqueue(saveStateBeforeEdit());
+  if (event.type === "edit.start") {
+    enqueue.assign({
+      editing: event.subject
+    });
+  }
+});
+const stopHotkey = () => machine.stopChild("hotkey");
+const ensureHotKey = () => machine.enqueueActions(({ check, enqueue, self }) => {
+  const hasUndo = check("can undo");
+  const hotkey = self.getSnapshot().children["hotkey"];
+  if (!hasUndo && hotkey) {
+    enqueue.stopChild(hotkey);
+    return;
+  }
+  if (hasUndo && !hotkey) {
+    enqueue.spawnChild("hotkey", {
+      id: "hotkey"
+    });
+  }
+});
+const pushHistory = () => machine.assign(({ context }) => {
+  const snapshot = context.beforeEditing;
+  if (!snapshot) {
+    return {
+      editing: null
+    };
+  }
+  return {
+    beforeEditing: null,
+    editing: null,
+    history: [
+      ...context.history,
+      snapshot
+    ]
+  };
+});
+const stopEditing = () => machine.enqueueActions(({ event, enqueue }) => {
+  if (event.type === "edit.finish" && event.wasChanged) {
+    enqueue(pushHistory());
+    enqueue(raiseSync());
+    return;
+  }
+  enqueue.assign({
+    beforeEditing: null,
+    editing: null
+  });
+});
+const markHistoryAsSynched = () => machine.assign(({ context }) => {
+  return {
+    beforeEditing: context.beforeEditing && context.beforeEditing.synched === false ? {
+      ...context.beforeEditing,
+      synched: true
+    } : context.beforeEditing,
+    history: context.history.map((i) => ({
+      ...i,
+      synched: true
+    }))
+  };
+});
+const popHistory = () => machine.assign(({ context }) => {
+  if (context.history.length <= 1) {
+    return {
+      history: []
+    };
+  }
+  return {
+    history: context.history.slice(0, context.history.length - 1)
+  };
+});
+const undo = () => machine.enqueueActions(({ context, enqueue, system }) => {
+  const lastHistoryItem = last(context.history);
+  if (!lastHistoryItem) {
+    return;
+  }
+  enqueue(cancelSync());
+  enqueue(popHistory());
+  enqueue(ensureHotKey());
+  const diagramActor = diagramActorRef(system);
+  enqueue.sendTo(diagramActor, {
+    type: "update.view",
+    view: lastHistoryItem.view,
+    xyedges: lastHistoryItem.xyedges,
+    xynodes: lastHistoryItem.xynodes,
+    source: "editor"
+  });
+  enqueue.assign({
+    pendingChanges: []
+  });
+  if (lastHistoryItem.synched) {
+    enqueue.raise({ type: "change", change: lastHistoryItem.change }, { delay: 50 });
+  } else {
+    enqueue(raiseSync());
+  }
+});
+const addSnapshotToPendingChanges = () => machine.assign(({ context, system }) => {
+  const parentContext = getDiagramContext(system);
+  const change = createViewChange(parentContext);
+  return {
+    pendingChanges: [
+      // Remove all save-view-snapshot and reset-manual-layout changes
+      ...withoutSnapshotChanges(context.pendingChanges),
+      change
+    ]
+  };
+});
+
+export { addSnapshotToPendingChanges, cancelSync, ensureHotKey, isLayoutChange, markHistoryAsSynched, popHistory, pushHistory, raiseSync, reschedule, saveStateBeforeEdit, startEditing, stopEditing, stopHotkey, undo, withoutSnapshotChanges };