@koobiq/components 19.8.3 → 20.1.0

package/alert/index.d.ts

@@ -1 +1,54 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterContentInit } from '@angular/core';
+import { KbqButton } from '@koobiq/components/button';
+import { KbqIconItem, KbqIcon } from '@koobiq/components/icon';
+import * as i1 from '@angular/cdk/a11y';
+import * as i2 from '@angular/cdk/platform';
+
+declare enum KbqAlertStyles {
+    Default = "default",
+    Colored = "colored"
+}
+declare enum KbqAlertColors {
+    Error = "error",
+    Warning = "warning",
+    Success = "success",
+    Info = "info"
+}
+declare class KbqAlertTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAlertTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqAlertTitle, "[kbq-alert-title]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqAlertCloseButton {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAlertCloseButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqAlertCloseButton, "[kbq-alert-close-button]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqAlertControl {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAlertControl, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqAlertControl, "[kbq-alert-control]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqAlert implements AfterContentInit {
+    readonly iconItem: i0.Signal<KbqIconItem | undefined>;
+    readonly icon: i0.Signal<KbqIcon | undefined>;
+    readonly button: i0.Signal<KbqButton | undefined>;
+    readonly title: i0.Signal<KbqAlertTitle | undefined>;
+    readonly control: i0.Signal<KbqAlertControl | undefined>;
+    readonly closeButton: i0.Signal<KbqAlertCloseButton | undefined>;
+    readonly compact: i0.InputSignal<boolean>;
+    readonly alertStyle: i0.InputSignal<string>;
+    get alertColor(): string;
+    set alertColor(value: string | KbqAlertColors);
+    private _alertColor;
+    get isColored(): boolean;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAlert, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqAlert, "kbq-alert", never, { "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "alertStyle": { "alias": "alertStyle"; "required": false; "isSignal": true; }; "alertColor": { "alias": "alertColor"; "required": false; }; }, {}, ["iconItem", "icon", "button", "title", "control", "closeButton"], ["[kbq-icon-item],[kbq-icon]", "[kbq-alert-title]", "*", "[kbq-alert-control]", "[kbq-alert-close-button]"], true, never>;
+}
+
+declare class KbqAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqAlertModule, never, [typeof i1.A11yModule, typeof i2.PlatformModule, typeof KbqAlert, typeof KbqAlertTitle, typeof KbqAlertCloseButton, typeof KbqAlertControl], [typeof KbqAlert, typeof KbqAlertTitle, typeof KbqAlertCloseButton, typeof KbqAlertControl]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqAlertModule>;
+}
+
+export { KbqAlert, KbqAlertCloseButton, KbqAlertColors, KbqAlertControl, KbqAlertModule, KbqAlertStyles, KbqAlertTitle };

package/app-switcher/app-switcher-dropdown-app.scss

@@ -9,6 +9,8 @@
     min-height: 50px;
 
     border-radius: var(--kbq-size-xs);
+    // base transparent border so the .cdk-keyboard-focused border-color renders a focus ring (matches list-item-base)
+    border: var(--kbq-size-3xs) solid transparent;
 
     @include common.user-select(none);
 

package/app-switcher/index.d.ts

