@likec4/diagram 1.59.4 → 1.61.0

package/dist/context/LikeC4ModelContext.js

@@ -1,19 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { createContext, useContext } from "react";
-import "react/jsx-runtime";
-//#region src/context/LikeC4ModelContext.tsx
-var LikeC4ModelContext = createContext(null);
-var LikeC4ModelContextProvider = LikeC4ModelContext.Provider;
-var CurrentViewModelCtx = createContext(null);
-var 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);
-}
-//#endregion
-export { CurrentViewModelContext, LikeC4ModelContextProvider, useOptionalCurrentViewModel, useOptionalLikeC4Model };

package/dist/context/LikeC4ProjectsContext.d.ts

@@ -1,9 +0,0 @@
-import { ProjectId } from '@likec4/core/types';
-import { LikeC4ProjectData } from '../LikeC4ProjectsProvider';
-import { Provider } from 'react';
-export type LikeC4ProjectsContext = {
-    projects: ReadonlyArray<LikeC4ProjectData>;
-    onProjectChange: (id: ProjectId) => void;
-};
-export declare const LikeC4ProjectsContextProvider: Provider<LikeC4ProjectsContext | null>;
-export declare function useOptionalProjectsContext(): LikeC4ProjectsContext | null;

package/dist/context/LikeC4ProjectsContext.js

@@ -1,10 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { createContext, useContext } from "react";
-//#region src/context/LikeC4ProjectsContext.ts
-var LikeC4ProjectsContext = createContext(null);
-var LikeC4ProjectsContextProvider = LikeC4ProjectsContext.Provider;
-function useOptionalProjectsContext() {
-	return useContext(LikeC4ProjectsContext);
-}
-//#endregion
-export { LikeC4ProjectsContextProvider, useOptionalProjectsContext };

package/dist/context/RootContainerContext.d.ts

@@ -1,19 +0,0 @@
-import { WritableAtom } from 'nanostores';
-import { RefObject, Provider } from 'react';
-export type RootContainerContextType = {
-    readonly id: string;
-    readonly selector: string;
-    readonly ref: RefObject<HTMLDivElement | null>;
-    readonly $panning: WritableAtom<boolean>;
-    readonly reducedGraphics: boolean;
-};
-export declare const RootContainerContextProvider: Provider<RootContainerContextType | null>;
-export declare function useRootContainerContext(): RootContainerContextType | null;
-export declare function useRootContainer(): RootContainerContextType;
-export declare function useRootContainerRef(): RefObject<HTMLDivElement | null>;
-export declare function useRootContainerElement(): HTMLDivElement | null;
-/**
- * Hook to determine if reduced graphics mode is enabled.
- */
-export declare function useIsReducedGraphics(): boolean;
-export declare function useIsPanning(): boolean;

package/dist/context/RootContainerContext.js

@@ -1,22 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { createContext, useContext } from "react";
-import "@nanostores/react";
-//#region src/context/RootContainerContext.tsx
-var RootContainerContext = createContext(null);
-var 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;
-}
-//#endregion
-export { RootContainerContextProvider, useRootContainer, useRootContainerContext, useRootContainerElement, useRootContainerRef };

package/dist/context/TagStylesContext.d.ts

@@ -1,15 +0,0 @@
-import { TagSpecification } from '@likec4/core';
-import { LikeC4Styles } from '@likec4/core/styles';
-import { PropsWithChildren } from 'react';
-export declare function generateColorVars(spec: TagSpecification, styles?: LikeC4Styles): string;
-type TagStylesProviderProps = PropsWithChildren<{
-    /**
-     * Root element selector to scope the tag styles to (e.g., "#diagram-root")
-     * Must be a valid CSS selector
-     */
-    rootSelector: string;
-}>;
-export declare function TagStylesProvider({ children, rootSelector }: TagStylesProviderProps): import("react").JSX.Element;
-export declare function useTagSpecifications(): Record<string, TagSpecification>;
-export declare function useTagSpecification(tag: string): TagSpecification;
-export {};

