@likec4/diagram 1.59.3 → 1.60.0

package/dist/editor/LikeC4EditorCallbacks.d.ts

@@ -1,42 +0,0 @@
-import type * as t from '@likec4/core/types';
-/**
- * Result of applying a change from the LikeC4 Editor.
- */
-export interface LikeC4EditorChangeResult {
-    /**
-     * Whether applying the change will publish a refreshed view to the diagram
-     * that the editor should wait for.
-     *
-     * Returning no result from `handleChange` defaults this to `true`,
-     * preserving the existing behavior for integrations that persist changes
-     * through an external model service.
-     */
-    waitForViewSync: boolean;
-}
-export declare function shouldWaitForViewSync(result?: void | LikeC4EditorChangeResult): boolean;
-/**
- * Callbacks from LikeC4 Editor.
- */
-export interface LikeC4EditorCallbacks {
-    /**
-     * Apply semantic layout to a view (if AI is available)
-     * See vite-plugin settings for more details
-     */
-    applySemanticLayout?: undefined | ((viewId: t.ViewId) => Promise<void>);
-    /**
-     * Fetch a view by its ID and layout type.
-     *
-     * @param viewId - The ID of the view to fetch.
-     * @param layout - The layout type to use when fetching the view.
-     */
-    fetchView(viewId: t.ViewId, layout?: t.LayoutType): t.LayoutedView | Promise<t.LayoutedView>;
-    /**
-     * Callback invoked when the view changes.
-     *
-     * Return `{ waitForViewSync: false }` when the integration applies the
-     * change locally and will not publish a refreshed view. When changes are
-     * batched, the editor waits if any callback invocation expects a refresh.
-     */
-    handleChange(viewId: t.ViewId, change: t.ViewChange): void | LikeC4EditorChangeResult | Promise<void | LikeC4EditorChangeResult>;
-}
-export declare function createLikeC4Editor(callbacks: LikeC4EditorCallbacks): LikeC4EditorCallbacks;

package/dist/editor/LikeC4EditorCallbacks.js

@@ -1,10 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-//#region src/editor/LikeC4EditorCallbacks.tsx
-function shouldWaitForViewSync(result) {
-	return result?.waitForViewSync ?? true;
-}
-function createLikeC4Editor(callbacks) {
-	return callbacks;
-}
-//#endregion
-export { createLikeC4Editor, shouldWaitForViewSync };

package/dist/editor/LikeC4EditorProvider.d.ts

@@ -1,34 +0,0 @@
-import { PropsWithChildren } from 'react';
-import { LikeC4EditorCallbacks } from './LikeC4EditorCallbacks';
-export type LikeC4EditorProviderProps = PropsWithChildren<{
-    editor: LikeC4EditorCallbacks;
-}>;
-/**
- * Provider for the LikeC4 Editor.
- * @example
- * ```tsx
- *
- * // Not required to use memo for editor callbacks
- * const editor = createLikeC4Editor({
- *   fetchView: async (viewId, layout) => {
- *     // fetch view logic
- *   },
- *   handleChange: (viewId, change) => {
- *     // handle change logic
- *   }
- * })
- *
- * <LikeC4EditorProvider
- *  editor={editor}>
- *   <App />
- * </LikeC4EditorProvider>
- * ```
- */
-export declare function LikeC4EditorProvider({ children, editor }: LikeC4EditorProviderProps): import("react").JSX.Element;
-/**
- * Component that ensures the editor context is available.
- *
- * @param children - The children to render.
- */
-export declare function EnsureEditorContext({ children }: PropsWithChildren): import("react").JSX.Element | null;
-export declare function useOptionalLikeC4Editor(): LikeC4EditorCallbacks | null;

package/dist/editor/LikeC4EditorProvider.js

