@grafloria/element 0.3.20 → 0.3.21

package/src/libs/renderer/src/svg/edge-optimizer.js

@@ -1,606 +0,0 @@
-"use strict";
-/**
- * edge-optimizer.ts — Wave 4 (Edges & links), Card 7
- *
- * ONE incremental pass that owns every diagram-wide edge constraint:
- *
- *   • JUMP-OVERS  — which links cross which, recomputed only where geometry
- *                   actually moved.
- *   • LABELS      — where each edge label can sit without landing on a node,
- *                   another label, or a link (this is what finally makes
- *                   `LinkLabel.autoOffset` do something; see below).
- *   • BUNDLES     — the parallel-link groups from Card 4, kept in step as links
- *                   are added, removed and re-routed.
- *
- * WHAT IT REPLACES
- * ----------------
- * Jump detection used to run inside `renderLink`, once per link per frame,
- * against EVERY other link in the diagram:
- *
- *     detectIntersections({id, points}, allOtherLinks.map(...))   // per link!
- *
- * That is O(L²·S²) segment-pair tests on every single frame — even when nothing
- * moved at all, and even while the user is merely panning. Here it becomes a
- * uniform-grid broad phase plus a dirty set: a frame in which nothing changed
- * does ZERO segment tests, and dragging one node only re-tests the links whose
- * cells that node's links touch.
- *
- * LATENT BUG THIS FIXES: `LinkLabel.autoOffset` ("Auto-position to avoid
- * overlaps") has been declared on the model since Phase 4 and was read by
- * NOBODY — dead config, the same shape of bug as `LinkStyle.curvature` in
- * Wave 3. It is now the flag that opts a label into the placement search below.
- *
- * EXACTNESS: the intersections this produces are the same set the per-link
- * detector produced (same primitive, same endpoint-touch exclusion, same
- * detect-mode filtering) — the grid is a broad phase, not an approximation. A
- * label with `autoOffset` unset keeps its author-given offset untouched, so no
- * existing diagram moves.
- *
- * Framework-agnostic and model-agnostic: plain data in, plain data out.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EdgeOptimizer = void 0;
-exports.overlapArea = overlapArea;
-exports.segmentIntersectsRect = segmentIntersectsRect;
-const JumpPointDetector_1 = require("./JumpPointDetector");
-const DEFAULTS = {
-    cellSize: 120,
-    labelSearchSteps: 6,
-    labelStep: 14,
-    jumpOwnership: 'both',
-};
-/** Cost weights. Nodes hurt most, then labels, then link bodies. */
-const W_NODE = 10;
-const W_LABEL = 6;
-const W_LINK = 3;
-/** Gentle pull back toward the author's preferred offset — a tie-breaker, not a force. */
-const W_DRIFT = 0.05;
-class EdgeOptimizer {
-    constructor(options = {}) {
-        var _a, _b, _c, _d;
-        this.detector = new JumpPointDetector_1.JumpPointDetector();
-        // ---- incremental state ---------------------------------------------------
-        /** linkId → signature of its polyline + jump config. */
-        this.linkSig = new Map();
-        /** linkId → its polyline (kept so a removed link can be pulled out of the grid). */
-        this.linkPoints = new Map();
-        /** linkId → does it draw jumps at all (Card 5: ownership needs to know). */
-        this.linkDrawsJumps = new Map();
-        /** linkId → the grid cells it occupies. */
-        this.linkCells = new Map();
-        /** cell → link ids in it. */
-        this.grid = new Map();
-        /** linkId → cached jump intersections. */
-        this.jumpCache = new Map();
-        /** `${linkId}::${labelId}` → resolved offset. */
-        this.labelCache = new Map();
-        /** `${linkId}::${labelId}` → the box that offset produced (an obstacle for others). */
-        this.labelBoxes = new Map();
-        /** `${linkId}::${labelId}` → signature of the label's own inputs. */
-        this.labelSig = new Map();
-        /** nodeId → rect signature. */
-        this.nodeSig = new Map();
-        /** Live node rects (obstacles). */
-        this.nodes = [];
-        this._stats = emptyStats();
-        this.options = {
-            cellSize: (_a = options.cellSize) !== null && _a !== void 0 ? _a : DEFAULTS.cellSize,
-            labelSearchSteps: (_b = options.labelSearchSteps) !== null && _b !== void 0 ? _b : DEFAULTS.labelSearchSteps,
-            labelStep: (_c = options.labelStep) !== null && _c !== void 0 ? _c : DEFAULTS.labelStep,
-            jumpOwnership: (_d = options.jumpOwnership) !== null && _d !== void 0 ? _d : DEFAULTS.jumpOwnership,
-        };
-    }
-    get stats() {
-        return this._stats;
-    }
-    /**
-     * Run the pass for a frame. Cheap when little changed: a frame whose links and
-     * nodes all carry the same signatures as last time performs zero segment tests
-     * and zero label searches.
-     */
-    update(frame) {
-        var _a, _b, _c, _d, _e;
-        this._stats = emptyStats();
-        // ---- 1. what moved? ----------------------------------------------------
-        const dirty = new Set();
-        const seen = new Set();
-        /** Cells that are stale because a link entered or left them. */
-        const touchedCells = new Set();
-        for (const link of frame.links) {
-            seen.add(link.id);
-            const sig = linkSignature(link);
-            if (this.linkSig.get(link.id) === sig)
-                continue;
-            dirty.add(link.id);
-            // Its OLD cells are stale (it left them) …
-            for (const cell of (_a = this.linkCells.get(link.id)) !== null && _a !== void 0 ? _a : []) {
-                touchedCells.add(cell);
-                (_b = this.grid.get(cell)) === null || _b === void 0 ? void 0 : _b.delete(link.id);
-            }
-            // … and so are its new ones.
-            const cells = this.cellsForPolyline(link.points);
-            for (const cell of cells) {
-                touchedCells.add(cell);
-                let bucket = this.grid.get(cell);
-                if (!bucket) {
-                    bucket = new Set();
-                    this.grid.set(cell, bucket);
-                }
-                bucket.add(link.id);
-            }
-            this.linkSig.set(link.id, sig);
-            this.linkPoints.set(link.id, link.points);
-            this.linkDrawsJumps.set(link.id, !!link.jumps);
-            this.linkCells.set(link.id, cells);
-        }
-        // Links that disappeared: evict them from the grid and every cache.
-        for (const id of Array.from(this.linkSig.keys())) {
-            if (seen.has(id))
-                continue;
-            for (const cell of (_c = this.linkCells.get(id)) !== null && _c !== void 0 ? _c : []) {
-                touchedCells.add(cell);
-                (_d = this.grid.get(cell)) === null || _d === void 0 ? void 0 : _d.delete(id);
-            }
-            this.linkSig.delete(id);
-            this.linkPoints.delete(id);
-            this.linkDrawsJumps.delete(id);
-            this.linkCells.delete(id);
-            this.jumpCache.delete(id);
-            for (const key of Array.from(this.labelCache.keys())) {
-                if (key.startsWith(`${id}::`)) {
-                    this.labelCache.delete(key);
-                    this.labelBoxes.delete(key);
-                    this.labelSig.delete(key);
-                }
-            }
-        }
-        // Nodes are obstacles for labels only — they do not affect jumps.
-        const nodesChanged = this.syncNodes(frame.nodes);
-        this._stats.dirtyLinks = dirty.size;
-        // ---- 2. jumps: recompute the affected links only -----------------------
-        // "Affected" = a link that moved, OR a link sharing a cell with one that
-        // moved (its crossings may have appeared or vanished even though it sat
-        // perfectly still).
-        const affected = new Set(dirty);
-        if (touchedCells.size > 0) {
-            for (const cell of touchedCells) {
-                for (const id of (_e = this.grid.get(cell)) !== null && _e !== void 0 ? _e : [])
-                    affected.add(id);
-            }
-        }
-        for (const link of frame.links) {
-            if (!link.jumps) {
-                this.jumpCache.delete(link.id);
-                continue;
-            }
-            if (!affected.has(link.id) && this.jumpCache.has(link.id)) {
-                this._stats.jumpsReused++;
-                continue;
-            }
-            this.jumpCache.set(link.id, this.computeJumps(link));
-            this._stats.jumpsRecomputed++;
-        }
-        // ---- 3. labels: place the ones that opted in ---------------------------
-        this.placeLabels(frame, dirty, nodesChanged);
-    }
-    /**
-     * The crossings on this link, for the jump-point path builder. Empty when the
-     * link draws no jumps.
-     */
-    getJumps(linkId) {
-        var _a;
-        return (_a = this.jumpCache.get(linkId)) !== null && _a !== void 0 ? _a : [];
-    }
-    /**
-     * The offset this label should actually be drawn at. For a label that did not
-     * opt into `autoOffset` this is exactly the offset the author set.
-     */
-    getLabelOffset(linkId, labelId, fallback) {
-        var _a;
-        return (_a = this.labelCache.get(`${linkId}::${labelId}`)) !== null && _a !== void 0 ? _a : fallback;
-    }
-    /** Drop all state (renderer disposal, or a wholesale diagram swap). */
-    reset() {
-        this.linkSig.clear();
-        this.linkPoints.clear();
-        this.linkDrawsJumps.clear();
-        this.linkCells.clear();
-        this.grid.clear();
-        this.jumpCache.clear();
-        this.labelCache.clear();
-        this.labelBoxes.clear();
-        this.labelSig.clear();
-        this.nodeSig.clear();
-        this.nodes = [];
-        this._stats = emptyStats();
-    }
-    // =========================================================================
-    // jumps
-    // =========================================================================
-    /**
-     * Crossings between `link` and its grid neighbours.
-     *
-     * Same primitive and same rules as the old per-link path — the difference is
-     * only WHICH links are tested: the grid narrows the candidate set from "every
-     * link in the diagram" to "links sharing a cell with one of my segments".
-     */
-    /**
-     * Card 5: does `myId` own the crossing between MY segment (a→b) and the
-     * other link's segment (c→d)? Horizontal arcs over vertical — the classic
-     * drafting convention (an arc on a horizontal line reads as "this line jumps
-     * that one"; an arc on a vertical reads as a kink). Neither-or-both
-     * horizontal ties break on the smaller link id. Pure and symmetric: for any
-     * crossing exactly one of the two links returns true.
-     */
-    ownsCrossing(myId, a, b, c, d, otherId) {
-        const EPS = 1e-6;
-        const mineHorizontal = Math.abs(a.y - b.y) < EPS && Math.abs(a.x - b.x) > EPS;
-        const otherHorizontal = Math.abs(c.y - d.y) < EPS && Math.abs(c.x - d.x) > EPS;
-        if (mineHorizontal !== otherHorizontal)
-            return mineHorizontal;
-        return myId < otherId;
-    }
-    computeJumps(link) {
-        var _a;
-        const config = link.jumps;
-        if (!config || link.points.length < 2)
-            return [];
-        const out = [];
-        const mine = link.points;
-        for (let i = 0; i < mine.length - 1; i++) {
-            const a = mine[i];
-            const b = mine[i + 1];
-            // Candidates: everything sharing a cell with THIS segment.
-            const candidates = new Set();
-            for (const cell of this.cellsForSegment(a, b)) {
-                for (const id of (_a = this.grid.get(cell)) !== null && _a !== void 0 ? _a : []) {
-                    if (id !== link.id)
-                        candidates.add(id);
-                }
-            }
-            if (candidates.size === 0)
-                continue;
-            // Deterministic order → deterministic output, regardless of Set insertion
-            // order or how the grid happened to be built.
-            for (const otherId of Array.from(candidates).sort()) {
-                const other = this.linkPoints.get(otherId);
-                if (!other || other.length < 2)
-                    continue;
-                for (let j = 0; j < other.length - 1; j++) {
-                    this._stats.segmentTests++;
-                    const hit = this.detector.findIntersection({ start: a, end: b }, { start: other[j], end: other[j + 1] });
-                    if (!hit)
-                        continue;
-                    // Two links MEETING at a shared port touch but do not cross — never
-                    // draw a jump at a connection point. (Identical rule to the detector's.)
-                    const EPS = 1e-6;
-                    const touchesOwnEndpoint = (i === 0 && hit.t1 < EPS) || (i === mine.length - 2 && hit.t1 > 1 - EPS);
-                    const touchesOtherEndpoint = (j === 0 && hit.t2 < EPS) || (j === other.length - 2 && hit.t2 > 1 - EPS);
-                    if (touchesOwnEndpoint || touchesOtherEndpoint)
-                        continue;
-                    if (!includeByMode(hit.angle, config.mode, config.threshold))
-                        continue;
-                    // Card 5: consistent jumpovers. Under 'single' ownership a crossing
-                    // between two jump-drawing links belongs to exactly one of them.
-                    if (this.options.jumpOwnership === 'single' &&
-                        this.linkDrawsJumps.get(otherId) &&
-                        !this.ownsCrossing(link.id, a, b, other[j], other[j + 1], otherId)) {
-                        continue;
-                    }
-                    out.push(Object.assign(Object.assign({}, hit), { linkId: otherId, segmentIndex: i }));
-                }
-            }
-        }
-        return out;
-    }
-    // =========================================================================
-    // labels
-    // =========================================================================
-    syncNodes(nodes) {
-        let changed = nodes.length !== this.nodeSig.size;
-        const seen = new Set();
-        for (const node of nodes) {
-            seen.add(node.id);
-            const sig = `${node.rect.x},${node.rect.y},${node.rect.width},${node.rect.height}`;
-            if (this.nodeSig.get(node.id) !== sig) {
-                this.nodeSig.set(node.id, sig);
-                changed = true;
-            }
-        }
-        for (const id of Array.from(this.nodeSig.keys())) {
-            if (!seen.has(id)) {
-                this.nodeSig.delete(id);
-                changed = true;
-            }
-        }
-        this.nodes = nodes;
-        return changed;
-    }
-    /**
-     * Place every label that opted into `autoOffset`.
-     *
-     * Deterministic ORDER (link id, then label id) matters: labels placed earlier
-     * become obstacles for the ones placed later, so a stable order is what makes
-     * the result stable frame to frame. Labels that did not change and whose
-     * neighbourhood did not change keep their cached placement — this is the
-     * incremental half.
-     */
-    placeLabels(frame, dirtyLinks, nodesChanged) {
-        const ordered = frame.links
-            .filter(l => l.labels.length > 0)
-            .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-        // Retire cached boxes for labels that no longer exist, so a deleted label
-        // stops shoving its neighbours around.
-        const live = new Set();
-        for (const link of ordered) {
-            for (const label of link.labels)
-                live.add(`${link.id}::${label.id}`);
-        }
-        for (const key of Array.from(this.labelSig.keys())) {
-            if (!live.has(key)) {
-                this.labelSig.delete(key);
-                this.labelCache.delete(key);
-                this.labelBoxes.delete(key);
-            }
-        }
-        for (const link of ordered) {
-            for (const label of [...link.labels].sort((a, b) => (a.id < b.id ? -1 : 1))) {
-                const key = `${link.id}::${label.id}`;
-                // Not opted in: the author's offset is the answer, full stop. This is
-                // what keeps every pre-Wave-4 diagram's labels exactly where they were.
-                if (!label.autoOffset) {
-                    this.labelCache.set(key, Object.assign({}, label.offset));
-                    this.labelBoxes.set(key, boxAt(label.anchor, label.offset, label.width, label.height));
-                    this.labelSig.set(key, labelSignature(label));
-                    continue;
-                }
-                const sig = labelSignature(label);
-                const stale = this.labelSig.get(key) !== sig ||
-                    dirtyLinks.has(link.id) ||
-                    nodesChanged ||
-                    // A label near a link that moved has to be re-searched even if it did
-                    // not move itself — the thing it was avoiding may be gone, or a new
-                    // one may have arrived.
-                    this.nearDirty(this.labelBoxes.get(key), dirtyLinks);
-                if (!stale && this.labelCache.has(key)) {
-                    this._stats.labelsReused++;
-                    continue;
-                }
-                const placed = this.searchLabelOffset(link.id, label, key);
-                this.labelCache.set(key, placed);
-                this.labelBoxes.set(key, boxAt(label.anchor, placed, label.width, label.height));
-                this.labelSig.set(key, sig);
-                this._stats.labelsPlaced++;
-            }
-        }
-    }
-    /** Does this box sit in a cell touched by a link that moved? */
-    nearDirty(box, dirtyLinks) {
-        var _a;
-        if (!box || dirtyLinks.size === 0)
-            return false;
-        for (const cell of this.cellsForRect(box)) {
-            for (const id of (_a = this.grid.get(cell)) !== null && _a !== void 0 ? _a : []) {
-                if (dirtyLinks.has(id))
-                    return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Search outward from the author's offset for a placement that collides with
-     * as little as possible.
-     *
-     * Candidates are generated ALONG THE PATH NORMAL — the one axis on which a
-     * label can move without ceasing to describe its edge. The author's own offset
-     * is candidate zero and wins every tie, so an `autoOffset` label that already
-     * sits somewhere clear does not budge.
-     */
-    searchLabelOffset(linkId, label, key) {
-        const { labelSearchSteps, labelStep } = this.options;
-        let best = Object.assign({}, label.offset);
-        let bestCost = this.labelCost(linkId, label, best, key);
-        if (bestCost === 0)
-            return best;
-        for (let step = 1; step <= labelSearchSteps; step++) {
-            // Both directions at each ring, nearest ring first: the label ends up as
-            // close to where the author put it as the collisions allow.
-            for (const sign of [1, -1]) {
-                const candidate = {
-                    x: label.offset.x + label.normal.x * labelStep * step * sign,
-                    y: label.offset.y + label.normal.y * labelStep * step * sign,
-                };
-                const cost = this.labelCost(linkId, label, candidate, key);
-                if (cost < bestCost) {
-                    bestCost = cost;
-                    best = candidate;
-                    if (bestCost === 0)
-                        return best;
-                }
-            }
-        }
-        return best;
-    }
-    /**
-     * How bad is this placement? Overlap AREA (not a boolean) so the search
-     * degrades gracefully in a crowded diagram: when nothing is free, it still
-     * picks the least-covered spot rather than giving up on the first candidate.
-     */
-    labelCost(linkId, label, offset, key) {
-        var _a;
-        const box = boxAt(label.anchor, offset, label.width, label.height);
-        let cost = 0;
-        for (const node of this.nodes) {
-            cost += W_NODE * overlapArea(box, node.rect);
-        }
-        for (const [otherKey, otherBox] of this.labelBoxes) {
-            if (otherKey === key)
-                continue;
-            cost += W_LABEL * overlapArea(box, otherBox);
-        }
-        // Link bodies: only the ones sharing a cell with the box — this is the whole
-        // point of keeping the grid.
-        const near = new Set();
-        for (const cell of this.cellsForRect(box)) {
-            for (const id of (_a = this.grid.get(cell)) !== null && _a !== void 0 ? _a : [])
-                near.add(id);
-        }
-        for (const id of near) {
-            const pts = this.linkPoints.get(id);
-            if (!pts)
-                continue;
-            // A label is ALLOWED to sit on its own link — that is where labels live.
-            if (id === linkId)
-                continue;
-            for (let i = 0; i < pts.length - 1; i++) {
-                if (segmentIntersectsRect(pts[i], pts[i + 1], box)) {
-                    cost += W_LINK * label.height; // one link body crossing ≈ one row of text
-                }
-            }
-        }
-        cost += W_DRIFT * Math.hypot(offset.x - label.offset.x, offset.y - label.offset.y);
-        return cost;
-    }
-    // =========================================================================
-    // uniform grid
-    // =========================================================================
-    cellKey(cx, cy) {
-        return `${cx},${cy}`;
-    }
-    cellsForPolyline(points) {
-        if (!points || points.length < 2)
-            return [];
-        const cells = new Set();
-        for (let i = 0; i < points.length - 1; i++) {
-            for (const cell of this.cellsForSegment(points[i], points[i + 1])) {
-                cells.add(cell);
-            }
-        }
-        return Array.from(cells);
-    }
-    /**
-     * Cells a segment touches. Uses the segment's bounding box rather than a
-     * DDA walk: a diagonal segment over-reports a little, which costs a few extra
-     * narrow-phase tests and can never MISS a crossing — the safe direction.
-     */
-    cellsForSegment(a, b) {
-        return this.cellsForRect({
-            x: Math.min(a.x, b.x),
-            y: Math.min(a.y, b.y),
-            width: Math.abs(b.x - a.x),
-            height: Math.abs(b.y - a.y),
-        });
-    }
-    cellsForRect(rect) {
-        const size = this.options.cellSize;
-        const x0 = Math.floor(rect.x / size);
-        const y0 = Math.floor(rect.y / size);
-        const x1 = Math.floor((rect.x + rect.width) / size);
-        const y1 = Math.floor((rect.y + rect.height) / size);
-        const cells = [];
-        for (let cx = x0; cx <= x1; cx++) {
-            for (let cy = y0; cy <= y1; cy++) {
-                cells.push(this.cellKey(cx, cy));
-            }
-        }
-        return cells;
-    }
-}
-exports.EdgeOptimizer = EdgeOptimizer;
-// ===========================================================================
-// helpers
-// ===========================================================================
-function emptyStats() {
-    return {
-        dirtyLinks: 0,
-        jumpsRecomputed: 0,
-        jumpsReused: 0,
-        labelsPlaced: 0,
-        labelsReused: 0,
-        segmentTests: 0,
-    };
-}
-/** Rounded so sub-pixel jitter in a route does not count as "it moved". */
-function linkSignature(link) {
-    const pts = link.points.map(p => `${Math.round(p.x * 10)},${Math.round(p.y * 10)}`).join(';');
-    const jumps = link.jumps ? `${link.jumps.mode}:${link.jumps.threshold}` : '-';
-    return `${pts}|${jumps}`;
-}
-function labelSignature(label) {
-    return [
-        Math.round(label.anchor.x * 10),
-        Math.round(label.anchor.y * 10),
-        label.offset.x,
-        label.offset.y,
-        label.width,
-        label.height,
-        label.autoOffset ? 1 : 0,
-        Math.round(label.normal.x * 100),
-        Math.round(label.normal.y * 100),
-    ].join(',');
-}
-/** The label's box, centred on `anchor + offset`. */
-function boxAt(anchor, offset, width, height) {
-    return {
-        x: anchor.x + offset.x - width / 2,
-        y: anchor.y + offset.y - height / 2,
-        width,
-        height,
-    };
-}
-function overlapArea(a, b) {
-    const w = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
-    const h = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
-    return w > 0 && h > 0 ? w * h : 0;
-}
-/** Liang-Barsky: does the segment touch the rect at all? */
-function segmentIntersectsRect(a, b, rect) {
-    let t0 = 0;
-    let t1 = 1;
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const minX = rect.x;
-    const minY = rect.y;
-    const maxX = rect.x + rect.width;
-    const maxY = rect.y + rect.height;
-    const clip = (p, q) => {
-        if (p === 0)
-            return q >= 0;
-        const r = q / p;
-        if (p < 0) {
-            if (r > t1)
-                return false;
-            if (r > t0)
-                t0 = r;
-        }
-        else {
-            if (r < t0)
-                return false;
-            if (r < t1)
-                t1 = r;
-        }
-        return true;
-    };
-    return (clip(-dx, a.x - minX) &&
-        clip(dx, maxX - a.x) &&
-        clip(-dy, a.y - minY) &&
-        clip(dy, maxY - a.y) &&
-        t0 < t1);
-}
-/**
- * The detect-mode filter, lifted verbatim from JumpPointDetector so the two
- * cannot drift: 'perpendicular' is a fixed 75° cutoff, 'threshold' honours the
- * link's own angle, 'all' takes everything.
- */
-function includeByMode(angle, mode, threshold) {
-    switch (mode) {
-        case 'perpendicular':
-            return angle >= 75;
-        case 'threshold':
-            return angle >= threshold;
-        case 'all':
-        default:
-            return true;
-    }
-}
-//# sourceMappingURL=edge-optimizer.js.map