@likec4/diagram 1.55.1 → 1.56.0

package/dist/editor/editorActor.setup.js

@@ -1,38 +1,32 @@
-import { setup, fromPromise } from 'xstate';
-import { hotkeyActorLogic } from './hotkeyActor.js';
-
-const applyLatest = fromPromise(
-  () => {
-    throw new Error("Not implemented");
-  }
-);
-const executeChange = fromPromise(
-  () => {
-    throw new Error("Not implemented");
-  }
-);
-const machine = setup({
-  types: {
-    context: {},
-    events: {},
-    emitted: {},
-    input: {},
-    children: {},
-    tags: {}
-  },
-  delays: {
-    "500ms": 500,
-    "waitBeforeSync": 1e3
-  },
-  actors: {
-    applyLatest,
-    executeChange,
-    hotkey: hotkeyActorLogic
-  },
-  guards: {
-    "has pending": ({ context }) => context.pendingChanges.length > 0,
-    "can undo": ({ context }) => context.history.length > 0
-  }
+import "../_virtual/_rolldown/runtime.js";
+import { hotkeyActorLogic } from "./hotkeyActor.js";
+import { fromPromise, setup } from "xstate";
+var machine = setup({
+	types: {
+		context: {},
+		events: {},
+		emitted: {},
+		input: {},
+		children: {},
+		tags: {}
+	},
+	delays: {
+		"500ms": 500,
+		"waitBeforeSync": 1e3
+	},
+	actors: {
+		applyLatest: fromPromise(() => {
+			throw new Error("Not implemented");
+		}),
+		executeChange: fromPromise(() => {
+			throw new Error("Not implemented");
+		}),
+		hotkey: hotkeyActorLogic
+	},
+	guards: {
+		"has pending": ({ context }) => context.pendingChanges.length > 0,
+		"can undo": ({ context }) => context.history.length > 0
+	}
 });
-
+//#endregion
 export { machine };

package/dist/editor/editorActor.states.js

@@ -1,273 +1,219 @@
-import { find } from 'remeda';
-import { assign, enqueueActions, log, sendTo } from 'xstate';
-import { cancelSync, stopHotkey, undo, markHistoryAsSynched, isLayoutChange, withoutSnapshotChanges, addSnapshotToPendingChanges, ensureHotKey, reschedule, pushHistory, saveStateBeforeEdit, stopEditing, startEditing } from './editorActor.actions.js';
-import { machine } from './editorActor.setup.js';
-
-const diagramActorRef = function(params) {
-  return params.system.get("diagram");
+import "../_virtual/_rolldown/runtime.js";
+import { machine } from "./editorActor.setup.js";
+import { addSnapshotToPendingChanges, cancelSync, ensureHotKey, isLayoutChange, markHistoryAsSynched, pushHistory, reschedule, saveStateBeforeEdit, startEditing, stopEditing, stopHotkey, undo, withoutSnapshotChanges } from "./editorActor.actions.js";
+import { find } from "remeda";
+import { assign, enqueueActions, log, sendTo } from "xstate";
+//#region src/editor/editorActor.states.ts
+/**
+* Actually this is DiagramActorRef
+* But we can't use it here due to circular type inference
+*/
+var diagramActorRef = function(params) {
+	return params.system.get("diagram");
 };
-const to = {
-  idle: { target: "#idle" },
-  editing: { target: "#editing" },
-  afterEdit: { target: "#afterEdit" },
-  pending: { target: "#pending" },
-  applyLatestToManual: { target: "#applyLatestToManual" },
-  executeChanges: { target: "#executeChanges" }
+var to = {
+	idle: { target: "#idle" },
+	editing: { target: "#editing" },
+	afterEdit: { target: "#afterEdit" },
+	pending: { target: "#pending" },
+	applyLatestToManual: { target: "#applyLatestToManual" },
+	executeChanges: { target: "#executeChanges" }
 };
-const idle = machine.createStateConfig({
-  id: "idle",
-  on: {
-    "sync": {
-      ...to.pending
-    },
-    "edit.start": {
-      ...to.editing
-    }
-  }
+/**
+* Idle state, no pending operations
+*/
+var idle = machine.createStateConfig({
+	id: "idle",
+	on: {
+		"sync": { ...to.pending },
+		"edit.start": { ...to.editing }
+	}
 });
-const editing = machine.createStateConfig({
-  id: "editing",
-  tags: "pending",
-  entry: [
-    startEditing(),
-    cancelSync()
-  ],
-  on: {
-    change: {
-      actions: stopEditing(),
-      ...to.executeChanges
-    },
-    "edit.finish": {
-      actions: stopEditing(),
-      ...to.afterEdit
-    },
-    "undo": {
-      actions: stopEditing(),
-      ...to.idle
-    }
-  }
+/**
+* Edit state, some operation is in progress, come to this state from idle
+*/
+var editing = machine.createStateConfig({
+	id: "editing",
+	tags: "pending",
+	entry: [startEditing(), cancelSync()],
+	on: {
+		change: {
+			actions: stopEditing(),
+			...to.executeChanges
+		},
+		"edit.finish": {
+			actions: stopEditing(),
+			...to.afterEdit
+		},
+		"undo": {
+			actions: stopEditing(),
+			...to.idle
+		}
+	}
 });
-const pending = machine.createStateConfig({
-  id: "pending",
-  tags: ["pending"],
-  entry: ensureHotKey(),
-  on: {
-    "sync": {
-      reenter: true,
-      ...to.pending
-    },
-    "edit.start": {
-      // this allows to return back from editing in afterEdit state
-      actions: [
-        addSnapshotToPendingChanges()
-      ],
-      ...to.editing
-    }
-  },
-  after: {
-    "waitBeforeSync": {
-      actions: [
-        addSnapshotToPendingChanges()
-      ],
-      ...to.executeChanges
-    }
-  }
+/**
+* Syncing state, some edits are not yet synced
+*/
+var pending = machine.createStateConfig({
+	id: "pending",
+	tags: ["pending"],
+	entry: ensureHotKey(),
+	on: {
+		"sync": {
+			reenter: true,
+			...to.pending
+		},
+		"edit.start": {
+			actions: [addSnapshotToPendingChanges()],
+			...to.editing
+		}
+	},
+	after: { "waitBeforeSync": {
+		actions: [addSnapshotToPendingChanges()],
+		...to.executeChanges
+	} }
 });
-const afterEdit = machine.createStateConfig({
-  id: "afterEdit",
-  always: [
-    { guard: "has pending", ...to.pending },
-    { ...to.idle }
-  ]
+/**
+* Decide where to go next
+*/
+var afterEdit = machine.createStateConfig({
+	id: "afterEdit",
+	always: [{
+		guard: "has pending",
+		...to.pending
+	}, { ...to.idle }]
 });
-const applyLatestToManual = machine.createStateConfig({
-  id: "applyLatestToManual",
-  entry: [
-    cancelSync(),
-    saveStateBeforeEdit()
-  ],
-  initial: "call",
-  states: {
-    // Fetch latest and manual layouts
-    // Apply changes, send update to diagram
-    call: {
-      invoke: {
-        src: "applyLatest",
-        input: ({ context }) => {
-          const current = context.beforeEditing?.change.layout;
-          return {
-            current: current && current._layout === "manual" ? current : void 0,
-            viewId: context.viewId
-          };
-        },
-        onDone: {
-          actions: sendTo(
-            diagramActorRef,
-            ({ event }) => ({
-              type: "update.view",
-              view: event.output.updated
-            }),
-            { delay: 10 }
-          ),
-          target: "wait"
-        },
-        onError: {
-          actions: [
-            assign({
-              beforeEditing: null,
-              pendingChanges: []
-            }),
-            ({ event }) => {
-              console.error(event.error);
-            }
-          ],
-          ...to.idle
-        }
-      }
-    },
-    // Now we wait 350ms, take new snapshot and send save-view-snapshot
-    wait: {
-      entry: pushHistory(),
-      on: {
-        "*": {
-          actions: [
-            log(({ event }) => `wait received unexpected event: ${event.type}`),
-            reschedule(500)
-          ]
-        }
-      },
-      after: {
-        "500ms": {
-          actions: [
-            addSnapshotToPendingChanges(),
-            ensureHotKey()
-          ],
-          ...to.executeChanges
-        }
-      }
-    }
-  }
+/**
+* Syncing state, some edits are not yet synced
+*/
+var applyLatestToManual = machine.createStateConfig({
+	id: "applyLatestToManual",
+	entry: [cancelSync(), saveStateBeforeEdit()],
+	initial: "call",
+	states: {
+		call: { invoke: {
+			src: "applyLatest",
+			input: ({ context }) => {
+				const current = context.beforeEditing?.change.layout;
+				return {
+					current: current && current._layout === "manual" ? current : void 0,
+					viewId: context.viewId
+				};
+			},
+			onDone: {
+				actions: sendTo(diagramActorRef, ({ event }) => ({
+					type: "update.view",
+					view: event.output.updated
+				}), { delay: 10 }),
+				target: "wait"
+			},
+			onError: {
+				actions: [assign({
+					beforeEditing: null,
+					pendingChanges: []
+				}), ({ event }) => {
+					console.error(event.error);
+				}],
+				...to.idle
+			}
+		} },
+		wait: {
+			entry: pushHistory(),
+			on: { "*": { actions: [log(({ event }) => `wait received unexpected event: ${event.type}`), reschedule(500)] } },
+			after: { "500ms": {
+				actions: [addSnapshotToPendingChanges(), ensureHotKey()],
+				...to.executeChanges
+			} }
+		}
+	}
 });
-const executeChanges = machine.createStateConfig({
-  id: "executeChanges",
-  entry: [
-    assign(({ event, context }) => {
-      if (event.type === "change") {
-        if (isLayoutChange(event.change)) {
-          return {
-            pendingChanges: [
-              ...withoutSnapshotChanges(context.pendingChanges),
-              event.change
-            ]
-          };
-        }
-        if (!context.pendingChanges.includes(event.change)) {
-          return {
-            pendingChanges: [
-              ...context.pendingChanges,
-              event.change
-            ]
-          };
-        }
-      }
-      return {};
-    }),
-    cancelSync()
-  ],
-  invoke: {
-    src: "executeChange",
-    input: ({ context }) => ({
-      changes: context.pendingChanges,
-      viewId: context.viewId
-    }),
-    onDone: {
-      actions: enqueueActions(({ context, event, enqueue }) => {
-        const snapshot = find(context.pendingChanges, (c) => c.op === "save-view-snapshot");
-        if (snapshot) {
-          enqueue.sendTo(
-            diagramActorRef,
-            {
-              type: "update.view-bounds",
-              bounds: snapshot.layout.bounds
-            }
-          );
-        }
-        enqueue.assign({
-          pendingChanges: []
-        });
-      }),
-      ...to.idle
-    },
-    onError: {
-      actions: assign(({ event }) => {
-        console.error("executeChanges onError", { error: event.error });
-        return {
-          pendingChanges: []
-        };
-      }),
-      ...to.idle
-    }
-  }
+/**
+* Calls `executeChange` to save the snapshot
+*/
+var executeChanges = machine.createStateConfig({
+	id: "executeChanges",
+	entry: [assign(({ event, context }) => {
+		if (event.type === "change") {
+			if (isLayoutChange(event.change)) return { pendingChanges: [...withoutSnapshotChanges(context.pendingChanges), event.change] };
+			if (!context.pendingChanges.includes(event.change)) return { pendingChanges: [...context.pendingChanges, event.change] };
+		}
+		return {};
+	}), cancelSync()],
+	invoke: {
+		src: "executeChange",
+		input: ({ context }) => ({
+			changes: context.pendingChanges,
+			viewId: context.viewId
+		}),
+		onDone: {
+			actions: enqueueActions(({ context, event, enqueue }) => {
+				const snapshot = find(context.pendingChanges, (c) => c.op === "save-view-snapshot");
+				if (snapshot) enqueue.sendTo(diagramActorRef, {
+					type: "update.view-bounds",
+					bounds: snapshot.layout.bounds
+				});
+				enqueue.assign({ pendingChanges: [] });
+			}),
+			...to.idle
+		},
+		onError: {
+			actions: assign(({ event }) => {
+				console.error("executeChanges onError", { error: event.error });
+				return { pendingChanges: [] };
+			}),
+			...to.idle
+		}
+	}
 });
-const _editorActorLogic = machine.createMachine({
-  id: "editor",
-  context: ({ input }) => ({
-    viewId: input.viewId,
-    beforeEditing: null,
-    editing: null,
-    pendingChanges: [],
-    history: []
-  }),
-  initial: "idle",
-  states: {
-    idle,
-    editing,
-    pending,
-    afterEdit,
-    applyLatestToManual,
-    executeChanges
-  },
-  on: {
-    cancel: {
-      actions: [
-        cancelSync(),
-        assign({
-          editing: null,
-          beforeEditing: null,
-          pendingChanges: []
-        })
-      ],
-      ...to.idle
-    },
-    synced: {
-      actions: markHistoryAsSynched()
-    },
-    undo: {
-      guard: "can undo",
-      actions: undo(),
-      ...to.idle
-    },
-    change: {
-      ...to.executeChanges
-    },
-    "applyLatestToManual": {
-      ...to.applyLatestToManual
-    },
-    reset: {
-      actions: [
-        cancelSync(),
-        assign({
-          history: [],
-          editing: null,
-          beforeEditing: null,
-          pendingChanges: []
-        }),
-        stopHotkey()
-      ],
-      ...to.idle
-    }
-  }
+var editorActorLogic = machine.createMachine({
+	id: "editor",
+	context: ({ input }) => ({
+		viewId: input.viewId,
+		beforeEditing: null,
+		editing: null,
+		pendingChanges: [],
+		history: []
+	}),
+	initial: "idle",
+	states: {
+		idle,
+		editing,
+		pending,
+		afterEdit,
+		applyLatestToManual,
+		executeChanges
+	},
+	on: {
+		cancel: {
+			actions: [cancelSync(), assign({
+				editing: null,
+				beforeEditing: null,
+				pendingChanges: []
+			})],
+			...to.idle
+		},
+		synced: { actions: markHistoryAsSynched() },
+		undo: {
+			guard: "can undo",
+			actions: undo(),
+			...to.idle
+		},
+		change: { ...to.executeChanges },
+		"applyLatestToManual": { ...to.applyLatestToManual },
+		reset: {
+			actions: [
+				cancelSync(),
+				assign({
+					history: [],
+					editing: null,
+					beforeEditing: null,
+					pendingChanges: []
+				}),
+				stopHotkey()
+			],
+			...to.idle
+		}
+	}
 });
-const editorActorLogic = _editorActorLogic;
-
+//#endregion
 export { editorActorLogic };

package/dist/editor/hotkeyActor.js

@@ -1,19 +1,20 @@
-import { getHotkeyHandler } from '@mantine/hooks';
-import { fromCallback } from 'xstate';
-
-const hotkeyActorLogic = fromCallback(({ sendBack }) => {
-  const ctrlZHandler = getHotkeyHandler([
-    ["mod + z", (event) => {
-      event.stopPropagation();
-      sendBack({ type: "undo" });
-    }, {
-      preventDefault: true
-    }]
-  ]);
-  document.body.addEventListener("keydown", ctrlZHandler, { capture: true });
-  return () => {
-    document.body.removeEventListener("keydown", ctrlZHandler, { capture: true });
-  };
+import "../_virtual/_rolldown/runtime.js";
+import { getHotkeyHandler } from "@mantine/hooks";
+import { fromCallback } from "xstate";
+//#region src/editor/hotkeyActor.ts
+var hotkeyActorLogic = fromCallback(({ sendBack }) => {
+	const ctrlZHandler = getHotkeyHandler([[
+		"mod + z",
+		(event) => {
+			event.stopPropagation();
+			sendBack({ type: "undo" });
+		},
+		{ preventDefault: true }
+	]]);
+	document.body.addEventListener("keydown", ctrlZHandler, { capture: true });
+	return () => {
+		document.body.removeEventListener("keydown", ctrlZHandler, { capture: true });
+	};
 });
-
+//#endregion
 export { hotkeyActorLogic };