@@ -1,37 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-//#region src/editor/LikeC4EditorProvider.tsx
-var LikeC4EditorReactContext = createContext(null);
-/**
-* Provider for the LikeC4 Editor.
-* @example
-* ```tsx
-*
-* // Not required to use memo for editor callbacks
-* const editor = createLikeC4Editor({
-*   fetchView: async (viewId, layout) => {
-*     // fetch view logic
-*   },
-*   handleChange: (viewId, change) => {
-*     // handle change logic
-*   }
-* })
-*
-* <LikeC4EditorProvider
-*  editor={editor}>
-*   <App />
-* </LikeC4EditorProvider>
-* ```
-*/
-function LikeC4EditorProvider({ children, editor }) {
-	return /* @__PURE__ */ jsx(LikeC4EditorReactContext.Provider, {
-		value: editor,
-		children
-	});
-}
-function useOptionalLikeC4Editor() {
-	return useContext(LikeC4EditorReactContext);
-}
-//#endregion
-export { LikeC4EditorProvider, useOptionalLikeC4Editor };

package/dist/editor/actor/actions.d.ts

@@ -1,174 +0,0 @@
-import { ActorSystem, ActionFunction, CancelAction, PromiseActorLogic, EventObject } from 'xstate';
-import { Snapshot, SyncOp, EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
-import { HotkeyActorLogic } from './hotkey';
-import type * as t from '@likec4/core/types';
-export declare function makeSnapshot(system: ActorSystem<any>): Snapshot;
-type LayoutChanges = t.ViewChange.ResetManualLayout | t.ViewChange.SaveViewSnapshot;
-export declare const isLayoutChange: (change: t.ViewChange) => change is LayoutChanges;
-export declare const isLayoutChangeOp: <T extends SyncOp>(op: T) => op is Extract<T, string | LayoutChanges>;
-export declare const withoutSnapshotChanges: (data: t.ViewChange[]) => (t.ViewChange.ChangeElementStyle | t.ViewChange.ChangeAutoLayout | t.ViewChange.ChangeProperty)[];
-export declare const scheduleSync: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
-export declare const cancelSync: () => CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
-/**
- * Save the state before editing starts
- */
-export declare const saveBeforeEditing: () => 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<import("./setup").EditorCalls.ExecuteChange.Output, 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>;
-/**
- * When editing finishes, push the "beforeEditing" state to the history stack
- */
-export declare const pushHistory: () => 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<import("./setup").EditorCalls.ExecuteChange.Output, 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;
-} | {
-    type: "can redo";
-    params: unknown;
-}, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
-export declare const reschedule: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
-export declare const undo: () => 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<import("./setup").EditorCalls.ExecuteChange.Output, 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;
-} | {
-    type: "can redo";
-    params: unknown;
-}, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
-export declare const redo: () => 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<import("./setup").EditorCalls.ExecuteChange.Output, 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;
-} | {
-    type: "can redo";
-    params: unknown;
-}, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
-export declare const deleteNodesAndEdges: () => 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<import("./setup").EditorCalls.ExecuteChange.Output, 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;
-} | {
-    type: "can redo";
-    params: unknown;
-}, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
-export declare const pushToSyncQueue: () => 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<import("./setup").EditorCalls.ExecuteChange.Output, 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>;
-export declare const clearQueue: () => 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<import("./setup").EditorCalls.ExecuteChange.Output, 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>;
-export {};

package/dist/editor/actor/actions.js

