@likec4/diagram 1.55.1 → 1.57.0

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

@@ -0,0 +1,59 @@
+import { Types } from '../../likec4diagram/types';
+import { HotKeyEvent } from './hotkey';
+import type * as t from '@likec4/core/types';
+export type EditorActorEvent = {
+    type: 'change.view';
+    change: t.ViewChange;
+} | {
+    type: 'change.semantic-layout';
+} | {
+    type: 'change.latest-to-manual';
+} | {
+    type: 'change.sync-snapshot';
+} | {
+    type: 'view.synched';
+} | {
+    type: 'cancel';
+} | {
+    type: 'edit.move.start';
+    subject: 'node' | 'edge';
+} | {
+    type: 'edit.move.end';
+} | {
+    type: 'edit.move.cancel';
+} | HotKeyEvent;
+export type Snapshot = {
+    view: t.LayoutedView;
+    change: t.ViewChange.SaveViewSnapshot;
+    xynodes: Types.Node[];
+    xyedges: Types.Edge[];
+};
+export type LinkedSnapshot = {
+    head: Snapshot;
+    tail: LinkedSnapshot | null;
+};
+export interface EditorActorInput {
+    viewId: t.ViewId;
+}
+export type SyncOp = t.ViewChange | 'sync-snapshot' | 'apply-semantic-layout' | 'apply-latest-to-manual';
+export declare const isViewChange: (change: SyncOp) => change is t.ViewChange;
+export interface EditorActorContext {
+    viewId: t.ViewId;
+    history: LinkedSnapshot | null;
+    editing: null | {
+        /**
+         * The subject of the edit
+         */
+        subject: 'node' | 'edge';
+        /**
+         * The state before editing started
+         */
+        before: Snapshot;
+    };
+    syncQueue: Array<SyncOp>;
+    processing: Exclude<SyncOp, 'sync-snapshot'> | null;
+}
+export type EditorActorEmitedEvent = {
+    type: 'idle';
+};
+export type EditorActorStateTag = 'pending' | 'busy' | 'ai-semantic-layout';

package/dist/editor/actor/types.js

@@ -0,0 +1,5 @@
+import "../../_virtual/_rolldown/runtime.js";
+//#region src/editor/actor/types.ts
+var isViewChange = (change) => typeof change !== "string";
+//#endregion
+export { isViewChange };

package/dist/editor/applyChangesToManualLayout.js

@@ -1,183 +1,164 @@
-import { invariant, nonNullable } from '@likec4/core';
-import { BBox, convertPoint, vector } from '@likec4/core/geometry';
-import { setAutoFreeze, produce, castDraft } from 'immer';
-import { map, isNullish } from 'remeda';
-
+import "../_virtual/_rolldown/runtime.js";
+import { isNullish, map } from "remeda";
+import { invariant, nonNullable } from "@likec4/core";
+import { BBox as BBox$1, convertPoint, vector } from "@likec4/core/geometry";
+import "@likec4/core/types";
+import { castDraft, produce, setAutoFreeze } from "immer";
+//#region src/editor/applyChangesToManualLayout.ts
+/**
+* Applies changes to a manual layout.
+*
+* @param manual - The manual layout.
+* @param latest - The latest layout.
+*/
 function applyChangesToManualLayout(manualView, latestView) {
-  try {
-    setAutoFreeze(false);
-    return _applyChangesToManualLayout(manualView, latestView);
-  } finally {
-    setAutoFreeze(true);
-  }
+	try {
+		setAutoFreeze(false);
+		return _applyChangesToManualLayout(manualView, latestView);
+	} finally {
+		setAutoFreeze(true);
+	}
 }
