@koobiq/components 20.4.1 → 21.0.0

package/types/koobiq-components-popover.d.ts

@@ -0,0 +1,468 @@
+import * as _angular_core from '@angular/core';
+import { Provider, InjectionToken, AfterViewInit, TemplateRef, OnChanges, AfterContentInit, OnInit, DestroyRef, EventEmitter, InputSignal, SimpleChanges, Type, ElementRef } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import * as _koobiq_components_core from '@koobiq/components/core';
+import { KbqPopUp, KbqPopUpTrigger, KbqPopUpPlacementValues, KbqStickToWindowPlacementValues, KbqPopUpSizeValues, KbqOverlayOrigin, KbqOverflowShadowContainer, KbqComponentColors } from '@koobiq/components/core';
+import { CdkTrapFocus } from '@angular/cdk/a11y';
+import { ScrollStrategy, ScrollDispatcher, OverlayConfig, OverlayRef, CdkScrollable } from '@angular/cdk/overlay';
+
+declare const defaultOffsetYWithArrow = 8;
+/** Leave delay applied to a hover-triggered popover when `kbqLeaveDelay` is not bound. */
+declare const defaultHoverLeaveDelay = 500;
+/**
+ * Focus-trap wiring of a popover panel.
+ *
+ * Provided on the panel components rather than on `KbqPopoverModule`: both entries are injector-wide, so at
+ * module level they replaced the CDK inert strategy for every other focus trap in the importing injector.
+ *
+ * @docs-private
+ */
+declare const KBQ_POPOVER_FOCUS_TRAP_PROVIDERS: Provider[];
+declare class KbqPopoverComponent extends KbqPopUp implements AfterViewInit {
+    /** Accessible name for the icon-only close button. */
+    protected readonly a11yLocaleConfiguration: _angular_core.Signal<_koobiq_components_core.KbqA11yLocaleConfiguration>;
+    /** Debounce shared by the mutation observer and the scroll-shadow container (both expose `debounce`). */
+    protected readonly contentObserverDebounce = 15;
+    prefix: string;
+    header: string | TemplateRef<any>;
+    footer: string | TemplateRef<any>;
+    trigger: KbqPopoverTrigger;
+    isTrapFocus: boolean;
+    hasCloseButton: boolean;
+    /** Id of the panel element, referenced by the trigger's `aria-controls`. Written by the trigger. */
+    panelId: string;
+    /** Accessible name of the panel, used when there is no header to label it. Written by the trigger. */
+    ariaLabel: string | undefined;
+    private readonly popoverElement;
+    /**
+     * Panel element (`.kbq-popover`), not the component host.
+     *
+     * Deliberately shadows the injected `KbqPopUp.elementRef`: the base measures and decorates the visible
+     * panel, so both `applyPopupMargins` here and `setStickPosition`/`addEventListenerForHide` in the base
+     * must resolve to the same element. The confirm template carries the matching `#popover` reference.
+     */
+    get elementRef(): ElementRef<HTMLElement>;
+    readonly cdkTrapFocus: _angular_core.Signal<CdkTrapFocus>;
+    /** @docs-private */
+    readonly overflowContainer: _angular_core.Signal<KbqOverflowShadowContainer | undefined>;
+    private readonly scrollbarViewport;
+    /** Id of the header text node, referenced by the panel's `aria-labelledby`. */
+    get headerId(): string;
+    /**
+     * Whether the header can name the dialog. Only a string header renders a text node with an id to point
+     * `aria-labelledby` at; a template header is arbitrary markup, so those panels fall back to `ariaLabel`.
+     */
+    protected get labelledByHeader(): boolean;
+    ngAfterViewInit(): void;
+    updateClassMap(placement: string, customClass: string, size: KbqPopUpSizeValues): void;
+    updateTrapFocus(isTrapFocus: boolean): void;
+    /** Closes the panel on `Escape` inside it, unless a control there spent the key closing a popup of its own. */
+    onEscape(event?: Event): void;
+    /** Handles a click on the close button. */
+    protected onClose(): void;
+    /**
+     * Closes the panel through its trigger, so that `kbqPopoverPreventClose` is honored and focus is restored
+     * the same way as on every other closing path.
+     *
+     * The component is exported and can be rendered without a trigger — `ngAfterViewInit` already allows for
+     * that — and such a panel has no `preventClose` to honor and no trigger to hand focus back to, so it hides
+     * itself rather than throwing on a keypress.
+     */
+    private requestClose;
+    /**
+     * Whether the scrollable content region needs its own tab stop and landmark (AXE
+     * `scrollable-region-focusable`). An unconditional `tabindex` would add a stop to every popover.
+     */
+    protected isScrollableRegion(container: KbqOverflowShadowContainer): boolean;
+    protected afterShowAnimation(): void;
+    protected readonly componentColors: typeof KbqComponentColors;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPopoverComponent, "kbq-popover-component", never, {}, {}, never, never, true, never>;
+}
+declare const KBQ_POPOVER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function kbqPopoverScrollStrategyFactory(scrollDispatcher: ScrollDispatcher): () => ScrollStrategy;
+/**
+ * Redundant to the root factory of the token; kept so an app can restore the default under its own override (#DS-2196).
+ *
+ * @docs-private
+ */
+declare const KBQ_POPOVER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof ScrollDispatcher)[];
+    useFactory: typeof kbqPopoverScrollStrategyFactory;
+};
+declare class KbqPopoverTrigger extends KbqPopUpTrigger<KbqPopoverComponent> implements OnChanges, AfterContentInit, OnInit {
+    protected scrollStrategy: () => ScrollStrategy;
+    private readonly focusMonitor;
+    private readonly document;
+    private readonly overlayLayers;
+    /** Id of the panel this trigger controls, shared with `aria-controls`. */
+    readonly panelId: string;
+    /**
+     * Input (`kbqPopoverHideIfNotInViewPort`) — whether the popover closes once its trigger scrolls out of the
+     * nearest scrollable ancestor. A bound `null` or `undefined` restores the default, `true`.
+     */
+    readonly popoverHideIfNotInViewPort: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** prevents closure by any event */
+    preventClose: boolean;
+    /** Whether the header, content and footer keep their default paddings. Bound with `kbqPopoverDefaultPaddings`. */
+    defaultPaddings: boolean;
+    /** Input (`kbqPopoverDefaultPaddings`) — sets {@link defaultPaddings}. */
+    set popoverDefaultPaddings(value: boolean);
+    /** Input (`kbqPopoverVisible`) — opens the popover when set to `true` and closes it when set to `false`. */
+    get popoverVisible(): boolean;
+    set popoverVisible(value: boolean);
+    /** Input (`kbqPopoverPlacement`) — preferred placement of the panel relative to the trigger. */
+    get popoverPlacement(): KbqPopUpPlacementValues;
+    set popoverPlacement(value: KbqPopUpPlacementValues);
+    /** Input (`kbqPopoverPlacementPriority`) — ordered placements tried before the default strategy. */
+    get popoverPlacementPriority(): string | string[] | null;
+    set popoverPlacementPriority(value: string | string[] | null);
+    /**
+     * Additionally positions the element relative to the window side (Top, Right, Bottom and Left).
+     * If container is specified, the positioning will be relative to it.
+     * */
+    stickToWindow: KbqStickToWindowPlacementValues | undefined;
+    /** Container for additional positioning, used with `kbqPopoverStickToWindow`. Bound with `kbqPopoverContainer`. */
+    container: HTMLElement | undefined;
+    /** Input (`kbqPopoverContainer`) — sets {@link container}. */
+    set popoverContainer(value: HTMLElement | undefined);
+    /**
+     * Whether a backdrop is rendered behind the panel. With a backdrop the popover closes on a backdrop click
+     * instead of on any outside pointer event. Bound with `kbqPopoverHasBackdrop`.
+     */
+    get hasBackdrop(): boolean;
+    set hasBackdrop(value: boolean);
+    private _hasBackdrop;
+    /** Input (`kbqPopoverHasBackdrop`) — sets {@link hasBackdrop}. */
+    set popoverHasBackdrop(value: boolean);
+    /** Input (`kbqPopoverHeader`) — header of the panel, as a string or a template. */
+    get header(): string | TemplateRef<any>;
+    set header(value: string | TemplateRef<any>);
+    private _header;
+    /** Input (`kbqPopoverContent`) — content of the panel, as a string or a template. */
+    get content(): string | TemplateRef<any>;
+    set content(value: string | TemplateRef<any>);
+    /** Input (`kbqPopoverFooter`) — footer of the panel, as a string or a template. */
+    get footer(): string | TemplateRef<any>;
+    set footer(value: string | TemplateRef<any>);
+    private _footer;
+    /** Input (`kbqPopoverDisabled`) — disables the trigger and closes an open popover. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Input (`kbqTrigger`) with the comma-separated trigger events. An empty value resets to click + keydown
+     * and rebinds listeners. The alias is shared with `kbqTooltip`, so binding it on an element that carries
+     * both reconfigures both.
+     */
+    get trigger(): string;
+    set trigger(value: string);
+    private _trigger;
+    /** Leave delay while `kbqLeaveDelay` is not bound. */
+    private get defaultLeaveDelay();
+    /** Input (`kbqPopoverSize`) — preset width of the panel. An unknown value falls back to `medium`. */
+    get size(): KbqPopUpSizeValues;
+    set size(value: KbqPopUpSizeValues);
+    private _size;
+    /** Input (`kbqPopoverClass`) with extra CSS classes applied to the panel. */
+    get customClass(): string;
+    set customClass(value: string);
+    /** Context for popover templates (kbqPopoverHeader, kbqPopoverContent and kbqPopoverFooter). */
+    get context(): unknown;
+    set context(ctx: unknown);
+    private _context;
+    /**
+     * Accessible name of the panel. Ignored while a string `kbqPopoverHeader` is set — the header labels the
+     * dialog then — and recommended for every header-less popover.
+     */
+    get ariaLabel(): string | undefined;
+    set ariaLabel(value: string | undefined);
+    private _ariaLabel;
+    /** Renders the icon-only close button in the top corner of the panel. Bound with `kbqPopoverHasCloseButton`. */
+    get hasCloseButton(): boolean;
+    set hasCloseButton(value: boolean);
+    private _hasCloseButton;
+    /** Input (`kbqPopoverHasCloseButton`) — sets {@link hasCloseButton}. */
+    set popoverHasCloseButton(value: boolean);
+    /**
+     * Controls the behavior of closing the component on scroll. Bound with `kbqPopoverCloseOnScroll`. Three
+     * states:
+     * - `null` (default) — the popover survives a scroll, except when it scrolls out of a
+     *   `.kbq-hide-nested-popup` container, which closes it;
+     * - `true` — any scroll closes the popover;
+     * - `false` — no scroll closes the popover, not even a `.kbq-hide-nested-popup` one.
+     *
+     * Use CloseScrollStrategy as alternative
+     */
+    get closeOnScroll(): boolean | null;
+    set closeOnScroll(value: boolean);
+    private _closeOnScroll;
+    /** Input (`kbqPopoverCloseOnScroll`) — sets {@link closeOnScroll}. */
+    set popoverCloseOnScroll(value: boolean);
+    /** Whether the trigger opens the popover on click, which is also what makes it a labelled dialog opener. */
+    get hasClickTrigger(): boolean;
+    /**
+     * Whether opening the popover should move the keyboard focus into the panel. Only deliberate opens
+     * (click, keyboard, programmatic) do — a hover- or focus-triggered popover must not steal focus.
+     */
+    get capturesFocusOnOpen(): boolean;
+    /** @docs-private */
+    get instanceDestroyRef(): DestroyRef;
+    /** CSS class applied to the backdrop, when there is one. Bound with `kbqPopoverBackdropClass`. */
+    get backdropClass(): string;
+    set backdropClass(value: string);
+    private _backdropClass;
+    /** Input (`kbqPopoverBackdropClass`) — sets {@link backdropClass}. */
+    set popoverBackdropClass(value: string);
+    /** Input (`kbqPopoverArrow`) — renders the arrow pointing at the trigger. */
+    arrow: boolean;
+    /** Input (`kbqPopoverOffset`) — distance between the trigger and the panel, in pixels. */
+    offset: number | null;
+    /**
+     * Input (`kbqPopoverAutoFocus`) — whether opening the popover moves the keyboard focus into the panel. Turn it
+     * off for a panel that must not disturb what the reader is doing: taking focus away from a text selection
+     * collapses it. Focus then never enters the panel, so its content has to be reachable some other way.
+     */
+    autoFocus: boolean;
+    /**
+     * Input (`kbqPopoverOrigin`) — what the panel is positioned against: an element, or a rectangle in viewport
+     * coordinates such as the one `kbqCreateCaretOrigin` keeps on the caret. `null` anchors it to the trigger.
+     *
+     * Bind it before `kbqPopoverVisible`, which opens the panel as it is written.
+     */
+    get popoverOrigin(): KbqOverlayOrigin | null;
+    set popoverOrigin(value: KbqOverlayOrigin | null);
+    /** Input (`kbqEnterDelay`) — delay before opening, in milliseconds. Defaults to `0`. */
+    enterDelay: number;
+    /**
+     * Input (`kbqLeaveDelay`) — delay before closing, in milliseconds. Defaults to `0`, and to
+     * {@link defaultHoverLeaveDelay} when `kbqTrigger` includes `hover`.
+     */
+    set kbqLeaveDelay(value: number);
+    private leaveDelayBound;
+    /**
+     * Emits the resolved placement whenever the panel is repositioned.
+     *
+     * Declared as `string` to match the abstract member on `KbqPopUpTrigger`: `EventEmitter` is invariant,
+     * so a narrower emitter cannot override a wider one. Narrowing both is a change to the shared pop-up
+     * base and belongs to the branch that owns it.
+     */
+    readonly placementChange: EventEmitter<"top" | "right" | "left" | "bottom" | "topLeft" | "topRight" | "rightTop" | "rightBottom" | "leftTop" | "leftBottom" | "bottomLeft" | "bottomRight">;
+    /** @docs-private */
+    readonly placementChangeOutput: _angular_core.OutputRef<"top" | "right" | "left" | "bottom" | "topLeft" | "topRight" | "rightTop" | "rightBottom" | "leftTop" | "leftBottom" | "bottomLeft" | "bottomRight">;
+    /** Emits `true` when the panel opens and `false` when it closes. */
+    readonly visibleChange: EventEmitter<boolean>;
+    /** @docs-private */
+    readonly visibleChangeOutput: _angular_core.OutputRef<boolean>;
+    protected originSelector: string;
+    /** Whether a position re-apply is already queued for this turn. */
+    private repositionScheduled;
+    /**
+     * Whether the open currently on screen was a deliberate one rather than a pointer or focus one.
+     *
+     * The shared base records the event that opened the pop-up in `triggerName`, but its keyboard opener is
+     * the one listener registered without that bookkeeping, and it defers the open to a task of its own —
+     * by then `triggerName` still holds whatever the pointer last did. Frozen on every `show()`, which the
+     * pointer and focus listeners reach with the name they have just written.
+     */
+    private deliberateOpen;
+    protected get overlayConfig(): OverlayConfig;
+    /** @docs-private */
+    readonly triggerInput: InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly kbqLeaveDelayInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** @docs-private */
+    readonly enterDelayInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** @docs-private */
+    readonly preventCloseInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly stickToWindowInput: InputSignal<"top" | "right" | "left" | "bottom" | undefined>;
+    /** @docs-private */
+    readonly popoverContainerInput: InputSignal<HTMLElement | undefined>;
+    /** @docs-private */
+    readonly popoverHasBackdropInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly popoverBackdropClassInput: InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly popoverDefaultPaddingsInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly sizeInput: InputSignal<"small" | "medium" | "large" | "custom" | undefined>;
+    /** @docs-private */
+    readonly customClassInput: InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly headerInput: InputSignal<KbqPopoverTrigger['header'] | undefined>;
+    /** @docs-private */
+    readonly contentInput: InputSignal<KbqPopoverTrigger['content'] | undefined>;
+    /** @docs-private */
+    readonly footerInput: InputSignal<KbqPopoverTrigger['footer'] | undefined>;
+    /** @docs-private */
+    readonly contextInput: InputSignal<{} | null | undefined>;
+    /** @docs-private */
+    readonly ariaLabelInput: InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly popoverHasCloseButtonInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly popoverCloseOnScrollInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly arrowInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly offsetInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** @docs-private */
+    readonly autoFocusInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly popoverOriginInput: InputSignal<KbqOverlayOrigin | null | undefined>;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly popoverPlacementPriorityInput: InputSignal<string | string[] | null | undefined>;
+    /** @docs-private */
+    readonly popoverPlacementInput: InputSignal<"top" | "right" | "left" | "bottom" | "topLeft" | "topRight" | "rightTop" | "rightBottom" | "leftTop" | "leftBottom" | "bottomLeft" | "bottomRight" | undefined>;
+    /** @docs-private */
+    readonly popoverVisibleInput: InputSignal<boolean | undefined>;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /** @docs-private */
+    show(delay?: number): void;
+    /** @docs-private */
+    updateData(): void;
+    /** Body of `updateData()`. */
+    private pushData;
+    /** @docs-private */
+    createOverlay(): OverlayRef;
+    /**
+     * Re-applies the overlay position.
+     *
+     * Deliberately narrower than the inherited one, which also rebuilds the closing-action subscription:
+     * that stream carries a `delay(0)`, so a reposition coalesced into the same task as an outside click —
+     * which is the task in which that click's change detection writes a popover input — would drop the
+     * close the click had already scheduled.
+     */
+    updatePosition(reapplyPosition?: boolean): void;
+    /** @docs-private */
+    getOverlayHandleComponentType(): Type<KbqPopoverComponent>;
+    /** @docs-private */
+    updateClassMap(newPlacement?: string): void;
+    /** @docs-private */
+    closingActionsForClick(): rxjs.Observable<MouseEvent>[];
+    /** @docs-private */
+    defaultClosingActions(): rxjs.Observable<MouseEvent>[];
+    /** @docs-private */
+    closingActions(): rxjs.Observable<void | CdkScrollable | MouseEvent>;
+    /**
+     * Returns focus to the trigger when the popover is closed while focus is still inside its panel.
+     *
+     * Goes through `FocusMonitor` rather than a native `focus()` call: the kbq focus ring is only rendered
+     * for a monitored origin, and a `program` origin keeps a tooltip on the same element from re-opening.
+     */
+    restoreFocus(): void;
+    /**
+     * Closes the popover on a deliberate action — the panel's close button, or `Escape` inside the panel.
+     *
+     * `hide()` keeps a hover popover open while the pointer rests on the panel, so that the pointer can
+     * travel from the trigger to the content; that is exactly where the pointer is when the close button is
+     * clicked, so a deliberate close answers to `kbqPopoverPreventClose` and to nothing else.
+     */
+    close(): void;
+    /**
+     * Coalesces the position re-apply: a burst of input writes — or a parent change-detection pass that
+     * recreates the object bound to `kbqPopoverContext` — schedules one reposition per turn instead of one
+     * per write, each of which costs a forced layout read per candidate position.
+     */
+    private scheduleReposition;
+    /**
+     * Drops a closed overlay so the next `show()` rebuilds it. The backdrop and its class are baked into the
+     * overlay when it is created, and CDK does not re-render them from the config afterwards.
+     */
+    private invalidateOverlay;
+    /** Closes the popover once it has scrolled out of its nearest scrollable ancestor. */
+    private hideIfScrolledOutOfView;
+    /** Closes the popover once its trigger has scrolled out of a `.kbq-hide-nested-popup` container. */
+    private hideIfNestedPopupScrolledAway;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPopoverTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPopoverTrigger, "[kbqPopover]", ["kbqPopover"], { "popoverHideIfNotInViewPort": { "alias": "kbqPopoverHideIfNotInViewPort"; "required": false; "isSignal": true; }; "triggerInput": { "alias": "kbqTrigger"; "required": false; "isSignal": true; }; "kbqLeaveDelayInput": { "alias": "kbqLeaveDelay"; "required": false; "isSignal": true; }; "enterDelayInput": { "alias": "kbqEnterDelay"; "required": false; "isSignal": true; }; "preventCloseInput": { "alias": "kbqPopoverPreventClose"; "required": false; "isSignal": true; }; "stickToWindowInput": { "alias": "kbqPopoverStickToWindow"; "required": false; "isSignal": true; }; "popoverContainerInput": { "alias": "kbqPopoverContainer"; "required": false; "isSignal": true; }; "popoverHasBackdropInput": { "alias": "kbqPopoverHasBackdrop"; "required": false; "isSignal": true; }; "popoverBackdropClassInput": { "alias": "kbqPopoverBackdropClass"; "required": false; "isSignal": true; }; "popoverDefaultPaddingsInput": { "alias": "kbqPopoverDefaultPaddings"; "required": false; "isSignal": true; }; "sizeInput": { "alias": "kbqPopoverSize"; "required": false; "isSignal": true; }; "customClassInput": { "alias": "kbqPopoverClass"; "required": false; "isSignal": true; }; "headerInput": { "alias": "kbqPopoverHeader"; "required": false; "isSignal": true; }; "contentInput": { "alias": "kbqPopoverContent"; "required": false; "isSignal": true; }; "footerInput": { "alias": "kbqPopoverFooter"; "required": false; "isSignal": true; }; "contextInput": { "alias": "kbqPopoverContext"; "required": false; "isSignal": true; }; "ariaLabelInput": { "alias": "kbqPopoverAriaLabel"; "required": false; "isSignal": true; }; "popoverHasCloseButtonInput": { "alias": "kbqPopoverHasCloseButton"; "required": false; "isSignal": true; }; "popoverCloseOnScrollInput": { "alias": "kbqPopoverCloseOnScroll"; "required": false; "isSignal": true; }; "arrowInput": { "alias": "kbqPopoverArrow"; "required": false; "isSignal": true; }; "offsetInput": { "alias": "kbqPopoverOffset"; "required": false; "isSignal": true; }; "autoFocusInput": { "alias": "kbqPopoverAutoFocus"; "required": false; "isSignal": true; }; "popoverOriginInput": { "alias": "kbqPopoverOrigin"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "kbqPopoverDisabled"; "required": false; "isSignal": true; }; "popoverPlacementPriorityInput": { "alias": "kbqPopoverPlacementPriority"; "required": false; "isSignal": true; }; "popoverPlacementInput": { "alias": "kbqPopoverPlacement"; "required": false; "isSignal": true; }; "popoverVisibleInput": { "alias": "kbqPopoverVisible"; "required": false; "isSignal": true; }; }, { "placementChangeOutput": "kbqPopoverPlacementChange"; "visibleChangeOutput": "kbqPopoverVisibleChange"; }, never, never, true, never>;
+}
+
+/**
+ * Overrides the question of every confirmation popover in the injector scope. Takes precedence over the
+ * locale, but not over the `kbqPopoverConfirmText` input.
+ */
+declare const KBQ_POPOVER_CONFIRM_TEXT: InjectionToken<string>;
+/**
+ * Overrides the confirm-button caption of every confirmation popover in the injector scope. Takes precedence
+ * over the locale, but not over the `kbqPopoverConfirmButtonText` input.
+ */
+declare const KBQ_POPOVER_CONFIRM_BUTTON_TEXT: InjectionToken<string>;
+declare class KbqPopoverConfirmComponent extends KbqPopoverComponent {
+    /**
+     * Emits when the confirm button is pressed. Internal channel between the panel and its trigger — consume
+     * the trigger's `confirm` output instead.
+     *
+     * @docs-private
+     */
+    readonly onConfirm: Subject<void>;
+    /** Caption of the confirm button. Written by the trigger. */
+    get confirmButtonText(): string;
+    set confirmButtonText(value: string);
+    private readonly confirmButtonTextState;
+    /** Question rendered in the panel. Written by the trigger. */
+    get confirmText(): string;
+    set confirmText(value: string);
+    private readonly confirmTextState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPopoverConfirmComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPopoverConfirmComponent, "kbq-popover-confirm-component", never, {}, {}, never, never, true, never>;
+}
+declare class KbqPopoverConfirmTrigger extends KbqPopoverTrigger {
+    /** Emits when the user confirms the action. */
+    readonly confirm: _angular_core.OutputEmitterRef<void>;
+    private readonly localeConfiguration;
+    private readonly externalConfirmText;
+    private readonly externalConfirmButtonText;
+    /**
+     * Input (`kbqPopoverConfirmText`) — question rendered in the panel. Falls back to
+     * {@link KBQ_POPOVER_CONFIRM_TEXT} and then to the `popoverConfirm` section of the active locale while
+     * unset or `undefined`.
+     */
+    get confirmText(): string;
+    set confirmText(value: string | undefined);
+    private readonly _confirmText;
+    /**
+     * Input (`kbqPopoverConfirmButtonText`) — caption of the confirm button. Falls back to
+     * {@link KBQ_POPOVER_CONFIRM_BUTTON_TEXT} and then to the `popoverConfirm` section of the active locale
+     * while unset or `undefined`.
+     */
+    get confirmButtonText(): string;
+    set confirmButtonText(value: string | undefined);
+    private readonly _confirmButtonText;
+    /** Panel the confirm handler is currently wired to, so it is wired once per attach. */
+    private wiredInstance;
+    /** @docs-private */
+    readonly confirmTextInput: _angular_core.InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly confirmButtonTextInput: _angular_core.InputSignal<string | undefined>;
+    ngOnChanges(changes: SimpleChanges): void;
+    constructor();
+    /** @docs-private */
+    updateData(): void;
+    /**
+     * Subscribes to the panel's confirm button. Called once per attach: the subscription is scoped to the
+     * panel, so it dies with it.
+     *
+     * @docs-private
+     */
+    setupButtonEvents(): void;
+    /** @docs-private */
+    getOverlayHandleComponentType(): typeof KbqPopoverConfirmComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPopoverConfirmTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPopoverConfirmTrigger, "[kbqPopoverConfirm]", ["kbqPopoverConfirm"], { "confirmTextInput": { "alias": "kbqPopoverConfirmText"; "required": false; "isSignal": true; }; "confirmButtonTextInput": { "alias": "kbqPopoverConfirmButtonText"; "required": false; "isSignal": true; }; }, { "confirm": "confirm"; }, never, never, true, never>;
+}
+
+declare class KbqPopoverModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPopoverModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqPopoverModule, never, [typeof KbqPopoverComponent, typeof KbqPopoverTrigger, typeof KbqPopoverConfirmComponent, typeof KbqPopoverConfirmTrigger], [typeof KbqPopoverComponent, typeof KbqPopoverTrigger, typeof KbqPopoverConfirmComponent, typeof KbqPopoverConfirmTrigger]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqPopoverModule>;
+}
+
+export { KBQ_POPOVER_CONFIRM_BUTTON_TEXT, KBQ_POPOVER_CONFIRM_TEXT, KBQ_POPOVER_FOCUS_TRAP_PROVIDERS, KBQ_POPOVER_SCROLL_STRATEGY, KBQ_POPOVER_SCROLL_STRATEGY_FACTORY_PROVIDER, KbqPopoverComponent, KbqPopoverConfirmComponent, KbqPopoverConfirmTrigger, KbqPopoverModule, KbqPopoverTrigger, defaultHoverLeaveDelay, defaultOffsetYWithArrow, kbqPopoverScrollStrategyFactory };