@@ -1,188 +0,0 @@
-import "../../_virtual/_rolldown/runtime.js";
-import { machine } from "./setup.js";
-import { createViewChange } from "../../likec4diagram/state/createViewChange.js";
-import { typedSystem } from "../../likec4diagram/state/utils.js";
-import { filter, isNot, omit } from "remeda";
-import { assertEvent } from "xstate";
-//#region src/editor/actor/actions.ts
-/**
-* Actually this is DiagramActorRef
-* But we can't use it here due to circular type inference
-*/
-var getDiagramContext = function(system) {
-	return system.get("diagram").getSnapshot().context;
-};
-function makeSnapshot(system) {
-	const parentContext = getDiagramContext(system);
-	return {
-		xynodes: parentContext.xynodes.map(({ measured, data, ...n }) => ({
-			...omit(n, [
-				"selected",
-				"dragging",
-				"resizing"
-			]),
-			data: omit(data, ["dimmed", "hovered"]),
-			measured,
-			initialWidth: measured?.width ?? n.width ?? n.initialWidth,
-			initialHeight: measured?.height ?? n.height ?? n.initialHeight
-		})),
-		xyedges: parentContext.xyedges.map(({ data, ...e }) => ({
-			...omit(e, ["selected"]),
-			data: omit(data, [
-				"active",
-				"dimmed",
-				"hovered"
-			])
-		})),
-		change: createViewChange(parentContext),
-		view: parentContext.view
-	};
-}
-var isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
-var isLayoutChangeOp = (op) => op === "apply-latest-to-manual" || op === "apply-semantic-layout" || op === "sync-snapshot" || isLayoutChange(op);
-filter(isNot(isLayoutChange));
-var scheduleSync = (delay = 50) => {
-	return machine.raise({ type: "change.sync-snapshot" }, delay ? {
-		delay,
-		id: "sync-snapshot"
-	} : void 0);
-};
-var cancelSync = () => {
-	return machine.cancel("sync-snapshot");
-};
-/**
-* Save the state before editing starts
-*/
-var saveBeforeEditing = () => machine.assign(({ system, event }) => {
-	assertEvent(event, "edit.move.start");
-	return { editing: {
-		subject: event.subject,
-		before: makeSnapshot(system)
-	} };
-});
-/**
-* When editing finishes, push the "beforeEditing" state to the history stack
-*/
-var pushHistory = () => machine.enqueueActions(({ context, enqueue }) => {
-	const editing = context.editing;
-	if (editing) {
-		enqueue.assign({
-			editing: null,
-			history: {
-				head: editing.before,
-				tail: context.history
-			},
-			redo: null
-		});
-		enqueue(scheduleSync());
-	}
-});
-var undo = () => machine.enqueueActions(({ context: { history, redo }, system, enqueue }) => {
-	if (!history) return;
-	const last = history.head;
-	enqueue.assign({
-		history: history.tail,
-		redo: {
-			head: makeSnapshot(system),
-			tail: redo
-		}
-	});
-	enqueue(cancelSync());
-	enqueue(scheduleSync(100));
-	enqueue.sendTo(typedSystem.diagramActor, {
-		type: "update.view",
-		view: last.view,
-		xyedges: last.xyedges,
-		xynodes: last.xynodes,
-		source: "editor"
-	});
-});
-var redo = () => machine.enqueueActions(({ context: { history, redo }, system, enqueue }) => {
-	if (!redo) return;
-	const last = redo.head;
-	enqueue.assign({
-		history: {
-			head: makeSnapshot(system),
-			tail: history
-		},
-		redo: redo.tail
-	});
-	enqueue(cancelSync());
-	enqueue(scheduleSync(100));
-	enqueue.sendTo(typedSystem.diagramActor, {
-		type: "update.view",
-		view: last.view,
-		xyedges: last.xyedges,
-		xynodes: last.xynodes,
-		source: "editor"
-	});
-});
-var deleteNodesAndEdges = () => machine.enqueueActions(({ context, system, event, enqueue }) => {
-	assertEvent(event, "delete.nodes-edges");
-	const deletedNodeIds = new Set(event.nodeIds);
-	const willNotBeDeletedNode = (node) => !deletedNodeIds.has(typeof node === "string" ? node : node.id);
-	const snapshot = makeSnapshot(system);
-	const deletedEdgeIds = new Set(event.edgeIds);
-	for (const edge of snapshot.view.edges) if (deletedNodeIds.has(edge.source) || deletedNodeIds.has(edge.target)) deletedEdgeIds.add(edge.id);
-	const willNotBeDeletedEdge = (edge) => !deletedEdgeIds.has(typeof edge === "string" ? edge : edge.id);
-	enqueue.assign({
-		history: {
-			head: snapshot,
-			tail: context.history
-		},
-		redo: null
-	});
-	const cleanupNode = (node) => {
-		if (node.children.every(willNotBeDeletedNode) && node.inEdges.every(willNotBeDeletedEdge) && node.outEdges.every(willNotBeDeletedEdge)) return node;
-		return {
-			...node,
-			children: node.children.filter(willNotBeDeletedNode),
-			inEdges: node.inEdges.filter(willNotBeDeletedEdge),
-			outEdges: node.outEdges.filter(willNotBeDeletedEdge)
-		};
-	};
-	enqueue(cancelSync());
-	enqueue(scheduleSync());
-	enqueue.sendTo(typedSystem.diagramActor, {
-		type: "update.view",
-		view: {
-			...snapshot.view,
-			nodes: snapshot.view.nodes.filter(willNotBeDeletedNode).map(cleanupNode),
-			edges: snapshot.view.edges.filter(willNotBeDeletedEdge)
-		},
-		source: "editor"
-	});
-});
-var pushToSyncQueue = () => machine.assign(({ context: { syncQueue }, event }) => {
-	let nextOp;
-	switch (event.type) {
-		case "change.view":
-			nextOp = event.change;
-			break;
-		case "change.semantic-layout":
-			nextOp = "apply-semantic-layout";
-			break;
-		case "change.latest-to-manual":
-			nextOp = "apply-latest-to-manual";
-			break;
-		case "change.sync-snapshot":
-			nextOp = "sync-snapshot";
-			break;
-		default: throw new Error(`Invalid event type: ${event.type}`);
-	}
-	if (syncQueue.length === 0) return { syncQueue: [nextOp] };
-	if (syncQueue.length === 1 && syncQueue[0] === nextOp) return {};
-	const isNextLayoutChange = isLayoutChangeOp(nextOp);
-	let pending = syncQueue.filter((existingOp) => {
-		if (existingOp === nextOp) return false;
-		if (isNextLayoutChange && isLayoutChangeOp(existingOp)) return false;
-		return true;
-	});
-	return { syncQueue: pending.length > 0 ? [...pending, nextOp] : [nextOp] };
-});
-var clearQueue = () => machine.assign({
-	syncQueue: [],
-	processing: null
-});
-//#endregion
-export { cancelSync, clearQueue, deleteNodesAndEdges, isLayoutChange, isLayoutChangeOp, makeSnapshot, pushHistory, pushToSyncQueue, redo, saveBeforeEditing, scheduleSync, undo };

