@likec4/diagram 1.55.1 → 1.57.0

package/dist/editor/actor/state.sync-queue.d.ts

@@ -0,0 +1,420 @@
+import { ActionFunction, PromiseActorLogic, EventObject, NonReducibleUnknown, GuardArgs, ActorRef, MachineSnapshot, AnyActorRef, StateValue, AnyEventObject, DoneActorEvent, ActionArgs, ErrorActorEvent } from 'xstate';
+import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
+import { HotkeyActorLogic } from './hotkey';
+import { DiagramView, Any, ViewId, ViewChange } from '@likec4/core';
+export declare const syncQueue: {
+    initial: string;
+    states: {
+        idle: {
+            always: {
+                target: "#queue-pending";
+                guard: "has pending";
+            };
+            on: {
+                'change.sync-snapshot': {
+                    target: "#queue-pending";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>;
+                };
+                'change.*': {
+                    target: "#queue-process";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>;
+                };
+                undo: {
+                    target: "#queue-idle";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                    reenter: true;
+                };
+            };
+            id: string;
+        };
+        pending: {
+            on: {
+                'change.sync-snapshot': {
+                    target: "#queue-pending";
+                    reenter: true;
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>;
+                };
+                'change.*': {
+                    target: "#queue-process";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>;
+                };
+                'edit.move.start': {
+                    target: "#queue-suspended";
+                };
+                undo: {
+                    target: "#queue-idle";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                'view.synched': {
+                    target: "#queue-process";
+                    guard: "has pending";
+                    actions: () => void;
+                };
+            };
+            after: {
+                'wait-after-edit': ({
+                    target: "#queue-process";
+                    guard: "has pending";
+                } | {
+                    target: "#queue-idle";
+                })[];
+            };
+            id: string;
+        };
+        suspended: {
+            on: {
+                undo: {
+                    target: "#queue-idle";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                'edit.*': {
+                    target: "#queue-pending";
+                };
+                'change.*': {
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
+                };
+                cancel: {
+                    target: "#queue-idle";
+                };
+            };
+            id: string;
+        };
+        process: {
+            initial: string;
+            tags: "busy"[];
+            states: {
+                enter: {
+                    entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>;
+                    always: ({
+                        guard: ({ context: { processing } }: GuardArgs<EditorActorContext, EditorActorEvent>) => boolean;
+                        target: string;
+                    } | {
+                        target: string;
+                        guard?: never;
+                    })[];
+                };
+                /**
+                 * Syncing state, some edits are not yet synced
+                 */
+                applyLatestToManual: {
+                    initial: string;
+                    states: {
+                        call: {
+                            invoke: {
+                                src: "applyLatest";
+                                input: ({ context }: {
+                                    context: EditorActorContext;
+                                    event: EditorActorEvent;
+                                    self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                                }) => {
+                                    current: DiagramView<Any> | undefined;
+                                    viewId: ViewId;
+                                };
+                                onDone: {
+                                    actions: ActionFunction<EditorActorContext, DoneActorEvent<import("./setup").EditorCalls.ApplyLatestToManual.Output, string>, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
+                                    target: string;
+                                };
+                                onError: {
+                                    target: "#queue-idle";
+                                    actions: (({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void)[];
+                                };
+                            };
+                        };
+                        wait: {
+                            entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                                src: "hotkey";
+                                logic: HotkeyActorLogic;
+                                id: "hotkey";
+                            } | {
+                                src: "applyLatest";
+                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                                id: string | undefined;
+                            } | {
+                                src: "executeChange";
+                                logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                                id: string | undefined;
+                            } | {
+                                src: "applySemanticLayout";
+                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                                id: string | undefined;
+                            }, never, never, never, never>;
+                            after: {
+                                '500ms': {
+                                    target: "#queue-idle";
+                                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
+                                };
+                            };
+                        };
+                    };
+                };
+                /**
+                 * User requested semantic layout, we will call the AI
+                 */
+                applySemanticLayout: {
+                    tags: "ai-semantic-layout"[];
+                    invoke: {
+                        src: "applySemanticLayout";
+                        input: ({ context }: {
+                            context: EditorActorContext;
+                            event: EditorActorEvent;
+                            self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                        }) => {
+                            viewId: ViewId;
+                        };
+                        onDone: {
+                            target: string;
+                        };
+                        onError: {
+                            actions: (({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void)[];
+                            target: string;
+                        };
+                    };
+                };
+                /**
+                 * Calls `executeChange` to save the snapshot
+                 */
+                executeChanges: {
+                    invoke: {
+                        src: "executeChange";
+                        input: ({ context: { processing, syncQueue, viewId } }: {
+                            context: EditorActorContext;
+                            event: EditorActorEvent;
+                            self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                        }) => {
+                            changes: ViewChange[];
+                            viewId: ViewId;
+                        };
+                        onDone: {
+                            actions: ActionFunction<EditorActorContext, DoneActorEvent<NonReducibleUnknown, string>, EditorActorEvent, undefined, {
+                                src: "hotkey";
+                                logic: HotkeyActorLogic;
+                                id: "hotkey";
+                            } | {
+                                src: "applyLatest";
+                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                                id: string | undefined;
+                            } | {
+                                src: "executeChange";
+                                logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                                id: string | undefined;
+                            } | {
+                                src: "applySemanticLayout";
+                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                                id: string | undefined;
+                            }, never, {
+                                type: "has pending";
+                                params: unknown;
+                            } | {
+                                type: "can undo";
+                                params: unknown;
+                            }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                            target: string;
+                        };
+                        onError: {
+                            target: "#queue-idle";
+                            actions: ActionFunction<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent, undefined, {
+                                src: "hotkey";
+                                logic: HotkeyActorLogic;
+                                id: "hotkey";
+                            } | {
+                                src: "applyLatest";
+                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                                id: string | undefined;
+                            } | {
+                                src: "executeChange";
+                                logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                                id: string | undefined;
+                            } | {
+                                src: "applySemanticLayout";
+                                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                                id: string | undefined;
+                            }, never, never, never, never>;
+                        };
+                    };
+                };
+                decideNext: {
+                    entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>;
+                    always: ({
+                        guard: "has pending";
+                        target: string;
+                    } | {
+                        target: "#queue-idle";
+                        guard?: never;
+                    })[];
+                };
+            };
+            on: {
+                'change.*': {
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
+                };
+                'view.synched': {
+                    actions: () => void;
+                };
+            };
+            id: string;
+        };
+    };
+    on: {};
+};

package/dist/editor/actor/state.sync-queue.js

@@ -0,0 +1,235 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { machine } from "./setup.js";
+import { typedSystem } from "../../likec4diagram/state/utils.js";
+import { isViewChange } from "./types.js";
+import { makeSnapshot, pushToSyncQueue, reschedule, scheduleSync, undo } from "./actions.js";
+import { isNot } from "remeda";
+import { invariant } from "@likec4/core";
+import { assign, enqueueActions, sendTo } from "xstate";
+//#region src/editor/actor/state.sync-queue.ts
+var to = {
+	idle: { target: "#queue-idle" },
+	pending: { target: "#queue-pending" },
+	suspended: { target: "#queue-suspended" },
+	process: { target: "#queue-process" }
+};
+var idOf = (t) => ({ id: t.target.substring(1) });
+/**
+* Idle state, no pending operations
+*/
+var idle = machine.createStateConfig({
+	...idOf(to.idle),
+	always: {
+		guard: "has pending",
+		...to.pending
+	},
+	on: {
+		"change.sync-snapshot": {
+			actions: pushToSyncQueue(),
+			...to.pending
+		},
+		"change.*": {
+			actions: pushToSyncQueue(),
+			...to.process
+		},
+		"undo": {
+			actions: undo(),
+			reenter: true,
+			...to.idle
+		}
+	}
+});
+/**
+* Has pending operations
+*/
+var pending = machine.createStateConfig({
+	...idOf(to.pending),
+	on: {
+		"change.sync-snapshot": {
+			reenter: true,
+			actions: pushToSyncQueue(),
+			...to.pending
+		},
+		"change.*": {
+			actions: pushToSyncQueue(),
+			...to.process
+		},
+		"edit.move.start": { ...to.suspended },
+		"undo": {
+			actions: undo(),
+			...to.idle
+		},
+		"view.synched": {
+			guard: "has pending",
+			actions: () => {},
+			...to.process
+		}
+	},
+	after: { "wait-after-edit": [{
+		guard: "has pending",
+		...to.process
+	}, { ...to.idle }] }
+});
+/**
+* When editing starts, we suspend the queue
+*/
+var suspended = machine.createStateConfig({
+	...idOf(to.suspended),
+	on: {
+		"undo": {
+			actions: undo(),
+			...to.idle
+		},
+		"edit.*": { ...to.pending },
+		"change.*": { actions: reschedule() },
+		"cancel": { ...to.idle }
+	}
+});
+var peekFromQueue = () => machine.assign(({ system, context: { syncQueue, processing } }) => {
+	if (processing) return {};
+	let [head, ...tail] = syncQueue;
+	if (head === "sync-snapshot") head = makeSnapshot(system).change;
+	return {
+		processing: head ?? null,
+		syncQueue: tail
+	};
+});
+var clearProcessing = () => ({ processing: null });
+/**
+* Processing pending operation
+*/
+var process = machine.createStateConfig({
+	...idOf(to.process),
+	initial: "enter",
+	tags: ["busy"],
+	states: {
+		enter: {
+			entry: peekFromQueue(),
+			always: [
+				{
+					guard: ({ context: { processing } }) => !processing,
+					...to.idle
+				},
+				{
+					guard: ({ context: { processing } }) => processing === "apply-latest-to-manual",
+					target: "applyLatestToManual"
+				},
+				{
+					guard: ({ context: { processing } }) => processing === "apply-semantic-layout",
+					target: "applySemanticLayout"
+				},
+				{ target: "executeChanges" }
+			]
+		},
+		/**
+		* Syncing state, some edits are not yet synced
+		*/
+		applyLatestToManual: machine.createStateConfig({
+			initial: "call",
+			states: {
+				call: { invoke: {
+					src: "applyLatest",
+					input: ({ context }) => {
+						const current = context.history?.head.change.layout;
+						return {
+							current: current?._layout === "manual" ? current : void 0,
+							viewId: context.viewId
+						};
+					},
+					onDone: {
+						actions: sendTo(typedSystem.diagramActor, ({ event }) => ({
+							type: "update.view",
+							view: event.output.updated
+						}), { delay: 10 }),
+						target: "wait"
+					},
+					onError: {
+						actions: [({ event }) => {
+							console.error(event.error);
+						}],
+						...to.idle
+					}
+				} },
+				wait: {
+					entry: assign(clearProcessing),
+					after: { "500ms": {
+						actions: scheduleSync(),
+						...to.idle
+					} }
+				}
+			}
+		}),
+		/**
+		* User requested semantic layout, we will call the AI
+		*/
+		applySemanticLayout: machine.createStateConfig({
+			tags: ["ai-semantic-layout"],
+			invoke: {
+				src: "applySemanticLayout",
+				input: ({ context }) => ({ viewId: context.viewId }),
+				onDone: { target: "decideNext" },
+				onError: {
+					actions: [({ event }) => {
+						console.error(event.error);
+					}],
+					target: "decideNext"
+				}
+			}
+		}),
+		/**
+		* Calls `executeChange` to save the snapshot
+		*/
+		executeChanges: machine.createStateConfig({ invoke: {
+			src: "executeChange",
+			input: ({ context: { processing, syncQueue, viewId } }) => {
+				invariant(processing && isViewChange(processing));
+				return {
+					changes: [processing, ...syncQueue.filter(isViewChange)],
+					viewId
+				};
+			},
+			onDone: {
+				actions: enqueueActions(({ context, event, enqueue }) => {
+					enqueue.assign({
+						processing: null,
+						syncQueue: context.syncQueue.filter(isNot(isViewChange))
+					});
+				}),
+				target: "decideNext"
+			},
+			onError: {
+				actions: assign(({ event }) => {
+					console.error("executeChanges onError", { error: event.error });
+					return {
+						processing: null,
+						syncQueue: []
+					};
+				}),
+				...to.idle
+			}
+		} }),
+		decideNext: {
+			entry: assign(clearProcessing),
+			always: [{
+				guard: "has pending",
+				target: "enter"
+			}, { ...to.idle }]
+		}
+	},
+	on: {
+		"change.*": { actions: reschedule() },
+		"view.synched": { actions: () => {} }
+	}
+});
+var syncQueue = machine.createStateConfig({
+	initial: "idle",
+	states: {
+		idle,
+		pending,
+		suspended,
+		process
+	},
+	on: {}
+});
+//#endregion
+export { syncQueue };