@konce-pt/angular 0.8.3 → 0.9.0

package/src/lib/progress/llms.txt

@@ -1,16 +1,92 @@
 # KptProgress (kpt-progress)
 
-A progress indicator — linear or circular, determinate (0–100) or indeterminate (`value`=null).
+A progress indicator — linear or circular, determinate (`min`–`max`) or indeterminate (`value` = null).
 Import: `import { KptProgress } from '@konce-pt/angular';`
 
+## DOM
+    <!-- linear, with a label, a buffer and a value -->
+    <kpt-progress class="kpt-progress-host" data-type="linear" data-size="md" data-variant="primary" data-label-position="top">
+      <span class="kpt-progress__label">Loading…</span>
+      <div class="kpt-progress__linear" role="progressbar" aria-valuemin="0" aria-valuemax="100" aria-valuenow="80">
+        <div class="kpt-progress__buffer" style="width: 92%"></div>
+        <div class="kpt-progress__bar" style="width: 80%"></div>
+      </div>
+      <span class="kpt-progress__value" aria-hidden="true">80%</span>
+    </kpt-progress>
+
+    <!-- circular -->
+    <kpt-progress class="kpt-progress-host" data-type="circular" data-size="md" data-variant="success">
+      <svg class="kpt-progress__circular" viewBox="0 0 40 40" role="progressbar" aria-valuenow="75">
+        <circle class="kpt-progress__track" cx="20" cy="20" r="16"></circle>
+        <circle class="kpt-progress__bar" cx="20" cy="20" r="16" style="stroke-dasharray: 100.531; stroke-dashoffset: 25.1327"></circle>
+      </svg>
+      <span class="kpt-progress__value" aria-hidden="true">75%</span>
+    </kpt-progress>
+
+The label, the track and the value are siblings straight under the host — there is no wrapper element.
+`data-variant`, `data-type`, `data-size` and `data-label-position` all sit on the host, which is also
+where the private `--_color` and `--_thickness` are resolved.
+
 ## Inputs
-- `value`: number|null (null = indeterminate); `type`: 'linear'|'circular'
-- `variant`: 'primary'|'success'|'danger'|'warning'|'info'; `diameter`: number (circular)
+- `value`: number|null (default null) — a value on the `min`–`max` scale, or null for indeterminate
+- `min`: number (default 0); `max`: number (default 100)
+- `variant`: 'primary'|'success'|'danger'|'warning'|'info' (default 'primary')
+- `type`: 'linear'|'circular' (default 'linear')
+- `size`: 'sm'|'md'|'lg' (default 'md') — track thickness, and arc width on the circular variant
+- `diameter`: number (default 40) — the circular variant's size in pixels
+- `bufferValue`: number|null (default null) — a second, dimmed bar behind the main one; linear only
+- `showValue`: boolean (default false) — turns the value area on; projected content needs it too
+- `valueFormat`: 'percent'|'fraction'|'none' (default 'percent')
+- `label`: string — descriptive text next to the bar; it also becomes the `aria-label`
+- `labelPosition`: 'top'|'bottom'|'end' (default 'top') — ignored by the circular variant
+
+## Value label
+`showValue` opens the value area; `valueFormat` decides what goes in it — `percent` renders `80%`,
+`fraction` renders `152 / 160` from `value` and `max`, `none` leaves it empty. Both strings come from
+the `KptMessages` dictionary (`progress.percent`, `progress.fraction`), so a new locale can reshape them.
+
+Projected content replaces the formatted value instead of adding to it, which is how a circle shows
+a headline number over a caption. Projection still requires `showValue`, because that input is what
+renders the element the content lands in.
+
+The circular variant always centres the value over the arc; `label` is not drawn there, it only feeds
+the accessible name.
+
+## How the arc is drawn
+The circle lives in a fixed `viewBox="0 0 40 40"` with `r=16`, so the circumference is computed from
+that radius, not from `diameter` — the SVG scales, the maths does not change. The arc is the dash
+offset: full circumference means empty, zero means complete. `size` only changes `stroke-width`, and
+the widest step still fits inside the box, so no arc is ever clipped.
+
+Values outside the range are clamped rather than rejected, `max` ≤ `min` collapses to zero, and the
+buffer is never allowed behind the main bar — a computed percentage that briefly overshoots cannot
+break the drawing.
 
 ## Examples
     <kpt-progress [value]="60" />
