@likec4/diagram 1.59.4 → 1.61.0

package/dist/components/markdown/useMarkdownRefsInteractivity.mjs

@@ -0,0 +1,126 @@
+import { __name } from "../../_virtual/_rolldown/runtime.mjs";
+import { useCallbackRef } from "../../hooks/useCallbackRef.mjs";
+import { parseMarkdownRefAnchor } from "./markdown-refs.mjs";
+import { useId, useMemo, useRef } from "react";
+import { useSyncedRef, useUnmountEffect } from "@react-hookz/web";
+import { shallowEqual } from "fast-equals";
+import { nonexhaustive } from "@likec4/core";
+import { createAtom } from "@xstate/store";
+
+// src/components/markdown/useMarkdownRefsInteractivity.tsx
+const interactiveRefSelector = "[data-likec4-ref-state=\"link\"], [data-likec4-ref-state=\"missing\"]";
+const inactiveRefState = {
+	element: null,
+	resolved: null,
+	opened: false
+};
+/**
+* Delegated event handlers for refs: one set of listeners on the Markdown block for all refs in it.
+* Activates links on click and Enter, shows a preview card on hover and focus.
+* Handlers from props are composed (called for events that are not ref activations).
+*/
+function useMarkdownRefsInteractivity(actions2, resolver3) {
+	const actionsRef = useSyncedRef(actions2);
+	const resolve = useCallbackRef(resolver3);
+	const previewId = useId();
+	const timer = useRef(void 0);
+	const interactivity = useMemo(() => {
+		const $active = createAtom(inactiveRefState, { compare: shallowEqual });
+		const $activeElement = createAtom(() => $active.get().element, { compare: (a, b) => a === b });
+		const $opened = createAtom(() => {
+			const state = $active.get();
+			return state.opened && state.element.isConnected;
+		});
+		let animationFrame = null;
+		const clearTimer = () => {
+			clearTimeout(timer.current);
+			if (animationFrame) {
+				cancelAnimationFrame(animationFrame);
+				animationFrame = null;
+			}
+		};
+		const open = (target, delay = 0) => {
+			if (animationFrame) cancelAnimationFrame(animationFrame);
+			animationFrame = requestAnimationFrame(() => {
+				animationFrame = null;
+				const element = closestRef(target, interactiveRefSelector);
+				if (!element) return;
+				clearTimer();
+				const state = $active.get();
+				if (state.opened && state.element === element) return;
+				const anchor = parseMarkdownRefAnchor(element);
+				const resolved = anchor ? resolve(anchor) : null;
+				if (!resolved || resolved.state === "text") return;
+				const show = () => $active.set((s) => ({
+					...s,
+					element,
+					resolved,
+					opened: true
+				}));
+				if (delay === 0 || state.opened) show();
+				else timer.current = setTimeout(show, delay);
+			});
+		};
+		const close = (delay = 0) => {
+			clearTimer();
+			const hide = () => $active.set((s) => ({
+				...s,
+				opened: false
+			}));
+			if (delay === 0) hide();
+			else timer.current = setTimeout(hide, delay);
+		};
+		const openRef = (resolved) => {
+			close();
+			switch (resolved.kind) {
+				case "element":
+					actionsRef.current?.openElement?.(resolved.fqn);
+					break;
+				case "view":
+					actionsRef.current?.openView?.(resolved.viewId);
+					break;
+				default: nonexhaustive(resolved);
+			}
+		};
+		/**
+		* @returns true if the event activated a ref
+		*/
+		const activate = (e) => {
+			const element = closestRef(e.target, "[data-likec4-ref-state=\"link\"]");
+			const anchor = element ? parseMarkdownRefAnchor(element) : null;
+			const resolved = anchor ? resolve(anchor) : null;
+			if (resolved?.state !== "link") return false;
+			e.preventDefault();
+			e.stopPropagation();
+			openRef(resolved);
+			return true;
+		};
+		const isInsidePreview = (node) => node instanceof Node && !!document.getElementById(previewId)?.contains(node);
+		return {
+			previewId,
+			$active,
+			$activeElement,
+			$opened,
+			open,
+			close,
+			openRef,
+			activate,
+			isInsidePreview,
+			clearTimer,
+			closestRef: (target) => closestRef(target, interactiveRefSelector),
+			reset: () => {
+				clearTimer();
+				$active.set(inactiveRefState);
+			}
+		};
+	}, [previewId]);
+	useUnmountEffect(interactivity.reset);
+	return interactivity;
+}
+function closestRef(target, selector) {
+	if (!(target instanceof Element)) return null;
+	const element = target.closest(selector);
+	return element instanceof HTMLElement ? element : null;
+}
+
+export { closestRef, interactiveRefSelector, useMarkdownRefsInteractivity };