package/dist/context/TagStylesContext.js

@@ -1,76 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { useLikeC4Specification } from "../hooks/useLikeC4Model.js";
-import { useLikeC4Styles } from "../hooks/useLikeC4Styles.js";
-import { createContext, memo } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { entries, flatMap, isEmpty, join, pipe } from "remeda";
-import { isTagColorSpecified } from "@likec4/core";
-import { useMantineStyleNonce } from "@mantine/core";
-import { DefaultTagColors, LikeC4Styles, getContrastedColorsAPCA, isValidColor } from "@likec4/core/styles";
-//#region src/context/TagStylesContext.tsx
-var radixColors = DefaultTagColors;
-function generateColorVars(spec, styles = LikeC4Styles.DEFAULT) {
-	const color = spec.color;
-	if (isTagColorSpecified(spec) && isValidColor(color)) return `
-  --colors-likec4-tag-bg: ${color};
-  --colors-likec4-tag-bg-hover: color-mix(in oklab, ${color}, var(--colors-likec4-mix-color) 20%);
-  --colors-likec4-tag-text: ${getContrastedColorsAPCA(color).hiContrast};
-    `;
-	if (radixColors.includes(color)) {
-		let textcolor = `var(--colors-${color}-12)`;
-		if ([
-			"mint",
-			"grass",
-			"lime",
-			"yellow",
-			"amber"
-		].includes(color)) textcolor = "rgba(0 0 0 / 0.85)";
-		return `
-  --colors-likec4-tag-border: var(--colors-${color}-8);
-  --colors-likec4-tag-bg: var(--colors-${color}-9);
-  --colors-likec4-tag-bg-hover: var(--colors-${color}-10);
-  --colors-likec4-tag-text: ${textcolor};
-    `;
-	}
-	if (styles.isThemeColor(color)) {
-		const { fill, hiContrast } = styles.tagColor(color);
-		return `
-  --colors-likec4-tag-bg: ${fill};
-  --colors-likec4-tag-bg-hover: color-mix(in oklab, ${fill}, var(--colors-likec4-mix-color) 20%);
-  --colors-likec4-tag-text: ${hiContrast};
-    `;
-	}
-	return "";
-}
-var TagStylesContext = createContext({});
-function generateStylesheet(tags, rootSelector, styles) {
-	if (!tags || isEmpty(tags)) return "";
-	return pipe(entries(tags), flatMap(([tag, spec]) => [
-		`:is(${rootSelector} [data-likec4-tag="${tag}"]) {`,
-		generateColorVars(spec, styles),
-		"}"
-	]), join("\n"));
-}
-function TagStylesProvider({ children, rootSelector }) {
-	const tags = useLikeC4Specification().tags;
-	const styles = useLikeC4Styles();
-	const nonce = useMantineStyleNonce()?.();
-	const stylesheet = generateStylesheet(tags, rootSelector, styles);
-	return /* @__PURE__ */ jsxs(TagStylesContext.Provider, {
-		value: tags,
-		children: [stylesheet !== "" && /* @__PURE__ */ jsx(TagStylesheet, {
-			nonce,
-			stylesheet
-		}), children]
-	});
-}
-var TagStylesheet = memo(({ stylesheet, nonce }) => {
-	return /* @__PURE__ */ jsx("style", {
-		"data-likec4-tags": true,
-		type: "text/css",
-		dangerouslySetInnerHTML: { __html: stylesheet },
-		nonce
-	});
-});
-//#endregion
-export { TagStylesProvider, generateColorVars };

package/dist/context/index.d.ts

@@ -1,7 +0,0 @@
-export { DiagramEventHandlers, useDiagramEventHandlers } from './DiagramEventHandlers';
-export { DefaultFeatures, DiagramFeatures, IfEnabled, IfNotEnabled, useEnabledFeatures, } from './DiagramFeatures';
-export type { EnabledFeatures } from './DiagramFeatures';
-export { EnsureMantine } from './EnsureMantine';
-export { FramerMotionConfig } from './FramerMotionConfig';
-export { IconRenderer, IconRendererProvider } from './IconRenderer';
-export { useRootContainer, useRootContainerElement, useRootContainerRef } from './RootContainerContext';

