@grafloria/element 0.3.20 → 0.3.22

package/src/libs/renderer/src/svg/channel-nudging.js

@@ -1,226 +0,0 @@
-"use strict";
-// Wave 5 (Edge routing) — Card 4: parallel-edge nudging / channel routing.
-//
-// Wave 4's fan-out separates links of the SAME node pair. This pass separates
-// the other kind of stack: edges of DIFFERENT pairs whose orthogonal segments
-// share a corridor — coincident (or near-coincident) collinear runs that today
-// draw on top of each other and read as one line.
-//
-// Scope is deliberately tight, because this runs inside the render loop:
-//
-//   • Only segments closer than `trigger` px cluster (default 4): the pass
-//     separates what is VISUALLY ON TOP of each other, and leaves deliberate
-//     16px-apart parallel runs (e.g. wave-4 fanned bundles) alone.
-//   • Only INTERIOR orthogonal segments move. Port stubs never move — the
-//     Card 1 jetty guarantee outranks lane separation.
-//   • A member whose slide would shrink or REVERSE an adjacent segment is
-//     PINNED (its lane is wherever it already is) and the ladder shifts to
-//     accommodate it; two conflicting pinned members abort the cluster.
-//
-// Card 5 preview — lane ORDER inside a corridor is chosen by each member's
-// EXIT barycentre (where its route continues on the perpendicular axis), so
-// members leave the corridor on the side they entered it for: corridor-mates
-// stop crossing each other at the corridor mouth. Deterministic tie-break by
-// link id.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeChannelNudges = computeChannelNudges;
-exports.applyChannelNudges = applyChannelNudges;
-const EPS = 1e-6;
-/**
- * Compute lane deltas for every corridor in the frame.
- *
- * `routes` are the frame's routed polylines (post same-pair fan-out); only
- * links present in the map participate. The caller applies the deltas by
- * sliding each segment along its normal — both endpoints move, the
- * perpendicular neighbours stretch, orthogonality is preserved.
- */
-function computeChannelNudges(routes, options) {
-    const members = [];
-    for (const [linkId, pts] of routes) {
-        if (pts.length < 2)
-            continue;
-        for (let i = 0; i < pts.length - 1; i++) {
-            const a = pts[i];
-            const b = pts[i + 1];
-            const horizontal = Math.abs(a.y - b.y) < EPS && Math.abs(a.x - b.x) > EPS;
-            const vertical = Math.abs(a.x - b.x) < EPS && Math.abs(a.y - b.y) > EPS;
-            if (!horizontal && !vertical)
-                continue; // diagonal: not corridor material
-            const axis = horizontal ? 'h' : 'v';
-            const ord = horizontal ? a.y : a.x;
-            const lo = horizontal ? Math.min(a.x, b.x) : Math.min(a.y, b.y);
-            const hi = horizontal ? Math.max(a.x, b.x) : Math.max(a.y, b.y);
-            // Port stubs (first/last segment) never move: the jetty guarantee wins.
-            const isStub = i === 0 || i === pts.length - 2;
-            // Slide slack: an adjacent perpendicular segment of length L tolerates a
-            // slide of up to L−1 toward its own far end before it reverses.
-            const slack = { minus: Infinity, plus: Infinity };
-            const clampBy = (fixedOrd) => {
-                // neighbour runs from `ord` to `fixedOrd` on the ordinate axis
-                const len = fixedOrd - ord;
-                if (len > EPS) {
-                    // neighbour extends toward +: sliding + shrinks it
-                    slack.plus = Math.min(slack.plus, len - 1);
-                }
-                else if (len < -EPS) {
-                    slack.minus = Math.min(slack.minus, -len - 1);
-                }
-                else {
-                    // zero-length neighbour: any slide reverses it
-                    slack.plus = Math.min(slack.plus, 0);
-                    slack.minus = Math.min(slack.minus, 0);
-                }
-            };
-            if (i > 0) {
-                const prev = pts[i - 1];
-                clampBy(horizontal ? prev.y : prev.x);
-            }
-            if (i + 2 < pts.length) {
-                const next = pts[i + 2];
-                clampBy(horizontal ? next.y : next.x);
-            }
-            // Exit barycentre: where this link's route sits on the ordinate axis just
-            // outside the corridor — the crossing-minimizing lane-order key.
-            const exits = [];
-            if (i > 0)
-                exits.push(horizontal ? pts[i - 1].y : pts[i - 1].x);
-            if (i + 2 < pts.length)
-                exits.push(horizontal ? pts[i + 2].y : pts[i + 2].x);
-            const exitKey = exits.length ? exits.reduce((s, v) => s + v, 0) / exits.length : ord;
-            members.push({
-                linkId,
-                segIndex: i,
-                axis,
-                ord,
-                lo,
-                hi,
-                exitKey,
-                pinned: isStub,
-                slack,
-            });
-        }
-    }
-    // ---- cluster: same axis, ords within trigger, spans overlapping ----------
-    const result = {
-        deltas: new Map(),
-        clustersNudged: 0,
-        clustersSkipped: 0,
-    };
-    for (const axis of ['h', 'v']) {
-        const pool = members.filter((m) => m.axis === axis).sort((a, b) => a.ord - b.ord || (a.linkId < b.linkId ? -1 : 1));
-        const used = new Array(pool.length).fill(false);
-        for (let i = 0; i < pool.length; i++) {
-            if (used[i])
-                continue;
-            const cluster = [pool[i]];
-            used[i] = true;
-            // grow while the next ord is within trigger of ANY member and spans overlap
-            let grown = true;
-            while (grown) {
-                grown = false;
-                for (let j = 0; j < pool.length; j++) {
-                    if (used[j])
-                        continue;
-                    const c = pool[j];
-                    const near = cluster.some((m) => Math.abs(m.ord - c.ord) <= options.trigger && Math.min(m.hi, c.hi) - Math.max(m.lo, c.lo) > EPS);
-                    if (near) {
-                        cluster.push(c);
-                        used[j] = true;
-                        grown = true;
-                    }
-                }
-            }
-            // one link's own segments never nudge against themselves; a corridor is
-            // only a corridor with ≥2 DISTINCT links
-            const distinct = new Set(cluster.map((m) => m.linkId));
-            if (cluster.length < 2 || distinct.size < 2)
-                continue;
-            // ---- lane order: exit barycentre, tie-broken by link id ---------------
-            cluster.sort((a, b) => a.exitKey - b.exitKey || (a.linkId < b.linkId ? -1 : 1) || a.segIndex - b.segIndex);
-            const n = cluster.length;
-            const centre = cluster.reduce((s, m) => s + m.ord, 0) / n;
-            // target ordinates: centre + (idx − (n−1)/2)·spacing, then shifted so any
-            // pinned member lands exactly where it already is
-            const base = (idx) => centre + (idx - (n - 1) / 2) * options.spacing;
-            const pinnedMembers = cluster
-                .map((m, idx) => ({ m, idx }))
-                .filter(({ m }) => m.pinned);
-            let shift = 0;
-            if (pinnedMembers.length === 1) {
-                const { m, idx } = pinnedMembers[0];
-                shift = m.ord - base(idx);
-            }
-            else if (pinnedMembers.length > 1) {
-                // Two immovable members: satisfiable only if the ladder already fits
-                // both — check the first two; anything else aborts the corridor.
-                const [p0, p1] = pinnedMembers;
-                const s0 = p0.m.ord - base(p0.idx);
-                const s1 = p1.m.ord - base(p1.idx);
-                if (Math.abs(s0 - s1) > EPS) {
-                    result.clustersSkipped++;
-                    continue;
-                }
-                shift = s0;
-            }
-            // ---- slack check: every movable member must tolerate its delta ---------
-            const plan = [];
-            let feasible = true;
-            cluster.forEach((m, idx) => {
-                const delta = base(idx) + shift - m.ord;
-                if (Math.abs(delta) < EPS)
-                    return;
-                if (m.pinned) {
-                    feasible = false; // a pinned member was asked to move
-                    return;
-                }
-                if (delta > 0 && delta > m.slack.plus)
-                    feasible = false;
-                if (delta < 0 && -delta > m.slack.minus)
-                    feasible = false;
-                plan.push({ m, delta });
-            });
-            if (!feasible) {
-                result.clustersSkipped++;
-                continue;
-            }
-            if (plan.length === 0)
-                continue;
-            for (const { m, delta } of plan) {
-                let perLink = result.deltas.get(m.linkId);
-                if (!perLink) {
-                    perLink = new Map();
-                    result.deltas.set(m.linkId, perLink);
-                }
-                perLink.set(m.segIndex, delta);
-            }
-            result.clustersNudged++;
-        }
-    }
-    return result;
-}
-/**
- * Apply a link's segment deltas to its polyline: each nudged segment's BOTH
- * endpoints move along the ordinate axis, the perpendicular neighbours stretch.
- * Returns a new array; the input is not mutated.
- */
-function applyChannelNudges(points, deltas) {
-    const out = points.map((p) => (Object.assign({}, p)));
-    if (!deltas || deltas.size === 0)
-        return out;
-    for (const [segIndex, delta] of deltas) {
-        const a = out[segIndex];
-        const b = out[segIndex + 1];
-        if (!a || !b)
-            continue;
-        if (Math.abs(a.y - b.y) < EPS) {
-            a.y += delta;
-            b.y += delta;
-        }
-        else if (Math.abs(a.x - b.x) < EPS) {
-            a.x += delta;
-            b.x += delta;
-        }
-    }
-    return out;
-}
-//# sourceMappingURL=channel-nudging.js.map

