@tumaet/apollon 4.9.0 → 5.0.1

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

@@ -1,123 +0,0 @@
-import { IPoint } from '../../edges/Connection';
-/**
- * Pure geometry for edge-label placement, in flow space. No React, no DOM —
- * every output is derived synchronously from the edge's polyline so it is
- * identical interactively and in headless (resvg) export, and unit-testable on
- * its own (mirrors edges/labelTypes/messageLayout.ts, the #645 gold standard).
- *
- * The model follows the cross-tool consensus (yEd / ELK CENTER / mxGraph /
- * JointJS): keep the text horizontal and offset it by a constant gap onto a
- * perpendicular side. The label is hosted on whichever ARM of the (possibly
- * stepped) edge has room — scored against the edge's own arms, nodes, and
- * neighbour edges — defaulting to centered-on-top of the arc-mid segment when
- * that is already clear. Deterministic scoring, not a continuous optimizer.
- */
-export interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export interface MidSegment {
-    /** Rounded midpoint of the chosen mid-segment (flow space). */
-    point: IPoint;
-    /** Orientation of the chosen mid-segment. */
-    isHorizontal: boolean;
-    /** Index of the chosen segment in the collapsed polyline. */
-    segmentIndex: number;
-    /** The chosen segment's endpoints in source->target order. Useful to derive
-     * the LOCAL flow direction at the middle (e.g. communication arrows) instead
-     * of the raw node anchors, which can disagree on a bent edge. */
-    start: IPoint;
-    end: IPoint;
-}
-export type LabelSide = "above" | "below" | "left" | "right";
-export interface PlacedLabel {
-    x: number;
-    y: number;
-    textAnchor: "start" | "middle" | "end";
-    dominantBaseline: "auto" | "middle" | "hanging";
-    /** Exposed for unit assertions; not needed for rendering. */
-    side: LabelSide;
-}
-/**
- * The mid-SEGMENT midpoint and orientation, computed purely from the polyline.
- *
- * Walks the collapsed polyline accumulating Manhattan segment length (exact
- * because EDGES.STEP_BORDER_RADIUS === 0, so getSmoothStepPath emits no corner
- * arcs and the rendered path equals the polyline). The "middle" is the first
- * segment whose cumulative length reaches half the total; the midpoint is lerped
- * strictly INSIDE that one segment, so it is corner-safe — unlike sampling the
- * rendered path with getPointAtLength(total/2), which can land on a bend or, if
- * line-jump bridges are present, on a bridge arc off the straight line.
- */
-export declare function getMidSegment(renderPoints: IPoint[], fallbackSource: IPoint, fallbackTarget: IPoint): MidSegment;
-/**
- * Rough single-line text width (flow px). Deterministic — a pure character-count
- * estimate, never canvas measurement — so the chosen placement is identical
- * interactively and in headless export, and SSR-safe. Slightly generous so the
- * scoring box errs toward MORE clearance.
- */
-export declare function estimateLabelWidth(text: string, fontSize: number): number;
-/**
- * The text box (flow space) for a label anchored at `point` on the chosen side,
- * sized to the actual label (`w` × `h`). Used to score overlap against the
- * edge's own arms, neighbour edges, and nodes.
- */
-export declare function candidateBox(point: IPoint, side: LabelSide, w: number, h: number): Rect;
-/**
- * The other edges' polylines whose bounding box comes within `radius` of
- * `center`, excluding `selfId`. Bounds the neighbour scan to edges actually near
- * the label so placement stays O(nearby), not O(all edges) per label.
- */
-export declare function collectNeighborPolylines(geometryById: Record<string, IPoint[]>, selfId: string, center: IPoint, radius: number): IPoint[][];
-export interface MiddleLabelInput {
-    /** The edge's full rendered polyline (source → target). */
-    renderPoints: IPoint[];
-    /** The label text — used for a width fallback when measuredWidth is absent. */
-    labelText: string;
-    /** Render font size (px) of the label. */
-    fontSize: number;
-    /** Real measured label width (px), from the rendering context. Preferred over
-     * the character-count estimate so the scored box equals the rendered ink. */
-    measuredWidth?: number;
-    /** Node rects to avoid — NOT only source/target: every node the edge routes
-     * near, so the label never lands on an unrelated node's body. */
-    nodeRects?: Rect[];
-    /** Nearby other-edge polylines (see collectNeighborPolylines), collected over
-     * the WHOLE edge so they cover any arm the label may land on. */
-    neighborGeometry?: IPoint[][];
-}
-/**
- * Places the relationship/stereotype middle label so it overlaps nothing it can
- * avoid. The label is hosted on whichever arm of the edge — and on whichever
- * perpendicular side — has room: each candidate (every segment × its two sides)
- * is scored lexicographically by
- *   [ overlaps (own other arms + nodes + neighbour edges),
- *     does-not-fit-within-the-segment,
- *     distance from the arc-midpoint (keep it central),
- *     side preference (on top / right) ].
- * For a simple edge the arc-mid segment wins with zero overlaps, so the label
- * stays centered on top exactly as before; on a zig-zag/stepped edge it moves to
- * a longer arm with clearance instead of crossing the short mid-segment's
- * neighbouring arms. All inputs are static geometry, so the placement is stable
- * across selection and identical in headless export.
- */
-export declare function computeMiddleLabelLayout(input: MiddleLabelInput): PlacedLabel;
-export interface RotatedLabelPlacement {
-    x: number;
-    y: number;
-    /** Degrees; the label is rotated to lie along the connector, flipped to stay
-     * upright. */
-    rotation: number;
-}
-/**
- * Placement for a label that lies ALONG a straight (possibly diagonal)
- * connector — use-case association names and the <<include>>/<<extend>>
- * stereotype. The text is rotated to the line's slope (flipped to stay upright)
- * and pushed `perpendicularOffset` px off the line on the upper-left normal.
- * Pass 0 to center it on the line (e.g. include/extend, which sits in the gap
- * carved by calculateStraightPath). Centralises the rotation math that was
- * duplicated across the use-case label components.
- */
-export declare function computeUseCaseLabelLayout(source: IPoint, target: IPoint, perpendicularOffset: number): RotatedLabelPlacement;

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

