orcasvn-react-diagrams 0.2.0 → 0.2.2

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

@@ -1,7 +1,8 @@
-import { DiagramEngineHandle, DiagramState, EngineChangeEvent, EngineSelectionEvent } from './types';
+import { DiagramEngineHandle, DiagramState, ElementShapeHoverControlActivationEvent, ElementShapeHoverControlInteractionEvent, ElementShapeHoverControls, EngineChangeEvent, EngineSelectionEvent } from './types';
+import { type BuiltInShapeKind } from '../shapes';
 export type SimpleShape = {
     id: string;
-    kind: 'rect' | 'circle' | 'diamond' | 'triangle';
+    kind: BuiltInShapeKind;
     style?: Record<string, unknown>;
 };
 export type DiagramEditorConfig = {
@@ -12,11 +13,15 @@ export type DiagramEditorConfig = {
     elementShapes?: SimpleShape[];
     portShapes?: SimpleShape[];
     panKey?: 'Control' | 'Shift' | 'Alt' | 'Meta';
+    elementShapeHoverControls?: ElementShapeHoverControls;
+    onElementShapeHoverControlInteraction?: (event: ElementShapeHoverControlInteractionEvent) => void;
+    onElementShapeHoverControlActivated?: (event: ElementShapeHoverControlActivationEvent) => void;
     onChange?: (event: EngineChangeEvent) => void;
     onSelection?: (event: EngineSelectionEvent) => void;
 };
 export type DiagramEditorHandle = DiagramEngineHandle & {
     resize: (width: number, height: number) => void;
+    setElementShapeHoverControls: (controls?: ElementShapeHoverControls) => void;
     destroy: () => void;
 };
 export declare const createDiagramEditor: (config: DiagramEditorConfig) => DiagramEditorHandle;

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

@@ -20,6 +20,130 @@ export type DiagramContainer = {
     getBoundingClientRect: () => ClientRectLike;
 };
 export type MoveConstraint = 'free' | 'inside' | 'border';
+export type BorderSide = 'left' | 'right' | 'top' | 'bottom';
+export type HostAnchorPreset = 'vertices' | 'cardinal';
+export type PortAnchor = {
+    id: string;
+    position: Point;
+    side?: BorderSide;
+    normal?: Point;
+    meta?: Record<string, unknown>;
+};
+export type PortAnchorConstraint = {
+    preset: HostAnchorPreset;
+    fallback?: 'nearest';
+};
+export type ResolvePortAnchorsOptions = {
+    preset: HostAnchorPreset;
+};
+export type ShapeVertexTarget = {
+    id: string;
+    position: Point;
+};
+export type ShapeEdgeTarget = {
+    id: string;
+    start: Point;
+    end: Point;
+    midpoint: Point;
+};
+export declare enum EllipseMidPoint {
+    top = "top",
+    right = "right",
+    bottom = "bottom",
+    left = "left"
+}
+export type ShapeEllipseMidPointTarget = {
+    id: EllipseMidPoint;
+    ellipseMidPoint: EllipseMidPoint;
+    position: Point;
+};
+export type ShapeHoverGeometry = {
+    vertices: ShapeVertexTarget[];
+    edges: ShapeEdgeTarget[];
+};
+export type HoverControlIcon = {
+    svgPath: string;
+    size?: Size;
+    style?: Record<string, unknown>;
+};
+export type ShapeControlTargetKind = 'vertex' | 'edge' | 'midpoint' | 'ellipse-midpoint';
+export type ShapeControlVisibilityTrigger = 'element-hover' | 'target-hover';
+export type ShapeControlDefinition = {
+    id: string;
+    targetKind: ShapeControlTargetKind;
+    icon: HoverControlIcon;
+    targetIndices?: number[];
+    ellipseMidPoints?: EllipseMidPoint | EllipseMidPoint[];
+    allowAllTargets?: boolean;
+    visibilityTriggers?: ShapeControlVisibilityTrigger[];
+    lineStyle?: Record<string, unknown>;
+    tolerance?: number;
+};
+/**
+ * @deprecated Use ShapeControlDefinition with targetKind='edge'.
+ */
+export type EdgeHoverControl = {
+    kind: 'edge';
+    icon: HoverControlIcon;
+    lineStyle?: Record<string, unknown>;
+    tolerance?: number;
+};
+/**
+ * @deprecated Use ShapeControlDefinition with targetKind='vertex'.
+ */
+export type VertexHoverControl = {
+    kind: 'vertex';
+    icon: HoverControlIcon;
+    tolerance?: number;
+};
+export type ElementShapeHoverControls = {
+    controls?: ShapeControlDefinition[];
+    /**
+     * @deprecated Legacy singleton edge control. Use controls[] instead.
+     */
+    edge?: EdgeHoverControl;
+    /**
+     * @deprecated Legacy singleton vertex control. Use controls[] instead.
+     */
+    vertex?: VertexHoverControl;
+    /**
+     * @deprecated Legacy resolution preference for singleton edge/vertex controls.
+     */
+    priority?: 'vertex-first';
+};
+export type ElementShapeControlEventType = 'click' | 'drag-start' | 'drag-move' | 'drag-end';
+export type ElementShapeControlDragEvent = {
+    sessionId: string;
+    startPointer: EnginePointerInfo;
+    delta: Point;
+};
+export type ElementShapeHoverControlInteractionEvent = {
+    eventType: ElementShapeControlEventType;
+    controlId: string;
+    elementId: string;
+    targetKind: ShapeControlTargetKind;
+    targetIndex: number;
+    pointer: EnginePointerInfo;
+    edge?: ShapeEdgeTarget;
+    vertex?: ShapeVertexTarget;
+    ellipseMidPoint?: EllipseMidPoint;
+    drag?: ElementShapeControlDragEvent;
+};
+/**
+ * @deprecated Use ElementShapeHoverControlInteractionEvent with eventType='click'.
+ */
+export type ElementShapeHoverControlActivationEvent = {
+    controlKind: 'edge' | 'vertex';
+    elementId: string;
+    targetId: string;
+    pointer: EnginePointerInfo;
+    edge?: ShapeEdgeTarget;
+    vertex?: ShapeVertexTarget;
+};
+export type ElementPortMovementPolicy = {
+    moveMode: MoveConstraint | 'anchors';
+    anchorConstraint?: PortAnchorConstraint;
+};
 export type LinkRoutingMode = 'auto' | 'manual';
 export type AnchorReference = 'top-left' | 'center';
 export type RerouteLinksOptions = {
@@ -27,6 +151,11 @@ export type RerouteLinksOptions = {
 };
 export type ElementLayoutMode = 'manual' | 'horizontal' | 'vertical';
 export type ElementLayoutAlign = 'start' | 'center' | 'end';
+export type ElementLayoutChildFitMainAxis = 'none' | 'distribute';
+export type ElementLayoutChildFitCrossAxis = 'none' | 'stretch';
+export type TextLayoutBoundsMode = 'owner-width' | 'owner-box' | 'fixed';
+export type TextLayoutWrapMode = 'none' | 'word' | 'char';
+export type TextLayoutOverflowMode = 'clip' | 'ellipsis-end' | 'ellipsis-middle' | 'ellipsis-start';
 export type ElementLayout = {
     mode: ElementLayoutMode;
     padding?: number | {
@@ -35,6 +164,18 @@ export type ElementLayout = {
     };
     gap?: number;
     align?: ElementLayoutAlign;
+    childFitMainAxis?: ElementLayoutChildFitMainAxis;
+    childFitCrossAxis?: ElementLayoutChildFitCrossAxis;
+    childFitMinSize?: Partial<Size>;
+    childFitMaxSize?: Partial<Size>;
+};
+export type TextLayout = {
+    boundsMode?: TextLayoutBoundsMode;
+    wrap?: TextLayoutWrapMode;
+    overflow?: TextLayoutOverflowMode;
+    padding?: number;
+    maxLines?: number;
+    fixedSize?: Size;
 };
 export type ElementDropEvent = {
     elementId: string;
@@ -68,6 +209,7 @@ export type ElementData = {
     moveMode?: MoveConstraint;
     anchorCenter?: boolean;
     layout?: ElementLayout;
+    portMovement?: ElementPortMovementPolicy;
 };
 export type PortData = {
     id: string;
@@ -79,6 +221,8 @@ export type PortData = {
     textIds?: string[];
     moveMode?: MoveConstraint;
     anchorCenter?: boolean;
+    orientToHostBorder?: boolean;
+    currentAnchorId?: string;
 };
 export type ShapeDrawContext = {
     ctx: CanvasRenderingContext2D;
@@ -100,6 +244,10 @@ export type TextData = {
     size?: Size;
     style?: Record<string, unknown>;
     ownerId?: string | null;
+    layout?: TextLayout;
+    displayContent?: string;
+    displayOffset?: Point;
+    displayClipSize?: Size;
 };
 export type DiagramState = {
     elements: ElementData[];
@@ -172,6 +320,26 @@ export type ElementResizedEvent = {
 export type ElementDeletedEvent = {
     elementId: string;
 };
+export type PortDeletedEvent = {
+    portId: string;
+    elementId: string;
+};
+export type LinkDeletedEvent = {
+    linkId: string;
+    sourcePortId: string;
+    targetPortId: string;
+};
+export type TextDeletedEvent = {
+    textId: string;
+    ownerId?: string | null;
+};
+export type TextUpdatedEvent = {
+    textId: string;
+    ownerId?: string | null;
+    content: string;
+    displayContent: string;
+    reason: 'content' | 'layout';
+};
 export type ElementLinkStartedEvent = {
     sourcePortId: string;
     sourceElementId: string;
@@ -218,6 +386,10 @@ export type EngineEventMap = {
     elementMoved: ElementMovedEvent;
     elementResized: ElementResizedEvent;
     elementDeleted: ElementDeletedEvent;
+    portDeleted: PortDeletedEvent;
+    linkDeleted: LinkDeletedEvent;
+    textDeleted: TextDeletedEvent;
+    textUpdated: TextUpdatedEvent;
     elementSelected: ElementSelectedEvent;
     elementLinkStarted: ElementLinkStartedEvent;
     elementLinkConnecting: ElementLinkConnectingEvent;
@@ -262,10 +434,16 @@ export type DiagramEngineHandle = {
     setSnapping: (snapper: unknown) => void;
     registerShape: (shape: {
         id: string;
+        baseRotation?: number;
         draw?: (context: ShapeDrawContext) => void;
         createNode?: (model: ElementData | PortData) => unknown;
         svgPath?: string;
         svgSize?: Size;
+        projectToBorder?: (point: Point, rect: Rect) => Point;
+        resolveBorderSide?: (point: Point, rect: Rect) => BorderSide;
+        resolvePortAnchors?: (rect: Rect, options: ResolvePortAnchorsOptions) => PortAnchor[];
+        resolveHoverGeometry?: (rect: Rect) => ShapeHoverGeometry | undefined;
+        resolveEllipseMidPoints?: (rect: Rect) => ShapeEllipseMidPointTarget[] | undefined;
     }) => void;
     render: () => void;
 };

package/dist/cjs/types/displaybox/demos/DeletionEventsDemoTab.d.ts

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

package/dist/cjs/types/displaybox/demos/ShapeHoverControlsDemoTab.d.ts

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

package/dist/cjs/types/displaybox/demos/TextLayoutDemoTab.d.ts

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

package/dist/cjs/types/displaybox/demos/deletionEventsDemo.d.ts

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

package/dist/cjs/types/displaybox/demos/rotatedCreationDemo.d.ts

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

package/dist/cjs/types/displaybox/demos/roundedRectRadiusDemo.d.ts

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

package/dist/cjs/types/displaybox/demos/shapeBorderMovementDemo.d.ts

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

package/dist/cjs/types/displaybox/demos/shapeHoverControlsDemo.d.ts

@@ -0,0 +1,10 @@
+import type { DemoConfig } from '../types';
+export declare const shapeHoverDemoIds: {
+    readonly drawer: "hover-drawer";
+    readonly diamond: "hover-diamond";
+    readonly target: "hover-target-rect";
+    readonly ellipse: "hover-ellipse-host";
+    readonly circle: "hover-circle-host";
+    readonly noopRect: "hover-noop-rect";
+};
+export declare const shapeHoverControlsDemoConfig: DemoConfig;

package/dist/cjs/types/displaybox/demos/textDemo.d.ts

@@ -1,2 +1,6 @@
 import type { DemoConfig } from '../types';
+export declare const textDemoOwnerId = "text-layout-owner";
+export declare const textDemoOwnedTextId = "text-owned-overflow";
+export declare const textDemoFloatingTextId = "text-floating-overflow";
+export declare const textDemoLongSample = "Long diagram label: middle ellipsis should keep the beginning and end visible while preserving the full canonical content in model state.";
 export declare const textDemoConfig: DemoConfig;

package/dist/cjs/types/displaybox/useDemoEditor.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import type { DiagramEditorHandle, DiagramState, SimpleShape } from '../api';
+import type { DiagramEditorHandle, DiagramState, ElementShapeHoverControlActivationEvent, ElementShapeHoverControlInteractionEvent, ElementShapeHoverControls, SimpleShape } from '../api';
 import type { RouterStrategy } from '../strategies/RouterStrategy';
 import type { ViewportSnapshot } from './types';
 type DemoEditorConfig = {
@@ -8,8 +8,11 @@ type DemoEditorConfig = {
     portShapes?: SimpleShape[];
     router?: RouterStrategy;
     snapDefault?: boolean;
+    elementShapeHoverControls?: ElementShapeHoverControls;
+    onElementShapeHoverControlInteraction?: (event: ElementShapeHoverControlInteractionEvent) => void;
+    onElementShapeHoverControlActivated?: (event: ElementShapeHoverControlActivationEvent) => void;
 };
-declare const useDemoEditor: ({ createState, elementShapes, portShapes, router, snapDefault }: DemoEditorConfig) => {
+declare const useDemoEditor: ({ createState, elementShapes, portShapes, router, snapDefault, elementShapeHoverControls, onElementShapeHoverControlInteraction, onElementShapeHoverControlActivated, }: DemoEditorConfig) => {
     containerRef: import("react").MutableRefObject<HTMLDivElement | null>;
     editorRef: import("react").MutableRefObject<DiagramEditorHandle | null>;
     diagramState: DiagramState | null;

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

@@ -0,0 +1,24 @@
+import { DiagramPatch } from '../api/types';
+import DiagramModel from '../models/DiagramModel';
+import CommandQueue from './CommandQueue';
+export type AutoLayoutResult = {
+    patches: DiagramPatch[];
+    movedPortIds: string[];
+};
+export type AutoLayoutServiceConfig = {
+    model: DiagramModel;
+    commandQueue: CommandQueue;
+    collectElementPortIds: (elementId: string) => string[];
+};
+export default class AutoLayoutService {
+    private model;
+    private commandQueue;
+    private collectElementPortIds;
+    constructor(config: AutoLayoutServiceConfig);
+    applyLayoutForParent(parentId: string): AutoLayoutResult;
+    applyLayoutCascade(startParentId: string | null): AutoLayoutResult;
+    applyAllLayouts(): AutoLayoutResult;
+    private resolveLayoutPadding;
+    private clampLayoutSize;
+    private distributeLayoutSizes;
+}

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

@@ -3,7 +3,7 @@ import { Renderer } from '../renderer/Renderer';
 import RenderScheduler from '../renderer/RenderScheduler';
 import { RouterStrategy } from '../strategies/RouterStrategy';
 import { SnapStrategy } from '../strategies/SnapStrategy';
-import { ShapeDefinition, ShapeRegistry } from '../renderer/RenderTypes';
+import { ShapeDefinition, ShapeRegistry, ShapeResizeHandle } from '../renderer/RenderTypes';
 import { TextMeasurer } from '../measure/TextMeasurer';
 export type DiagramEngineConfig = {
     renderer: Renderer;
@@ -21,10 +21,12 @@ export default class DiagramEngine {
     private viewport;
     private renderer;
     private scheduler;
-    private router;
     private snapper;
     private shapeRegistry;
-    private textMeasurer;
+    private textLayoutService;
+    private autoLayoutService;
+    private linkRoutingService;
+    private mutationPipeline;
     constructor(config: DiagramEngineConfig);
     static create(config: DiagramEngineConfig): DiagramEngine;
     load(state: DiagramState): void;
@@ -63,6 +65,18 @@ export default class DiagramEngine {
     toggleSelection(id: string): void;
     getSelection(): string[];
     getElementWorldPosition(id: string): Point | null;
+    getElementRotation(id: string): number;
+    normalizeElementResize(id: string, proposal: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, handle: ShapeResizeHandle, minSize?: number): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
     getPortWorldPosition(id: string): Point | null;
     getTextWorldPosition(id: string): Point | null;
     getPortElementId(portId: string): string | null;
@@ -92,24 +106,28 @@ export default class DiagramEngine {
         cancelled: boolean;
     }): void;
     private emitChange;
+    private appendTextLayoutPatches;
+    private reprojectBorderPortsForResizedElements;
+    private collectResizedElementSizes;
+    private resolveBorderPortResizeProjection;
+    private resolveConstrainedPortRelativePosition;
+    private resolveEffectivePortMoveMode;
+    private resolvePortAnchorsForElement;
+    private resolveNearestPortAnchor;
+    private findNearestPortAnchor;
+    private resolveAnchoredPortResizeProjection;
+    private resolveTextPresentation;
     private emitSelection;
-    private resolveLayoutPadding;
     private applyLayoutForParent;
     private applyLayoutCascade;
     private applyAllLayouts;
     private updateLinksForPorts;
     private collectElementPortIds;
-    private resolveLinkPointsForUpdate;
-    private updateManualRoute;
     private computeAutoRoute;
-    private buildRouteContext;
-    private getElementRect;
-    private getAncestorChain;
-    private getAncestorExclusions;
-    private resolveRouteBounds;
-    private isPointOnRectEdge;
-    private resolveEdgeSide;
+    private constrainPortToHostBorder;
+    private projectPointToHostBorder;
     private routeLinksWithEmptyPoints;
-    private computeRemovalPatches;
+    private computeRemovalDiff;
+    private emitEntityDeletionEvents;
 }
 export declare const createDiagramEngine: (config: DiagramEngineConfig) => DiagramEngineHandle;

package/dist/cjs/types/engine/EngineCommands.d.ts

@@ -14,7 +14,10 @@ export declare const createResizeElementCommand: (id: string, size: {
 export declare const createRemoveElementCommand: (id: string) => EngineCommand;
 export declare const createSetElementLayoutCommand: (id: string, layout: ElementData['layout']) => EngineCommand;
 export declare const createAddPortCommand: (port: PortData) => EngineCommand;
-export declare const createMovePortCommand: (id: string, position: Point) => EngineCommand;
+export declare const createMovePortCommand: (id: string, update: {
+    position: Point;
+    currentAnchorId?: string | null;
+}) => EngineCommand;
 export declare const createRemovePortCommand: (id: string) => EngineCommand;
 export declare const createAddLinkCommand: (link: LinkData) => EngineCommand;
 export declare const createUpdateLinkCommand: (id: string, update: {

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

@@ -0,0 +1,35 @@
+import { DiagramPatch, LinkData, Point } from '../api/types';
+import DiagramModel from '../models/DiagramModel';
+import { ShapeRegistry } from '../renderer/RenderTypes';
+import { RouterStrategy } from '../strategies/RouterStrategy';
+import CommandQueue from './CommandQueue';
+export type LinkRoutingServiceConfig = {
+    model: DiagramModel;
+    commandQueue: CommandQueue;
+    router: RouterStrategy;
+    shapeRegistry: ShapeRegistry;
+};
+export default class LinkRoutingService {
+    private model;
+    private commandQueue;
+    private router;
+    private shapeRegistry;
+    constructor(config: LinkRoutingServiceConfig);
+    setRouter(router: RouterStrategy): void;
+    updateLinksForPorts(portIds: string[]): DiagramPatch[];
+    routeLinksWithEmptyPoints(): DiagramPatch[];
+    computeAutoRoute(link: LinkData, source: Point, target: Point): Point[];
+    private resolveLinkPointsForUpdate;
+    private updateManualRoute;
+    private buildRouteContext;
+    private resolveEndpointGeometry;
+    private resolveCornerTieBreakSide;
+    private resolveElementShape;
+    private isPointOnProjectedBorder;
+    private getElementRect;
+    private getAncestorChain;
+    private getAncestorExclusions;
+    private resolveRouteBounds;
+    private isPointOnRectEdge;
+    private resolveEdgeSide;
+}

package/dist/cjs/types/engine/MutationPipeline.d.ts

@@ -0,0 +1,23 @@
+import { DiagramPatch } from '../api/types';
+import { AutoLayoutResult } from './AutoLayoutService';
+export type MutationPipelineConfig = {
+    routeLinksWithEmptyPoints: () => DiagramPatch[];
+    reprojectBorderPortsForResizedElements: (patches: DiagramPatch[]) => {
+        patches: DiagramPatch[];
+        movedPortIds: string[];
+    };
+    updateLinksForPorts: (portIds: string[]) => DiagramPatch[];
+};
+export type MutationPipelineRunOptions = {
+    basePatches: DiagramPatch[];
+    layoutSteps?: Array<() => AutoLayoutResult>;
+    movedPortIds?: string[];
+    includeEmptyLinkRouting?: boolean;
+};
+export default class MutationPipeline {
+    private routeLinksWithEmptyPoints;
+    private reprojectBorderPortsForResizedElements;
+    private updateLinksForPorts;
+    constructor(config: MutationPipelineConfig);
+    run(options: MutationPipelineRunOptions): DiagramPatch[];
+}

package/dist/cjs/types/engine/TextLayoutService.d.ts

@@ -0,0 +1,40 @@
+import { DiagramPatch, EngineEventMap, Point, TextData } from '../api/types';
+import { TextMeasurer } from '../measure/TextMeasurer';
+import DiagramModel from '../models/DiagramModel';
+export type ResolvedTextPresentation = {
+    size: {
+        width: number;
+        height: number;
+    };
+    displayContent: string;
+    displayOffset?: Point;
+    displayClipSize?: {
+        width: number;
+        height: number;
+    };
+};
+export type TextLayoutServiceConfig = {
+    model: DiagramModel;
+    textMeasurer: TextMeasurer;
+};
+export default class TextLayoutService {
+    private model;
+    private textMeasurer;
+    constructor(config: TextLayoutServiceConfig);
+    resolveTextPresentation(text: TextData): ResolvedTextPresentation;
+    appendTextLayoutPatches(patches: DiagramPatch[], options?: {
+        emitTextUpdated?: boolean;
+        onTextUpdated?: (payload: EngineEventMap['textUpdated']) => void;
+    }): DiagramPatch[];
+    private collectResizedElementIds;
+    private shouldTrackOwnerBoundLayout;
+    private resolveTextLayoutBounds;
+    private wrapText;
+    private wrapByWord;
+    private wrapByChar;
+    private truncateToWidth;
+    private clipToWidth;
+    private measureTextWidth;
+    private resolveTruncationWidthSafety;
+    private resolveTextRenderPadding;
+}

package/dist/cjs/types/examples/index.d.ts

@@ -0,0 +1,2 @@
+export { demoTabs, baseElementShapes, basePortShapes, customGalleryShapes, defaultGhostSize, defaultSvgPath, defaultSvgPathSize, externalToolboxItems, } from '../displaybox/demos';
+export type { DemoAction, DemoActionHelpers, DemoConfig, DemoDefinition, ToolboxItem, DiagramCounts, ViewportSnapshot, DisplayBoxMetrics, } from '../displaybox/types';

package/dist/cjs/types/measure/textStyleDefaults.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_TEXT_FONT_SIZE = 12;
+export declare const DEFAULT_TEXT_FONT_FAMILY = "Arial";
+export declare const DEFAULT_TEXT_LINE_HEIGHT = 1.2;
+export type ResolvedTextStyle = {
+    fontSize: number;
+    fontFamily: string;
+    lineHeight: number;
+};
+export declare const resolveTextStyleDefaults: (style?: Record<string, unknown>) => ResolvedTextStyle;

package/dist/cjs/types/models/DiagramModel.d.ts

@@ -31,6 +31,7 @@ export default class DiagramModel {
     removeElement(id: string): void;
     addPort(data: PortData): PortModel;
     movePort(id: string, position: Point): void;
+    setPortCurrentAnchorId(id: string, currentAnchorId?: string): void;
     removePort(id: string): void;
     addLink(data: LinkData): LinkModel;
     updateLinkPoints(id: string, points: Point[]): void;

package/dist/cjs/types/models/ElementModel.d.ts

@@ -11,6 +11,7 @@ export default class ElementModel {
     moveMode?: MoveConstraint;
     anchorCenter?: boolean;
     layout?: ElementData['layout'];
+    portMovement?: ElementData['portMovement'];
     constructor(data: ElementData);
     setPosition(position: Point): void;
     setSize(size: Size): void;

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

@@ -9,8 +9,11 @@ export default class PortModel {
     textIds: string[];
     moveMode?: MoveConstraint;
     anchorCenter?: boolean;
+    orientToHostBorder: boolean;
+    currentAnchorId?: string;
     constructor(data: PortData);
     setPosition(position: Point): void;
+    setCurrentAnchorId(currentAnchorId?: string): void;
     addText(textId: string): void;
     removeText(textId: string): void;
     toData(): PortData;

package/dist/cjs/types/models/TextModel.d.ts

@@ -6,9 +6,17 @@ export default class TextModel {
     size?: Size;
     style?: Record<string, unknown>;
     ownerId?: string | null;
+    layout?: TextData['layout'];
+    displayContent?: string;
+    displayOffset?: Point;
+    displayClipSize?: Size;
     constructor(data: TextData);
     setContent(content: string): void;
     setSize(size: Size): void;
+    setDisplayContent(content: string): void;
+    setDisplayOffset(offset: Point | undefined): void;
+    setDisplayClipSize(size: Size | undefined): void;
+    setLayout(layout: TextData['layout']): void;
     setPosition(position: Point): void;
     toData(): TextData;
 }