@konce-pt/angular 0.6.1 → 0.7.5

package/fesm2022/konce-pt-angular-roadmap.mjs

@@ -0,0 +1,1919 @@
+import * as i0 from '@angular/core';
+import { inject, input, booleanAttribute, model, linkedSignal, computed, output, viewChild, signal, afterRenderEffect, ViewEncapsulation, ChangeDetectionStrategy, Component } from '@angular/core';
+import { KptI18n, KptTooltip } from '@konce-pt/angular';
+
+/*
+ * Arytmetyka kalendarzowa w czasie LOKALNYM, odporna na zmianę czasu (DST).
+ *
+ * Roadmapa jest narzędziem planistycznym — użytkownik myśli zegarem ściennym,
+ * więc wszystkie obliczenia idą po lokalnych polach daty.
+ *
+ * ZASADA: nigdy nie dodajemy milisekund. `t + 86_400_000` na 2026-03-29 00:00 CET
+ * daje 2026-03-30 01:00 (dryf kumulatywny), a na 2026-10-25 daje tę samą datę
+ * dwa razy. Zamiast tego iterujemy po polach `Date` (`setDate`, `setHours`),
+ * bo one normalizują wynik do lokalnego zegara ściennego.
+ *
+ * Wszystkie różnice dni/tygodni liczymy przez `Math.round`, nigdy `floor`/`ceil`:
+ * doba DST to 0.958 albo 1.042 doby, a `round` te odchyłki pochłania.
+ */
+const MS_DAY = 86_400_000;
+const MS_WEEK = 604_800_000;
+const MS_HOUR = 3_600_000;
+/** Normalizuje dowolne wejście daty do epoch ms. Zwraca NaN dla wartości nieparsowalnych. */
+function toTimestamp(value) {
+    if (typeof value === 'number')
+        return value;
+    if (value instanceof Date)
+        return value.getTime();
+    return new Date(value).getTime();
+}
+/** Kopia obiektu Date — nigdy nie mutujemy argumentów. */
+function clone(date) {
+    return new Date(date);
+}
+/**
+ * Początek lokalnej doby.
+ *
+ * Guard: w strefach, gdzie przejście DST wypada o północy (np. America/Santiago),
+ * `setHours(0, …)` potrafi wylądować w dobie poprzedniej — wtedy korygujemy
+ * o jedną dobę w przód.
+ */
+function startOfDay(date) {
+    const result = clone(date);
+    result.setHours(0, 0, 0, 0);
+    if (result.getDate() !== date.getDate() || result.getMonth() !== date.getMonth()) {
+        result.setTime(date.getTime());
+        result.setHours(0, 0, 0, 0);
+        if (result.getTime() < date.getTime() - MS_DAY)
+            result.setDate(result.getDate() + 1);
+    }
+    return result;
+}
+/** Dodaje `n` dób kalendarzowych, zachowując godzinę ścienną (DST-safe). */
+function addDays(date, n) {
+    const result = clone(date);
+    result.setDate(result.getDate() + n);
+    return result;
+}
+/** Dodaje `n` godzin ściennych. Godzina nieistniejąca (wiosna) normalizuje się w przód. */
+function addHours(date, n) {
+    const result = clone(date);
+    result.setHours(result.getHours() + n);
+    return result;
+}
+/** Liczba dni w miesiącu (`month` 0-indeksowany). */
+function daysInMonth(year, month) {
+    return new Date(year, month + 1, 0).getDate();
+}
+/** Dodaje `n` miesięcy z przycięciem dnia (31 stycznia + 1 miesiąc = 28/29 lutego). */
+function addMonths(date, n) {
+    const result = clone(date);
+    const day = result.getDate();
+    result.setDate(1);
+    result.setMonth(result.getMonth() + n);
+    result.setDate(Math.min(day, daysInMonth(result.getFullYear(), result.getMonth())));
+    return result;
+}
+/**
+ * Różnica w pełnych dobach kalendarzowych.
+ * `Math.round` jest konieczny: doba DST ma 23 h (0.958) albo 25 h (1.042),
+ * więc `Math.floor` gubiłby jeden dzień dwa razy w roku.
+ */
+function diffDays(a, b) {
+    return Math.round((startOfDay(b).getTime() - startOfDay(a).getTime()) / MS_DAY);
+}
+/** Czy obie daty wypadają w tej samej lokalnej dobie? */
+function isSameDay(a, b) {
+    return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+// ──────────────────────────────────────────────────────────────────── ISO 8601
+/**
+ * Dzień tygodnia wg ISO 8601: 1 = poniedziałek … 7 = niedziela.
+ * `Date#getDay()` zwraca 0 dla niedzieli, stąd przesunięcie.
+ */
+function isoWeekday(date) {
+    return ((date.getDay() + 6) % 7) + 1;
+}
+/** Poniedziałek tygodnia ISO zawierającego `date` (początek doby). */
+function startOfIsoWeek(date) {
+    const day = startOfDay(date);
+    return startOfDay(addDays(day, -(isoWeekday(day) - 1)));
+}
+/**
+ * Czwartek tygodnia ISO zawierającego `date`.
+ *
+ * Czwartek jest kotwicą ISO: rok czwartka to rok tygodnia, a odległość między
+ * czwartkami dwóch tygodni to zawsze dokładnie N tygodni.
+ */
+function isoThursday(date) {
+    const day = startOfDay(date);
+    return startOfDay(addDays(day, 4 - isoWeekday(day)));
+}
+/**
+ * Rok tygodnia ISO 8601 — bywa różny od `getFullYear()` na przełomie roku.
+ * Przykłady: 2025-12-29 → 2026 (tydzień 1), 2027-01-03 → 2026 (tydzień 53).
+ */
+function isoWeekYear(date) {
+    return isoThursday(date).getFullYear();
+}
+/**
+ * Numer tygodnia ISO 8601 (1..53).
+ * Tydzień zaczyna się w poniedziałek, a tydzień 1 to ten, który zawiera pierwszy
+ * czwartek roku (równoważnie: zawiera 4 stycznia).
+ *
+ * `Math.round` jest tu krytyczny: przy DST różnica dwóch północy to 7 dni ±1 h
+ * (6.994 / 7.006), więc `Math.floor` zaniżałby numer tygodnia przez pół roku.
+ */
+function isoWeekNumber(date) {
+    const thursday = isoThursday(date);
+    const jan4 = new Date(thursday.getFullYear(), 0, 4);
+    const firstThursday = isoThursday(jan4);
+    return 1 + Math.round((thursday.getTime() - firstThursday.getTime()) / MS_WEEK);
+}
+/** Liczba tygodni ISO w danym roku tygodniowym (52 albo 53). */
+function isoWeeksInYear(weekYear) {
+    // 28 grudnia zawsze leży w ostatnim tygodniu ISO danego roku.
+    return isoWeekNumber(new Date(weekYear, 11, 28));
+}
+// ─────────────────────────────────────────────────── zaokrąglanie do jednostki
+/** Początek jednostki zoomu zawierającej `date` (w dół). */
+function floorToUnit(date, zoom) {
+    const result = clone(date);
+    switch (zoom) {
+        case 'hour':
+            result.setMinutes(0, 0, 0);
+            return result;
+        case 'day':
+            return startOfDay(result);
+        case 'week':
+            return startOfIsoWeek(result);
+        case 'month':
+            result.setDate(1);
+            return startOfDay(result);
+        case 'quarter':
+            result.setMonth(Math.floor(result.getMonth() / 3) * 3, 1);
+            return startOfDay(result);
+        case 'year':
+            result.setMonth(0, 1);
+            return startOfDay(result);
+    }
+}
+/** Dodaje `n` jednostek zoomu (DST-safe — po polach daty, nie po ms). */
+function addUnits(date, zoom, n) {
+    switch (zoom) {
+        case 'hour':
+            return addHours(date, n);
+        case 'day':
+            return addDays(date, n);
+        case 'week':
+            return addDays(date, n * 7);
+        case 'month':
+            return addMonths(date, n);
+        case 'quarter':
+            return addMonths(date, n * 3);
+        case 'year':
+            return addMonths(date, n * 12);
+    }
+}
+/** Początek następnej jednostki zoomu; bez zmian, gdy `date` już leży na granicy. */
+function ceilToUnit(date, zoom) {
+    const floored = floorToUnit(date, zoom);
+    if (floored.getTime() === date.getTime())
+        return floored;
+    return addUnits(floored, zoom, 1);
+}
+/**
+ * Liczba pełnych jednostek zoomu między dwiema granicami (DST-safe).
+ * Dla 'hour' liczymy wprost po ms — doba DST po prostu ma 23 albo 25 godzin
+ * i tyle właśnie powinno powstać kolumn.
+ */
+function countUnits(start, end, zoom) {
+    switch (zoom) {
+        case 'hour':
+            return Math.round((end.getTime() - start.getTime()) / MS_HOUR);
+        case 'day':
+            return diffDays(start, end);
+        case 'week':
+            return Math.round(diffDays(start, end) / 7);
+        case 'month':
+            return (end.getFullYear() - start.getFullYear()) * 12 + (end.getMonth() - start.getMonth());
+        case 'quarter':
+            return Math.round(((end.getFullYear() - start.getFullYear()) * 12 + (end.getMonth() - start.getMonth())) / 3);
+        case 'year':
+            return end.getFullYear() - start.getFullYear();
+    }
+}
+/** Numer kwartału (1..4) dla danej daty. */
+function quarterOf(date) {
+    return Math.floor(date.getMonth() / 3) + 1;
+}
+
+/*
+ * 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). */
+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). */
+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]. */
+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.
+ */
+function svgNum(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(3);
+}
+
+/*
+ * Wyznaczanie zakresu osi czasu z danych.
+ *
+ * Krańce zawsze wyrównujemy na zewnątrz do granicy jednostki zoomu, żeby
+ * pierwsza i ostatnia kolumna nie były ucięte w połowie.
+ */
+/** Margines po obu stronach danych, w jednostkach zoomu. */
+const DEFAULT_PAD = {
+    hour: 2,
+    day: 2,
+    week: 1,
+    month: 1,
+    quarter: 1,
+    year: 0,
+};
+/** Minimalna szerokość osi, w jednostkach zoomu — żeby jeden item nie dał jednej kolumny. */
+const DEFAULT_MIN = {
+    hour: 12,
+    day: 14,
+    week: 8,
+    month: 6,
+    quarter: 4,
+    year: 3,
+};
+/** Zbiera skrajne wartości czasu z itemów, pomijając wpisy z niepoprawną datą. */
+function collectBounds(items) {
+    const bounds = [];
+    for (const item of items) {
+        const start = toTimestamp(item.start);
+        if (!Number.isFinite(start))
+            continue;
+        const end = item.end !== undefined ? toTimestamp(item.end) : start;
+        bounds.push(start, Number.isFinite(end) ? end : start);
+    }
+    return bounds;
+}
+/**
+ * Zakres osi wyliczony z danych: min(start)…max(end) powiększony o margines
+ * i wyrównany do granic jednostki zoomu.
+ * Dla pustej listy zwraca okno wokół „dziś" o szerokości `minUnits`.
+ */
+function autoRange(items, opts) {
+    const { zoom } = opts;
+    const pad = opts.padUnits ?? DEFAULT_PAD[zoom];
+    const minUnits = opts.minUnits ?? DEFAULT_MIN[zoom];
+    const todayTs = opts.today ?? Date.now();
+    const bounds = collectBounds(items);
+    if ((opts.includeToday ?? true) && bounds.length > 0)
+        bounds.push(todayTs);
+    const [min, max] = bounds.length > 0 ? extent(bounds) : [todayTs, todayTs];
+    // Margines dodajemy po polach daty (DST-safe), nie przez arytmetykę na ms.
+    let start = floorToUnit(addUnits(new Date(min), zoom, -pad), zoom);
+    let end = ceilToUnit(addUnits(new Date(max), zoom, pad), zoom);
+    // Dociągnięcie do minimalnej szerokości — symetrycznie, zaczynając od prawej.
+    let units = countUnits(start, end, zoom);
+    while (units < minUnits) {
+        end = addUnits(end, zoom, 1);
+        units++;
+        if (units < minUnits) {
+            start = addUnits(start, zoom, -1);
+            units++;
+        }
+    }
+    return { start: start.getTime(), end: end.getTime() };
+}
+/**
+ * Ostateczny zakres osi. `config.range` ma priorytet, a brakujący kraniec
+ * uzupełniamy z `autoRange`. Wynik zawsze leży na granicach jednostki zoomu.
+ */
+function resolveRange(config, items) {
+    const zoom = config.zoom ?? 'week';
+    const todaySource = config.today ?? config.timeline?.today;
+    const today = todaySource !== undefined ? toTimestamp(todaySource) : Date.now();
+    // `KptRoadmapNormalizedItem` niesie oryginał w `source` — sprowadzamy oba kształty
+    // do postaci akceptowanej przez `autoRange`.
+    const raw = items.map((item) => ('source' in item ? item.source : item));
+    const auto = autoRange(raw, { zoom, today });
+    const startTs = config.range?.start ?? auto.start;
+    const endTs = config.range?.end ?? auto.end;
+    const start = floorToUnit(new Date(startTs), zoom);
+    let end = ceilToUnit(new Date(endTs), zoom);
+    // Zakres musi obejmować co najmniej jedną kolumnę.
+    if (end.getTime() <= start.getTime())
+        end = addUnits(start, zoom, 1);
+    return { start: start.getTime(), end: end.getTime() };
+}
+
+/*
+ * 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.
+ */
+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`.
+ */
+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). */
+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.
+ */
+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.
+ */
+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)
+ */
+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').
+ */
+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 };
+}
+
+/*
+ * 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.
+ */
+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.
+ */
+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.
+ */
+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`. */
+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).
+ */
+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,
+    };
+}
+
+/*
+ * Model osi czasu: kolumny dolnego poziomu nagłówka, pasma górnego poziomu
+ * oraz skala czas ↔ pozycja.
+ *
+ * Skala domyślna ('uniform') odwzorowuje czas odcinkami: każda kolumna ma równą
+ * szerokość, a wewnątrz niej interpolujemy liniowo po ms. Dzięki temu doba po
+ * zmianie czasu (23/25 h) i luty nie są węższe od sąsiadów, a skala pozostaje
+ * ciągła i monotoniczna — zadanie może zaczynać się w środku dnia.
+ */
+/** Domyślna jednostka górnego poziomu nagłówka dla danego zoomu. */
+const DEFAULT_BAND = {
+    hour: 'day',
+    day: 'week',
+    week: 'month',
+    month: 'quarter',
+    quarter: 'year',
+    year: 'none',
+};
+const DEFAULT_MAX_CELLS = 4000;
+const DEFAULT_WEEKEND = [0, 6];
+function resolveOptions(zoom, opts) {
+    const workHours = opts?.workHours;
+    return {
+        locale: opts?.locale,
+        todayTs: opts?.today !== undefined ? toTimestamp(opts.today) : Date.now(),
+        weekendDays: opts?.weekendDays ?? DEFAULT_WEEKEND,
+        // Okno godzin roboczych ma sens tylko przy kolumnach godzinowych.
+        workHours: zoom === 'hour' && workHours
+            ? {
+                from: workHours.from,
+                to: workHours.to,
+                mode: workHours.mode ?? 'skip',
+                skipWeekends: workHours.skipWeekends ?? true,
+            }
+            : null,
+        bandUnit: opts?.bandUnit ?? DEFAULT_BAND[zoom],
+        positionMode: opts?.positionMode ?? 'uniform',
+        weekPrefix: opts?.weekPrefix ?? 'W',
+        maxCells: opts?.maxCells ?? DEFAULT_MAX_CELLS,
+    };
+}
+function makeFormatters(locale) {
+    return {
+        dayNum: new Intl.DateTimeFormat(locale, { day: 'numeric' }),
+        weekdayShort: new Intl.DateTimeFormat(locale, { weekday: 'short' }),
+        dayMonth: new Intl.DateTimeFormat(locale, { day: '2-digit', month: '2-digit' }),
+        monthLong: new Intl.DateTimeFormat(locale, { month: 'long' }),
+        monthShort: new Intl.DateTimeFormat(locale, { month: 'short' }),
+        dayLong: new Intl.DateTimeFormat(locale, { weekday: 'long', day: 'numeric', month: 'long', year: 'numeric' }),
+        hour: new Intl.DateTimeFormat(locale, { hour: '2-digit', minute: '2-digit', hour12: false }),
+    };
+}
+function isWeekendDay(date, o) {
+    return o.weekendDays.includes(date.getDay());
+}
+/** Czy dana godzina mieści się w oknie roboczym (i poza weekendem, gdy tak ustawiono)? */
+function isWorkingSlot(date, o) {
+    const wh = o.workHours;
+    if (!wh)
+        return true;
+    if (wh.skipWeekends && isWeekendDay(date, o))
+        return false;
+    const hour = date.getHours();
+    return hour >= wh.from && hour < wh.to;
+}
+/**
+ * Kotwica przypisania kolumny do pasma.
+ * Dla tygodnia bierzemy czwartek — tak samo jak ISO wyznacza rok tygodnia,
+ * więc tydzień na przełomie miesiąca trafia do miesiąca swojego czwartku.
+ */
+function bandAnchor(cellStart, zoom) {
+    if (zoom !== 'week')
+        return cellStart;
+    const anchor = new Date(cellStart);
+    anchor.setDate(anchor.getDate() + 3);
+    return anchor;
+}
+/**
+ * Wielka pierwsza litera. `Intl` zwraca nazwy zgodne z ortografią języka — po polsku,
+ * francusku czy czesku miesiące i dni tygodnia pisze się małą literą, po angielsku
+ * i niemiecku wielką. Na osi czasu i w podpowiedziach chcemy jednolitego wyglądu
+ * niezależnie od języka, więc podnosimy wyłącznie pierwszy znak; reszta zostaje bez
+ * zmian, żeby „wtorek, 15 września 2026" nie stało się „Wtorek, 15 Września 2026".
+ */
+function capitalizeFirst(text) {
+    if (!text)
+        return text;
+    const first = text.charAt(0);
+    const upper = first.toLocaleUpperCase();
+    // `toLocaleUpperCase` bywa dłuższe niż źródło (np. niemieckie ß → SS) — wtedy
+    // zostawiamy oryginał, bo zamiana zmieniłaby długość i wygląd etykiety.
+    return upper.length === first.length ? upper + text.slice(1) : text;
+}
+function cellLabels(start, zoom, o, f) {
+    switch (zoom) {
+        case 'hour':
+            return {
+                label: f.hour.format(start),
+                title: capitalizeFirst(`${f.dayLong.format(start)}, ${f.hour.format(start)}`),
+            };
+        case 'day':
+            return {
+                label: f.dayNum.format(start),
+                sublabel: capitalizeFirst(f.weekdayShort.format(start)),
+                title: capitalizeFirst(f.dayLong.format(start)),
+            };
+        case 'week': {
+            // Podpis to prawdziwy zakres dat tygodnia: poniedziałek – niedziela.
+            const sunday = new Date(start);
+            sunday.setDate(sunday.getDate() + 6);
+            const range = `${f.dayMonth.format(start)}–${f.dayMonth.format(sunday)}`;
+            return {
+                label: `${o.weekPrefix}${isoWeekNumber(start)}`,
+                sublabel: range,
+                title: `${o.weekPrefix}${isoWeekNumber(start)} ${isoWeekYear(start)} · ${range}`,
+            };
+        }
+        case 'month':
+            return {
+                label: capitalizeFirst(f.monthShort.format(start)),
+                title: capitalizeFirst(`${f.monthLong.format(start)} ${start.getFullYear()}`),
+            };
+        case 'quarter':
+            return { label: `Q${quarterOf(start)}`, title: `Q${quarterOf(start)} ${start.getFullYear()}` };
+        case 'year':
+            return { label: String(start.getFullYear()), title: String(start.getFullYear()) };
+    }
+}
+function bandLabels(start, unit, f) {
+    switch (unit) {
+        case 'hour':
+            return { label: f.hour.format(start) };
+        case 'day':
+            return { label: capitalizeFirst(f.dayLong.format(start)) };
+        case 'week':
+            return { label: `W${isoWeekNumber(start)}`, sublabel: capitalizeFirst(f.monthLong.format(start)) };
+        case 'month':
+            return { label: capitalizeFirst(f.monthLong.format(start)), sublabel: String(start.getFullYear()) };
+        case 'quarter':
+            return { label: `Q${quarterOf(start)}`, sublabel: String(start.getFullYear()) };
+        case 'year':
+            return { label: String(start.getFullYear()) };
+    }
+}
+/**
+ * Rok kolumny użyty do wykrycia granicy roku.
+ * Przy zoomie tygodniowym musi to być rok tygodnia ISO — inaczej W53/2026
+ * (28.12.2026) dostałaby błędnie znacznik „2027".
+ */
+function yearOfCell(date, zoom) {
+    return zoom === 'week' ? isoWeekYear(date) : date.getFullYear();
+}
+/**
+ * Początek następnej kolumny albo `null`, gdy kursor nie potrafi się już posunąć.
+ * DST wiosną przy zoomie godzinowym: 02:00 nie istnieje, więc `setHours`
+ * normalizuje na 03:00 i zwykły krok mógłby nie wyprzedzić `cursor` — wtedy
+ * przeskakujemy o dwie godziny.
+ */
+function nextBoundary(cursor, zoom) {
+    const next = addUnits(cursor, zoom, 1);
+    if (next.getTime() > cursor.getTime())
+        return next;
+    const jumped = addHours(cursor, 2);
+    return jumped.getTime() > cursor.getTime() ? jumped : null;
+}
+/**
+ * Czy kolumna obejmuje „dziś"? Dla jednostek grubszych niż tydzień akceptujemy
+ * dodatkowo zgodność samej daty — `todayTs` bywa znormalizowane do północy.
+ */
+function isTodayCell(cursor, next, zoom, o, today) {
+    const withinSpan = o.todayTs >= cursor.getTime() && o.todayTs < next.getTime();
+    if (zoom === 'hour' || zoom === 'day' || zoom === 'week')
+        return withinSpan;
+    return withinSpan || isSameDay(cursor, today);
+}
+/** Flagi wyglądu kolumny: tło weekendu/godzin niepracujących i granice okresów. */
+function cellDecorations(cursor, zoom, o) {
+    const isDayGrid = zoom === 'day' || zoom === 'hour';
+    return {
+        isWeekend: isDayGrid && isWeekendDay(cursor, o),
+        isNonWorking: o.workHours?.mode === 'dim' && !isWorkingSlot(cursor, o),
+        isMonthBoundary: isDayGrid && cursor.getDate() === 1,
+        isQuarterBoundary: (zoom === 'month' || zoom === 'quarter') && cursor.getMonth() % 3 === 0,
+    };
+}
+function buildCells(range, zoom, o, f) {
+    const cells = [];
+    const today = new Date(o.todayTs);
+    // Startujemy od granicy jednostki — inaczej pierwsza kolumna byłaby ucięta.
+    let cursor = floorToUnit(new Date(range.start), zoom);
+    let pendingGap = false;
+    let previousYear = null;
+    let guard = 0;
+    while (cursor.getTime() < range.end && guard++ < o.maxCells) {
+        const next = nextBoundary(cursor, zoom);
+        if (next === null)
+            break;
+        if (o.workHours?.mode === 'skip' && !isWorkingSlot(cursor, o)) {
+            pendingGap = true;
+            cursor = next;
+            continue;
+        }
+        const year = yearOfCell(cursor, zoom);
+        const labels = cellLabels(cursor, zoom, o, f);
+        cells.push({
+            index: cells.length,
+            key: String(cursor.getTime()),
+            start: cursor.getTime(),
+            end: next.getTime(),
+            label: labels.label,
+            sublabel: labels.sublabel,
+            title: labels.title,
+            ratioStart: 0,
+            ratioEnd: 0,
+            isToday: isTodayCell(cursor, next, zoom, o, today),
+            ...cellDecorations(cursor, zoom, o),
+            isYearBoundary: previousYear !== null && year !== previousYear,
+            hasGapBefore: pendingGap,
+        });
+        pendingGap = false;
+        previousYear = year;
+        cursor = next;
+    }
+    return cells;
+}
+function applyRatios(cells, mode, range) {
+    const count = cells.length;
+    if (count === 0)
+        return;
+    if (mode === 'uniform') {
+        const step = 1 / count;
+        for (const cell of cells) {
+            cell.ratioStart = cell.index * step;
+            cell.ratioEnd = (cell.index + 1) * step;
+        }
+        return;
+    }
+    const scale = linearScale(range.start, range.end, 0, 1);
+    for (const cell of cells) {
+        cell.ratioStart = clamp(scale(cell.start), 0, 1);
+        cell.ratioEnd = clamp(scale(cell.end), 0, 1);
+    }
+}
+/** Indeks kolumny zawierającej `ts`, albo pierwszej kolumny po `ts`. */
+function findCell(cells, ts) {
+    let lo = 0;
+    let hi = cells.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (ts >= cells[mid].end)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+function buildBands(cells, zoom, o, f) {
+    const unit = o.bandUnit;
+    if (unit === 'none' || cells.length === 0)
+        return [];
+    const bands = [];
+    let seenYear = null;
+    for (const cell of cells) {
+        const anchor = bandAnchor(new Date(cell.start), zoom);
+        const bandStart = floorToUnit(anchor, unit);
+        const key = String(bandStart.getTime());
+        const last = bands.at(-1);
+        if (last?.key === key) {
+            last.toIndex = cell.index;
+            last.span += 1;
+            last.ratioEnd = cell.ratioEnd;
+            last.end = cell.end;
+            continue;
+        }
+        const labels = bandLabels(bandStart, unit, f);
+        const year = unit === 'week' ? isoWeekYear(bandStart) : bandStart.getFullYear();
+        const isYearStart = seenYear === null ? bands.length === 0 : year !== seenYear;
+        seenYear = year;
+        bands.push({
+            key,
+            start: cell.start,
+            end: cell.end,
+            fromIndex: cell.index,
+            toIndex: cell.index,
+            span: 1,
+            ratioStart: cell.ratioStart,
+            ratioEnd: cell.ratioEnd,
+            label: labels.label,
+            sublabel: labels.sublabel,
+            isYearStart,
+            // Znacznik roku niesie tylko pierwsze pasmo danego roku.
+            yearBadge: isYearStart ? String(year) : undefined,
+        });
+    }
+    return bands;
+}
+/**
+ * Buduje model osi czasu: kolumny, pasma nagłówka i skalę.
+ * Wszystkie obliczenia w czasie LOKALNYM przeglądarki.
+ *
+ * @param range zakres osi w ms — zwykle wynik `resolveRange`
+ * @param zoom  poziom przybliżenia
+ * @param opts  locale, „dziś", weekendy, godziny robocze, tryb pozycjonowania
+ */
+function buildTimeline(range, zoom, opts) {
+    const o = resolveOptions(zoom, opts);
+    const f = makeFormatters(o.locale);
+    const cells = buildCells(range, zoom, o, f);
+    applyRatios(cells, o.positionMode, range);
+    const bands = buildBands(cells, zoom, o, f);
+    const count = cells.length;
+    const first = cells[0];
+    const last = cells[count - 1];
+    /** Czas → 0..1. Skala odcinkowa: indeks kolumny + interpolacja w jej wnętrzu. */
+    const toRatio = (ts) => {
+        if (count === 0)
+            return 0;
+        if (o.positionMode === 'linear') {
+            return clamp(linearScale(range.start, range.end, 0, 1)(ts), 0, 1);
+        }
+        if (ts <= first.start)
+            return 0;
+        if (ts >= last.end)
+            return 1;
+        const index = findCell(cells, ts);
+        const cell = cells[index];
+        // `ts` może wpaść w lukę wyciętą przez `workHours: 'skip'` — wtedy
+        // interpolacja wychodzi poza [0, 1] i clamp dociąga ją do krawędzi kolumny.
+        const inner = clamp(linearScale(cell.start, cell.end, 0, 1)(ts), 0, 1);
+        return (index + inner) / count;
+    };
+    const fromRatio = (ratio) => {
+        if (count === 0)
+            return range.start;
+        if (o.positionMode === 'linear') {
+            return range.start + clamp(ratio, 0, 1) * (range.end - range.start);
+        }
+        const scaled = clamp(ratio, 0, 1) * count;
+        const index = Math.min(count - 1, Math.floor(scaled));
+        const cell = cells[index];
+        // Poprawnie odwzorowuje także dobę 25-godzinną — długość bierzemy z kolumny.
+        return cell.start + (scaled - index) * (cell.end - cell.start);
+    };
+    const span = (startTs, endTs) => {
+        const lo = Math.min(startTs, endTs);
+        const hi = Math.max(startTs, endTs);
+        const axisStart = count > 0 ? first.start : range.start;
+        const axisEnd = count > 0 ? last.end : range.end;
+        const left = toRatio(lo);
+        const right = toRatio(hi);
+        return {
+            left,
+            width: Math.max(0, right - left),
+            clippedStart: lo < axisStart,
+            clippedEnd: hi > axisEnd,
+            // Kamień milowy ma zerową szerokość, więc sam dotyk krawędzi wystarczy.
+            visible: hi >= axisStart && lo <= axisEnd,
+        };
+    };
+    const todayInRange = count > 0 && o.todayTs >= first.start && o.todayTs <= last.end;
+    return {
+        zoom,
+        range,
+        positionMode: o.positionMode,
+        cells,
+        bands,
+        hasBands: bands.length > 0,
+        todayRatio: todayInRange ? toRatio(o.todayTs) : null,
+        toRatio,
+        fromRatio,
+        span,
+    };
+}
+
+const _c0 = ["scrollEl"];
+const _c1 = ["laneMeasure"];
+const _forTrack0 = ($index, $item) => $item.key;
+const _forTrack1 = ($index, $item) => $item.item.id;
+function KptRoadmap_Conditional_5_For_2_Conditional_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 14);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const band_r1 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(band_r1.yearBadge);
+} }
+function KptRoadmap_Conditional_5_For_2_Conditional_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 16);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const band_r1 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(band_r1.sublabel);
+} }
+function KptRoadmap_Conditional_5_For_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 13);
+    i0.ɵɵconditionalCreate(1, KptRoadmap_Conditional_5_For_2_Conditional_1_Template, 2, 1, "span", 14);
+    i0.ɵɵelementStart(2, "span", 15);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵconditionalCreate(4, KptRoadmap_Conditional_5_For_2_Conditional_4_Template, 2, 1, "span", 16);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const band_r1 = ctx.$implicit;
+    i0.ɵɵstyleProp("inline-size", (band_r1.ratioEnd - band_r1.ratioStart) * 100, "%");
+    i0.ɵɵclassProp("kpt-roadmap__band--year-start", band_r1.isYearStart);
+    i0.ɵɵproperty("kptTooltip", band_r1.sublabel ? band_r1.label + " " + band_r1.sublabel : band_r1.label);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional(band_r1.yearBadge ? 1 : -1);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(band_r1.label);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional(band_r1.sublabel && !band_r1.yearBadge ? 4 : -1);
+} }
+function KptRoadmap_Conditional_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 6);
+    i0.ɵɵrepeaterCreate(1, KptRoadmap_Conditional_5_For_2_Template, 5, 8, "div", 12, _forTrack0);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵrepeater(ctx_r1.timeline().bands);
+} }
+function KptRoadmap_For_9_Conditional_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 19);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const cell_r3 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(cell_r3.sublabel);
+} }
+function KptRoadmap_For_9_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 17)(1, "span", 18);
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵconditionalCreate(3, KptRoadmap_For_9_Conditional_3_Template, 2, 1, "span", 19);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const cell_r3 = ctx.$implicit;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵstyleProp("inline-size", (cell_r3.ratioEnd - cell_r3.ratioStart) * 100, "%");
+    i0.ɵɵclassProp("kpt-roadmap__cell--weekend", cell_r3.isWeekend)("kpt-roadmap__cell--today", cell_r3.isToday && ctx_r1.showToday())("kpt-roadmap__cell--year-boundary", cell_r3.isYearBoundary)("kpt-roadmap__cell--gap-before", cell_r3.hasGapBefore);
+    i0.ɵɵproperty("kptTooltip", cell_r3.title);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(cell_r3.label);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional(cell_r3.sublabel ? 3 : -1);
+} }
+function KptRoadmap_Conditional_10_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "span", 20);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵstyleProp("inset-inline-start", ctx_r1.timeline().todayRatio * 100, "%");
+    i0.ɵɵattribute("title", ctx_r1.i18n.t("roadmap.today"));
+} }
+function KptRoadmap_Conditional_11_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 10);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(ctx_r1.i18n.t("roadmap.empty"));
+} }
+function KptRoadmap_Conditional_12_For_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "div", 28);
+} if (rf & 2) {
+    const cell_r4 = ctx.$implicit;
+    i0.ɵɵstyleProp("inline-size", (cell_r4.ratioEnd - cell_r4.ratioStart) * 100, "%");
+    i0.ɵɵclassProp("kpt-roadmap__grid-cell--weekend", cell_r4.isWeekend)("kpt-roadmap__grid-cell--non-working", cell_r4.isNonWorking)("kpt-roadmap__grid-cell--year-boundary", cell_r4.isYearBoundary)("kpt-roadmap__grid-cell--gap-before", cell_r4.hasGapBefore);
+} }
+function KptRoadmap_Conditional_12_Conditional_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "div", 29);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵstyleProp("inset-inline-start", ctx_r1.timeline().todayRatio * 100, "%");
+} }
+function KptRoadmap_Conditional_12_Conditional_6_For_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "g", 31);
+    i0.ɵɵelement(1, "path", 32)(2, "path", 33);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const link_r5 = ctx.$implicit;
+    i0.ɵɵclassProp("kpt-roadmap__link--violated", link_r5.isViolated);
+    i0.ɵɵattribute("data-variant", link_r5.variant);
+    i0.ɵɵadvance();
+    i0.ɵɵstyleProp("stroke", link_r5.color);
+    i0.ɵɵattribute("d", link_r5.path);
+    i0.ɵɵadvance();
+    i0.ɵɵstyleProp("fill", link_r5.color);
+    i0.ɵɵattribute("d", link_r5.arrow);
+} }
+function KptRoadmap_Conditional_12_Conditional_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵnamespaceSVG();
+    i0.ɵɵelementStart(0, "svg", 26);
+    i0.ɵɵrepeaterCreate(1, KptRoadmap_Conditional_12_Conditional_6_For_2_Template, 3, 9, ":svg:g", 30, _forTrack0);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵattribute("viewBox", "0 0 " + ctx_r1.laneWidth() + " " + ctx_r1.layout().totalHeight)("width", ctx_r1.laneWidth())("height", ctx_r1.layout().totalHeight);
+    i0.ɵɵadvance();
+    i0.ɵɵrepeater(ctx_r1.links());
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_2_Conditional_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 41);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const group_r7 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(group_r7.sublabel);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_2_Conditional_6_Conditional_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 42);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const state_r8 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(state_r8.itemCount);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_2_Conditional_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵconditionalCreate(0, KptRoadmap_Conditional_12_For_8_Conditional_2_Conditional_6_Conditional_0_Template, 2, 1, "span", 42);
+} if (rf & 2) {
+    i0.ɵɵconditional(ctx.itemCount ? 0 : -1);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_2_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 37);
+    i0.ɵɵlistener("click", function KptRoadmap_Conditional_12_For_8_Conditional_2_Template_button_click_0_listener() { const group_r7 = i0.ɵɵrestoreView(_r6); const ctx_r1 = i0.ɵɵnextContext(3); return i0.ɵɵresetView(ctx_r1.toggleGroup(group_r7)); });
+    i0.ɵɵelement(1, "span", 38);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(2, "span", 39)(3, "span", 40);
+    i0.ɵɵtext(4);
+    i0.ɵɵelementEnd();
+    i0.ɵɵconditionalCreate(5, KptRoadmap_Conditional_12_For_8_Conditional_2_Conditional_5_Template, 2, 1, "span", 41);
+    i0.ɵɵelementEnd();
+    i0.ɵɵconditionalCreate(6, KptRoadmap_Conditional_12_For_8_Conditional_2_Conditional_6_Template, 1, 1);
+} if (rf & 2) {
+    let tmp_21_0;
+    const group_r7 = ctx;
+    const row_r9 = i0.ɵɵnextContext().$implicit;
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵattribute("aria-expanded", !ctx_r1.isCollapsed(group_r7))("aria-label", ctx_r1.isCollapsed(group_r7) ? ctx_r1.i18n.t("roadmap.expandGroup") : ctx_r1.i18n.t("roadmap.collapseGroup"));
+    i0.ɵɵadvance();
+    i0.ɵɵclassProp("kpt-roadmap__toggle-icon--open", !ctx_r1.isCollapsed(group_r7));
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("kptTooltip", group_r7.sublabel ? group_r7.label + " \u2014 " + group_r7.sublabel : group_r7.label);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(group_r7.label);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional(group_r7.sublabel ? 5 : -1);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional((tmp_21_0 = row_r9.groupState) ? 6 : -1, tmp_21_0);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_3_Conditional_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 41);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const first_r10 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(first_r10.source.sublabel);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 43);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+    i0.ɵɵconditionalCreate(2, KptRoadmap_Conditional_12_For_8_Conditional_3_Conditional_2_Template, 2, 1, "span", 41);
+} if (rf & 2) {
+    const first_r10 = ctx;
+    const row_r9 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(first_r10.source.label);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional(row_r9.items.length === 1 && first_r10.source.sublabel ? 2 : -1);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_5_Conditional_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "div", 45);
+} if (rf & 2) {
+    const sum_r11 = ctx;
+    i0.ɵɵstyleProp("inset-inline-start", sum_r11.left, "%")("inline-size", sum_r11.width, "%")("background", sum_r11.color);
+    i0.ɵɵattribute("data-variant", sum_r11.variant);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵconditionalCreate(0, KptRoadmap_Conditional_12_For_8_Conditional_5_Conditional_0_Template, 1, 7, "div", 44);
+} if (rf & 2) {
+    let tmp_14_0;
+    const row_r9 = i0.ɵɵnextContext().$implicit;
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵconditional((tmp_14_0 = ctx_r1.summary(row_r9)) ? 0 : -1, tmp_14_0);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_0_Template(rf, ctx) { if (rf & 1) {
+    const _r12 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 48);
+    i0.ɵɵlistener("click", function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_0_Template_div_click_0_listener() { i0.ɵɵrestoreView(_r12); const bar_r13 = i0.ɵɵnextContext().$implicit; const ctx_r1 = i0.ɵɵnextContext(4); return i0.ɵɵresetView(ctx_r1.onItemClick(bar_r13.item)); })("keydown", function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_0_Template_div_keydown_0_listener($event) { i0.ɵɵrestoreView(_r12); const bar_r13 = i0.ɵɵnextContext().$implicit; const ctx_r1 = i0.ɵɵnextContext(4); return i0.ɵɵresetView(ctx_r1.onItemKeydown($event, bar_r13.item)); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const bar_r13 = i0.ɵɵnextContext().$implicit;
+    const ctx_r1 = i0.ɵɵnextContext(4);
+    i0.ɵɵstyleProp("inset-inline-start", bar_r13.left, "%")("inset-block-start", bar_r13.top, "px")("inline-size", bar_r13.height, "px")("block-size", bar_r13.height, "px")("background", bar_r13.color);
+    i0.ɵɵproperty("kptTooltip", bar_r13.title);
+    i0.ɵɵattribute("data-variant", bar_r13.variant)("aria-label", ctx_r1.i18n.t("roadmap.milestone") + ": " + bar_r13.label);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_1_Conditional_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "span", 52);
+} if (rf & 2) {
+    const bar_r13 = i0.ɵɵnextContext(2).$implicit;
+    i0.ɵɵstyleProp("inline-size", bar_r13.progress * 100, "%");
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_1_Template(rf, ctx) { if (rf & 1) {
+    const _r14 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 49);
+    i0.ɵɵlistener("click", function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_1_Template_div_click_0_listener() { i0.ɵɵrestoreView(_r14); const bar_r13 = i0.ɵɵnextContext().$implicit; const ctx_r1 = i0.ɵɵnextContext(4); return i0.ɵɵresetView(ctx_r1.onItemClick(bar_r13.item)); })("keydown", function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_1_Template_div_keydown_0_listener($event) { i0.ɵɵrestoreView(_r14); const bar_r13 = i0.ɵɵnextContext().$implicit; const ctx_r1 = i0.ɵɵnextContext(4); return i0.ɵɵresetView(ctx_r1.onItemKeydown($event, bar_r13.item)); });
+    i0.ɵɵconditionalCreate(1, KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_1_Conditional_1_Template, 1, 2, "span", 50);
+    i0.ɵɵelementStart(2, "span", 51);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const bar_r13 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵstyleProp("inset-inline-start", bar_r13.left, "%")("inline-size", bar_r13.width, "%")("inset-block-start", bar_r13.top, "px")("block-size", bar_r13.height, "px")("background", bar_r13.color);
+    i0.ɵɵclassProp("kpt-roadmap__bar--clipped-start", bar_r13.clippedStart)("kpt-roadmap__bar--clipped-end", bar_r13.clippedEnd)("kpt-roadmap__bar--disabled", bar_r13.item.source.disabled);
+    i0.ɵɵproperty("kptTooltip", bar_r13.title);
+    i0.ɵɵattribute("data-variant", bar_r13.variant);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional(bar_r13.progress !== null ? 1 : -1);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(bar_r13.label);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵconditionalCreate(0, KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_0_Template, 1, 13, "div", 46)(1, KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Conditional_1_Template, 4, 20, "div", 47);
+} if (rf & 2) {
+    const bar_r13 = ctx.$implicit;
+    i0.ɵɵconditional(bar_r13.isMilestone ? 0 : 1);
+} }
+function KptRoadmap_Conditional_12_For_8_Conditional_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵrepeaterCreate(0, KptRoadmap_Conditional_12_For_8_Conditional_6_For_1_Template, 2, 1, null, null, _forTrack1);
+} if (rf & 2) {
+    const row_r9 = i0.ɵɵnextContext().$implicit;
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵrepeater(ctx_r1.bars(row_r9));
+} }
+function KptRoadmap_Conditional_12_For_8_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 34)(1, "div", 35);
+    i0.ɵɵconditionalCreate(2, KptRoadmap_Conditional_12_For_8_Conditional_2_Template, 7, 8)(3, KptRoadmap_Conditional_12_For_8_Conditional_3_Template, 3, 2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "div", 36);
+    i0.ɵɵconditionalCreate(5, KptRoadmap_Conditional_12_For_8_Conditional_5_Template, 1, 1)(6, KptRoadmap_Conditional_12_For_8_Conditional_6_Template, 2, 0);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    let tmp_19_0;
+    const row_r9 = ctx.$implicit;
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵstyleProp("inset-block-start", row_r9.top, "px")("block-size", row_r9.height, "px");
+    i0.ɵɵclassProp("kpt-roadmap__row--group", row_r9.kind === "group");
+    i0.ɵɵadvance();
+    i0.ɵɵstyleProp("padding-inline-start", 0.75 + row_r9.depth * 1, "rem");
+    i0.ɵɵclassProp("kpt-roadmap__label--group", row_r9.kind === "group");
+    i0.ɵɵproperty("kptTooltip", ctx_r1.labelTooltip(row_r9));
+    i0.ɵɵadvance();
+    i0.ɵɵconditional((tmp_19_0 = row_r9.group) ? 2 : (tmp_19_0 = row_r9.items[0]) ? 3 : -1, tmp_19_0);
+    i0.ɵɵadvance(3);
+    i0.ɵɵconditional(row_r9.kind === "group" ? 5 : 6);
+} }
+function KptRoadmap_Conditional_12_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 21)(1, "div", 22)(2, "div", 23);
+    i0.ɵɵrepeaterCreate(3, KptRoadmap_Conditional_12_For_4_Template, 1, 10, "div", 24, _forTrack0);
+    i0.ɵɵelementEnd();
+    i0.ɵɵconditionalCreate(5, KptRoadmap_Conditional_12_Conditional_5_Template, 1, 2, "div", 25);
+    i0.ɵɵelementEnd();
+    i0.ɵɵconditionalCreate(6, KptRoadmap_Conditional_12_Conditional_6_Template, 3, 3, ":svg:svg", 26);
+    i0.ɵɵrepeaterCreate(7, KptRoadmap_Conditional_12_For_8_Template, 7, 13, "div", 27, _forTrack0);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵstyleProp("block-size", ctx_r1.layout().totalHeight, "px");
+    i0.ɵɵadvance(3);
+    i0.ɵɵrepeater(ctx_r1.timeline().cells);
+    i0.ɵɵadvance(2);
+    i0.ɵɵconditional(ctx_r1.showToday() && ctx_r1.timeline().todayRatio !== null ? 5 : -1);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional(ctx_r1.links().length > 0 ? 6 : -1);
+    i0.ɵɵadvance();
+    i0.ɵɵrepeater(ctx_r1.visibleRows());
+} }
+/** Domyślna szerokość kolumny dla danego zoomu (px). */
+const CELL_WIDTH = {
+    year: 96,
+    quarter: 88,
+    month: 80,
+    week: 76,
+    day: 44,
+    hour: 46,
+};
+/** Wysokość paska w trybie „jeden item na wiersz" (px). */
+const BAR_HEIGHT = 22;
+/** Odstęp między pasami w trybie „pack" (px). */
+const LANE_GAP = 4;
+/**
+ * Roadmapa — wiersze zadań na poziomej osi czasu (widok typu Gantt).
+ *
+ * Układ opiera się na DOM i `position: sticky` (kolumna etykiet oraz nagłówek),
+ * paski są pozycjonowane procentowo w torze, a zależności rysuje warstwa SVG
+ * rozpięta nad torami. Cała geometria pochodzi z rdzenia w `../core`.
+ */
+class KptRoadmap {
+    constructor() {
+        this.i18n = inject(KptI18n);
+        /** Pełna konfiguracja: dane, zoom, zakres i opcje. */
+        this.config = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "config" }] : /* istanbul ignore next */ []));
+        /** Stała wysokość obszaru przewijania (np. '420px'). Włącza przyklejony nagłówek. */
+        this.scrollHeight = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "scrollHeight" }] : /* istanbul ignore next */ []));
+        /** Szerokość kolumny etykiet. */
+        this.labelWidth = input('14rem', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "labelWidth" }] : /* istanbul ignore next */ []));
+        /** Szerokość kolumny osi czasu; brak ⇒ wartość zależna od zoomu. */
+        this.cellWidthPx = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "cellWidthPx" }] : /* istanbul ignore next */ []));
+        /** Znacznik „dziś". */
+        this.showToday = input(true, { ...(ngDevMode ? { debugName: "showToday" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+        /** Renderowanie tylko widocznych wierszy. Warto włączyć od ~100 wierszy. */
+        this.virtual = input(false, { ...(ngDevMode ? { debugName: "virtual" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+        /** Zwinięte grupy (dwukierunkowe). */
+        this.collapsedGroups = model([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "collapsedGroups" }] : /* istanbul ignore next */ []));
+        /**
+         * Grupy zwinięte na starcie przez `group.collapsed`. Trzymamy je osobno od modelu,
+         * żeby dwukierunkowe wiązanie pozostało w rękach aplikacji, a zwinięcie zadeklarowane
+         * w danych nadal działało. Resetuje się, gdy zmieni się lista grup.
+         */
+        this.collapsedFromConfig = linkedSignal({ ...(ngDevMode ? { debugName: "collapsedFromConfig" } : /* istanbul ignore next */ {}), source: () => this.config().groups,
+            computation: (groups) => (groups ?? []).filter((group) => group.collapsed).map((group) => group.id) });
+        /** Suma obu źródeł — stan faktycznie użyty do budowy wierszy. */
+        this.collapsedIds = computed(() => new Set([...this.collapsedFromConfig(), ...this.collapsedGroups()]), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "collapsedIds" }] : /* istanbul ignore next */ []));
+        this.itemClick = output();
+        /** Emitowane przy każdej zmianie wyliczonego zakresu osi. */
+        this.rangeChange = output();
+        this.scrollEl = viewChild('scrollEl', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "scrollEl" }] : /* istanbul ignore next */ []));
+        this.laneEl = viewChild('laneMeasure', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "laneEl" }] : /* istanbul ignore next */ []));
+        this.scrollTop = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "scrollTop" }] : /* istanbul ignore next */ []));
+        this.viewportHeight = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "viewportHeight" }] : /* istanbul ignore next */ []));
+        /** Szerokość toru w px — potrzebna warstwie SVG, która pracuje w pikselach. */
+        this.laneWidth = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "laneWidth" }] : /* istanbul ignore next */ []));
+        this.zoom = computed(() => this.config().zoom ?? 'week', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "zoom" }] : /* istanbul ignore next */ []));
+        this.cellWidth = computed(() => this.cellWidthPx() ?? CELL_WIDTH[this.zoom()], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "cellWidth" }] : /* istanbul ignore next */ []));
+        this.range = computed(() => resolveRange(this.config(), this.config().items), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "range" }] : /* istanbul ignore next */ []));
+        this.timeline = computed(() => {
+            const config = this.config();
+            return buildTimeline(this.range(), this.zoom(), {
+                ...config.timeline,
+                locale: config.locale ?? config.timeline?.locale ?? this.i18n.locale(),
+                today: config.today ?? config.timeline?.today,
+                weekPrefix: config.timeline?.weekPrefix ?? this.i18n.t('roadmap.week'),
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "timeline" }] : /* istanbul ignore next */ []));
+        this.layout = computed(() => {
+            const config = this.config();
+            return buildRows(config.items, config.groups, this.collapsedIds(), config.rows);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "layout" }] : /* istanbul ignore next */ []));
+        /** Wiersze faktycznie renderowane — całość albo okno wirtualizacji. */
+        this.visibleRows = computed(() => {
+            const layout = this.layout();
+            if (!this.virtual())
+                return layout.rows;
+            const height = this.viewportHeight();
+            if (height <= 0)
+                return layout.rows;
+            return sliceRows(layout, this.scrollTop(), height).rows;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "visibleRows" }] : /* istanbul ignore next */ []));
+        this.isEmpty = computed(() => this.layout().rows.length === 0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isEmpty" }] : /* istanbul ignore next */ []));
+        this.barHeight = computed(() => this.config().rows?.laneHeight ?? BAR_HEIGHT, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "barHeight" }] : /* istanbul ignore next */ []));
+        /**
+         * Geometria zależności w pikselach.
+         * Liczona dopiero po zmierzeniu toru; wiersze poza oknem wirtualizacji
+         * nie mają końców, więc ich krawędzie są pomijane.
+         */
+        this.links = computed(() => {
+            const config = this.config();
+            if (config.dependencies?.enabled === false)
+                return [];
+            const width = this.laneWidth();
+            if (width <= 0)
+                return [];
+            const layout = this.layout();
+            const timeline = this.timeline();
+            const height = this.barHeight();
+            const endpoints = new Map();
+            for (const row of this.visibleRows()) {
+                for (const item of row.items) {
+                    const geom = timeline.span(item.start, item.end);
+                    if (!geom.visible)
+                        continue;
+                    // Romb kamienia milowego jest renderowany wyśrodkowany na dacie
+                    // (`translateX(-50%)`), więc jego prostokąt zaczyna się o pół rozmiaru wcześniej.
+                    const left = geom.left * width - (item.isMilestone ? height / 2 : 0);
+                    endpoints.set(item.id, {
+                        id: item.id,
+                        rect: {
+                            x: left,
+                            y: row.top + this.barTop(row, item.lane),
+                            width: Math.max(geom.width * width, item.isMilestone ? height : 1),
+                            height,
+                        },
+                        startTs: item.start,
+                        endTs: item.end,
+                    });
+                }
+            }
+            const resolved = resolveLinks([...layout.byId.values()], config.links);
+            const result = [];
+            for (const link of resolved.links) {
+                const geom = linkGeometry(link, endpoints.get(link.from), endpoints.get(link.to), config.dependencies);
+                if (geom)
+                    result.push(geom);
+            }
+            return result;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "links" }] : /* istanbul ignore next */ []));
+        this.trackRow = (_, row) => row.key;
+        this.trackBar = (_, bar) => bar.item.id;
+        // Zakres jest wielkością wyliczaną — informujemy o nim po każdym przeliczeniu.
+        afterRenderEffect(() => {
+            this.rangeChange.emit(this.range());
+        });
+        // Pomiar toru i okna przewijania; oba wpływają wyłącznie na warstwę widoku.
+        afterRenderEffect((onCleanup) => {
+            const lane = this.laneEl()?.nativeElement;
+            const scroll = this.scrollEl()?.nativeElement;
+            if (!lane || typeof ResizeObserver === 'undefined')
+                return;
+            const observer = new ResizeObserver(() => {
+                this.laneWidth.set(lane.clientWidth);
+                if (scroll)
+                    this.viewportHeight.set(scroll.clientHeight);
+            });
+            observer.observe(lane);
+            if (scroll)
+                observer.observe(scroll);
+            this.laneWidth.set(lane.clientWidth);
+            if (scroll)
+                this.viewportHeight.set(scroll.clientHeight);
+            onCleanup(() => observer.disconnect());
+        });
+        // Ostrzeżenie dla danych, których nie da się narysować.
+        afterRenderEffect(() => {
+            const invalid = this.layout().invalid;
+            if (invalid.length > 0 && typeof ngDevMode !== 'undefined' && ngDevMode) {
+                console.warn('[kpt-roadmap] Pominięto elementy:', invalid.map((entry) => `${entry.id} (${entry.reason})`).join(', '));
+            }
+        });
+    }
+    onScroll(event) {
+        const target = event.target;
+        this.scrollTop.set(target.scrollTop);
+    }
+    /** Wysokość paska wraz z odstępem — wspólna dla widoku i geometrii zależności. */
+    laneStep() {
+        return this.barHeight() + LANE_GAP;
+    }
+    /** Offset pionowy paska wewnątrz wiersza (px). */
+    barTop(row, lane) {
+        const total = row.laneCount * this.barHeight() + (row.laneCount - 1) * LANE_GAP;
+        return Math.max(0, (row.height - total) / 2) + lane * this.laneStep();
+    }
+    /** Paski danego wiersza gotowe do renderu. */
+    bars(row) {
+        const timeline = this.timeline();
+        const height = this.barHeight();
+        const result = [];
+        for (const item of row.items) {
+            const geom = timeline.span(item.start, item.end);
+            if (!geom.visible)
+                continue;
+            const source = item.source;
+            result.push({
+                item,
+                left: geom.left * 100,
+                width: geom.width * 100,
+                top: this.barTop(row, item.lane),
+                height,
+                label: source.label,
+                title: source.sublabel ? `${source.label} — ${source.sublabel}` : source.label,
+                variant: source.variant ?? 'primary',
+                color: source.color,
+                progress: source.progress ?? null,
+                isMilestone: item.isMilestone,
+                clippedStart: geom.clippedStart,
+                clippedEnd: geom.clippedEnd,
+            });
+        }
+        return result;
+    }
+    /** Pasek zbiorczy wiersza grupy. */
+    summary(row) {
+        const span = row.groupState?.span;
+        if (!span)
+            return null;
+        const geom = this.timeline().span(span.start, span.end);
+        if (!geom.visible)
+            return null;
+        return {
+            left: geom.left * 100,
+            width: geom.width * 100,
+            variant: row.group?.variant ?? 'neutral',
+            color: row.group?.color,
+        };
+    }
+    toggleGroup(group) {
+        const current = this.collapsedGroups();
+        if (this.collapsedIds().has(group.id)) {
+            // Rozwijanie musi zdjąć grupę z obu źródeł, inaczej `group.collapsed`
+            // natychmiast zwinęłoby ją z powrotem.
+            this.collapsedFromConfig.update((ids) => ids.filter((id) => id !== group.id));
+            this.collapsedGroups.set(current.filter((id) => id !== group.id));
+            return;
+        }
+        this.collapsedGroups.set([...current, group.id]);
+    }
+    onItemClick(item) {
+        if (item.source.disabled)
+            return;
+        this.itemClick.emit(item.source);
+    }
+    /** Obsługa klawiatury na pasku — Enter/Spacja działają jak kliknięcie. */
+    onItemKeydown(event, item) {
+        if (event.key !== 'Enter' && event.key !== ' ')
+            return;
+        event.preventDefault();
+        this.onItemClick(item);
+    }
+    /**
+     * Treść dymka dla kolumny etykiet. Pusta tam, gdzie dymek nie miałby czego
+     * uzupełnić — dyrektywa pomija wtedy podpowiedź.
+     */
+    labelTooltip(row) {
+        // Wiersz grupy ma własny dymek, osadzony głębiej (na stosie etykiet).
+        if (row.kind === 'group')
+            return '';
+        // Tryb 'pack' mieści wiele zadań w jednym wierszu — nie ma jednej etykiety.
+        if (row.items.length !== 1)
+            return '';
+        const source = row.items[0].source;
+        return source.sublabel ? `${source.label} — ${source.sublabel}` : source.label;
+    }
+    isCollapsed(group) {
+        return group ? this.collapsedIds().has(group.id) : false;
+    }
+    static { this.ɵfac = function KptRoadmap_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || KptRoadmap)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: KptRoadmap, selectors: [["kpt-roadmap"]], viewQuery: function KptRoadmap_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuerySignal(ctx.scrollEl, _c0, 5)(ctx.laneEl, _c1, 5);
+        } if (rf & 2) {
+            i0.ɵɵqueryAdvance(2);
+        } }, hostAttrs: [1, "kpt-roadmap"], hostVars: 8, hostBindings: function KptRoadmap_HostBindings(rf, ctx) { if (rf & 2) {
+            i0.ɵɵstyleProp("--%NS%kpt-roadmap-cells", ctx.timeline().cells.length)("--%NS%kpt-roadmap-cell-w", ctx.cellWidth(), "px")("--%NS%kpt-roadmap-label-w", ctx.labelWidth());
+            i0.ɵɵclassProp("kpt-roadmap--fixed-height", !!ctx.scrollHeight());
+        } }, inputs: { config: [1, "config"], scrollHeight: [1, "scrollHeight"], labelWidth: [1, "labelWidth"], cellWidthPx: [1, "cellWidthPx"], showToday: [1, "showToday"], virtual: [1, "virtual"], collapsedGroups: [1, "collapsedGroups"] }, outputs: { collapsedGroups: "collapsedGroupsChange", itemClick: "itemClick", rangeChange: "rangeChange" }, decls: 13, vars: 5, consts: [["scrollEl", ""], ["laneMeasure", ""], [1, "kpt-roadmap__scroll", 3, "scroll"], [1, "kpt-roadmap__head"], [1, "kpt-roadmap__head-label"], [1, "kpt-roadmap__head-track"], [1, "kpt-roadmap__bands"], [1, "kpt-roadmap__cells"], [1, "kpt-roadmap__cell", 3, "kpt-roadmap__cell--weekend", "kpt-roadmap__cell--today", "kpt-roadmap__cell--year-boundary", "kpt-roadmap__cell--gap-before", "inline-size", "kptTooltip"], [1, "kpt-roadmap__today-dot", 3, "inset-inline-start"], [1, "kpt-roadmap__empty"], [1, "kpt-roadmap__body", 3, "block-size"], ["kptTooltipOnlyWhenTruncated", "", 1, "kpt-roadmap__band", 3, "kpt-roadmap__band--year-start", "inline-size", "kptTooltip"], ["kptTooltipOnlyWhenTruncated", "", 1, "kpt-roadmap__band", 3, "kptTooltip"], [1, "kpt-roadmap__year-badge"], [1, "kpt-roadmap__band-label"], [1, "kpt-roadmap__band-sublabel"], [1, "kpt-roadmap__cell", 3, "kptTooltip"], [1, "kpt-roadmap__cell-label"], [1, "kpt-roadmap__cell-sublabel"], [1, "kpt-roadmap__today-dot"], [1, "kpt-roadmap__body"], ["aria-hidden", "true", 1, "kpt-roadmap__grid"], [1, "kpt-roadmap__grid-cells"], [1, "kpt-roadmap__grid-cell", 3, "kpt-roadmap__grid-cell--weekend", "kpt-roadmap__grid-cell--non-working", "kpt-roadmap__grid-cell--year-boundary", "kpt-roadmap__grid-cell--gap-before", "inline-size"], [1, "kpt-roadmap__today", 3, "inset-inline-start"], ["aria-hidden", "true", 1, "kpt-roadmap__links"], [1, "kpt-roadmap__row", 3, "kpt-roadmap__row--group", "inset-block-start", "block-size"], [1, "kpt-roadmap__grid-cell"], [1, "kpt-roadmap__today"], [1, "kpt-roadmap__link", 3, "kpt-roadmap__link--violated"], [1, "kpt-roadmap__link"], [1, "kpt-roadmap__link-path"], [1, "kpt-roadmap__link-arrow"], [1, "kpt-roadmap__row"], ["kptTooltipOnlyWhenTruncated", "", 1, "kpt-roadmap__label", 3, "kptTooltip"], [1, "kpt-roadmap__lane"], ["type", "button", 1, "kpt-roadmap__toggle", 3, "click"], [1, "kpt-roadmap__toggle-icon"], ["kptTooltipOnlyWhenTruncated", "", 1, "kpt-roadmap__label-stack", 3, "kptTooltip"], [1, "kpt-roadmap__label-text", "kpt-roadmap__label-text--group"], [1, "kpt-roadmap__label-sub"], [1, "kpt-roadmap__label-count"], [1, "kpt-roadmap__label-text"], [1, "kpt-roadmap__summary", 3, "inset-inline-start", "inline-size", "background"], [1, "kpt-roadmap__summary"], ["tabindex", "0", 1, "kpt-roadmap__milestone", 3, "kptTooltip", "inset-inline-start", "inset-block-start", "inline-size", "block-size", "background"], ["kptTooltipOnlyWhenTruncated", "", "tabindex", "0", 1, "kpt-roadmap__bar", 3, "kptTooltip", "kpt-roadmap__bar--clipped-start", "kpt-roadmap__bar--clipped-end", "kpt-roadmap__bar--disabled", "inset-inline-start", "inline-size", "inset-block-start", "block-size", "background"], ["tabindex", "0", 1, "kpt-roadmap__milestone", 3, "click", "keydown", "kptTooltip"], ["kptTooltipOnlyWhenTruncated", "", "tabindex", "0", 1, "kpt-roadmap__bar", 3, "click", "keydown", "kptTooltip"], [1, "kpt-roadmap__bar-progress", 3, "inline-size"], [1, "kpt-roadmap__bar-label"], [1, "kpt-roadmap__bar-progress"]], template: function KptRoadmap_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 2, 0);
+            i0.ɵɵlistener("scroll", function KptRoadmap_Template_div_scroll_0_listener($event) { return ctx.onScroll($event); });
+            i0.ɵɵelementStart(2, "div", 3);
+            i0.ɵɵelement(3, "div", 4);
+            i0.ɵɵelementStart(4, "div", 5);
+            i0.ɵɵconditionalCreate(5, KptRoadmap_Conditional_5_Template, 3, 0, "div", 6);
+            i0.ɵɵelementStart(6, "div", 7, 1);
+            i0.ɵɵrepeaterCreate(8, KptRoadmap_For_9_Template, 4, 13, "div", 8, _forTrack0);
+            i0.ɵɵelementEnd();
+            i0.ɵɵconditionalCreate(10, KptRoadmap_Conditional_10_Template, 1, 3, "span", 9);
+            i0.ɵɵelementEnd()();
+            i0.ɵɵconditionalCreate(11, KptRoadmap_Conditional_11_Template, 2, 1, "div", 10)(12, KptRoadmap_Conditional_12_Template, 9, 4, "div", 11);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵstyleProp("max-block-size", ctx.scrollHeight());
+            i0.ɵɵadvance(5);
+            i0.ɵɵconditional(ctx.timeline().hasBands ? 5 : -1);
+            i0.ɵɵadvance(3);
+            i0.ɵɵrepeater(ctx.timeline().cells);
+            i0.ɵɵadvance(2);
+            i0.ɵɵconditional(ctx.showToday() && ctx.timeline().todayRatio !== null ? 10 : -1);
+            i0.ɵɵadvance();
+            i0.ɵɵconditional(ctx.isEmpty() ? 11 : 12);
+        } }, dependencies: [KptTooltip], styles: ["@layer kpt.components{.kpt-roadmap{display:block;--%NS%kpt-roadmap-cells: 1;--%NS%kpt-roadmap-cell-w: 76px;--%NS%kpt-roadmap-label-w: 14rem;--%NS%kpt-roadmap-track-w: calc(var(--%NS%kpt-roadmap-cell-w) * var(--%NS%kpt-roadmap-cells));color:var(--%NS%kpt-color-on-surface);font-family:var(--%NS%kpt-font-family-sans);background:var(--%NS%kpt-color-surface);border:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border);border-radius:var(--%NS%kpt-radius-lg, .75rem);overflow:hidden}.kpt-roadmap__scroll{overflow:auto;position:relative}.kpt-roadmap__head,.kpt-roadmap__row{display:grid;grid-template-columns:var(--%NS%kpt-roadmap-label-w) minmax(var(--%NS%kpt-roadmap-track-w),1fr);inline-size:max-content;min-inline-size:100%}.kpt-roadmap__head{position:sticky;inset-block-start:0;z-index:4;background:var(--%NS%kpt-color-surface-variant, var(--%NS%kpt-color-surface));border-block-end:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border)}.kpt-roadmap__head-label{position:sticky;inset-inline-start:0;z-index:5;background:var(--%NS%kpt-color-surface-variant, var(--%NS%kpt-color-surface));border-inline-end:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border)}.kpt-roadmap__head-track{position:relative;display:flex;flex-direction:column;min-inline-size:0}.kpt-roadmap__bands,.kpt-roadmap__cells,.kpt-roadmap__grid-cells{display:flex;inline-size:100%}.kpt-roadmap__band{position:relative;display:flex;align-items:center;justify-content:center;gap:var(--%NS%kpt-space-2, .5rem);min-inline-size:0;padding:var(--%NS%kpt-space-2, .5rem) var(--%NS%kpt-space-3, .75rem);font-size:var(--%NS%kpt-font-size-sm, .875rem);font-weight:var(--%NS%kpt-font-weight-medium, 500);color:var(--%NS%kpt-color-on-surface-muted);white-space:nowrap;overflow:hidden;border-inline-start:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border)}.kpt-roadmap__band:first-child{border-inline-start:0}.kpt-roadmap__band--year-start{border-inline-start:var(--%NS%kpt-border-width-medium, 2px) solid var(--%NS%kpt-color-border-strong)}.kpt-roadmap__band-label{overflow:hidden;text-overflow:ellipsis}.kpt-roadmap__band-sublabel{color:var(--%NS%kpt-color-text-subtle, var(--%NS%kpt-color-on-surface-muted))}.kpt-roadmap__year-badge{display:inline-flex;align-items:center;padding:.125rem var(--%NS%kpt-space-2, .5rem);font-size:var(--%NS%kpt-font-size-xs, .75rem);font-weight:var(--%NS%kpt-font-weight-semibold, 600);color:var(--%NS%kpt-color-surface);background:var(--%NS%kpt-color-on-surface);border-radius:var(--%NS%kpt-radius-full, 9999px)}.kpt-roadmap__cell{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:.125rem;min-inline-size:0;padding:var(--%NS%kpt-space-2, .5rem) .25rem;text-align:center;white-space:nowrap;border-inline-start:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border)}.kpt-roadmap__cell:first-child{border-inline-start:0}.kpt-roadmap__cell-label{font-size:var(--%NS%kpt-font-size-xs, .75rem);font-weight:var(--%NS%kpt-font-weight-semibold, 600);letter-spacing:.02em;text-transform:uppercase;color:var(--%NS%kpt-color-on-surface-muted)}.kpt-roadmap__cell-sublabel{font-size:var(--%NS%kpt-font-size-xs, .75rem);color:var(--%NS%kpt-color-text-subtle, var(--%NS%kpt-color-on-surface-muted));overflow:hidden;text-overflow:ellipsis;inline-size:100%}.kpt-roadmap__cell--weekend{background:var(--%NS%kpt-color-surface-sunken, var(--%NS%kpt-color-muted))}.kpt-roadmap__cell--today .kpt-roadmap__cell-label{color:var(--%NS%kpt-color-primary)}.kpt-roadmap__cell--year-boundary,.kpt-roadmap__grid-cell--year-boundary{border-inline-start:var(--%NS%kpt-border-width-medium, 2px) solid var(--%NS%kpt-color-border-strong)}.kpt-roadmap__cell--gap-before,.kpt-roadmap__grid-cell--gap-before{border-inline-start:var(--%NS%kpt-border-width-thin, 1px) dashed var(--%NS%kpt-color-border-strong)}.kpt-roadmap__body{position:relative;inline-size:calc(var(--%NS%kpt-roadmap-label-w) + var(--%NS%kpt-roadmap-track-w));min-inline-size:100%}.kpt-roadmap__grid{position:absolute;inset-block:0;inset-inline-start:var(--%NS%kpt-roadmap-label-w);inset-inline-end:0;z-index:0;pointer-events:none}.kpt-roadmap__grid-cells{block-size:100%}.kpt-roadmap__grid-cell{min-inline-size:0;border-inline-start:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border)}.kpt-roadmap__grid-cell:first-child{border-inline-start:0}.kpt-roadmap__grid-cell--weekend,.kpt-roadmap__grid-cell--non-working{background:var(--%NS%kpt-color-surface-sunken, var(--%NS%kpt-color-muted))}.kpt-roadmap__today{position:absolute;inset-block:0;inline-size:0;border-inline-start:var(--%NS%kpt-border-width-medium, 2px) dashed color-mix(in oklch,var(--%NS%kpt-color-primary) 40%,transparent)}.kpt-roadmap__today-dot{position:absolute;inset-block-end:0rem;inline-size:.5rem;block-size:.5rem;transform:translate(-50%);background:color-mix(in oklch,var(--%NS%kpt-color-primary) 40%,transparent);border-radius:var(--%NS%kpt-radius-full, 9999px);pointer-events:none}.kpt-roadmap__links{position:absolute;inset-block-start:0;inset-inline-start:var(--%NS%kpt-roadmap-label-w);z-index:2;pointer-events:none;overflow:visible}.kpt-roadmap__link-path{fill:none;stroke:var(--%NS%kpt-color-on-surface-muted);stroke-width:1.75}.kpt-roadmap__link-arrow{fill:var(--%NS%kpt-color-on-surface-muted)}.kpt-roadmap__link--violated .kpt-roadmap__link-path{stroke:var(--%NS%kpt-color-danger);stroke-dasharray:4 3}.kpt-roadmap__link--violated .kpt-roadmap__link-arrow{fill:var(--%NS%kpt-color-danger)}.kpt-roadmap__row{position:absolute;inset-inline:0;border-block-end:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border)}.kpt-roadmap__row:hover{background:color-mix(in oklch,var(--%NS%kpt-color-primary) 10%,transparent)}.kpt-roadmap__row:hover .kpt-roadmap__label{background:color-mix(in oklch,var(--%NS%kpt-color-primary) 10%,var(--%NS%kpt-color-surface))}.kpt-roadmap__row--group,.kpt-roadmap__row--group .kpt-roadmap__label{background:var(--%NS%kpt-color-surface-variant, var(--%NS%kpt-color-surface))}.kpt-roadmap__row--%NS%group:hover,.kpt-roadmap__row--%NS%group:hover .kpt-roadmap__label{background:color-mix(in oklch,var(--%NS%kpt-color-primary) 10%,var(--%NS%kpt-color-surface-variant, var(--%NS%kpt-color-surface)))}.kpt-roadmap__label{position:sticky;inset-inline-start:0;z-index:3;display:flex;flex-direction:column;justify-content:center;gap:.125rem;min-inline-size:0;padding-inline-end:var(--%NS%kpt-space-3, .75rem);background:var(--%NS%kpt-color-surface);border-inline-end:var(--%NS%kpt-border-width-thin, 1px) solid var(--%NS%kpt-color-border)}.kpt-roadmap__label--group{justify-content:start;flex-direction:row;align-items:center;gap:var(--%NS%kpt-space-2, .5rem)}.kpt-roadmap__label-text{overflow:hidden;font-size:var(--%NS%kpt-font-size-sm, .875rem);font-weight:var(--%NS%kpt-font-weight-medium, 500);text-overflow:ellipsis;white-space:nowrap}.kpt-roadmap__label-text--group{font-weight:var(--%NS%kpt-font-weight-semibold, 600)}.kpt-roadmap__label-sub{overflow:hidden;font-size:var(--%NS%kpt-font-size-xs, .75rem);color:var(--%NS%kpt-color-on-surface-muted);text-overflow:ellipsis;white-space:nowrap}.kpt-roadmap__label-stack{display:flex;flex-direction:column;justify-content:center;gap:.125rem;min-inline-size:0}.kpt-roadmap__label-count{align-self:center;flex:0 0 auto;padding:0 var(--%NS%kpt-space-2, .5rem);font-size:var(--%NS%kpt-font-size-xs, .75rem);color:var(--%NS%kpt-color-on-surface-muted);background:var(--%NS%kpt-color-muted);border-radius:var(--%NS%kpt-radius-full, 9999px)}.kpt-roadmap__toggle{display:inline-flex;flex:0 0 auto;align-items:center;justify-content:center;inline-size:1.25rem;block-size:1.25rem;padding:0;color:inherit;cursor:pointer;background:transparent;border:0;border-radius:var(--%NS%kpt-radius-sm, .25rem)}.kpt-roadmap__toggle:focus-visible{outline:var(--%NS%kpt-border-width-medium, 2px) solid var(--%NS%kpt-color-focus-ring);outline-offset:1px}.kpt-roadmap__toggle-icon{inline-size:0;block-size:0;border-block-start:.3rem solid transparent;border-block-end:.3rem solid transparent;border-inline-start:.4rem solid currentcolor;transition:transform var(--%NS%kpt-motion-duration-fast, .12s) var(--%NS%kpt-motion-easing-standard)}.kpt-roadmap__toggle-icon--open{transform:rotate(90deg)}.kpt-roadmap__lane{position:relative;min-inline-size:0}.kpt-roadmap__bar,.kpt-roadmap__milestone,.kpt-roadmap__summary{--%NS%_color: var(--%NS%kpt-color-primary)}.kpt-roadmap__bar[data-variant=neutral],.kpt-roadmap__milestone[data-variant=neutral],.kpt-roadmap__summary[data-variant=neutral]{--%NS%_color: var(--%NS%kpt-color-muted)}.kpt-roadmap__bar[data-variant=success],.kpt-roadmap__milestone[data-variant=success],.kpt-roadmap__summary[data-variant=success]{--%NS%_color: var(--%NS%kpt-color-success)}.kpt-roadmap__bar[data-variant=danger],.kpt-roadmap__milestone[data-variant=danger],.kpt-roadmap__summary[data-variant=danger]{--%NS%_color: var(--%NS%kpt-color-danger)}.kpt-roadmap__bar[data-variant=warning],.kpt-roadmap__milestone[data-variant=warning],.kpt-roadmap__summary[data-variant=warning]{--%NS%_color: var(--%NS%kpt-color-warning)}.kpt-roadmap__bar[data-variant=info],.kpt-roadmap__milestone[data-variant=info],.kpt-roadmap__summary[data-variant=info]{--%NS%_color: var(--%NS%kpt-color-info)}.kpt-roadmap__bar{position:absolute;z-index:1;display:flex;align-items:center;min-inline-size:.25rem;padding-inline:var(--%NS%kpt-space-2, .5rem);overflow:hidden;cursor:pointer;background:var(--%NS%_color);border-radius:var(--%NS%kpt-radius-full, 9999px);transition:filter var(--%NS%kpt-motion-duration-fast, .12s) var(--%NS%kpt-motion-easing-standard)}.kpt-roadmap__bar:hover{filter:brightness(1.08)}.kpt-roadmap__bar:focus-visible{outline:var(--%NS%kpt-border-width-medium, 2px) solid var(--%NS%kpt-color-focus-ring);outline-offset:2px}.kpt-roadmap__bar--disabled{cursor:default;opacity:.55}.kpt-roadmap__bar--clipped-start{border-start-start-radius:0;border-end-start-radius:0;clip-path:polygon(.5rem 0,100% 0,100% 100%,.5rem 100%,0 50%)}.kpt-roadmap__bar--clipped-end{border-start-end-radius:0;border-end-end-radius:0;clip-path:polygon(0 0,calc(100% - .5rem) 0,100% 50%,calc(100% - .5rem) 100%,0 100%)}.kpt-roadmap__bar--clipped-start.kpt-roadmap__bar--clipped-end{clip-path:polygon(.5rem 0,calc(100% - .5rem) 0,100% 50%,calc(100% - .5rem) 100%,.5rem 100%,0 50%)}.kpt-roadmap__bar-progress{position:absolute;inset-block:0;inset-inline-start:0;background:#00000038;pointer-events:none}.kpt-roadmap__bar-label{position:relative;overflow:hidden;font-size:var(--%NS%kpt-font-size-xs, .75rem);font-weight:var(--%NS%kpt-font-weight-medium, 500);color:var(--%NS%kpt-color-text-inverse, #fff);text-overflow:ellipsis;white-space:nowrap}.kpt-roadmap__bar[data-variant=neutral] .kpt-roadmap__bar-label{color:var(--%NS%kpt-color-on-muted)}.kpt-roadmap__milestone{position:absolute;z-index:1;cursor:pointer;background:var(--%NS%_color);transform:translate(-50%) rotate(45deg);border-radius:var(--%NS%kpt-radius-sm, .25rem)}.kpt-roadmap__milestone:focus-visible{outline:var(--%NS%kpt-border-width-medium, 2px) solid var(--%NS%kpt-color-focus-ring);outline-offset:2px}.kpt-roadmap__summary{position:absolute;inset-block-start:50%;z-index:1;block-size:.5rem;background:var(--%NS%_color);border-radius:var(--%NS%kpt-radius-full, 9999px);transform:translateY(-50%)}.kpt-roadmap__summary[data-variant=neutral]{--%NS%_color: var(--%NS%kpt-color-on-surface-muted)}.kpt-roadmap__empty{padding:var(--%NS%kpt-space-8, 2rem);color:var(--%NS%kpt-color-on-surface-muted);text-align:center}}\n"], encapsulation: 2 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(KptRoadmap, [{
+        type: Component,
+        args: [{ selector: 'kpt-roadmap', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [KptTooltip], host: {
+                    class: 'kpt-roadmap',
+                    '[style.--kpt-roadmap-cells]': 'timeline().cells.length',
+                    '[style.--kpt-roadmap-cell-w.px]': 'cellWidth()',
+                    '[style.--kpt-roadmap-label-w]': 'labelWidth()',
+                    '[class.kpt-roadmap--fixed-height]': '!!scrollHeight()',
+                }, template: "<div\n  #scrollEl\n  class=\"kpt-roadmap__scroll\"\n  [style.max-block-size]=\"scrollHeight()\"\n  (scroll)=\"onScroll($event)\"\n>\n  <!-- Nag\u0142\u00F3wek: przykleja si\u0119 do g\u00F3ry, gdy podano sta\u0142\u0105 wysoko\u015B\u0107. -->\n  <div class=\"kpt-roadmap__head\">\n    <div class=\"kpt-roadmap__head-label\"></div>\n\n    <div class=\"kpt-roadmap__head-track\">\n      @if (timeline().hasBands) {\n        <div class=\"kpt-roadmap__bands\">\n          @for (band of timeline().bands; track band.key) {\n            <div\n              class=\"kpt-roadmap__band\"\n              [class.kpt-roadmap__band--year-start]=\"band.isYearStart\"\n              [style.inline-size.%]=\"(band.ratioEnd - band.ratioStart) * 100\"\n              [kptTooltip]=\"band.sublabel ? band.label + ' ' + band.sublabel : band.label\"\n              kptTooltipOnlyWhenTruncated\n            >\n              @if (band.yearBadge) {\n                <span class=\"kpt-roadmap__year-badge\">{{ band.yearBadge }}</span>\n              }\n              <span class=\"kpt-roadmap__band-label\">{{ band.label }}</span>\n              @if (band.sublabel && !band.yearBadge) {\n                <span class=\"kpt-roadmap__band-sublabel\">{{ band.sublabel }}</span>\n              }\n            </div>\n          }\n        </div>\n      }\n\n      <!-- Nag\u0142\u00F3wek definiuje siatk\u0119, wi\u0119c to on jest \u017Ar\u00F3d\u0142em pomiaru szeroko\u015Bci toru. -->\n      <div #laneMeasure class=\"kpt-roadmap__cells\">\n        @for (cell of timeline().cells; track cell.key) {\n          <div\n            class=\"kpt-roadmap__cell\"\n            [class.kpt-roadmap__cell--weekend]=\"cell.isWeekend\"\n            [class.kpt-roadmap__cell--today]=\"cell.isToday && showToday()\"\n            [class.kpt-roadmap__cell--year-boundary]=\"cell.isYearBoundary\"\n            [class.kpt-roadmap__cell--gap-before]=\"cell.hasGapBefore\"\n            [style.inline-size.%]=\"(cell.ratioEnd - cell.ratioStart) * 100\"\n            [kptTooltip]=\"cell.title\"\n          >\n            <span class=\"kpt-roadmap__cell-label\">{{ cell.label }}</span>\n            @if (cell.sublabel) {\n              <span class=\"kpt-roadmap__cell-sublabel\">{{ cell.sublabel }}</span>\n            }\n          </div>\n        }\n      </div>\n\n      <!-- Znacznik \u201Edzi\u015B\" mieszka w nag\u0142\u00F3wku: warstwa siatki ma w\u0142asny kontekst\n           uk\u0142adania, wi\u0119c nic w niej nie mo\u017Ce znale\u017A\u0107 si\u0119 nad nag\u0142\u00F3wkiem. -->\n      @if (showToday() && timeline().todayRatio !== null) {\n        <span\n          class=\"kpt-roadmap__today-dot\"\n          [style.inset-inline-start.%]=\"timeline().todayRatio! * 100\"\n          [attr.title]=\"i18n.t('roadmap.today')\"\n        ></span>\n      }\n    </div>\n  </div>\n\n  @if (isEmpty()) {\n    <div class=\"kpt-roadmap__empty\">{{ i18n.t('roadmap.empty') }}</div>\n  } @else {\n    <div class=\"kpt-roadmap__body\" [style.block-size.px]=\"layout().totalHeight\">\n      <!-- Siatka t\u0142a: kolumny weekendowe, granice roku i znacznik dzi\u015B. -->\n      <div class=\"kpt-roadmap__grid\" aria-hidden=\"true\">\n        <div class=\"kpt-roadmap__grid-cells\">\n          @for (cell of timeline().cells; track cell.key) {\n            <div\n              class=\"kpt-roadmap__grid-cell\"\n              [class.kpt-roadmap__grid-cell--weekend]=\"cell.isWeekend\"\n              [class.kpt-roadmap__grid-cell--non-working]=\"cell.isNonWorking\"\n              [class.kpt-roadmap__grid-cell--year-boundary]=\"cell.isYearBoundary\"\n              [class.kpt-roadmap__grid-cell--gap-before]=\"cell.hasGapBefore\"\n              [style.inline-size.%]=\"(cell.ratioEnd - cell.ratioStart) * 100\"\n            ></div>\n          }\n        </div>\n\n        @if (showToday() && timeline().todayRatio !== null) {\n          <!-- Sama prowadnica; znacznik siedzi w nag\u0142\u00F3wku, \u017Ceby by\u0142 nad nim widoczny. -->\n          <div class=\"kpt-roadmap__today\" [style.inset-inline-start.%]=\"timeline().todayRatio! * 100\"></div>\n        }\n      </div>\n\n      <!-- Zale\u017Cno\u015Bci rysowane nad paskami, pod kolumn\u0105 etykiet. -->\n      @if (links().length > 0) {\n        <svg\n          class=\"kpt-roadmap__links\"\n          [attr.viewBox]=\"'0 0 ' + laneWidth() + ' ' + layout().totalHeight\"\n          [attr.width]=\"laneWidth()\"\n          [attr.height]=\"layout().totalHeight\"\n          aria-hidden=\"true\"\n        >\n          @for (link of links(); track link.key) {\n            <g\n              class=\"kpt-roadmap__link\"\n              [class.kpt-roadmap__link--violated]=\"link.isViolated\"\n              [attr.data-variant]=\"link.variant\"\n            >\n              <path class=\"kpt-roadmap__link-path\" [attr.d]=\"link.path\" [style.stroke]=\"link.color\" />\n              <path class=\"kpt-roadmap__link-arrow\" [attr.d]=\"link.arrow\" [style.fill]=\"link.color\" />\n            </g>\n          }\n        </svg>\n      }\n\n      @for (row of visibleRows(); track row.key) {\n        <div\n          class=\"kpt-roadmap__row\"\n          [class.kpt-roadmap__row--group]=\"row.kind === 'group'\"\n          [style.inset-block-start.px]=\"row.top\"\n          [style.block-size.px]=\"row.height\"\n        >\n          <div\n            class=\"kpt-roadmap__label\"\n            [style.padding-inline-start.rem]=\"0.75 + row.depth * 1\"\n            [class.kpt-roadmap__label--group]=\"row.kind === 'group'\"\n            [kptTooltip]=\"labelTooltip(row)\"\n            kptTooltipOnlyWhenTruncated\n          >\n            @if (row.group; as group) {\n              <button\n                type=\"button\"\n                class=\"kpt-roadmap__toggle\"\n                [attr.aria-expanded]=\"!isCollapsed(group)\"\n                [attr.aria-label]=\"isCollapsed(group) ? i18n.t('roadmap.expandGroup') : i18n.t('roadmap.collapseGroup')\"\n                (click)=\"toggleGroup(group)\"\n              >\n                <span class=\"kpt-roadmap__toggle-icon\" [class.kpt-roadmap__toggle-icon--open]=\"!isCollapsed(group)\">\n                </span>\n              </button>\n              <!-- Dymek siedzi na stacku, nie na ca\u0142ej etykiecie: w grupie tekst jest\n                   o poziom g\u0142\u0119biej, a pomiar obejmuje tylko bezpo\u015Brednie dzieci hosta. -->\n              <span\n                class=\"kpt-roadmap__label-stack\"\n                [kptTooltip]=\"group.sublabel ? group.label + ' \u2014 ' + group.sublabel : group.label\"\n                kptTooltipOnlyWhenTruncated\n              >\n                <span class=\"kpt-roadmap__label-text kpt-roadmap__label-text--group\">{{ group.label }}</span>\n                @if (group.sublabel) {\n                  <span class=\"kpt-roadmap__label-sub\">{{ group.sublabel }}</span>\n                }\n              </span>\n              @if (row.groupState; as state) {\n                @if (state.itemCount) {\n                  <span class=\"kpt-roadmap__label-count\">{{ state.itemCount }}</span>\n                }\n              }\n            } @else if (row.items[0]; as first) {\n              <span class=\"kpt-roadmap__label-text\">{{ first.source.label }}</span>\n              @if (row.items.length === 1 && first.source.sublabel) {\n                <span class=\"kpt-roadmap__label-sub\">{{ first.source.sublabel }}</span>\n              }\n            }\n          </div>\n\n          <div class=\"kpt-roadmap__lane\">\n            @if (row.kind === 'group') {\n              @if (summary(row); as sum) {\n                <div\n                  class=\"kpt-roadmap__summary\"\n                  [attr.data-variant]=\"sum.variant\"\n                  [style.inset-inline-start.%]=\"sum.left\"\n                  [style.inline-size.%]=\"sum.width\"\n                  [style.background]=\"sum.color\"\n                ></div>\n              }\n            } @else {\n              @for (bar of bars(row); track bar.item.id) {\n                @if (bar.isMilestone) {\n                  <div\n                    class=\"kpt-roadmap__milestone\"\n                    [attr.data-variant]=\"bar.variant\"\n                    [kptTooltip]=\"bar.title\"\n                    [attr.aria-label]=\"i18n.t('roadmap.milestone') + ': ' + bar.label\"\n                    [style.inset-inline-start.%]=\"bar.left\"\n                    [style.inset-block-start.px]=\"bar.top\"\n                    [style.inline-size.px]=\"bar.height\"\n                    [style.block-size.px]=\"bar.height\"\n                    [style.background]=\"bar.color\"\n                    tabindex=\"0\"\n                    (click)=\"onItemClick(bar.item)\"\n                    (keydown)=\"onItemKeydown($event, bar.item)\"\n                  ></div>\n                } @else {\n                  <div\n                    class=\"kpt-roadmap__bar\"\n                    [attr.data-variant]=\"bar.variant\"\n                    [kptTooltip]=\"bar.title\"\n                    kptTooltipOnlyWhenTruncated\n                    [class.kpt-roadmap__bar--clipped-start]=\"bar.clippedStart\"\n                    [class.kpt-roadmap__bar--clipped-end]=\"bar.clippedEnd\"\n                    [class.kpt-roadmap__bar--disabled]=\"bar.item.source.disabled\"\n                    [style.inset-inline-start.%]=\"bar.left\"\n                    [style.inline-size.%]=\"bar.width\"\n                    [style.inset-block-start.px]=\"bar.top\"\n                    [style.block-size.px]=\"bar.height\"\n                    [style.background]=\"bar.color\"\n                    tabindex=\"0\"\n                    (click)=\"onItemClick(bar.item)\"\n                    (keydown)=\"onItemKeydown($event, bar.item)\"\n                  >\n                    @if (bar.progress !== null) {\n                      <span class=\"kpt-roadmap__bar-progress\" [style.inline-size.%]=\"bar.progress * 100\"></span>\n                    }\n                    <span class=\"kpt-roadmap__bar-label\">{{ bar.label }}</span>\n                  </div>\n                }\n              }\n            }\n          </div>\n        </div>\n      }\n    </div>\n  }\n</div>\n", styles: ["@layer kpt.components{.kpt-roadmap{display:block;--kpt-roadmap-cells: 1;--kpt-roadmap-cell-w: 76px;--kpt-roadmap-label-w: 14rem;--kpt-roadmap-track-w: calc(var(--kpt-roadmap-cell-w) * var(--kpt-roadmap-cells));color:var(--kpt-color-on-surface);font-family:var(--kpt-font-family-sans);background:var(--kpt-color-surface);border:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border);border-radius:var(--kpt-radius-lg, .75rem);overflow:hidden}.kpt-roadmap__scroll{overflow:auto;position:relative}.kpt-roadmap__head,.kpt-roadmap__row{display:grid;grid-template-columns:var(--kpt-roadmap-label-w) minmax(var(--kpt-roadmap-track-w),1fr);inline-size:max-content;min-inline-size:100%}.kpt-roadmap__head{position:sticky;inset-block-start:0;z-index:4;background:var(--kpt-color-surface-variant, var(--kpt-color-surface));border-block-end:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border)}.kpt-roadmap__head-label{position:sticky;inset-inline-start:0;z-index:5;background:var(--kpt-color-surface-variant, var(--kpt-color-surface));border-inline-end:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border)}.kpt-roadmap__head-track{position:relative;display:flex;flex-direction:column;min-inline-size:0}.kpt-roadmap__bands,.kpt-roadmap__cells,.kpt-roadmap__grid-cells{display:flex;inline-size:100%}.kpt-roadmap__band{position:relative;display:flex;align-items:center;justify-content:center;gap:var(--kpt-space-2, .5rem);min-inline-size:0;padding:var(--kpt-space-2, .5rem) var(--kpt-space-3, .75rem);font-size:var(--kpt-font-size-sm, .875rem);font-weight:var(--kpt-font-weight-medium, 500);color:var(--kpt-color-on-surface-muted);white-space:nowrap;overflow:hidden;border-inline-start:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border)}.kpt-roadmap__band:first-child{border-inline-start:0}.kpt-roadmap__band--year-start{border-inline-start:var(--kpt-border-width-medium, 2px) solid var(--kpt-color-border-strong)}.kpt-roadmap__band-label{overflow:hidden;text-overflow:ellipsis}.kpt-roadmap__band-sublabel{color:var(--kpt-color-text-subtle, var(--kpt-color-on-surface-muted))}.kpt-roadmap__year-badge{display:inline-flex;align-items:center;padding:.125rem var(--kpt-space-2, .5rem);font-size:var(--kpt-font-size-xs, .75rem);font-weight:var(--kpt-font-weight-semibold, 600);color:var(--kpt-color-surface);background:var(--kpt-color-on-surface);border-radius:var(--kpt-radius-full, 9999px)}.kpt-roadmap__cell{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:.125rem;min-inline-size:0;padding:var(--kpt-space-2, .5rem) .25rem;text-align:center;white-space:nowrap;border-inline-start:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border)}.kpt-roadmap__cell:first-child{border-inline-start:0}.kpt-roadmap__cell-label{font-size:var(--kpt-font-size-xs, .75rem);font-weight:var(--kpt-font-weight-semibold, 600);letter-spacing:.02em;text-transform:uppercase;color:var(--kpt-color-on-surface-muted)}.kpt-roadmap__cell-sublabel{font-size:var(--kpt-font-size-xs, .75rem);color:var(--kpt-color-text-subtle, var(--kpt-color-on-surface-muted));overflow:hidden;text-overflow:ellipsis;inline-size:100%}.kpt-roadmap__cell--weekend{background:var(--kpt-color-surface-sunken, var(--kpt-color-muted))}.kpt-roadmap__cell--today .kpt-roadmap__cell-label{color:var(--kpt-color-primary)}.kpt-roadmap__cell--year-boundary,.kpt-roadmap__grid-cell--year-boundary{border-inline-start:var(--kpt-border-width-medium, 2px) solid var(--kpt-color-border-strong)}.kpt-roadmap__cell--gap-before,.kpt-roadmap__grid-cell--gap-before{border-inline-start:var(--kpt-border-width-thin, 1px) dashed var(--kpt-color-border-strong)}.kpt-roadmap__body{position:relative;inline-size:calc(var(--kpt-roadmap-label-w) + var(--kpt-roadmap-track-w));min-inline-size:100%}.kpt-roadmap__grid{position:absolute;inset-block:0;inset-inline-start:var(--kpt-roadmap-label-w);inset-inline-end:0;z-index:0;pointer-events:none}.kpt-roadmap__grid-cells{block-size:100%}.kpt-roadmap__grid-cell{min-inline-size:0;border-inline-start:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border)}.kpt-roadmap__grid-cell:first-child{border-inline-start:0}.kpt-roadmap__grid-cell--weekend,.kpt-roadmap__grid-cell--non-working{background:var(--kpt-color-surface-sunken, var(--kpt-color-muted))}.kpt-roadmap__today{position:absolute;inset-block:0;inline-size:0;border-inline-start:var(--kpt-border-width-medium, 2px) dashed color-mix(in oklch,var(--kpt-color-primary) 40%,transparent)}.kpt-roadmap__today-dot{position:absolute;inset-block-end:0rem;inline-size:.5rem;block-size:.5rem;transform:translate(-50%);background:color-mix(in oklch,var(--kpt-color-primary) 40%,transparent);border-radius:var(--kpt-radius-full, 9999px);pointer-events:none}.kpt-roadmap__links{position:absolute;inset-block-start:0;inset-inline-start:var(--kpt-roadmap-label-w);z-index:2;pointer-events:none;overflow:visible}.kpt-roadmap__link-path{fill:none;stroke:var(--kpt-color-on-surface-muted);stroke-width:1.75}.kpt-roadmap__link-arrow{fill:var(--kpt-color-on-surface-muted)}.kpt-roadmap__link--violated .kpt-roadmap__link-path{stroke:var(--kpt-color-danger);stroke-dasharray:4 3}.kpt-roadmap__link--violated .kpt-roadmap__link-arrow{fill:var(--kpt-color-danger)}.kpt-roadmap__row{position:absolute;inset-inline:0;border-block-end:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border)}.kpt-roadmap__row:hover{background:color-mix(in oklch,var(--kpt-color-primary) 10%,transparent)}.kpt-roadmap__row:hover .kpt-roadmap__label{background:color-mix(in oklch,var(--kpt-color-primary) 10%,var(--kpt-color-surface))}.kpt-roadmap__row--group,.kpt-roadmap__row--group .kpt-roadmap__label{background:var(--kpt-color-surface-variant, var(--kpt-color-surface))}.kpt-roadmap__row--group:hover,.kpt-roadmap__row--group:hover .kpt-roadmap__label{background:color-mix(in oklch,var(--kpt-color-primary) 10%,var(--kpt-color-surface-variant, var(--kpt-color-surface)))}.kpt-roadmap__label{position:sticky;inset-inline-start:0;z-index:3;display:flex;flex-direction:column;justify-content:center;gap:.125rem;min-inline-size:0;padding-inline-end:var(--kpt-space-3, .75rem);background:var(--kpt-color-surface);border-inline-end:var(--kpt-border-width-thin, 1px) solid var(--kpt-color-border)}.kpt-roadmap__label--group{justify-content:start;flex-direction:row;align-items:center;gap:var(--kpt-space-2, .5rem)}.kpt-roadmap__label-text{overflow:hidden;font-size:var(--kpt-font-size-sm, .875rem);font-weight:var(--kpt-font-weight-medium, 500);text-overflow:ellipsis;white-space:nowrap}.kpt-roadmap__label-text--group{font-weight:var(--kpt-font-weight-semibold, 600)}.kpt-roadmap__label-sub{overflow:hidden;font-size:var(--kpt-font-size-xs, .75rem);color:var(--kpt-color-on-surface-muted);text-overflow:ellipsis;white-space:nowrap}.kpt-roadmap__label-stack{display:flex;flex-direction:column;justify-content:center;gap:.125rem;min-inline-size:0}.kpt-roadmap__label-count{align-self:center;flex:0 0 auto;padding:0 var(--kpt-space-2, .5rem);font-size:var(--kpt-font-size-xs, .75rem);color:var(--kpt-color-on-surface-muted);background:var(--kpt-color-muted);border-radius:var(--kpt-radius-full, 9999px)}.kpt-roadmap__toggle{display:inline-flex;flex:0 0 auto;align-items:center;justify-content:center;inline-size:1.25rem;block-size:1.25rem;padding:0;color:inherit;cursor:pointer;background:transparent;border:0;border-radius:var(--kpt-radius-sm, .25rem)}.kpt-roadmap__toggle:focus-visible{outline:var(--kpt-border-width-medium, 2px) solid var(--kpt-color-focus-ring);outline-offset:1px}.kpt-roadmap__toggle-icon{inline-size:0;block-size:0;border-block-start:.3rem solid transparent;border-block-end:.3rem solid transparent;border-inline-start:.4rem solid currentcolor;transition:transform var(--kpt-motion-duration-fast, .12s) var(--kpt-motion-easing-standard)}.kpt-roadmap__toggle-icon--open{transform:rotate(90deg)}.kpt-roadmap__lane{position:relative;min-inline-size:0}.kpt-roadmap__bar,.kpt-roadmap__milestone,.kpt-roadmap__summary{--_color: var(--kpt-color-primary)}.kpt-roadmap__bar[data-variant=neutral],.kpt-roadmap__milestone[data-variant=neutral],.kpt-roadmap__summary[data-variant=neutral]{--_color: var(--kpt-color-muted)}.kpt-roadmap__bar[data-variant=success],.kpt-roadmap__milestone[data-variant=success],.kpt-roadmap__summary[data-variant=success]{--_color: var(--kpt-color-success)}.kpt-roadmap__bar[data-variant=danger],.kpt-roadmap__milestone[data-variant=danger],.kpt-roadmap__summary[data-variant=danger]{--_color: var(--kpt-color-danger)}.kpt-roadmap__bar[data-variant=warning],.kpt-roadmap__milestone[data-variant=warning],.kpt-roadmap__summary[data-variant=warning]{--_color: var(--kpt-color-warning)}.kpt-roadmap__bar[data-variant=info],.kpt-roadmap__milestone[data-variant=info],.kpt-roadmap__summary[data-variant=info]{--_color: var(--kpt-color-info)}.kpt-roadmap__bar{position:absolute;z-index:1;display:flex;align-items:center;min-inline-size:.25rem;padding-inline:var(--kpt-space-2, .5rem);overflow:hidden;cursor:pointer;background:var(--_color);border-radius:var(--kpt-radius-full, 9999px);transition:filter var(--kpt-motion-duration-fast, .12s) var(--kpt-motion-easing-standard)}.kpt-roadmap__bar:hover{filter:brightness(1.08)}.kpt-roadmap__bar:focus-visible{outline:var(--kpt-border-width-medium, 2px) solid var(--kpt-color-focus-ring);outline-offset:2px}.kpt-roadmap__bar--disabled{cursor:default;opacity:.55}.kpt-roadmap__bar--clipped-start{border-start-start-radius:0;border-end-start-radius:0;clip-path:polygon(.5rem 0,100% 0,100% 100%,.5rem 100%,0 50%)}.kpt-roadmap__bar--clipped-end{border-start-end-radius:0;border-end-end-radius:0;clip-path:polygon(0 0,calc(100% - .5rem) 0,100% 50%,calc(100% - .5rem) 100%,0 100%)}.kpt-roadmap__bar--clipped-start.kpt-roadmap__bar--clipped-end{clip-path:polygon(.5rem 0,calc(100% - .5rem) 0,100% 50%,calc(100% - .5rem) 100%,.5rem 100%,0 50%)}.kpt-roadmap__bar-progress{position:absolute;inset-block:0;inset-inline-start:0;background:#00000038;pointer-events:none}.kpt-roadmap__bar-label{position:relative;overflow:hidden;font-size:var(--kpt-font-size-xs, .75rem);font-weight:var(--kpt-font-weight-medium, 500);color:var(--kpt-color-text-inverse, #fff);text-overflow:ellipsis;white-space:nowrap}.kpt-roadmap__bar[data-variant=neutral] .kpt-roadmap__bar-label{color:var(--kpt-color-on-muted)}.kpt-roadmap__milestone{position:absolute;z-index:1;cursor:pointer;background:var(--_color);transform:translate(-50%) rotate(45deg);border-radius:var(--kpt-radius-sm, .25rem)}.kpt-roadmap__milestone:focus-visible{outline:var(--kpt-border-width-medium, 2px) solid var(--kpt-color-focus-ring);outline-offset:2px}.kpt-roadmap__summary{position:absolute;inset-block-start:50%;z-index:1;block-size:.5rem;background:var(--_color);border-radius:var(--kpt-radius-full, 9999px);transform:translateY(-50%)}.kpt-roadmap__summary[data-variant=neutral]{--_color: var(--kpt-color-on-surface-muted)}.kpt-roadmap__empty{padding:var(--kpt-space-8, 2rem);color:var(--kpt-color-on-surface-muted);text-align:center}}\n"] }]
+    }], () => [], { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: true }] }], scrollHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "scrollHeight", required: false }] }], labelWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "labelWidth", required: false }] }], cellWidthPx: [{ type: i0.Input, args: [{ isSignal: true, alias: "cellWidthPx", required: false }] }], showToday: [{ type: i0.Input, args: [{ isSignal: true, alias: "showToday", required: false }] }], virtual: [{ type: i0.Input, args: [{ isSignal: true, alias: "virtual", required: false }] }], collapsedGroups: [{ type: i0.Input, args: [{ isSignal: true, alias: "collapsedGroups", required: false }] }, { type: i0.Output, args: ["collapsedGroupsChange"] }], itemClick: [{ type: i0.Output, args: ["itemClick"] }], rangeChange: [{ type: i0.Output, args: ["rangeChange"] }], scrollEl: [{ type: i0.ViewChild, args: ['scrollEl', { isSignal: true }] }], laneEl: [{ type: i0.ViewChild, args: ['laneMeasure', { isSignal: true }] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(KptRoadmap, { className: "KptRoadmap", filePath: "lib/roadmap.component.ts", lineNumber: 94 }); })();
+
+/*
+ * Public API — @konce-pt/angular/roadmap
+ * Roadmapa / oś czasu typu Gantt (sygnały, zoneless). Rdzeń obliczeń: pure TS.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { KptRoadmap, addDays, addHours, addMonths, addUnits, arrowHead, autoRange, buildRows, buildTimeline, ceilToUnit, countUnits, daysInMonth, diffDays, floorToUnit, isSameDay, isoWeekNumber, isoWeekYear, isoWeekday, isoWeeksInYear, linkGeometry, normalizeItems, packLanes, resolveLinks, resolveRange, rollupProgress, roundedPolyline, sliceRows, spanOf, startOfDay, startOfIsoWeek, toTimestamp };
+//# sourceMappingURL=konce-pt-angular-roadmap.mjs.map