@@ -1,44 +0,0 @@
-/**
- * Pure side-selection for the provided/required interface node label. The
- * interface is a small circle that connects only at its four directional
- * handles ("top"/"right"/"bottom"/"left"). The name sits centered below by
- * default (see InterfaceLabel), but must move off any side a connecting edge
- * attaches to — otherwise the label overlaps that edge. Pure and unit-testable
- * in the spirit of edgeLabelLayout.ts; no React, no DOM, no constants.
- */
-/** A side an edge can attach to (the four directional interface handles). */
-export type CardinalSide = "top" | "right" | "bottom" | "left";
-/**
- * Where the label sits relative to the circle: one of the four sides, or — when
- * every side has a connecting edge — a diagonal quadrant (which no cardinal edge
- * passes through).
- */
-export type InterfaceLabelSide = CardinalSide | "top-left" | "top-right" | "bottom-left" | "bottom-right";
-/** Minimal structural view of a React Flow edge (the store's `Edge[]` fits). */
-interface InterfaceEdgeLike {
-    source: string;
-    target: string;
-    sourceHandle?: string | null;
-    targetHandle?: string | null;
-}
-/** The sides of `nodeId` that a connecting edge attaches to. */
-export declare function getOccupiedInterfaceSides(edges: ReadonlyArray<InterfaceEdgeLike>, nodeId: string): Set<CardinalSide>;
-/**
- * Picks where the label sits. Prefers a free cardinal side by priority — reads
- * naturally under a small circle (bottom, then top, then a horizontal side).
- * When the assessment badge occupies the top-right corner, "top" and "right"
- * are demoted last so a label can't graze the badge.
- *
- * If every cardinal side has a connecting edge, the label moves into a DIAGONAL
- * quadrant: each cardinal edge leaves along an axis, so a corner label sits in
- * the gap between two of them and crosses none. Prefer a corner away from the
- * top-right badge.
- */
-export declare function pickInterfaceLabelSide(occupied: ReadonlySet<CardinalSide>, opts?: {
-    badgeTopRight?: boolean;
-}): InterfaceLabelSide;
-/** Convenience: the interface label side for `nodeId` given the current edges. */
-export declare function computeInterfaceLabelSide(edges: ReadonlyArray<InterfaceEdgeLike>, nodeId: string, opts?: {
-    badgeTopRight?: boolean;
-}): InterfaceLabelSide;
-export {};

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