-    <kpt-progress type="circular" [value]="75" variant="success" />
+    <kpt-progress [value]="80" label="Loading…" showValue />
+    <kpt-progress [value]="152" [max]="160" size="lg" showValue valueFormat="fraction" labelPosition="bottom" />
+    <kpt-progress [value]="65" showValue labelPosition="end" />
+    <kpt-progress [value]="38" [bufferValue]="62" />
+    <kpt-progress type="circular" [value]="80" showValue />
+    <kpt-progress type="circular" [value]="72" [diameter]="140" size="lg" showValue>
+      <strong>29</strong>
+      <small>Excellent</small>
+    </kpt-progress>
     <kpt-progress [value]="null" />
 
 ## Tokens
-`--kpt-color-{primary,success,danger,warning,info}`, the track `--kpt-color-surface-variant`.
+The semantic colour of each variant (`--kpt-color-primary` / `-success` / `-danger` / `-warning` /
+`-info`), plus the component layer: `--kpt-progress-track-bg`, `--kpt-progress-thickness-sm`,
+`--kpt-progress-thickness-md`, `--kpt-progress-thickness-lg`, `--kpt-progress-buffer-opacity`,
+`--kpt-progress-label-fg`, `--kpt-progress-value-fg`, `--kpt-progress-gap`.
+
+## Accessibility
+`role="progressbar"` with `aria-valuemin`, `aria-valuemax` and `aria-valuenow`; an indeterminate bar
+leaves the value out, which is how a screen reader learns the progress is unknown rather than zero.
+`valueFormat="fraction"` also sets `aria-valuetext`, so the reader says "152 / 160" instead of
+announcing the raw number as a percentage. The visible value is `aria-hidden`, so it is never read
+twice. The accessible name comes from `label`, or from the dictionary when there is none.
+
+Under `prefers-reduced-motion: reduce` the indeterminate animation slows down instead of stopping —
+a frozen progress indicator reads as a hung application.

package/src/lib/rich-text/llms.txt