package/dist/custom/builtins.d.ts

@@ -1 +0,0 @@
-export { CompoundActions, CompoundDeploymentNode, CompoundDeploymentToolbar, CompoundDetailsButtonWithHandler, CompoundElementNode, CompoundElementToolbar, DeploymentElementActions, DeploymentElementToolbar, DeploymentNode, ElementActions, ElementDetailsButtonWithHandler, ElementNode, ElementToolbar, SequenceActorNode, SequenceParallelArea, Toolbar, ViewGroupNode, } from '../likec4diagram/custom/nodes';

package/dist/custom/customNodes.d.ts

@@ -1,233 +0,0 @@
-import { NodeModel } from '@likec4/core/model';
-import { aux } from '@likec4/core/types';
-import { FC } from 'react';
-import { Types } from '../likec4diagram/types';
-type Any = aux.Any;
-type Unknown = aux.UnknownLayouted;
-/**
- * Node that will be used to render the element from the model.
- * It is a leaf node, i.e. it does not have children.
- *
- * Custom node renderer receives these props:
- * - `nodeProps`: props from XYFlow
- * - `nodeModel`: LikeC4 {@link NodeModel.WithElement}
- *
- * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
- *
- * @example
- * ```tsx
- * import {
- *   elementNode,
- *   ElementNodeContainer,
- *   ElementShape,
- *   ElementData,
- *   ElementActions,
- *   ElementDetailsButtonWithHandler,
- *   IfEnabled,
- *   IfNotReadOnly,
- *   ElementToolbar,
- *   DefaultHandles,
- *   ElementTags
- * } from '@likec4/diagram/custom'
- *
- * const CustomElementNode = elementNode(({ nodeProps, nodeModel }) => (
- *   <ElementNodeContainer nodeProps={nodeProps}>
- *     <ElementShape {...nodeProps} />
- *     <ElementData {...nodeProps} />
- *     <IfEnabled feature="ElementTags">
- *       <ElementTags {...nodeProps} />
- *     </IfEnabled>
- *     <ElementActions
- *       {...nodeProps}
- *       extraButtons={[
- *         {
- *           key: 'plus',
- *           icon: <IconPlus />,
- *           onClick: () => console.log('extra'),
- *         },
- *       ]}
- *     />
- *     <ElementDetailsButtonWithHandler {...nodeProps} />
- *     {nodeModel.element.getMetadata('your-attr') === 'value' && <YourComponent />}
- *     <IfNotReadOnly>
- *       <ElementToolbar {...nodeProps} />
- *     </IfNotReadOnly>
- *     <DefaultHandles />
- *   </ElementNodeContainer>
- * ))
- * ```
- */
-export declare function elementNode<A extends Any = Unknown>(component: FC<ElementNodeProps<A>>): Types.NodeRenderer<'element'>;
-export type ElementNodeProps<A extends Any = Unknown> = {
-    nodeProps: Types.NodeProps<'element'>;
-    nodeModel: NodeModel.WithElement<A>;
-};
-/**
- * Node that will be used to render the element from deployment model.
- * It is a leaf node, i.e. it does not have children.
- * Can be {@link DeploymentNodeModel} or {@link DeployedInstanceModel}.
- *
- * Custom node renderer receives these props:
- * - `nodeProps`: props from XYFlow
- * - `nodeModel`: {@link NodeModel.WithDeploymentElement}
- *
- * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
- *
- * @example
- * ```tsx
- * import {
- *   deploymentNode,
- *   ElementNodeContainer,
- *   ElementShape,
- *   ElementData,
- *   DeploymentElementActions,
- *   ElementDetailsButtonWithHandler,
- *   IfNotReadOnly,
- *   DeploymentElementToolbar,
- *   DefaultHandles,
- * } from '@likec4/diagram/custom'
- *
- * const CustomDeploymentNode = deploymentNode(({ nodeProps, nodeModel }) => (
- *   <ElementNodeContainer nodeProps={nodeProps}>
- *     <ElementShape {...nodeProps} />
- *     <ElementData {...nodeProps} />
- *     <DeploymentElementActions
- *       {...nodeProps}
- *       extraButtons={[
- *         {
- *           key: 'plus',
- *           icon: <IconPlus />,
- *           onClick: () => console.log('extra'),
- *         },
- *       ]}
- *     />
- *     <ElementDetailsButtonWithHandler {...nodeProps} />
- *     <IfNotReadOnly>
- *       <DeploymentElementToolbar {...nodeProps} />
- *     </IfNotReadOnly>
- *     <DefaultHandles />
- *   </ElementNodeContainer>
- * ))
- * ```
- */
-export declare function deploymentNode<A extends Any = Unknown>(component: FC<DeploymentNodeProps<A>>): Types.NodeRenderer<'deployment'>;
-export type DeploymentNodeProps<A extends Any = Unknown> = {
-    nodeProps: Types.NodeProps<'deployment'>;
-    nodeModel: NodeModel.WithDeploymentElement<A>;
-};
-/**
- * Node that will be used to render the compound element from the model.
- * It is a container node, i.e. it has children.
- *
- * Custom node renderer receives these props:
- * - `nodeProps`: props from XYFlow
- * - `nodeModel`: LikeC4 {@link NodeModel.WithElement}
- *
- * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
- *
- * @example
- * ```tsx
- * import {
- *   compoundElementNode,
- *   CompoundNodeContainer,
- *   CompoundTitle,
- *   CompoundActions,
- *   CompoundDetailsButtonWithHandler,
- *   IfEnabled,
- *   CompoundElementToolbar,
- *   DefaultHandles,
- * } from '@likec4/diagram/custom'
- *
- * const CustomCompoundElementNode = compoundElementNode(({ nodeProps, nodeModel }) => (
- *   <CompoundNodeContainer nodeProps={props}>
- *     <CompoundTitle {...props} />
- *     <CompoundActions {...props} />
- *     <IfEnabled feature="ElementDetails">
- *       <CompoundDetailsButtonWithHandler {...props} />
- *     </IfEnabled>
- *     <IfNotReadOnly>
- *       <CompoundElementToolbar {...props} />
- *     </IfNotReadOnly>
- *     <DefaultHandles />
- *   </CompoundNodeContainer>
- * ))
- * ```
- */
-export declare function compoundElementNode<A extends Any = Unknown>(component: FC<CompoundElementNodeProps<A>>): Types.NodeRenderer<'compound-element'>;
-export type CompoundElementNodeProps<A extends Any = Unknown> = {
-    nodeProps: Types.NodeProps<'compound-element'>;
-    nodeModel: NodeModel.WithElement<A>;
-};
-/**
- * Node that will be used to render the compound from the deployment model.
- * It is a container node, i.e. it has children.
- *
- * Custom node renderer receives these props:
- * - `nodeProps`: props from XYFlow
- * - `nodeModel`: LikeC4 {@link NodeModel.WithDeploymentElement}
- *
- * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
- *
- * @example
- * ```tsx
- * import {
- *   compoundDeploymentNode,
- *   CompoundNodeContainer,
- *   CompoundTitle,
- *   CompoundActions,
- *   CompoundDeploymentToolbar,
- *   DefaultHandles,
- * } from '@likec4/diagram/custom'
- *
- * const CustomCompoundDeploymentNode = compoundDeploymentNode(({ nodeProps, nodeModel }) => (
- *   <CompoundNodeContainer nodeProps={nodeProps}>
- *     <CompoundTitle {...nodeProps} />
- *     <CompoundActions {...nodeProps} />
- *     <IfNotReadOnly>
- *       <CompoundDeploymentToolbar {...nodeProps} />
- *     </IfNotReadOnly>
- *     <DefaultHandles />
- *   </CompoundNodeContainer>
- * ```
- */
-export declare function compoundDeploymentNode<A extends Any = Unknown>(component: FC<CompoundDeploymentNodeProps<A>>): Types.NodeRenderer<'compound-deployment'>;
-export type CompoundDeploymentNodeProps<A extends Any = Unknown> = {
-    nodeProps: Types.NodeProps<'compound-deployment'>;
-    nodeModel: NodeModel.WithDeploymentElement<A>;
-};
-/**
- * Node that will be used to render the view group from the model.
- *
- * Custom node renderer receives these props:
- * - `nodeProps`: props from XYFlow
- * - `nodeModel`: LikeC4 {@link NodeModel.IsGroup}
- *
- * @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
- *
- * @example
- * ```tsx
- * import {
- *   viewGroupNode,
- *   CompoundNodeContainer,
- *   CompoundTitle,
- *   DefaultHandles,
- * } from '@likec4/diagram/custom'
- *
- * const CustomViewGroupNode = viewGroupNode(({ nodeProps, nodeModel }) => (
- *   <CompoundNodeContainer nodeProps={nodeProps}>
- *     <CompoundTitle {...nodeProps} />
- *     <DefaultHandles />
- *   </CompoundNodeContainer>
- * ```
- */
-export declare function viewGroupNode<A extends Any = Unknown>(component: FC<ViewGroupNodeProps<A>>): Types.NodeRenderer<'view-group'>;
-export type ViewGroupNodeProps<A extends Any = Unknown> = {
-    nodeProps: Types.NodeProps<'view-group'>;
-    nodeModel: NodeModel.IsGroup<A>;
-};
-export declare function sequenceActorNode<A extends Any = Unknown>(component: FC<SequenceActorNodeProps<A>>): Types.NodeRenderer<'seq-actor'>;
-export type SequenceActorNodeProps<A extends Any = Unknown> = {
-    nodeProps: Types.NodeProps<'seq-actor'>;
-    nodeModel: NodeModel.WithElement<A>;
-};
-export {};