@@ -1 +1,239 @@
-export * from './public-api';
+import * as rxjs from 'rxjs';
+import { Subscription } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewInit, AfterContentInit, OnInit, TemplateRef, EventEmitter, Type } from '@angular/core';
+import * as _koobiq_components_core from '@koobiq/components/core';
+import { KbqPopUp, KbqPopUpTrigger, KbqPopUpPlacementValues, KbqPopUpSizeValues } from '@koobiq/components/core';
+import { ScrollStrategy, Overlay, OverlayConfig, CdkScrollable } from '@angular/cdk/overlay';
+import { FormControl } from '@angular/forms';
+import { KbqDropdownTrigger, KbqDropdownItem } from '@koobiq/components/dropdown';
+import { KbqInput } from '@koobiq/components/input';
+import { AnimationTriggerMetadata } from '@angular/animations';
+import * as _angular_platform_browser from '@angular/platform-browser';
+
+interface KbqAppSwitcherApp {
+    name: string;
+    id: string | number;
+    type?: string | number;
+    /** Inline SVG markup for the application icon. Use this for SVG icons that should be rendered directly in the DOM. */
+    icon?: string;
+    /** Path to the icon file (URL or relative path). */
+    iconSrc?: string;
+    caption?: string;
+    aliases?: KbqAppSwitcherApp[];
+    link?: string;
+}
+interface KbqAppSwitcherSite {
+    name: string;
+    id: string | number;
+    status?: string;
+    /** Inline SVG markup for the site icon. Use this for SVG icons that should be rendered directly in the DOM. */
+    icon?: string;
+    /** Path to the icon file (URL or relative path). */
+    iconSrc?: string;
+    apps: KbqAppSwitcherApp[];
+}
+/** @docs-private */
+declare function defaultGroupBy(app: KbqAppSwitcherApp, groups: Record<string, KbqAppSwitcherApp>, untyped: KbqAppSwitcherApp[]): void;
+declare const KBQ_MIN_NUMBER_OF_APPS_TO_ENABLE_SEARCH: number;
+declare const KBQ_MIN_NUMBER_OF_APPS_TO_ENABLE_GROUPING: number;
+/** @docs-private */
+declare const KBQ_APP_SWITCHER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function kbqAppSwitcherScrollStrategyFactory(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+declare const KBQ_APP_SWITCHER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof kbqAppSwitcherScrollStrategyFactory;
+};
+/** default configuration of app-switcher */
+/** @docs-private */
+declare const KBQ_APP_SWITCHER_DEFAULT_CONFIGURATION: {
+    searchPlaceholder: string;
+    searchEmptyResult: string;
+    sitesHeader: string;
+};
+/** Injection Token for providing configuration of app-switcher */
+/** @docs-private */
+declare const KBQ_APP_SWITCHER_CONFIGURATION: InjectionToken<unknown>;
+/** @docs-private */
+declare class KbqAppSwitcherComponent extends KbqPopUp implements AfterViewInit {
+    /** @docs-private */
+    protected readonly localeService: _koobiq_components_core.KbqLocaleService | null;
+    readonly externalConfiguration: unknown;
+    configuration: any;
+    /** localized data
+     * @docs-private */
+    get localeData(): any;
+    /** @docs-private */
+    readonly searchControl: FormControl<string | null>;
+    /** @docs-private */
+    filteredSites: KbqAppSwitcherSite[];
+    /** @docs-private */
+    prefix: string;
+    /** @docs-private */
+    trigger: KbqAppSwitcherTrigger;
+    /** @docs-private */
+    isTrapFocus: boolean;
+    /** @docs-private */
+    protected activeSite: KbqAppSwitcherSite;
+    /** @docs-private */
+    protected activeApp: KbqAppSwitcherApp;
+    /** @docs-private */
+    readonly input: i0.Signal<KbqInput | undefined>;
+    /** @docs-private */
+    readonly otherSites: i0.Signal<KbqDropdownTrigger>;
+    constructor();
+    ngAfterViewInit(): void;
+    /** @docs-private */
+    updateClassMap(placement: string, customClass: string, size: KbqPopUpSizeValues): void;
+    /** @docs-private */
+    updateTrapFocus(isTrapFocus: boolean): void;
+    /** @docs-private */
+    escapeHandler(): void;
+    /** @docs-private */
+    selectAppInSite(site: KbqAppSwitcherSite, app: KbqAppSwitcherApp): void;
+    private filterSites;
+    private updateLocaleParams;
+    private initDefaultParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAppSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqAppSwitcherComponent, "kbq-app-switcher", never, { "trigger": { "alias": "trigger"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class KbqAppSwitcherTrigger extends KbqPopUpTrigger<KbqAppSwitcherComponent> implements AfterContentInit, OnInit {
+    /** @docs-private */
+    protected scrollStrategy: () => ScrollStrategy;
+    /** @docs-private */
+    arrow: boolean;
+    /** @docs-private */
+    customClass: string;
+    /** @docs-private */
+    private hasBackdrop;
+    /** @docs-private */
+    private size;
+    /** @docs-private */
+    content: string | TemplateRef<any>;
+    /** @docs-private */
+    header: string | TemplateRef<any>;
+    /** @docs-private */
+    footer: string | TemplateRef<any>;
+    /** @docs-private */
+    private closeOnScroll;
+    /** Whether search is used or not */
+    get withSearch(): boolean;
+    /** Number of applications to choose from
+     * @docs-private */
+    get appsCount(): number;
+    /** Whether the sites are used or not
+     * @docs-private */
+    get sitesMode(): boolean;
+    /** @docs-private */
+    get currentApps(): KbqAppSwitcherApp[];
+    /** Selected application */
+    selectedApp: KbqAppSwitcherApp;
+    /** Placement of popUp */
+    placement: KbqPopUpPlacementValues;
+    /** Class that will be used in the background */
+    backdropClass: string;
+    /** Offset of popUp */
+    offset: number | null;
+    /** Array of sites */
+    get sites(): KbqAppSwitcherSite[];
+    set sites(value: KbqAppSwitcherSite[]);
+    private _parsedSites;
+    private makeGroupsForApps;
+    private _parsedApps;
+    /** Function to group the apps by type. The first argument is an app object with type.
+     * The second is a groups object and third is an array for untyped apps */
+    get groupBy(): (app: KbqAppSwitcherApp, groups: Record<string, KbqAppSwitcherApp>, untyped: KbqAppSwitcherApp[]) => void;
+    set groupBy(fn: (app: KbqAppSwitcherApp, groups: Record<string, KbqAppSwitcherApp>, untyped: KbqAppSwitcherApp[]) => void);
+    private _groupBy;
+    /** Selected site */
+    get selectedSite(): KbqAppSwitcherSite;
+    set selectedSite(value: KbqAppSwitcherSite);
+    private _parsedSelectedSite;
+    /** Whether the trigger is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** @docs-private */
+    get hasClickTrigger(): boolean;
+    /** Emits a change event whenever the placement state changes. */
+    readonly placementChange: EventEmitter<any>;
+    /** Emits a change event whenever the visible state changes. */
+    readonly visibleChange: EventEmitter<boolean>;
+    /** @docs-private */
+    readonly selectedSiteChange: i0.OutputEmitterRef<KbqAppSwitcherSite>;
+    /** @docs-private */
+    readonly selectedAppChange: i0.OutputEmitterRef<KbqAppSwitcherApp>;
+    /** @docs-private */
+    trigger: string;
+    /** @docs-private */
+    originalSites: KbqAppSwitcherSite[];
+    /** @docs-private */
+    protected originSelector: string;
+    /** @docs-private */
+    protected get overlayConfig(): OverlayConfig;
+    /** @docs-private */
+    protected preventClosingByInnerScrollSubscription: Subscription;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /** @docs-private */
+    updateData(): void;
+    /** Updates the current position.
+     * @docs-private */
+    updatePosition(reapplyPosition?: boolean): void;
+    /** @docs-private */
+    getOverlayHandleComponentType(): Type<KbqAppSwitcherComponent>;
+    /** @docs-private */
+    updateClassMap(newPlacement?: string): void;
+    /** @docs-private */
+    closingActions(): rxjs.Observable<void | MouseEvent | CdkScrollable>;
+    private hideIfNotInViewPort;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAppSwitcherTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqAppSwitcherTrigger, "[kbqAppSwitcher]", ["kbqAppSwitcher"], { "selectedApp": { "alias": "selectedApp"; "required": false; }; "placement": { "alias": "kbqAppSwitcherPlacement"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "sites": { "alias": "sites"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; "selectedSite": { "alias": "selectedSite"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "placementChange": "kbqPlacementChange"; "visibleChange": "kbqVisibleChange"; "selectedSiteChange": "selectedSiteChange"; "selectedAppChange": "selectedAppChange"; }, never, never, true, never>;
+    static ngAcceptInputType_offset: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** @docs-private */
+declare const kbqAppSwitcherAnimations: {
+    readonly state: AnimationTriggerMetadata;
+};
+
+/** @docs-private */
+declare class KbqAppSwitcherDropdownApp extends KbqDropdownItem {
+    private sanitizer;
+    app: KbqAppSwitcherApp;
+    getIcon(icon: string | null): _angular_platform_browser.SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAppSwitcherDropdownApp, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqAppSwitcherDropdownApp, "[kbq-app-switcher-dropdown-app]", ["kbqAppSwitcherDropdownApp"], { "app": { "alias": "kbq-app-switcher-dropdown-app"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** @docs-private */
+declare class KbqAppSwitcherDropdownSite extends KbqDropdownItem {
+    site: KbqAppSwitcherSite;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAppSwitcherDropdownSite, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqAppSwitcherDropdownSite, "[kbq-app-switcher-dropdown-site]", ["kbqAppSwitcherDropdownSite"], { "site": { "alias": "kbq-app-switcher-dropdown-site"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** @docs-private */
+declare class KbqAppSwitcherListItem extends KbqDropdownItem {
+    private sanitizer;
+    app: KbqAppSwitcherApp;
+    readonly toggle: i0.InputSignalWithTransform<boolean, unknown>;
+    collapsed: boolean;
+    clickHandler(event: MouseEvent): void;
+    getIcon(icon: string | null): _angular_platform_browser.SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAppSwitcherListItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqAppSwitcherListItem, "[kbq-app-switcher-list-item]", ["kbqAppSwitcherApp"], { "app": { "alias": "app"; "required": false; }; "toggle": { "alias": "toggle"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_collapsed: unknown;
+}
+
+declare class KbqAppSwitcherModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAppSwitcherModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqAppSwitcherModule, never, [typeof KbqAppSwitcherComponent, typeof KbqAppSwitcherTrigger, typeof KbqAppSwitcherListItem, typeof KbqAppSwitcherDropdownApp, typeof KbqAppSwitcherDropdownSite], [typeof KbqAppSwitcherTrigger]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqAppSwitcherModule>;
+}
+
+export { KBQ_APP_SWITCHER_CONFIGURATION, KBQ_APP_SWITCHER_DEFAULT_CONFIGURATION, KBQ_APP_SWITCHER_SCROLL_STRATEGY, KBQ_APP_SWITCHER_SCROLL_STRATEGY_FACTORY_PROVIDER, KBQ_MIN_NUMBER_OF_APPS_TO_ENABLE_GROUPING, KBQ_MIN_NUMBER_OF_APPS_TO_ENABLE_SEARCH, KbqAppSwitcherComponent, KbqAppSwitcherDropdownApp, KbqAppSwitcherDropdownSite, KbqAppSwitcherListItem, KbqAppSwitcherModule, KbqAppSwitcherTrigger, defaultGroupBy, kbqAppSwitcherAnimations, kbqAppSwitcherScrollStrategyFactory };
+export type { KbqAppSwitcherApp, KbqAppSwitcherSite };

package/autocomplete/index.d.ts

@@ -1 +1,265 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterContentInit, TemplateRef, QueryList, InjectionToken, Provider, AfterViewInit, OnDestroy } from '@angular/core';
+import * as i2 from '@angular/cdk/overlay';
+import { ScrollStrategy, Overlay } from '@angular/cdk/overlay';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1 from '@koobiq/components/core';
+import { ActiveDescendantKeyManager, KbqOption, KbqOptgroup, KeyboardNavigationHandler, KbqOptionSelectionChange } from '@koobiq/components/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Directive applied to an element to make it usable
+ * as a connection point for an autocomplete panel.
+ */
+declare class KbqAutocompleteOrigin {
+    elementRef: ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAutocompleteOrigin, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqAutocompleteOrigin, "[kbqAutocompleteOrigin]", ["kbqAutocompleteOrigin"], {}, {}, never, never, true, never>;
+}
+
+/** Footer that is rendered below the autocomplete options panel. */
+declare class KbqAutocompleteFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAutocompleteFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqAutocompleteFooter, "[kbqAutocompleteFooter], kbq-autocomplete-footer", never, {}, {}, never, never, true, never>;
+}
+declare class KbqAutocompleteSelectedEvent {
+    source: KbqAutocomplete;
+    option: KbqOption;
+    constructor(source: KbqAutocomplete, option: KbqOption);
+}
+/** Default `kbq-autocomplete` options that can be overridden. */
+interface KbqAutocompleteDefaultOptions {
+    /** Whether the first option should be highlighted when an autocomplete panel is opened. */
+    autoActiveFirstOption?: boolean;
+}
+/** Injection token to be used to override the default options for `kbq-autocomplete`. */
+declare const KBQ_AUTOCOMPLETE_DEFAULT_OPTIONS: InjectionToken<KbqAutocompleteDefaultOptions>;
+declare function KBQ_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY(): KbqAutocompleteDefaultOptions;
+declare class KbqAutocomplete implements AfterContentInit {
+    private changeDetectorRef;
+    private elementRef;
+    private readonly parentFormField;
+    private readonly destroyRef;
+    /** Unique ID to be used by autocomplete trigger's "aria-owns" property. */
+    id: string;
+    /** Manages active item in option list based on key events. */
+    keyManager: ActiveDescendantKeyManager<KbqOption>;
+    /** Whether the autocomplete panel should be visible, depending on option length. */
+    showPanel: boolean;
+    readonly template: i0.Signal<TemplateRef<any>>;
+    readonly panel: i0.Signal<ElementRef<any>>;
+    options: QueryList<KbqOption>;
+    readonly optionGroups: i0.Signal<readonly KbqOptgroup[]>;
+    /** Function that maps an option's control value to its display value in the trigger. */
+    displayWith: ((value: any) => string) | null;
+    /**
+     * Specify the width of the autocomplete panel.  Can be any CSS sizing value, otherwise it will
+     * match the width of its host.
+     */
+    panelWidth: string | number;
+    /**
+     * Minimum width of the panel in pixels.
+     * When panelWidth is not set, the panel will be at least as wide as its host and no less than panelMinWidth.
+     */
+    panelMinWidth: number;
+    /** Event that is emitted whenever an option from the list is selected. */
+    readonly optionSelected: i0.OutputEmitterRef<KbqAutocompleteSelectedEvent>;
+    /** Event that is emitted when the autocomplete panel is opened. */
+    readonly opened: i0.OutputEmitterRef<void>;
+    /** Event that is emitted when the autocomplete panel is closed. */
+    readonly closed: i0.OutputEmitterRef<void>;
+    /**
+     * Takes classes set on the host kbq-autocomplete element and applies them to the panel
+     * inside the overlay container to allow for easy styling.
+     */
+    get classList(): string;
+    set classList(value: string);
+    private _classList;
+    /**
+     * Whether the first option should be highlighted when the autocomplete panel is opened.
+     * Can be configured globally through the `KBQ_AUTOCOMPLETE_DEFAULT_OPTIONS` token.
+     */
+    get autoActiveFirstOption(): boolean;
+    set autoActiveFirstOption(value: boolean);
+    private _autoActiveFirstOption;
+    get isOpen(): boolean;
+    set isOpen(value: boolean);
+    private _isOpen;
+    get openOnFocus(): boolean;
+    set openOnFocus(value: boolean);
+    private _openOnFocus;
+    constructor();
+    ngAfterContentInit(): void;
+    setScrollTop(scrollTop: number): void;
+    getScrollTop(): number;
+    setVisibility(): void;
+    emitSelectEvent(option: KbqOption): void;
+    onKeydown(event: KeyboardEvent): any;
+    private updateFocusClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAutocomplete, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqAutocomplete, "kbq-autocomplete", ["kbqAutocomplete"], { "displayWith": { "alias": "displayWith"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; }; "classList": { "alias": "class"; "required": false; }; "autoActiveFirstOption": { "alias": "autoActiveFirstOption"; "required": false; }; "openOnFocus": { "alias": "openOnFocus"; "required": false; }; }, { "optionSelected": "optionSelected"; "opened": "opened"; "closed": "closed"; }, ["optionGroups", "options"], ["*", "[kbqAutocompleteFooter], kbq-autocomplete-footer"], true, never>;
+    static ngAcceptInputType_panelMinWidth: unknown;
+}
+
+/**
+ * The following style constants are necessary to save here in order
+ * to properly calculate the scrollTop of the panel. Because we are not
+ * actually focusing the active item, scroll must be handled manually.
+ */
+/** The total height of the autocomplete panel. */
+declare const AUTOCOMPLETE_PANEL_HEIGHT = 256;
+/** Injection token that determines the scroll handling while the autocomplete panel is open. */
+declare const KBQ_AUTOCOMPLETE_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+declare function KBQ_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+declare const KBQ_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof KBQ_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY;
+};
+/**
+ * Provider that allows the autocomplete to register as a ControlValueAccessor.
+ * @docs-private
+ */
+declare const KBQ_AUTOCOMPLETE_VALUE_ACCESSOR: Provider;
+/**
+ * Creates an error to be thrown when attempting to use an autocomplete trigger without a panel.
+ * @docs-private
+ */
+declare function getKbqAutocompleteMissingPanelError(): Error;
+declare class KbqAutocompleteTrigger implements AfterViewInit, ControlValueAccessor, OnDestroy, KeyboardNavigationHandler {
+    private elementRef;
+    private viewContainerRef;
+    private changeDetectorRef;
+    private overlay;
+    private zone;
+    private dir;
+    private formField;
+    private viewportRuler;
+    protected readonly document: Document;
+    readonly optionSelections: Observable<KbqOptionSelectionChange>;
+    /** The currently active option, coerced to MatOption type. */
+    get activeOption(): KbqOption | null;
+    get panelOpen(): boolean;
+    /** The autocomplete panel to be attached to this trigger. */
+    readonly autocomplete: i0.InputSignal<KbqAutocomplete>;
+    /**
+     * Reference relative to which to position the autocomplete panel.
+     * Defaults to the autocomplete trigger element.
+     */
+    readonly connectedTo: i0.InputSignal<KbqAutocompleteOrigin>;
+    /**
+     * `autocomplete` attribute to be set on the input element.
+     * @docs-private
+     */
+    readonly autocompleteAttribute: i0.InputSignal<string>;
+    /**
+     * Whether the autocomplete is disabled. When disabled, the element will
+     * act as a regular input and the user won't be able to open the panel.
+     */
+    get autocompleteDisabled(): boolean;
+    set autocompleteDisabled(value: boolean);
+    /**
+     * Event handler for input blur events.
+     * Determines whether the blur event is triggered outside the specific target
+     * @returns A boolean indicating if the blur event happened outside the target element
+     */
+    readonly onInputBlur: i0.InputSignal<(event: FocusEvent) => boolean>;
+    private _autocompleteDisabled;
+    private overlayAttached;
+    private overlayRef;
+    private portal;
+    private componentDestroyed;
+    private scrollStrategy;
+    /** Old value of the native input. Used to work around issues with the `input` event on IE. */
+    private previousValue;
+    /** Strategy that is used to position the panel. */
+    private positionStrategy;
+    /** The subscription for closing actions (some are bound to document). */
+    private closingActionsSubscription;
+    /** Subscription to viewport size changes. */
+    private viewportSubscription;
+    /**
+     * Whether the autocomplete can open the next time it is focused. Used to prevent a focused,
+     * closed autocomplete from being reopened if the user switches to another browser tab and then
+     * comes back.
+     */
+    private canOpenOnNextFocus;
+    /** Stream of keyboard events that can close the panel. */
+    private readonly closeKeyEventStream;
+    private readonly window;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** `View -> model callback called when value changes` */
+    onChange: (value: any) => void;
+    /** `View -> model callback called when autocomplete has been touched` */
+    onTouched: () => void;
+    /** Opens the autocomplete suggestion panel. */
+    open(): void;
+    closePanel(): void;
+    /**
+     * Updates the position of the autocomplete suggestion panel to ensure that it fits all options
+     * within the viewport.
+     */
+    updatePosition(): void;
+    /**
+     * A stream of actions that should close the autocomplete panel, including
+     * when an option is selected, on blur, and when TAB is pressed.
+     */
+    get panelClosingActions(): Observable<KbqOptionSelectionChange | null>;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => {}): void;
+    registerOnTouched(fn: () => {}): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleKeydown(event: KeyboardEvent): void;
+    handleInput(event: KeyboardEvent): void;
+    handleFocus(): void;
+    handleClick($event: MouseEvent): void;
+    scrollActiveOptionIntoView(): void;
+    /** Stream of clicks outside of the autocomplete panel. */
+    private getOutsideClickStream;
+    /**
+     * Event handler for when the window is blurred. Needs to be an
+     * arrow function in order to preserve the context.
+     */
+    private windowBlurHandler;
+    /**
+     * This method listens to a stream of panel closing actions and resets the
+     * stream every time the option list changes.
+     */
+    private subscribeToClosingActions;
+    /** Destroys the autocomplete suggestion panel. */
+    private destroyPanel;
+    private setTriggerValue;
+    /** This method closes the panel, and if a value is specified, also sets the associated
+     * control to that value. It will also mark the control as dirty if this interaction
+     * stemmed from the user.
+     */
+    private setValueAndClose;
+    /** Clear any previous selected option and emit a selection change event for this option */
+    private clearPreviousSelectedOption;
+    private attachOverlay;
+    private getOverlayConfig;
+    private getOverlayPosition;
+    private getConnectedElement;
+    private getPanelMinWidth;
+    private getOverlaySize;
+    private getHostWidth;
+    /**
+     * Resets the active item to -1 so arrow events will activate the
+     * correct options, or to 0 if the consumer opted into it.
+     */
+    private resetActiveItem;
+    private canOpen;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAutocompleteTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqAutocompleteTrigger, "input[kbqAutocomplete], textarea[kbqAutocomplete]", ["kbqAutocompleteTrigger"], { "autocomplete": { "alias": "kbqAutocomplete"; "required": false; "isSignal": true; }; "connectedTo": { "alias": "kbqAutocompleteConnectedTo"; "required": false; "isSignal": true; }; "autocompleteAttribute": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "autocompleteDisabled": { "alias": "kbqAutocompleteDisabled"; "required": false; }; "onInputBlur": { "alias": "kbqAutocompleteOnBlur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqAutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqAutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqAutocompleteModule, never, [typeof i1.KbqOptionModule, typeof i2.OverlayModule, typeof KbqAutocomplete, typeof KbqAutocompleteTrigger, typeof KbqAutocompleteOrigin, typeof KbqAutocompleteFooter], [typeof KbqAutocomplete, typeof i1.KbqOptionModule, typeof KbqAutocompleteTrigger, typeof KbqAutocompleteOrigin, typeof KbqAutocompleteFooter]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqAutocompleteModule>;
+}
+
+export { AUTOCOMPLETE_PANEL_HEIGHT, KBQ_AUTOCOMPLETE_DEFAULT_OPTIONS, KBQ_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY, KBQ_AUTOCOMPLETE_SCROLL_STRATEGY, KBQ_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY, KBQ_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER, KBQ_AUTOCOMPLETE_VALUE_ACCESSOR, KbqAutocomplete, KbqAutocompleteFooter, KbqAutocompleteModule, KbqAutocompleteOrigin, KbqAutocompleteSelectedEvent, KbqAutocompleteTrigger, getKbqAutocompleteMissingPanelError };
+export type { KbqAutocompleteDefaultOptions };

package/badge/index.d.ts

@@ -1 +1,57 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterContentInit } from '@angular/core';
+import { KbqIconItem } from '@koobiq/components/icon';
+import * as i1 from '@angular/cdk/a11y';
+import * as i2 from '@angular/cdk/platform';
+
+declare enum KbqBadgeColors {
+    FadeContrast = "fade-contrast",
+    FadeTheme = "fade-theme",
+    FadeSuccess = "fade-success",
+    FadeWarning = "fade-warning",
+    FadeError = "fade-error",
+    Contrast = "contrast",
+    Theme = "theme",
+    Success = "success",
+    Warning = "warning",
+    Error = "error",
+    Disabled = "disabled"
+}
+declare class KbqBadgeCaption {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqBadgeCaption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqBadgeCaption, "[kbq-badge-caption]", never, {}, {}, never, never, true, never>;
+}
+declare const leftIconClassName = "kbq-icon_left";
+declare const rightIconClassName = "kbq-icon_right";
+declare const badgeLeftIconClassName = "kbq-badge-icon_left";
+declare const badgeRightIconClassName = "kbq-badge-icon_right";
+declare class KbqBadgeCssStyler implements AfterContentInit {
+    private renderer;
+    private cdr;
+    readonly icons: i0.Signal<readonly any[]>;
+    nativeElement: HTMLElement;
+    isIconButton: boolean;
+    constructor();
+    ngAfterContentInit(): void;
+    updateClassModifierForIcons(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqBadgeCssStyler, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqBadgeCssStyler, "kbq-badge", never, {}, {}, ["icons"], never, true, never>;
+}
+declare class KbqBadge {
+    readonly iconItem: i0.Signal<KbqIconItem | undefined>;
+    readonly compact: i0.InputSignal<boolean>;
+    readonly outline: i0.InputSignal<boolean>;
+    get badgeColor(): string;
+    set badgeColor(value: string | KbqBadgeColors);
+    private _badgeColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqBadge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqBadge, "kbq-badge", never, { "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "badgeColor": { "alias": "badgeColor"; "required": false; }; }, {}, ["iconItem"], ["*"], true, never>;
+}
+
+declare class KbqBadgeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqBadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqBadgeModule, never, [typeof i1.A11yModule, typeof i2.PlatformModule, typeof KbqBadge, typeof KbqBadgeCaption, typeof KbqBadgeCssStyler], [typeof KbqBadge, typeof KbqBadgeCaption, typeof KbqBadgeCssStyler]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqBadgeModule>;
+}
+
+export { KbqBadge, KbqBadgeCaption, KbqBadgeColors, KbqBadgeCssStyler, KbqBadgeModule, badgeLeftIconClassName, badgeRightIconClassName, leftIconClassName, rightIconClassName };

package/breadcrumbs/breadcrumbs.scss

@@ -73,6 +73,10 @@
             --kbq-button-size-border-radius: var(--kbq-breadcrumb-item-border-radius);
         }
 
+        &.kbq-dropdown-trigger {
+            --kbq-dropdown-trigger-horizontal-padding: var(--kbq-breadcrumb-item-horizontal-padding);
+        }
+
         &:focus-visible {
             outline-offset: unset;
         }