package/src/libs/renderer/src/svg/edge-optimizer.d.ts

@@ -1,228 +0,0 @@
-/**
- * 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.
- */
-import type { Point } from '@grafloria/engine';
-import { type Intersection, type DetectionMode } from './JumpPointDetector';
-export interface OptimizerRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** A node, as far as the optimizer cares: an obstacle with an id. */
-export interface OptimizerNode {
-    id: string;
-    rect: OptimizerRect;
-}
-/** A label awaiting placement. */
-export interface OptimizerLabel {
-    id: string;
-    /** On-path anchor the label hangs off (world). */
-    anchor: Point;
-    /** The offset the AUTHOR asked for — the preferred placement, and the fallback. */
-    offset: Point;
-    /** Box size used for collision tests. */
-    width: number;
-    height: number;
-    /** Opt-in to the collision search. Off ⇒ `offset` is returned verbatim. */
-    autoOffset: boolean;
-    /** Unit normal of the path at `anchor` — the axis the search pushes along. */
-    normal: Point;
-}
-export interface OptimizerLink {
-    id: string;
-    /** The ROUTED polyline for this frame (post parallel-separation / self-loop). */
-    points: Point[];
-    /** Jump config, if this link draws jumps at all. */
-    jumps?: {
-        mode: DetectionMode;
-        threshold: number;
-    };
-    labels: OptimizerLabel[];
-}
-export interface OptimizerFrame {
-    nodes: OptimizerNode[];
-    links: OptimizerLink[];
-}
-export interface EdgeOptimizerOptions {
-    /**
-     * Wave 5 (Edge routing) — Card 5. Who draws the arc when two jump-drawing
-     * links cross:
-     *   'both'   — legacy: each link bridges the other (a double bridge).
-     *   'single' — exactly ONE deterministic owner per intersection: the link
-     *              whose crossing segment is HORIZONTAL arcs over the vertical
-     *              (the classic drafting convention); when neither or both are
-     *              horizontal, the smaller link id owns. A crossing with a link
-     *              that draws no jumps at all is always kept — someone must
-     *              bridge it.
-     * Default 'both', because wave-4's regression contract pins the optimizer's
-     * crossings byte-identical to the legacy detector.
-     */
-    jumpOwnership?: 'both' | 'single';
-    /**
-     * Uniform-grid cell size (world px) for the link broad phase. Should be on the
-     * order of a typical node — too small and long links occupy hundreds of cells,
-     * too large and the broad phase stops filtering.
-     */
-    cellSize?: number;
-    /** How far out the label search pushes, in steps of `labelStep`. */
-    labelSearchSteps?: number;
-    /** Distance between successive label candidates (px). */
-    labelStep?: number;
-}
-/** Per-frame work counters — the incrementality is only real if these are 0 on a quiet frame. */
-export interface OptimizerStats {
-    /** Links whose geometry changed this frame. */
-    dirtyLinks: number;
-    /** Links whose jump set was recomputed (dirty ones + their grid neighbours). */
-    jumpsRecomputed: number;
-    /** Links that served their jump set from cache. */
-    jumpsReused: number;
-    /** Labels whose placement was searched. */
-    labelsPlaced: number;
-    /** Labels served from cache. */
-    labelsReused: number;
-    /** Segment-pair intersection tests actually performed. */
-    segmentTests: number;
-}
-export declare class EdgeOptimizer {
-    private readonly detector;
-    private readonly options;
-    /** linkId → signature of its polyline + jump config. */
-    private linkSig;
-    /** linkId → its polyline (kept so a removed link can be pulled out of the grid). */
-    private linkPoints;
-    /** linkId → does it draw jumps at all (Card 5: ownership needs to know). */
-    private linkDrawsJumps;
-    /** linkId → the grid cells it occupies. */
-    private linkCells;
-    /** cell → link ids in it. */
-    private grid;
-    /** linkId → cached jump intersections. */
-    private jumpCache;
-    /** `${linkId}::${labelId}` → resolved offset. */
-    private labelCache;
-    /** `${linkId}::${labelId}` → the box that offset produced (an obstacle for others). */
-    private labelBoxes;
-    /** `${linkId}::${labelId}` → signature of the label's own inputs. */
-    private labelSig;
-    /** nodeId → rect signature. */
-    private nodeSig;
-    /** Live node rects (obstacles). */
-    private nodes;
-    private _stats;
-    constructor(options?: EdgeOptimizerOptions);
-    get stats(): Readonly<OptimizerStats>;
-    /**
-     * 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: OptimizerFrame): void;
-    /**
-     * The crossings on this link, for the jump-point path builder. Empty when the
-     * link draws no jumps.
-     */
-    getJumps(linkId: string): Intersection[];
-    /**
-     * 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: string, labelId: string, fallback: Point): Point;
-    /** Drop all state (renderer disposal, or a wholesale diagram swap). */
-    reset(): void;
-    /**
-     * 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.
-     */
-    private ownsCrossing;
-    private computeJumps;
-    private syncNodes;
-    /**
-     * 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.
-     */
-    private placeLabels;
-    /** Does this box sit in a cell touched by a link that moved? */
-    private nearDirty;
-    /**
-     * 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.
-     */
-    private searchLabelOffset;
-    /**
-     * 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.
-     */
-    private labelCost;
-    private cellKey;
-    private cellsForPolyline;
-    /**
-     * 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.
-     */
-    private cellsForSegment;
-    private cellsForRect;
-}
-export declare function overlapArea(a: OptimizerRect, b: OptimizerRect): number;
-/** Liang-Barsky: does the segment touch the rect at all? */
-export declare function segmentIntersectsRect(a: Point, b: Point, rect: OptimizerRect): boolean;