package/dist/custom/customNodes.js

@@ -1,239 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { useLikeC4Model } from "../hooks/useLikeC4Model.js";
-import { jsx } from "react/jsx-runtime";
-//#region src/custom/customNodes.tsx
-function customDiagramNode(Node) {
-	return ((props) => {
-		const viewId = props.data.viewId;
-		const viewModel = useLikeC4Model().findView(viewId);
-		if (!viewModel) {
-			console.error(`View "${viewId}" not found, requested by customNode "${props.data.id}"`, { props });
-			return null;
-		}
-		const model = viewModel.findNode(props.data.id);
-		if (!model) {
-			console.error(`Node "${props.id}" not found in view "${viewId}", requested by customNode "${props.data.id}"`, { props });
-			return null;
-		}
-		return /* @__PURE__ */ jsx(Node, {
-			nodeProps: props,
-			nodeModel: model
-		});
-	});
-}
-/**
-* Node that will be used to render the element from the model.
-* It is a leaf node, i.e. it does not have children.
-*
-* Custom node renderer receives these props:
-* - `nodeProps`: props from XYFlow
-* - `nodeModel`: LikeC4 {@link NodeModel.WithElement}
-*
-* @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
-*
-* @example
-* ```tsx
-* import {
-*   elementNode,
-*   ElementNodeContainer,
-*   ElementShape,
-*   ElementData,
-*   ElementActions,
-*   ElementDetailsButtonWithHandler,
-*   IfEnabled,
-*   IfNotReadOnly,
-*   ElementToolbar,
-*   DefaultHandles,
-*   ElementTags
-* } from '@likec4/diagram/custom'
-*
-* const CustomElementNode = elementNode(({ nodeProps, nodeModel }) => (
-*   <ElementNodeContainer nodeProps={nodeProps}>
-*     <ElementShape {...nodeProps} />
-*     <ElementData {...nodeProps} />
-*     <IfEnabled feature="ElementTags">
-*       <ElementTags {...nodeProps} />
-*     </IfEnabled>
-*     <ElementActions
-*       {...nodeProps}
-*       extraButtons={[
-*         {
-*           key: 'plus',
-*           icon: <IconPlus />,
-*           onClick: () => console.log('extra'),
-*         },
-*       ]}
-*     />
-*     <ElementDetailsButtonWithHandler {...nodeProps} />
-*     {nodeModel.element.getMetadata('your-attr') === 'value' && <YourComponent />}
-*     <IfNotReadOnly>
-*       <ElementToolbar {...nodeProps} />
-*     </IfNotReadOnly>
-*     <DefaultHandles />
-*   </ElementNodeContainer>
-* ))
-* ```
-*/
-function elementNode(component) {
-	return customDiagramNode(component);
-}
-/**
-* Node that will be used to render the element from deployment model.
-* It is a leaf node, i.e. it does not have children.
-* Can be {@link DeploymentNodeModel} or {@link DeployedInstanceModel}.
-*
-* Custom node renderer receives these props:
-* - `nodeProps`: props from XYFlow
-* - `nodeModel`: {@link NodeModel.WithDeploymentElement}
-*
-* @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
-*
-* @example
-* ```tsx
-* import {
-*   deploymentNode,
-*   ElementNodeContainer,
-*   ElementShape,
-*   ElementData,
-*   DeploymentElementActions,
-*   ElementDetailsButtonWithHandler,
-*   IfNotReadOnly,
-*   DeploymentElementToolbar,
-*   DefaultHandles,
-* } from '@likec4/diagram/custom'
-*
-* const CustomDeploymentNode = deploymentNode(({ nodeProps, nodeModel }) => (
-*   <ElementNodeContainer nodeProps={nodeProps}>
-*     <ElementShape {...nodeProps} />
-*     <ElementData {...nodeProps} />
-*     <DeploymentElementActions
-*       {...nodeProps}
-*       extraButtons={[
-*         {
-*           key: 'plus',
-*           icon: <IconPlus />,
-*           onClick: () => console.log('extra'),
-*         },
-*       ]}
-*     />
-*     <ElementDetailsButtonWithHandler {...nodeProps} />
-*     <IfNotReadOnly>
-*       <DeploymentElementToolbar {...nodeProps} />
-*     </IfNotReadOnly>
-*     <DefaultHandles />
-*   </ElementNodeContainer>
-* ))
-* ```
-*/
-function deploymentNode(component) {
-	return customDiagramNode(component);
-}
-/**
-* Node that will be used to render the compound element from the model.
-* It is a container node, i.e. it has children.
-*
-* Custom node renderer receives these props:
-* - `nodeProps`: props from XYFlow
-* - `nodeModel`: LikeC4 {@link NodeModel.WithElement}
-*
-* @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
-*
-* @example
-* ```tsx
-* import {
-*   compoundElementNode,
-*   CompoundNodeContainer,
-*   CompoundTitle,
-*   CompoundActions,
-*   CompoundDetailsButtonWithHandler,
-*   IfEnabled,
-*   CompoundElementToolbar,
-*   DefaultHandles,
-* } from '@likec4/diagram/custom'
-*
-* const CustomCompoundElementNode = compoundElementNode(({ nodeProps, nodeModel }) => (
-*   <CompoundNodeContainer nodeProps={props}>
-*     <CompoundTitle {...props} />
-*     <CompoundActions {...props} />
-*     <IfEnabled feature="ElementDetails">
-*       <CompoundDetailsButtonWithHandler {...props} />
-*     </IfEnabled>
-*     <IfNotReadOnly>
-*       <CompoundElementToolbar {...props} />
-*     </IfNotReadOnly>
-*     <DefaultHandles />
-*   </CompoundNodeContainer>
-* ))
-* ```
-*/
-function compoundElementNode(component) {
-	return customDiagramNode(component);
-}
-/**
-* Node that will be used to render the compound from the deployment model.
-* It is a container node, i.e. it has children.
-*
-* Custom node renderer receives these props:
-* - `nodeProps`: props from XYFlow
-* - `nodeModel`: LikeC4 {@link NodeModel.WithDeploymentElement}
-*
-* @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
-*
-* @example
-* ```tsx
-* import {
-*   compoundDeploymentNode,
-*   CompoundNodeContainer,
-*   CompoundTitle,
-*   CompoundActions,
-*   CompoundDeploymentToolbar,
-*   DefaultHandles,
-* } from '@likec4/diagram/custom'
-*
-* const CustomCompoundDeploymentNode = compoundDeploymentNode(({ nodeProps, nodeModel }) => (
-*   <CompoundNodeContainer nodeProps={nodeProps}>
-*     <CompoundTitle {...nodeProps} />
-*     <CompoundActions {...nodeProps} />
-*     <IfNotReadOnly>
-*       <CompoundDeploymentToolbar {...nodeProps} />
-*     </IfNotReadOnly>
-*     <DefaultHandles />
-*   </CompoundNodeContainer>
-* ```
-*/
-function compoundDeploymentNode(component) {
-	return customDiagramNode(component);
-}
-/**
-* Node that will be used to render the view group from the model.
-*
-* Custom node renderer receives these props:
-* - `nodeProps`: props from XYFlow
-* - `nodeModel`: LikeC4 {@link NodeModel.IsGroup}
-*
-* @see [Default implementation](https://github.com/likec4/likec4/blob/main/packages/diagram/src/likec4diagram/custom/nodes/nodes.tsx)
-*
-* @example
-* ```tsx
-* import {
-*   viewGroupNode,
-*   CompoundNodeContainer,
-*   CompoundTitle,
-*   DefaultHandles,
-* } from '@likec4/diagram/custom'
-*
-* const CustomViewGroupNode = viewGroupNode(({ nodeProps, nodeModel }) => (
-*   <CompoundNodeContainer nodeProps={nodeProps}>
-*     <CompoundTitle {...nodeProps} />
-*     <DefaultHandles />
-*   </CompoundNodeContainer>
-* ```
-*/
-function viewGroupNode(component) {
-	return customDiagramNode(component);
-}
-function sequenceActorNode(component) {
-	return customDiagramNode(component);
-}
-//#endregion
-export { compoundDeploymentNode, compoundElementNode, deploymentNode, elementNode, sequenceActorNode, viewGroupNode };

