@tumaet/apollon 4.3.0 → 4.5.0

package/dist/react/services/migration/EdgeTransformer.d.ts

@@ -0,0 +1,11 @@
+import { ApollonEdge, UMLModel } from '../../typings';
+/**
+ * Returns a new edge whose data is free of stale runtime geometry. Does NOT
+ * mutate the input. A null/absent `data` is normalized to an empty object.
+ */
+export declare function hydrateEdgeData(edge: ApollonEdge): ApollonEdge;
+/**
+ * Transforms all edges in a `UMLModel`, ensuring every edge satisfies
+ * the `OrthogonalEdgeData` interface. Returns a new model object.
+ */
+export declare function transformEdges(model: UMLModel): UMLModel;

package/dist/{store → react/store}/context.d.ts

@@ -4,13 +4,16 @@ import { MetadataStore } from './metadataStore';
 import { PopoverStore } from './popoverStore';
 import { AssessmentSelectionStore } from './assessmentSelectionStore';
 import { AlignmentGuidesStore } from './alignmentGuidesStore';
+import { EdgeGeometryStore } from './edgeGeometryStore';
 export declare const DiagramStoreContext: import('react').Context<StoreApi<DiagramStore> | null>;
 export declare const MetadataStoreContext: import('react').Context<StoreApi<MetadataStore> | null>;
 export declare const PopoverStoreContext: import('react').Context<StoreApi<PopoverStore> | null>;
 export declare const AssessmentSelectionStoreContext: import('react').Context<StoreApi<AssessmentSelectionStore> | null>;
 export declare const AlignmentGuidesStoreContext: import('react').Context<StoreApi<AlignmentGuidesStore> | null>;
+export declare const EdgeGeometryStoreContext: import('react').Context<StoreApi<EdgeGeometryStore> | null>;
 export declare const useDiagramStore: <T>(selector: (state: DiagramStore) => T) => T;
 export declare const useMetadataStore: <T>(selector: (state: MetadataStore) => T) => T;
 export declare const usePopoverStore: <T>(selector: (state: PopoverStore) => T) => T;
 export declare const useAssessmentSelectionStore: <T>(selector: (state: AssessmentSelectionStore) => T) => T;
 export declare const useAlignmentGuidesStore: <T>(selector: (state: AlignmentGuidesStore) => T) => T;
+export declare const useEdgeGeometryStore: <T>(selector: (state: EdgeGeometryStore) => T) => T;

package/dist/{store → react/store}/diagramStore.d.ts

