@tolle_/tolle-ui 18.2.28 → 18.2.30

package/lib/navigation-menu.component.d.ts

@@ -0,0 +1,230 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit, OnChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+/**
+ * Coordinates the items of a single `tolle-navigation-menu`. Provided by
+ * `NavigationMenuComponent`, injected by its descendants.
+ *
+ * Closing is deferred by `closeDelay` so a pointer travelling diagonally from a
+ * trigger into its panel does not dismiss the menu mid-flight; re-entering
+ * either surface calls `cancelClose()` and the pending close is dropped.
+ */
+export declare class NavigationMenuService {
+    private openIdSource;
+    /** Emits the id of the currently open item, or `null` when all are closed. */
+    readonly openId$: import("rxjs").Observable<string | null>;
+    /** Milliseconds to wait before closing after the pointer leaves. */
+    closeDelay: number;
+    private closeTimer;
+    /** Id of the open item, or `null`. */
+    get openId(): string | null;
+    /** True while any panel is open. */
+    get isAnyOpen(): boolean;
+    /** True while a deferred close is pending — exposed for tests/diagnostics. */
+    get isCloseScheduled(): boolean;
+    isOpen(id: string): boolean;
+    /** Opens an item immediately and cancels any pending close. */
+    open(id: string): void;
+    /** Closes immediately, dropping any pending close. */
+    closeNow(): void;
+    /** Queues a close in `closeDelay` ms; a later `open`/`cancelClose` wins. */
+    scheduleClose(): void;
+    /** Drops a pending close (pointer came back). */
+    cancelClose(): void;
+    toggle(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationMenuService>;
+}
+declare const navigationMenuVariants: (props?: ({
+    align?: "start" | "end" | "center" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type NavigationMenuProps = VariantProps<typeof navigationMenuVariants>;
+declare const navigationMenuTriggerVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type NavigationMenuTriggerProps = VariantProps<typeof navigationMenuTriggerVariants>;
+declare const navigationMenuLinkVariants: (props?: ({
+    variant?: "default" | "muted" | null | undefined;
+    active?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type NavigationMenuLinkProps = VariantProps<typeof navigationMenuLinkVariants>;
+/**
+ * Site navigation menu: a row of links and triggers, where each trigger reveals
+ * a floating panel on hover, focus or click.
+ *
+ * ```html
+ * <tolle-navigation-menu>
+ *   <tolle-navigation-menu-list>
+ *     <tolle-navigation-menu-item>
+ *       <tolle-navigation-menu-trigger>Products</tolle-navigation-menu-trigger>
+ *       <tolle-navigation-menu-content class="w-[420px]">
+ *         <tolle-navigation-menu-link href="/analytics">Analytics</tolle-navigation-menu-link>
+ *       </tolle-navigation-menu-content>
+ *     </tolle-navigation-menu-item>
+ *   </tolle-navigation-menu-list>
+ * </tolle-navigation-menu>
+ * ```
+ * @new
+ */
+export declare class NavigationMenuComponent implements OnChanges, OnInit, OnDestroy {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Horizontal alignment of the list within the nav. @default 'center' */
+    align: NavigationMenuProps['align'];
+    /** Accessible name for the `<nav>` landmark. @default 'Main' */
+    ariaLabel: string;
+    /**
+     * Milliseconds before a panel closes after the pointer leaves — the grace
+     * period that lets the pointer travel diagonally into the panel. @default 150
+     */
+    set closeDelay(value: number);
+    get closeDelay(): number;
+    /** Extra Tailwind classes merged onto the `<nav>` via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the id of the item that opened, or `null` when the menu closes. */
+    openChange: EventEmitter<string | null>;
+    private readonly service;
+    private readonly host;
+    private readonly sub;
+    private listening;
+    protected get computedClass(): string;
+    ngOnInit(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private outsideClick;
+    private startListening;
+    private stopListening;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuComponent, "tolle-navigation-menu", never, { "align": { "alias": "align"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "closeDelay": { "alias": "closeDelay"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+}
+/** The horizontal list that holds the navigation items. */
+export declare class NavigationMenuListComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Extra Tailwind classes merged onto the `<ul>` via `cn()` (last-wins). */
+    class: string;
+    protected readonly cn: typeof cn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuListComponent, "tolle-navigation-menu-list", never, { "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** One entry in the list — a plain link, or a trigger plus its content panel. */
+export declare class NavigationMenuItemComponent implements OnChanges, OnDestroy {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Explicit id for the item; one is generated when omitted. */
+    id: string;
+    /** Extra Tailwind classes merged onto the `<li>` via `cn()` (last-wins). */
+    class: string;
+    readonly service: NavigationMenuService;
+    protected readonly cn: typeof cn;
+    triggerElement: HTMLElement | null;
+    get triggerId(): string;
+    get contentId(): string;
+    get isOpen(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuItemComponent, "tolle-navigation-menu-item", never, { "id": { "alias": "id"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** Button that reveals its item's panel on hover, focus or click. */
+export declare class NavigationMenuTriggerComponent implements OnChanges, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Prevents the panel from opening. @default false */
+    disabled: boolean;
+    /** Height/padding scale of the trigger. @default 'default' */
+    size: NavigationMenuTriggerProps['size'];
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class: string;
+    protected readonly item: NavigationMenuItemComponent;
+    private readonly service;
+    private readonly cdr;
+    private readonly sub;
+    constructor();
+    set triggerRef(ref: ElementRef<HTMLButtonElement> | undefined);
+    protected get isOpen(): boolean;
+    protected get computedClass(): string;
+    protected onClick(): void;
+    protected onPointerEnter(): void;
+    protected onPointerLeave(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuTriggerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuTriggerComponent, "tolle-navigation-menu-trigger", never, { "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The floating panel revealed by a trigger. Rendered only while open. */
+export declare class NavigationMenuContentComponent implements OnChanges, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Preferred side of the trigger to render on; flips when space is tight. @default 'bottom' */
+    placement: 'bottom' | 'bottom-start' | 'bottom-end' | 'top' | 'top-start' | 'top-end';
+    /** Gap in pixels between the trigger and the panel. @default 8 */
+    sideOffset: number;
+    /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */
+    class: string;
+    protected readonly item: NavigationMenuItemComponent;
+    private readonly service;
+    private readonly cdr;
+    private readonly sub;
+    private cleanup?;
+    constructor();
+    set panelRef(ref: ElementRef<HTMLElement> | undefined);
+    protected get isOpen(): boolean;
+    protected get computedClass(): string;
+    protected onPointerEnter(): void;
+    protected onPointerLeave(): void;
+    private startPositioning;
+    private stopPositioning;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuContentComponent, "tolle-navigation-menu-content", never, { "placement": { "alias": "placement"; "required": false; }; "sideOffset": { "alias": "sideOffset"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** A link inside a panel (or directly in the list, for flat entries). */
+export declare class NavigationMenuLinkComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Destination URL. Omit to render a non-navigating item. */
+    href: string;
+    /** Anchor target; `_blank` also sets a safe `rel`. */
+    target: string;
+    /** Marks the link as the current page. @default false */
+    active: boolean;
+    /** Visual style of the link. @default 'default' */
+    variant: NavigationMenuLinkProps['variant'];
+    /** Extra Tailwind classes merged onto the anchor via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the click event when the link is activated. */
+    navigate: EventEmitter<MouseEvent>;
+    protected get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuLinkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuLinkComponent, "tolle-navigation-menu-link", never, { "href": { "alias": "href"; "required": false; }; "target": { "alias": "target"; "required": false; }; "active": { "alias": "active"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "navigate": "navigate"; }, never, ["[label]", "*", "[description]"], true, never>;
+}
+export {};

package/lib/plan.component.d.ts

@@ -0,0 +1,120 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+/** Progress of a single step in an agent plan. */
+export type PlanStepStatus = 'pending' | 'active' | 'done' | 'skipped';
+/** How far through the plan the agent is. */
+export interface PlanProgress {
+    /** 1-based position of the step being worked on, or of the last finished one. */
+    current: number;
+    /** Number of registered steps. */
+    total: number;
+}
+declare const planVariants: (props?: ({
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type PlanProps = VariantProps<typeof planVariants>;
+declare const planStepVariants: (props?: ({
+    status?: "active" | "pending" | "done" | "skipped" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type PlanStepProps = VariantProps<typeof planStepVariants>;
+/**
+ * Coordinates a `tolle-plan` and its steps: assigns each step its number and
+ * derives the "Step N of M" summary.
+ *
+ * The header is `OnPush` and the step count is not one of its inputs, so the
+ * summary is published as an observable and every subscriber calls
+ * `markForCheck()`.
+ */
+export declare class PlanService {
+    private readonly statuses;
+    private readonly order;
+    private readonly progressSource;
+    /** Emits the plan's current position and step count. */
+    readonly progress$: import("rxjs").Observable<PlanProgress>;
+    private readonly collapsedSource;
+    /** Emits whether the plan is showing only its summary row. */
+    readonly collapsed$: import("rxjs").Observable<boolean>;
+    get progress(): PlanProgress;
+    get collapsed(): boolean;
+    setCollapsed(collapsed: boolean): void;
+    toggleCollapsed(): void;
+    /** Registers a step and returns its 1-based number. */
+    register(id: string, status: PlanStepStatus): number;
+    setStatus(id: string, status: PlanStepStatus): void;
+    unregister(id: string): void;
+    /**
+     * "Current" is the first step still in flight — the active one if there is
+     * one, otherwise however many have already been resolved.
+     */
+    private recompute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlanService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlanService>;
+}
+/**
+ * An ordered plan the agent intends to work through. Each `tolle-plan-step`
+ * numbers itself and joins the connector line; collapsing the plan swaps the
+ * steps for a single "Step N of M" summary.
+ *
+ * ```html
+ * <tolle-plan title="Migration plan">
+ *   <tolle-plan-step label="Read the schema" status="done"></tolle-plan-step>
+ *   <tolle-plan-step label="Write the migration" status="active"></tolle-plan-step>
+ *   <tolle-plan-step label="Run it" status="pending"></tolle-plan-step>
+ * </tolle-plan>
+ * ```
+ * @new
+ */
+export declare class PlanComponent implements OnInit, OnChanges, OnDestroy {
+    /** Heading shown above the steps. @default 'Plan' */
+    title: string;
+    /** Shows only the header and its "Step N of M" summary. @default false */
+    collapsed: boolean;
+    /** Lets the user collapse and expand the plan by clicking the header. @default true */
+    collapsible: boolean;
+    /** Padding and text scale of the plan. @default 'default' */
+    size: PlanProps['size'];
+    /** Extra Tailwind classes merged onto the plan via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the new collapsed state when the header is toggled. */
+    collapsedChange: EventEmitter<boolean>;
+    private readonly service;
+    private readonly cdr;
+    private readonly sub;
+    isCollapsed: boolean;
+    progress: PlanProgress;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    /** The compact "Step N of M" label, empty until at least one step registers. */
+    get summary(): string;
+    get computedClass(): string;
+    get headerClass(): string;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlanComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlanComponent, "tolle-plan", never, { "title": { "alias": "title"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "collapsedChange": "collapsedChange"; }, never, ["*"], true, never>;
+}
+/** One numbered step of a `tolle-plan`. */
+export declare class PlanStepComponent implements OnInit, OnChanges, OnDestroy {
+    /** What this step does. @default '' */
+    label: string;
+    /** Supporting detail shown under the label. @default '' */
+    description: string;
+    /** Progress of this step; drives the badge colour and glyph. @default 'pending' */
+    status: PlanStepStatus;
+    /** Extra Tailwind classes merged onto the step via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly id;
+    /** 1-based position of this step, assigned on registration. */
+    index: number;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    get badgeClass(): string;
+    get labelClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlanStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlanStepComponent, "tolle-plan-step", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "status": { "alias": "status"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/lib/popover.component.d.ts

@@ -9,6 +9,7 @@ export declare class PopoverComponent implements OnDestroy {
     isOpen: boolean;
     private cleanup?;
     private _outsideClickHandler;
+    private _escapeHandler;
     toggle(): void;
     open(): void;
     close(): void;

package/lib/prompt-input.component.d.ts

@@ -0,0 +1,194 @@
+import { AfterViewInit, EventEmitter, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+declare const promptInputVariants: (props?: ({
+    status?: "error" | "ready" | "streaming" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type PromptInputProps = VariantProps<typeof promptInputVariants>;
+/** Lifecycle of the response the composer is driving. */
+export type PromptInputStatus = NonNullable<PromptInputProps['status']>;
+/**
+ * Coordinates a `tolle-prompt-input` with its projected toolbar controls.
+ *
+ * The submit button is an OnPush child that must flip to a stop button the
+ * moment the status changes, so the composer publishes its state here instead
+ * of the button reading the parent's fields.
+ *
+ * Provided on `PromptInputComponent`, so each composer gets its own instance.
+ */
+export declare class PromptInputService {
+    private readonly statusSource;
+    /** Emits the composer's current status. */
+    readonly status$: import("rxjs").Observable<PromptInputStatus>;
+    private readonly canSubmitSource;
+    /** Emits whether there is submittable text and the composer is enabled. */
+    readonly canSubmit$: import("rxjs").Observable<boolean>;
+    private readonly submitSource;
+    /** Emits when a toolbar control asks the composer to submit. */
+    readonly submit$: import("rxjs").Observable<void>;
+    private readonly stopSource;
+    /** Emits when a toolbar control asks the composer to stop streaming. */
+    readonly stop$: import("rxjs").Observable<void>;
+    /** The composer's current status. */
+    get status(): PromptInputStatus;
+    /** True when the composer has submittable text. */
+    get canSubmit(): boolean;
+    setStatus(status: PromptInputStatus): void;
+    setCanSubmit(value: boolean): void;
+    requestSubmit(): void;
+    requestStop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PromptInputService>;
+}
+/**
+ * A message composer: an auto-growing textarea plus a toolbar, wired as a
+ * `ControlValueAccessor` so it drops into template- or reactive-driven forms.
+ *
+ * Enter submits and Shift+Enter inserts a newline (swap with `submitOnEnter`).
+ * While `status` is 'streaming' the projected `tolle-prompt-input-submit`
+ * becomes a stop button that emits `stopped`.
+ * @new
+ */
+export declare class PromptInputComponent implements ControlValueAccessor, OnInit, OnChanges, AfterViewInit, OnDestroy {
+    /** Placeholder shown while the composer is empty. @default 'Send a message…' */
+    placeholder: string;
+    /** Blocks typing and submission. @default false */
+    disabled: boolean;
+    /** Rows the textarea may grow to before it starts scrolling. @default 8 */
+    maxRows: number;
+    /** Lifecycle of the response being composed. @default 'ready' */
+    status: PromptInputStatus;
+    /** Size scale of the composer. @default 'default' */
+    size: PromptInputProps['size'];
+    /** Submit on Enter, keeping Shift+Enter for newlines. @default true */
+    submitOnEnter: boolean;
+    /** Clears the composer after a successful submit. @default true */
+    clearOnSubmit: boolean;
+    /** Accessible name for the textarea. @default '' */
+    ariaLabel: string;
+    /** Extra Tailwind classes merged onto the composer via `cn()` (last-wins). */
+    class: string;
+    /** Extra Tailwind classes merged onto the textarea via `cn()` (last-wins). */
+    textareaClass: string;
+    /** Emitted with the trimmed message text when the user submits. */
+    submitted: EventEmitter<string>;
+    /** Emitted when the user cancels an in-flight streaming response. */
+    stopped: EventEmitter<void>;
+    /** Emitted with the message text whenever it changes. */
+    valueChange: EventEmitter<string>;
+    private textarea?;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    value: string;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    get textareaComputedClass(): string;
+    onInput(event: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onBlur(): void;
+    /** Submits the current text, unless the composer is empty, disabled or busy. */
+    submit(): void;
+    /** Cancels an in-flight streaming response. */
+    stop(): void;
+    /** Moves focus into the textarea. */
+    focus(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private get canSubmit();
+    private setValue;
+    private syncService;
+    /**
+     * Grows the textarea with its content up to `maxRows`, then lets it scroll.
+     * Measured from the computed line height so it tracks the inherited font.
+     */
+    private resize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputComponent, "tolle-prompt-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "maxRows": { "alias": "maxRows"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "submitOnEnter": { "alias": "submitOnEnter"; "required": false; }; "clearOnSubmit": { "alias": "clearOnSubmit"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; "textareaClass": { "alias": "textareaClass"; "required": false; }; }, { "submitted": "submitted"; "stopped": "stopped"; "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+/** Bottom bar of a `tolle-prompt-input`: tools on the left, submit on the right. */
+export declare class PromptInputToolbarComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Extra Tailwind classes merged onto the toolbar via `cn()` (last-wins). */
+    class: string;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputToolbarComponent, "tolle-prompt-input-toolbar", never, { "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** Left-aligned cluster of tool buttons inside a `tolle-prompt-input-toolbar`. */
+export declare class PromptInputToolsComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Extra Tailwind classes merged onto the tool row via `cn()` (last-wins). */
+    class: string;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputToolsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputToolsComponent, "tolle-prompt-input-tools", never, { "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+declare const promptInputSubmitVariants: (props?: ({
+    variant?: "default" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type PromptInputSubmitProps = VariantProps<typeof promptInputSubmitVariants>;
+/**
+ * Send button for a `tolle-prompt-input`. Turns into a stop button while the
+ * composer's status is 'streaming', so one control covers both directions.
+ */
+export declare class PromptInputSubmitComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Visual style of the button. @default 'default' */
+    variant: PromptInputSubmitProps['variant'];
+    /** Size of the button. @default 'default' */
+    size: PromptInputSubmitProps['size'];
+    /** Accessible name while the composer is idle. @default 'Send message' */
+    submitLabel: string;
+    /** Accessible name while the composer is streaming. @default 'Stop generating' */
+    stopLabel: string;
+    /** Renders the label next to the icon. @default false */
+    showLabel: boolean;
+    /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    status: PromptInputStatus;
+    canSubmit: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** True while the button is showing its stop affordance. */
+    get isStreaming(): boolean;
+    get currentIcon(): string;
+    get currentLabel(): string;
+    /** Stopping stays available with an empty composer; sending does not. */
+    get isDisabled(): boolean;
+    get computedClass(): string;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputSubmitComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputSubmitComponent, "tolle-prompt-input-submit", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "submitLabel": { "alias": "submitLabel"; "required": false; }; "stopLabel": { "alias": "stopLabel"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/queue.component.d.ts

@@ -0,0 +1,106 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+/** Where a queued entry is in its lifecycle. */
+export type QueueItemStatus = 'queued' | 'running' | 'done';
+/** Tallies of the entries currently in a queue. */
+export interface QueueCounts {
+    total: number;
+    queued: number;
+    running: number;
+    done: number;
+}
+declare const queueVariants: (props?: ({
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type QueueProps = VariantProps<typeof queueVariants>;
+declare const queueItemVariants: (props?: ({
+    status?: "running" | "done" | "queued" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type QueueItemProps = VariantProps<typeof queueItemVariants>;
+/**
+ * Counts the items of a single `tolle-queue`.
+ *
+ * The header is `OnPush` and the item count is not one of its inputs, so it is
+ * published as an observable and the subscriber calls `markForCheck()`.
+ */
+export declare class QueueService {
+    private readonly statuses;
+    private readonly countsSource;
+    /** Emits the queue's tallies whenever an item is added, updated or removed. */
+    readonly counts$: import("rxjs").Observable<QueueCounts>;
+    get counts(): QueueCounts;
+    register(id: string, status: QueueItemStatus): void;
+    setStatus(id: string, status: QueueItemStatus): void;
+    unregister(id: string): void;
+    private recompute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueueService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueueService>;
+}
+/**
+ * Messages or tasks waiting their turn. The header counts the entries for you,
+ * so the host only has to render `tolle-queue-item` children.
+ *
+ * ```html
+ * <tolle-queue title="Queued">
+ *   <tolle-queue-item label="Summarise the thread" status="running"></tolle-queue-item>
+ *   <tolle-queue-item label="Draft a reply" (remove)="drop(1)"></tolle-queue-item>
+ * </tolle-queue>
+ * ```
+ * @new
+ */
+export declare class QueueComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Heading shown above the queued items. @default 'Queue' */
+    title: string;
+    /** Text shown while the queue holds nothing. @default 'Nothing queued.' */
+    emptyMessage: string;
+    /** Padding and text scale of the queue. @default 'default' */
+    size: QueueProps['size'];
+    /** Extra Tailwind classes merged onto the queue via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the queue's tallies whenever its items change. */
+    countsChange: EventEmitter<QueueCounts>;
+    private readonly service;
+    private readonly cdr;
+    private readonly sub;
+    counts: QueueCounts;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    get countClass(): string;
+    get listClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueueComponent, "tolle-queue", never, { "title": { "alias": "title"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "countsChange": "countsChange"; }, never, ["*"], true, never>;
+}
+/** A single entry in a `tolle-queue`. */
+export declare class QueueItemComponent implements OnInit, OnChanges, OnDestroy {
+    /** Text describing the queued work. @default '' */
+    label: string;
+    /** Lifecycle state of this entry. @default 'queued' */
+    status: QueueItemStatus;
+    /** Shows the trailing dismiss button that emits `remove`. @default true */
+    removable: boolean;
+    /** Accessible label for the dismiss button. @default 'Remove from queue' */
+    removeLabel: string;
+    /** Extra Tailwind classes merged onto the entry via `cn()` (last-wins). */
+    class: string;
+    /** Emitted when the user dismisses this entry. */
+    remove: EventEmitter<void>;
+    private readonly service;
+    private readonly id;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    get iconClass(): string;
+    get labelClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueueItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueueItemComponent, "tolle-queue-item", never, { "label": { "alias": "label"; "required": false; }; "status": { "alias": "status"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "removeLabel": { "alias": "removeLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "remove": "remove"; }, never, ["*"], true, never>;
+}
+export {};