package/dist/custom/hooks.d.ts

@@ -1,11 +0,0 @@
-export type { DiagramActorRef, DiagramActorSnapshot, DiagramContext, DiagramEmittedEvents, DiagramEvents, } from '../likec4diagram/state/types';
-export { useDiagramEventHandlers, } from '../context/DiagramEventHandlers';
-export { type EnabledFeatures, type FeatureName, useEnabledFeatures, } from '../context/DiagramFeatures';
-export { useCurrentView, useCurrentViewId, } from '../hooks/useCurrentView';
-export { type DiagramApi, useDiagram, useDiagramActorRef, useDiagramContext, useOnDiagramEvent, } from '../hooks/useDiagram';
-export { type CurrentViewModel, useCurrentViewModel, useOptionalCurrentViewModel, } from '../hooks/useCurrentViewModel';
-export { useLikeC4Model, useLikeC4Specification, useLikeC4ViewModel, useOptionalLikeC4Model, } from '../hooks/useLikeC4Model';
-export { useHasProjects, useLikeC4Project, useLikeC4ProjectId, useLikeC4Projects, useLikeC4ProjectsContext, } from '../hooks/useLikeC4Project';
-export { useLikeC4Styles, } from '../hooks/useLikeC4Styles';
-export { useSetState } from '../hooks/useSetState';
-export { useUpdateEffect } from '../hooks/useUpdateEffect';