@@ -18,6 +18,7 @@ export type DiagramStore = {
     canUndo: boolean;
     canRedo: boolean;
     undoManager: Y.UndoManager | null;
+    previewMode: boolean;
     setDiagramId: (diagramId: string) => void;
     setNodes: (payload: Node[] | ((nodes: Node[]) => Node[])) => void;
     setEdges: (payload: Edge[] | ((edges: Edge[]) => Edge[])) => void;
@@ -42,5 +43,12 @@ export type DiagramStore = {
     getInteractiveForSerialization: () => InteractiveElements | undefined;
     setInteractive: (interactive: InteractiveElements | undefined) => void;
     isElementInteractive: (elementId: string) => boolean;
+    /**
+     * Toggle the preview overlay. When entering, the Yjs doc is left
+     * untouched by store mutators and observers. When exiting, the local
+     * Zustand state is rebuilt from the (peer-augmented) Yjs maps so the
+     * canvas catches up to everything that arrived during preview.
+     */
+    setPreviewMode: (active: boolean) => void;
 };
 export declare const createDiagramStore: (ydoc: Y.Doc) => UseBoundStore<StoreApi<DiagramStore>>;

package/dist/react/store/edgeGeometryStore.d.ts

@@ -0,0 +1,18 @@
+import { StoreApi, UseBoundStore } from 'zustand';
+import { IPoint } from '../edges/Connection';
+/**
+ * Runtime-only registry of each edge's ACTUAL rendered polyline (jump-free),
+ * keyed by edge id. Line jumps read other edges' geometry from here instead of
+ * re-deriving it, so a bridge always centers on the crossing the user actually
+ * sees — regardless of edge type, routing (step / straight-path), handle, or
+ * container offset. Each edge publishes on render and removes on unmount.
+ *
+ * Not persisted (Yjs never sees it) — it is ephemeral view geometry, exactly
+ * the kind of "computed segments" the model deliberately does not store.
+ */
+export type EdgeGeometryStore = {
+    geometryById: Record<string, IPoint[]>;
+    publishEdgeGeometry: (id: string, points: IPoint[]) => void;
+    removeEdgeGeometry: (id: string) => void;
+};
+export declare const createEdgeGeometryStore: () => UseBoundStore<StoreApi<EdgeGeometryStore>>;

package/dist/{store → react/store}/index.d.ts

@@ -3,4 +3,5 @@ export { createMetadataStore } from './metadataStore';
 export { createPopoverStore } from './popoverStore';
 export { createAssessmentSelectionStore } from './assessmentSelectionStore';
 export { createAlignmentGuidesStore } from './alignmentGuidesStore';
-export { DiagramStoreContext, MetadataStoreContext, PopoverStoreContext, AssessmentSelectionStoreContext, AlignmentGuidesStoreContext, useDiagramStore, useMetadataStore, usePopoverStore, useAssessmentSelectionStore, useAlignmentGuidesStore, } from './context';
+export { createEdgeGeometryStore } from './edgeGeometryStore';
+export { DiagramStoreContext, MetadataStoreContext, PopoverStoreContext, AssessmentSelectionStoreContext, AlignmentGuidesStoreContext, EdgeGeometryStoreContext, useDiagramStore, useMetadataStore, usePopoverStore, useAssessmentSelectionStore, useAlignmentGuidesStore, useEdgeGeometryStore, } from './context';

package/dist/{store → react/store}/metadataStore.d.ts

@@ -1,6 +1,7 @@
 import { StoreApi, UseBoundStore } from 'zustand';
 import { UMLDiagramType } from '../types';
 import { ApollonMode, ApollonView } from '../typings';
+import { IPoint } from '../edges/Connection';
 import * as Y from "yjs";
 export type MetadataStore = {
     diagramTitle: string;
@@ -12,12 +13,22 @@ export type MetadataStore = {
     debug: boolean;
     scrollLock: boolean;
     scrollEnabled: boolean;
+    connectionGuidanceActive: boolean;
+    connectionGuidanceSourceNodeId: string | null;
+    connectionGuidanceSourceHandleId: string | null;
+    reconnectPreviewEdgeId: string | null;
+    reconnectPreviewHandleType: "source" | "target" | null;
+    reconnectPreviewBasePoints: IPoint[];
     setMode: (mode: ApollonMode) => void;
     setView: (view: ApollonView) => void;
     setAvailableViews: (availableViews: ApollonView[]) => void;
     setReadonly: (readonly: boolean) => void;
     setScrollLock: (scrollLock: boolean) => void;
     setScrollEnabled: (scrollEnabled: boolean) => void;
+    startConnectionGuidance: (sourceNodeId: string | null, sourceHandleId: string | null) => void;
+    stopConnectionGuidance: () => void;
+    startReconnectPreview: (edgeId: string, handleType: "source" | "target", basePoints: IPoint[]) => void;
+    stopReconnectPreview: () => void;
     updateDiagramTitle: (diagramTitle: string) => void;
     updateDiagramType: (diagramType: UMLDiagramType) => void;
     updateMetaData: (diagramTitle: string, diagramType: UMLDiagramType) => void;
@@ -25,4 +36,4 @@ export type MetadataStore = {
     reset: () => void;
     setDebug: (debug: boolean) => void;
 };
-export declare const createMetadataStore: (ydoc: Y.Doc) => UseBoundStore<StoreApi<MetadataStore>>;
+export declare const createMetadataStore: (ydoc: Y.Doc, isPreviewMode?: () => boolean) => UseBoundStore<StoreApi<MetadataStore>>;

package/dist/react/sync/headless.d.ts

@@ -0,0 +1,16 @@
+import { YjsSync } from './yjsSync';
+import * as Y from "yjs";
+/**
+ * Construct a `YjsSync` against minimal stub stores. Intended for
+ * tests that exercise the wire protocol (sync/awareness handshake,
+ * incremental updates, reconnect behaviour) without dragging the React
+ * editor / React-Flow / zustand-with-middleware setup into the harness.
+ *
+ * Stores expose only the methods the sync class actually invokes. The
+ * Yjs observers will call them, but their bodies are no-ops because the
+ * test asserts directly against the `Y.Doc` that's returned.
+ */
+export declare function createHeadlessSync(ydoc?: Y.Doc): {
+    ydoc: Y.Doc;
+    sync: YjsSync;
+};

package/dist/react/sync/yjsSync.d.ts

@@ -0,0 +1,62 @@
+import { DiagramStore } from '../store/diagramStore';
+import { MetadataStore } from '../store/metadataStore';
+import { CollaborationState, CollaborationUser, CollaborationViewport, CollaboratorInfo } from '../typings';
+import { StoreApi } from 'zustand';
+import * as Y from "yjs";
+export declare enum MessageType {
+    YjsSYNC = 0,
+    YjsUpdate = 1,
+    AwarenessSync = 2,
+    AwarenessUpdate = 3
+}
+export type SendBroadcastMessage = (base64data: string) => void;
+export declare class YjsSync {
+    private readonly stopYjsObserver;
+    private sendBroadcastMessage;
+    private readonly ydoc;
+    private readonly diagramStore;
+    private readonly metadataStore;
+    private readonly awareness;
+    constructor(ydoc: Y.Doc, diagramStore: StoreApi<DiagramStore>, metadataStore: StoreApi<MetadataStore>);
+    stopSync(): void;
+    /**
+     * Push the entire local Yjs document as a single `YjsUpdate`. Callers should
+     * invoke this after a (re)connect so peers absorb any edits made while we
+     * were disconnected — those updates fire while `readyState !== OPEN`, are
+     * silently dropped by the send callback, and never replayed otherwise.
+     * Yjs CRDTs converge on merge, so peers that already have these ops just
+     * no-op.
+     */
+    broadcastFullState: () => void;
+    setSendBroadcastMessage: (sendFn: SendBroadcastMessage) => void;
+    setLocalAwarenessUser: (user: CollaborationUser) => void;
+    setLocalAwarenessCursor: (cursor: {
+        x: number;
+        y: number;
+    } | null) => void;
+    setLocalAwarenessViewport: (viewport: CollaborationViewport | null) => void;
+    setLocalAwarenessFollowing: (followingClientId: number | null) => void;
+    setLocalAwarenessSelectedElement: (selectedElementId: string | null) => void;
+    setLocalAwarenessState: (state: Partial<CollaborationState>) => void;
+    subscribeToAwarenessChanges: (callback: (states: Map<number, CollaborationState>) => void) => () => void;
+    getAwarenessStates: () => Map<number, CollaborationState>;
+    getCollaborators: () => CollaboratorInfo[];
+    subscribeToCollaboratorChanges: (callback: (collaborators: CollaboratorInfo[]) => void) => () => void;
+    getLocalAwarenessClientId: () => number;
+    private static narrowState;
+    private getTypedStates;
+    private computeParticipantSignature;
+    private sendFramedMessage;
+    private applyUpdate;
+    handleReceivedData: (base64Data: string) => void;
+    private startYjsObserver;
+    private isUndoRedoTransaction;
+    /**
+     *  Convert Uint8Array to Base64 string
+     */
+    static uint8ToBase64(uint8: Uint8Array): string;
+    /**
+     * Convert Base64 string to Uint8Array
+     */
+    private base64ToUint8;
+}

package/dist/{typings.d.ts → react/typings.d.ts}

@@ -2,7 +2,6 @@ import { DiagramEdgeType, IPoint } from './edges/types';
 import { DiagramNodeType } from './nodes/types';
 import { UMLDiagramType } from './types/DiagramType';
 import { Styles } from './styles/theme';
-import { DeepPartial } from './utils';
 export { UMLDiagramType, type DiagramNodeType, type DiagramEdgeType };
 export { type Styles };
 export type Unsubscriber = () => void;
@@ -10,6 +9,44 @@ export type Subscribers = {
     [key: number]: Unsubscriber;
 };
 export type UMLModelElementType = DiagramNodeType | DiagramEdgeType;
+export type CollaborationUser = {
+    name: string;
+    color: string;
+    id?: string;
+    imageUrl?: string;
+};
+export type CollaborationCursor = {
+    x: number;
+    y: number;
+};
+export type CollaborationViewport = {
+    x: number;
+    y: number;
+    zoom: number;
+};
+export type CollaborationState = {
+    user?: CollaborationUser;
+    cursor?: CollaborationCursor | null;
+    viewport?: CollaborationViewport | null;
+    followingClientId?: number | null;
+    selectedElementId?: string | null;
+};
+export type CollaboratorInfo = {
+    id: string;
+    name: string;
+    color: string;
+    imageUrl?: string;
+    clientIds: number[];
+    isLocal: boolean;
+};
+export type ApollonCollaborationOptions = {
+    enabled?: boolean;
+    user?: CollaborationUser;
+    showPresence?: boolean;
+    showCursors?: boolean;
+    showSelectionHighlights?: boolean;
+    showFollow?: boolean;
+};
 export declare enum Locale {
     en = "en",
     de = "de"
@@ -37,6 +74,10 @@ export type ApollonNode = {
         height: number;
     };
 };
+export interface OrthogonalEdgeData {
+    [key: string]: unknown;
+    points: IPoint[];
+}
 export type ApollonEdge = {
     id: string;
     source: string;
@@ -44,10 +85,7 @@ export type ApollonEdge = {
     type: DiagramEdgeType;
     sourceHandle: string;
     targetHandle: string;
-    data: {
-        [key: string]: unknown;
-        points: IPoint[];
-    };
+    data: OrthogonalEdgeData;
 };
 export type InteractiveElements = {
     elements: Record<string, boolean>;
@@ -79,13 +117,10 @@ export type ApollonOptions = {
     readonly?: boolean;
     enablePopups?: boolean;
     model?: UMLModel;
-    theme?: DeepPartial<Styles>;
     locale?: Locale;
-    copyPasteToClipboard?: boolean;
-    colorEnabled?: boolean;
-    scale?: number;
     debug?: boolean;
     collaborationEnabled?: boolean;
+    collaboration?: ApollonCollaborationOptions;
     scrollLock?: boolean;
 };
 export type FeedbackCorrectionStatus = {

package/dist/{utils → react/utils}/alignmentUtils.d.ts

@@ -11,7 +11,7 @@ export type AlignmentInfo = {
 /**
  * Get the bounds of a node (considering its position and dimensions)
  */
-export declare const getNodeBounds: (node: Node) => {
+export declare const getNodeBounds: (node: Node, allNodes?: Node[]) => {
     left: number;
     right: number;
     top: number;
@@ -26,7 +26,7 @@ export declare const calculateAlignmentGuides: (draggedNode: Node, allNodes: Nod
 /**
  * Snap node position to nearby nodes
  */
-export declare const snapNodeToGuides: (draggedNode: Node, guides: AlignmentGuide[], threshold?: number) => {
+export declare const snapNodeToGuides: (draggedNode: Node, guides: AlignmentGuide[], threshold?: number, allNodes?: Node[]) => {
     x?: number;
     y?: number;
 };

package/dist/react/utils/collaboration.d.ts

@@ -0,0 +1,10 @@
+import { CollaborationViewport } from '../typings';
+export declare const randomCollabName: () => string;
+export declare const collabColorFromName: (name: string) => string;
+/**
+ * Narrow an untrusted, peer-supplied viewport before it reaches React Flow's
+ * `setViewport`. A `NaN`/`Infinity`/non-positive zoom corrupts the canvas
+ * transform, so every field must be a finite number and zoom must be positive.
+ * Returns `null` for anything malformed.
+ */
+export declare const sanitizeCollaborationViewport: (raw: unknown) => CollaborationViewport | null;

package/dist/react/utils/edgeUtils.d.ts

@@ -0,0 +1,167 @@
+import { IPoint } from '../edges/Connection';
+import { DiagramEdgeType, UMLDiagramType } from '../typings';
+import { Position, Rect, XYPosition, ConnectionLineType } from '@xyflow/react';
+/**
+ * Adjusts the target coordinates based on the position and marker padding.
+ */
+export declare const adjustTargetCoordinates: (targetX: number, targetY: number, targetPosition: Position, markerPadding: number) => {
+    targetX: number;
+    targetY: number;
+};
+/**
+ * Adjusts the source coordinates based on the position and marker padding.
+ */
+export declare const adjustSourceCoordinates: (sourceX: number, sourceY: number, sourcePosition: Position, sourcePadding: number) => {
+    sourceX: number;
+    sourceY: number;
+};
+export declare const calculateDynamicEdgeLabels: (x: number, y: number, direction: string) => {
+    roleX: number;
+    roleY: number;
+    roleTextAnchor: "end";
+    multiplicityX: number;
+    multiplicityY: number;
+    multiplicityTextAnchor: "start";
+} | {
+    roleX: number;
+    roleY: number;
+    roleTextAnchor: "end";
+    multiplicityX: number;
+    multiplicityY: number;
+    multiplicityTextAnchor: "end";
+} | {
+    roleX: number;
+    roleY: number;
+    roleTextAnchor: "start";
+    multiplicityX: number;
+    multiplicityY: number;
+    multiplicityTextAnchor: "start";
+} | {
+    roleX: number;
+    roleY: number;
+    roleTextAnchor: "middle";
+    multiplicityX: number;
+    multiplicityY: number;
+    multiplicityTextAnchor: "middle";
+};
+export interface EdgeMarkerStyles {
+    markerEnd?: string;
+    markerStart?: string;
+    markerPadding?: number;
+    strokeDashArray?: string;
+    offset?: number;
+}
+export declare function getEdgeMarkerStyles(edgeType: string): EdgeMarkerStyles;
+interface FindClosestHandleParams {
+    point: XYPosition;
+    rect: Rect;
+    useFourHandles?: boolean;
+}
+export declare function getNormalizedHandleOffset(axisLength: number, ratio: number): number;
+export declare function getNormalizedHandleOffsetPercent(axisLength: number, ratio: number): string;
+export type AxisHandlePlan = {
+    offsets: [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+    ];
+    visibleArcCount: 1 | 3 | 5;
+};
+export declare function getAxisHandlePlan(axisLength: number): AxisHandlePlan;
+/**
+ * Reduce how many arcs a side actually shows so adjacent visible arcs never
+ * overlap ON SCREEN. The slot offsets stay fixed (handles don't move); we just
+ * hide arcs when, at the current zoom, two neighbours would be closer than an
+ * arc's on-screen length apart. Arcs counter-scale to a constant on-screen size
+ * when zoomed out and grow when zoomed in, so the required flow spacing is
+ * ARC_LENGTH_PX / min(zoom, 1): bigger (fewer arcs) when zoomed out, constant
+ * at and above 1x.
+ *
+ * Returns 5, 3, or 1 — always <= the size-based `baseVisibleArcCount`.
+ */
+export declare function reduceVisibleArcCountForZoom(offsets: AxisHandlePlan["offsets"], baseVisibleArcCount: 1 | 3 | 5, zoom: number): 1 | 3 | 5;
+export declare function getDistributedHandleOffsets(axisLength: number): number[];
+export declare function getDistributedHandleOffsetPercents(axisLength: number): [string, string, string, string, string, string, string, string, string];
+type HandleSide = "top" | "right" | "bottom" | "left";
+export declare function getHandleIdForSideSlot(side: HandleSide, slotIndex: number, slotCount: number): string;
+export declare function findClosestHandle({ point, rect, useFourHandles, }: FindClosestHandleParams): string;
+/**
+ * Helper function to get handle position on ellipse perimeter
+ */
+export declare function getEllipseHandlePosition(centerX: number, centerY: number, radiusX: number, radiusY: number, handle: string): {
+    x: number;
+    y: number;
+};
+export type Orientation = "horizontal" | "vertical";
+export type AxisAlignedSegment = {
+    index: number;
+    start: IPoint;
+    end: IPoint;
+    orientation: Orientation;
+    fixed: number;
+    min: number;
+    max: number;
+};
+export declare function getAxisAlignedSegments(points: IPoint[], tolerance?: number): AxisAlignedSegment[];
+export type LineJumpHit = {
+    segmentIndex: number;
+    point: IPoint;
+    orientation: Orientation;
+};
+export declare function findLineJumpIntersections(baseSegments: AxisAlignedSegment[], otherSegments: AxisAlignedSegment[], jumpWidth: number, preferredOrientation?: Orientation | "any", tolerance?: number): LineJumpHit[];
+export declare function buildPathWithLineJumps(points: IPoint[], jumps: LineJumpHit[], jumpHeight: number, jumpWidth?: number): string;
+/**
+ * Collects the crossings an edge should bridge over. Uses the layout-stable
+ * "horizontal hops vertical" convention (yEd / yFiles' `BridgeManager` default
+ * `HORIZONTAL_BRIDGES_VERTICAL`): the bridge is always drawn on the HORIZONTAL
+ * segment of a crossing. Consequences that make this the right default for a
+ * declarative editor:
+ *  - exactly one edge of any H×V pair hops (the horizontal one),
+ *  - the assignment is independent of edge array order / z-index, so it never
+ *    flips when an edge is selected (React Flow's `elevateEdgesOnSelect`) or
+ *    reordered — unlike a render-order rule.
+ * Diagonal segments yield no axis-aligned segments, so they neither hop nor are
+ * hopped (line jumps are orthogonal-only, matching mxGraph/ELK/yFiles).
+ *
+ * @param geometryMap each OTHER edge's actual rendered polyline, keyed by id
+ *   (from the edge-geometry registry)
+ */
+export declare function computeLineJumpsForEdge(edgeId: string, basePoints: IPoint[], edges: ReadonlyArray<{
+    id: string;
+}>, geometryMap: ReadonlyMap<string, IPoint[]>): LineJumpHit[];
+export declare function calculateOverlayPath(sourceX: number, sourceY: number, targetX: number, targetY: number, type: string): string;
+export declare function calculateStraightPath(sourceX: number, sourceY: number, targetX: number, targetY: number, type: string): string;
+export declare function simplifySvgPath(path: string): string;
+export declare function simplifyPoints(points: IPoint[]): IPoint[];
+export declare function parseSvgPath(path: string): IPoint[];
+export declare function removeDuplicatePoints(points: IPoint[]): IPoint[];
+export declare function resolveReconnectPreviewBasePoints(storedPoints: IPoint[] | undefined, localPoints: IPoint[] | undefined, fallbackPoints: IPoint[]): IPoint[];
+/**
+ * Returns true when source and target stubs point toward each other and would
+ * overlap or leave no room between them. This catches the "narrow U" case —
+ * where the two arms of a U-shape almost touch — before the geometry has
+ * actually inverted (which hasCollapsingSegments catches too late).
+ *
+ * Only applies to facing-stub configurations where both stubs exit into the
+ * same space and can collide. Diverging pairs are handled by later validation.
+ */
+export declare const stubsWouldOverlap: (sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position, stubLength: number) => boolean;
+export declare function isInvalidOrthogonalEdgeRelease(points: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): boolean;
+export declare function normalizeOrthogonalEdgePoints(points: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): IPoint[];
+export declare function resolveOrthogonalEdgeReleasePoints(releasedPoints: IPoint[], lastValidPoints: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): IPoint[];
+export declare function preserveOrthogonalEdgePoints(points: IPoint[], sourcePoint: IPoint, targetPoint: IPoint, sourcePosition: Position, targetPosition: Position): IPoint[];
+export declare function getMarkerSegmentPath(points: IPoint[], offset: number, targetPosition: "top" | "bottom" | "left" | "right"): string;
+export declare const getDefaultEdgeType: (diagramType: UMLDiagramType) => DiagramEdgeType;
+/**
+ * Determines the appropriate connection line type based on the diagram type
+ * @param diagramType - The type of diagram being rendered
+ * @returns The corresponding ConnectionLineType
+ */
+export declare function getConnectionLineType(diagramType: UMLDiagramType): ConnectionLineType;
+export {};

package/dist/{utils → react/utils}/exportUtils.d.ts

@@ -34,7 +34,6 @@ declare function getNodeBoundsFromDOM(container: HTMLElement, reactFlow?: ReactF
  */
 declare function getNodeOverflowBoundsFromDOM(container: HTMLElement): Rect | undefined;
 declare function mergeBounds(a: Rect, b: Rect): Rect;
-export declare function getDiagramBounds(reactFlow: ReactFlowInstance<Node, Edge>, container?: HTMLElement | null): Rect;
 export declare function getRenderedDiagramBounds(reactFlow: ReactFlowInstance<Node, Edge>, container: HTMLElement): Rect;
 declare function extractStyles(styleString: string): {
     transform: {

package/dist/react/utils/geometry/bendHandles.d.ts

@@ -0,0 +1,42 @@
+import { Position } from '@xyflow/react';
+import { IPoint } from '../../edges/Connection';
+export declare function collapseCollinearPoints(points: IPoint[]): IPoint[];
+export type SegmentKind = "source-terminal" | "target-terminal" | "inner";
+export interface BendHandle {
+    segmentIndex: number;
+    position: IPoint;
+    orientation: "H" | "V";
+    kind: SegmentKind;
+}
+export declare function hasArmCollapse(points: IPoint[], proximityPx: number): boolean;
+export declare function getSegmentOrientation(points: IPoint[], segmentIndex: number): "H" | "V";
+export declare function getSegmentKind(segmentIndex: number, totalPoints: number): SegmentKind;
+export declare function getSegmentEffectiveLength(points: IPoint[], segmentIndex: number, stubLength: number): number;
+/**
+ * Whether a flow-space length is long enough to host an interactive handle,
+ * judged by its ON-SCREEN size. Screen-based so the rule matches what the user
+ * sees: zooming in always reveals more handles (a short segment becomes
+ * editable once it is `minScreenLength` px long on screen) and never hides
+ * them. `minScreenLength` is a screen-px budget (handle size + clearance).
+ */
+export declare function isLengthEditableAtZoom(canvasLength: number, minScreenLength: number, zoom: number): boolean;
+export declare function getStubExit(nodePoint: IPoint, position: Position, stubLength: number): IPoint;
+export declare function getBendHandlePosition(points: IPoint[], segmentIndex: number): IPoint;
+/**
+ * Bend handles for every segment with enough ON-SCREEN room to host one.
+ *
+ * The "safe area" next to each node (`safeAreaPx`) is excluded: a terminal
+ * segment loses that length at its node end, both for deciding whether a handle
+ * fits AND for where the handle sits. The handle is placed at the midpoint of
+ * the *bendable* region (past the safe area), never inside the locked stub —
+ * so dragging always grabs a real, bendable slice instead of a detached sliver
+ * hugging the node.
+ *
+ * Availability is judged on the bendable region's ON-SCREEN length
+ * (bendable * zoom >= `minSegmentScreenLength`), so zooming in reveals handles
+ * on shorter segments and never hides them.
+ */
+export declare function getBendableSegments(points: IPoint[], _sourcePosition: Position, _targetPosition: Position, safeAreaPx: number, minSegmentScreenLength: number, zoom?: number): BendHandle[];
+export declare function applyInnerSegmentBend(points: IPoint[], segmentIndex: number, delta: IPoint, snapGrid: number): IPoint[];
+export declare function computeToolbarPosition(pathMiddlePosition: IPoint, isMiddlePathHorizontal: boolean): IPoint;
+export declare function applyTerminalSegmentBend(points: IPoint[], handle: BendHandle, delta: IPoint, sourcePosition: Position, targetPosition: Position, stubLength: number, snapGrid: number): IPoint[];

package/dist/{utils → react/utils}/index.d.ts

@@ -10,9 +10,9 @@ export * from './diagramTypeUtils';
 export * from './storeUtils';
 export * from './deepPartial';
 export * from './bpmnConstraints';
-export * from './versionConverter';
-export * from './labelUtils';
+export { importDiagram } from './versionConverter';
 export * from './alignmentUtils';
 export * from './requiredInterfaceUtils';
+export * from './collaboration';
 export { wrapTextInRect, layoutTextInEllipse, layoutTextInDiamond, maxLinesForHeight, } from './svgTextLayout';
 export type { WrappedText, ShapeLayout, SvgFontSpec, WhiteSpaceMode, } from './svgTextLayout';

package/dist/{utils → react/utils}/interactiveUtils.d.ts

@@ -3,5 +3,4 @@ type InteractivePruneNode = Pick<ApollonNode, "id"> & Partial<Pick<ApollonNode,
 export declare function getNestedNodeElementIds(nodes: InteractivePruneNode[]): Set<string>;
 export declare function pruneInteractiveElements(interactive: InteractiveElements | undefined, nodes: InteractivePruneNode[], edges: Array<Pick<ApollonEdge, "id">>): InteractiveElements | undefined;
 export declare function toggleInteractiveRecord(record: Record<string, boolean>, id: string): Record<string, boolean>;
-export declare function hasInteractiveSelections(interactive: InteractiveElements | undefined): boolean;
 export {};

package/dist/{utils → react/utils}/nodeUtils.d.ts

@@ -1,5 +1,5 @@
 import { XYPosition, Node } from '@xyflow/react';
-export declare const getPositionOnCanvas: (node: Node, allNodes: Node[]) => XYPosition;
+export declare const getPositionOnCanvas: (node: Node, allNodes: ReadonlyArray<Node>) => XYPosition;
 export declare const resizeAllParents: (node: Node, allNodes: Node[]) => Node[];
 export declare function sortNodesTopologically(nodes: Node[]): Node[];
 /**

package/dist/react/utils/storeUtils.d.ts

@@ -0,0 +1 @@
+export declare const deepEqual: (a: unknown, b: unknown) => boolean;

package/dist/react/utils/textUtils.d.ts

@@ -0,0 +1 @@
+export declare const measureTextWidth: (text: string, font?: string) => number;