package/dist/context/ComparingLayoutsContext.mjs

@@ -0,0 +1,24 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { createContext, useContext } from "react";
+
+// src/context/ComparingLayoutsContext.tsx
+const ComparingLayoutsContext = createContext(false);
+/**
+* Provides whether the diagram is comparing manual layout with the latest auto layout
+* (diagram actor is in `ready.comparing` state).
+*
+* Provided once by the diagram actor provider, so that nodes and edges
+* don't need to subscribe to the actor.
+*/
+const ComparingLayoutsProvider = ComparingLayoutsContext.Provider;
+/**
+* Returns true if the diagram is comparing manual layout with the latest auto layout.
+*
+* Unlike `useEnabledFeatures().enableCompareWithLatest` (feature is available),
+* this reflects whether comparing is active.
+*/
+function useIsComparingLayouts() {
+	return useContext(ComparingLayoutsContext);
+}
+
+export { ComparingLayoutsProvider, useIsComparingLayouts };

package/dist/context/CurrentViewModelProvider.mjs

@@ -0,0 +1,16 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { useCurrentViewId } from "../hooks/useCurrentView.mjs";
+import { CurrentViewModelContext, useOptionalLikeC4Model } from "./LikeC4ModelContext.mjs";
+import { jsx } from "react/jsx-runtime";
+
+// src/context/CurrentViewModelProvider.tsx
+function CurrentViewModelProvider({ children }) {
+	const viewId = useCurrentViewId();
+	const viewmodel = useOptionalLikeC4Model()?.findView(viewId) ?? null;
+	return /* @__PURE__ */ jsx(CurrentViewModelContext, {
+		value: viewmodel,
+		children
+	});
+}
+
+export { CurrentViewModelProvider };

package/dist/context/DiagramEventHandlers.mjs

@@ -0,0 +1,47 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { createContext, useContext, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useSyncedRef } from "@react-hookz/web";
+import { isFunction, keys, mapToObj } from "remeda";
+
+// src/context/DiagramEventHandlers.tsx
+const defaultHandlers = {
+	onNavigateTo: null,
+	onNodeClick: null,
+	onNodeContextMenu: null,
+	onCanvasContextMenu: null,
+	onEdgeClick: null,
+	onEdgeContextMenu: null,
+	onCanvasClick: null,
+	onCanvasDblClick: null,
+	onLogoClick: null,
+	onOpenSource: null,
+	onInitialized: null,
+	onLayoutTypeChange: null,
+	onRelationshipBrowserScopeChange: null
+};
+const HandlerNames = keys(defaultHandlers);
+const DiagramEventHandlersReactContext = createContext({
+	...mapToObj(HandlerNames, (name) => [name, null]),
+	handlersRef: { current: defaultHandlers }
+});
+function DiagramEventHandlers({ handlers, children }) {
+	const handlersRef = useSyncedRef(handlers);
+	const deps = HandlerNames.map((name) => isFunction(handlers[name]) ? name : "-").join(",");
+	const value = useMemo(() => ({
+		...mapToObj(HandlerNames, (name) => {
+			if (isFunction(handlers[name])) return [name, (...args) => handlersRef.current[name]?.(...args)];
+			return [name, null];
+		}),
+		handlersRef
+	}), [handlersRef, deps]);
+	return /* @__PURE__ */ jsx(DiagramEventHandlersReactContext.Provider, {
+		value,
+		children
+	});
+}
+function useDiagramEventHandlers() {
+	return useContext(DiagramEventHandlersReactContext);
+}
+
+export { DiagramEventHandlers, useDiagramEventHandlers };

package/dist/context/DiagramFeatures.d.mts