@@ -1,14 +0,0 @@
-import { UMLModel } from '../typings';
-export type AssessmentViewData = {
-    elementId: string;
-    elementType: string;
-    name: string;
-    feedback: string;
-    score: number;
-};
-export declare const getAssessmentNameForArtemis: (elementId: string, model: UMLModel) => {
-    name: string;
-    type: string;
-} | undefined;
-export declare const getEdgeAssessmentDataById: (edgeId: string, model: UMLModel) => AssessmentViewData | undefined;
-export declare const getNodeAssessmentDataByNodeElementId: (nodeElementId: string, model: UMLModel) => AssessmentViewData | undefined;

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

@@ -1,19 +0,0 @@
-export declare const generateUUID: () => string;
-export * from './layoutUtils';
-export * from './textUtils';
-export * from './popoverUtils';
-export * from './quadrantUtils';
-export * from './nodeUtils';
-export * from './edgeUtils';
-export * from './exportUtils';
-export * from './diagramTypeUtils';
-export * from './storeUtils';
-export * from './deepPartial';
-export * from './bpmnConstraints';
-export * from './swimlaneUtils';
-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/react/utils/interactiveUtils.d.ts

@@ -1,6 +0,0 @@
-import { ApollonEdge, ApollonNode, InteractiveElements } from '../typings';
-type InteractivePruneNode = Pick<ApollonNode, "id"> & Partial<Pick<ApollonNode, "data">>;
-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 {};

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

@@ -1,30 +0,0 @@
-import { DefaultNodeProps } from '../types';
-/**
- * Calculates the minimum width required to fit the text with specified padding and margin.
- * @param maxTextWidth - The maximum width of the text.
- * @param padding - The inner padding for text.
- * @returns The calculated minimum width.
- */
-export declare const calculateMinWidth: (maxTextWidth: number, padding: number) => number;
-/**
- * Calculates the minimum height based on header, attributes, methods, and margins.
- * @param headerHeight - The height of the header section.
- * @param attributesCount - Number of attributes.
- * @param methodsCount - Number of methods.
- * @param attributeHeight - Height per attribute.
- * @param methodHeight - Height per method.
- * @returns The calculated minimum height.
- */
-export declare const calculateMinHeight: (headerHeight: number, attributesCount: number, methodsCount: number, attributeHeight: number, methodHeight: number) => number;
-export declare const getCustomColorsFromData: (data: DefaultNodeProps) => {
-    strokeColor: string;
-    fillColor: string;
-    textColor: string;
-};
-export declare const getCustomColorsFromDataForEdge: (data?: {
-    strokeColor?: string;
-    textColor?: string;
-}) => {
-    strokeColor: string;
-    textColor: string;
-};

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

@@ -1,15 +0,0 @@
-import { XYPosition, Node } from '@xyflow/react';
-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[];
-/**
- * Does this node's SVG renderer wrap its label? Drives whether the rename
- * popover accepts multiline input — see `NODE_LABEL_CAPABILITIES`.
- */
-export declare const supportsMultilineName: (nodeType?: string) => boolean;
-/**
- * Does this node render a user-editable text label at all? False for
- * pure-symbol nodes so the rename popover hides its input for them.
- */
-export declare const rendersNameLabel: (nodeType?: string) => boolean;
-export declare const isParentNodeType: (nodeType?: string) => boolean;

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

