@cuby-ui/core 0.0.181 → 0.0.191

package/directives/text-field-controller/text-field-icon-left.directive.d.ts

@@ -1,9 +1,9 @@
-import { InjectionToken } from '@angular/core';
-import type { CuiIcon } from '@cuby-ui/icons';
-import * as i0 from "@angular/core";
-export declare const CUI_TEXT_FIELD_ICON_LEFT: InjectionToken<CuiTextFieldIconLeftDirective>;
-export declare class CuiTextFieldIconLeftDirective {
-    iconLeft?: CuiIcon | string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIconLeftDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIconLeftDirective, "[cuiTextFieldIconLeft]", never, { "iconLeft": "cuiTextFieldIconLeft"; }, {}, never, never, false, never>;
-}
+import { InjectionToken } from '@angular/core';
+import type { CuiIcon } from '@cuby-ui/icons';
+import * as i0 from "@angular/core";
+export declare const CUI_TEXT_FIELD_ICON_LEFT: InjectionToken<CuiTextFieldIconLeftDirective>;
+export declare class CuiTextFieldIconLeftDirective {
+    iconLeft?: CuiIcon | string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIconLeftDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIconLeftDirective, "[cuiTextFieldIconLeft]", never, { "iconLeft": { "alias": "cuiTextFieldIconLeft"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/text-field-controller/text-field-id.directive.d.ts

@@ -1,8 +1,8 @@
-import { InjectionToken } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare const CUI_TEXT_FIELD_ID: InjectionToken<CuiTextFieldIdDirective>;
-export declare class CuiTextFieldIdDirective {
-    id?: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIdDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIdDirective, "[cuiTextFieldId]", never, { "id": "cuiTextFieldId"; }, {}, never, never, false, never>;
-}
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CUI_TEXT_FIELD_ID: InjectionToken<CuiTextFieldIdDirective>;
+export declare class CuiTextFieldIdDirective {
+    id?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIdDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIdDirective, "[cuiTextFieldId]", never, { "id": { "alias": "cuiTextFieldId"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/text-field-controller/text-field-is-error.directive.d.ts

@@ -1,8 +1,8 @@
-import { InjectionToken } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare const CUI_TEXT_FIELD_IS_ERROR: InjectionToken<CuiTextFieldIsErrorDirective>;
-export declare class CuiTextFieldIsErrorDirective {
-    isError: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIsErrorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIsErrorDirective, "[cuiTextFieldIsError]", never, { "isError": "cuiTextFieldIsError"; }, {}, never, never, false, never>;
-}
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CUI_TEXT_FIELD_IS_ERROR: InjectionToken<CuiTextFieldIsErrorDirective>;
+export declare class CuiTextFieldIsErrorDirective {
+    isError: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIsErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIsErrorDirective, "[cuiTextFieldIsError]", never, { "isError": { "alias": "cuiTextFieldIsError"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/text-field-controller/text-field-placeholder.directive.d.ts

@@ -1,8 +1,8 @@
-import { InjectionToken } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare const CUI_TEXT_FIELD_PLACEHOLDER: InjectionToken<CuiTextFieldPlaceholderDirective>;
-export declare class CuiTextFieldPlaceholderDirective {
-    placeholder?: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldPlaceholderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldPlaceholderDirective, "[cuiTextFieldPlaceholder]", never, { "placeholder": "cuiTextFieldPlaceholder"; }, {}, never, never, false, never>;
-}
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CUI_TEXT_FIELD_PLACEHOLDER: InjectionToken<CuiTextFieldPlaceholderDirective>;
+export declare class CuiTextFieldPlaceholderDirective {
+    placeholder?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldPlaceholderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldPlaceholderDirective, "[cuiTextFieldPlaceholder]", never, { "placeholder": { "alias": "cuiTextFieldPlaceholder"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/text-field-controller/text-field-size.directive.d.ts

@@ -1,9 +1,9 @@
-import { InjectionToken } from '@angular/core';
-import type { CuiSizeMd, CuiSizeSm } from '../../types';
-import * as i0 from "@angular/core";
-export declare const CUI_TEXT_FIELD_SIZE: InjectionToken<CuiTextFieldSizeDirective>;
-export declare class CuiTextFieldSizeDirective {
-    size: CuiSizeSm | CuiSizeMd;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldSizeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldSizeDirective, "[cuiTextFieldSize]", never, { "size": "cuiTextFieldSize"; }, {}, never, never, false, never>;
-}
+import { InjectionToken } from '@angular/core';
+import type { CuiSizeMd, CuiSizeSm } from '../../types';
+import * as i0 from "@angular/core";
+export declare const CUI_TEXT_FIELD_SIZE: InjectionToken<CuiTextFieldSizeDirective>;
+export declare class CuiTextFieldSizeDirective {
+    size: CuiSizeSm | CuiSizeMd;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldSizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldSizeDirective, "[cuiTextFieldSize]", never, { "size": { "alias": "cuiTextFieldSize"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/text-field-controller/text-field.controller.d.ts

@@ -1,20 +1,20 @@
-import type { CuiIcon } from '@cuby-ui/icons';
-import type { CuiTextFieldSizeDirective } from './text-field-size.directive';
-import type { CuiTextFieldIdDirective } from './text-field-id.directive';
-import type { CuiTextFieldIconLeftDirective } from './text-field-icon-left.directive';
-import type { CuiTextFieldPlaceholderDirective } from './text-field-placeholder.directive';
-import type { CuiTextFieldIsErrorDirective } from './text-field-is-error.directive';
-import type { CuiSizeMd, CuiSizeSm } from '../../types';
-export declare class CuiTextFieldController {
-    private readonly iconLeftDirective;
-    private readonly idDirective;
-    private readonly isErrorDirective;
-    private readonly placeholderDirective;
-    private readonly sizeDirective;
-    constructor(iconLeftDirective: CuiTextFieldIconLeftDirective, idDirective: CuiTextFieldIdDirective, isErrorDirective: CuiTextFieldIsErrorDirective, placeholderDirective: CuiTextFieldPlaceholderDirective, sizeDirective: CuiTextFieldSizeDirective);
-    get iconLeft(): CuiIcon | string | undefined;
-    get id(): string | undefined;
-    get isError(): boolean;
-    get placeholder(): string | undefined;
-    get size(): CuiSizeSm | CuiSizeMd;
-}
+import type { CuiIcon } from '@cuby-ui/icons';
+import type { CuiTextFieldSizeDirective } from './text-field-size.directive';
+import type { CuiTextFieldIdDirective } from './text-field-id.directive';
+import type { CuiTextFieldIconLeftDirective } from './text-field-icon-left.directive';
+import type { CuiTextFieldPlaceholderDirective } from './text-field-placeholder.directive';
+import type { CuiTextFieldIsErrorDirective } from './text-field-is-error.directive';
+import type { CuiSizeMd, CuiSizeSm } from '../../types';
+export declare class CuiTextFieldController {
+    private readonly iconLeftDirective;
+    private readonly idDirective;
+    private readonly isErrorDirective;
+    private readonly placeholderDirective;
+    private readonly sizeDirective;
+    constructor(iconLeftDirective: CuiTextFieldIconLeftDirective, idDirective: CuiTextFieldIdDirective, isErrorDirective: CuiTextFieldIsErrorDirective, placeholderDirective: CuiTextFieldPlaceholderDirective, sizeDirective: CuiTextFieldSizeDirective);
+    get iconLeft(): CuiIcon | string | undefined;
+    get id(): string | undefined;
+    get isError(): boolean;
+    get placeholder(): string | undefined;
+    get size(): CuiSizeSm | CuiSizeMd;
+}

package/directives/tooltip/index.d.ts

@@ -0,0 +1,16 @@
+export * from './tooltip';
+export * from './tooltip.component';
+export * from './tooltip.directive';
+export * from './tooltip.providers';
+export * from './tooltip.service';
+export * from './tooltip-describe.directive';
+export * from './tooltip-driver.directive';
+export * from './tooltip-host.directive';
+export * from './tooltip-hover.directive';
+export * from './tooltip-manual.directive';
+export * from './tooltip-options.directive';
+export * from './tooltip-overflow.directive';
+export * from './tooltip-pointer.directive';
+export * from './tooltip-position.directive';
+export * from './tooltip-unstyled.component';
+export * from './tooltips.component';

package/directives/tooltip/tooltip-describe.directive.d.ts

@@ -0,0 +1,16 @@
+import { CuiDriver } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipDescribe extends CuiDriver {
+    private readonly doc;
+    private readonly el;
+    private readonly zone;
+    private readonly id$;
+    private readonly stream$;
+    readonly type = "hint";
+    constructor();
+    set cuiTooltipDescribe(id: string | null | undefined);
+    private get element();
+    private get focused();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipDescribe, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipDescribe, "[cuiTooltipDescribe]", never, { "cuiTooltipDescribe": { "alias": "cuiTooltipDescribe"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-driver.directive.d.ts

@@ -0,0 +1,7 @@
+import { CuiDriverDirective } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipDriver extends CuiDriverDirective {
+    readonly type = "hint";
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipDriver, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipDriver, never, never, {}, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-host.directive.d.ts

@@ -0,0 +1,9 @@
+import { CuiRectAccessor } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipHost extends CuiRectAccessor {
+    cuiTooltipHost?: HTMLElement;
+    readonly type = "hint";
+    getClientRect(): DOMRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipHost, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipHost, "[cuiTooltip][cuiTooltipHost]", never, { "cuiTooltipHost": { "alias": "cuiTooltipHost"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-hover.directive.d.ts

@@ -0,0 +1,21 @@
+import { CuiDriver } from '../../classes';
+import type { CuiTooltipOptions } from './tooltip-options.directive';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipHover extends CuiDriver {
+    private readonly isMobile;
+    private readonly el;
+    private readonly hovered$;
+    private readonly options;
+    private visible;
+    private readonly toggle$;
+    private readonly stream$;
+    private readonly parent;
+    cuiTooltipShowDelay: CuiTooltipOptions['showDelay'];
+    cuiTooltipHideDelay: CuiTooltipOptions['hideDelay'];
+    readonly type = "hint";
+    enabled: boolean;
+    constructor();
+    toggle(visible?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipHover, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipHover, never, ["cuiTooltipHover"], { "cuiTooltipShowDelay": { "alias": "cuiTooltipShowDelay"; "required": false; }; "cuiTooltipHideDelay": { "alias": "cuiTooltipHideDelay"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-manual.directive.d.ts

@@ -0,0 +1,13 @@
+import type { OnChanges } from '@angular/core';
+import { CuiDriver } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipManual extends CuiDriver implements OnChanges {
+    private readonly hover;
+    private readonly stream$;
+    cuiTooltipManual: boolean;
+    readonly type = "hint";
+    constructor();
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipManual, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipManual, "[cuiTooltip][cuiTooltipManual]", never, { "cuiTooltipManual": { "alias": "cuiTooltipManual"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-options.directive.d.ts

@@ -0,0 +1,36 @@
+import type { FactoryProvider, OnChanges } from '@angular/core';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export type CuiTooltipDirection = 'bottom-left' | 'bottom-right' | 'bottom' | 'left-bottom' | 'left-top' | 'left' | 'right-bottom' | 'right-top' | 'right' | 'top-left' | 'top-right' | 'top';
+export declare const CUI_TOOLTIP_DIRECTIONS: readonly CuiTooltipDirection[];
+export interface CuiTooltipOptions {
+    readonly appearance: string;
+    readonly direction: CuiTooltipDirection | CuiTooltipDirection[];
+    readonly hideDelay: number;
+    readonly icon: string;
+    readonly showDelay: number;
+}
+/** Default values for tooltip options */
+export declare const CUI_TOOLTIP_DEFAULT_OPTIONS: CuiTooltipOptions;
+/**
+ * Default parameters for tooltip directive
+ */
+export declare const CUI_TOOLTIP_OPTIONS: import("@angular/core").InjectionToken<CuiTooltipOptions>;
+export declare const cuiTooltipOptionsProvider: (options: Partial<CuiTooltipOptions>) => FactoryProvider;
+/**
+ * @deprecated: drop in 5.0
+ */
+export declare class CuiTooltipOptionsDirective implements CuiTooltipOptions, OnChanges {
+    private readonly options;
+    content: PolymorpheusContent;
+    direction: CuiTooltipDirection | CuiTooltipDirection[];
+    appearance: string;
+    showDelay: number;
+    hideDelay: number;
+    icon: string;
+    readonly change$: Subject<void>;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipOptionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipOptionsDirective, "[cuiTooltipContent]", never, { "content": { "alias": "cuiTooltipContent"; "required": false; }; "direction": { "alias": "cuiTooltipDirection"; "required": false; }; "appearance": { "alias": "cuiTooltipAppearance"; "required": false; }; "showDelay": { "alias": "cuiTooltipShowDelay"; "required": false; }; "hideDelay": { "alias": "cuiTooltipHideDelay"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-overflow.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tooltip.directive";
+export declare class CuiTooltipOverflow {
+    private readonly hint;
+    protected onMouseEnter({ scrollWidth, clientWidth, textContent }: Element): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipOverflow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipOverflow, "[cuiTooltipOverflow]", never, {}, {}, never, never, true, [{ directive: typeof i1.CuiTooltipDirective; inputs: { "cuiTooltipAppearance": "cuiTooltipAppearance"; }; outputs: {}; }]>;
+}

package/directives/tooltip/tooltip-pointer.directive.d.ts

@@ -0,0 +1,10 @@
+import type { CuiRectAccessor } from '../../classes';
+import { CuiTooltipHover } from './tooltip-hover.directive';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipPointer extends CuiTooltipHover implements CuiRectAccessor {
+    private currentRect;
+    getClientRect(): DOMRect;
+    protected onMove({ clientX, clientY }: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipPointer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipPointer, "[cuiTooltip][cuiTooltipPointer]", never, {}, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-position.directive.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import { CuiPositionAccessor } from '../../classes';
+import type { CuiPoint } from '../../types';
+import type { CuiTooltipDirection, CuiTooltipOptions } from './tooltip-options.directive';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipPosition extends CuiPositionAccessor {
+    private readonly offset;
+    private readonly viewport;
+    private readonly accessor;
+    private readonly points;
+    direction: CuiTooltipOptions['direction'];
+    readonly directionChange: EventEmitter<CuiTooltipDirection>;
+    readonly type = "hint";
+    emitDirection(direction: CuiTooltipDirection): void;
+    getPosition(rect: DOMRect, el?: HTMLElement): CuiPoint;
+    private get fallback();
+    private checkPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipPosition, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipPosition, never, never, { "direction": { "alias": "cuiTooltipDirection"; "required": false; }; }, { "directionChange": "cuiTooltipDirectionChange"; }, never, never, true, never>;
+}

package/directives/tooltip/tooltip-unstyled.component.d.ts

@@ -0,0 +1,17 @@
+import type { WritableSignal } from '@angular/core';
+import type { CuiContext } from '@cuby-ui/cdk';
+import type { CuiPortalItem } from '../../types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipUnstyledComponent {
+    protected readonly context: CuiContext<CuiPortalItem<any> & {
+        content: WritableSignal<PolymorpheusContent>;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipUnstyledComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTooltipUnstyledComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+export declare class CuiTooltipUnstyled<C> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipUnstyled<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipUnstyled<any>, "ng-template[cuiTooltip]", never, {}, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip.component.d.ts

@@ -0,0 +1,33 @@
+import { CuiHoveredService } from '@cuby-ui/cdk';
+import { CuiRectAccessor } from '../../classes';
+import { CuiPositionService } from '../../services';
+import { CuiTooltipDirective } from './tooltip.directive';
+import { CuiTooltipPointer } from './tooltip-pointer.directive';
+import * as i0 from "@angular/core";
+export declare const CUI_TOOLTIP_PROVIDERS: (import("@angular/core").FactoryProvider | typeof CuiPositionService | typeof CuiHoveredService)[];
+export declare class CuiTooltipComponent<C = any> {
+    private readonly el;
+    private readonly hover;
+    private readonly vvs;
+    private readonly viewport;
+    protected readonly desktop: {
+        value: string;
+        params: {
+            end: number;
+            start: number;
+        };
+    };
+    protected readonly options: import("@angular/animations").AnimationOptions;
+    protected readonly pointer: CuiTooltipPointer | null;
+    protected readonly accessor: CuiRectAccessor;
+    protected readonly hint: CuiTooltipDirective<C>;
+    protected readonly isMobile: boolean;
+    protected readonly content: import("@angular/core").WritableSignal<import("@taiga-ui/polymorpheus").PolymorpheusContent<C>>;
+    protected readonly appearance: string | null | undefined;
+    constructor();
+    protected onClick(target: HTMLElement): void;
+    private apply;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTooltipComponent<any>, "cui-tooltip", never, {}, {}, never, ["*"], true, never>;
+}

package/directives/tooltip/tooltip.d.ts

@@ -0,0 +1,13 @@
+import { CuiTooltipComponent } from './tooltip.component';
+import { CuiTooltipDirective } from './tooltip.directive';
+import { CuiTooltipDescribe } from './tooltip-describe.directive';
+import { CuiTooltipDriver } from './tooltip-driver.directive';
+import { CuiTooltipHost } from './tooltip-host.directive';
+import { CuiTooltipHover } from './tooltip-hover.directive';
+import { CuiTooltipManual } from './tooltip-manual.directive';
+import { CuiTooltipOptionsDirective } from './tooltip-options.directive';
+import { CuiTooltipOverflow } from './tooltip-overflow.directive';
+import { CuiTooltipPointer } from './tooltip-pointer.directive';
+import { CuiTooltipPosition } from './tooltip-position.directive';
+import { CuiTooltipUnstyled } from './tooltip-unstyled.component';
+export declare const CuiTooltip: readonly [typeof CuiTooltipComponent, typeof CuiTooltipDirective, typeof CuiTooltipOptionsDirective, typeof CuiTooltipUnstyled, typeof CuiTooltipDriver, typeof CuiTooltipPosition, typeof CuiTooltipHover, typeof CuiTooltipOverflow, typeof CuiTooltipDescribe, typeof CuiTooltipHost, typeof CuiTooltipManual, typeof CuiTooltipPointer];

package/directives/tooltip/tooltip.directive.d.ts

@@ -0,0 +1,26 @@
+import type { OnDestroy } from '@angular/core';
+import { CuiActiveZone } from '@cuby-ui/cdk';
+import type { CuiRectAccessor, CuiVehicle } from '../../classes';
+import type { CuiPortalItem } from '../../types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { PolymorpheusComponent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+import * as i1 from "./tooltip-driver.directive";
+import * as i2 from "./tooltip-hover.directive";
+import * as i3 from "./tooltip-position.directive";
+export declare class CuiTooltipDirective<C> implements OnDestroy, CuiPortalItem<C>, CuiRectAccessor, CuiVehicle {
+    private readonly service;
+    context?: C;
+    appearance: string;
+    content: import("@angular/core").WritableSignal<PolymorpheusContent<C>>;
+    component: PolymorpheusComponent<any>;
+    readonly el: HTMLElement;
+    readonly activeZone?: CuiActiveZone | null | undefined;
+    readonly type = "hint";
+    set cuiTooltip(content: PolymorpheusContent<C>);
+    ngOnDestroy(): void;
+    getClientRect(): DOMRect;
+    toggle(show: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipDirective<any>, "[cuiTooltip]:not(ng-container):not(ng-template)", never, { "context": { "alias": "cuiTooltipContext"; "required": false; }; "appearance": { "alias": "cuiTooltipAppearance"; "required": false; }; "cuiTooltip": { "alias": "cuiTooltip"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.CuiTooltipDriver; inputs: {}; outputs: {}; }, { directive: typeof i2.CuiTooltipHover; inputs: { "cuiTooltipHideDelay": "cuiTooltipHideDelay"; "cuiTooltipShowDelay": "cuiTooltipShowDelay"; }; outputs: {}; }, { directive: typeof i3.CuiTooltipPosition; inputs: { "cuiTooltipDirection": "cuiTooltipDirection"; }; outputs: { "cuiTooltipDirectionChange": "cuiTooltipDirectionChange"; }; }]>;
+}

package/directives/tooltip/tooltip.providers.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from '@angular/core';
+/**
+ * A component to display a tooltip
+ */
+export declare const CUI_TOOLTIP_COMPONENT: import("@angular/core").InjectionToken<Type<unknown>>;

package/directives/tooltip/tooltip.service.d.ts

@@ -0,0 +1,13 @@
+import type { CuiPortalItem } from '../../types';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service for displaying hints/tooltips
+ */
+export declare class CuiTooltipService extends BehaviorSubject<readonly CuiPortalItem[]> {
+    constructor();
+    add(directive: CuiPortalItem): void;
+    remove(directive: CuiPortalItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiTooltipService>;
+}

package/directives/tooltip/tooltips.component.d.ts

@@ -0,0 +1,12 @@
+import type { OnInit } from '@angular/core';
+import type { CuiPortalItem } from '../../types';
+import * as i0 from "@angular/core";
+export declare class CuiTooltips implements OnInit {
+    private readonly hints$;
+    private readonly destroyRef;
+    private readonly cdr;
+    protected hints: readonly CuiPortalItem[];
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltips, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTooltips, "cui-tooltips", never, {}, {}, never, never, true, never>;
+}