@@ -12,6 +12,21 @@ Import: `import { KptRichText, KptRichTool, KptRichToolbar } from '@konce-pt/ang
 - `placeholder`: string; `disabled`/`invalid`/`touched`: boolean; `touch`: output
 - `maxListLevel`: number = 6 — the maximum list nesting depth. The limit applies to interaction
   (Tab and the `indent`/`outdent` tools); pasted content is not flattened, so that no data is lost.
+- `mentions`: `readonly KptMentionItem[]` — suggestions for `@`; an empty list turns the mechanism
+  off, so `@` stays an ordinary character. `mentionLimit`: number = 8; `(mentioned)` fires with the
+  inserted entry — the moment to notify a person or attach a link.
+
+## Mentions (`@`)
+With `mentions` set, typing `@` opens a suggestion list anchored at the caret: arrows move through
+it, Enter or Tab inserts, Escape closes. The query is read from the **text node** at the caret, not
+from the HTML, and recognised by `mentionQuery()` from `@konce-pt/mention` — the same rules as in a
+plain text field.
+
+An inserted mention is `<span class="kpt-mention" data-mention="id" contenteditable="false">@Name`
+plus a non-breaking space. The id survives a rename and the round trip through the value;
+`contenteditable="false"` keeps the mention in one piece, and the space is what gives the caret a
+place to stand after a block it cannot enter. Both attributes are on the sanitizer's allowlist —
+they are inert, so they open no new door.
 
 ## Tools (KptRichTool)
 - Clipboard: `copy`, `paste` (with formatting, sanitized), `pasteText` (without formatting)

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

@@ -0,0 +1,334 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { KptI18n } from '@konce-pt/angular';
+import { KptChatMessage as KptChatMessage$1, KptChatAuthor, KptChatReactionOption, KptChatReplyRef, KptChatRow, KptChatDateLabel, KptChatAttachment, KptChatReaction, KptChatStatus, KptChatGroupPosition } from '@konce-pt/chat';
+export { KPT_CHAT_GROUP_GAP_MS, KPT_CHAT_REACTIONS, KptChatAttachment, KptChatAuthor, KptChatDateLabel, KptChatDateRow, KptChatGroupOptions, KptChatGroupPosition, KptChatMessage as KptChatMessageModel, KptChatMessageRow, KptChatReaction, KptChatReactionKind, KptChatReactionOption, KptChatReplyRef, KptChatRow, KptChatStatus, KptChatUnreadRow, buildChatRows, canRetry, chatDayIndicator, dateLabel, diffInDays, isSameDay, mergeStatus, pendingCount, replyRefFrom, startOfDay, statusRank, toDate, toggleReaction } from '@konce-pt/chat';
+
+/** Wybór reakcji na wiadomości — komponent mówi, w co kliknięto, dopisanie należy do aplikacji. */
+interface KptChatReactEvent<T = unknown> {
+    message: KptChatMessage$1<T>;
+    emoji: string;
+}
+/** Wiersz separatora daty z gotową etykietą — tłumaczenie robi komponent, nie rdzeń. */
+type KptChatDateViewRow = {
+    kind: 'date';
+    key: string;
+    date: Date;
+    label: KptChatDateLabel;
+    text: string;
+};
+type KptChatViewRow<T> = KptChatDateViewRow | Exclude<KptChatRow<T>, {
+    kind: 'date';
+}>;
+/**
+ * Lista rozmowy — grupuje wiadomości, wstawia separatory dni i dzielnik nieprzeczytanych,
+ * trzyma widok przy dole i pokazuje pasek offline z liczbą wiadomości czekających na wysłanie.
+ *
+ * Sama logika wierszy mieszka w `@konce-pt/chat` (`buildChatRows`), więc port Reacta liczy ją
+ * tak samo. Komponent nie ma nic wspólnego z transportem: wiadomości dostaje, a `(retry)`
+ * i `(loadMore)` tylko zgłasza — ponowieniem wysyłki i dociąganiem historii zajmuje się aplikacja.
+ *
+ * Treść bąbla można podmienić własnym `<ng-template>`; kontekst dostaje wiadomość jako
+ * `$implicit` i cały wiersz jako `row`.
+ *
+ * Kompozytor (`kpt-chat-composer`) jest osobnym komponentem i stoi obok listy — dzięki temu
+ * czat bez pola wpisywania (podgląd, archiwum) nie wozi go ze sobą.
+ *
+ * @example
+ * <kpt-chat [messages]="messages()" currentUser="me" [typing]="typing()" (retry)="resend($event)" />
+ */
+declare class KptChat<T = unknown> {
+    /** Wiadomości w kolejności chronologicznej — komponent ich nie sortuje. */
+    readonly messages: _angular_core.InputSignal<readonly KptChatMessage$1<T>[]>;
+    /** `id` nadawcy uznawanego za „mnie": jego wiadomości idą na prawo i mają status. */
+    readonly currentUser: _angular_core.InputSignal<string>;
+    /** Przerwa łamiąca grupę wiadomości jednego nadawcy. */
+    readonly groupGapMs: _angular_core.InputSignal<number>;
+    /** `id` pierwszej nieprzeczytanej wiadomości — nad nią stanie dzielnik. */
+    readonly unreadFrom: _angular_core.InputSignal<string | null>;
+    /** Brak połączenia: pasek u góry listy z liczbą wiadomości czekających na wysłanie. */
+    readonly offline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Osoby piszące w tej chwili. */
+    readonly typing: _angular_core.InputSignal<readonly KptChatAuthor[]>;
+    /** Dosuwanie widoku do najnowszej wiadomości, dopóki użytkownik nie odjedzie w górę. */
+    readonly autoScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Akcje bąbla pod kursorem: odpowiedz i zareaguj. */
+    readonly actions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Zestaw wybieraka reakcji, przekazywany bąblom. Domyślnie pięć wbudowanych. */
+    readonly reactionOptions: _angular_core.InputSignal<readonly KptChatReactionOption[]>;
+    /** Własny komunikat pustej rozmowy. */
+    readonly emptyLabel: _angular_core.InputSignal<string>;
+    readonly retry: _angular_core.OutputEmitterRef<KptChatMessage$1<T>>;
+    readonly reply: _angular_core.OutputEmitterRef<KptChatMessage$1<T>>;
+    /** Kliknięcie w reakcję w wybieraku: wiadomość i wybrane emoji. */
+    readonly react: _angular_core.OutputEmitterRef<KptChatReactEvent<T>>;
+    readonly quoted: _angular_core.OutputEmitterRef<KptChatReplyRef>;
+    /** Przewinięcie na sam szczyt — moment na dociągnięcie starszych wiadomości. */
+    readonly loadMore: _angular_core.OutputEmitterRef<void>;
+    protected readonly i18n: KptI18n;
+    protected readonly messageTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly viewport;
+    private readonly day;
+    private readonly destroyRef;
+    /** Czy widok stoi przy dole listy. Odjazd w górę wyłącza dosuwanie. */
+    protected readonly pinned: _angular_core.WritableSignal<boolean>;
+    /** Ile wiadomości przyszło, odkąd użytkownik odjechał w górę. */
+    protected readonly newCount: _angular_core.WritableSignal<number>;
+    /** Tekst pływającej pigułki dnia — zostaje po zgaszeniu, żeby jej pas nie zmieniał wysokości. */
+    protected readonly dayLabel: _angular_core.WritableSignal<string>;
+    /** Czy pigułka dnia jest widoczna. */
+    protected readonly dayVisible: _angular_core.WritableSignal<boolean>;
+    private lastCount;
+    private wasAtTop;
+    protected readonly rows: _angular_core.Signal<KptChatRow<T>[]>;
+    protected readonly viewRows: _angular_core.Signal<KptChatViewRow<T>[]>;
+    protected readonly pending: _angular_core.Signal<number>;
+    constructor();
+    /** Przewija do najnowszej wiadomości i kasuje licznik nowych. */
+    jumpToLatest(): void;
+    protected onScroll(element: HTMLElement): void;
+    /**
+     * Ustawia tekst pływającej pigułki dnia — co ma na niej być, liczy `chatDayIndicator`
+     * z `@konce-pt/chat`, tutaj zostaje czytanie prostokątów i przepisanie etykiety.
+     *
+     * Wszystkie pomiary idą przed zapisem sygnału, więc przeglądarka przelicza układ raz
+     * na klatkę zamiast przy każdym wierszu.
+     */
+    private syncDay;
+    private scrollToBottom;
+    /**
+     * Etykieta separatora dnia. Rdzeń zwraca rodzaj, słownik daje „dziś"/„wczoraj",
+     * a nazwę dnia i pełną datę — `Intl`, żeby nie trzymać w słowniku kalendarza.
+     */
+    private dateText;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptChat<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptChat<any>, "kpt-chat", never, { "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "currentUser": { "alias": "currentUser"; "required": false; "isSignal": true; }; "groupGapMs": { "alias": "groupGapMs"; "required": false; "isSignal": true; }; "unreadFrom": { "alias": "unreadFrom"; "required": false; "isSignal": true; }; "offline": { "alias": "offline"; "required": false; "isSignal": true; }; "typing": { "alias": "typing"; "required": false; "isSignal": true; }; "autoScroll": { "alias": "autoScroll"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "reactionOptions": { "alias": "reactionOptions"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; }, { "retry": "retry"; "reply": "reply"; "react": "react"; "quoted": "quoted"; "loadMore": "loadMore"; }, ["messageTpl"], never, true, never>;
+}
+
+/** Wygląd bąbla. `system` nie rysuje bąbla w ogóle — to komunikat, nie wypowiedź. */
+type KptChatMessageVariant = 'neutral' | 'primary' | 'solid' | 'ghost' | 'system';
+/**
+ * Pojedyncza wiadomość czatu — bąbel z treścią, godziną, statusem wysyłki i opcjonalnym
+ * awatarem, cytatem, załącznikami i reakcjami.
+ *
+ * Działa na dwa sposoby: dostaje gotowy obiekt przez `[message]` (tak używa go `kpt-chat`)
+ * albo pojedyncze inputy, gdy budujesz listę samodzielnie. Treść można też wrzucić
+ * przez `<ng-content />` — projekcja wygrywa z `text`, więc bąbel przyjmuje cokolwiek.
+ *
+ * Wygląd wewnątrz grupy steruje `position`: zapadnięty narożnik od strony nadawcy i ogonek
+ * tylko przy ostatnim bąblu. Wylicza to `buildChatRows()` z `@konce-pt/chat`.
+ *
+ * @example
+ * <kpt-chat-message [message]="msg" align="end" position="last" />
+ * <kpt-chat-message align="end" status="failed" (retry)="resend()">Nie poszło</kpt-chat-message>
+ */
+declare class KptChatMessage {
+    /** Cała wiadomość naraz. Pojedyncze inputy poniżej mają nad nią priorytet. */
+    readonly message: _angular_core.InputSignal<KptChatMessage$1<unknown> | null>;
+    readonly author: _angular_core.InputSignal<KptChatAuthor | null>;
+    readonly text: _angular_core.InputSignal<string | null>;
+    readonly time: _angular_core.InputSignal<string | number | Date | null>;
+    readonly attachments: _angular_core.InputSignal<readonly KptChatAttachment[] | null>;
+    readonly reactions: _angular_core.InputSignal<readonly KptChatReaction[] | null>;
+    readonly replyTo: _angular_core.InputSignal<KptChatReplyRef | null>;
+    readonly status: _angular_core.InputSignal<KptChatStatus | null>;
+    /** Strona listy: `start` to cudza wiadomość, `end` własna. */
+    readonly align: _angular_core.InputSignal<"start" | "end">;
+    /** Wariant kolorystyczny; bez niego wynika z `align` (własna = `primary`). */
+    readonly variant: _angular_core.InputSignal<KptChatMessageVariant | null>;
+    readonly position: _angular_core.InputSignal<KptChatGroupPosition>;
+    readonly system: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showAuthor: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showAvatar: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showMeta: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tail: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Akcje pod kursorem: odpowiedz i zareaguj. Domyślnie wyłączone. */
+    readonly actions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Zestaw wybieraka reakcji. Domyślnie pięć wbudowanych; można go skrócić lub przestawić. */
+    readonly reactionOptions: _angular_core.InputSignal<readonly KptChatReactionOption[]>;
+    readonly retry: _angular_core.OutputEmitterRef<void>;
+    readonly reply: _angular_core.OutputEmitterRef<void>;
+    /** Wybrana reakcja (emoji). Biblioteka niczego nie dopisuje do modelu — robi to aplikacja. */
+    readonly react: _angular_core.OutputEmitterRef<string>;
+    /** Kliknięcie w cytat — aplikacja może przewinąć listę do oryginału. */
+    readonly quoted: _angular_core.OutputEmitterRef<KptChatReplyRef>;
+    protected readonly i18n: KptI18n;
+    private readonly host;
+    /** Czy wybierak reakcji jest otwarty. */
+    protected readonly pickerOpen: _angular_core.WritableSignal<boolean>;
+    constructor();
+    protected readonly isSystem: _angular_core.Signal<boolean>;
+    protected readonly resolvedAuthor: _angular_core.Signal<KptChatAuthor | null>;
+    protected readonly resolvedText: _angular_core.Signal<string>;
+    protected readonly resolvedStatus: _angular_core.Signal<KptChatStatus | null>;
+    protected readonly resolvedReplyTo: _angular_core.Signal<KptChatReplyRef | null>;
+    protected readonly resolvedAttachments: _angular_core.Signal<readonly KptChatAttachment[]>;
+    protected readonly resolvedReactions: _angular_core.Signal<readonly KptChatReaction[]>;
+    protected readonly sentAt: _angular_core.Signal<Date | null>;
+    /**
+     * Wariant domyślny bierze się z wyrównania. Własna wiadomość dostaje pełny `solid`,
+     * bo motyw biblioteki jest monochromatyczny: pastelowy `primary-subtle` ma tę samą
+     * jasność co `muted`, więc własny i cudzy bąbel byłyby nie do odróżnienia. Kto woli
+     * ciszej, ustawia `variant="primary"` ręcznie.
+     */
+    protected readonly resolvedVariant: _angular_core.Signal<KptChatMessageVariant>;
+    /** Ogonek tylko na końcu grupy i tylko tam, gdzie bąbel ma tło, z którego da się go wyciąć. */
+    protected readonly hasTail: _angular_core.Signal<boolean>;
+    protected readonly canRetry: _angular_core.Signal<boolean>;
+    protected readonly statusIcon: _angular_core.Signal<string | null>;
+    protected readonly timeLabel: _angular_core.Signal<string>;
+    protected readonly isoTime: _angular_core.Signal<string | null>;
+    /**
+     * Etykieta dla czytnika ekranu. Bez niej z bąbla płynie sama treść — bez nadawcy,
+     * godziny i informacji, że wiadomość się nie wysłała.
+     */
+    protected readonly ariaLabel: _angular_core.Signal<string>;
+    protected readonly statusLabel: _angular_core.Signal<string>;
+    /** Etykieta opcji wybieraka — `like` → `chat.reactLike`. */
+    protected reactionLabel(option: KptChatReactionOption): string;
+    /** Czy bieżący użytkownik dał już tę reakcję — opcja wybieraka pokazuje to przez `aria-pressed`. */
+    protected hasReacted(emoji: string): boolean;
+    protected pick(emoji: string): void;
+    /** Wyjście fokusu poza wybierak zamyka go — przechodzenie Tabem między opcjami nie. */
+    protected onPickerFocusOut(event: FocusEvent): void;
+    /** Rozmiar załącznika w kB/MB — surowe bajty nic nie mówią przy pliku obok nazwy. */
+    protected fileSize(bytes?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptChatMessage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptChatMessage, "kpt-chat-message", never, { "message": { "alias": "message"; "required": false; "isSignal": true; }; "author": { "alias": "author"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "time": { "alias": "time"; "required": false; "isSignal": true; }; "attachments": { "alias": "attachments"; "required": false; "isSignal": true; }; "reactions": { "alias": "reactions"; "required": false; "isSignal": true; }; "replyTo": { "alias": "replyTo"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "system": { "alias": "system"; "required": false; "isSignal": true; }; "showAuthor": { "alias": "showAuthor"; "required": false; "isSignal": true; }; "showAvatar": { "alias": "showAvatar"; "required": false; "isSignal": true; }; "showMeta": { "alias": "showMeta"; "required": false; "isSignal": true; }; "tail": { "alias": "tail"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "reactionOptions": { "alias": "reactionOptions"; "required": false; "isSignal": true; }; }, { "retry": "retry"; "reply": "reply"; "react": "react"; "quoted": "quoted"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Wskaźnik pisania — trzy kropki i informacja, kto pisze.
+ *
+ * Pusta lista autorów nie renderuje niczego, więc można go trzymać w szablonie na stałe
+ * i sterować wyłącznie danymi.
+ *
+ * Element jest `role="status"` z `aria-live="polite"`: czytnik ogłasza wejście i zniknięcie
+ * wskaźnika, ale nie przerywa czytania wiadomości. Sama animacja kropek nic nie mówi —
+ * informację niesie etykieta.
+ *
+ * @example
+ * <kpt-chat-typing [authors]="typing()" />
+ */
+declare class KptChatTyping {
+    /** Osoby piszące w tej chwili. Pusta lista chowa wskaźnik. */
+    readonly authors: _angular_core.InputSignal<readonly KptChatAuthor[]>;
+    /** Własna etykieta zamiast tej ze słownika. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly i18n: KptI18n;
+    protected readonly visible: _angular_core.Signal<boolean>;
+    /**
+     * Jedna osoba jest wymieniona z imienia, przy większej liczbie liczy się głowy —
+     * lista nazwisk rozjeżdża wiersz i i tak nikt jej nie czyta.
+     */
+    protected readonly text: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptChatTyping, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptChatTyping, "kpt-chat-typing", never, { "authors": { "alias": "authors"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Ładunek wysyłki. Kompozytor niczego nie wysyła — pakuje dane i oddaje aplikacji. */
+interface KptChatComposerSubmit {
+    text: string;
+    files: readonly File[];
+    replyTo: KptChatReplyRef | null;
+}
+/**
+ * Pole pisania wiadomości — autorosnące, z załącznikami i paskiem cytatu.
+ *
+ * Nie jest kontrolką Signal Forms i celowo nią nie będzie: nie wchodzi do formularza, nie ma
+ * stanu `touched`/`invalid`, a jego wartość znika po wysłaniu. `model('')` opisuje to wiernie.
+ *
+ * `Enter` wysyła, `Shift+Enter` łamie linię (`[enterToSend]="false"` odwraca układ).
+ * Przy `[offline]` przycisk zmienia etykietę na kolejkowanie — wiadomość dalej da się napisać
+ * i oddać aplikacji, bo to ona decyduje, co zrobić z kolejką.
+ *
+ * @example
+ * <kpt-chat-composer [(value)]="draft" allowAttachments (send)="onSend($event)" />
+ */
+declare class KptChatComposer {
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Podpowiedź w pustym polu; bez niej etykieta ze słownika. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Brak połączenia — przycisk mówi o kolejkowaniu, nie o wysyłce. */
+    readonly offline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly allowAttachments: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Ile wierszy pole może urosnąć, zanim zacznie się przewijać. */
+    readonly maxRows: _angular_core.InputSignal<number>;
+    readonly enterToSend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Wiadomość, na którą odpowiadamy. Po wysłaniu czyści się razem z treścią. */
+    readonly replyTo: _angular_core.ModelSignal<KptChatReplyRef | null>;
+    readonly send: _angular_core.OutputEmitterRef<KptChatComposerSubmit>;
+    /** Pierwsze uderzenie w klawiaturę — sygnał „piszę" dla drugiej strony. */
+    readonly typing: _angular_core.OutputEmitterRef<void>;
+    protected readonly i18n: KptI18n;
+    protected readonly files: _angular_core.WritableSignal<readonly File[]>;
+    protected readonly canSend: _angular_core.Signal<boolean>;
+    protected readonly sendLabel: _angular_core.Signal<string>;
+    protected onInput(element: HTMLTextAreaElement): void;
+    protected onKeydown(event: KeyboardEvent, element: HTMLTextAreaElement): void;
+    protected submit(element?: HTMLTextAreaElement): void;
+    protected onFiles(input: HTMLInputElement): void;
+    protected removeFile(file: File): void;
+    /**
+     * Wysokość liczona od treści. Zerowanie przed odczytem `scrollHeight` jest konieczne:
+     * bez niego pole potrafi tylko rosnąć, bo `scrollHeight` nigdy nie zejdzie poniżej
+     * ustawionej wcześniej wysokości. Górny limit trzyma CSS (`--_max-rows`).
+     */
+    private grow;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptChatComposer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptChatComposer, "kpt-chat-composer", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "offline": { "alias": "offline"; "required": false; "isSignal": true; }; "allowAttachments": { "alias": "allowAttachments"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; "enterToSend": { "alias": "enterToSend"; "required": false; "isSignal": true; }; "replyTo": { "alias": "replyTo"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "replyTo": "replyToChange"; "send": "send"; "typing": "typing"; }, never, never, true, never>;
+}
+
+type KptChatDockPosition = 'bottom-end' | 'bottom-start';
+/**
+ * Pływający czat w rogu ekranu — FAB z licznikiem nieprzeczytanych i panel z rozmową.
+ *
+ * Zawartość panelu jest rzutowana, więc dock nie wie nic o wiadomościach: wkłada się do niego
+ * `kpt-chat` i `kpt-chat-composer` (albo cokolwiek innego). Sam FAB to `kpt-fab` — dock go
+ * używa, nie zastępuje.
+ *
+ * Poniżej `--kpt-breakpoint-sm` panel wchodzi na pełny ekran: 22,5 cm szerokości na telefonie
+ * to nie panel, tylko szpara.
+ *
+ * @example
+ * <kpt-chat-dock [(open)]="chatOpen" [unread]="unread()" header="Wsparcie">
+ *   <kpt-chat [messages]="messages()" currentUser="me" />
+ *   <kpt-chat-composer (send)="onSend($event)" />
+ * </kpt-chat-dock>
+ */
+declare class KptChatDock {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly position: _angular_core.InputSignal<KptChatDockPosition>;
+    /** Licznik na plakietce FAB-a. Zero chowa plakietkę. */
+    readonly unread: _angular_core.InputSignal<number>;
+    readonly header: _angular_core.InputSignal<string>;
+    /** Ikona zamkniętego FAB-a; otwarty zawsze pokazuje krzyżyk. */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Szerokość panelu na ekranach powyżej `--kpt-breakpoint-sm`. */
+    readonly width: _angular_core.InputSignal<string>;
+    /**
+     * Odsunięcie od rogu ekranu (dowolna długość CSS), wspólne dla obu osi.
+     * Domyślnie `--kpt-space-6`. Przydaje się, gdy w tym samym rogu stoi już inny widget —
+     * `kpt-scroll-top` przykleja się dokładnie tam samo i bez tego oba się nakładają.
+     */
+    readonly offset: _angular_core.InputSignal<string>;
+    protected readonly i18n: KptI18n;
+    private readonly panel;
+    private readonly trigger;
+    protected readonly triggerLabel: _angular_core.Signal<string>;
+    constructor();
+    protected toggle(): void;
+    close(): void;
+    /**
+     * Fokus ląduje na polu pisania, jeśli w panelu jest — po to się czat otwiera.
+     * Bez pola bierze pierwszy element interaktywny, a w ostateczności sam panel.
+     */
+    private focusPanel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptChatDock, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptChatDock, "kpt-chat-dock", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "unread": { "alias": "unread"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+export { KptChat, KptChatComposer, KptChatDock, KptChatMessage, KptChatTyping };
+export type { KptChatComposerSubmit, KptChatDockPosition, KptChatMessageVariant, KptChatReactEvent };
+//# sourceMappingURL=konce-pt-angular-chat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"konce-pt-angular-chat.d.ts","sources":["../../chat/src/lib/chat.component.ts","../../chat/src/lib/chat-message.component.ts","../../chat/src/lib/chat-typing.component.ts","../../chat/src/lib/chat-composer.component.ts","../../chat/src/lib/chat-dock.component.ts"],"mappings":"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","names":["KptChatMessageModel"]}