@konce-pt/angular 0.6.1 → 0.7.5

package/types/konce-pt-angular-roadmap.d.ts

@@ -0,0 +1,649 @@
+import * as _konce_pt_angular_roadmap from '@konce-pt/angular/roadmap';
+import * as _angular_core from '@angular/core';
+import { KptI18n } from '@konce-pt/angular';
+
+/** Akceptowane formy daty na wejściu; rdzeń normalizuje je do epoch ms (czas LOKALNY). */
+type KptDateInput = Date | number | string;
+/** Poziom przybliżenia osi czasu. */
+type KptRoadmapZoom = 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour';
+/** Warianty kolorystyczne spójne z resztą biblioteki. */
+type KptRoadmapVariant = 'neutral' | 'primary' | 'success' | 'danger' | 'warning' | 'info';
+/** Zamknięty przedział czasu w epoch ms. */
+interface KptTimeRange {
+    /** Początek włącznie (ms). */
+    start: number;
+    /** Koniec wyłącznie (ms). */
+    end: number;
+}
+/** Punkt w układzie px overlaya SVG. */
+interface KptRoadmapPoint {
+    x: number;
+    y: number;
+}
+/** Prostokąt w px overlaya SVG. */
+interface KptRoadmapRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Typ zależności wg konwencji zarządzania projektami. */
+type KptRoadmapLinkType = 'FS' | 'SS' | 'FF' | 'SF';
+/** Krawędź grafu zależności między dwoma itemami. */
+interface KptRoadmapLink<TMeta = unknown> {
+    /** Stabilny klucz (trackBy); generowany z `from`/`to`/`type`, gdy brak. */
+    id?: string;
+    /** `id` itemu-poprzednika. */
+    from: string;
+    /** `id` itemu-następnika. */
+    to: string;
+    /** Domyślnie 'FS' (finish-to-start). */
+    type?: KptRoadmapLinkType;
+    /** Wyprzedzenie/opóźnienie w ms (ujemne = lead). Domyślnie 0. */
+    lag?: number;
+    variant?: KptRoadmapVariant;
+    color?: string;
+    meta?: TMeta;
+}
+/** Ograniczenia edycyjne — zarezerwowane pod drag&drop (v1 ich nie czyta). */
+interface KptRoadmapConstraints {
+    /** Item nie może zacząć się wcześniej niż tu. */
+    minStart?: KptDateInput;
+    /** Item nie może skończyć się później niż tu. */
+    maxEnd?: KptDateInput;
+    /** Minimalny czas trwania w ms. */
+    minDurationMs?: number;
+    /** Przyciąganie do jednostki podczas przeciągania. */
+    snap?: KptRoadmapZoom | 'none';
+}
+/** Pojedynczy pasek / kamień milowy roadmapy. */
+interface KptRoadmapItem<TMeta = unknown> {
+    /** Unikalny identyfikator (klucz trackBy i cel zależności). */
+    id: string;
+    /** Etykieta główna (kolumna sticky + wnętrze paska). */
+    label: string;
+    /** Etykieta pomocnicza (druga linia w kolumnie sticky). */
+    sublabel?: string;
+    /** Początek (czas lokalny). */
+    start: KptDateInput;
+    /** Koniec wyłącznie. Brak ⇒ kamień milowy (`end = start`). */
+    end?: KptDateInput;
+    /** Wymusza render jako romb, nawet gdy `end` podane. */
+    milestone?: boolean;
+    variant?: KptRoadmapVariant;
+    /** Dowolny kolor CSS — nadpisuje `variant`. */
+    color?: string;
+    /** Postęp 0..1; render jako wypełnienie wewnątrz paska. */
+    progress?: number;
+    /** Przynależność do grupy/swimlane. Brak ⇒ wiersz na poziomie 0. */
+    groupId?: string;
+    /** Zależności skrótowo: `string` = FS bez lagu. Scalane z `config.links`. */
+    dependsOn?: readonly (string | KptRoadmapLink)[];
+    /** Nazwa ikony (KptIconName) renderowana przed etykietą. */
+    icon?: string;
+    disabled?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    locked?: boolean;
+    constraints?: KptRoadmapConstraints;
+    /** Dane aplikacyjne przekazywane do szablonów i zdarzeń. */
+    meta?: TMeta;
+}
+/** Znormalizowany item — daty jako ms, wyliczone flagi. Wynik rdzenia. */
+interface KptRoadmapNormalizedItem<TMeta = unknown> {
+    readonly source: KptRoadmapItem<TMeta>;
+    readonly id: string;
+    readonly start: number;
+    readonly end: number;
+    readonly isMilestone: boolean;
+    readonly durationMs: number;
+}
+/** Sposób wyliczania paska zbiorczego grupy. */
+type KptRoadmapSummaryMode = 'auto' | 'none';
+/** Grupa / swimlane. Może być zagnieżdżona przez `parentId`. */
+interface KptRoadmapGroup<TMeta = unknown> {
+    id: string;
+    label: string;
+    sublabel?: string;
+    /** Grupa nadrzędna — API gotowe na drzewo; `depth` steruje wcięciem. */
+    parentId?: string;
+    /** Stan początkowy zwinięcia (dalej sterowany sygnałem komponentu). */
+    collapsed?: boolean;
+    variant?: KptRoadmapVariant;
+    color?: string;
+    /** 'auto' (domyślnie) = pasek od min(start) do max(end) potomków. */
+    summary?: KptRoadmapSummaryMode;
+    meta?: TMeta;
+}
+/** Okno godzin roboczych dla zoomu 'hour'. */
+interface KptWorkHours {
+    /** Pierwsza godzina robocza włącznie, 0..23 (domyślnie 8). */
+    from: number;
+    /** Ostatnia godzina wyłącznie, 1..24 (domyślnie 18). */
+    to: number;
+    /**
+     * 'skip' — godziny poza oknem nie mają kolumn (oś się skraca) [domyślne],
+     * 'dim'  — kolumny istnieją, dostają flagę `isNonWorking`.
+     */
+    mode?: 'skip' | 'dim';
+    /** Czy pomijać także całe dni weekendowe (domyślnie true przy mode='skip'). */
+    skipWeekends?: boolean;
+}
+/**
+ * Sposób odwzorowania czasu na pozycję.
+ * 'uniform' — każda kolumna ma równą szerokość, wewnątrz interpolacja liniowa po ms.
+ *             Doba po zmianie czasu (23/25 h) i luty nie są węższe od sąsiadów.
+ * 'linear'  — czysto liniowo (start..end → 0..1); kolumny wtedy nierówne.
+ */
+type KptRoadmapPositionMode = 'uniform' | 'linear';
+interface KptTimelineOptions {
+    /** BCP-47 dla `Intl`. Domyślnie locale z KptI18n. */
+    locale?: string;
+    /** „Dziś" — wstrzykiwalne dla testów i SSR. Domyślnie `new Date()`. */
+    today?: KptDateInput;
+    /** Dni weekendu wg `Date#getDay()`. Domyślnie `[0, 6]`. */
+    weekendDays?: readonly number[];
+    /** Godziny robocze — tylko przy `zoom: 'hour'`. */
+    workHours?: KptWorkHours;
+    /** Jednostka górnego poziomu nagłówka. Brak ⇒ domyślna dla zoomu. */
+    bandUnit?: KptRoadmapZoom | 'none';
+    /**
+     * Prefiks numeru tygodnia (domyślnie 'W').
+     * Rdzeń nie zna warstwy i18n — komponent podaje tu wartość z KptI18n.
+     */
+    weekPrefix?: string;
+    /** Domyślnie 'uniform'. */
+    positionMode?: KptRoadmapPositionMode;
+    /** Bezpiecznik przed eksplozją liczby kolumn. Domyślnie 4000. */
+    maxCells?: number;
+}
+type KptRoadmapRowMode = 'row-per-item' | 'pack';
+interface KptRoadmapRowOptions {
+    /** 'row-per-item' (domyślnie) lub 'pack' (kilka itemów w jednym wierszu). */
+    mode?: KptRoadmapRowMode;
+    /** Wysokość wiersza itemu w px. Domyślnie 44. */
+    itemHeight?: number;
+    /** Wysokość wiersza nagłówka grupy w px. Domyślnie 38. */
+    groupHeight?: number;
+    /** Wysokość jednego pasa w trybie 'pack'. Domyślnie 28. */
+    laneHeight?: number;
+    /** Minimalny odstęp między itemami w tym samym pasie (ms). Domyślnie 0. */
+    packMinGapMs?: number;
+    /** Czy pokazywać wiersz nagłówka dla itemów bez `groupId`. Domyślnie false. */
+    showUngroupedHeader?: boolean;
+    /** Etykieta pseudo-grupy dla itemów bez `groupId`. */
+    ungroupedLabel?: string;
+}
+interface KptRoadmapDependencyOptions {
+    /** Czy rysować overlay zależności. Domyślnie true. */
+    enabled?: boolean;
+    /** Długość wąsa wychodzącego z paska w px. Domyślnie 12. */
+    stub?: number;
+    /** Promień zaokrąglenia narożników łamanej w px. Domyślnie 6. */
+    cornerRadius?: number;
+    /** Rozmiar grotu strzałki w px. Domyślnie 6. */
+    arrowSize?: number;
+    /** Podświetlać zależności naruszone (następnik startuje za wcześnie). Domyślnie true. */
+    highlightViolations?: boolean;
+}
+/** Zarezerwowane pod v2 (drag&drop, resize, inline edit). W v1 ignorowane. */
+interface KptRoadmapInteractionOptions {
+    selectable?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    linkable?: boolean;
+    snap?: KptRoadmapZoom | 'none';
+}
+/** Pełna konfiguracja roadmapy — jeden obiekt wejściowy komponentu. */
+interface KptRoadmapConfig<TItem = unknown, TGroup = unknown> {
+    items: readonly KptRoadmapItem<TItem>[];
+    groups?: readonly KptRoadmapGroup<TGroup>[];
+    /** Zależności podane grafowo (alternatywa/uzupełnienie `item.dependsOn`). */
+    links?: readonly KptRoadmapLink[];
+    /** Domyślnie 'week'. */
+    zoom?: KptRoadmapZoom;
+    /** Zakres osi. Częściowy ⇒ brakujący kraniec z `autoRange`. Brak ⇒ cały `autoRange`. */
+    range?: Partial<KptTimeRange>;
+    locale?: string;
+    today?: KptDateInput;
+    timeline?: KptTimelineOptions;
+    rows?: KptRoadmapRowOptions;
+    dependencies?: KptRoadmapDependencyOptions;
+    interaction?: KptRoadmapInteractionOptions;
+}
+/** Rodzaj zmiany zgłaszanej przez interakcję (zdefiniowany w v1, emitowany od v2). */
+type KptRoadmapChangeKind = 'move' | 'resize-start' | 'resize-end' | 'link-add' | 'link-remove';
+/** Ładunek zdarzenia edycji — stabilny kontrakt na przyszłość. */
+interface KptRoadmapChange<TMeta = unknown> {
+    kind: KptRoadmapChangeKind;
+    item: KptRoadmapItem<TMeta>;
+    /** Poprzednie wartości (ms). */
+    previous: KptTimeRange;
+    /** Nowe wartości (ms). */
+    next: KptTimeRange;
+    /** Dla 'link-add' / 'link-remove'. */
+    link?: KptRoadmapLink;
+}
+
+type KptRoadmapRowKind = 'group' | 'item';
+/** Item osadzony w konkretnym wierszu i pasie. */
+interface KptRoadmapPlacedItem<TMeta = unknown> extends KptRoadmapNormalizedItem<TMeta> {
+    /** Indeks pasa w obrębie wiersza (0 przy trybie 'row-per-item'). */
+    lane: number;
+    rowKey: string;
+}
+/** Wyliczony agregat grupy. */
+interface KptRoadmapGroupState {
+    collapsed: boolean;
+    /** Liczba itemów należących do grupy. */
+    itemCount: number;
+    /** Zakres zbiorczy (null, gdy grupa pusta). */
+    span: KptTimeRange | null;
+    /** Postęp ważony czasem trwania, 0..1 (null, gdy żaden item go nie podaje). */
+    progress: number | null;
+}
+/** Wiersz renderowalny — jednostka wirtualizacji. */
+interface KptRoadmapRow<TItem = unknown, TGroup = unknown> {
+    key: string;
+    kind: KptRoadmapRowKind;
+    /** Indeks w spłaszczonej liście widocznych wierszy. */
+    index: number;
+    /** Poziom zagnieżdżenia — wcięcie w kolumnie etykiet. */
+    depth: number;
+    /** Offset od góry w px (skumulowany). */
+    top: number;
+    height: number;
+    /** Liczba pasów (>1 tylko w trybie 'pack'). */
+    laneCount: number;
+    /** Wypełnione dla `kind === 'group'`. */
+    group?: KptRoadmapGroup<TGroup>;
+    groupState?: KptRoadmapGroupState;
+    /** Wypełnione dla `kind === 'item'`. */
+    items: readonly KptRoadmapPlacedItem<TItem>[];
+}
+/** Wpis odrzucony przy normalizacji — do ostrzeżeń w trybie deweloperskim. */
+interface KptRoadmapInvalidItem {
+    id: string;
+    reason: string;
+}
+interface KptRoadmapLayout<TItem = unknown, TGroup = unknown> {
+    rows: readonly KptRoadmapRow<TItem, TGroup>[];
+    /** Łączna wysokość w px. */
+    totalHeight: number;
+    /** Wszystkie znormalizowane itemy po `id` — także te w zwiniętych grupach. */
+    byId: ReadonlyMap<string, KptRoadmapNormalizedItem<TItem>>;
+    /** Mapa `itemId → rowKey` dla itemów widocznych. */
+    rowOfItem: ReadonlyMap<string, string>;
+    /** Itemy odrzucone (zła data, duplikat `id`). */
+    invalid: readonly KptRoadmapInvalidItem[];
+}
+/**
+ * Normalizuje itemy: daty na ms, brak `end` oznacza kamień milowy.
+ * Odrzuca wpisy z nieparsowalną datą oraz duplikaty `id`.
+ */
+declare function normalizeItems<T>(items: readonly KptRoadmapItem<T>[]): {
+    valid: KptRoadmapNormalizedItem<T>[];
+    invalid: KptRoadmapInvalidItem[];
+};
+/** Zakres zbiorczy listy itemów: min(start)…max(end). */
+declare function spanOf(items: readonly KptRoadmapNormalizedItem[]): KptTimeRange | null;
+/**
+ * Postęp grupy ważony czasem trwania.
+ * Kamienie milowe mają zerową długość, więc liczymy je z wagą 1.
+ */
+declare function rollupProgress(items: readonly KptRoadmapNormalizedItem[]): number | 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.
+ */
+declare function packLanes(items: KptRoadmapPlacedItem[], minGapMs?: number): number;
+/**
+ * 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)
+ */
+declare function buildRows<TItem, TGroup>(items: readonly KptRoadmapItem<TItem>[], groups: readonly KptRoadmapGroup<TGroup>[] | undefined, collapsed: ReadonlySet<string>, opts?: KptRoadmapRowOptions): KptRoadmapLayout<TItem, TGroup>;
+/**
+ * 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').
+ */
+declare function sliceRows<TItem, TGroup>(layout: KptRoadmapLayout<TItem, TGroup>, scrollTop: number, viewportHeight: number, buffer?: number): {
+    rows: readonly KptRoadmapRow<TItem, TGroup>[];
+    startIndex: number;
+    endIndex: number;
+};
+
+/** Pasek w układzie px overlaya wraz z czasem — czas służy do detekcji naruszeń. */
+interface KptLinkEndpoint {
+    id: string;
+    rect: KptRoadmapRect;
+    startTs: number;
+    endTs: number;
+}
+interface KptLinkGeom {
+    key: string;
+    from: string;
+    to: string;
+    type: KptRoadmapLinkType;
+    /** Ścieżka `d` łamanej z zaokrąglonymi narożnikami. */
+    path: string;
+    /** Ścieżka grotu strzałki (trójkąt domknięty przez `Z`). */
+    arrow: string;
+    variant?: KptRoadmapVariant;
+    color?: string;
+    /** Następnik startuje wcześniej, niż pozwala zależność (z uwzględnieniem `lag`). */
+    isViolated: boolean;
+}
+/**
+ * Scala zależności z `item.dependsOn` (skrót oznacza typ 'FS' bez lagu)
+ * z listą `config.links`, odrzuca krawędzie wiszące i wykrywa cykle.
+ */
+declare function resolveLinks(items: readonly KptRoadmapNormalizedItem[], links: readonly KptRoadmapLink[] | undefined): {
+    links: KptRoadmapLink[];
+    cycles: string[][];
+};
+/**
+ * Łamana ortogonalna z zaokrąglonymi narożnikami.
+ * Narożnik rysujemy krzywą kwadratową — dla kąta prostego wygląda jak łuk,
+ * a ścieżka jest o połowę krótsza. Promień przycinamy do połowy krótszego
+ * z sąsiednich odcinków, żeby ciasne zakręty nie tworzyły pętli.
+ */
+declare function roundedPolyline(points: readonly KptRoadmapPoint[], radius: number): string;
+/** Grot strzałki w punkcie `point`, skierowany zgodnie z `direction`. */
+declare function arrowHead(point: KptRoadmapPoint, direction: 'left' | 'right', size: number): string;
+/**
+ * Geometria pojedynczej zależności.
+ * Zwraca `null`, gdy któryś koniec nie jest widoczny (zwinięta grupa albo
+ * wiersz poza oknem wirtualizacji).
+ */
+declare function linkGeometry(link: KptRoadmapLink, source: KptLinkEndpoint | undefined, target: KptLinkEndpoint | undefined, opts?: KptRoadmapDependencyOptions): KptLinkGeom | null;
+
+/** Pojedyncza kolumna dolnego poziomu nagłówka i linii siatki. */
+interface KptTimelineCell {
+    /** Indeks w `cells` (0-based) — podstawa skali 'uniform'. */
+    index: number;
+    /** Klucz trackBy. */
+    key: string;
+    /** Początek jednostki (ms, lokalny). */
+    start: number;
+    /** Początek następnej jednostki (ms, wyłącznie). Uwzględnia doby 23/25 h. */
+    end: number;
+    /** Etykieta dolnego poziomu, np. '35', '24', '09:00'. */
+    label: string;
+    /** Podpis pod etykietą, np. '24.08–30.08' albo 'pon'. */
+    sublabel?: string;
+    /** Pełny opis do atrybutu `title`. */
+    title: string;
+    /** Lewa krawędź 0..1. */
+    ratioStart: number;
+    /** Prawa krawędź 0..1. */
+    ratioEnd: number;
+    isToday: boolean;
+    isWeekend: boolean;
+    /** Poza oknem godzin roboczych (tylko `workHours.mode === 'dim'`). */
+    isNonWorking: boolean;
+    isMonthBoundary: boolean;
+    isQuarterBoundary: boolean;
+    isYearBoundary: boolean;
+    /** Przed tą kolumną wycięto zakres (`workHours.mode === 'skip'`). */
+    hasGapBefore: boolean;
+}
+/** Grupa kolumn tworząca górny poziom nagłówka (np. miesiąc nad tygodniami). */
+interface KptTimelineBand {
+    key: string;
+    start: number;
+    end: number;
+    /** Indeks pierwszej i ostatniej obejmowanej kolumny (włącznie). */
+    fromIndex: number;
+    toIndex: number;
+    /** Liczba obejmowanych kolumn. */
+    span: number;
+    ratioStart: number;
+    ratioEnd: number;
+    /** Etykieta główna, np. 'sierpień'. */
+    label: string;
+    /** Etykieta pomocnicza, np. '2026'. */
+    sublabel?: string;
+    /** Pierwsze pasmo danego roku — nośnik czarnego znacznika roku. */
+    isYearStart: boolean;
+    /** Rok do znacznika; ustawiony tylko gdy `isYearStart`. */
+    yearBadge?: string;
+}
+/** Geometria paska na osi (wartości 0..1). */
+interface KptSpanGeom {
+    left: number;
+    width: number;
+    /** Item zaczyna się przed lewą krawędzią zakresu. */
+    clippedStart: boolean;
+    /** Item kończy się za prawą krawędzią zakresu. */
+    clippedEnd: boolean;
+    /** Czy jakakolwiek część mieści się w zakresie. */
+    visible: boolean;
+}
+/** Niemutowalny model osi czasu — wynik `buildTimeline`. */
+interface KptTimelineModel {
+    zoom: KptRoadmapZoom;
+    range: KptTimeRange;
+    positionMode: KptRoadmapPositionMode;
+    cells: readonly KptTimelineCell[];
+    bands: readonly KptTimelineBand[];
+    /** Czy górny poziom nagłówka istnieje. */
+    hasBands: boolean;
+    /** Pozycja „dziś" 0..1 albo null, gdy poza zakresem. */
+    todayRatio: number | null;
+    /** Czas → pozycja 0..1 (monotoniczna, clampowana do zakresu). */
+    toRatio(timestamp: number): number;
+    /** Pozycja 0..1 → czas (odwrotność `toRatio`; podstawa pod drag&drop). */
+    fromRatio(ratio: number): number;
+    /** Geometria przedziału wraz z informacją o przycięciu. */
+    span(startTs: number, endTs: number): KptSpanGeom;
+}
+/**
+ * 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
+ */
+declare function buildTimeline(range: KptTimeRange, zoom: KptRoadmapZoom, opts?: KptTimelineOptions): KptTimelineModel;
+
+/** Pasek gotowy do związania w szablonie. */
+interface BarVm<TMeta = unknown> {
+    item: KptRoadmapPlacedItem<TMeta>;
+    /** Pozycja i szerokość w procentach szerokości toru. */
+    left: number;
+    width: number;
+    /** Offset pionowy wewnątrz wiersza (px). */
+    top: number;
+    height: number;
+    label: string;
+    title: string;
+    variant: string;
+    color?: string;
+    progress: number | null;
+    isMilestone: boolean;
+    clippedStart: boolean;
+    clippedEnd: boolean;
+}
+/** Pasek zbiorczy grupy. */
+interface SummaryVm {
+    left: number;
+    width: number;
+    variant: string;
+    color?: string;
+}
+/**
+ * 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`.
+ */
+declare class KptRoadmap<TItem = unknown, TGroup = unknown> {
+    protected readonly i18n: KptI18n;
+    /** Pełna konfiguracja: dane, zoom, zakres i opcje. */
+    readonly config: _angular_core.InputSignal<KptRoadmapConfig<TItem, TGroup>>;
+    /** Stała wysokość obszaru przewijania (np. '420px'). Włącza przyklejony nagłówek. */
+    readonly scrollHeight: _angular_core.InputSignal<string | null>;
+    /** Szerokość kolumny etykiet. */
+    readonly labelWidth: _angular_core.InputSignal<string>;
+    /** Szerokość kolumny osi czasu; brak ⇒ wartość zależna od zoomu. */
+    readonly cellWidthPx: _angular_core.InputSignal<number | null>;
+    /** Znacznik „dziś". */
+    readonly showToday: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Renderowanie tylko widocznych wierszy. Warto włączyć od ~100 wierszy. */
+    readonly virtual: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Zwinięte grupy (dwukierunkowe). */
+    readonly collapsedGroups: _angular_core.ModelSignal<string[]>;
+    /**
+     * 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.
+     */
+    private readonly collapsedFromConfig;
+    /** Suma obu źródeł — stan faktycznie użyty do budowy wierszy. */
+    private readonly collapsedIds;
+    readonly itemClick: _angular_core.OutputEmitterRef<KptRoadmapItem<TItem>>;
+    /** Emitowane przy każdej zmianie wyliczonego zakresu osi. */
+    readonly rangeChange: _angular_core.OutputEmitterRef<KptTimeRange>;
+    private readonly scrollEl;
+    private readonly laneEl;
+    protected readonly scrollTop: _angular_core.WritableSignal<number>;
+    protected readonly viewportHeight: _angular_core.WritableSignal<number>;
+    /** Szerokość toru w px — potrzebna warstwie SVG, która pracuje w pikselach. */
+    protected readonly laneWidth: _angular_core.WritableSignal<number>;
+    protected readonly zoom: _angular_core.Signal<KptRoadmapZoom>;
+    protected readonly cellWidth: _angular_core.Signal<number>;
+    protected readonly range: _angular_core.Signal<KptTimeRange>;
+    protected readonly timeline: _angular_core.Signal<KptTimelineModel>;
+    protected readonly layout: _angular_core.Signal<_konce_pt_angular_roadmap.KptRoadmapLayout<TItem, TGroup>>;
+    /** Wiersze faktycznie renderowane — całość albo okno wirtualizacji. */
+    protected readonly visibleRows: _angular_core.Signal<readonly KptRoadmapRow<TItem, TGroup>[]>;
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    private readonly barHeight;
+    constructor();
+    protected onScroll(event: Event): void;
+    /** Wysokość paska wraz z odstępem — wspólna dla widoku i geometrii zależności. */
+    private laneStep;
+    /** Offset pionowy paska wewnątrz wiersza (px). */
+    private barTop;
+    /** Paski danego wiersza gotowe do renderu. */
+    protected bars(row: KptRoadmapRow<TItem, TGroup>): BarVm<TItem>[];
+    /** Pasek zbiorczy wiersza grupy. */
+    protected summary(row: KptRoadmapRow<TItem, TGroup>): SummaryVm | null;
+    /**
+     * 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.
+     */
+    protected readonly links: _angular_core.Signal<readonly KptLinkGeom[]>;
+    protected toggleGroup(group: KptRoadmapGroup<TGroup>): void;
+    protected onItemClick(item: KptRoadmapPlacedItem<TItem>): void;
+    /** Obsługa klawiatury na pasku — Enter/Spacja działają jak kliknięcie. */
+    protected onItemKeydown(event: KeyboardEvent, item: KptRoadmapPlacedItem<TItem>): void;
+    /**
+     * Treść dymka dla kolumny etykiet. Pusta tam, gdzie dymek nie miałby czego
+     * uzupełnić — dyrektywa pomija wtedy podpowiedź.
+     */
+    protected labelTooltip(row: KptRoadmapRow<TItem, TGroup>): string;
+    protected isCollapsed(group: KptRoadmapGroup<TGroup> | undefined): boolean;
+    protected trackRow: (_: number, row: KptRoadmapRow<TItem, TGroup>) => string;
+    protected trackBar: (_: number, bar: BarVm<TItem>) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptRoadmap<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptRoadmap<any, any>, "kpt-roadmap", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; "labelWidth": { "alias": "labelWidth"; "required": false; "isSignal": true; }; "cellWidthPx": { "alias": "cellWidthPx"; "required": false; "isSignal": true; }; "showToday": { "alias": "showToday"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "collapsedGroups": { "alias": "collapsedGroups"; "required": false; "isSignal": true; }; }, { "collapsedGroups": "collapsedGroupsChange"; "itemClick": "itemClick"; "rangeChange": "rangeChange"; }, never, never, true, never>;
+}
+
+interface KptAutoRangeOptions {
+    zoom: KptRoadmapZoom;
+    /** Margines po obu stronach w jednostkach zoomu. */
+    padUnits?: number;
+    /** Minimalna szerokość osi w jednostkach zoomu. */
+    minUnits?: number;
+    /** Czy zakres ma zawsze obejmować „dziś". Domyślnie true. */
+    includeToday?: boolean;
+    today?: number;
+}
+/**
+ * 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`.
+ */
+declare function autoRange(items: readonly KptRoadmapItem[], opts: KptAutoRangeOptions): KptTimeRange;
+/**
+ * Ostateczny zakres osi. `config.range` ma priorytet, a brakujący kraniec
+ * uzupełniamy z `autoRange`. Wynik zawsze leży na granicach jednostki zoomu.
+ */
+declare function resolveRange(config: Pick<KptRoadmapConfig, 'range' | 'zoom' | 'today' | 'timeline'>, items: readonly (KptRoadmapItem | KptRoadmapNormalizedItem)[]): KptTimeRange;
+
+/** Normalizuje dowolne wejście daty do epoch ms. Zwraca NaN dla wartości nieparsowalnych. */
+declare function toTimestamp(value: KptDateInput): number;
+/**
+ * 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.
+ */
+declare function startOfDay(date: Date): Date;
+/** Dodaje `n` dób kalendarzowych, zachowując godzinę ścienną (DST-safe). */
+declare function addDays(date: Date, n: number): Date;
+/** Dodaje `n` godzin ściennych. Godzina nieistniejąca (wiosna) normalizuje się w przód. */
+declare function addHours(date: Date, n: number): Date;
+/** Liczba dni w miesiącu (`month` 0-indeksowany). */
+declare function daysInMonth(year: number, month: number): number;
+/** Dodaje `n` miesięcy z przycięciem dnia (31 stycznia + 1 miesiąc = 28/29 lutego). */
+declare function addMonths(date: Date, n: number): Date;
+/**
+ * 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.
+ */
+declare function diffDays(a: Date, b: Date): number;
+/** Czy obie daty wypadają w tej samej lokalnej dobie? */
+declare function isSameDay(a: Date, b: Date): boolean;
+/**
+ * Dzień tygodnia wg ISO 8601: 1 = poniedziałek … 7 = niedziela.
+ * `Date#getDay()` zwraca 0 dla niedzieli, stąd przesunięcie.
+ */
+declare function isoWeekday(date: Date): number;
+/** Poniedziałek tygodnia ISO zawierającego `date` (początek doby). */
+declare function startOfIsoWeek(date: Date): Date;
+/**
+ * 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).
+ */
+declare function isoWeekYear(date: Date): number;
+/**
+ * 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.
+ */
+declare function isoWeekNumber(date: Date): number;
+/** Liczba tygodni ISO w danym roku tygodniowym (52 albo 53). */
+declare function isoWeeksInYear(weekYear: number): number;
+/** Początek jednostki zoomu zawierającej `date` (w dół). */
+declare function floorToUnit(date: Date, zoom: KptRoadmapZoom): Date;
+/** Dodaje `n` jednostek zoomu (DST-safe — po polach daty, nie po ms). */
+declare function addUnits(date: Date, zoom: KptRoadmapZoom, n: number): Date;
+/** Początek następnej jednostki zoomu; bez zmian, gdy `date` już leży na granicy. */
+declare function ceilToUnit(date: Date, zoom: KptRoadmapZoom): Date;
+/**
+ * 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.
+ */
+declare function countUnits(start: Date, end: Date, zoom: KptRoadmapZoom): number;
+
+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 };
+export type { KptDateInput, KptLinkEndpoint, KptLinkGeom, KptRoadmapChange, KptRoadmapChangeKind, KptRoadmapConfig, KptRoadmapConstraints, KptRoadmapDependencyOptions, KptRoadmapGroup, KptRoadmapGroupState, KptRoadmapInteractionOptions, KptRoadmapItem, KptRoadmapLayout, KptRoadmapLink, KptRoadmapLinkType, KptRoadmapNormalizedItem, KptRoadmapPlacedItem, KptRoadmapPositionMode, KptRoadmapRow, KptRoadmapRowKind, KptRoadmapRowMode, KptRoadmapRowOptions, KptRoadmapSummaryMode, KptRoadmapVariant, KptRoadmapZoom, KptSpanGeom, KptTimeRange, KptTimelineBand, KptTimelineCell, KptTimelineModel, KptTimelineOptions, KptWorkHours };
+//# sourceMappingURL=konce-pt-angular-roadmap.d.ts.map

package/types/konce-pt-angular-roadmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"konce-pt-angular-roadmap.d.ts","sources":["../../roadmap/src/core/types.ts","../../roadmap/src/core/layout.ts","../../roadmap/src/core/links.ts","../../roadmap/src/core/timeline.ts","../../roadmap/src/lib/roadmap.component.ts","../../roadmap/src/core/auto-range.ts","../../roadmap/src/core/calendar.ts"],"mappings":"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","names":[]}