@@ -1,70 +0,0 @@
-/**
- * Layout math for the floating element palette. The palette is an overlay on
- * the canvas (all viewports — there is no docked variant), so it must lay every
- * element out in a grid that fits the available canvas WITHOUT scrolling.
- *
- * Objective (in priority order):
- *   1. Use the FEWEST columns — a tall, narrow card preserves horizontal canvas
- *      space, which is what you actually draw in.
- *   2. Fill the available VERTICAL space — a single column down the side reads
- *      like a classic palette and wastes no height.
- *   3. Shrink the cells down to the `COMFORT_MIN_H` LEGIBILITY threshold BEFORE
- *      adding a column — but no smaller: below that, spill to another column so
- *      the node types stay distinguishable (rather than collapsing to an
- *      illegible sliver). Cap at `CELL_MAX_H` so they're never too large. The
- *      `CELL_MIN_H` touch floor is the last-resort fallback on a tiny canvas.
- *
- * So: walk column counts low→high and take the first one whose cells, sized to
- * fill the height (capped), are still at least the legibility threshold. One
- * column of legible cells is preferred over two columns of bigger ones; cells
- * shrink toward the legibility threshold first, and only spill to another column
- * when staying legible in fewer columns no longer fits the height.
- *
- * `availH` is the palette's REAL available band (the caller measures the space
- * between the palette's top and the bottom controls), so this math does NOT
- * re-subtract any top/bottom chrome reserve — it fills the band it is given.
- *
- * Cells are rectangular (the dominant elements — class boxes, BPMN tasks — are
- * ~1.6:1 wide); narrower/square elements letterbox centered inside. Sizing the
- * cell, not the SVG, keeps the node components untouched.
- */
-export declare const PALETTE: Readonly<{
-    /** Absolute floor (HIG/WCAG touch) — only reached on a tiny canvas where even
-     *  spilling to more columns can't keep cells legible; never shrink past it. */
-    readonly CELL_MIN_H: 44;
-    /** Legibility threshold: shrink a column's cells down to here BEFORE adding
-     *  another column, but spill (rather than go smaller) so the node types stay
-     *  distinguishable. ~a comfortably legible node-preview cell. */
-    readonly COMFORT_MIN_H: 64;
-    /** Upper bound so few-element palettes don't get absurdly tall cells;
-     *  ~a 0.8-scale class-box preview. */
-    readonly CELL_MAX_H: 88;
-    /** cellW = round(CELL_RATIO * cellH); ~matches the 160×100 class box. */
-    readonly CELL_RATIO: 1.6;
-    readonly GAP: 8;
-    readonly PAD: 6;
-    /** Keep the palette horizontally narrow so the canvas keeps its width. */
-    readonly MAX_FRAC_W: 0.5;
-    /** Letterbox padding around the preview inside a cell. */
-    readonly CONTENT_INSET: 6;
-}>;
-export interface PaletteLayout {
-    cols: number;
-    cellW: number;
-    cellH: number;
-    /** True only in the rare case all items can't fit even at the floor size. */
-    scroll: boolean;
-}
-/**
- * @param itemCount total grid cells (drag elements + the color-description cell)
- * @param availW    measured canvas width
- * @param availH    measured canvas height
- * @param chromeH   height of non-grid palette chrome (view switch / hint), 0 if none
- */
-export declare function computePaletteLayout(itemCount: number, availW: number, availH: number, chromeH: number): PaletteLayout;
-/**
- * Preview scale that fits an element's natural size into a cell's content box.
- * Elements fill their cell (so they read "big"); wide boxes fit width, tall/
- * square nodes fit height and letterbox.
- */
-export declare function previewScaleForCell(naturalWidth: number, naturalHeight: number, cellW: number, cellH: number): number;

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

@@ -1,54 +0,0 @@
-/**
- * SVG Path Parsing Utilities
- *
- * Parses SVG path commands to extract endpoint positions and directions.
- * Used by InlineMarker to correctly position and orient edge markers.
- *
- * Supports all SVG path commands including relative coordinates.
- */
-export interface Point {
-    readonly x: number;
-    readonly y: number;
-}
-export interface PathEndInfo {
-    /** The endpoint coordinates */
-    readonly endPoint: Point;
-    /** Direction angle in radians (from previous point to endpoint) */
-    readonly direction: number;
-}
-export interface PathStartInfo {
-    /** The start point coordinates */
-    readonly startPoint: Point;
-    /** Direction angle in radians (pointing into the start, away from second point) */
-    readonly direction: number;
-}
-/**
- * Calculate the direction angle from point A to point B.
- */
-export declare function calculateDirection(from: Point, to: Point): number;
-/**
- * Extract endpoint information from an SVG path.
- *
- * Parses the path to find the final position and the direction of approach.
- * The direction is calculated from the control point (or previous point) to the endpoint.
- *
- * @param pathD - SVG path data string (e.g., "M0,0 L100,100")
- * @returns Endpoint info or null if path is invalid
- */
-export declare function getPathEndInfo(pathD: string): PathEndInfo | null;
-/**
- * Extract start point information from an SVG path.
- *
- * @param pathD - SVG path data string
- * @returns Start point info or null if path is invalid
- */
-export declare function getPathStartInfo(pathD: string): PathStartInfo | null;
-/**
- * Extract marker ID from a url() reference.
- *
- * @example
- * extractMarkerId("url(#black-arrow)") // "black-arrow"
- * extractMarkerId("url('#my-marker')") // "my-marker"
- * extractMarkerId(undefined) // null
- */
-export declare function extractMarkerId(markerUrl: string | undefined): string | null;

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