@@ -0,0 +1,28 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { PropsWithChildren } from "react";
+import { JSX as JSX$1 } from "react/jsx-runtime";
+import { ExclusiveUnion } from "@likec4/core/types";
+declare const FeatureNames: readonly ["Controls", "Editor", "AISemanticLayout", "ReadOnly", "FocusMode", "NavigateTo", "ElementDetails", "RelationshipDetails", "RelationshipBrowser", "Search", "NavigationButtons", "Notations", "DynamicViewWalkthrough", "FitView", "CompareWithLatest", "Notes", "Vscode", "ElementTags"];
+export type FeatureName = typeof FeatureNames[number];
+export type TogglableFeature = 'ReadOnly' & FeatureName;
+export type EnabledFeatures = { [P in `enable${FeatureName}`]: boolean; };
+export declare function useEnabledFeatures(): EnabledFeatures;
+/**
+ * Renders children only if the specified feature is enabled
+ * @param feature Feature name
+ * @param and Additional AND condition
+ * @example
+ * <IfEnabled feature="ReadOnly" and={isSomething}>
+ *   ...
+ * </IfEnabled>
+ */
+export declare function IfEnabled({ feature, children, and }: PropsWithChildren<{
+  feature: FeatureName;
+  and?: boolean;
+}>): JSX$1.Element | null;
+export declare function IfNotEnabled({ feature, children }: PropsWithChildren<{
+  feature: FeatureName;
+}>): JSX$1.Element | null;
+export declare function IfReadOnly({ children }: PropsWithChildren): JSX$1.Element | null;
+export declare function IfNotReadOnly({ children }: PropsWithChildren): JSX$1.Element | null;
+export {};

package/dist/context/DiagramFeatures.mjs

@@ -0,0 +1,101 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { useSetState } from "../hooks/useSetState.mjs";
+import { useUpdateEffect } from "../hooks/useUpdateEffect.mjs";
+import { ComparingLayoutsProvider } from "./ComparingLayoutsContext.mjs";
+import { createContext, useContext } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+
+// src/context/DiagramFeatures.tsx
+const DefaultFeatures = {
+	enableEditor: false,
+	/**
+	* Enabled if editor has `applySemanticLayout` method
+	*/
+	enableAISemanticLayout: false,
+	enableReadOnly: true,
+	enableCompareWithLatest: false,
+	enableControls: false,
+	enableDynamicViewWalkthrough: false,
+	enableElementDetails: false,
+	enableFocusMode: false,
+	enableNavigateTo: false,
+	enableNotations: false,
+	enableRelationshipBrowser: false,
+	enableRelationshipDetails: false,
+	enableSearch: false,
+	enableNavigationButtons: false,
+	enableFitView: false,
+	enableVscode: false,
+	enableElementTags: false,
+	enableNotes: false
+};
+const DiagramFeaturesContext = createContext(DefaultFeatures);
+function DiagramFeatures({ children, features, overrides }) {
+	const outerScope = useContext(DiagramFeaturesContext);
+	const [scope, setScope] = useSetState(() => ({
+		...outerScope,
+		...features,
+		...overrides
+	}));
+	useUpdateEffect(() => {
+		setScope({
+			...outerScope,
+			...features,
+			...overrides
+		});
+	}, [
+		outerScope,
+		features,
+		overrides,
+		setScope
+	]);
+	return /* @__PURE__ */ jsx(DiagramFeaturesContext.Provider, {
+		value: scope,
+		children
+	});
+}
+const overridesForOverlays = {
+	enableControls: false,
+	enableReadOnly: true,
+	enableAISemanticLayout: false,
+	enableCompareWithLatest: false
+};
+DiagramFeatures.Overlays = ({ children }) => {
+	return /* @__PURE__ */ jsx(DiagramFeatures, {
+		overrides: overridesForOverlays,
+		children: /* @__PURE__ */ jsx(ComparingLayoutsProvider, {
+			value: false,
+			children
+		})
+	});
+};
+function useEnabledFeatures() {
+	return useContext(DiagramFeaturesContext);
+}
+/**
+* Renders children only if the specified feature is enabled
+* @param feature Feature name
+* @param and Additional AND condition
+* @example
+* <IfEnabled feature="ReadOnly" and={isSomething}>
+*   ...
+* </IfEnabled>
+*/
+function IfEnabled({ feature, children, and = true }) {
+	const enabled = useEnabledFeatures()[`enable${feature}`] === true;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: enabled && and ? children : null });
+}
+function IfNotEnabled({ feature, children }) {
+	const notEnabled = useEnabledFeatures()[`enable${feature}`] !== true;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: notEnabled ? children : null });
+}
+function IfReadOnly({ children }) {
+	const isReadOnly = useEnabledFeatures().enableReadOnly === true;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: isReadOnly ? children : null });
+}
+function IfNotReadOnly({ children }) {
+	const isReadOnly = useEnabledFeatures().enableReadOnly === true;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: isReadOnly ? null : children });
+}
+
+export { DefaultFeatures, DiagramFeatures, IfEnabled, IfNotEnabled, IfNotReadOnly, IfReadOnly, useEnabledFeatures };

