@likec4/diagram 1.56.0 → 1.57.0

package/dist/bundle/index.d.ts

@@ -1 +0,0 @@
-export * from '../index';

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

@@ -1,153 +0,0 @@
-import { ViewChange } from '@likec4/core/types';
-import { ActionFunction, CancelAction, PromiseActorLogic, EventObject, NonReducibleUnknown, StopAction } from 'xstate';
-import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './editorActor.setup';
-import { HotkeyActorLogic } from './hotkeyActor';
-export declare const raiseSync: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "waitBeforeSync", never>;
-export declare const cancelSync: () => CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
-export declare const reschedule: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "waitBeforeSync", never>;
-type LayoutChanges = ViewChange.ResetManualLayout | ViewChange.SaveViewSnapshot;
-export declare const isLayoutChange: (change: ViewChange) => change is LayoutChanges;
-export declare const withoutSnapshotChanges: (data: ViewChange[]) => (ViewChange.ChangeElementStyle | ViewChange.ChangeAutoLayout)[];
-export declare const saveStateBeforeEdit: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const startEditing: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const stopHotkey: () => StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
-export declare const ensureHotKey: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const pushHistory: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const stopEditing: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const markHistoryAsSynched: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const popHistory: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const undo: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const addSnapshotToPendingChanges: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export {};

package/dist/editor/editorActor.actions.js

@@ -1,133 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { createViewChange } from "../likec4diagram/state/createViewChange.js";
-import { machine } from "./editorActor.setup.js";
-import { filter, isNot, last, omit } from "remeda";
-//#region src/editor/editorActor.actions.ts
-/**
-* Actually this is DiagramActorRef
-* But we can't use it here due to circular type inference
-*/
-var diagramActorRef = (system) => {
-	return system.get("diagram");
-};
-/**
-* 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;
-};
-var raiseSync = () => machine.raise({ type: "sync" }, {
-	delay: 200,
-	id: "sync"
-});
-var cancelSync = () => machine.cancel("sync");
-var reschedule = (delay = 350) => machine.raise(({ event }) => event, { delay });
-var isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
-var withoutSnapshotChanges = filter(isNot(isLayoutChange));
-var saveStateBeforeEdit = () => machine.assign(({ system }) => {
-	const parentContext = getDiagramContext(system);
-	return { beforeEditing: {
-		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,
-		synched: false
-	} };
-});
-var startEditing = () => machine.enqueueActions(({ enqueue, event }) => {
-	enqueue(saveStateBeforeEdit());
-	if (event.type === "edit.start") enqueue.assign({ editing: event.subject });
-});
-var stopHotkey = () => machine.stopChild("hotkey");
-var 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" });
-});
-var pushHistory = () => machine.assign(({ context }) => {
-	const snapshot = context.beforeEditing;
-	if (!snapshot) return { editing: null };
-	const history = [...context.history, snapshot];
-	if (history.length > 50) history.shift();
-	return {
-		beforeEditing: null,
-		editing: null,
-		history
-	};
-});
-var stopEditing = () => machine.enqueueActions(({ event, enqueue }) => {
-	if (event.type === "edit.finish" && event.wasChanged) {
-		enqueue(pushHistory());
-		enqueue(raiseSync());
-		return;
-	}
-	enqueue.assign({
-		beforeEditing: null,
-		editing: null
-	});
-});
-var 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
-		}))
-	};
-});
-var popHistory = () => machine.assign(({ context }) => {
-	if (context.history.length <= 1) return { history: [] };
-	return { history: context.history.slice(0, context.history.length - 1) };
-});
-var 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());
-});
-var addSnapshotToPendingChanges = () => machine.assign(({ context, system }) => {
-	const change = createViewChange(getDiagramContext(system));
-	return { pendingChanges: [...withoutSnapshotChanges(context.pendingChanges), change] };
-});
-//#endregion
-export { addSnapshotToPendingChanges, cancelSync, ensureHotKey, isLayoutChange, markHistoryAsSynched, pushHistory, reschedule, saveStateBeforeEdit, startEditing, stopEditing, stopHotkey, undo, withoutSnapshotChanges };

package/dist/editor/editorActor.states.d.ts

@@ -1,9 +0,0 @@
-import { ActorRef, SnapshotFrom, StateMachine } from 'xstate';
-import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput } from './editorActor.setup';
-export type { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, } from './editorActor.setup';
-export interface EditorActorLogic extends StateMachine<EditorActorContext, EditorActorEvent, any, any, any, any, any, 'idle' | 'editing' | 'pending' | 'afterEdit' | 'applyLatestToManual' | 'executeChanges', any, EditorActorInput, any, EditorActorEmitedEvent, any, any> {
-}
-export declare const editorActorLogic: EditorActorLogic;
-export type EditorActorSnapshot = SnapshotFrom<EditorActorLogic>;
-export interface EditorActorRef extends ActorRef<EditorActorSnapshot, EditorActorEvent, EditorActorEmitedEvent> {
-}

package/dist/editor/editorActor.states.js

@@ -1,219 +0,0 @@
-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");
-};
-var to = {
-	idle: { target: "#idle" },
-	editing: { target: "#editing" },
-	afterEdit: { target: "#afterEdit" },
-	pending: { target: "#pending" },
-	applyLatestToManual: { target: "#applyLatestToManual" },
-	executeChanges: { target: "#executeChanges" }
-};
-/**
-* Idle state, no pending operations
-*/
-var idle = machine.createStateConfig({
-	id: "idle",
-	on: {
-		"sync": { ...to.pending },
-		"edit.start": { ...to.editing }
-	}
-});
-/**
-* 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
-		}
-	}
-});
-/**
-* 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
-	} }
-});
-/**
-* Decide where to go next
-*/
-var afterEdit = machine.createStateConfig({
-	id: "afterEdit",
-	always: [{
-		guard: "has pending",
-		...to.pending
-	}, { ...to.idle }]
-});
-/**
-* 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
-			} }
-		}
-	}
-});
-/**
-* 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
-		}
-	}
-});
-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
-		}
-	}
-});
-//#endregion
-export { editorActorLogic };

package/dist/hooks/useOverlaysActor.js

@@ -1,11 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { selectDiagramActor, useDiagramSnapshot } from "./useDiagram.js";
-//#region src/hooks/useOverlaysActor.ts
-var select = selectDiagramActor((s) => {
-	return s.children.overlays;
-});
-function useOverlaysActorRef() {
-	return useDiagramSnapshot(select, Object.is);
-}
-//#endregion
-export { useOverlaysActorRef };

package/dist/hooks/useSearchActor.js

@@ -1,11 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { selectDiagramActor, useDiagramSnapshot } from "./useDiagram.js";
-//#region src/hooks/useSearchActor.ts
-var select = selectDiagramActor((s) => {
-	return s.children.search ?? null;
-});
-function useSearchActorRef() {
-	return useDiagramSnapshot(select, Object.is);
-}
-//#endregion
-export { useSearchActorRef };