@koobiq/components 19.8.1 → 20.0.0

package/divider/index.d.ts

@@ -1 +1,20 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+declare class KbqDivider {
+    get vertical(): boolean;
+    set vertical(value: boolean);
+    private _vertical;
+    get paddings(): boolean;
+    set paddings(value: boolean);
+    private _paddings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDivider, "kbq-divider", never, { "vertical": { "alias": "vertical"; "required": false; }; "paddings": { "alias": "paddings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqDividerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDividerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqDividerModule, never, [typeof KbqDivider], [typeof KbqDivider]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqDividerModule>;
+}
+
+export { KbqDivider, KbqDividerModule };

package/dl/index.d.ts

@@ -1 +1,37 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i1 from '@angular/cdk/a11y';
+import * as i2 from '@angular/cdk/platform';
+
+declare class KbqDlComponent implements AfterContentInit, OnDestroy {
+    readonly minWidth: i0.InputSignal<number>;
+    readonly wide: i0.InputSignal<boolean>;
+    vertical: boolean | null;
+    readonly resizeStream: Subject<Event>;
+    private readonly resizeDebounceInterval;
+    private resizeSubscription;
+    private readonly elementRef;
+    private readonly changeDetectorRef;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private readonly updateState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDlComponent, "kbq-dl", never, { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "wide": { "alias": "wide"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+declare class KbqDtComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDtComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDtComponent, "kbq-dt", never, {}, {}, never, ["*"], true, never>;
+}
+declare class KbqDdComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDdComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDdComponent, "kbq-dd", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class KbqDlModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDlModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqDlModule, never, [typeof i1.A11yModule, typeof i2.PlatformModule, typeof KbqDlComponent, typeof KbqDtComponent, typeof KbqDdComponent], [typeof KbqDlComponent, typeof KbqDtComponent, typeof KbqDdComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqDlModule>;
+}
+
+export { KbqDdComponent, KbqDlComponent, KbqDlModule, KbqDtComponent };

package/dropdown/_dropdown-theme.scss

@@ -23,18 +23,14 @@
         }
 
         &.kbq-dropdown-item_highlighted,
-        &:hover:not(.kbq-disabled) {
+        &.cdk-focused:not(.kbq-disabled) {
             @include _kbq-dropdown-item-state(states-hover);
         }
 
-        &.cdk-keyboard-focused {
-            border-color: var(--kbq-list-states-focused-focus-outline-color);
-        }
-
         &.kbq-selected {
             @include _kbq-dropdown-item-state(states-selected);
 
-            &:hover:not(.kbq-disabled) {
+            &.cdk-focused:not(.kbq-disabled) {
                 @include _kbq-dropdown-item-state(states-selected-hover);
             }
         }
@@ -43,12 +39,12 @@
             @include _kbq-dropdown-item-state(states-disabled);
         }
 
-        &:is(.kbq-selected, .cdk-keyboard-focused):has(+ :is(.kbq-selected, .cdk-keyboard-focused)) {
+        &:is(.kbq-selected, .cdk-focused):has(+ :is(.kbq-selected, .cdk-focused)) {
             border-bottom-left-radius: 0;
             border-bottom-right-radius: 0;
         }
 
-        &:is(.kbq-selected, .cdk-keyboard-focused) + :is(.kbq-selected, .cdk-keyboard-focused) {
+        &:is(.kbq-selected, .cdk-focused) + :is(.kbq-selected, .cdk-focused) {
             border-top-left-radius: 0;
             border-top-right-radius: 0;
         }

package/dropdown/dropdown.scss

@@ -32,6 +32,10 @@
 }
 
 .kbq-dropdown__panel {
+    // The panel receives programmatic focus when the dropdown is opened by mouse or touch,
+    // so the focus outline should never be rendered on it.
+    outline: none;
+
     overflow-x: hidden;
     overflow-y: auto;
 

package/dropdown/index.d.ts

@@ -1 +1,473 @@
-export * from './public-api';
+import { AnimationTriggerMetadata, AnimationEvent } from '@angular/animations';
+import * as i0 from '@angular/core';
+import { OnDestroy, TemplateRef, EventEmitter, QueryList, InjectionToken, AfterViewInit, ElementRef, AfterContentInit, OnInit } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { KbqTitleTextRef, IFocusableOption, KbqComponentColors } from '@koobiq/components/core';
+import * as i2 from '@koobiq/components/icon';
+import { KbqIcon } from '@koobiq/components/icon';
+import { Direction } from '@angular/cdk/bidi';
+import * as i1 from '@angular/cdk/overlay';
+import { ScrollStrategy, Overlay } from '@angular/cdk/overlay';
+
+/**
+ * Animations used by the kbq-dropdown component.
+ * @docs-private
+ */
+declare const kbqDropdownAnimations: {
+    readonly transformDropdown: AnimationTriggerMetadata;
+    readonly fadeInItems: AnimationTriggerMetadata;
+};
+declare const fadeInItems: AnimationTriggerMetadata;
+declare const transformDropdown: AnimationTriggerMetadata;
+
+/**
+ * Dropdown content that will be rendered lazily once the dropdown is opened.
+ */
+declare class KbqDropdownContent implements OnDestroy {
+    private template;
+    private appRef;
+    private injector;
+    private viewContainerRef;
+    protected readonly document: Document;
+    /** Emits when the dropdown content has been attached. */
+    attached: Subject<void>;
+    private portal;
+    private outlet;
+    /**
+     * Attaches the content with a particular context.
+     * @docs-private
+     */
+    attach(context?: any): void;
+    /**
+     * Detaches the content.
+     * @docs-private
+     */
+    detach(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownContent, "ng-template[kbqDropdownContent]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Throws an exception for the case when dropdown trigger doesn't have a valid kbq-dropdown instance
+ * @docs-private
+ */
+declare function throwKbqDropdownMissingError(): void;
+/**
+ * Throws an exception for the case when dropdown's x-position value isn't valid.
+ * In other words, it doesn't match 'before' or 'after'.
+ * @docs-private
+ */
+declare function throwKbqDropdownInvalidPositionX(): void;
+/**
+ * Throws an exception for the case when dropdown's y-position value isn't valid.
+ * In other words, it doesn't match 'above' or 'below'.
+ * @docs-private
+ */
+declare function throwKbqDropdownInvalidPositionY(): void;
+
+/** Position of the dropdown panel along the x-axis. */
+type KbqDropdownPositionX = 'before' | 'after' | 'center';
+/**
+ * @deprecated Use `KbqDropdownPositionX` instead.
+ * @docs-private
+ */
+type DropdownPositionX = KbqDropdownPositionX;
+/** Position of the dropdown panel along the y-axis. */
+type KbqDropdownPositionY = 'above' | 'below';
+/**
+ * @deprecated Use `KbqDropdownPositionY` instead.
+ * @docs-private
+ */
+type DropdownPositionY = KbqDropdownPositionY;
+/** Reason why the menu was closed. */
+type DropdownCloseReason = void | 'click' | 'keydown' | 'tab';
+/**
+ * Interface for a custom dropdown panel that can be used with `kbqDropdownTriggerFor`.
+ * @docs-private
+ */
+interface KbqDropdownPanel {
+    xPosition: KbqDropdownPositionX;
+    yPosition: KbqDropdownPositionY;
+    overlapTriggerX: boolean;
+    overlapTriggerY: boolean;
+    templateRef: TemplateRef<any>;
+    closed: EventEmitter<DropdownCloseReason>;
+    parent?: KbqDropdownPanel | undefined;
+    triggerWidth?: string;
+    direction?: Direction;
+    lazyContent?: KbqDropdownContent;
+    backdropClass?: string;
+    hasBackdrop?: boolean;
+    items: QueryList<KbqDropdownItem>;
+    focusFirstItem(origin?: FocusOrigin): void;
+    resetActiveItem(): void;
+    setPositionClasses?(x: KbqDropdownPositionX, y: KbqDropdownPositionY): void;
+}
+/** Default `kbq-dropdown` options that can be overridden. */
+interface KbqDropdownDefaultOptions {
+    /** The x-axis position of the dropdown. */
+    xPosition: KbqDropdownPositionX;
+    /** The y-axis position of the dropdown. */
+    yPosition: KbqDropdownPositionY;
+    /** Whether the dropdown should overlap the dropdown trigger horizontally. */
+    overlapTriggerX: boolean;
+    /** Whether the dropdown should overlap the dropdown trigger vertically. */
+    overlapTriggerY: boolean;
+    /** Class to be applied to the dropdown's backdrop. */
+    backdropClass: string;
+    /** Whether the dropdown has a backdrop. */
+    hasBackdrop: boolean;
+}
+/**
+ * Injection token used to provide the parent dropdown to dropdown-specific components.
+ * @docs-private
+ */
+declare const KBQ_DROPDOWN_PANEL: InjectionToken<KbqDropdownPanel>;
+/** Injection token to be used to override the default options for `kbq-dropdown`. */
+declare const KBQ_DROPDOWN_DEFAULT_OPTIONS: InjectionToken<KbqDropdownDefaultOptions>;
+/** @docs-private */
+declare function KBQ_DROPDOWN_DEFAULT_OPTIONS_FACTORY(): KbqDropdownDefaultOptions;
+
+/**
+ * This directive is intended to be used inside an kbq-dropdown tag.
+ * It exists mostly to set the role attribute.
+ */
+declare class KbqDropdownItem implements KbqTitleTextRef, IFocusableOption, AfterViewInit, OnDestroy {
+    private elementRef;
+    private focusMonitor;
+    parentDropdownPanel?: KbqDropdownPanel | null | undefined;
+    textElement: ElementRef;
+    icon: KbqIcon;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Stream that emits when the dropdown item is hovered. */
+    readonly hovered: Subject<KbqDropdownItem>;
+    /** Stream that emits when the menu item is focused. */
+    readonly focused: Subject<KbqDropdownItem>;
+    /** Whether the dropdown item is highlighted. */
+    highlighted: boolean;
+    /** Whether the dropdown item acts as a trigger for a nested dropdown. */
+    isNested: boolean;
+    /** @docs-private */
+    protected readonly componentColors: typeof KbqComponentColors;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    resetStyles(): void;
+    /** Focuses the dropdown item. */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Returns the host DOM element. */
+    getHostElement(): HTMLElement;
+    /** Used to set the `tabindex`. */
+    getTabIndex(): string;
+    /** Prevents the default element actions if it is disabled. Bound via `host` metadata. */
+    checkDisabled(event: Event): void;
+    /** Emits to the hover stream. Bound via `host` metadata. */
+    handleMouseEnter(): void;
+    /** Gets the label to be used when determining whether the option should be focused. */
+    getLabel(): string;
+    haltDisabledEvents(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDropdownItem, "kbq-dropdown-item, [kbq-dropdown-item]", ["kbqDropdownItem"], { "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["icon"], ["[kbq-icon]", "*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Injection token that determines the scroll handling while the dropdown is open. */
+declare const KBQ_DROPDOWN_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+declare const KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY;
+};
+/**
+ * Marker provided by host components that create their own stacking context at
+ * the default overlay z-index (e.g. `KbqTopBar`, `KbqNavbar` use
+ * `position: sticky` + `z-index: $overlay-z-index`). When this token is
+ * available in the injector tree, `KbqDropdownTrigger` defaults `demoteOverlay`
+ * to `false` so the dropdown overlay is not lowered below the host.
+ *
+ * An explicit `[demoteOverlay]` binding on the trigger still wins.
+ */
+declare const KBQ_DROPDOWN_HOST: InjectionToken<unknown>;
+/** Default top padding of the nested dropdown panel. */
+declare const NESTED_PANEL_TOP_PADDING = 4;
+declare const NESTED_PANEL_LEFT_PADDING = 8;
+/**
+ * This directive is intended to be used in conjunction with an kbq-dropdown tag.  It is
+ * responsible for toggling the display of the provided dropdown instance.
+ */
+declare class KbqDropdownTrigger implements AfterContentInit, OnDestroy {
+    private overlay;
+    private elementRef;
+    private viewContainerRef;
+    private scrollStrategy;
+    private parent;
+    private dropdownItemInstance;
+    private _dir;
+    private changeDetectorRef;
+    private focusMonitor;
+    private readonly overlayContainer;
+    private readonly renderer;
+    protected readonly isBrowser: boolean;
+    private readonly window;
+    private readonly host;
+    lastDestroyReason: DropdownCloseReason;
+    /** Position offset of the dropdown in the X axis. */
+    offsetX: number;
+    /** Position offset of the dropdown in the Y axis. */
+    offsetY: number;
+    /** Data to be passed along to any lazily-rendered content. */
+    data: any;
+    openByArrowDown: boolean;
+    /**
+     * Whether to demote the overlay container z-index so that dropdown overlays
+     * sit below sibling overlays (tooltips, modals, etc.). Set to `false` to
+     * keep the dropdown overlay at the default overlay container z-index.
+     */
+    demoteOverlay: boolean;
+    /**
+     * Whether focus should be restored when the menu is closed.
+     * Note that disabling this option can have accessibility implications
+     * and it's up to you to manage focus, if you decide to turn it off.
+     */
+    restoreFocus: boolean;
+    /** References the dropdown instance that the trigger is associated with. */
+    get dropdown(): KbqDropdownPanel;
+    set dropdown(dropdown: KbqDropdownPanel);
+    private _dropdown;
+    /** Event emitted when the associated dropdown is opened. */
+    readonly dropdownOpened: i0.OutputEmitterRef<void>;
+    /**
+     * Event emitted when the associated dropdown is closed. Kept as an `@Output()` EventEmitter
+     * (not `output()`): `KbqOptionActionComponent` subscribes to it via `.pipe()` through the
+     * KBQ_OPTION_ACTION_PARENT contract, which an `OutputEmitterRef` does not support — see #DS-5079.
+     */
+    readonly dropdownClosed: EventEmitter<void>;
+    openedBy: Exclude<FocusOrigin, 'program' | null> | undefined;
+    /** The text direction of the containing app. */
+    get dir(): Direction;
+    /** Whether the dropdown is open. */
+    get opened(): boolean;
+    private _opened;
+    private portal;
+    private overlayRef;
+    private closeSubscription;
+    private hoverSubscription;
+    private classAddedToOverlayContainer;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Whether the dropdown triggers a nested dropdown or a top-level one. */
+    isNested(): boolean;
+    /** Toggles the dropdown between the open and closed states. */
+    toggle(): void;
+    /** Opens the dropdown. */
+    open(): void;
+    /** Closes the dropdown. */
+    close(): void;
+    /**
+     * Focuses the dropdown trigger.
+     */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Handles mouse presses on the trigger. */
+    handleMousedown(event: MouseEvent): void;
+    /** Handles key presses on the trigger. */
+    handleKeydown(event: KeyboardEvent): void;
+    /** Handles click events on the trigger. */
+    handleClick(event: MouseEvent): void;
+    /**
+     * Handles touch start events on the trigger.
+     * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.
+     */
+    private handleTouchStart;
+    /** Closes the dropdown and does the necessary cleanup. */
+    private destroy;
+    /**
+     * This method sets the dropdown state to open and focuses the first item if
+     * the dropdown was opened via the keyboard.
+     */
+    private init;
+    private setIsOpened;
+    /**
+     * This method checks that a valid instance of KbqDropdown has been passed into
+     * kbqDropdownTriggerFor. If not, an exception is thrown.
+     */
+    private check;
+    /**
+     * This method creates the overlay from the provided dropdown's template and saves its
+     * OverlayRef so that it can be attached to the DOM when open is called.
+     */
+    private createOverlay;
+    /**
+     * This method builds the configuration object needed to create the overlay, the OverlayState.
+     * @returns OverlayConfig
+     */
+    private getOverlayConfig;
+    /**
+     * Listens to changes in the position of the overlay and sets the correct classes
+     * on the dropdown based on the new position. This ensures the animation origin is always
+     * correct, even if a fallback position is used for the overlay.
+     */
+    private subscribeToPositions;
+    /**
+     * Sets the appropriate positions on a position strategy
+     * so the overlay connects with the trigger correctly.
+     * @param positionStrategy Strategy whose position to update.
+     */
+    private setPosition;
+    /** Cleans up the active subscriptions. */
+    private cleanUpSubscriptions;
+    /** Returns a stream that emits whenever an action that should close the dropdown occurs. */
+    private closingActions;
+    /** Handles the cases where the user hovers over the trigger. */
+    private handleHover;
+    /** Gets the portal that should be attached to the overlay. */
+    private getPortal;
+    private getWidth;
+    private addClassToOverlayContainer;
+    private removeClassFromOverlayContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownTrigger, "[kbqDropdownTriggerFor]", ["kbqDropdownTrigger"], { "offsetX": { "alias": "offsetX"; "required": false; }; "offsetY": { "alias": "offsetY"; "required": false; }; "data": { "alias": "kbqDropdownTriggerData"; "required": false; }; "openByArrowDown": { "alias": "openByArrowDown"; "required": false; }; "demoteOverlay": { "alias": "demoteOverlay"; "required": false; }; "restoreFocus": { "alias": "kbqDropdownTriggerRestoreFocus"; "required": false; }; "dropdown": { "alias": "kbqDropdownTriggerFor"; "required": false; }; }, { "dropdownOpened": "dropdownOpened"; "dropdownClosed": "dropdownClosed"; }, never, never, true, never>;
+    static ngAcceptInputType_offsetX: unknown;
+    static ngAcceptInputType_offsetY: unknown;
+    static ngAcceptInputType_demoteOverlay: unknown;
+}
+
+declare class KbqDropdownStaticContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownStaticContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownStaticContent, "[kbqDropdownStaticContent]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnInit, OnDestroy {
+    private elementRef;
+    private ngZone;
+    private defaultOptions;
+    private readonly search;
+    readonly navigationWithWrap: i0.InputSignal<boolean>;
+    /** Position of the dropdown in the X axis. */
+    get xPosition(): KbqDropdownPositionX;
+    set xPosition(value: KbqDropdownPositionX);
+    /** Position of the dropdown in the Y axis. */
+    get yPosition(): KbqDropdownPositionY;
+    set yPosition(value: KbqDropdownPositionY);
+    /** Whether the dropdown should overlap its trigger vertically. */
+    get overlapTriggerY(): boolean;
+    set overlapTriggerY(value: boolean);
+    /** Whether the dropdown should overlap its trigger horizontally. */
+    get overlapTriggerX(): boolean;
+    set overlapTriggerX(value: boolean);
+    /** Whether the dropdown has a backdrop. */
+    get hasBackdrop(): boolean;
+    set hasBackdrop(value: boolean);
+    /**
+     * This method takes classes set on the host kbq-dropdown element and applies them on the
+     * dropdown template that displays in the overlay container.  Otherwise, it's difficult
+     * to style the containing dropdown from outside the component.
+     * @param classes list of class names
+     */
+    set panelClass(classes: string);
+    private _xPosition;
+    private _yPosition;
+    private _overlapTriggerX;
+    private _overlapTriggerY;
+    private _hasBackdrop;
+    triggerWidth: string;
+    /** Config object to be passed into the dropdown panel's `[class]` binding */
+    classList: {
+        [key: string]: boolean;
+    };
+    /** Current state of the panel animation. */
+    panelAnimationState: 'void' | 'enter';
+    /** Emits whenever an animation on the dropdown completes. */
+    animationDone: Subject<AnimationEvent>;
+    /** Whether the dropdown is animating. */
+    isAnimating: boolean;
+    /** Parent dropdown of the current dropdown panel. */
+    parent: KbqDropdownPanel | undefined;
+    /** Layout direction of the dropdown. */
+    direction: Direction;
+    /** Class to be added to the backdrop element. */
+    backdropClass: string;
+    /** @docs-private */
+    templateRef: TemplateRef<any>;
+    /**
+     * List of the items inside of a dropdown.
+     */
+    items: QueryList<KbqDropdownItem>;
+    /**
+     * Dropdown content that will be rendered lazily.
+     * @docs-private
+     */
+    lazyContent: KbqDropdownContent;
+    /** Event emitted when the dropdown is closed. */
+    readonly closed: EventEmitter<void | "click" | "keydown" | "tab">;
+    private previousPanelClass;
+    private keyManager;
+    /** Only the direct descendant menu items. */
+    private directDescendantItems;
+    /** Subscription to tab events on the dropdown panel */
+    private tabSubscription;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Stream that emits whenever the hovered dropdown item changes. */
+    hovered(): Observable<KbqDropdownItem>;
+    /** Handle a keyboard event from the dropdown, delegating to the appropriate action. */
+    handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Focus the first item in the dropdown.
+     * @param origin Action from which the focus originated. Used to set the correct styling.
+     */
+    focusFirstItem(origin?: FocusOrigin): void;
+    /**
+     * Applies focus when the dropdown is opened. When opened by mouse or touch, the first item
+     * should not be highlighted, so the panel itself is focused instead — keyboard events still
+     * reach the panel and the first arrow key press will highlight the first item.
+     */
+    private applyInitialFocus;
+    /** Moves DOM focus onto the dropdown panel so that keydown events keep being handled. */
+    private focusPanel;
+    /**
+     * Resets the active item in the dropdown. This is used when the dropdown is opened, allowing
+     * the user to start from the first option when pressing the down arrow.
+     */
+    resetActiveItem(): void;
+    /**
+     * Adds classes to the dropdown panel based on its position. Can be used by
+     * consumers to add specific styling based on the position.
+     * @param posX Position of the dropdown along the x axis.
+     * @param posY Position of the dropdown along the y axis.
+     * @docs-private
+     */
+    setPositionClasses(posX?: KbqDropdownPositionX, posY?: KbqDropdownPositionY): void;
+    /** Starts the enter animation. */
+    startAnimation(): void;
+    /** Resets the panel animation to its initial state. */
+    resetAnimation(): void;
+    /** Callback that is invoked when the panel animation completes. */
+    onAnimationDone(event: AnimationEvent): void;
+    onAnimationStart(event: AnimationEvent): void;
+    close(): void;
+    /**
+     * Sets up a stream that will keep track of any newly-added menu items and will update the list
+     * of direct descendants. We collect the descendants this way, because `items` can include
+     * items that are part of child menus, and using a custom way of registering items is unreliable
+     * when it comes to maintaining the item order.
+     */
+    private updateDirectDescendants;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdown, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDropdown, "kbq-dropdown", ["kbqDropdown"], { "navigationWithWrap": { "alias": "navigationWithWrap"; "required": false; "isSignal": true; }; "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "overlapTriggerY": { "alias": "overlapTriggerY"; "required": false; }; "overlapTriggerX": { "alias": "overlapTriggerX"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "panelClass": { "alias": "class"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; }, { "closed": "closed"; }, ["search", "lazyContent", "items"], ["*", "[kbqDropdownStaticContent]"], true, never>;
+}
+
+declare class KbqDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqDropdownModule, never, [typeof i1.OverlayModule, typeof i2.KbqIconModule, typeof KbqDropdownStaticContent, typeof KbqDropdown, typeof KbqDropdownItem, typeof KbqDropdownTrigger, typeof KbqDropdownContent], [typeof KbqDropdown, typeof KbqDropdownItem, typeof KbqDropdownTrigger, typeof KbqDropdownContent, typeof KbqDropdownStaticContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqDropdownModule>;
+}
+
+export { KBQ_DROPDOWN_DEFAULT_OPTIONS, KBQ_DROPDOWN_DEFAULT_OPTIONS_FACTORY, KBQ_DROPDOWN_HOST, KBQ_DROPDOWN_PANEL, KBQ_DROPDOWN_SCROLL_STRATEGY, KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY, KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY_PROVIDER, KbqDropdown, KbqDropdownContent, KbqDropdownItem, KbqDropdownModule, KbqDropdownStaticContent, KbqDropdownTrigger, NESTED_PANEL_LEFT_PADDING, NESTED_PANEL_TOP_PADDING, fadeInItems, kbqDropdownAnimations, throwKbqDropdownInvalidPositionX, throwKbqDropdownInvalidPositionY, throwKbqDropdownMissingError, transformDropdown };
+export type { DropdownCloseReason, DropdownPositionX, DropdownPositionY, KbqDropdownDefaultOptions, KbqDropdownPanel, KbqDropdownPositionX, KbqDropdownPositionY };

package/dynamic-translation/index.d.ts

@@ -1,2 +1,81 @@
-export * from './dynamic-translation';
-export * from './module';
+import * as i0 from '@angular/core';
+import { TemplateRef, Signal } from '@angular/core';
+
+/**
+ * @docs-private
+ */
+type KbqDynamicTranslationParsedSlot = {
+    type: 'text' | 'slot';
+    template: TemplateRef<unknown> | null;
+    context?: {
+        $implicit: unknown;
+    };
+    text?: string;
+};
+/**
+ * @docs-private
+ */
+interface KbqDynamicTranslationHelperSlot {
+    name: string;
+    tag: string;
+    attributes?: {
+        key: string;
+        value: string;
+    }[];
+    content?: string;
+}
+/**
+ * Directive for defining a dynamic translation slot.
+ */
+declare class KbqDynamicTranslationSlot {
+    /**
+     * The name of the dynamic translation slot.
+     */
+    readonly name: i0.InputSignal<string>;
+    /**
+     * @docs-private
+     */
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDynamicTranslationSlot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDynamicTranslationSlot, "[kbqDynamicTranslationSlot]", never, { "name": { "alias": "kbqDynamicTranslationSlot"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Component for dynamic translation.
+ */
+declare class KbqDynamicTranslation {
+    private readonly slots;
+    /**
+     * The text which will be translated.
+     */
+    readonly text: i0.InputSignal<string>;
+    /**
+     * @docs-private
+     */
+    protected readonly parsedSlots: Signal<KbqDynamicTranslationParsedSlot[]>;
+    private parseSlots;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDynamicTranslation, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDynamicTranslation, "kbq-dynamic-translation", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; }, {}, ["slots"], never, true, never>;
+}
+/**
+ * @docs-private
+ */
+declare class KbqDynamicTranslationHelper {
+    private readonly renderer;
+    private readonly replaceableSlotContainers;
+    private readonly slotsByName;
+    readonly text: i0.InputSignal<string>;
+    readonly slots: i0.InputSignal<KbqDynamicTranslationHelperSlot[]>;
+    constructor();
+    private replaceSlots;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDynamicTranslationHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDynamicTranslationHelper, "kbq-dynamic-translation-with-dynamic-component-creation", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "slots": { "alias": "slots"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqDynamicTranslationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDynamicTranslationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqDynamicTranslationModule, never, [typeof KbqDynamicTranslationSlot, typeof KbqDynamicTranslationHelper, typeof KbqDynamicTranslation], [typeof KbqDynamicTranslationSlot, typeof KbqDynamicTranslationHelper, typeof KbqDynamicTranslation]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqDynamicTranslationModule>;
+}
+
+export { KbqDynamicTranslation, KbqDynamicTranslationHelper, KbqDynamicTranslationModule, KbqDynamicTranslationSlot };
+export type { KbqDynamicTranslationHelperSlot };