-const isRootNode = (node) => isNullish(node.parent);
+var isRootNode = (node) => isNullish(node.parent);
 function _applyChangesToManualLayout(manualView, latestView) {
-  invariant(manualView.id === latestView.id, "View IDs do not match");
-  invariant(manualView._type === latestView._type, "View types do not match");
-  invariant(manualView._layout === "manual" && latestView._layout === "auto", "Views must be manual and auto");
-  const compounds = /* @__PURE__ */ new Set();
-  const newnodes = /* @__PURE__ */ new Set();
-  const isNotCompound = (node) => !compounds.has(typeof node === "string" ? node : node.id);
-  const isBetweenNewLeafNodes = (edge) => newnodes.has(edge.source) && newnodes.has(edge.target) && isNotCompound(edge.source) && isNotCompound(edge.target);
-  const nodesMap = new Map(
-    latestView.nodes.map((latest) => {
-      if (latest.children && latest.children.length > 0) {
-        compounds.add(latest.id);
-      }
-      const manual = manualView.nodes.find((n) => n.id === latest.id);
-      if (manual) {
-        return [latest.id, applyFromManualNode({ latest, manual })];
-      }
-      newnodes.add(latest.id);
-      return [latest.id, removeDrift(latest)];
-    })
-  );
-  const newNodesOnly = newnodes.size === nodesMap.size;
-  if (newNodesOnly) {
-    return produce(latestView, (draft) => {
-      draft._layout = "manual";
-      draft.nodes = castDraft([...nodesMap.values()]);
-      draft.edges = castDraft(latestView.edges.map(removeDrift));
-      delete draft.drifts;
-    });
-  }
-  if (compounds.size > 0) {
-    expandCompoundNodes(nodesMap);
-  }
-  const nodes = [...nodesMap.values()];
-  const edges = latestView.edges.map((latest) => {
-    const dir = latest.dir ?? "forward";
-    const hasSameEndpoints = (candidate) => candidate.source === latest.source && candidate.target === latest.target && (candidate.dir === dir || !candidate.dir && !latest.dir);
-    let manual = manualView.edges.find((e) => e.id === latest.id && hasSameEndpoints(e));
-    if (!manual) {
-      manual = manualView.edges.find((e) => hasSameEndpoints(e));
-    }
-    if (manual) {
-      return applyFromManualEdge({
-        latest,
-        manual
-      });
-    }
-    if (isBetweenNewLeafNodes(latest)) {
-      return removeDrift(latest);
-    }
-    const sourceNode = nodesMap.get(latest.source);
-    const targetNode = nodesMap.get(latest.target);
-    return makeAsStraightLine(latest, sourceNode, targetNode);
-  });
-  const bounds = BBox.merge(...nodes.filter(isRootNode));
-  return produce(latestView, (draft) => {
-    draft._layout = "manual";
-    draft.nodes = castDraft(nodes);
-    draft.edges = castDraft(edges);
-    draft.bounds = bounds;
-    delete draft.drifts;
-  });
+	invariant(manualView.id === latestView.id, "View IDs do not match");
+	invariant(manualView._type === latestView._type, "View types do not match");
+	invariant(manualView._layout === "manual" && latestView._layout === "auto", "Views must be manual and auto");
+	const compounds = /* @__PURE__ */ new Set();
+	const newnodes = /* @__PURE__ */ new Set();
+	const isNotCompound = (node) => !compounds.has(typeof node === "string" ? node : node.id);
+	const isBetweenNewLeafNodes = (edge) => newnodes.has(edge.source) && newnodes.has(edge.target) && isNotCompound(edge.source) && isNotCompound(edge.target);
+	const nodesMap = new Map(latestView.nodes.map((latest) => {
+		if (latest.children && latest.children.length > 0) compounds.add(latest.id);
+		const manual = manualView.nodes.find((n) => n.id === latest.id);
+		if (manual) return [latest.id, applyFromManualNode({
+			latest,
+			manual
+		})];
+		newnodes.add(latest.id);
+		return [latest.id, removeDrift(latest)];
+	}));
+	if (newnodes.size === nodesMap.size) return produce(latestView, (draft) => {
+		draft._layout = "manual";
+		draft.nodes = castDraft([...nodesMap.values()]);
+		draft.edges = castDraft(latestView.edges.map(removeDrift));
+		delete draft.drifts;
+	});
+	if (compounds.size > 0) expandCompoundNodes(nodesMap);
+	const nodes = [...nodesMap.values()];
+	const edges = latestView.edges.map((latest) => {
+		const dir = latest.dir ?? "forward";
+		const hasSameEndpoints = (candidate) => candidate.source === latest.source && candidate.target === latest.target && (candidate.dir === dir || !candidate.dir && !latest.dir);
+		let manual = manualView.edges.find((e) => e.id === latest.id && hasSameEndpoints(e));
+		if (!manual) manual = manualView.edges.find((e) => hasSameEndpoints(e));
+		if (manual) return applyFromManualEdge({
+			latest,
+			manual
+		});
+		if (isBetweenNewLeafNodes(latest)) return removeDrift(latest);
+		return makeAsStraightLine(latest, nodesMap.get(latest.source), nodesMap.get(latest.target));
+	});
+	const bounds = BBox$1.merge(...nodes.filter(isRootNode));
+	return produce(latestView, (draft) => {
+		draft._layout = "manual";
+		draft.nodes = castDraft(nodes);
+		draft.edges = castDraft(edges);
+		draft.bounds = bounds;
+		delete draft.drifts;
+	});
 }