@@ -1,3 +0,0 @@
-import { Quadrant } from '../enums';
-import { LocationPopover } from '../types';
-export declare const getPopoverOrigin: (quadrant: Quadrant) => LocationPopover;

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

@@ -1,3 +0,0 @@
-import { Quadrant } from '../enums';
-import { XYPosition } from '@xyflow/react';
-export declare const getQuadrant: (target: XYPosition, reference: XYPosition) => Quadrant;

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

@@ -1,18 +0,0 @@
-type RequiredInterfaceLikeEdge = {
-    id: string;
-    target: string;
-    type?: string | null;
-    targetHandle?: string | null;
-};
-type ResolveRequiredInterfaceEdgeTypeParams = {
-    type: string;
-    id: string;
-    target: string;
-    targetHandleId?: string | null;
-    edges: RequiredInterfaceLikeEdge[];
-    requiredTypes: readonly string[];
-    defaultType: string;
-    reducedType: string;
-};
-export declare function resolveRequiredInterfaceEdgeType({ type, id, target, targetHandleId, edges, requiredTypes, defaultType, reducedType, }: ResolveRequiredInterfaceEdgeTypeParams): string;
-export {};

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

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

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

@@ -1,86 +0,0 @@
-/** Compact spec for a text style. Converted into a canvas `font` shorthand. */
-export type SvgFontSpec = {
-    fontSize: number;
-    fontWeight?: string | number;
-    fontFamily?: string;
-    fontStyle?: string;
-};
-export declare const toCanvasFont: (spec: SvgFontSpec) => string;
-/** How to treat whitespace during layout. Mirrors a CSS `white-space` subset. */
-export type WhiteSpaceMode = "normal" | "pre-wrap";
-/**
- * Invalidate every cached preparation. Call this when the set of available
- * fonts changes (e.g. a webfont just finished loading) so that subsequent
- * measurements use the real font metrics rather than the fallback's.
- */
-export declare const clearPrepareCache: () => void;
-/**
- * Convenience: the most lines of `lineHeight` that can stack vertically in
- * `availableHeight` pixels. Always returns at least 1. Useful for SVG nodes
- * whose inner drawable area has a known vertical budget (rectangle height
- * minus top/bottom padding, for instance) and who want to cap
- * `MultilineText`'s `maxLines` so wrapping never overflows the shape.
- */
-export declare const maxLinesForHeight: (availableHeight: number, lineHeight: number) => number;
-export type WrappedText = {
-    lines: string[];
-    /**
-     * Measured width of the widest laid-out line, in CSS px. Does not account
-     * for any ellipsis a caller may append after truncation.
-     */
-    maxLineWidth: number;
-    /** Whether every grapheme of the input was consumed by the layout. */
-    overflow: boolean;
-};
-/**
- * Wrap text inside a rectangle of `maxWidth`. Word-break is CSS `normal`.
- * When `whiteSpace` is `"pre-wrap"` (the default), literal `\n` characters in
- * the input become hard line breaks; when it is `"normal"` whitespace runs
- * collapse the way CSS normally collapses them.
- *
- * Returns the resulting lines, the widest line's measured width, and whether
- * any content was dropped (i.e. could not fit within `maxLines`).
- */
-export declare const wrapTextInRect: (text: string, maxWidth: number, font: SvgFontSpec | string, options?: {
-    maxLines?: number;
-    lineHeight?: number;
-    whiteSpace?: WhiteSpaceMode;
-}) => WrappedText;
-export type ShapeLayout = {
-    /** Materialized lines (from pretext). `text` already includes any ellipsis. */
-    lines: {
-        text: string;
-        width: number;
-    }[];
-    lineHeight: number;
-    /** Signed y-offsets (relative to shape center) of each line's visual center. */
-    lineOffsets: number[];
-    /** Total vertical span of the laid-out block. */
-    blockHeight: number;
-    /** True when input text exceeded the shape's capacity and was truncated. */
-    overflow: boolean;
-};
-type ShapeOptions = {
-    paddingX?: number;
-    paddingY?: number;
-    /** Cap on how many lines we will try to fit. Defaults to a generous value. */
-    maxLines?: number;
-    /** Same semantics as `wrapTextInRect`'s `whiteSpace`. */
-    whiteSpace?: WhiteSpaceMode;
-};
-/**
- * Lay out `text` inside an ellipse of size `width`×`height`, respecting the
- * ellipse's curvature so lines near the top and bottom get a narrower max
- * width than lines near the middle. When the text does not fit, the final
- * visible line is suffixed with a horizontal ellipsis.
- */
-export declare const layoutTextInEllipse: (text: string, width: number, height: number, font: SvgFontSpec | string, lineHeight: number, options?: ShapeOptions) => ShapeLayout;
-/**
- * Lay out `text` inside a rhombus / diamond of size `width`×`height`. The
- * inner width varies linearly with the distance from the vertical center
- * (full width at the middle, zero at the top and bottom vertices). Lines
- * near the vertices therefore get narrower line boxes, and overflow is
- * marked with a horizontal ellipsis on the last visible line.
- */
-export declare const layoutTextInDiamond: (text: string, width: number, height: number, font: SvgFontSpec | string, lineHeight: number, options?: ShapeOptions) => ShapeLayout;
-export {};

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

