@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/models/LinkModel.js

@@ -0,0 +1,1045 @@
+"use strict";
+// LinkModel - Represents a connection between two ports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkModel = exports.LINK_LABEL_SLOT_POSITIONS = void 0;
+exports.linkLabelPosition = linkLabelPosition;
+const DiagramEntity_1 = require("./DiagramEntity");
+const readonly_lock_1 = require("./readonly-lock"); // Wave 9 — Card 7
+const utils_1 = require("../utils");
+/**
+ * A detached copy of a label collection — the value the `labels` register holds.
+ *
+ * Every `trackChange('labels', …)` reports one of these on BOTH sides. It has to be a
+ * copy rather than the live array: `updateLabel` mutates a label object IN PLACE, so a
+ * "previous" value that shared those objects would already carry the edit, and undo would
+ * restore the new text over itself. `offset` and `style` are the only nested members.
+ */
+function snapshotLabels(labels) {
+    return labels.map((label) => (Object.assign(Object.assign(Object.assign({}, label), { offset: Object.assign({}, label.offset) }), (label.style ? { style: Object.assign({}, label.style) } : {}))));
+}
+/**
+ * Wave 4 (Edges & links), Card 5 — where each of the three edge label SLOTS sits
+ * along the path.
+ *
+ * Pulled IN from the endpoints on purpose: at exactly 0 and 1 a slot label would
+ * land under the arrowhead and on top of the port. 0.12 / 0.88 clears both while
+ * still reading as "at the start / at the end of this edge".
+ *
+ * ONE definition, shared by the model (LinkModel.addLabel), the renderer
+ * (LabelRenderer) and the edge optimizer — three places that must never disagree
+ * about where a label actually is.
+ */
+exports.LINK_LABEL_SLOT_POSITIONS = {
+    start: 0.12,
+    center: 0.5,
+    end: 0.88,
+};
+/**
+ * The position along the path (0-1) a label resolves to.
+ *
+ * `slot` WINS over `position`. Naming a slot is an explicit act; `position` is a
+ * required field that most slot users only fill in to satisfy the type, so
+ * letting it win would make `slot` silently do nothing.
+ */
+function linkLabelPosition(label) {
+    if (label.slot && label.slot in exports.LINK_LABEL_SLOT_POSITIONS) {
+        return exports.LINK_LABEL_SLOT_POSITIONS[label.slot];
+    }
+    return typeof label.position === 'number' && isFinite(label.position)
+        ? label.position
+        : 0.5;
+}
+class LinkModel extends DiagramEntity_1.DiagramEntity {
+    constructor(sourcePortId, targetPortId, pathType) {
+        super();
+        // Path
+        this.pathType = 'smooth';
+        this.points = [];
+        this.segments = [];
+        // Labels
+        this.labels = [];
+        // State
+        this.state = 'default';
+        // Styling
+        this.style = {};
+        // User data
+        this.data = {};
+        // Phase 1: Endpoint selection state (for reconnection)
+        /**
+         * Whether source endpoint handle is selected
+         * Used for dragging endpoint to reconnect
+         */
+        this.isSourceEndpointSelected = false;
+        /**
+         * Whether target endpoint handle is selected
+         * Used for dragging endpoint to reconnect
+         */
+        this.isTargetEndpointSelected = false;
+        this.sourcePortId = sourcePortId;
+        this.targetPortId = targetPortId;
+        // Non-enumerable so the diagram back-reference never enters serialization or
+        // deep-clone (the circular-reference trap NodeModel already avoids this way).
+        Object.defineProperty(this, 'diagram', {
+            value: undefined,
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
+        if (pathType) {
+            this.pathType = pathType;
+        }
+    }
+    /**
+     * Wave 9 — Card 7. Is a document write to this link forbidden right now?
+     * True only when the link belongs to a diagram that is locked (read-only) and we
+     * are not inside a system write. A detached link (not yet added to any diagram)
+     * is freely mutable — you must be able to BUILD a link before adding it, and
+     * `DiagramModel.addLink` is what refuses.
+     */
+    writeBlocked() {
+        return (0, readonly_lock_1.writeBlocked)(this.diagram);
+    }
+    /**
+     * Wave 4 (Edges & links) — Card 4: is this link a SELF-LOOP, i.e. do both
+     * ends live on the same node?
+     *
+     * Reads the cached owning-node ids, which `DiagramModel.installLink` backfills
+     * for every link that reaches a diagram (including ones built with
+     * `new LinkModel()` + `addLink`, which carry no ids of their own). A link that
+     * has never been installed has no ids and is — correctly — not a self-loop as
+     * far as anything can tell.
+     *
+     * A self-loop between two DIFFERENT ports of the same node counts, and so does
+     * one that starts and ends on the SAME port.
+     */
+    isSelfLoop() {
+        return !!this.sourceNodeId && this.sourceNodeId === this.targetNodeId;
+    }
+    /**
+     * Wave 4 — Card 4: the unordered node pair this link connects, as a stable
+     * key. UNORDERED on purpose: A→B and B→A are the same visual bundle and must
+     * fan out together, or a bidirectional pair would draw both links on the same
+     * centre line. Returns null when the owning nodes are unknown.
+     */
+    getNodePairKey() {
+        if (!this.sourceNodeId || !this.targetNodeId)
+            return null;
+        return this.sourceNodeId <= this.targetNodeId
+            ? `${this.sourceNodeId}|${this.targetNodeId}`
+            : `${this.targetNodeId}|${this.sourceNodeId}`;
+    }
+    /**
+     * Set source port
+     */
+    setSourcePort(portId, nodeId) {
+        if (this.writeBlocked())
+            return;
+        const oldPortId = this.sourcePortId;
+        this.sourcePortId = portId;
+        if (nodeId) {
+            this.sourceNodeId = nodeId;
+        }
+        this.trackChange('sourcePortId', oldPortId, portId);
+    }
+    /**
+     * Set target port
+     */
+    setTargetPort(portId, nodeId) {
+        if (this.writeBlocked())
+            return;
+        const oldPortId = this.targetPortId;
+        this.targetPortId = portId;
+        if (nodeId) {
+            this.targetNodeId = nodeId;
+        }
+        this.trackChange('targetPortId', oldPortId, portId);
+    }
+    /**
+     * Set path type
+     */
+    setPathType(pathType) {
+        if (this.writeBlocked())
+            return;
+        const oldType = this.pathType;
+        this.pathType = pathType;
+        // The cached route belongs to the old path type; clear it so the renderer
+        // re-routes with the new algorithm instead of drawing the stale polyline.
+        if (oldType !== pathType) {
+            this.points = [];
+            this.segments = [];
+            this.setMetadata('hasManualWaypoints', false);
+        }
+        this.trackChange('pathType', oldType, pathType);
+    }
+    /**
+     * Card 0: set the routing geometry explicitly. Clears the cached route the
+     * same way setPathType does — the old polyline belongs to the old router.
+     */
+    setRouter(router) {
+        if (this.writeBlocked())
+            return;
+        const old = this.router;
+        if (old === router)
+            return;
+        this.router = router;
+        this.points = [];
+        this.segments = [];
+        this.setMetadata('hasManualWaypoints', false);
+        this.trackChange('router', old, router);
+    }
+    /** Card 0: set the polyline rendering explicitly. Pure re-render; the routed
+     * points are still valid, so the cache is NOT cleared. */
+    setConnector(connector) {
+        if (this.writeBlocked())
+            return;
+        const old = this.connector;
+        if (old === connector)
+            return;
+        this.connector = connector;
+        this.trackChange('connector', old, connector);
+    }
+    /**
+     * The router actually in force: the explicit field, else derived from
+     * pathType exactly as the renderer always derived it (direct → straight,
+     * orthogonal → orthogonal, smooth/bezier → straight-with-curved-rendering).
+     */
+    effectiveRouter() {
+        if (this.router)
+            return this.router;
+        switch (this.pathType) {
+            case 'orthogonal': return 'orthogonal';
+            case 'direct':
+            case 'smooth':
+            case 'bezier':
+            default: return 'straight';
+        }
+    }
+    /**
+     * The connector actually in force: the explicit field, else implied by an
+     * explicitly axis-aligned ROUTER, else derived from pathType.
+     *
+     * The router rung exists because `{ router: 'orthogonal' }` with the default
+     * pathType used to draw a smooth SPLINE through Manhattan waypoints — the
+     * route was orthogonal, the picture was wavy (the screenshot audit caught the
+     * demo's own readout saying "orthogonal" over a curve). Asking for an
+     * axis-aligned router IS asking for axis-aligned rendering; rounded corners
+     * are that family's standard look. An explicit `connector` still overrides.
+     */
+    effectiveConnector() {
+        if (this.connector)
+            return this.connector;
+        switch (this.router) {
+            case 'orthogonal':
+            case 'manhattan':
+            case 'avoid':
+            case 'elk':
+                return 'rounded';
+            default:
+                break;
+        }
+        switch (this.pathType) {
+            case 'direct': return 'straight';
+            case 'orthogonal': return 'rounded';
+            case 'bezier': return 'bezier';
+            case 'smooth':
+            default: return 'smooth';
+        }
+    }
+    /**
+     * Set points for custom path
+     */
+    setPoints(points) {
+        if (this.writeBlocked())
+            return;
+        const oldPoints = [...this.points];
+        this.points = points.map((p) => (Object.assign({}, p)));
+        this.trackChange('points', oldPoints, this.points);
+        this.updateSegments();
+    }
+    /**
+     * Add point to path
+     */
+    addPoint(point, index) {
+        if (this.writeBlocked())
+            return;
+        const actualIndex = index !== undefined ? index : this.points.length;
+        if (index !== undefined) {
+            this.points.splice(index, 0, Object.assign({}, point));
+        }
+        else {
+            this.points.push(Object.assign({}, point));
+        }
+        this.trackChange('points', null, point);
+        this.updateSegments();
+        this.emitter.emit('link:point-added', { point, index: actualIndex });
+    }
+    /**
+     * Remove point from path
+     */
+    removePoint(index) {
+        if (this.writeBlocked())
+            return undefined;
+        if (index >= 0 && index < this.points.length) {
+            const point = this.points.splice(index, 1)[0];
+            this.trackChange('points', point, null);
+            this.updateSegments();
+            return point;
+        }
+        return undefined;
+    }
+    /**
+     * Update segments based on points
+     */
+    updateSegments() {
+        this.segments = [];
+        if (this.points.length < 2)
+            return;
+        for (let i = 0; i < this.points.length - 1; i++) {
+            const from = this.points[i];
+            const to = this.points[i + 1];
+            if (from && to) {
+                this.segments.push({
+                    type: 'line',
+                    from: Object.assign({}, from),
+                    to: Object.assign({}, to),
+                });
+            }
+        }
+    }
+    /**
+     * Generate path based on type
+     */
+    generatePath(sourcePoint, targetPoint, sourceDirection, targetDirection) {
+        switch (this.pathType) {
+            case 'direct':
+                this.generateDirectPath(sourcePoint, targetPoint);
+                break;
+            case 'orthogonal':
+                this.generateOrthogonalPath(sourcePoint, targetPoint, sourceDirection, targetDirection);
+                break;
+            case 'smooth':
+            case 'bezier':
+                this.generateSmoothPath(sourcePoint, targetPoint);
+                break;
+        }
+        // wave8/dirty — LATENT BUG. Every generator above rewrites `this.points` and
+        // `this.segments` IN PLACE, bypassing `trackChange()` — so a link whose path
+        // was regenerated by layout, live-rerouting, a node drag or connectNodes()
+        // stayed CLEAN. Its rendered `d` had changed and nothing said so. The link
+        // VNode cache keys off `isDirty`, and only Wave 4's per-frame geometry
+        // signature (markLinksWhoseFrameChanged) was covering for it — a backstop
+        // that only runs with caching on, and only for links the frame actually
+        // visits. The path IS the link's state; say so.
+        this.markDirty('points');
+        this.emitter.emit('link:path-changed', { segments: this.segments });
+    }
+    /**
+     * Generate direct path (straight line)
+     */
+    generateDirectPath(from, to) {
+        this.points = [Object.assign({}, from), Object.assign({}, to)];
+        this.segments = [
+            {
+                type: 'line',
+                from: Object.assign({}, from),
+                to: Object.assign({}, to),
+            },
+        ];
+    }
+    /**
+     * Generate orthogonal path (right angles)
+     * Uses React Flow's smoothstep algorithm with port directions for proper routing
+     */
+    generateOrthogonalPath(from, to, sourceDirection, targetDirection) {
+        // If no directions provided, use simple default
+        if (!sourceDirection || !targetDirection) {
+            const midX = (from.x + to.x) / 2;
+            this.points = [
+                Object.assign({}, from),
+                { x: midX, y: from.y },
+                { x: midX, y: to.y },
+                Object.assign({}, to),
+            ];
+            this.segments = [
+                { type: 'line', from: this.points[0], to: this.points[1] },
+                { type: 'line', from: this.points[1], to: this.points[2] },
+                { type: 'line', from: this.points[2], to: this.points[3] },
+            ];
+            return;
+        }
+        // React Flow smoothstep algorithm
+        const gapOffset = 20;
+        // Calculate offset points (gap from ports)
+        let sourceOffset = this.applyGapOffset(from, sourceDirection, gapOffset);
+        let targetOffset = this.applyGapOffset(to, targetDirection, gapOffset);
+        // Determine routing direction
+        const dir = this.getRoutingDirection(sourceOffset, sourceDirection, targetOffset);
+        const dirAccessor = dir.x !== 0 ? 'x' : 'y';
+        const sourceDir = this.getDirectionVector(sourceDirection);
+        const targetDir = this.getDirectionVector(targetDirection);
+        let intermediatePoints = [];
+        const sourceGapOffset = { x: 0, y: 0 };
+        const targetGapOffset = { x: 0, y: 0 };
+        // Check if ports are opposite
+        const areOpposite = sourceDir[dirAccessor] * targetDir[dirAccessor] === -1;
+        if (areOpposite) {
+            // Z-shape routing for opposite ports
+            if (dirAccessor === 'x') {
+                const centerX = (sourceOffset.x + targetOffset.x) / 2;
+                intermediatePoints = [
+                    { x: centerX, y: sourceOffset.y },
+                    { x: centerX, y: targetOffset.y }
+                ];
+            }
+            else {
+                const centerY = (sourceOffset.y + targetOffset.y) / 2;
+                intermediatePoints = [
+                    { x: sourceOffset.x, y: centerY },
+                    { x: targetOffset.x, y: centerY }
+                ];
+            }
+        }
+        else {
+            // L-shape routing for perpendicular ports
+            const isSourceHorizontal = sourceDirection === 'left' || sourceDirection === 'right';
+            const isTargetHorizontal = targetDirection === 'left' || targetDirection === 'right';
+            if (isSourceHorizontal && !isTargetHorizontal) {
+                intermediatePoints = [{ x: targetOffset.x, y: sourceOffset.y }];
+            }
+            else if (!isSourceHorizontal && isTargetHorizontal) {
+                intermediatePoints = [{ x: sourceOffset.x, y: targetOffset.y }];
+            }
+            else {
+                if (dirAccessor === 'x') {
+                    intermediatePoints = [{ x: targetOffset.x, y: sourceOffset.y }];
+                }
+                else {
+                    intermediatePoints = [{ x: sourceOffset.x, y: targetOffset.y }];
+                }
+            }
+            // Handle same position ports that are too close
+            if (sourceDirection === targetDirection) {
+                const diff = Math.abs(from[dirAccessor] - to[dirAccessor]);
+                if (diff <= gapOffset) {
+                    const additionalGap = Math.min(gapOffset - 1, gapOffset - diff);
+                    const currDir = dir[dirAccessor];
+                    if (sourceDir[dirAccessor] === currDir) {
+                        const sign = sourceOffset[dirAccessor] > from[dirAccessor] ? -1 : 1;
+                        sourceGapOffset[dirAccessor] = sign * additionalGap;
+                    }
+                    else {
+                        const sign = targetOffset[dirAccessor] > to[dirAccessor] ? -1 : 1;
+                        targetGapOffset[dirAccessor] = sign * additionalGap;
+                    }
+                }
+            }
+        }
+        // Apply gap offsets
+        sourceOffset.x += sourceGapOffset.x;
+        sourceOffset.y += sourceGapOffset.y;
+        targetOffset.x += targetGapOffset.x;
+        targetOffset.y += targetGapOffset.y;
+        // Construct final points array
+        this.points = [
+            Object.assign({}, from),
+            sourceOffset,
+            ...intermediatePoints,
+            targetOffset,
+            Object.assign({}, to)
+        ];
+        // Build segments
+        this.segments = [];
+        for (let i = 0; i < this.points.length - 1; i++) {
+            this.segments.push({
+                type: 'line',
+                from: Object.assign({}, this.points[i]),
+                to: Object.assign({}, this.points[i + 1])
+            });
+        }
+    }
+    /**
+     * Apply gap offset in port direction
+     */
+    applyGapOffset(point, direction, offset) {
+        switch (direction) {
+            case 'left':
+                return { x: point.x - offset, y: point.y };
+            case 'right':
+                return { x: point.x + offset, y: point.y };
+            case 'top':
+                return { x: point.x, y: point.y - offset };
+            case 'bottom':
+                return { x: point.x, y: point.y + offset };
+        }
+    }
+    /**
+     * Get direction vector for port orientation
+     */
+    getDirectionVector(direction) {
+        switch (direction) {
+            case 'left': return { x: -1, y: 0 };
+            case 'right': return { x: 1, y: 0 };
+            case 'top': return { x: 0, y: -1 };
+            case 'bottom': return { x: 0, y: 1 };
+        }
+    }
+    /**
+     * Get routing direction from source to target
+     */
+    getRoutingDirection(source, sourcePosition, target) {
+        if (sourcePosition === 'left' || sourcePosition === 'right') {
+            return source.x < target.x ? { x: 1, y: 0 } : { x: -1, y: 0 };
+        }
+        return source.y < target.y ? { x: 0, y: 1 } : { x: 0, y: -1 };
+    }
+    getCurvature() {
+        const c = this.style.curvature;
+        return typeof c === 'number' && isFinite(c) && c >= 0
+            ? c
+            : LinkModel.DEFAULT_CURVATURE;
+    }
+    /**
+     * Generate smooth/bezier path
+     */
+    generateSmoothPath(from, to) {
+        const dx = to.x - from.x;
+        const controlOffset = Math.abs(dx) * this.getCurvature();
+        this.points = [Object.assign({}, from), Object.assign({}, to)];
+        this.segments = [
+            {
+                type: 'curve',
+                from: Object.assign({}, from),
+                to: Object.assign({}, to),
+                control1: { x: from.x + controlOffset, y: from.y },
+                control2: { x: to.x - controlOffset, y: to.y },
+            },
+        ];
+    }
+    /**
+     * Add label
+     *
+     * Wave 4 (Card 5): `position` is no longer required when the label names a
+     * `slot` — and every other LinkLabel field (html, template, slot, autoOffset,
+     * rotation…) is now carried through instead of being silently dropped. The old
+     * body hand-copied five fields, so a label created here could not be an HTML
+     * label, could not auto-rotate and could not opt into auto-placement.
+     */
+    addLabel(label) {
+        if (this.writeBlocked())
+            return;
+        const fullLabel = Object.assign(Object.assign({}, label), { id: label.id || (0, utils_1.generateId)(), text: label.text, position: linkLabelPosition(label), offset: label.offset || { x: 0, y: 0 }, style: label.style });
+        const prev = snapshotLabels(this.labels);
+        this.labels.push(fullLabel);
+        // THE VALUE, NOT THE DELTA. This used to be
+        // `trackChange('labels', null, fullLabel)` — it named the label that MOVED, not
+        // what the register now holds, and capture ships the funnel payload verbatim. The
+        // receiving peer has no `setLabels()` to prefer, so the generic write ASSIGNED THE
+        // BARE LABEL OBJECT over its array; `serialize()` then threw "this.labels.map is
+        // not a function" and the peer could no longer save the document AT ALL. Identical
+        // in shape to the `members` defect — see collab/register-values.spec.ts.
+        this.trackChange('labels', prev, snapshotLabels(this.labels));
+        this.emitter.emit('link:label-added', fullLabel);
+    }
+    /**
+     * Remove label by ID
+     */
+    removeLabel(labelId) {
+        if (this.writeBlocked())
+            return undefined;
+        const index = this.labels.findIndex((l) => l.id === labelId);
+        if (index !== -1) {
+            const prev = snapshotLabels(this.labels);
+            const label = this.labels.splice(index, 1)[0];
+            // The VALUE. This reported `null` — the peer's `labels` became null and
+            // `null.map()` broke serialize() outright. See addLabel.
+            this.trackChange('labels', prev, snapshotLabels(this.labels));
+            this.emitter.emit('link:label-removed', label);
+            return label;
+        }
+        return undefined;
+    }
+    /**
+     * Remove label by index
+     */
+    removeLabelAt(index) {
+        if (this.writeBlocked())
+            return undefined;
+        if (index >= 0 && index < this.labels.length) {
+            const prev = snapshotLabels(this.labels);
+            const label = this.labels.splice(index, 1)[0];
+            this.trackChange('labels', prev, snapshotLabels(this.labels));
+            this.emitter.emit('link:label-removed', label);
+            return label;
+        }
+        return undefined;
+    }
+    /**
+     * Update label by index
+     */
+    updateLabel(index, updates) {
+        if (this.writeBlocked())
+            return;
+        const label = this.labels[index];
+        if (label) {
+            const oldLabel = Object.assign({}, label);
+            // Snapshotted BEFORE the in-place Object.assign below: `prev` must not share the
+            // object about to be mutated, or the "previous" collection would already carry
+            // the edit and undo would restore the new text over itself.
+            const prev = snapshotLabels(this.labels);
+            Object.assign(label, updates);
+            // The VALUE. This reported the ONE label that changed, so a peer assigned that
+            // single object over its array and lost every other label on the link.
+            this.trackChange('labels', prev, snapshotLabels(this.labels));
+            this.emitter.emit('link:label-updated', { index, label });
+        }
+    }
+    /**
+     * REPLACE the whole label collection — the write `addLabel`/`updateLabel` cannot express.
+     *
+     * `SetLinkLabelsCommand` used to do this by assigning `link.labels` directly on BOTH
+     * execute and undo. A plain field write does not pass `trackChange()` — the one funnel
+     * collab captures from — so the command emitted ZERO ops in BOTH directions: authoring
+     * a link's labels was invisible to every other peer, and so was taking it back. (The
+     * `UpdateLinkStyleCommand` defect at least emitted one op on execute; this emitted none
+     * at all.) `replaceStyle` is the same seam for the same reason.
+     */
+    setLabels(labels) {
+        if (this.writeBlocked())
+            return;
+        // A NON-ARRAY IS REFUSED rather than read as "no labels". This is what makes the fix
+        // safe against LOGS PERSISTED BEFORE IT: a pre-fix op carries a bare LinkLabel object
+        // (the old addLabel) or a bare `null` (the old removeLabel), and both would otherwise
+        // land here through the reducer. Refusing leaves the collection alone, so replaying an
+        // old log degrades rather than destroying the peer's ability to serialize.
+        if (!Array.isArray(labels))
+            return;
+        const prev = snapshotLabels(this.labels);
+        this.labels = snapshotLabels(labels);
+        this.trackChange('labels', prev, snapshotLabels(this.labels));
+        this.emitter.emit('link:labels-changed', { labels: this.labels });
+    }
+    getLabel(labelId) {
+        if (labelId === undefined)
+            return super.getLabel();
+        return this.labels.find((l) => l.id === labelId);
+    }
+    /**
+     * Set state
+     */
+    setState(state) {
+        const oldState = this.state;
+        this.state = state;
+        this.trackChange('state', oldState, this.state);
+        this.emitter.emit('link:state-changed', { oldState, newState: state });
+    }
+    /**
+     * Update style
+     */
+    updateStyle(style) {
+        if (this.writeBlocked())
+            return;
+        const oldStyle = Object.assign({}, this.style);
+        this.style = Object.assign(Object.assign({}, this.style), style);
+        this.trackChange('style', oldStyle, this.style);
+        this.emitter.emit('link:style-changed', { oldStyle, newStyle: this.style });
+    }
+    /**
+     * REPLACE the whole style object — the write `updateStyle` cannot express.
+     *
+     * `updateStyle` merges, so it can never REMOVE a key; restoring a snapshot has to
+     * assign wholesale. `UpdateLinkStyleCommand.undo()` used to do that with a direct
+     * field write (`link.style = restored`), which never passes `trackChange()` — the
+     * single funnel collab captures from. Measured: execute emitted 1 op, undo emitted 0,
+     * so every peer kept the styled link forever while the author saw it correctly
+     * reverted. See collab/style-undo.spec.ts.
+     */
+    replaceStyle(style) {
+        if (this.writeBlocked())
+            return;
+        const oldStyle = Object.assign({}, this.style);
+        this.style = Object.assign({}, style);
+        this.trackChange('style', oldStyle, this.style);
+        this.emitter.emit('link:style-changed', { oldStyle, newStyle: this.style });
+    }
+    /**
+     * Set data property
+     */
+    setData(key, value) {
+        if (this.writeBlocked())
+            return;
+        const oldValue = this.data[key];
+        this.data[key] = value;
+        this.trackChange(`data.${key}`, oldValue, value);
+    }
+    /**
+     * Get data property
+     */
+    getData(key) {
+        return this.data[key];
+    }
+    /**
+     * Phase 1: Reconnect source endpoint to new port
+     * Used for link reconnection workflow
+     */
+    reconnectSource(newPortId, newNodeId) {
+        if (this.writeBlocked())
+            return;
+        const oldPortId = this.sourcePortId;
+        const oldNodeId = this.sourceNodeId;
+        this.sourcePortId = newPortId;
+        if (newNodeId) {
+            this.sourceNodeId = newNodeId;
+        }
+        this.trackChange('sourcePortId', oldPortId, newPortId);
+        this.emitter.emit('link:reconnected', {
+            endpoint: 'source',
+            oldPortId,
+            newPortId,
+            oldNodeId,
+            newNodeId,
+        });
+        // Mark dirty for re-rendering
+        this.markDirty();
+    }
+    /**
+     * Phase 1: Reconnect target endpoint to new port
+     * Used for link reconnection workflow
+     */
+    reconnectTarget(newPortId, newNodeId) {
+        if (this.writeBlocked())
+            return;
+        const oldPortId = this.targetPortId;
+        const oldNodeId = this.targetNodeId;
+        this.targetPortId = newPortId;
+        if (newNodeId) {
+            this.targetNodeId = newNodeId;
+        }
+        this.trackChange('targetPortId', oldPortId, newPortId);
+        this.emitter.emit('link:reconnected', {
+            endpoint: 'target',
+            oldPortId,
+            newPortId,
+            oldNodeId,
+            newNodeId,
+        });
+        // Mark dirty for re-rendering
+        this.markDirty();
+    }
+    /**
+     * Phase 1: Get source endpoint position
+     * Returns the first point in the path (source end)
+     */
+    getSourceEndpoint() {
+        return this.points[0] || { x: 0, y: 0 };
+    }
+    /**
+     * Phase 1: Get target endpoint position
+     * Returns the last point in the path (target end)
+     */
+    getTargetEndpoint() {
+        return this.points[this.points.length - 1] || { x: 0, y: 0 };
+    }
+    /**
+     * Phase 1: Select source endpoint handle
+     */
+    selectSourceEndpoint() {
+        this.isSourceEndpointSelected = true;
+        this.isTargetEndpointSelected = false;
+        this.emitter.emit('link:endpoint-selected', { endpoint: 'source' });
+    }
+    /**
+     * Phase 1: Select target endpoint handle
+     */
+    selectTargetEndpoint() {
+        this.isTargetEndpointSelected = true;
+        this.isSourceEndpointSelected = false;
+        this.emitter.emit('link:endpoint-selected', { endpoint: 'target' });
+    }
+    /**
+     * Phase 1: Deselect all endpoint handles
+     */
+    deselectEndpoints() {
+        this.isSourceEndpointSelected = false;
+        this.isTargetEndpointSelected = false;
+        this.emitter.emit('link:endpoint-deselected');
+    }
+    /**
+     * Phase 1: Check if any endpoint is selected
+     */
+    hasSelectedEndpoint() {
+        return this.isSourceEndpointSelected || this.isTargetEndpointSelected;
+    }
+    /**
+     * Get point at position along link (0-1)
+     */
+    getPointAtPosition(t) {
+        if (this.points.length < 2)
+            return null;
+        t = Math.max(0, Math.min(1, t));
+        if (this.pathType === 'direct') {
+            const from = this.points[0];
+            const to = this.points[this.points.length - 1];
+            return {
+                x: from.x + (to.x - from.x) * t,
+                y: from.y + (to.y - from.y) * t,
+            };
+        }
+        // For other path types, use segments when they exist. Renderers that sync
+        // `points` directly leave `segments` stale/empty — fall back to walking
+        // the points polyline so consumers (e.g. label placement) still get a
+        // real on-path position instead of the endpoint.
+        const totalLength = this.getTotalLength();
+        if (this.segments.length > 0 && totalLength > 0) {
+            const targetLength = totalLength * t;
+            let currentLength = 0;
+            for (const segment of this.segments) {
+                const segmentLength = this.getSegmentLength(segment);
+                if (currentLength + segmentLength >= targetLength) {
+                    const segmentT = segmentLength > 0 ? (targetLength - currentLength) / segmentLength : 0;
+                    return this.getPointOnSegment(segment, segmentT);
+                }
+                currentLength += segmentLength;
+            }
+            return this.points[this.points.length - 1] || null;
+        }
+        // Polyline fallback: arc-length interpolation over points
+        let polyLength = 0;
+        for (let i = 0; i < this.points.length - 1; i++) {
+            polyLength += Math.hypot(this.points[i + 1].x - this.points[i].x, this.points[i + 1].y - this.points[i].y);
+        }
+        if (polyLength <= 0)
+            return Object.assign({}, this.points[0]);
+        let remaining = polyLength * t;
+        for (let i = 0; i < this.points.length - 1; i++) {
+            const a = this.points[i];
+            const b = this.points[i + 1];
+            const segLen = Math.hypot(b.x - a.x, b.y - a.y);
+            if (remaining <= segLen) {
+                const st = segLen > 0 ? remaining / segLen : 0;
+                return { x: a.x + (b.x - a.x) * st, y: a.y + (b.y - a.y) * st };
+            }
+            remaining -= segLen;
+        }
+        return Object.assign({}, this.points[this.points.length - 1]);
+    }
+    /**
+     * Get total path length
+     */
+    getTotalLength() {
+        return this.segments.reduce((sum, segment) => sum + this.getSegmentLength(segment), 0);
+    }
+    /**
+     * Get segment length
+     */
+    getSegmentLength(segment) {
+        const dx = segment.to.x - segment.from.x;
+        const dy = segment.to.y - segment.from.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    /**
+     * Get point on segment
+     */
+    getPointOnSegment(segment, t) {
+        if (segment.type === 'curve' && segment.control1 && segment.control2) {
+            // Cubic bezier
+            const t2 = t * t;
+            const t3 = t2 * t;
+            const mt = 1 - t;
+            const mt2 = mt * mt;
+            const mt3 = mt2 * mt;
+            return {
+                x: mt3 * segment.from.x +
+                    3 * mt2 * t * segment.control1.x +
+                    3 * mt * t2 * segment.control2.x +
+                    t3 * segment.to.x,
+                y: mt3 * segment.from.y +
+                    3 * mt2 * t * segment.control1.y +
+                    3 * mt * t2 * segment.control2.y +
+                    t3 * segment.to.y,
+            };
+        }
+        // Linear interpolation for line segments
+        return {
+            x: segment.from.x + (segment.to.x - segment.from.x) * t,
+            y: segment.from.y + (segment.to.y - segment.from.y) * t,
+        };
+    }
+    // ========================================
+    // Phase 4: Advanced Path Calculations
+    // ========================================
+    /**
+     * Get path length (alias for getTotalLength for API consistency)
+     */
+    getLength() {
+        return this.getTotalLength();
+    }
+    /**
+     * Get tangent (direction vector) at position along path (0-1)
+     * Returns normalized direction vector
+     */
+    getTangentAt(t) {
+        if (this.segments.length === 0)
+            return null;
+        t = Math.max(0, Math.min(1, t));
+        // For direct path, tangent is constant
+        if (this.pathType === 'direct' && this.points.length >= 2) {
+            const from = this.points[0];
+            const to = this.points[this.points.length - 1];
+            const dx = to.x - from.x;
+            const dy = to.y - from.y;
+            const length = Math.sqrt(dx * dx + dy * dy);
+            return length > 0 ? { x: dx / length, y: dy / length } : { x: 1, y: 0 };
+        }
+        // Find segment at position t
+        const totalLength = this.getTotalLength();
+        const targetLength = totalLength * t;
+        let currentLength = 0;
+        for (const segment of this.segments) {
+            const segmentLength = this.getSegmentLength(segment);
+            if (currentLength + segmentLength >= targetLength) {
+                const segmentT = segmentLength > 0 ? (targetLength - currentLength) / segmentLength : 0;
+                return this.getTangentOnSegment(segment, segmentT);
+            }
+            currentLength += segmentLength;
+        }
+        // Fallback to last segment direction
+        const lastSegment = this.segments[this.segments.length - 1];
+        return lastSegment ? this.getTangentOnSegment(lastSegment, 1) : { x: 1, y: 0 };
+    }
+    /**
+     * Get tangent on a specific segment
+     */
+    getTangentOnSegment(segment, t) {
+        if (segment.type === 'curve' && segment.control1 && segment.control2) {
+            // Cubic bezier derivative
+            const mt = 1 - t;
+            const mt2 = mt * mt;
+            const t2 = t * t;
+            const dx = 3 * mt2 * (segment.control1.x - segment.from.x) +
+                6 * mt * t * (segment.control2.x - segment.control1.x) +
+                3 * t2 * (segment.to.x - segment.control2.x);
+            const dy = 3 * mt2 * (segment.control1.y - segment.from.y) +
+                6 * mt * t * (segment.control2.y - segment.control1.y) +
+                3 * t2 * (segment.to.y - segment.control2.y);
+            const length = Math.sqrt(dx * dx + dy * dy);
+            return length > 0 ? { x: dx / length, y: dy / length } : { x: 1, y: 0 };
+        }
+        // Linear segment
+        const dx = segment.to.x - segment.from.x;
+        const dy = segment.to.y - segment.from.y;
+        const length = Math.sqrt(dx * dx + dy * dy);
+        return length > 0 ? { x: dx / length, y: dy / length } : { x: 1, y: 0 };
+    }
+    /**
+     * Get normal (perpendicular vector) at position along path (0-1)
+     * Returns normalized perpendicular vector (90° counter-clockwise from tangent)
+     */
+    getNormalAt(t) {
+        const tangent = this.getTangentAt(t);
+        if (!tangent)
+            return null;
+        // Rotate tangent 90° counter-clockwise
+        return {
+            x: -tangent.y,
+            y: tangent.x,
+        };
+    }
+    /**
+     * Get closest point on path to a given point
+     * Returns the closest point, distance, and normalized position (t)
+     */
+    getClosestPoint(point) {
+        if (this.segments.length === 0) {
+            return null;
+        }
+        let closestPoint = null;
+        let minDistance = Infinity;
+        let closestT = 0;
+        let cumulativeLength = 0;
+        const totalLength = this.getTotalLength();
+        for (let i = 0; i < this.segments.length; i++) {
+            const segment = this.segments[i];
+            const segmentLength = this.getSegmentLength(segment);
+            // Sample points along segment to find closest
+            const samples = 20;
+            for (let j = 0; j <= samples; j++) {
+                const segmentT = j / samples;
+                const samplePoint = this.getPointOnSegment(segment, segmentT);
+                const dx = samplePoint.x - point.x;
+                const dy = samplePoint.y - point.y;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    closestPoint = samplePoint;
+                    // Calculate global t
+                    closestT = totalLength > 0 ? (cumulativeLength + segmentLength * segmentT) / totalLength : 0;
+                }
+            }
+            cumulativeLength += segmentLength;
+        }
+        if (!closestPoint) {
+            return null;
+        }
+        return {
+            point: closestPoint,
+            distance: minDistance,
+            t: closestT,
+        };
+    }
+    /**
+     * Get angle at position along path (0-1) in degrees
+     * Useful for label rotation
+     */
+    getAngleAt(t) {
+        const tangent = this.getTangentAt(t);
+        if (!tangent)
+            return null;
+        return (Math.atan2(tangent.y, tangent.x) * 180) / Math.PI;
+    }
+    /**
+     * Serialize to JSON
+     */
+    serialize() {
+        return Object.assign(Object.assign(Object.assign({ id: this.id, uuid: this.uuid, type: 'link', version: this.version, metadata: Object.fromEntries(this.metadata), sourcePortId: this.sourcePortId, targetPortId: this.targetPortId, sourceNodeId: this.sourceNodeId, targetNodeId: this.targetNodeId, pathType: this.pathType }, (this.router !== undefined ? { router: this.router } : {})), (this.connector !== undefined ? { connector: this.connector } : {})), { points: this.points.map((p) => (Object.assign({}, p))), segments: this.segments.map((s) => (Object.assign({}, s))), labels: this.labels.map((l) => (Object.assign({}, l))), state: this.state, style: Object.assign({}, this.style), data: Object.assign({}, this.data) });
+    }
+    /**
+     * Deserialize from JSON
+     */
+    static fromJSON(data) {
+        const link = new LinkModel(data.sourcePortId, data.targetPortId, data.pathType);
+        // Restore ID (no constructor param exists for it) and persisted
+        // identity/version via the sanctioned entity helper.
+        link.id = data.id;
+        link.restoreIdentity(data);
+        link.sourceNodeId = data.sourceNodeId;
+        link.targetNodeId = data.targetNodeId;
+        if (data.router !== undefined)
+            link.router = data.router;
+        if (data.connector !== undefined)
+            link.connector = data.connector;
+        link.points = data.points.map((p) => (Object.assign({}, p)));
+        link.segments = data.segments.map((s) => (Object.assign({}, s)));
+        link.labels = data.labels.map((l) => (Object.assign({}, l)));
+        link.state = data.state;
+        link.style = data.style;
+        link.data = data.data;
+        // Restore metadata
+        for (const [key, value] of Object.entries(data.metadata)) {
+            link.metadata.set(key, value);
+        }
+        return link;
+    }
+}
+exports.LinkModel = LinkModel;
+/**
+ * Wave 3 (Edges & links): the curve tightness of a smooth/bezier link.
+ *
+ * `style.curvature` is a multiplier of the endpoint distance for the
+ * control-point offset. It used to be DEAD (declared on LinkStyle, read by
+ * nobody); it is now the single knob both this model and the SVG renderer
+ * read, so a per-link value produces the same curve whichever produced the
+ * path. Default 0.5 = the historical hardcoded factor; negatives are clamped
+ * to 0 (a straight chord).
+ */
+LinkModel.DEFAULT_CURVATURE = 0.5;
+//# sourceMappingURL=LinkModel.js.map