-const COMPOUND_PADDING = {
-  Left: 42,
-  Right: 42,
-  Top: 60,
-  Bottom: 42
+/**
+* Padding constants for compound nodes (same as in useLayoutConstraints)
+*/
+var COMPOUND_PADDING = {
+	Left: 42,
+	Right: 42,
+	Top: 60,
+	Bottom: 42
 };
+/**
+* Expands compound nodes to wrap all their children with proper padding.
+* Processes nodes recursively from leaves up to ensure correct bounding boxes.
+*/
 function expandCompoundNodes(nodes) {
-  function expand(nodeId) {
-    const node = nonNullable(nodes.get(nodeId), `Node ${nodeId} not found`);
-    if (node.children.length === 0) {
-      return node;
-    }
-    const childBBoxes = [];
-    for (const childId of node.children) {
-      childBBoxes.push(
-        expand(childId)
-      );
-    }
-    const childrenBBox = BBox.merge(...childBBoxes);
-    node.x = childrenBBox.x - COMPOUND_PADDING.Left;
-    node.y = childrenBBox.y - COMPOUND_PADDING.Top;
-    node.width = childrenBBox.width + COMPOUND_PADDING.Left + COMPOUND_PADDING.Right;
-    node.height = childrenBBox.height + COMPOUND_PADDING.Top + COMPOUND_PADDING.Bottom;
-    return node;
-  }
-  for (const node of nodes.values()) {
-    if (!isRootNode(node) || node.children.length === 0) {
-      continue;
-    }
-    expand(node.id);
-  }
+	function expand(nodeId) {
+		const node = nonNullable(nodes.get(nodeId), `Node ${nodeId} not found`);
+		if (node.children.length === 0) return node;
+		const childBBoxes = [];
+		for (const childId of node.children) childBBoxes.push(expand(childId));
+		const childrenBBox = BBox$1.merge(...childBBoxes);
+		node.x = childrenBBox.x - COMPOUND_PADDING.Left;
+		node.y = childrenBBox.y - COMPOUND_PADDING.Top;
+		node.width = childrenBBox.width + COMPOUND_PADDING.Left + COMPOUND_PADDING.Right;
+		node.height = childrenBBox.height + COMPOUND_PADDING.Top + COMPOUND_PADDING.Bottom;
+		return node;
+	}
+	for (const node of nodes.values()) {
+		if (!isRootNode(node) || node.children.length === 0) continue;
+		expand(node.id);
+	}
 }
 function applyFromManualNode({ latest, manual }) {
-  invariant(manual.id === latest.id, "Node IDs do not match");
-  return produce(latest, (next) => {
-    next.x = manual.x;
-    next.y = manual.y;
-    next.drifts = null;
-  });
+	invariant(manual.id === latest.id, "Node IDs do not match");
+	return produce(latest, (next) => {
+		next.x = manual.x;
+		next.y = manual.y;
+		next.drifts = null;
+	});
 }
 function applyFromManualEdge(edges) {
-  const { manual, latest } = edges;
-  return produce(latest, (draft) => {
-    if (manual.controlPoints) {
-      draft.controlPoints = manual.controlPoints;
-    } else {
-      delete draft.controlPoints;
-    }
-    draft.points = castDraft(manual.points);
-    if (manual.labelBBox) {
-      draft.labelBBox = latest.labelBBox ?? manual.labelBBox;
-      draft.labelBBox.x = manual.labelBBox.x;
-      draft.labelBBox.y = manual.labelBBox.y;
-    }
-    draft.drifts = null;
-  });
+	const { manual, latest } = edges;
+	return produce(latest, (draft) => {
+		if (manual.controlPoints) draft.controlPoints = manual.controlPoints;
+		else delete draft.controlPoints;
+		draft.points = castDraft(manual.points);
+		if (manual.labelBBox) {
+			draft.labelBBox = latest.labelBBox ?? manual.labelBBox;
+			draft.labelBBox.x = manual.labelBBox.x;
+			draft.labelBBox.y = manual.labelBBox.y;
+		}
+		draft.drifts = null;
+	});
 }
 function removeDrift(object) {
-  if ("drifts" in object && object.drifts !== null) {
-    const result = { ...object };
-    result.drifts = null;
-    return result;
-  }
-  return object;
+	if ("drifts" in object && object.drifts !== null) {
+		const result = { ...object };
+		result.drifts = null;
+		return result;
+	}
+	return object;
 }
 function makeAsStraightLine(edge, sourceNode, targetNode) {
-  const controlPoints = edgeControlPoints(sourceNode, targetNode);
-  const labelPos = controlPoints[0];
-  return produce(edge, (draft) => {
-    draft.points = castDraft(map(controlPoints, convertPoint));
-    draft.controlPoints = controlPoints;
-    if (edge.labelBBox) {
-      draft.labelBBox.x = labelPos.x;
-      draft.labelBBox.y = labelPos.y;
-    }
-    delete draft.drifts;
-  });
+	const controlPoints = edgeControlPoints(sourceNode, targetNode);
+	const labelPos = controlPoints[0];
+	return produce(edge, (draft) => {
+		draft.points = castDraft(map(controlPoints, convertPoint));
+		draft.controlPoints = controlPoints;
+		if (edge.labelBBox) {
+			draft.labelBBox.x = labelPos.x;
+			draft.labelBBox.y = labelPos.y;
+		}
+		delete draft.drifts;
+	});
 }
 function getBorderPointOnVector(node, nodeCenter, v) {
-  const xScale = node.width / 2 / v.x;
-  const yScale = node.height / 2 / v.y;
-  const scale = Math.min(Math.abs(xScale), Math.abs(yScale));
-  return vector(v).multiply(scale).add(nodeCenter);
+	const xScale = node.width / 2 / v.x;
+	const yScale = node.height / 2 / v.y;
+	const scale = Math.min(Math.abs(xScale), Math.abs(yScale));
+	return vector(v).multiply(scale).add(nodeCenter);
 }
 function edgeControlPoints(source, target) {
-  const sourceCenter = vector(BBox.center(source));
-  const targetCenter = vector(BBox.center(target));
-  if (source === target) {
-    const loopSize = 80;
-    const centerOfTopBoundary = vector(0, source.height || 0).multiply(-0.5).add(sourceCenter);
-    return [
-      centerOfTopBoundary.add(vector(-loopSize / 2.5, -loopSize)).trunc().toObject(),
-      centerOfTopBoundary.add(vector(loopSize / 2.5, -loopSize)).trunc().toObject()
-    ];
-  }
-  const sourceToTargetVector = targetCenter.subtract(sourceCenter);
-  const sourceBorderPoint = getBorderPointOnVector(source, sourceCenter, sourceToTargetVector);
-  const targetBorderPoint = getBorderPointOnVector(target, targetCenter, sourceToTargetVector.multiply(-1));
-  const sourceToTarget = targetBorderPoint.subtract(sourceBorderPoint);
-  return [
-    sourceBorderPoint.add(sourceToTarget.multiply(0.4)).trunc().toObject(),
-    sourceBorderPoint.add(sourceToTarget.multiply(0.6)).trunc().toObject()
-  ];
+	const sourceCenter = vector(BBox$1.center(source));
+	const targetCenter = vector(BBox$1.center(target));
+	if (source === target) {
+		const loopSize = 80;
+		const centerOfTopBoundary = vector(0, source.height || 0).multiply(-.5).add(sourceCenter);
+		return [centerOfTopBoundary.add(vector(-80 / 2.5, -80)).trunc().toObject(), centerOfTopBoundary.add(vector(loopSize / 2.5, -80)).trunc().toObject()];
+	}
+	const sourceToTargetVector = targetCenter.subtract(sourceCenter);
+	const sourceBorderPoint = getBorderPointOnVector(source, sourceCenter, sourceToTargetVector);
+	const sourceToTarget = getBorderPointOnVector(target, targetCenter, sourceToTargetVector.multiply(-1)).subtract(sourceBorderPoint);
+	return [sourceBorderPoint.add(sourceToTarget.multiply(.4)).trunc().toObject(), sourceBorderPoint.add(sourceToTarget.multiply(.6)).trunc().toObject()];
 }
-
+//#endregion
 export { applyChangesToManualLayout };

package/dist/editor/index.d.ts

@@ -1,4 +1,5 @@
-export type * from './editorActor.states';
+export type * from './actor/machine';
+export type * from './actor/types';
 export { createLikeC4Editor } from './LikeC4EditorCallbacks';
 export type { LikeC4EditorCallbacks } from './LikeC4EditorCallbacks';
 export { EnsureEditorContext, LikeC4EditorProvider, useOptionalLikeC4Editor, } from './LikeC4EditorProvider';

package/dist/editor/useEditorActorLogic.d.ts

@@ -1,2 +1,8 @@
-import { EditorActorLogic } from './editorActor.states';
-export declare function useEditorActorLogic(): EditorActorLogic;
+import { EditorActorLogic } from './actor/machine';
+export declare function useEditorActorLogic(): EditorActorLogic & {
+    /**
+     * True if the editor is running in stub mode (no actual editor port available)
+     * This happens when the diagram is rendered outside of vscode extension / vite- plugin
+     */
+    readonly isStub: boolean;
+};

package/dist/editor/useEditorActorLogic.js

@@ -1,47 +1,55 @@
-import { useMemo } from 'react';
-import { fromPromise } from 'xstate';
-import { applyChangesToManualLayout } from './applyChangesToManualLayout.js';
-import { editorActorLogic } from './editorActor.states.js';
-import { useOptionalLikeC4Editor } from './LikeC4EditorProvider.js';
-import { useCallbackRef } from '../hooks/useCallbackRef.js';
-
-const promisify = (fn) => {
-  return Promise.resolve().then(() => fn());
+import "../_virtual/_rolldown/runtime.js";
+import { useCallbackRef } from "../hooks/useCallbackRef.js";
+import { useOptionalLikeC4Editor } from "./LikeC4EditorProvider.js";
+import { editorActorLogic } from "./actor/machine.js";
+import { applyChangesToManualLayout } from "./applyChangesToManualLayout.js";
+import { useMemo } from "react";
+import { isNullish } from "remeda";
+import { fromPromise } from "xstate";
+//#region src/editor/useEditorActorLogic.ts
+var promisify = (fn) => {
+	return Promise.resolve().then(() => fn());
 };
 function useEditorActorLogic() {
-  const port = useOptionalLikeC4Editor();
-  const applyLatest = useCallbackRef(
-    async ({ input: { viewId, current } }) => {
-      if (!port) {
-        console.error("No editor port available for applying latest to manual layout");
-        return Promise.reject(new Error("No editor port"));
-      }
-      const manual = await promisify(() => current ?? port.fetchView(viewId, "manual"));
-      const latest = await promisify(() => port.fetchView(viewId, "auto"));
-      const updated = applyChangesToManualLayout(manual, latest);
-      return {
-        updated
-      };
-    }
-  );
-  const executeChange = useCallbackRef(
-    async ({ input }) => {
-      if (!port) {
-        console.error("No editor port available for executing change");
-        return Promise.reject(new Error("No editor port"));
-      }
-      for (const change of input.changes) {
-        await promisify(() => port.handleChange(input.viewId, change));
-      }
-      return {};
-    }
-  );
-  return useMemo(() => editorActorLogic.provide({
-    actors: {
-      applyLatest: fromPromise(applyLatest),
-      executeChange: fromPromise(executeChange)
-    }
-  }), [applyLatest, executeChange]);
+	const port = useOptionalLikeC4Editor();
+	const isStub = isNullish(port);
+	const applyLatest = useCallbackRef(async ({ input: { viewId, current } }) => {
+		if (!port) {
+			console.error("No editor port available for applying latest to manual layout");
+			throw new Error("No editor port");
+		}
+		return { updated: applyChangesToManualLayout(await promisify(() => current ?? port.fetchView(viewId, "manual")), await promisify(() => port.fetchView(viewId, "auto"))) };
+	});
+	const executeChange = useCallbackRef(async ({ input }) => {
+		if (!port) {
+			console.error("No editor port available for executing change");
+			throw new Error("No editor port");
+		}
+		for (const change of input.changes) await promisify(() => port.handleChange(input.viewId, change));
+		return {};
+	});
+	const applySemanticLayout = useCallbackRef(async ({ input }) => {
+		if (!port) {
+			console.error("No editor port available for applying semantic layout");
+			throw new Error("No editor port");
+		}
+		if (!port.applySemanticLayout) {
+			console.error("No applySemanticLayout method available on editor port");
+			throw new Error("No applySemanticLayout method");
+		}
+		await port.applySemanticLayout(input.viewId);
+		return {};
+	});
+	return useMemo(() => Object.assign(editorActorLogic.provide({ actors: {
+		applyLatest: fromPromise(applyLatest),
+		executeChange: fromPromise(executeChange),
+		applySemanticLayout: fromPromise(applySemanticLayout)
+	} }), { isStub }), [
+		applyLatest,
+		executeChange,
+		applySemanticLayout,
+		isStub
+	]);
 }
-
+//#endregion
 export { useEditorActorLogic };

package/dist/hooks/safeContext.js

@@ -1,24 +1,24 @@
-import { useContext, createContext } from 'react';
-
-const DiagramActorSafeContext = createContext(null);
+import "../_virtual/_rolldown/runtime.js";
+import { createContext, useContext } from "react";
+//#region src/hooks/safeContext.tsx
+/**
+* To improve experience with HMR, we move context to separate files and use as a boundary for hooks
+*/
+var DiagramActorSafeContext = createContext(null);
 DiagramActorSafeContext.displayName = "DiagramActorSafeContext";
-const DiagramApiSafeContext = createContext(null);
+var DiagramApiSafeContext = createContext(null);
 DiagramApiSafeContext.displayName = "DiagramApiSafeContext";
-const DiagramActorContextProvider = DiagramActorSafeContext.Provider;
-const DiagramApiContextProvider = DiagramApiSafeContext.Provider;
+var DiagramActorContextProvider = DiagramActorSafeContext.Provider;
+var DiagramApiContextProvider = DiagramApiSafeContext.Provider;
 function useDiagramActorRef() {
-  const ctx = useContext(DiagramActorSafeContext);
-  if (ctx === null) {
-    throw new Error("DiagramActorRef is not provided");
-  }
-  return ctx;
+	const ctx = useContext(DiagramActorSafeContext);
+	if (ctx === null) throw new Error("DiagramActorRef is not provided");
+	return ctx;
 }
 function useDiagram() {
-  const ctx = useContext(DiagramApiSafeContext);
-  if (ctx === null) {
-    throw new Error("DiagramApi is not provided");
-  }
-  return ctx;
+	const ctx = useContext(DiagramApiSafeContext);
+	if (ctx === null) throw new Error("DiagramApi is not provided");
+	return ctx;
 }
-
+//#endregion
 export { DiagramActorContextProvider, DiagramApiContextProvider, useDiagram, useDiagramActorRef };

package/dist/hooks/useCallbackRef.js

@@ -1,14 +1,21 @@
-import { useRef, useMemo } from 'react';
-
+import "../_virtual/_rolldown/runtime.js";
+import { useMemo, useRef } from "react";
+//#region src/hooks/useCallbackRef.ts
+/**
+* Memoizes a callback function so that it will not be recreated on every render.
+* The returned function is guaranteed to be the same reference across renders.
+* @param callback the callback function to memoize
+* @returns the memoized callback function
+*/
 function useCallbackRef(callback) {
-  const ref = useRef(callback);
-  ref.current = callback;
-  return useMemo(() => {
-    function callbackRef(...args) {
-      return ref.current?.(...args);
-    }
-    return callbackRef;
-  }, []);
+	const ref = useRef(callback);
+	ref.current = callback;
+	return useMemo(() => {
+		function callbackRef(...args) {
+			return ref.current?.(...args);
+		}
+		return callbackRef;
+	}, []);
 }
-
+//#endregion
 export { useCallbackRef };

package/dist/hooks/useCurrentView.js

@@ -1,12 +1,21 @@
-import { useDiagramSnapshot, selectDiagramActor } from './useDiagram.js';
-
-const selectViewId = selectDiagramActor((s) => s.context.view.id);
+import "../_virtual/_rolldown/runtime.js";
+import { selectDiagramActor, useDiagramSnapshot } from "./useDiagram.js";
+//#region src/hooks/useCurrentView.ts
+var selectViewId = selectDiagramActor((s) => s.context.view.id);
+/**
+* Returns current view id
+* Should be used only inside LikeC4Diagram
+*/
 function useCurrentViewId() {
-  return useDiagramSnapshot(selectViewId);
+	return useDiagramSnapshot(selectViewId);
 }
-const selectView = selectDiagramActor((s) => s.context.view);
+var selectView = selectDiagramActor((s) => s.context.view);
+/**
+* Returns current view
+* Should be used only inside LikeC4Diagram
+*/
 function useCurrentView() {
-  return useDiagramSnapshot(selectView);
+	return useDiagramSnapshot(selectView);
 }
-
+//#endregion
 export { useCurrentView, useCurrentViewId };

package/dist/hooks/useCurrentViewModel.js

@@ -1,11 +1,16 @@
-import { useOptionalCurrentViewModel } from '../context/LikeC4ModelContext.js';
-
+import "../_virtual/_rolldown/runtime.js";
+import { useOptionalCurrentViewModel } from "../context/LikeC4ModelContext.js";
+//#region src/hooks/useCurrentViewModel.ts
+/**
+* Hook to get the current view model from the context.
+* Throws an error if no view model is found in the context.
+*
+* @see useOptionalCurrentViewModel
+*/
 function useCurrentViewModel() {
-  const vm = useOptionalCurrentViewModel();
-  if (!vm) {
-    throw new Error("No CurrentViewModelContext found");
-  }
-  return vm;
+	const vm = useOptionalCurrentViewModel();
+	if (!vm) throw new Error("No CurrentViewModelContext found");
+	return vm;
 }
-
-export { useCurrentViewModel, useOptionalCurrentViewModel };
+//#endregion
+export { useCurrentViewModel };