@konce-pt/roadmap 0.8.0

package/dist/layout.js

@@ -0,0 +1,306 @@
+/*
+ * Układ wierszy: normalizacja itemów, spłaszczenie grup do listy wierszy
+ * renderowalnych, przydział pasów przy nakładaniu się zadań i wirtualizacja.
+ *
+ * Offset pionowy (`top`) liczymy tutaj, dzięki czemu warstwa widoku pozycjonuje
+ * wiersze absolutnie, a wirtualizacja sprowadza się do wycięcia podlisty —
+ * bez elementów dystansowych i z obsługą wierszy o różnej wysokości.
+ */
+import { toTimestamp } from "./calendar.js";
+const DEFAULT_ITEM_HEIGHT = 44;
+const DEFAULT_GROUP_HEIGHT = 38;
+const DEFAULT_LANE_HEIGHT = 28;
+/**
+ * Normalizuje itemy: daty na ms, brak `end` oznacza kamień milowy.
+ * Odrzuca wpisy z nieparsowalną datą oraz duplikaty `id`.
+ */
+export function normalizeItems(items) {
+    const valid = [];
+    const invalid = [];
+    const seen = new Set();
+    for (const item of items) {
+        if (!item.id) {
+            invalid.push({ id: String(item.label ?? '?'), reason: 'brak id' });
+            continue;
+        }
+        if (seen.has(item.id)) {
+            invalid.push({ id: item.id, reason: 'zduplikowane id' });
+            continue;
+        }
+        const start = toTimestamp(item.start);
+        if (!Number.isFinite(start)) {
+            invalid.push({ id: item.id, reason: 'niepoprawna data początkowa' });
+            continue;
+        }
+        const rawEnd = item.end !== undefined ? toTimestamp(item.end) : start;
+        if (!Number.isFinite(rawEnd)) {
+            invalid.push({ id: item.id, reason: 'niepoprawna data końcowa' });
+            continue;
+        }
+        // Odwrócony zakres prostujemy zamiast odrzucać — dane bywają brudne.
+        const from = Math.min(start, rawEnd);
+        const to = Math.max(start, rawEnd);
+        const isMilestone = item.milestone === true || item.end === undefined || from === to;
+        seen.add(item.id);
+        valid.push({
+            source: item,
+            id: item.id,
+            start: from,
+            end: isMilestone ? from : to,
+            isMilestone,
+            durationMs: isMilestone ? 0 : to - from,
+        });
+    }
+    return { valid, invalid };
+}
+/** Zakres zbiorczy listy itemów: min(start)…max(end). */
+export function spanOf(items) {
+    if (items.length === 0)
+        return null;
+    let start = items[0].start;
+    let end = items[0].end;
+    for (const item of items) {
+        if (item.start < start)
+            start = item.start;
+        if (item.end > end)
+            end = item.end;
+    }
+    return { start, end };
+}
+/**
+ * Postęp grupy ważony czasem trwania.
+ * Kamienie milowe mają zerową długość, więc liczymy je z wagą 1.
+ */
+export function rollupProgress(items) {
+    let weightSum = 0;
+    let progressSum = 0;
+    let any = false;
+    for (const item of items) {
+        const progress = item.source.progress;
+        if (progress === undefined)
+            continue;
+        any = true;
+        const weight = item.isMilestone ? 1 : Math.max(1, item.durationMs);
+        weightSum += weight;
+        progressSum += weight * Math.min(1, Math.max(0, progress));
+    }
+    return any && weightSum > 0 ? progressSum / weightSum : null;
+}
+/**
+ * Zachłanne przydzielanie pasów (interval partitioning).
+ * Itemy sortujemy po czasie startu i wkładamy do pierwszego pasa, w którym
+ * poprzednie zadanie zdążyło się skończyć. Zwraca liczbę użytych pasów.
+ */
+export function packLanes(items, minGapMs = 0) {
+    const sorted = [...items].sort((a, b) => a.start - b.start || a.end - b.end);
+    /** Ostatni zajęty koniec dla każdego pasa. */
+    const laneEnd = [];
+    for (const item of sorted) {
+        const to = Math.max(item.end, item.start);
+        let lane = laneEnd.findIndex((end) => end + minGapMs <= item.start);
+        if (lane === -1) {
+            lane = laneEnd.length;
+            laneEnd.push(to);
+        }
+        else {
+            laneEnd[lane] = to;
+        }
+        item.lane = lane;
+    }
+    return Math.max(1, laneEnd.length);
+}
+/** Głębokość grupy w drzewie `parentId` (z zabezpieczeniem przed cyklem). */
+function groupDepth(group, byId) {
+    let depth = 0;
+    let current = group.parentId;
+    const guard = new Set([group.id]);
+    while (current && !guard.has(current)) {
+        guard.add(current);
+        depth++;
+        current = byId.get(current)?.parentId;
+    }
+    return depth;
+}
+/** Czy któryś z przodków grupy jest zwinięty? */
+function hasCollapsedAncestor(group, byId, collapsed) {
+    let current = group.parentId;
+    const guard = new Set([group.id]);
+    while (current && !guard.has(current)) {
+        if (collapsed.has(current))
+            return true;
+        guard.add(current);
+        current = byId.get(current)?.parentId;
+    }
+    return false;
+}
+/**
+ * Spłaszcza grupy i itemy do listy wierszy renderowalnych.
+ *
+ * Kolejność: grupy w kolejności podanej przez użytkownika, wewnątrz itemy
+ * posortowane po czasie startu, na końcu itemy bez `groupId`. Zwinięta grupa
+ * nie emituje wierszy potomnych, ale jej zakres zbiorczy nadal obejmuje dzieci.
+ *
+ * @param collapsed zbiór `id` grup zwiniętych (stan trzymany w sygnale komponentu)
+ */
+export function buildRows(items, groups, collapsed, opts) {
+    const mode = opts?.mode ?? 'row-per-item';
+    const itemHeight = opts?.itemHeight ?? DEFAULT_ITEM_HEIGHT;
+    const groupHeight = opts?.groupHeight ?? DEFAULT_GROUP_HEIGHT;
+    const laneHeight = opts?.laneHeight ?? DEFAULT_LANE_HEIGHT;
+    const minGap = opts?.packMinGapMs ?? 0;
+    const { valid, invalid } = normalizeItems(items);
+    const byId = new Map(valid.map((item) => [item.id, item]));
+    const rowOfItem = new Map();
+    const rows = [];
+    const groupList = groups ?? [];
+    const groupById = new Map(groupList.map((group) => [group.id, group]));
+    // Itemy w kubełkach wg grupy; nieznane `groupId` traktujemy jak brak grupy.
+    const buckets = new Map();
+    const ungrouped = [];
+    for (const item of valid) {
+        const groupId = item.source.groupId;
+        if (groupId && groupById.has(groupId)) {
+            const bucket = buckets.get(groupId);
+            if (bucket)
+                bucket.push(item);
+            else
+                buckets.set(groupId, [item]);
+        }
+        else {
+            ungrouped.push(item);
+        }
+    }
+    for (const bucket of buckets.values())
+        bucket.sort((a, b) => a.start - b.start || a.end - b.end);
+    ungrouped.sort((a, b) => a.start - b.start || a.end - b.end);
+    let top = 0;
+    /** Dokłada wiersze itemów — jeden na item albo jeden spakowany. */
+    const pushItemRows = (bucket, depth, keyPrefix) => {
+        if (bucket.length === 0)
+            return;
+        if (mode === 'pack') {
+            const rowKey = `${keyPrefix}:pack`;
+            const placed = bucket.map((item) => ({ ...item, lane: 0, rowKey }));
+            const laneCount = packLanes(placed, minGap);
+            const height = Math.max(itemHeight, laneCount * laneHeight + 8);
+            for (const item of placed)
+                rowOfItem.set(item.id, rowKey);
+            rows.push({
+                key: rowKey,
+                kind: 'item',
+                index: rows.length,
+                depth,
+                top,
+                height,
+                laneCount,
+                items: placed,
+            });
+            top += height;
+            return;
+        }
+        for (const item of bucket) {
+            const rowKey = `item:${item.id}`;
+            rowOfItem.set(item.id, rowKey);
+            rows.push({
+                key: rowKey,
+                kind: 'item',
+                index: rows.length,
+                depth,
+                top,
+                height: itemHeight,
+                laneCount: 1,
+                items: [{ ...item, lane: 0, rowKey }],
+            });
+            top += itemHeight;
+        }
+    };
+    for (const group of groupList) {
+        // Grupa pod zwiniętym przodkiem w ogóle się nie renderuje.
+        if (hasCollapsedAncestor(group, groupById, collapsed))
+            continue;
+        const bucket = buckets.get(group.id) ?? [];
+        const depth = groupDepth(group, groupById);
+        const isCollapsed = collapsed.has(group.id);
+        const rowKey = `group:${group.id}`;
+        rows.push({
+            key: rowKey,
+            kind: 'group',
+            index: rows.length,
+            depth,
+            top,
+            height: groupHeight,
+            laneCount: 1,
+            group,
+            groupState: {
+                collapsed: isCollapsed,
+                itemCount: bucket.length,
+                // Pasek zbiorczy obejmuje dzieci również wtedy, gdy grupa jest zwinięta.
+                span: group.summary === 'none' ? null : spanOf(bucket),
+                progress: rollupProgress(bucket),
+            },
+            items: [],
+        });
+        top += groupHeight;
+        if (!isCollapsed)
+            pushItemRows(bucket, depth + 1, `group:${group.id}`);
+    }
+    if (ungrouped.length > 0) {
+        if (opts?.showUngroupedHeader) {
+            const rowKey = 'group:__ungrouped';
+            const isCollapsed = collapsed.has('__ungrouped');
+            rows.push({
+                key: rowKey,
+                kind: 'group',
+                index: rows.length,
+                depth: 0,
+                top,
+                height: groupHeight,
+                laneCount: 1,
+                group: { id: '__ungrouped', label: opts.ungroupedLabel ?? '' },
+                groupState: {
+                    collapsed: isCollapsed,
+                    itemCount: ungrouped.length,
+                    span: spanOf(ungrouped),
+                    progress: rollupProgress(ungrouped),
+                },
+                items: [],
+            });
+            top += groupHeight;
+            if (!isCollapsed)
+                pushItemRows(ungrouped, 1, 'ungrouped');
+        }
+        else {
+            pushItemRows(ungrouped, 0, 'ungrouped');
+        }
+    }
+    return { rows, totalHeight: top, byId, rowOfItem, invalid };
+}
+/** Indeks pierwszego wiersza sięgającego pozycji `y` (binary search po `top`). */
+function firstRowAt(rows, y) {
+    let lo = 0;
+    let hi = rows.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (rows[mid].top + rows[mid].height <= y)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+/**
+ * Wycinek wierszy widocznych w oknie przewijania.
+ * Szuka binarnie po skumulowanym `top`, więc działa także dla wierszy
+ * o różnej wysokości (tryb 'pack').
+ */
+export function sliceRows(layout, scrollTop, viewportHeight, buffer = 4) {
+    const all = layout.rows;
+    if (all.length === 0 || viewportHeight <= 0) {
+        return { rows: all, startIndex: 0, endIndex: all.length };
+    }
+    const first = firstRowAt(all, Math.max(0, scrollTop));
+    const last = firstRowAt(all, Math.max(0, scrollTop + viewportHeight));
+    const startIndex = Math.max(0, first - buffer);
+    const endIndex = Math.min(all.length, last + buffer + 1);
+    return { rows: all.slice(startIndex, endIndex), startIndex, endIndex };
+}

package/dist/links.d.ts

@@ -0,0 +1,45 @@
+import type { KptRoadmapDependencyOptions, KptRoadmapLink, KptRoadmapLinkType, KptRoadmapNormalizedItem, KptRoadmapPoint, KptRoadmapRect, KptRoadmapVariant } from './types.ts';
+/** Pasek w układzie px overlaya wraz z czasem — czas służy do detekcji naruszeń. */
+export interface KptLinkEndpoint {
+    id: string;
+    rect: KptRoadmapRect;
+    startTs: number;
+    endTs: number;
+}
+export interface KptLinkGeom {
+    key: string;
+    from: string;
+    to: string;
+    type: KptRoadmapLinkType;
+    /** Ścieżka `d` łamanej z zaokrąglonymi narożnikami. */
+    path: string;
+    /** Ścieżka grotu strzałki (trójkąt domknięty przez `Z`). */
+    arrow: string;
+    variant?: KptRoadmapVariant;
+    color?: string;
+    /** Następnik startuje wcześniej, niż pozwala zależność (z uwzględnieniem `lag`). */
+    isViolated: boolean;
+}
+/**
+ * Scala zależności z `item.dependsOn` (skrót oznacza typ 'FS' bez lagu)
+ * z listą `config.links`, odrzuca krawędzie wiszące i wykrywa cykle.
+ */
+export declare function resolveLinks(items: readonly KptRoadmapNormalizedItem[], links: readonly KptRoadmapLink[] | undefined): {
+    links: KptRoadmapLink[];
+    cycles: string[][];
+};
+/**
+ * Łamana ortogonalna z zaokrąglonymi narożnikami.
+ * Narożnik rysujemy krzywą kwadratową — dla kąta prostego wygląda jak łuk,
+ * a ścieżka jest o połowę krótsza. Promień przycinamy do połowy krótszego
+ * z sąsiednich odcinków, żeby ciasne zakręty nie tworzyły pętli.
+ */
+export declare function roundedPolyline(points: readonly KptRoadmapPoint[], radius: number): string;
+/** Grot strzałki w punkcie `point`, skierowany zgodnie z `direction`. */
+export declare function arrowHead(point: KptRoadmapPoint, direction: 'left' | 'right', size: number): string;
+/**
+ * Geometria pojedynczej zależności.
+ * Zwraca `null`, gdy któryś koniec nie jest widoczny (zwinięta grupa albo
+ * wiersz poza oknem wirtualizacji).
+ */
+export declare function linkGeometry(link: KptRoadmapLink, source: KptLinkEndpoint | undefined, target: KptLinkEndpoint | undefined, opts?: KptRoadmapDependencyOptions): KptLinkGeom | null;

package/dist/links.js

@@ -0,0 +1,249 @@
+/*
+ * Geometria zależności między paskami — warstwa SVG nad torami.
+ *
+ * Overlay pracuje w pikselach, nie w procentach: zaokrąglenie narożnika wymaga
+ * tych samych jednostek na obu osiach, inaczej łuki byłyby zniekształcone.
+ */
+import { svgNum } from "./scale.js";
+const DEFAULT_STUB = 12;
+const DEFAULT_CORNER = 6;
+const DEFAULT_ARROW = 6;
+/** Stabilny klucz krawędzi — pozwala pominąć duplikaty i służy jako trackBy. */
+function linkKey(link) {
+    return link.id ?? `${link.from}→${link.to}:${link.type ?? 'FS'}`;
+}
+/**
+ * Scala zależności z `item.dependsOn` (skrót oznacza typ 'FS' bez lagu)
+ * z listą `config.links`, odrzuca krawędzie wiszące i wykrywa cykle.
+ */
+export function resolveLinks(items, links) {
+    const known = new Set(items.map((item) => item.id));
+    const merged = new Map();
+    const add = (link) => {
+        if (!known.has(link.from) || !known.has(link.to) || link.from === link.to)
+            return;
+        const key = linkKey(link);
+        if (!merged.has(key))
+            merged.set(key, link);
+    };
+    for (const item of items) {
+        for (const dependency of item.source.dependsOn ?? []) {
+            if (typeof dependency === 'string')
+                add({ from: dependency, to: item.id, type: 'FS' });
+            else
+                add(dependency);
+        }
+    }
+    for (const link of links ?? [])
+        add(link);
+    return { links: [...merged.values()], cycles: findCycles([...merged.values()]) };
+}
+/** Wykrywa cykle w grafie zależności (DFS z kolorowaniem wierzchołków). */
+function findCycles(links) {
+    const adjacency = new Map();
+    for (const link of links) {
+        const list = adjacency.get(link.from);
+        if (list)
+            list.push(link.to);
+        else
+            adjacency.set(link.from, [link.to]);
+    }
+    const cycles = [];
+    const state = new Map();
+    const stack = [];
+    const visit = (node) => {
+        const current = state.get(node);
+        if (current === 'done')
+            return;
+        if (current === 'visiting') {
+            const from = stack.lastIndexOf(node);
+            if (from !== -1)
+                cycles.push(stack.slice(from));
+            return;
+        }
+        state.set(node, 'visiting');
+        stack.push(node);
+        for (const next of adjacency.get(node) ?? [])
+            visit(next);
+        stack.pop();
+        state.set(node, 'done');
+    };
+    for (const node of adjacency.keys())
+        visit(node);
+    return cycles;
+}
+/** Czy zależność jest naruszona? Liczone w ms, nie w pikselach. */
+function violates(link, source, target) {
+    const lag = link.lag ?? 0;
+    switch (link.type ?? 'FS') {
+        case 'FS':
+            return target.startTs < source.endTs + lag;
+        case 'SS':
+            return target.startTs < source.startTs + lag;
+        case 'FF':
+            return target.endTs < source.endTs + lag;
+        case 'SF':
+            return target.endTs < source.startTs + lag;
+    }
+}
+/** Usuwa punkty pokrywające się i leżące na jednej prostej z sąsiadami. */
+function dedupeCollinear(points) {
+    const result = [];
+    for (const point of points) {
+        const last = result.at(-1);
+        if (last && Math.abs(last.x - point.x) < 1e-6 && Math.abs(last.y - point.y) < 1e-6)
+            continue;
+        result.push(point);
+    }
+    for (let i = result.length - 2; i >= 1; i--) {
+        const previous = result[i - 1];
+        const current = result[i];
+        const next = result[i + 1];
+        const collinearX = Math.abs(previous.x - current.x) < 1e-6 && Math.abs(current.x - next.x) < 1e-6;
+        const collinearY = Math.abs(previous.y - current.y) < 1e-6 && Math.abs(current.y - next.y) < 1e-6;
+        if (collinearX || collinearY)
+            result.splice(i, 1);
+    }
+    return result;
+}
+/**
+ * Łamana ortogonalna z zaokrąglonymi narożnikami.
+ * Narożnik rysujemy krzywą kwadratową — dla kąta prostego wygląda jak łuk,
+ * a ścieżka jest o połowę krótsza. Promień przycinamy do połowy krótszego
+ * z sąsiednich odcinków, żeby ciasne zakręty nie tworzyły pętli.
+ */
+export function roundedPolyline(points, radius) {
+    const path = dedupeCollinear(points);
+    if (path.length < 2)
+        return '';
+    const parts = [`M ${svgNum(path[0].x)} ${svgNum(path[0].y)}`];
+    for (let i = 1; i < path.length - 1; i++) {
+        const previous = path[i - 1];
+        const current = path[i];
+        const next = path[i + 1];
+        const lengthIn = Math.hypot(current.x - previous.x, current.y - previous.y);
+        const lengthOut = Math.hypot(next.x - current.x, next.y - current.y);
+        const r = Math.max(0, Math.min(radius, lengthIn / 2, lengthOut / 2));
+        if (r === 0 || lengthIn === 0 || lengthOut === 0) {
+            parts.push(`L ${svgNum(current.x)} ${svgNum(current.y)}`);
+            continue;
+        }
+        const enter = {
+            x: current.x + ((previous.x - current.x) / lengthIn) * r,
+            y: current.y + ((previous.y - current.y) / lengthIn) * r,
+        };
+        const leave = {
+            x: current.x + ((next.x - current.x) / lengthOut) * r,
+            y: current.y + ((next.y - current.y) / lengthOut) * r,
+        };
+        parts.push(`L ${svgNum(enter.x)} ${svgNum(enter.y)}`, `Q ${svgNum(current.x)} ${svgNum(current.y)} ${svgNum(leave.x)} ${svgNum(leave.y)}`);
+    }
+    const last = path.at(-1);
+    parts.push(`L ${svgNum(last.x)} ${svgNum(last.y)}`);
+    return parts.join(' ');
+}
+/** Grot strzałki w punkcie `point`, skierowany zgodnie z `direction`. */
+export function arrowHead(point, direction, size) {
+    const sign = direction === 'right' ? 1 : -1;
+    const baseX = point.x - sign * size;
+    return [
+        `M ${svgNum(point.x)} ${svgNum(point.y)}`,
+        `L ${svgNum(baseX)} ${svgNum(point.y - size / 2)}`,
+        `L ${svgNum(baseX)} ${svgNum(point.y + size / 2)}`,
+        'Z',
+    ].join(' ');
+}
+/** Kotwica wyjścia/wejścia zależnie od typu: -1 = lewa krawędź, 1 = prawa. */
+function anchors(type) {
+    switch (type) {
+        case 'FS':
+            return { out: 1, in: -1 };
+        case 'SS':
+            return { out: -1, in: -1 };
+        case 'FF':
+            return { out: 1, in: 1 };
+        case 'SF':
+            return { out: -1, in: 1 };
+    }
+}
+function edgePoint(rect, side) {
+    return { x: side === 1 ? rect.x + rect.width : rect.x, y: rect.y + rect.height / 2 };
+}
+/**
+ * Trasa łamanej między dwoma kotwicami.
+ *
+ * Konwencja kierunków: `outDir` i `inDir` wskazują stronę paska (-1 = lewa
+ * krawędź, +1 = prawa), więc odsunięcie „na zewnątrz" to zawsze `x + dir * stub`.
+ *
+ * Gdy cel leży za końcem źródła, wystarczy prosty schodek: pion wypada między
+ * paskami. W przeciwnym razie trzeba je obejść poziomym objazdem prowadzonym
+ * w połowie odstępu między wierszami.
+ */
+function route(out, outDir, anchor, endPoint, inDir, stub, detourGap) {
+    const afterOut = out.x + outDir * stub;
+    const beforeIn = endPoint.x + inDir * stub;
+    if (outDir === inDir) {
+        // SS / FF — obie kotwice po tej samej stronie pasków. Wspólny pion musi ominąć
+        // oba paski, więc bierzemy punkt najdalej wysunięty w kierunku wyjścia;
+        // inaczej trasa schowałaby się pod paskiem, z którego wychodzi.
+        const middle = outDir === -1 ? Math.min(afterOut, beforeIn) : Math.max(afterOut, beforeIn);
+        return [out, { x: middle, y: out.y }, { x: middle, y: endPoint.y }, endPoint];
+    }
+    // FS / SF — kotwice po przeciwnych stronach. Prosty schodek ma sens tylko wtedy,
+    // gdy między paskami zostaje miejsce na czytelny pion. Zapas liczymy względem
+    // rzeczywistej krawędzi celu (`anchor`), a nie skróconego o grot końca trzonu.
+    // Warunek `room >= 0` jest równoważny „odstęp >= 2 * stub", więc próg zawijasa
+    // wynika wprost z geometrii i nie wymaga osobnej stałej.
+    const room = (anchor.x + inDir * stub - afterOut) * (inDir === -1 ? 1 : -1);
+    if (room >= 0) {
+        const lo = Math.min(afterOut, beforeIn);
+        const hi = Math.max(afterOut, beforeIn);
+        const middle = Math.min(hi, Math.max(lo, (out.x + endPoint.x) / 2));
+        return [out, { x: middle, y: out.y }, { x: middle, y: endPoint.y }, endPoint];
+    }
+    // Paski stykają się albo cel cofa się względem źródła — prowadzimy trasę wokół,
+    // przez odstęp między wierszami.
+    const detourY = Math.abs(endPoint.y - out.y) < 1e-6 ? out.y + detourGap : (out.y + endPoint.y) / 2;
+    return [
+        out,
+        { x: afterOut, y: out.y },
+        { x: afterOut, y: detourY },
+        { x: beforeIn, y: detourY },
+        { x: beforeIn, y: endPoint.y },
+        endPoint,
+    ];
+}
+/**
+ * Geometria pojedynczej zależności.
+ * Zwraca `null`, gdy któryś koniec nie jest widoczny (zwinięta grupa albo
+ * wiersz poza oknem wirtualizacji).
+ */
+export function linkGeometry(link, source, target, opts) {
+    if (!source || !target)
+        return null;
+    const type = link.type ?? 'FS';
+    const stub = opts?.stub ?? DEFAULT_STUB;
+    const corner = opts?.cornerRadius ?? DEFAULT_CORNER;
+    const arrowSize = opts?.arrowSize ?? DEFAULT_ARROW;
+    const side = anchors(type);
+    const from = edgePoint(source.rect, side.out);
+    const to = edgePoint(target.rect, side.in);
+    // Grot dosuwamy do krawędzi paska, więc trzon kończy się tuż przed nim —
+    // czyli o długość grotu na zewnątrz celu.
+    const tip = to;
+    const shaftEnd = { x: to.x + side.in * arrowSize, y: to.y };
+    const detourGap = Math.max(source.rect.height, target.rect.height);
+    const points = route(from, side.out, to, shaftEnd, side.in, stub, detourGap);
+    const highlight = opts?.highlightViolations ?? true;
+    return {
+        key: linkKey(link),
+        from: link.from,
+        to: link.to,
+        type,
+        path: roundedPolyline(points, corner),
+        arrow: arrowHead(tip, side.in === -1 ? 'right' : 'left', arrowSize),
+        variant: link.variant,
+        color: link.color,
+        isViolated: highlight ? violates(link, source, target) : false,
+    };
+}

package/dist/scale.d.ts

@@ -0,0 +1,11 @@
+/** Zakres [min, max] tablicy liczb (0..0 dla pustej). */
+export declare function extent(values: readonly number[]): [number, number];
+/** Interpolacja liniowa domeny → zakresu (np. czas → udział 0..1). */
+export declare function linearScale(domainMin: number, domainMax: number, rangeMin: number, rangeMax: number): (value: number) => number;
+/** Ogranicza wartość do przedziału [min, max]. */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Skraca liczbę na potrzeby atrybutu `d` ścieżki SVG.
+ * Odpowiednik prywatnego `n()` z `charts/src/core/bar.ts` — trzyma ścieżki krótkie.
+ */
+export declare function svgNum(value: number): string;

package/dist/scale.js

@@ -0,0 +1,42 @@
+/*
+ * Skalowanie liniowe i pomocniki liczbowe.
+ *
+ * `linearScale` i `extent` są celowo zduplikowane z `charts/src/core/scale.ts`
+ * (ten sam kontrakt): import między subpathami tworzyłby twardą zależność
+ * `roadmap → charts` dla kilkunastu linii kodu.
+ */
+/** Zakres [min, max] tablicy liczb (0..0 dla pustej). */
+export function extent(values) {
+    if (values.length === 0)
+        return [0, 0];
+    let min = values[0];
+    let max = values[0];
+    for (const v of values) {
+        if (v < min)
+            min = v;
+        if (v > max)
+            max = v;
+    }
+    return [min, max];
+}
+/** Interpolacja liniowa domeny → zakresu (np. czas → udział 0..1). */
+export function linearScale(domainMin, domainMax, rangeMin, rangeMax) {
+    const dSpan = domainMax - domainMin || 1;
+    const rSpan = rangeMax - rangeMin;
+    return (value) => rangeMin + ((value - domainMin) / dSpan) * rSpan;
+}
+/** Ogranicza wartość do przedziału [min, max]. */
+export function clamp(value, min, max) {
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+/**
+ * Skraca liczbę na potrzeby atrybutu `d` ścieżki SVG.
+ * Odpowiednik prywatnego `n()` z `charts/src/core/bar.ts` — trzyma ścieżki krótkie.
+ */
+export function svgNum(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(3);
+}