@koobiq/components 19.8.3 → 20.1.0

package/tooltip/index.d.ts

@@ -1 +1,211 @@
-export * from './public-api';
+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 { FocusMonitor } from '@angular/cdk/a11y';
+import { ScrollStrategy, Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { KbqPopUp, KbqPopUpTrigger, KbqParentPopup, KbqPopUpPlacementValues, KbqComponentColors } from '@koobiq/components/core';
+
+declare enum TooltipModifier {
+    Default = "default",
+    Warning = "warning",
+    Extended = "extended"
+}
+declare const KBQ_TOOLTIP_OPEN_TIME: InjectionToken<{
+    value: number;
+}>;
+/** @docs-private */
+declare const KBQ_TOOLTIP_OPEN_TIME_PROVIDER: {
+    provide: InjectionToken<{
+        value: number;
+    }>;
+    useValue: {
+        value: number;
+    };
+};
+declare const MIN_TIME_FOR_DELAY = 2000;
+declare class KbqTooltipComponent extends KbqPopUp {
+    private openTime;
+    prefix: string;
+    elementRef: ElementRef;
+    show(delay: number): void;
+    updateClassMap(placement: string, customClass: string, { modifier }: {
+        modifier: any;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTooltipComponent, "kbq-tooltip-component", never, {}, {}, never, never, true, never>;
+}
+declare const KBQ_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function kbqTooltipScrollStrategyFactory(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+declare const KBQ_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof kbqTooltipScrollStrategyFactory;
+};
+/**
+ * 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 {
+    /** @docs-private */
+    protected scrollStrategy: () => ScrollStrategy;
+    /** @docs-private */
+    protected parentPopup: KbqParentPopup | null;
+    /** @docs-private */
+    protected focusMonitor: FocusMonitor;
+    /** @docs-private */
+    protected renderer: Renderer2;
+    /**
+     * Input for controlling the disabled state of a component.
+     *
+     * The input expects a component containing `disabledSignal` property, which is
+     * a writable signal emitting boolean values.
+     */
+    readonly forDisabledComponent: i0.InputSignal<Record<"disabledSignal", WritableSignal<boolean>> | undefined>;
+    /**
+     * Determines whether pointer events should be ignored on tooltips.
+     *
+     * When set to `true`, tooltip elements will not receive pointer events,
+     * allowing interactions to pass through to underlying elements.
+     * Defaults to `true`.
+     */
+    readonly ignoreTooltipPointerEvents: i0.InputSignal<boolean>;
+    /**
+     * 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;
+    /** 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'`.
+     * Replaces the removed `KbqWarningTooltipTrigger` and `KbqExtendedTooltipTrigger`
+     * subclasses — to render a warning tooltip use `kbqTooltipModifier="warning"`,
+     * and `kbqTooltipModifier="extended"` for the extended variant (combine with `kbqTooltipHeader`).
+     */
+    modifier: TooltipModifier | `${TooltipModifier}`;
+    /**
+     * Header text or template, rendered above the tooltip content. Only meaningful with
+     * `kbqTooltipModifier="extended"`. Replaces the removed `KbqExtendedTooltipTrigger.header`.
+     */
+    header: string | TemplateRef<any>;
+    /**
+     * The old `KbqWarningTooltipTrigger` / `KbqExtendedTooltipTrigger` subclasses had
+     * setters on their content/header inputs that pushed updates into the open tooltip.
+     * Now that `modifier` and `header` are plain `@Input` fields on this base class,
+     * we need to mirror that reactivity manually — without it, changing the inputs
+     * while a tooltip is open silently leaves the overlay showing stale data until
+     * the next show/hide cycle.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * 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.
+     */
+    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.
+     * @docs-private */
+    showForMouseEvent(event: MouseEvent): void;
+    /**
+     * method allows to show the tooltip relative to the element
+     * Use this approach when it is not possible to define a trigger in the template.
+     *
+     * 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 ngAcceptInputType_hideWithTimeout: unknown;
+    static ngAcceptInputType_relativeToPointer: unknown;
+    static ngAcceptInputType_arrow: unknown;
+    static ngAcceptInputType_offset: unknown;
+}
+
+declare class KbqToolTipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToolTipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqToolTipModule, never, [typeof KbqTooltipComponent, typeof KbqTooltipTrigger], [typeof KbqTooltipComponent, typeof KbqTooltipTrigger]>;
+    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 };

package/top-bar/index.d.ts

@@ -1 +1,33 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+declare class KbqTopBarSpacer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBarSpacer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTopBarSpacer, "[kbqTopBarSpacer]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive that dynamically applying CSS classes based on a placement value (left or right).
+ */
+declare class KbqTopBarContainer {
+    /**
+     * Conditionally applies a CSS class based on the value
+     */
+    readonly placement: i0.InputSignal<"start" | "end">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBarContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTopBarContainer, "[kbqTopBarContainer]", never, { "placement": { "alias": "placement"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class KbqTopBar {
+    /**
+     * Enables overflow behavior, applying `kbq-top-bar-overflow` to show a bottom shadow.
+     */
+    readonly withShadow: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTopBar, "kbq-top-bar", never, { "withShadow": { "alias": "withShadow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class KbqTopBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTopBarModule, never, [typeof KbqTopBar, typeof KbqTopBarContainer, typeof KbqTopBarSpacer], [typeof KbqTopBar, typeof KbqTopBarContainer, typeof KbqTopBarSpacer]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTopBarModule>;
+}
+
+export { KbqTopBar, KbqTopBarContainer, KbqTopBarModule, KbqTopBarSpacer };

package/top-bar/top-bar.scss

@@ -21,8 +21,7 @@
 }
 
 .kbq-top-bar {
-    // TODO: Disabled, need fix in DS-5288
-    //z-index: overlay.$overlay-z-index;
+    z-index: overlay.$overlay-z-index;
 
     display: flex;
     align-items: center;

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);
     }
 }