package/types/koobiq-components-progress-bar.d.ts

@@ -0,0 +1,67 @@
+import * as _angular_core from '@angular/core';
+import { KbqColorDirective } from '@koobiq/components/core';
+
+/** Whether the bar reports a known share of the work, or an operation whose duration is unknown. */
+type ProgressBarMode = 'determinate' | 'indeterminate';
+/**
+ * Label projected above the bar. Names the bar for assistive tech: `KbqProgressBar` points its
+ * `aria-labelledby` at this element.
+ */
+declare class KbqProgressBarText {
+    /** Element id. Generated when not supplied, so the bar can always reference it. */
+    readonly id: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqProgressBarText, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqProgressBarText, "[kbq-progress-bar-text]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Caption projected below the bar. Describes the bar for assistive tech: `KbqProgressBar` points its
+ * `aria-describedby` at this element.
+ */
+declare class KbqProgressBarCaption {
+    /** Element id. Generated when not supplied, so the bar can always reference it. */
+    readonly id: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqProgressBarCaption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqProgressBarCaption, "[kbq-progress-bar-caption]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Horizontal indicator of the progress of an operation. */
+declare class KbqProgressBar extends KbqColorDirective {
+    private readonly a11yLocaleConfiguration;
+    private readonly text;
+    protected readonly caption: _angular_core.Signal<KbqProgressBarCaption | undefined>;
+    /** Id of the host element. Generated when not supplied. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Share of the work that is done, in the `[0, 100]` range. Ignored in indeterminate mode. */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Whether the bar reports `value`, or an operation whose duration is unknown. */
+    readonly mode: _angular_core.InputSignal<ProgressBarMode>;
+    /**
+     * Accessible name of the bar. Takes precedence over a projected `[kbq-progress-bar-text]`; when
+     * neither is given, the bar falls back to the `progressBar` name from the a11y locale.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * Whether the fill follows a new value without a transition, and the indeterminate fill pulses in place instead
+     * of sliding, as under reduced motion.
+     *
+     * @docs-private
+     */
+    protected readonly animationsDisabled: boolean;
+    /** Anything other than `indeterminate` reports a value, matching the branch the template renders. */
+    protected readonly indeterminate: _angular_core.Signal<boolean>;
+    /** `value` clamped into `[0, 100]`. A non-finite value would be written out as an invalid width. */
+    protected readonly percentage: _angular_core.Signal<number>;
+    protected readonly resolvedAriaLabelledby: _angular_core.Signal<string | null>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqProgressBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqProgressBar, "kbq-progress-bar", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, ["text", "caption"], ["[kbq-progress-bar-text]", "[kbq-progress-bar-caption]"], true, never>;
+}
+
+declare class KbqProgressBarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqProgressBarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqProgressBarModule, never, [typeof KbqProgressBar, typeof KbqProgressBarText, typeof KbqProgressBarCaption], [typeof KbqProgressBar, typeof KbqProgressBarText, typeof KbqProgressBarCaption]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqProgressBarModule>;
+}
+
+export { KbqProgressBar, KbqProgressBarCaption, KbqProgressBarModule, KbqProgressBarText };
+export type { ProgressBarMode };

package/{progress-spinner/index.d.ts → types/koobiq-components-progress-spinner.d.ts}

@@ -1,30 +1,53 @@
 import * as i0 from '@angular/core';
-import { KbqColorDirective } from '@koobiq/components/core';
+import { KbqColorDirective, KbqDefaultSizes } from '@koobiq/components/core';
 import * as i1 from '@angular/cdk/platform';
 
+/** Whether the spinner reports a known progress value or spins indefinitely. */
 type ProgressSpinnerMode = 'determinate' | 'indeterminate';
-type ProgressSpinnerSize = 'compact' | 'big';
+/** Sizes supported by the progress spinner. */
+type ProgressSpinnerSize = Exclude<KbqDefaultSizes, 'normal'>;
+/** Directive that marks the text of a progress spinner. */
 declare class KbqProgressSpinnerText {
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqProgressSpinnerText, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<KbqProgressSpinnerText, "[kbq-progress-spinner-text]", never, {}, {}, never, never, true, never>;
 }
+/** Directive that marks the caption of a progress spinner. */
 declare class KbqProgressSpinnerCaption {
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqProgressSpinnerCaption, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<KbqProgressSpinnerCaption, "[kbq-progress-spinner-caption]", never, {}, {}, never, never, true, never>;
 }
+/** Component that reports the progress of an ongoing operation. */
 declare class KbqProgressSpinner extends KbqColorDirective {
+    /** Unique id of the spinner. */
     readonly id: i0.InputSignal<string>;
-    readonly value: i0.InputSignal<number>;
+    /**
+     * Progress of the operation, in percent. Clamped to `[0, 100]` and only rendered in `determinate` mode.
+     *
+     * Anything that is not a number reads as `0`: the value feeds a `stroke-dashoffset` percentage, and a
+     * bare `numberAttribute` would turn a null binding into `NaN%`, which is not a length at all. The
+     * transform is typed rather than taking `unknown`, so `[value]="progress$ | async"` and `value="40"`
+     * keep type-checking while an object or an array stays a template type error.
+     */
+    readonly value: i0.InputSignalWithTransform<number, string | number | null | undefined>;
+    /** Whether the spinner reports `value` or spins indefinitely. */
     readonly mode: i0.InputSignal<ProgressSpinnerMode>;
-    get size(): ProgressSpinnerSize | string;
-    set size(value: ProgressSpinnerSize | string);
-    private _size;
-    svgCircleRadius: string;
-    get percentage(): number;
-    get dashOffsetPercent(): string;
+    /** Size of the spinner. */
+    readonly size: i0.InputSignal<ProgressSpinnerSize>;
+    /** @docs-private */
+    protected readonly svgCircleRadius: i0.Signal<string>;
+    /** @docs-private */
+    protected readonly percentage: i0.Signal<number>;
+    /** @docs-private */
+    protected readonly dashOffsetPercent: i0.Signal<string>;
+    /**
+     * Whether the indeterminate spinner stands still and the determinate one follows a new value at once.
+     *
+     * @docs-private
+     */
+    protected readonly animationsDisabled: boolean;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqProgressSpinner, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqProgressSpinner, "kbq-progress-spinner", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["[kbq-progress-spinner-text]", "[kbq-progress-spinner-caption]"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqProgressSpinner, "kbq-progress-spinner", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[kbq-progress-spinner-text]", "[kbq-progress-spinner-caption]"], true, never>;
 }
 
 declare class KbqProgressSpinnerModule {