orcasvn-react-diagrams 0.2.2 → 0.2.4

package/dist/esm/types/api/createDiagramEditor.d.ts

@@ -1,4 +1,4 @@
-import { DiagramEngineHandle, DiagramState, ElementShapeHoverControlActivationEvent, ElementShapeHoverControlInteractionEvent, ElementShapeHoverControls, EngineChangeEvent, EngineSelectionEvent } from './types';
+import { DiagramEngineHandle, Point, DiagramState, ElementShapeHoverControlActivationEvent, ElementShapeHoverControlInteractionEvent, ElementShapeHoverControls, EngineChangeEvent, EngineSelectionEvent } from './types';
 import { type BuiltInShapeKind } from '../shapes';
 export type SimpleShape = {
     id: string;
@@ -19,7 +19,25 @@ export type DiagramEditorConfig = {
     onChange?: (event: EngineChangeEvent) => void;
     onSelection?: (event: EngineSelectionEvent) => void;
 };
+export type DiagramImageExportOptions = {
+    mimeType?: string;
+    quality?: number;
+    pixelRatio?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    fitToContent?: boolean | {
+        padding?: number;
+    };
+};
 export type DiagramEditorHandle = DiagramEngineHandle & {
+    startLinkFromPort: (sourcePortId: string, pointer?: Point) => void;
+    updateLinkPreview: (pointer: Point) => void;
+    completeLinkToPort: (targetPortId: string) => void;
+    completeLinkToElement: (targetElementId: string, pointer: Point) => void;
+    cancelLink: () => void;
+    exportImage: (options?: DiagramImageExportOptions) => string;
     resize: (width: number, height: number) => void;
     setElementShapeHoverControls: (controls?: ElementShapeHoverControls) => void;
     destroy: () => void;

package/dist/esm/types/api/index.d.ts

@@ -1,4 +1,4 @@
 export * from './types';
 export { createDiagramEngine } from '../engine/DiagramEngine';
 export { createDiagramEditor } from './createDiagramEditor';
-export type { DiagramEditorConfig, DiagramEditorHandle, SimpleShape } from './createDiagramEditor';
+export type { DiagramEditorConfig, DiagramEditorHandle, DiagramImageExportOptions, SimpleShape, } from './createDiagramEditor';

package/dist/esm/types/api/types.d.ts

@@ -22,6 +22,7 @@ export type DiagramContainer = {
 export type MoveConstraint = 'free' | 'inside' | 'border';
 export type BorderSide = 'left' | 'right' | 'top' | 'bottom';
 export type HostAnchorPreset = 'vertices' | 'cardinal';
+export type PortLinkAttachMode = 'external' | 'internal';
 export type PortAnchor = {
     id: string;
     position: Point;
@@ -29,10 +30,32 @@ export type PortAnchor = {
     normal?: Point;
     meta?: Record<string, unknown>;
 };
+export type PortBorderTransformContext = {
+    side: BorderSide;
+    normal: Point;
+    hostRect: Rect;
+    attachMode: PortLinkAttachMode;
+    effectiveLinkAttachPoint: Point;
+    placementPoint: Point;
+    rotationPivot: Point;
+    portSize?: Size;
+};
+export type PortBorderTransformResult = {
+    rotation?: number;
+    offset?: Point;
+};
 export type PortAnchorConstraint = {
     preset: HostAnchorPreset;
     fallback?: 'nearest';
 };
+export type PositionAxisLimit = {
+    min?: number;
+    max?: number;
+};
+export type PortPositionLimits = {
+    x?: PositionAxisLimit;
+    y?: PositionAxisLimit;
+};
 export type ResolvePortAnchorsOptions = {
     preset: HostAnchorPreset;
 };
@@ -143,6 +166,7 @@ export type ElementShapeHoverControlActivationEvent = {
 export type ElementPortMovementPolicy = {
     moveMode: MoveConstraint | 'anchors';
     anchorConstraint?: PortAnchorConstraint;
+    positionLimits?: PortPositionLimits;
 };
 export type LinkRoutingMode = 'auto' | 'manual';
 export type AnchorReference = 'top-left' | 'center';
@@ -153,6 +177,15 @@ export type ElementLayoutMode = 'manual' | 'horizontal' | 'vertical';
 export type ElementLayoutAlign = 'start' | 'center' | 'end';
 export type ElementLayoutChildFitMainAxis = 'none' | 'distribute';
 export type ElementLayoutChildFitCrossAxis = 'none' | 'stretch';
+export type ElementLayoutLabelReservedSpaceMode = 'none' | 'fixed' | 'flexible';
+export type ElementLayoutLabelReservedSpacePlacement = 'top';
+export type ElementLayoutLabelReservedSpace = {
+    mode?: ElementLayoutLabelReservedSpaceMode;
+    placement?: ElementLayoutLabelReservedSpacePlacement;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+};
 export type TextLayoutBoundsMode = 'owner-width' | 'owner-box' | 'fixed';
 export type TextLayoutWrapMode = 'none' | 'word' | 'char';
 export type TextLayoutOverflowMode = 'clip' | 'ellipsis-end' | 'ellipsis-middle' | 'ellipsis-start';
@@ -168,6 +201,7 @@ export type ElementLayout = {
     childFitCrossAxis?: ElementLayoutChildFitCrossAxis;
     childFitMinSize?: Partial<Size>;
     childFitMaxSize?: Partial<Size>;
+    labelReservedSpace?: ElementLayoutLabelReservedSpace;
 };
 export type TextLayout = {
     boundsMode?: TextLayoutBoundsMode;
@@ -222,6 +256,11 @@ export type PortData = {
     moveMode?: MoveConstraint;
     anchorCenter?: boolean;
     orientToHostBorder?: boolean;
+    placementPoint?: Point;
+    linkAttachPoint?: Point;
+    externalLinkAttachPoint?: Point;
+    internalLinkAttachPoint?: Point;
+    rotationPivot?: Point;
     currentAnchorId?: string;
 };
 export type ShapeDrawContext = {
@@ -441,7 +480,9 @@ export type DiagramEngineHandle = {
         svgSize?: Size;
         projectToBorder?: (point: Point, rect: Rect) => Point;
         resolveBorderSide?: (point: Point, rect: Rect) => BorderSide;
+        resolveBorderNormal?: (point: Point, rect: Rect) => Point;
         resolvePortAnchors?: (rect: Rect, options: ResolvePortAnchorsOptions) => PortAnchor[];
+        resolvePortBorderTransform?: (context: PortBorderTransformContext) => PortBorderTransformResult | undefined;
         resolveHoverGeometry?: (rect: Rect) => ShapeHoverGeometry | undefined;
         resolveEllipseMidPoints?: (rect: Rect) => ShapeEllipseMidPointTarget[] | undefined;
     }) => void;

package/dist/esm/types/displaybox/DisplayBoxControls.d.ts

@@ -13,6 +13,10 @@ type ControlsProps = {
     onManualRender: () => void;
     onToggleLinkRouting: () => void;
     onAction: (action: DemoAction) => void;
+    onExportImage?: () => void;
+    onClearExportPreview?: () => void;
+    exportPreviewDataUrl?: string | null;
+    exportError?: string | null;
 };
-declare const DisplayBoxControls: ({ actions, snapEnabled, selectedLinkRouting, canToggleLinkRouting, onReload, onZoomIn, onZoomOut, onResetViewport, onToggleSnap, onManualRender, onToggleLinkRouting, onAction, }: ControlsProps) => React.JSX.Element;
+declare const DisplayBoxControls: ({ actions, snapEnabled, selectedLinkRouting, canToggleLinkRouting, onReload, onZoomIn, onZoomOut, onResetViewport, onToggleSnap, onManualRender, onToggleLinkRouting, onAction, onExportImage, onClearExportPreview, exportPreviewDataUrl, exportError, }: ControlsProps) => React.JSX.Element;
 export default DisplayBoxControls;

package/dist/esm/types/displaybox/demos/AsymmetricPortMultiAnchorDemoTab.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const AsymmetricPortMultiAnchorDemo: () => React.JSX.Element;
+export default AsymmetricPortMultiAnchorDemo;

package/dist/esm/types/displaybox/demos/LayoutLabelReservedSpaceDemoTab.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const LayoutLabelReservedSpaceDemo: () => React.JSX.Element;
+export default LayoutLabelReservedSpaceDemo;

package/dist/esm/types/displaybox/demos/VertexControlLinkSessionDemoTab.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const VertexControlLinkSessionDemo: () => React.JSX.Element;
+export default VertexControlLinkSessionDemo;

package/dist/esm/types/displaybox/demos/asymmetricPortMultiAnchorDemo.d.ts

@@ -0,0 +1,31 @@
+import type { DiagramState, Point } from '../../api';
+import type { DemoConfig } from '../types';
+export declare const asymmetricPortMultiAnchorDemoId = "asymmetric-port-multi-anchor";
+export declare const asymmetricPortDefaultVariantId = "classic";
+export type AsymmetricPortShapeVariant = {
+    id: string;
+    label: string;
+    description: string;
+    shapeId: string;
+    svgPath: string;
+    svgSize: {
+        width: number;
+        height: number;
+    };
+    placementPoint: Point;
+    externalLinkAttachPoint: Point;
+    internalLinkAttachPoint: Point;
+    rotationPivot: Point;
+};
+export declare const asymmetricPortShapeVariants: AsymmetricPortShapeVariant[];
+export declare const resolveAsymmetricPortShapeVariant: (variantId?: string) => AsymmetricPortShapeVariant;
+export declare const asymmetricPortMultiAnchorShapeId: string;
+export declare const asymmetricPortMultiAnchorShapeSvgPath: string;
+export declare const asymmetricPortMultiAnchorShapeSize: {
+    width: number;
+    height: number;
+};
+export declare const multiAnchorHostId = "multi-anchor-host";
+export declare const multiAnchorExternalPortId = "multi-anchor-port-external";
+export declare const createAsymmetricPortMultiAnchorState: (showLegacyComparison?: boolean, variantId?: string) => DiagramState;
+export declare const asymmetricPortMultiAnchorDemoConfig: DemoConfig;

package/dist/esm/types/displaybox/demos/labelStyleDemo.d.ts

@@ -0,0 +1,2 @@
+import type { DemoConfig } from '../types';
+export declare const labelStyleDemoConfig: DemoConfig;

package/dist/esm/types/displaybox/demos/layoutLabelReservedSpaceDemo.d.ts

@@ -0,0 +1,11 @@
+import type { DemoConfig } from '../types';
+export declare const layoutReservedDemoIds: {
+    readonly parent: "layout-lane-parent";
+    readonly childA: "layout-lane-child-a";
+    readonly childB: "layout-lane-child-b";
+    readonly nestedParent: "layout-lane-nested-parent";
+    readonly nestedChildA: "layout-lane-nested-child-a";
+    readonly nestedChildB: "layout-lane-nested-child-b";
+    readonly parentLabel: "layout-lane-parent-label";
+};
+export declare const layoutLabelReservedSpaceDemoConfig: DemoConfig;

package/dist/esm/types/displaybox/demos/portPositionLimitsDemo.d.ts

@@ -0,0 +1,2 @@
+import type { DemoConfig } from '../types';
+export declare const portPositionLimitsDemoConfig: DemoConfig;

package/dist/esm/types/displaybox/demos/vertexControlLinkSessionDemo.d.ts

@@ -0,0 +1,12 @@
+import type { DemoConfig } from '../types';
+export declare const vertexSessionDemoIds: {
+    readonly source: "vertex-session-source";
+    readonly portTarget: "vertex-session-port-target";
+    readonly elementTarget: "vertex-session-element-target";
+    readonly nativeSource: "vertex-session-native-source";
+    readonly nativeTarget: "vertex-session-native-target";
+    readonly existingTargetPort: "vertex-session-existing-target-port";
+    readonly nativeSourcePort: "vertex-session-native-source-port";
+    readonly nativeTargetPort: "vertex-session-native-target-port";
+};
+export declare const vertexControlLinkSessionDemoConfig: DemoConfig;

package/dist/esm/types/displaybox/useDemoControls.d.ts

@@ -13,6 +13,8 @@ type UseDemoControlsArgs = {
 declare const useDemoControls: ({ demo, editorRef, diagramState, selection, snapEnabled, setSnapEnabled, actionHelpers, }: UseDemoControlsArgs) => {
     selectedLinkRouting: import("../api").LinkRoutingMode;
     canToggleLinkRouting: boolean;
+    exportPreviewDataUrl: string | null;
+    exportError: string | null;
     handleAction: (action: DemoAction) => void;
     handleReload: () => void;
     handleZoomIn: () => void;
@@ -21,6 +23,8 @@ declare const useDemoControls: ({ demo, editorRef, diagramState, selection, snap
     handleToggleSnap: () => void;
     handleManualRender: () => void;
     handleToggleLinkRouting: () => void;
+    handleExportImage: () => void;
+    handleClearExportPreview: () => void;
     snapEnabled: boolean;
 };
 export default useDemoControls;

package/dist/esm/types/engine/AutoLayoutService.d.ts

@@ -19,6 +19,8 @@ export default class AutoLayoutService {
     applyLayoutCascade(startParentId: string | null): AutoLayoutResult;
     applyAllLayouts(): AutoLayoutResult;
     private resolveLayoutPadding;
+    private resolveLabelReservedTopLane;
+    private resolveFlexibleLabelLaneFromText;
     private clampLayoutSize;
     private distributeLayoutSizes;
 }

package/dist/esm/types/engine/DiagramEngine.d.ts

@@ -78,6 +78,10 @@ export default class DiagramEngine {
         height: number;
     };
     getPortWorldPosition(id: string): Point | null;
+    getPortLinkWorldPosition(id: string, options?: {
+        oppositePortId?: string;
+        attachMode?: 'external' | 'internal';
+    }): Point | null;
     getTextWorldPosition(id: string): Point | null;
     getPortElementId(portId: string): string | null;
     deleteSelection(): void;
@@ -111,22 +115,29 @@ export default class DiagramEngine {
     private collectResizedElementSizes;
     private resolveBorderPortResizeProjection;
     private resolveConstrainedPortRelativePosition;
+    private applyPortPositionLimits;
+    private resolveBorderPositionWithLimits;
+    private isPointWithinPositionLimits;
+    private filterAnchorsByPositionLimits;
     private resolveEffectivePortMoveMode;
     private resolvePortAnchorsForElement;
     private resolveNearestPortAnchor;
     private findNearestPortAnchor;
     private resolveAnchoredPortResizeProjection;
     private resolveTextPresentation;
+    private resolveAllTextPresentationPatches;
     private emitSelection;
     private applyLayoutForParent;
     private applyLayoutCascade;
     private applyAllLayouts;
+    private hasFlexibleLabelReservedSpace;
     private updateLinksForPorts;
     private collectElementPortIds;
     private computeAutoRoute;
     private constrainPortToHostBorder;
     private projectPointToHostBorder;
     private routeLinksWithEmptyPoints;
+    private normalizePortsForHostPolicies;
     private computeRemovalDiff;
     private emitEntityDeletionEvents;
 }

package/dist/esm/types/engine/LinkRoutingService.d.ts

@@ -1,4 +1,4 @@
-import { DiagramPatch, LinkData, Point } from '../api/types';
+import { DiagramPatch, LinkData, Point, PortLinkAttachMode } from '../api/types';
 import DiagramModel from '../models/DiagramModel';
 import { ShapeRegistry } from '../renderer/RenderTypes';
 import { RouterStrategy } from '../strategies/RouterStrategy';
@@ -18,8 +18,13 @@ export default class LinkRoutingService {
     setRouter(router: RouterStrategy): void;
     updateLinksForPorts(portIds: string[]): DiagramPatch[];
     routeLinksWithEmptyPoints(): DiagramPatch[];
+    getPortLinkWorldPosition(portId: string, options?: {
+        oppositePortId?: string;
+        attachMode?: PortLinkAttachMode;
+    }): Point | null;
     computeAutoRoute(link: LinkData, source: Point, target: Point): Point[];
     private resolveLinkPointsForUpdate;
+    private resolveLinkEndpoints;
     private updateManualRoute;
     private buildRouteContext;
     private resolveEndpointGeometry;
@@ -27,6 +32,9 @@ export default class LinkRoutingService {
     private resolveElementShape;
     private isPointOnProjectedBorder;
     private getElementRect;
+    private resolveHostForPort;
+    private resolveAttachModeForPorts;
+    private isAncestorOf;
     private getAncestorChain;
     private getAncestorExclusions;
     private resolveRouteBounds;

package/dist/esm/types/models/PortModel.d.ts

@@ -10,6 +10,11 @@ export default class PortModel {
     moveMode?: MoveConstraint;
     anchorCenter?: boolean;
     orientToHostBorder: boolean;
+    placementPoint?: Point;
+    linkAttachPoint?: Point;
+    externalLinkAttachPoint?: Point;
+    internalLinkAttachPoint?: Point;
+    rotationPivot?: Point;
     currentAnchorId?: string;
     constructor(data: PortData);
     setPosition(position: Point): void;

package/dist/esm/types/renderer/RenderTypes.d.ts

@@ -1,4 +1,4 @@
-import { ElementData, Point, PortAnchor, PortData, Rect, ResolvePortAnchorsOptions, ShapeEllipseMidPointTarget, ShapeDrawContext, ShapeHoverGeometry } from '../api/types';
+import { ElementData, Point, PortBorderTransformContext, PortBorderTransformResult, PortAnchor, PortData, Rect, ResolvePortAnchorsOptions, ShapeEllipseMidPointTarget, ShapeDrawContext, ShapeHoverGeometry } from '../api/types';
 import { BorderSide } from '../utils/borderGeometry';
 export type ShapeNodeSizeUpdateContext = {
     size: {
@@ -38,7 +38,9 @@ export type ShapeDefinition = {
     };
     projectToBorder?: (point: Point, rect: Rect) => Point;
     resolveBorderSide?: (point: Point, rect: Rect) => BorderSide;
+    resolveBorderNormal?: (point: Point, rect: Rect) => Point;
     resolvePortAnchors?: (rect: Rect, options: ResolvePortAnchorsOptions) => PortAnchor[];
+    resolvePortBorderTransform?: (context: PortBorderTransformContext) => PortBorderTransformResult | undefined;
     resolveHoverGeometry?: (rect: Rect) => ShapeHoverGeometry | undefined;
     resolveEllipseMidPoints?: (rect: Rect) => ShapeEllipseMidPointTarget[] | undefined;
 };

package/dist/esm/types/renderer/konva/KonvaInteraction.d.ts

@@ -56,6 +56,7 @@ export default class KonvaInteraction {
     private onShapeHoverControlInteracted?;
     private onShapeHoverControlActivated?;
     private linkDragContext;
+    private programmaticLinkSession;
     private bound;
     private handlers;
     private windowHandlers;
@@ -70,9 +71,16 @@ export default class KonvaInteraction {
     private textEditor;
     private readonly dragThreshold;
     private readonly panSpeed;
+    private readonly occupiedVertexTolerance;
+    private emittingElementLinkEnded;
     private panKey;
     constructor(engine: DiagramEngine, config?: InteractionConfig);
     setShapeHoverControls(controls?: ElementShapeHoverControls): void;
+    startLinkFromPort(sourcePortId: string, pointer?: Point): void;
+    updateLinkPreview(pointer: Point): void;
+    completeLinkToPort(targetPortId: string): void;
+    completeLinkToElement(targetElementId: string, pointer: Point): void;
+    cancelLink(): void;
     private buildPointerInfo;
     bind(stage?: KonvaStageLike): void;
     dispose(): void;
@@ -102,6 +110,7 @@ export default class KonvaInteraction {
     private resolveTargetHoverCandidate;
     private resolveElementHoverCandidate;
     private resolveEligibleTargetIndices;
+    private resolveOccupiedVertexIndices;
     private resolveEligibleEllipseMidPoints;
     private resolveRotatedHoverGeometry;
     private resolveRotatedEllipseMidPoints;
@@ -122,7 +131,12 @@ export default class KonvaInteraction {
     private projectPointOnSegment;
     private applyMarqueeSelection;
     private applyPortConstraints;
+    private resolveLinkPreviewSource;
+    private resolveActiveLinkSession;
+    private finishLinkDragSession;
+    private emitElementLinkEndedSafely;
     private tryCreateLinkToPort;
+    private tryCreateLinkToElement;
     private createPortForLink;
     private createPlaceholderPort;
     private getElementById;

package/dist/esm/types/renderer/konva/KonvaNodeFactory.d.ts

@@ -36,6 +36,17 @@ export default class KonvaNodeFactory {
     createPortNode(model: PortData): KonvaNodeLike;
     createLinkNode(model: LinkData): KonvaNodeLike;
     createTextNode(model: TextData): KonvaNodeLike;
+    createTextBackgroundNode(config: {
+        id: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        stroke?: string;
+        strokeWidth?: number;
+        cornerRadius?: number | [number, number, number, number];
+    }): KonvaNodeLike;
     createHandleNode(config: {
         id: string;
         x: number;
@@ -79,5 +90,6 @@ export default class KonvaNodeFactory {
     }): KonvaNodeLike;
     private createDrawNode;
     private createSvgPathNode;
+    private resolveShapeRotation;
     private applyShapeBehaviorAttrs;
 }

package/dist/esm/types/renderer/konva/KonvaRenderer.d.ts

@@ -61,6 +61,7 @@ export default class KonvaRenderer implements Renderer {
     private portNodes;
     private linkNodes;
     private textNodes;
+    private textBackgroundNodes;
     private selectedIds;
     private overlayLayer;
     private tempLinkNode;
@@ -118,9 +119,9 @@ export default class KonvaRenderer implements Renderer {
     private syncPorts;
     private syncLinks;
     private syncTexts;
+    private resolveTextBackgroundMeta;
     private updatePosition;
     private applyPortOrientation;
-    private resolvePortBorderRotation;
     private resolveHostElement;
     private getNodeAttr;
     private updateSize;

package/dist/esm/types/shapes/BuiltInShapes.d.ts

@@ -1,4 +1,4 @@
-import { Point, PortAnchor, Rect, ResolvePortAnchorsOptions, ShapeEllipseMidPointTarget, ShapeHoverGeometry } from '../api/types';
+import { Point, PortBorderTransformContext, PortBorderTransformResult, PortAnchor, Rect, ResolvePortAnchorsOptions, ShapeEllipseMidPointTarget, ShapeHoverGeometry } from '../api/types';
 import { ShapeNodeSizeUpdater, ShapeResizeNormalizeContext } from '../renderer/RenderTypes';
 import { BorderSide } from '../utils/borderGeometry';
 export type BuiltInShapeKind = 'rect' | 'circle' | 'ellipse' | 'diamond' | 'triangle' | 'pentagon' | 'hexagon';
@@ -46,7 +46,9 @@ export declare abstract class BuiltInShape {
     abstract createNode(context: ShapeCreateContext): unknown;
     projectToBorder(point: Point, rect: Rect): Point;
     resolveBorderSide(point: Point, rect: Rect): BorderSide;
+    resolveBorderNormal(point: Point, rect: Rect): Point;
     resolvePortAnchors(_rect: Rect, _options: ResolvePortAnchorsOptions): PortAnchor[];
+    resolvePortBorderTransform(_context: PortBorderTransformContext): PortBorderTransformResult | undefined;
     resolveHoverGeometry(_rect: Rect): ShapeHoverGeometry | undefined;
     resolveEllipseMidPoints(_rect: Rect): ShapeEllipseMidPointTarget[] | undefined;
     protected resolveShapeName(isPort: boolean): string;

package/dist/esm/types/strategies/ObstacleRouter.d.ts

@@ -16,6 +16,8 @@ export default class ObstacleRouter implements RouterStrategy {
     private pointsWithinBounds;
     private isPathClear;
     private computeStubEndpoint;
+    private computeAvailableStubLength;
+    private rectsEqual;
     private getNormal;
     private distanceToBounds;
     private distanceToObstacles;

package/dist/esm/types/utils/__tests__/portGeometry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/utils/portGeometry.d.ts

@@ -0,0 +1,44 @@
+import { BorderSide, Point, PortData, PortLinkAttachMode } from '../api/types';
+import { ShapeRegistry } from '../renderer/RenderTypes';
+type HostElementLike = {
+    id: string;
+    position: Point;
+    size: {
+        width: number;
+        height: number;
+    };
+    shapeId: string;
+};
+export type PortGeometryPoints = {
+    placementPoint: Point;
+    sharedLinkAttachPoint: Point;
+    effectiveLinkAttachPoint: Point;
+    rotationPivot: Point;
+};
+export type PortOrientationContext = {
+    localRotation: number;
+    rotation: number;
+    offset: Point;
+    nodeAnchorPoint: Point;
+    side?: BorderSide;
+    normal?: Point;
+};
+export declare const borderSideToNormal: (side: BorderSide) => Point;
+export declare const resolvePortGeometryPoints: (port: Pick<PortData, 'placementPoint' | 'linkAttachPoint' | 'externalLinkAttachPoint' | 'internalLinkAttachPoint' | 'rotationPivot'>, attachMode: PortLinkAttachMode) => PortGeometryPoints;
+export declare const resolvePortOrientationContext: (options: {
+    port: Pick<PortData, 'shapeId' | 'style' | 'moveMode' | 'orientToHostBorder' | 'anchorCenter' | 'placementPoint' | 'linkAttachPoint' | 'externalLinkAttachPoint' | 'internalLinkAttachPoint' | 'rotationPivot' | 'size'>;
+    worldPlacement: Point;
+    host: HostElementLike | null;
+    shapeRegistry: ShapeRegistry;
+    attachMode: PortLinkAttachMode;
+}) => PortOrientationContext;
+export declare const resolvePortWorldTransform: (options: {
+    port: Pick<PortData, 'placementPoint' | 'linkAttachPoint' | 'externalLinkAttachPoint' | 'internalLinkAttachPoint' | 'rotationPivot'>;
+    worldPlacement: Point;
+    attachMode: PortLinkAttachMode;
+    orientation: Pick<PortOrientationContext, 'localRotation' | 'rotation' | 'offset' | 'nodeAnchorPoint'>;
+}) => {
+    nodePosition: Point;
+    linkAttachWorld: Point;
+};
+export {};

package/dist/examples.d.ts

@@ -24,6 +24,7 @@ type DiagramContainer = {
 type MoveConstraint = 'free' | 'inside' | 'border';
 type BorderSide = 'left' | 'right' | 'top' | 'bottom';
 type HostAnchorPreset = 'vertices' | 'cardinal';
+type PortLinkAttachMode = 'external' | 'internal';
 type PortAnchor = {
     id: string;
     position: Point;
@@ -31,10 +32,32 @@ type PortAnchor = {
     normal?: Point;
     meta?: Record<string, unknown>;
 };
+type PortBorderTransformContext = {
+    side: BorderSide;
+    normal: Point;
+    hostRect: Rect;
+    attachMode: PortLinkAttachMode;
+    effectiveLinkAttachPoint: Point;
+    placementPoint: Point;
+    rotationPivot: Point;
+    portSize?: Size;
+};
+type PortBorderTransformResult = {
+    rotation?: number;
+    offset?: Point;
+};
 type PortAnchorConstraint = {
     preset: HostAnchorPreset;
     fallback?: 'nearest';
 };
+type PositionAxisLimit = {
+    min?: number;
+    max?: number;
+};
+type PortPositionLimits = {
+    x?: PositionAxisLimit;
+    y?: PositionAxisLimit;
+};
 type ResolvePortAnchorsOptions = {
     preset: HostAnchorPreset;
 };
@@ -116,6 +139,7 @@ type ElementShapeHoverControls = {
 type ElementPortMovementPolicy = {
     moveMode: MoveConstraint | 'anchors';
     anchorConstraint?: PortAnchorConstraint;
+    positionLimits?: PortPositionLimits;
 };
 type LinkRoutingMode = 'auto' | 'manual';
 type AnchorReference = 'top-left' | 'center';
@@ -126,6 +150,15 @@ type ElementLayoutMode = 'manual' | 'horizontal' | 'vertical';
 type ElementLayoutAlign = 'start' | 'center' | 'end';
 type ElementLayoutChildFitMainAxis = 'none' | 'distribute';
 type ElementLayoutChildFitCrossAxis = 'none' | 'stretch';
+type ElementLayoutLabelReservedSpaceMode = 'none' | 'fixed' | 'flexible';
+type ElementLayoutLabelReservedSpacePlacement = 'top';
+type ElementLayoutLabelReservedSpace = {
+    mode?: ElementLayoutLabelReservedSpaceMode;
+    placement?: ElementLayoutLabelReservedSpacePlacement;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+};
 type TextLayoutBoundsMode = 'owner-width' | 'owner-box' | 'fixed';
 type TextLayoutWrapMode = 'none' | 'word' | 'char';
 type TextLayoutOverflowMode = 'clip' | 'ellipsis-end' | 'ellipsis-middle' | 'ellipsis-start';
@@ -141,6 +174,7 @@ type ElementLayout = {
     childFitCrossAxis?: ElementLayoutChildFitCrossAxis;
     childFitMinSize?: Partial<Size>;
     childFitMaxSize?: Partial<Size>;
+    labelReservedSpace?: ElementLayoutLabelReservedSpace;
 };
 type TextLayout = {
     boundsMode?: TextLayoutBoundsMode;
@@ -195,6 +229,11 @@ type PortData = {
     moveMode?: MoveConstraint;
     anchorCenter?: boolean;
     orientToHostBorder?: boolean;
+    placementPoint?: Point;
+    linkAttachPoint?: Point;
+    externalLinkAttachPoint?: Point;
+    internalLinkAttachPoint?: Point;
+    rotationPivot?: Point;
     currentAnchorId?: string;
 };
 type ShapeDrawContext = {
@@ -414,7 +453,9 @@ type DiagramEngineHandle = {
         svgSize?: Size;
         projectToBorder?: (point: Point, rect: Rect) => Point;
         resolveBorderSide?: (point: Point, rect: Rect) => BorderSide;
+        resolveBorderNormal?: (point: Point, rect: Rect) => Point;
         resolvePortAnchors?: (rect: Rect, options: ResolvePortAnchorsOptions) => PortAnchor[];
+        resolvePortBorderTransform?: (context: PortBorderTransformContext) => PortBorderTransformResult | undefined;
         resolveHoverGeometry?: (rect: Rect) => ShapeHoverGeometry | undefined;
         resolveEllipseMidPoints?: (rect: Rect) => ShapeEllipseMidPointTarget[] | undefined;
     }) => void;
@@ -450,7 +491,25 @@ type SimpleShape = {
     kind: BuiltInShapeKind;
     style?: Record<string, unknown>;
 };
+type DiagramImageExportOptions = {
+    mimeType?: string;
+    quality?: number;
+    pixelRatio?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    fitToContent?: boolean | {
+        padding?: number;
+    };
+};
 type DiagramEditorHandle = DiagramEngineHandle & {
+    startLinkFromPort: (sourcePortId: string, pointer?: Point) => void;
+    updateLinkPreview: (pointer: Point) => void;
+    completeLinkToPort: (targetPortId: string) => void;
+    completeLinkToElement: (targetElementId: string, pointer: Point) => void;
+    cancelLink: () => void;
+    exportImage: (options?: DiagramImageExportOptions) => string;
     resize: (width: number, height: number) => void;
     setElementShapeHoverControls: (controls?: ElementShapeHoverControls) => void;
     destroy: () => void;