@koobiq/components 20.0.0 → 20.2.0

package/title/index.d.ts

@@ -1,35 +1,125 @@
 import * as i0 from '@angular/core';
-import { AfterViewInit, OnDestroy } from '@angular/core';
+import { AfterViewInit, OnDestroy, TemplateRef } from '@angular/core';
 import * as i1 from '@koobiq/components/tooltip';
 import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
 import { Subject } from 'rxjs';
 
+/**
+ * Shows a tooltip with the full text of the host element, but only when that text is truncated —
+ * i.e. it overflows horizontally, or vertically when clamped to several lines. The tooltip opens on
+ * hover and on keyboard focus, and hides on blur, mouse leave, or window resize.
+ *
+ * By default, the tooltip content is the trimmed `textContent` of the host. Provide explicit content
+ * with `[kbq-title]="stringOrTemplateRef"`. For nested markup, mark the measured container with the
+ * `#kbqTitleContainer` template reference and the text element(s) with `#kbqTitleText`; several
+ * `#kbqTitleText` elements are supported and the tooltip is shown when any of them overflows.
+ *
+ * Host components that provide `KBQ_TITLE_TEXT_REF` (e.g. `KbqOption`) supply the text and parent
+ * elements automatically, so the directive works without explicit template references.
+ */
 declare class KbqTitleDirective extends KbqTooltipTrigger implements AfterViewInit, OnDestroy {
+    /** Optional host component that exposes the measured text/parent elements via `KBQ_TITLE_TEXT_REF`. */
     private componentInstance;
+    /** Host native element the directive is attached to. */
     private readonly nativeElement;
+    /** SSR-safe window reference used for `getComputedStyle` reads. */
+    private readonly window;
+    /** Observes host content mutations to re-evaluate overflow and refresh the resolved tooltip content. */
     private contentObserver;
+    /**
+     * Optional explicit tooltip content. Accepts a `TemplateRef` (rendered as rich tooltip content) or a string.
+     * When omitted (a bare `kbq-title` attribute resolves to an empty string), the directive falls back to the
+     * trimmed `textContent` of the host (`viewValue`), preserving the default behavior.
+     */
+    readonly titleContent: i0.InputSignal<string | TemplateRef<any>>;
     set trigger(value: string);
+    /**
+     * The pop-up trigger. Always reports `PopUpTriggers.Hover`, so the title tooltip reacts to hover and
+     * keyboard focus regardless of the assigned value. The setter is kept only as a no-op workaround so a
+     * host that also uses a popover can assign a trigger without breaking `kbq-title`.
+     */
     get trigger(): string;
+    /**
+     * Whether the host content is clipped and therefore needs a tooltip. Returns `true` if any measured
+     * text element overflows the parent — covering multiple `#kbqTitleText` elements, the sub-pixel
+     * special case, and both horizontal and vertical overflow.
+     */
     get isOverflown(): boolean;
+    /** Whether the text is clipped horizontally: the parent `offsetWidth` is smaller than the child `scrollWidth`. */
     get isHorizontalOverflown(): boolean;
+    /** Whether the text is clipped vertically: the parent `offsetHeight` is smaller than the child `scrollHeight`. */
     get isVerticalOverflown(): boolean;
+    /**
+     * Compares measured widths, treating only *visible* clipping as overflow. With `text-overflow: ellipsis`
+     * any positive difference counts (even a sub-pixel overflow shows `…`). With `text-overflow: clip` the
+     * widths are rounded to whole CSS pixels first — mirroring the integer `offsetWidth`/`scrollWidth` path —
+     * so an imperceptible sub-pixel clip is not treated as truncation.
+     * @docs-private */
+    private isWidthOverflown;
+    /** Trimmed `textContent` of the measured parent, used as the default tooltip content. */
     get viewValue(): string;
+    /**
+     * Measured container element. Resolved as the projected `#kbqTitleContainer`, otherwise the
+     * `KBQ_TITLE_TEXT_REF` host's `parentTextElement`, otherwise the host element itself.
+     * @docs-private */
     get parent(): HTMLElement;
+    /** First effective text element used for overflow detection (the first entry of `childElements`).
+     * @docs-private */
     get child(): HTMLElement;
+    /** Whether the host element contains exactly one child node and that node is a text node. */
     get hasOnlyText(): boolean;
+    /**
+     * Whether the measured text truncates with an ellipsis on either the child text element or its
+     * wrapping container. Only then is a sub-pixel overflow actually visible (the trailing glyph is
+     * replaced by `…`); with the default `text-overflow: clip` a sub-pixel clip is imperceptible, so
+     * it must not be reported as truncation. Both elements are checked because `text-overflow` is not
+     * inherited and consumers place it differently: `KbqOption`/`KbqDropdownItem` style the measured
+     * `child`, whereas `KbqTreeOption` styles the `parent` container that wraps the child.
+     * @docs-private */
+    private get hasEllipsis();
+    /** Whether the element's computed `text-overflow` renders an ellipsis.
+     * @docs-private */
+    private elementHasEllipsis;
+    /**
+     * Effective text elements used for overflow detection. Resolves to the projected `#kbqTitleText` elements,
+     * otherwise falls back to the `KbqTitleTextRef` host's `textElement`, otherwise to the host element itself.
+     * Always contains at least one element.
+     * @docs-private */
+    private get childElements();
+    /** Resolved tooltip content: the explicit `titleContent` input when provided, otherwise the host text.
+     * @docs-private */
+    private get resolvedContent();
+    /** Emits `window:resize` events; subscribed to re-evaluate overflow after the viewport changes.
+     * @docs-private */
     readonly resizeStream: Subject<Event>;
+    /** Debounce/throttle interval (ms) applied to the resize and content-observer streams. */
     private readonly debounceInterval;
+    /** Subscription to `resizeStream`, torn down in `ngOnDestroy`. */
     private resizeSubscription;
+    /** Subscription to the content observer, torn down in `ngOnDestroy`. */
     private contentObserverSubscription;
+    /** Subscription to the focus monitor, torn down in `ngOnDestroy`. */
     private focusMonitorSubscription;
+    /** Projected text elements marked with the `#kbqTitleText` template reference. */
     private childContainer;
+    /** Projected container element marked with the `#kbqTitleContainer` template reference. */
     private parentContainer;
+    /**
+     * Sets the initial tooltip content and wires the streams that toggle the tooltip's `disabled` state:
+     * window resize and content mutations re-evaluate overflow, and keyboard focus opens the tooltip
+     * while other focus origins hide it.
+     */
     ngAfterViewInit(): void;
+    /** Unsubscribes from the resize, content-observer and focus-monitor streams and stops focus monitoring. */
     ngOnDestroy(): void;
+    /** Enables the tooltip only when the content is overflown. Bound to `mouseenter` and keyboard focus.
+     * @docs-private */
     handleElementEnter(): void;
+    /** Always disables (hides) the tooltip. Bound to `mouseleave` and non-keyboard focus changes.
+     * @docs-private */
     hideTooltip(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTitleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTitleDirective, "[kbq-title]", ["kbqTitle"], {}, {}, ["childContainer", "parentContainer"], never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTitleDirective, "[kbq-title]", ["kbqTitle"], { "titleContent": { "alias": "kbq-title"; "required": false; "isSignal": true; }; }, {}, ["parentContainer", "childContainer"], never, true, never>;
 }
 
 declare class KbqTitleModule {

package/tooltip/index.d.ts

@@ -1,10 +1,42 @@
-import * as rxjs from 'rxjs';
 import * as i0 from '@angular/core';
 import { InjectionToken, ElementRef, AfterViewInit, OnChanges, OnDestroy, Renderer2, WritableSignal, TemplateRef, EventEmitter, SimpleChanges, Type } from '@angular/core';
+import * as rxjs from 'rxjs';
 import { FocusMonitor } from '@angular/cdk/a11y';
 import { ScrollStrategy, Overlay, OverlayConfig } from '@angular/cdk/overlay';
 import { KbqPopUp, KbqPopUpTrigger, KbqParentPopup, KbqPopUpPlacementValues, KbqComponentColors } from '@koobiq/components/core';
 
+/**
+ * Default value of the `kbqTooltipSingleInstance` input. Provide `false` at the application level to
+ * globally disable the "only one tooltip is visible at a time" behavior.
+ */
+declare const KBQ_TOOLTIP_SINGLE_INSTANCE_DEFAULT: InjectionToken<boolean>;
+/**
+ * Contract of a tooltip taking part in the "only one tooltip is visible at a time" group.
+ * @docs-private
+ */
+interface KbqExclusiveTooltip {
+    /** Hides the tooltip because another one has taken its place. */
+    hideAsInactive(): void;
+}
+/**
+ * Keeps track of the single tooltip that is currently visible, so that showing a new one hides the
+ * previous. Holds the *trigger*, not the overlay component — the latter is re-created on every show.
+ */
+declare class KbqTooltipRegistry {
+    /** Tooltip that currently owns the screen, or `null` when nothing is visible. */
+    private visibleTooltip;
+    /** Marks the tooltip as the only visible one, hiding the previously visible tooltip. */
+    setVisible(tooltip: KbqExclusiveTooltip): void;
+    /**
+     * Clears the registry, but only when the given tooltip is still the registered one. The guard
+     * matters because hiding the previous tooltip is asynchronous: its `visibleChange(false)` arrives
+     * after the new tooltip has already been registered, and must not wipe that newer entry.
+     */
+    clearVisible(tooltip: KbqExclusiveTooltip): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KbqTooltipRegistry>;
+}
+
 declare enum TooltipModifier {
     Default = "default",
     Warning = "warning",
@@ -43,9 +75,19 @@ declare const KBQ_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
     deps: (typeof Overlay)[];
     useFactory: typeof kbqTooltipScrollStrategyFactory;
 };
-declare class KbqTooltipTrigger extends KbqPopUpTrigger<KbqTooltipComponent> implements AfterViewInit, OnChanges, OnDestroy {
+/**
+ * Trigger directive that shows a `KbqTooltipComponent` for its host element. Extends `KbqPopUpTrigger` with
+ * tooltip-specific inputs (content, placement, color, arrow, enter/leave delays, modifier and header) and
+ * behavior such as opening on keyboard focus only and positioning relative to the mouse cursor.
+ */
+declare class KbqTooltipTrigger extends KbqPopUpTrigger<KbqTooltipComponent> implements AfterViewInit, OnChanges, OnDestroy, KbqExclusiveTooltip {
+    /** Registry holding the single tooltip that is currently visible. */
+    private readonly tooltipRegistry;
+    /** @docs-private */
     protected scrollStrategy: () => ScrollStrategy;
+    /** @docs-private */
     protected parentPopup: KbqParentPopup | null;
+    /** @docs-private */
     protected focusMonitor: FocusMonitor;
     /** @docs-private */
     protected renderer: Renderer2;
@@ -64,46 +106,78 @@ declare class KbqTooltipTrigger extends KbqPopUpTrigger<KbqTooltipComponent> imp
      * Defaults to `true`.
      */
     readonly ignoreTooltipPointerEvents: i0.InputSignal<boolean>;
+    /**
+     * Whether the tooltip takes part in the "only one tooltip is visible at a time" group: showing it
+     * hides the previously visible tooltip, and it is hidden when another tooltip is shown.
+     *
+     * Defaults to `true`; the default can be changed application-wide with the
+     * `KBQ_TOOLTIP_SINGLE_INSTANCE_DEFAULT` token.
+     *
+     * Tooltips without an interactive `kbqTrigger` (`manual`, `none`, …) never take part in the group,
+     * regardless of this input — they are shown imperatively and are expected to stay pinned.
+     */
+    readonly singleInstance: i0.InputSignalWithTransform<boolean, unknown>;
     /**
      * Changes hiding behavior. By default, tooltip is hidden on mouseleave from trigger.
      * Setting hideWithTimeout to true will delay tooltip hiding and will not hide when the mouse moves from trigger
      * to tooltip.
      */
     hideWithTimeout: boolean;
+    /** Input (`kbqVisible`) that programmatically shows or hides the tooltip; reflects the current `visible` state. */
     get tooltipVisible(): boolean;
     set tooltipVisible(value: boolean);
+    /** Input (`kbqPlacement`) that sets the tooltip placement relative to its trigger; reflects the current `placement`. */
     get tooltipPlacement(): KbqPopUpPlacementValues;
+    set tooltipPlacement(value: KbqPopUpPlacementValues);
     /**
      * Positions the tooltip relative to the mouse cursor. Only available for top and bottom kbqPlacement.
      * Does not work with kbqPlacementPriority.
      */
     relativeToPointer: boolean;
-    set tooltipPlacement(value: KbqPopUpPlacementValues);
+    /** Input (`kbqPlacementPriority`) that sets the ordered fallback placements; reflects the current `placementPriority`. */
     get tooltipPlacementPriority(): string | string[] | null;
     set tooltipPlacementPriority(value: string | string[] | null);
+    /** Input (`kbqTooltip`) with the tooltip content — a string or a template. Updating it refreshes an open tooltip. */
     get content(): string | TemplateRef<any>;
     set content(content: string | TemplateRef<any>);
+    /** Input (`kbqTooltipDisabled`) controlling whether the tooltip is disabled; setting it to `true` hides it. */
     get disabled(): boolean;
     set disabled(value: boolean);
+    /** Input (`kbqEnterDelay`) — delay in milliseconds before the tooltip is shown. Defaults to `400`. */
     enterDelay: number;
+    /** Input (`kbqLeaveDelay`) — delay in milliseconds before the tooltip is hidden. Defaults to `0`. */
     leaveDelay: number;
+    /** Input (`kbqTrigger`) with the comma-separated trigger events. An empty value resets to hover + focus and rebinds listeners. */
     get trigger(): string;
     set trigger(value: string);
+    /** Backing field for `trigger`; defaults to hover + focus. */
     protected _trigger: string;
+    /** Input (`kbqTooltipClass`) with an extra CSS class applied to the tooltip; updating it refreshes the class map. */
     get customClass(): string;
     set customClass(value: string);
+    /** Input (`kbqTooltipContext`) with the context object passed to a template tooltip; updating it refreshes the open tooltip. */
     get context(): any;
     set context(ctx: any);
+    /** Backing field for `context`. */
     private _context;
+    /** Input (`kbqTooltipColor`) with the tooltip color theme; the getter returns the `kbq-`-prefixed CSS class. */
     get color(): string;
     set color(value: KbqComponentColors | string);
+    /** Backing field for `color`; defaults to `KbqComponentColors.Contrast`. */
     private _color;
+    /** Input (`kbqTooltipArrow`) — whether to render the tooltip's arrow/pointer. Defaults to `false`. */
     arrow: boolean;
+    /** Input (`kbqTooltipOffset`) — distance in pixels between the tooltip and its trigger; `null` uses the default. */
     offset: number | null;
+    /** Output (`kbqPlacementChange`) that emits the new placement whenever the tooltip repositions. */
     readonly placementChange: EventEmitter<any>;
+    /** Output (`kbqVisibleChange`) that emits when the tooltip's visibility changes. */
     readonly visibleChange: EventEmitter<boolean>;
+    /** Whether the configured trigger list includes the `click` trigger. */
     private get hasClickInTrigger();
+    /** @docs-private */
     protected originSelector: string;
+    /** @docs-private */
     protected overlayConfig: OverlayConfig;
     /**
      * Visual variant of the tooltip. Accepts `'default'` | `'warning'` | `'extended'`.
@@ -126,11 +200,48 @@ declare class KbqTooltipTrigger extends KbqPopUpTrigger<KbqTooltipComponent> imp
      * the next show/hide cycle.
      */
     ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Whether this tooltip takes part in the "only one tooltip is visible at a time" group.
+     *
+     * Read through the `trigger` getter on purpose: `KbqTitleDirective` always reports `hover`, so title
+     * tooltips participate, while `kbqValidationTooltip` consumers (datepicker, timepicker, inline-edit)
+     * assign `trigger = 'manual'` and therefore stay out of the group.
+     */
+    private get participatesInSingleInstance();
+    /**
+     * Sets up an effect that mirrors a `forDisabledComponent`'s disabled signal: when that component is disabled it
+     * makes the host focusable (so the tooltip can still be triggered) and enables the tooltip, otherwise disables it.
+     *
+     * Also joins the "only one tooltip is visible at a time" group. Both the subscription and the teardown live
+     * here rather than in `ngAfterViewInit`/`ngOnDestroy` because several subclasses override those hooks:
+     * `KbqTitleDirective` and `KbqEllipsisCenterDirective` skip `super.ngAfterViewInit()`, and `KbqPasswordToggle`
+     * skips `super` in both hooks entirely. `destroyRef` additionally covers a trigger destroyed while its
+     * tooltip is still visible — that path disposes the overlay without emitting `visibleChange(false)`.
+     */
     constructor();
+    /**
+     * Hides the tooltip when a parent pop-up closes, starts focus monitoring on the host, and—when
+     * `ignoreTooltipPointerEvents` is set—adds the panel class that makes the tooltip ignore pointer events.
+     */
     ngAfterViewInit(): void;
+    /** Stops focus monitoring on the host element and runs the base-class teardown. */
     ngOnDestroy(): void;
+    /**
+     * Shows the tooltip after `delay` ms. Suppresses showing on a focus trigger that did not originate from
+     * the keyboard, and applies cursor-relative positioning when `relativeToPointer` is enabled.
+     */
     show(delay?: number): void;
-    /** method allows to show the tooltip relative to the given mouse event. */
+    /**
+     * Hides the tooltip because another tooltip became visible.
+     *
+     * Goes straight to the pop-up instead of `hide()`: `hide()` silently no-ops when the last recorded
+     * `triggerName` is `mouseleave` and the pop-up itself is hovered. Hiding through the instance keeps
+     * `visibleChange(false)` firing, so `isOpen`, `kbqVisibleChange` and the `kbqVisible` input stay in sync.
+     * Does nothing when the tooltip is already detached or when closing is prevented.
+     * @docs-private */
+    hideAsInactive(): void;
+    /** method allows to show the tooltip relative to the given mouse event.
+     * @docs-private */
     showForMouseEvent(event: MouseEvent): void;
     /**
      * method allows to show the tooltip relative to the element
@@ -139,15 +250,20 @@ declare class KbqTooltipTrigger extends KbqPopUpTrigger<KbqTooltipComponent> imp
      * For example:
      * const tooltip = new KbqTooltipTrigger();
      * tooltip.showForElement(element);
-     */
+     * @docs-private */
     showForElement(element: HTMLElement): void;
+    /** @docs-private */
     updateData(): void;
+    /** @docs-private */
     closingActions(): rxjs.Observable<void | MouseEvent>;
+    /** @docs-private */
     getOverlayHandleComponentType(): Type<KbqTooltipComponent>;
+    /** @docs-private */
     updateClassMap(newPlacement?: string): void;
+    /** @docs-private */
     protected applyRelativeToPointer(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipTrigger, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTooltipTrigger, "[kbqTooltip]", ["kbqTooltip"], { "forDisabledComponent": { "alias": "forDisabledComponent"; "required": false; "isSignal": true; }; "ignoreTooltipPointerEvents": { "alias": "ignoreTooltipPointerEvents"; "required": false; "isSignal": true; }; "hideWithTimeout": { "alias": "hideWithTimeout"; "required": false; }; "tooltipVisible": { "alias": "kbqVisible"; "required": false; }; "tooltipPlacement": { "alias": "kbqPlacement"; "required": false; }; "relativeToPointer": { "alias": "kbqRelativeToPointer"; "required": false; }; "tooltipPlacementPriority": { "alias": "kbqPlacementPriority"; "required": false; }; "content": { "alias": "kbqTooltip"; "required": false; }; "disabled": { "alias": "kbqTooltipDisabled"; "required": false; }; "enterDelay": { "alias": "kbqEnterDelay"; "required": false; }; "leaveDelay": { "alias": "kbqLeaveDelay"; "required": false; }; "trigger": { "alias": "kbqTrigger"; "required": false; }; "customClass": { "alias": "kbqTooltipClass"; "required": false; }; "context": { "alias": "kbqTooltipContext"; "required": false; }; "color": { "alias": "kbqTooltipColor"; "required": false; }; "arrow": { "alias": "kbqTooltipArrow"; "required": false; }; "offset": { "alias": "kbqTooltipOffset"; "required": false; }; "modifier": { "alias": "kbqTooltipModifier"; "required": false; }; "header": { "alias": "kbqTooltipHeader"; "required": false; }; }, { "placementChange": "kbqPlacementChange"; "visibleChange": "kbqVisibleChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTooltipTrigger, "[kbqTooltip]", ["kbqTooltip"], { "forDisabledComponent": { "alias": "forDisabledComponent"; "required": false; "isSignal": true; }; "ignoreTooltipPointerEvents": { "alias": "ignoreTooltipPointerEvents"; "required": false; "isSignal": true; }; "singleInstance": { "alias": "kbqTooltipSingleInstance"; "required": false; "isSignal": true; }; "hideWithTimeout": { "alias": "hideWithTimeout"; "required": false; }; "tooltipVisible": { "alias": "kbqVisible"; "required": false; }; "tooltipPlacement": { "alias": "kbqPlacement"; "required": false; }; "relativeToPointer": { "alias": "kbqRelativeToPointer"; "required": false; }; "tooltipPlacementPriority": { "alias": "kbqPlacementPriority"; "required": false; }; "content": { "alias": "kbqTooltip"; "required": false; }; "disabled": { "alias": "kbqTooltipDisabled"; "required": false; }; "enterDelay": { "alias": "kbqEnterDelay"; "required": false; }; "leaveDelay": { "alias": "kbqLeaveDelay"; "required": false; }; "trigger": { "alias": "kbqTrigger"; "required": false; }; "customClass": { "alias": "kbqTooltipClass"; "required": false; }; "context": { "alias": "kbqTooltipContext"; "required": false; }; "color": { "alias": "kbqTooltipColor"; "required": false; }; "arrow": { "alias": "kbqTooltipArrow"; "required": false; }; "offset": { "alias": "kbqTooltipOffset"; "required": false; }; "modifier": { "alias": "kbqTooltipModifier"; "required": false; }; "header": { "alias": "kbqTooltipHeader"; "required": false; }; }, { "placementChange": "kbqPlacementChange"; "visibleChange": "kbqVisibleChange"; }, never, never, true, never>;
     static ngAcceptInputType_hideWithTimeout: unknown;
     static ngAcceptInputType_relativeToPointer: unknown;
     static ngAcceptInputType_arrow: unknown;
@@ -160,4 +276,5 @@ declare class KbqToolTipModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<KbqToolTipModule>;
 }
 
-export { KBQ_TOOLTIP_OPEN_TIME, KBQ_TOOLTIP_OPEN_TIME_PROVIDER, KBQ_TOOLTIP_SCROLL_STRATEGY, KBQ_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER, KbqToolTipModule, KbqTooltipComponent, KbqTooltipTrigger, MIN_TIME_FOR_DELAY, TooltipModifier, kbqTooltipScrollStrategyFactory };
+export { KBQ_TOOLTIP_OPEN_TIME, KBQ_TOOLTIP_OPEN_TIME_PROVIDER, KBQ_TOOLTIP_SCROLL_STRATEGY, KBQ_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER, KBQ_TOOLTIP_SINGLE_INSTANCE_DEFAULT, KbqToolTipModule, KbqTooltipComponent, KbqTooltipRegistry, KbqTooltipTrigger, MIN_TIME_FOR_DELAY, TooltipModifier, kbqTooltipScrollStrategyFactory };
+export type { KbqExclusiveTooltip };

package/tree/_tree-theme.scss

@@ -11,11 +11,6 @@
         color: var(--kbq-tree-#{$state-name}-text-color);
     }
 
-    .kbq-tree-node-toggle .kbq-icon.kbq-empty,
-    .kbq-icon.kbq-empty.kbq-tree-node-toggle {
-        color: var(--kbq-tree-#{$state-name}-tree-toggle-color);
-    }
-
     .kbq-option-action .kbq-icon.kbq-empty {
         color: var(--kbq-tree-#{$state-name}-action-button-color);
     }
@@ -69,7 +64,7 @@
         &.kbq-disabled {
             @include kbq-tree-option(states-disabled);
 
-            & .kbq-icon.kbq-empty {
+            & .kbq-icon.kbq-empty:not(.kbq-tree-node-toggle .kbq-icon) {
                 color: var(--kbq-states-icon-disabled);
             }
         }
@@ -91,7 +86,7 @@
         @include kbq-typography-level-to-styles-css-variables(typography, text-normal);
     }
 
-    .kbq-tree-option-caption {
+    .kbq-option-caption {
         @include kbq-typography-level-to-styles-css-variables(typography, text-compact);
     }
 }

package/tree/index.d.ts

@@ -605,9 +605,15 @@ declare class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueA
     private elementRef;
     private scheduler;
     private clipboard;
+    private readonly platform;
     protected readonly focusMonitor: FocusMonitor;
-    /** Indicates whether this component is placed inside a KbqFormField component. */
-    protected readonly inSelect: boolean;
+    /**
+     * Whether this tree-selection is rendered inside a select panel (enables option
+     * hover-to-focus). Defaults to detecting a wrapping `KbqFormField`, and is forced to `true`
+     * by the host `KbqTreeSelect` so hover works even when the tree-select has no form-field
+     * wrapper (e.g. the filter-bar pipes render the tree-select bare).
+     */
+    inSelect: boolean;
     renderedOptions: QueryList<KbqTreeOption>;
     keyManager: FocusKeyManager<KbqTreeOption>;
     selectionModel: SelectionModel<SelectionModelOption>;
@@ -633,6 +639,8 @@ declare class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueA
     get noUnselectLast(): boolean;
     set noUnselectLast(value: boolean);
     private _noUnselectLast;
+    /** When `true`, a repeated Ctrl/Cmd+A deselects all options. Off by default (Ctrl+A only selects). */
+    readonly selectAllToggle: i0.InputSignalWithTransform<boolean, unknown>;
     get disabled(): boolean;
     set disabled(rawValue: boolean);
     private _disabled;
@@ -660,7 +668,14 @@ declare class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueA
     renderNodeChanges(data: KbqTreeOption[], dataDiffer?: IterableDiffer<KbqTreeOption>, viewContainer?: ViewContainerRef, parentData?: KbqTreeOption): void;
     emitNavigationEvent(option: KbqTreeOption): void;
     emitChangeEvent(option: KbqTreeOption): void;
-    selectAllOptions(): void;
+    /**
+     * Function for handling the combination Ctrl + A (select all). By default, the internal handler is used,
+     * which toggles the selection of all non-disabled, selectable options.
+     */
+    get selectAllHandler(): (event: KeyboardEvent, tree: KbqTreeSelection) => void;
+    set selectAllHandler(fn: (event: KeyboardEvent, tree: KbqTreeSelection) => void);
+    private _selectAllHandler;
+    selectAllOptions(allowDeselect?: boolean): void;
     copyActiveOption(event: KeyboardEvent): void;
     writeValue(value: any): void;
     /** `View -> model callback called when value changes` */
@@ -705,7 +720,7 @@ declare class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueA
     private canDeselectLast;
     private isFocusReceivedFromNestedOption;
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelection, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeSelection, "kbq-tree-selection", ["kbqTreeSelection"], { "treeControl": { "alias": "treeControl"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "noUnselectLast": { "alias": "noUnselectLast"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "onCopy": "onCopy"; }, ["unorderedOptions"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeSelection, "kbq-tree-selection", ["kbqTreeSelection"], { "treeControl": { "alias": "treeControl"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "noUnselectLast": { "alias": "noUnselectLast"; "required": false; }; "selectAllToggle": { "alias": "selectAllToggle"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "selectAllHandler": { "alias": "selectAllHandler"; "required": false; }; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "onCopy": "onCopy"; }, ["unorderedOptions"], never, true, never>;
 }
 
 declare class KbqTreeModule {

package/tree/toggle.scss

@@ -9,6 +9,7 @@
     flex-shrink: 0;
 
     height: 100%;
+
     // FIXME: default token doesn't exist
     padding-left: var(--kbq-tree-size-toggle-padding);
     padding-right: var(--kbq-tree-size-toggle-padding);
@@ -27,6 +28,10 @@
 
     &[disabled] {
         cursor: default;
+
+        & .kbq-icon {
+            color: var(--kbq-tree-states-disabled-tree-toggle-color);
+        }
     }
 }
 

package/tree/tree-option.scss

@@ -70,10 +70,6 @@
         outline: none;
     }
 
-    &.kbq-disabled .kbq-icon {
-        cursor: default;
-    }
-
     &:not(.kbq-disabled) {
         cursor: pointer;
 

package/tree-select/_tree-select-theme.scss

@@ -9,7 +9,7 @@
         &.kbq-control_has-validate-directive.ng-invalid,
         // Invalid by control `ErrorStateMatcher`
         &.kbq-invalid {
-            color: var(--kbq-error-default);
+            color: var(--kbq-foreground-error);
 
             .kbq-select__placeholder {
                 color: var(--kbq-form-field-states-error-placeholder);