package/dist/context/EnsureMantine.mjs

@@ -0,0 +1,17 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { LikeC4MantineProvider } from "../LikeC4MantineProvider.mjs";
+import { useContext, useEffect } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+import { MantineContext } from "@mantine/core";
+
+// src/context/EnsureMantine.tsx
+function EnsureMantine({ children }) {
+	const mantineCtx = useContext(MantineContext);
+	useEffect(() => {
+		if (!mantineCtx) console.warn("LikeC4Diagram must be a child of LikeC4MantineProvider");
+	}, []);
+	if (!mantineCtx) return /* @__PURE__ */ jsx(LikeC4MantineProvider, { children });
+	return /* @__PURE__ */ jsx(Fragment$1, { children });
+}
+
+export { EnsureMantine };

package/dist/context/FramerMotionConfig.d.mts

@@ -0,0 +1,9 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { PropsWithChildren } from "react";
+export declare function FramerMotionConfig({ reducedMotion, children }: PropsWithChildren<{
+  /**
+   * If true, will respect the device prefersReducedMotion setting by switching
+   * transform animations off.
+   */
+  reducedMotion?: 'always' | 'never' | 'user' | undefined;
+}>): import("react").JSX.Element;

package/dist/context/FramerMotionConfig.mjs

@@ -0,0 +1,20 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { jsx } from "react/jsx-runtime";
+import { useMantineStyleNonce } from "@mantine/core";
+import { LazyMotion, MotionConfig, domMax } from "motion/react";
+
+// src/context/FramerMotionConfig.tsx
+function FramerMotionConfig({ reducedMotion = "user", children }) {
+	const nonce = useMantineStyleNonce()?.();
+	return /* @__PURE__ */ jsx(LazyMotion, {
+		features: domMax,
+		strict: true,
+		children: /* @__PURE__ */ jsx(MotionConfig, {
+			reducedMotion,
+			...nonce && { nonce },
+			children
+		})
+	});
+}
+
+export { FramerMotionConfig };

package/dist/context/IconRenderer.d.mts

@@ -0,0 +1,22 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { ElementIconRenderer, ElementIconRendererProps } from "../LikeC4Diagram.props.mjs";
+import { CSSProperties, PropsWithChildren, ReactNode } from "react";
+import { ElementShape } from "@likec4/core";
+/**
+ * Provider for custom element icon renderers
+ *
+ * @example
+ * ```tsx
+ * const MyIconRenderer: ElementIconRenderer = ({ node }) => {
+ *   return <div>{node.title}</div>
+ * }
+ *
+ * <IconRendererProvider value={MyIconRenderer}>
+ *   <LikeC4Diagram />
+ * </IconRendererProvider>
+ * ```
+ */
+export declare function IconRendererProvider({ value, children }: PropsWithChildren<{
+  value: ElementIconRenderer | null;
+}>): import("react").JSX.Element;
+export declare function DefaultIconRenderer({ node, ...props }: ElementIconRendererProps): import("react").JSX.Element | null;

package/dist/context/IconRenderer.mjs