@@ -1,58 +0,0 @@
-import { SwimlaneLane } from '../types';
-/** Smallest a lane may be shrunk to (flow px) when dragging a separator. */
-export declare const MIN_LANE_EXTENT = 40;
-/**
- * Pixel `start`/`extent` of every lane along the primary axis.
- *
- * Lane sizes are stored as absolute flow px. The **last** lane is elastic: it
- * always fills the remaining space. That way resizing the whole swimlane only
- * grows/shrinks the last lane — the interior separators stay put — instead of
- * rescaling every lane (which would move every separator). Lanes with no size
- * at all (a freshly dropped swimlane) divide the axis equally.
- */
-export declare const getLaneOffsets: (lanes: {
-    size?: number;
-}[], primaryExtent: number) => {
-    start: number;
-    extent: number;
-}[];
-/**
- * Pin every lane's current rendered extent as its `size`, so the elastic last
- * lane gets a concrete value before an operation (reorder/add/remove) that
- * changes which lane is last.
- */
-export declare const materializeLaneSizes: (lanes: SwimlaneLane[], primaryExtent: number) => SwimlaneLane[];
-/** Index of the lane whose range contains the primary-axis coordinate `pos`. */
-export declare const laneIndexAtOffset: (offsets: {
-    start: number;
-    extent: number;
-}[], pos: number) => number;
-/**
- * Balanced resize of the divider between lane `index` and `index + 1`: move the
- * shared boundary by `deltaPx`, growing one lane and shrinking the other by the
- * same amount so the swimlane's outer size never changes. Neither lane drops
- * below `MIN_LANE_EXTENT`. Returns lanes with an explicit `size` on every entry.
- *
- * When `snapGridPx > 0` the moved boundary is snapped to that grid, so a lane
- * separator lands on the same grid that nodes and edge bends snap to. The lane
- * offsets are measured from the swimlane's own origin, which React Flow already
- * keeps grid-aligned, so the snapped boundary lines up with the absolute grid.
- */
-export declare const resizeLaneDivider: (lanes: SwimlaneLane[], index: number, deltaPx: number, primaryExtent: number, snapGridPx?: number) => SwimlaneLane[];
-/**
- * Reposition a swimlane child when orientation flips and the swimlane's
- * width/height swap: transpose the child's corner (x,y)->(y,x), then clamp it
- * into the swapped frame by its own size so it can't be stranded off the new
- * (shorter) cross-axis. `newWidth`/`newHeight` are the post-swap dimensions.
- */
-export declare const flipSwimlaneChildPosition: (child: {
-    position: {
-        x: number;
-        y: number;
-    };
-    width?: number;
-    height?: number;
-}, newWidth: number, newHeight: number) => {
-    x: number;
-    y: number;
-};

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

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