@grafloria/element 0.3.19 → 0.3.21

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

@@ -1,1045 +0,0 @@
-"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