package/dist/editor/actor/hotkey.d.ts

@@ -1,7 +0,0 @@
-import { AnyEventObject, CallbackActorLogic, NonReducibleUnknown } from 'xstate';
-export type HotKeyEvent = {
-    type: 'undo' | 'redo';
-};
-export interface HotkeyActorLogic extends CallbackActorLogic<AnyEventObject, NonReducibleUnknown, HotKeyEvent> {
-}
-export declare const hotkey: HotkeyActorLogic;

package/dist/editor/actor/hotkey.js

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

package/dist/editor/actor/machine.d.ts

@@ -1,9 +0,0 @@
-import { ActorRef, SnapshotFrom } from 'xstate';
-import { BaseEditorActorLogic } from './setup';
-import { EditorActorEmitedEvent, EditorActorEvent } from './types';
-export interface EditorActorLogic extends BaseEditorActorLogic {
-}
-export declare const editorActorLogic: EditorActorLogic;
-export type EditorActorSnapshot = SnapshotFrom<EditorActorLogic>;
-export interface EditorActorRef extends ActorRef<EditorActorSnapshot, EditorActorEvent, EditorActorEmitedEvent> {
-}

package/dist/editor/actor/machine.js

@@ -1,23 +0,0 @@
-import "../../_virtual/_rolldown/runtime.js";
-import { machine } from "./setup.js";
-import { editor } from "./state.editor.js";
-import { syncQueue } from "./state.sync-queue.js";
-var editorActorLogic = machine.createMachine({
-	id: "editor",
-	context: ({ input }) => ({
-		viewId: input.viewId,
-		editing: null,
-		history: null,
-		redo: null,
-		pending: null,
-		syncQueue: [],
-		processing: null
-	}),
-	type: "parallel",
-	states: {
-		editor,
-		syncQueue
-	}
-});
-//#endregion
-export { editorActorLogic };

package/dist/editor/actor/setup.d.ts