@@ -0,0 +1,179 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import IconBrowser from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconBrowser.mjs";
+import IconCylinder from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconCylinder.mjs";
+import IconDeviceMobile from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconDeviceMobile.mjs";
+import IconFileText from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconFileText.mjs";
+import IconRectangularPrism from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconRectangularPrism.mjs";
+import IconReorder from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconReorder.mjs";
+import IconRobot from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconRobot.mjs";
+import IconUser from "../node_modules/.pnpm/@tabler_icons-react@3.49.0_react@19.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconUser.mjs";
+import { cx } from "@likec4/styles/css";
+import { createContext, useContext, useMemo } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+
+// src/context/IconRenderer.tsx
+const IconRendererContext = createContext(null);
+/**
+* Provider for custom element icon renderers
+*
+* @example
+* ```tsx
+* const MyIconRenderer: ElementIconRenderer = ({ node }) => {
+*   return <div>{node.title}</div>
+* }
+*
+* <IconRendererProvider value={MyIconRenderer}>
+*   <LikeC4Diagram />
+* </IconRendererProvider>
+* ```
+*/
+function IconRendererProvider({ value, children }) {
+	if (useContext(IconRendererContext)) return /* @__PURE__ */ jsx(Fragment$1, { children });
+	return /* @__PURE__ */ jsx(IconRendererContext.Provider, {
+		value,
+		children
+	});
+}
+function IconRenderer({ element, className, style }) {
+	const RenderIcon = useContext(IconRendererContext);
+	if (!element || !element.icon || element.icon === "none") return null;
+	let icon;
+	switch (true) {
+		case element.icon.startsWith("data:image/svg+xml"):
+			icon = /* @__PURE__ */ jsx(SvgDataUrlIcon, {
+				dataUrl: element.icon,
+				alt: element.title
+			});
+			break;
+		case element.icon.startsWith("http://"):
+		case element.icon.startsWith("https://"):
+		case element.icon.startsWith("data:image"):
+			icon = /* @__PURE__ */ jsx("img", {
+				src: element.icon,
+				alt: element.title
+			});
+			break;
+		case !!RenderIcon:
+			icon = /* @__PURE__ */ jsx(RenderIcon, { node: element });
+			break;
+		default: icon = /* @__PURE__ */ jsx(DefaultIconRenderer, { node: element });
+	}
+	if (!icon) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: cx(className, "likec4-element-icon"),
+		"data-likec4-icon": element.icon,
+		style,
+		children: icon
+	});
+}
+const ShapeIcons = {
+	browser: IconBrowser,
+	cylinder: IconCylinder,
+	mobile: IconDeviceMobile,
+	person: IconUser,
+	queue: IconReorder,
+	rectangle: IconRectangularPrism,
+	storage: IconCylinder,
+	bucket: IconCylinder,
+	document: IconFileText,
+	component: IconRectangularPrism,
+	agent: IconRobot
+};
+function IconOrShapeRenderer({ element, className, style }) {
+	if (!element.icon || element.icon === "none") {
+		const ShapeIcon = ShapeIcons[element.shape];
+		return /* @__PURE__ */ jsx("div", {
+			className: cx(className, "likec4-shape-icon"),
+			style,
+			children: /* @__PURE__ */ jsx(ShapeIcon, {})
+		});
+	}
+	return /* @__PURE__ */ jsx(IconRenderer, {
+		element,
+		className,
+		style
+	});
+}
+function SvgDataUrlIcon({ dataUrl, alt }) {
+	if (!useMemo(() => hasCurrentColorReference(dataUrl), [dataUrl])) return /* @__PURE__ */ jsx("img", {
+		src: dataUrl,
+		alt
+	});
+	const maskUrl = `url(${JSON.stringify(dataUrl)})`;
+	return /* @__PURE__ */ jsx("span", {
+		role: alt ? "img" : void 0,
+		"aria-label": alt,
+		style: {
+			display: "inline-block",
+			width: "100%",
+			height: "100%",
+			backgroundColor: "currentColor",
+			maskImage: maskUrl,
+			maskRepeat: "no-repeat",
+			maskPosition: "center",
+			maskSize: "contain",
+			WebkitMaskImage: maskUrl,
+			WebkitMaskRepeat: "no-repeat",
+			WebkitMaskPosition: "center",
+			WebkitMaskSize: "contain"
+		}
+	});
+}
+function hasCurrentColorReference(dataUrl) {
+	return /currentcolor/i.test(decodeSvgDataUrl(dataUrl) ?? "");
+}
+function decodeSvgDataUrl(dataUrl) {
+	if (!dataUrl.startsWith("data:image/svg+xml")) return null;
+	try {
+		const comma = dataUrl.indexOf(",");
+		if (comma === -1) return null;
+		const payload = dataUrl.slice(comma + 1);
+		if (dataUrl.slice(0, comma).endsWith(";base64")) return new TextDecoder().decode(Uint8Array.from(atob(payload), (c) => c.charCodeAt(0)));
+		try {
+			return decodeURIComponent(payload);
+		} catch {
+			return payload;
+		}
+	} catch {
+		return null;
+	}
+}
+const iconUrl = (group, name) => `https://icons.like-c4.dev/${encodeURIComponent(group)}/${encodeURIComponent(name)}.svg`;
+function MaskedIcon({ name, group, ...props }) {
+	const url = iconUrl(group, name);
+	const style = {
+		display: "inline-block",
+		width: "100%",
+		height: "100%",
+		backgroundColor: "currentColor",
+		maskImage: `url("${url}")`,
+		maskRepeat: "no-repeat",
+		maskPosition: "center",
+		maskSize: "contain",
+		WebkitMaskImage: `url("${url}")`,
+		WebkitMaskRepeat: "no-repeat",
+		WebkitMaskPosition: "center",
+		WebkitMaskSize: "contain"
+	};
+	return /* @__PURE__ */ jsx("span", {
+		...props,
+		"aria-hidden": "true",
+		style
+	});
+}
+function DefaultIconRenderer({ node, ...props }) {
+	if (!node.icon || node.icon === "none") return null;
+	const [group, name, ...rest] = node.icon.split(":");
+	if (!group || !name || rest.length > 0) return null;
+	if (group === "bootstrap" || group === "md") return /* @__PURE__ */ jsx(MaskedIcon, {
+		...props,
+		name,
+		group
+	});
+	return /* @__PURE__ */ jsx("img", {
+		...props,
+		src: iconUrl(group, name)
+	});
+}
+
+export { DefaultIconRenderer, IconOrShapeRenderer, IconRenderer, IconRendererProvider };

