@likec4/diagram 1.55.1 → 1.56.0

package/dist/likec4diagram/state/machine.state.ready.walkthrough.js

@@ -1,198 +1,158 @@
-import { invariant, isStepEdgeId, getParallelStepsPrefix, nonNullable } from '@likec4/core';
-import { clamp, first } from 'remeda';
-import { assertEvent } from 'xstate';
-import { SeqParallelAreaColor } from '../xyflow-sequence/const.js';
-import { updateView, emitEdgeClick, stopHotKeyActor, undimEverything, startHotKeyActor, cancelEditing } from './machine.actions.js';
-import { machine, targetState } from './machine.setup.js';
-import { fitFocusedBounds, returnViewportBefore, cancelFitDiagram, assignViewportBefore } from './machine.actions.layout.js';
-import { x as xstateActions_cjsExports } from '../../_virtual/xstate-actions.cjs.js';
-import { Base } from '../../base/Base.js';
-
-const updateActiveWalkthroughState = () => machine.enqueueActions(({ context, enqueue }) => {
-  const { activeWalkthrough } = context;
-  if (!activeWalkthrough) {
-    console.warn("Active walkthrough is null");
-    enqueue.raise({ type: "walkthrough.end" });
-    return;
-  }
-  const { stepId, parallelPrefix } = activeWalkthrough;
-  const step = context.xyedges.find((x) => x.id === stepId);
-  if (!step) {
-    console.warn("Invalid walkthrough stepId:", stepId);
-    enqueue.raise({ type: "walkthrough.end" });
-    return;
-  }
-  enqueue.assign({
-    xyedges: context.xyedges.map((edge) => {
-      const active = stepId === edge.id || !!parallelPrefix && edge.id.startsWith(parallelPrefix);
-      return Base.setData(edge, {
-        active,
-        dimmed: stepId !== edge.id
-      });
-    }),
-    xynodes: context.xynodes.map((node) => {
-      const dimmed = step.source !== node.id && step.target !== node.id;
-      if (node.type === "seq-parallel") {
-        return Base.setData(node, {
-          color: parallelPrefix === node.data.parallelPrefix ? SeqParallelAreaColor.active : SeqParallelAreaColor.default,
-          dimmed
-        });
-      }
-      return Base.setDimmed(node, dimmed);
-    })
-  });
+import "../../_virtual/_rolldown/runtime.js";
+import { Base } from "../../base/Base.js";
+import { machine, targetState } from "./machine.setup.js";
+import { SeqParallelAreaColor } from "../xyflow-sequence/const.js";
+import { assignViewportBefore, cancelFitDiagram, fitFocusedBounds, returnViewportBefore } from "./machine.actions.layout.js";
+import { cancelEditing, emitEdgeClick, startHotKeyActor, stopHotKeyActor, undimEverything, updateView } from "./machine.actions.js";
+import { clamp, first } from "remeda";
+import { getParallelStepsPrefix, invariant, isStepEdgeId, nonNullable } from "@likec4/core";
+import { assertEvent } from "xstate";
+import { assign as assign$1, enqueueActions as enqueueActions$1, raise as raise$1 } from "xstate/actions";
+//#region src/likec4diagram/state/machine.state.ready.walkthrough.ts
+var updateActiveWalkthroughState = () => machine.enqueueActions(({ context, enqueue }) => {
+	const { activeWalkthrough } = context;
+	if (!activeWalkthrough) {
+		console.warn("Active walkthrough is null");
+		enqueue.raise({ type: "walkthrough.end" });
+		return;
+	}
+	const { stepId, parallelPrefix } = activeWalkthrough;
+	const step = context.xyedges.find((x) => x.id === stepId);
+	if (!step) {
+		console.warn("Invalid walkthrough stepId:", stepId);
+		enqueue.raise({ type: "walkthrough.end" });
+		return;
+	}
+	enqueue.assign({
+		xyedges: context.xyedges.map((edge) => {
+			const active = stepId === edge.id || !!parallelPrefix && edge.id.startsWith(parallelPrefix);
+			return Base.setData(edge, {
+				active,
+				dimmed: stepId !== edge.id
+			});
+		}),
+		xynodes: context.xynodes.map((node) => {
+			const dimmed = step.source !== node.id && step.target !== node.id;
+			if (node.type === "seq-parallel") return Base.setData(node, {
+				color: parallelPrefix === node.data.parallelPrefix ? SeqParallelAreaColor.active : SeqParallelAreaColor.default,
+				dimmed
+			});
+			return Base.setDimmed(node, dimmed);
+		})
+	});
 });
-const emitWalkthroughStarted = () => machine.emit(({ context }) => {
-  const edge = context.xyedges.find((x) => x.id === context.activeWalkthrough?.stepId);
-  invariant(edge, "Invalid walkthrough state");
-  return {
-    type: "walkthroughStarted",
-    edge
-  };
+var emitWalkthroughStarted = () => machine.emit(({ context }) => {
+	const edge = context.xyedges.find((x) => x.id === context.activeWalkthrough?.stepId);
+	invariant(edge, "Invalid walkthrough state");
+	return {
+		type: "walkthroughStarted",
+		edge
+	};
 });
-const emitWalkthroughStopped = () => machine.emit(() => ({
-  type: "walkthroughStopped"
-}));
-const emitWalkthroughStep = () => machine.emit(({ context }) => {
-  const edge = context.xyedges.find((x) => x.id === context.activeWalkthrough?.stepId);
-  invariant(edge, "Invalid walkthrough state");
-  return {
-    type: "walkthroughStep",
-    edge
-  };
+var emitWalkthroughStopped = () => machine.emit(() => ({ type: "walkthroughStopped" }));
+var emitWalkthroughStep = () => machine.emit(({ context }) => {
+	const edge = context.xyedges.find((x) => x.id === context.activeWalkthrough?.stepId);
+	invariant(edge, "Invalid walkthrough state");
+	return {
+		type: "walkthroughStep",
+		edge
+	};
 });
-const walkthrough = machine.createStateConfig({
-  id: targetState.walkthrough.slice(1),
-  entry: [
-    startHotKeyActor(),
-    cancelEditing(),
-    cancelFitDiagram(),
-    assignViewportBefore(),
-    xstateActions_cjsExports.assign({
-      activeWalkthrough: ({ context, event }) => {
-        assertEvent(event, "walkthrough.start");
-        const stepId = event.stepId ?? first(context.xyedges).id;
-        return {
-          stepId,
-          parallelPrefix: getParallelStepsPrefix(stepId)
-        };
-      }
-    }),
-    updateActiveWalkthroughState(),
-    fitFocusedBounds(),
-    emitWalkthroughStarted()
-  ],
-  exit: [
-    stopHotKeyActor(),
-    xstateActions_cjsExports.enqueueActions(({ enqueue, context }) => {
-      enqueue.assign({
-        activeWalkthrough: null
-      });
-      if (context.dynamicViewVariant === "sequence" && context.activeWalkthrough?.parallelPrefix) {
-        enqueue.assign({
-          xynodes: context.xynodes.map((n) => {
-            if (n.type === "seq-parallel") {
-              return Base.setData(n, {
-                color: SeqParallelAreaColor.default
-              });
-            }
-            return n;
-          })
-        });
-      }
-    }),
-    undimEverything(),
-    returnViewportBefore(),
-    emitWalkthroughStopped()
-  ],
-  on: {
-    "key.esc": {
-      target: targetState.idle
-    },
-    "key.arrow.left": {
-      actions: xstateActions_cjsExports.raise({ type: "walkthrough.step", direction: "previous" })
-    },
-    "key.arrow.up": {
-      actions: xstateActions_cjsExports.raise({ type: "walkthrough.step", direction: "previous" })
-    },
-    "key.arrow.right": {
-      actions: xstateActions_cjsExports.raise({ type: "walkthrough.step", direction: "next" })
-    },
-    "key.arrow.down": {
-      actions: xstateActions_cjsExports.raise({ type: "walkthrough.step", direction: "next" })
-    },
-    "walkthrough.step": {
-      actions: [
-        xstateActions_cjsExports.assign(({ context, event }) => {
-          const { stepId } = context.activeWalkthrough;
-          const stepIndex = context.xyedges.findIndex((e) => e.id === stepId);
-          const nextStepIndex = clamp(event.direction === "next" ? stepIndex + 1 : stepIndex - 1, {
-            min: 0,
-            max: context.xyedges.length - 1
-          });
-          if (nextStepIndex === stepIndex) {
-            return {};
-          }
-          const nextStepId = nonNullable(context.xyedges[nextStepIndex]).id;
-          return {
-            activeWalkthrough: {
-              stepId: nextStepId,
-              parallelPrefix: getParallelStepsPrefix(nextStepId)
-            }
-          };
-        }),
-        updateActiveWalkthroughState(),
-        fitFocusedBounds(),
-        emitWalkthroughStep()
-      ]
-    },
-    "xyflow.edgeClick": [
-      {
-        guard: "click: active walkthrough step",
-        actions: [
-          fitFocusedBounds(),
-          emitEdgeClick()
-        ]
-      },
-      {
-        actions: [
-          xstateActions_cjsExports.assign(({ event }) => {
-            const stepId = event.edge.id;
-            invariant(isStepEdgeId(stepId));
-            return {
-              activeWalkthrough: {
-                stepId,
-                parallelPrefix: getParallelStepsPrefix(stepId)
-              }
-            };
-          }),
-          updateActiveWalkthroughState(),
-          fitFocusedBounds(),
-          emitEdgeClick(),
-          emitWalkthroughStep()
-        ]
-      }
-    ],
-    "notations.unhighlight": {
-      actions: updateActiveWalkthroughState()
-    },
-    "tag.unhighlight": {
-      actions: updateActiveWalkthroughState()
-    },
-    "update.view": {
-      guard: "is same view",
-      actions: [
-        updateView(),
-        updateActiveWalkthroughState()
-      ]
-    },
-    "walkthrough.end": {
-      target: targetState.idle
-    },
-    "xyflow.paneDblClick": {
-      target: targetState.idle
-    }
-  }
+var walkthrough = machine.createStateConfig({
+	id: targetState.walkthrough.slice(1),
+	entry: [
+		startHotKeyActor(),
+		cancelEditing(),
+		cancelFitDiagram(),
+		assignViewportBefore(),
+		assign$1({ activeWalkthrough: ({ context, event }) => {
+			assertEvent(event, "walkthrough.start");
+			const stepId = event.stepId ?? first(context.xyedges).id;
+			return {
+				stepId,
+				parallelPrefix: getParallelStepsPrefix(stepId)
+			};
+		} }),
+		updateActiveWalkthroughState(),
+		fitFocusedBounds(),
+		emitWalkthroughStarted()
+	],
+	exit: [
+		stopHotKeyActor(),
+		enqueueActions$1(({ enqueue, context }) => {
+			enqueue.assign({ activeWalkthrough: null });
+			if (context.dynamicViewVariant === "sequence" && context.activeWalkthrough?.parallelPrefix) enqueue.assign({ xynodes: context.xynodes.map((n) => {
+				if (n.type === "seq-parallel") return Base.setData(n, { color: SeqParallelAreaColor.default });
+				return n;
+			}) });
+		}),
+		undimEverything(),
+		returnViewportBefore(),
+		emitWalkthroughStopped()
+	],
+	on: {
+		"key.esc": { target: targetState.idle },
+		"key.arrow.left": { actions: raise$1({
+			type: "walkthrough.step",
+			direction: "previous"
+		}) },
+		"key.arrow.up": { actions: raise$1({
+			type: "walkthrough.step",
+			direction: "previous"
+		}) },
+		"key.arrow.right": { actions: raise$1({
+			type: "walkthrough.step",
+			direction: "next"
+		}) },
+		"key.arrow.down": { actions: raise$1({
+			type: "walkthrough.step",
+			direction: "next"
+		}) },
+		"walkthrough.step": { actions: [
+			assign$1(({ context, event }) => {
+				const { stepId } = context.activeWalkthrough;
+				const stepIndex = context.xyedges.findIndex((e) => e.id === stepId);
+				const nextStepIndex = clamp(event.direction === "next" ? stepIndex + 1 : stepIndex - 1, {
+					min: 0,
+					max: context.xyedges.length - 1
+				});
+				if (nextStepIndex === stepIndex) return {};
+				const nextStepId = nonNullable(context.xyedges[nextStepIndex]).id;
+				return { activeWalkthrough: {
+					stepId: nextStepId,
+					parallelPrefix: getParallelStepsPrefix(nextStepId)
+				} };
+			}),
+			updateActiveWalkthroughState(),
+			fitFocusedBounds(),
+			emitWalkthroughStep()
+		] },
+		"xyflow.edgeClick": [{
+			guard: "click: active walkthrough step",
+			actions: [fitFocusedBounds(), emitEdgeClick()]
+		}, { actions: [
+			assign$1(({ event }) => {
+				const stepId = event.edge.id;
+				invariant(isStepEdgeId(stepId));
+				return { activeWalkthrough: {
+					stepId,
+					parallelPrefix: getParallelStepsPrefix(stepId)
+				} };
+			}),
+			updateActiveWalkthroughState(),
+			fitFocusedBounds(),
+			emitEdgeClick(),
+			emitWalkthroughStep()
+		] }],
+		"notations.unhighlight": { actions: updateActiveWalkthroughState() },
+		"tag.unhighlight": { actions: updateActiveWalkthroughState() },
+		"update.view": {
+			guard: "is same view",
+			actions: [updateView(), updateActiveWalkthroughState()]
+		},
+		"walkthrough.end": { target: targetState.idle },
+		"xyflow.paneDblClick": { target: targetState.idle }
+	}
 });
-
+//#endregion
 export { walkthrough };

package/dist/likec4diagram/state/mediaPrintActor.js

@@ -1,18 +1,22 @@
-import { fromCallback } from 'xstate';
-
-const mediaPrintActorLogic = fromCallback(({ sendBack }) => {
-  const beforePrint = () => {
-    sendBack({ type: "media.print.on" });
-  };
-  const afterPrint = () => {
-    sendBack({ type: "media.print.off" });
-  };
-  window.addEventListener("beforeprint", beforePrint);
-  window.addEventListener("afterprint", afterPrint);
-  return () => {
-    window.removeEventListener("beforeprint", beforePrint);
-    window.removeEventListener("afterprint", afterPrint);
-  };
+import "../../_virtual/_rolldown/runtime.js";
+import { fromCallback } from "xstate";
+//#region src/likec4diagram/state/mediaPrintActor.ts
+/**
+* Actor logic to listen for media print events.
+*/
+var mediaPrintActorLogic = fromCallback(({ sendBack }) => {
+	const beforePrint = () => {
+		sendBack({ type: "media.print.on" });
+	};
+	const afterPrint = () => {
+		sendBack({ type: "media.print.off" });
+	};
+	window.addEventListener("beforeprint", beforePrint);
+	window.addEventListener("afterprint", afterPrint);
+	return () => {
+		window.removeEventListener("beforeprint", beforePrint);
+		window.removeEventListener("afterprint", afterPrint);
+	};
 });
-
+//#endregion
 export { mediaPrintActorLogic };

package/dist/likec4diagram/state/persistence.js

@@ -1,23 +1,22 @@
-import { pickBy, isBoolean } from 'remeda';
-
-const key = `likec4:diagram:toggledFeatures`;
-const DiagramToggledFeaturesPersistence = {
-  read() {
-    try {
-      let fromStorage = sessionStorage.getItem(key);
-      if (fromStorage) {
-        return JSON.parse(fromStorage);
-      }
-      return null;
-    } catch (e) {
-      console.error(`Error reading fromStorage ${key}:`, e);
-      return null;
-    }
-  },
-  write(toggledFeatures) {
-    sessionStorage.setItem(key, JSON.stringify(pickBy(toggledFeatures, isBoolean)));
-    return toggledFeatures;
-  }
+import "../../_virtual/_rolldown/runtime.js";
+import { isBoolean, pickBy } from "remeda";
+//#region src/likec4diagram/state/persistence.ts
+var key = `likec4:diagram:toggledFeatures`;
+var DiagramToggledFeaturesPersistence = {
+	read() {
+		try {
+			let fromStorage = sessionStorage.getItem(key);
+			if (fromStorage) return JSON.parse(fromStorage);
+			return null;
+		} catch (e) {
+			console.error(`Error reading fromStorage ${key}:`, e);
+			return null;
+		}
+	},
+	write(toggledFeatures) {
+		sessionStorage.setItem(key, JSON.stringify(pickBy(toggledFeatures, isBoolean)));
+		return toggledFeatures;
+	}
 };
-
+//#endregion
 export { DiagramToggledFeaturesPersistence };