@@ -1,70 +0,0 @@
-import { ActorRefFromLogic, StateMachine, StateValue, PromiseActorLogic, EventObject, SetupReturn, NonReducibleUnknown, MetaObject } from 'xstate';
-import { inferChildrenRef, inferProvidedActor } from '../../utils/defineActors';
-import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, EditorActorStateTag } from './types';
-import { HotkeyActorLogic } from './hotkey';
-import type * as t from '@likec4/core/types';
-export declare namespace EditorCalls {
-    type ApplyLatestToManual = (params: {
-        input: ApplyLatestToManual.Input;
-    }) => Promise<ApplyLatestToManual.Output>;
-    namespace ApplyLatestToManual {
-        type Input = {
-            viewId: t.ViewId;
-            current: t.LayoutedView | undefined;
-        };
-        type Output = {
-            updated: t.LayoutedView;
-        };
-    }
-    type ApplySemanticLayout = (params: {
-        input: ApplySemanticLayout.Input;
-    }) => Promise<ApplySemanticLayout.Output>;
-    namespace ApplySemanticLayout {
-        type Input = {
-            viewId: t.ViewId;
-        };
-        type Output = {};
-    }
-    type ExecuteChange = (params: {
-        input: ExecuteChange.Input;
-    }) => Promise<ExecuteChange.Output>;
-    namespace ExecuteChange {
-        type Input = {
-            viewId: t.ViewId;
-            changes: t.ViewChange[];
-        };
-        /**
-         * Returns the changes that were applied to the view
-         */
-        type Output = {
-            requested: t.ViewChange[];
-            applied: t.ViewChange[];
-            waitForViewSync: boolean;
-        };
-    }
-}
-declare const actors: {
-    hotkey: HotkeyActorLogic;
-    applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    executeChange: PromiseActorLogic<EditorCalls.ExecuteChange.Output, EditorCalls.ExecuteChange.Input, EventObject>;
-    applySemanticLayout: PromiseActorLogic<EditorCalls.ApplySemanticLayout.Output, EditorCalls.ApplySemanticLayout.Input, EventObject>;
-};
-export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent, {
-    hotkey: HotkeyActorLogic;
-    applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    executeChange: PromiseActorLogic<EditorCalls.ExecuteChange.Output, EditorCalls.ExecuteChange.Input, EventObject>;
-    applySemanticLayout: PromiseActorLogic<EditorCalls.ApplySemanticLayout.Output, EditorCalls.ApplySemanticLayout.Input, EventObject>;
-}, {
-    hotkey: "hotkey";
-}, {}, {
-    'has pending': unknown;
-    'can undo': unknown;
-    'can redo': unknown;
-}, "500ms" | "wait-after-edit", EditorActorStateTag, EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;
-/**
- * to workaround circular dependency issue between editor and diagram packages
- */
-export interface BaseEditorActorLogic<State extends StateValue = any> extends StateMachine<EditorActorContext, EditorActorEvent, inferChildrenRef<typeof actors>, inferProvidedActor<typeof actors>, never, never, never, State, EditorActorStateTag, EditorActorInput, never, EditorActorEmitedEvent, never, never> {
-}
-export type BaseEditorActorRef = ActorRefFromLogic<BaseEditorActorLogic>;
-export {};

package/dist/editor/actor/setup.js

@@ -1,42 +0,0 @@
-import "../../_virtual/_rolldown/runtime.js";
-import { defineActors } from "../../utils/defineActors.js";
-import { hotkey } from "./hotkey.js";
-import { fromPromise, setup } from "xstate";
-//#region src/editor/actor/setup.ts
-var applyLatest = fromPromise(() => {
-	throw new Error("Not implemented");
-});
-var executeChange = fromPromise(() => {
-	throw new Error("Not implemented");
-});
-var applySemanticLayout = fromPromise(() => {
-	throw new Error("Not implemented");
-});
-var actors = defineActors({
-	hotkey,
-	applyLatest,
-	executeChange,
-	applySemanticLayout
-});
-var machine = setup({
-	types: {
-		context: {},
-		events: {},
-		emitted: {},
-		input: {},
-		children: {},
-		tags: ""
-	},
-	actors,
-	delays: {
-		"500ms": 500,
-		"wait-after-edit": 1e3
-	},
-	guards: {
-		"has pending": ({ context }) => context.syncQueue.length > 0,
-		"can undo": ({ context }) => context.history !== null,
-		"can redo": ({ context }) => context.redo !== null
-	}
-});
-//#endregion
-export { machine };