package/dist/context/LikeC4ModelContext.d.mts

@@ -0,0 +1,13 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { PropsWithChildren } from "react";
+import * as t from "@likec4/core/types";
+import { LayoutedView } from "@likec4/core/types";
+import { LikeC4Model, LikeC4ViewModel } from "@likec4/core/model";
+type UnknownLayouted$1 = t.aux.UnknownLayouted;
+export type CurrentViewModel = LikeC4ViewModel<UnknownLayouted$1, LayoutedView<UnknownLayouted$1>>;
+/**
+ * @returns The LikeC4Model from context, or null if no LikeC4ModelProvider is found.
+ */
+export declare function useOptionalLikeC4Model<A extends t.aux.Any = UnknownLayouted$1>(): LikeC4Model<A> | null;
+export declare function useOptionalCurrentViewModel(): CurrentViewModel | null;
+export {};

package/dist/context/LikeC4ModelContext.mjs

@@ -0,0 +1,20 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { createContext, useContext } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+
+// src/context/LikeC4ModelContext.tsx
+const LikeC4ModelContext = createContext(null);
+const LikeC4ModelContextProvider = LikeC4ModelContext.Provider;
+const CurrentViewModelCtx = createContext(null);
+const CurrentViewModelContext = CurrentViewModelCtx.Provider;
+/**
+* @returns The LikeC4Model from context, or null if no LikeC4ModelProvider is found.
+*/
+function useOptionalLikeC4Model() {
+	return useContext(LikeC4ModelContext);
+}
+function useOptionalCurrentViewModel() {
+	return useContext(CurrentViewModelCtx);
+}
+
+export { CurrentViewModelContext, LikeC4ModelContextProvider, useOptionalCurrentViewModel, useOptionalLikeC4Model };

package/dist/context/LikeC4ProjectsContext.d.mts

@@ -0,0 +1,7 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { LikeC4ProjectData } from "../LikeC4ProjectsProvider.mjs";
+import { ProjectId } from "@likec4/core/types";
+export type LikeC4ProjectsContext = {
+  projects: ReadonlyArray<LikeC4ProjectData>;
+  onProjectChange: (id: ProjectId) => void;
+};

package/dist/context/LikeC4ProjectsContext.mjs

@@ -0,0 +1,11 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { createContext, useContext } from "react";
+
+// src/context/LikeC4ProjectsContext.ts
+const LikeC4ProjectsContext = createContext(null);
+const LikeC4ProjectsContextProvider = LikeC4ProjectsContext.Provider;
+function useOptionalProjectsContext() {
+	return useContext(LikeC4ProjectsContext);
+}
+
+export { LikeC4ProjectsContextProvider, useOptionalProjectsContext };

package/dist/context/RootContainerContext.mjs

@@ -0,0 +1,23 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { createContext, useContext } from "react";
+import { useStore } from "@nanostores/react";
+
+// src/context/RootContainerContext.tsx
+const RootContainerContext = createContext(null);
+const RootContainerContextProvider = RootContainerContext.Provider;
+function useRootContainerContext() {
+	return useContext(RootContainerContext);
+}
+function useRootContainer() {
+	const ctx = useRootContainerContext();
+	if (!ctx) throw new Error("useRootContainer must be used within a RootContainer");
+	return ctx;
+}
+function useRootContainerRef() {
+	return useRootContainer().ref;
+}
+function useRootContainerElement() {
+	return useRootContainer().ref.current;
+}
+
+export { RootContainerContextProvider, useRootContainer, useRootContainerContext, useRootContainerElement, useRootContainerRef };