@cuby-ui/core 0.0.487 → 0.0.488

package/directives/index.d.ts

@@ -0,0 +1,2 @@
+export * from './text-field-controller';
+export * from './tooltip';

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

@@ -0,0 +1,8 @@
+export * from './text-field.controller';
+export * from './text-field-controller.module';
+export * from './text-field-controller.provider';
+export * from './text-field-icon-left.directive';
+export * from './text-field-id.directive';
+export * from './text-field-is-error.directive';
+export * from './text-field-placeholder.directive';
+export * from './text-field-size.directive';

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

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./text-field-icon-left.directive";
+import * as i2 from "./text-field-id.directive";
+import * as i3 from "./text-field-placeholder.directive";
+import * as i4 from "./text-field-is-error.directive";
+import * as i5 from "./text-field-size.directive";
+export declare class CuiTextFieldControllerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldControllerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiTextFieldControllerModule, [typeof i1.CuiTextFieldIconLeftDirective, typeof i2.CuiTextFieldIdDirective, typeof i3.CuiTextFieldPlaceholderDirective, typeof i4.CuiTextFieldIsErrorDirective, typeof i5.CuiTextFieldSizeDirective], never, [typeof i1.CuiTextFieldIconLeftDirective, typeof i2.CuiTextFieldIdDirective, typeof i3.CuiTextFieldPlaceholderDirective, typeof i4.CuiTextFieldIsErrorDirective, typeof i5.CuiTextFieldSizeDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuiTextFieldControllerModule>;
+}

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

@@ -0,0 +1,4 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { CuiTextFieldController } from './text-field.controller';
+export declare const CUI_TEXT_FIELD_CONTROLLER: InjectionToken<CuiTextFieldController>;
+export declare const CUI_TEXT_FILED_CONTROLLER_PROVIDER: Provider;

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

@@ -0,0 +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": { "alias": "cuiTextFieldIconLeft"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +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": { "alias": "cuiTextFieldId"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +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": { "alias": "cuiTextFieldIsError"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +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": { "alias": "cuiTextFieldPlaceholder"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +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": { "alias": "cuiTextFieldSize"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +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;
+}

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 CuiHoveredService | typeof CuiPositionService)[];
+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>;
+}

package/editor/components/editor-attaches-tool/editor-attaches-tool.component.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from '@angular/core';
+import type { CuiFileData } from '../../interfaces/file-response-data';
+import { EditorToolComponent } from '../editor-tool/editor-tool.component';
+import * as i0 from "@angular/core";
+export declare class EditorAttachesToolComponent extends EditorToolComponent {
+    private _file;
+    private _title;
+    get file(): CuiFileData | undefined;
+    set file(value: CuiFileData);
+    get title(): string;
+    set title(value: string);
+    readonly fileClicked: EventEmitter<CuiFileData>;
+    protected get isShowLoadButton(): boolean;
+    protected onFileClick(): void;
+    protected onPreventEnter(event: KeyboardEvent): void;
+    private checkKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorAttachesToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorAttachesToolComponent, "ng-component", never, { "file": { "alias": "file"; "required": true; }; "title": { "alias": "title"; "required": true; }; }, { "fileClicked": "fileClicked"; }, never, never, true, never>;
+}

package/editor/components/editor-attaches-tool/editor-attaches-tool.options.d.ts

@@ -0,0 +1,18 @@
+import type { API } from '@editorjs/editorjs';
+import type { CuiFileData } from '../../interfaces/file-response-data';
+import { CuiFileUploaderConfig } from '../../utils/file-uploader';
+export declare const EDITOR_ATTACHES_TOOL_SELECTOR = "cc-editor-attaches-tool";
+export interface CuiAttachesToolConfig extends CuiFileUploaderConfig {
+    readonly buttonContent: string;
+    readonly fileClicked: (file: CuiFileData) => void;
+}
+export interface CuiAttachesToolOptions {
+    readonly api: API;
+    readonly config: CuiAttachesToolConfig;
+    readonly onSelectFile: () => void;
+    readonly readOnly: boolean;
+}
+export interface CuiAttachesToolData {
+    title: string;
+    file: CuiFileData;
+}

package/editor/components/editor-attaches-tool/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorAttachesToolComponent } from './editor-attaches-tool.component';
+export * from './editor-attaches-tool.options';

package/editor/components/editor-image-tool/editor-image-tool.component.d.ts

@@ -0,0 +1,14 @@
+import { EditorToolComponent } from '../editor-tool/editor-tool.component';
+import type { CuiImageTunes } from './editor-image-tool.options';
+import * as i0 from "@angular/core";
+export declare class EditorImageToolComponent extends EditorToolComponent {
+    protected readonly isLoaded: import("@angular/core").WritableSignal<boolean>;
+    protected readonly tunesSignal: import("@angular/core").WritableSignal<CuiImageTunes>;
+    image: string;
+    set tunes(tunes: CuiImageTunes);
+    protected get isShowLoadButton(): boolean;
+    protected onPreventEnter(event: KeyboardEvent): void;
+    private checkKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorImageToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorImageToolComponent, "ng-component", never, { "image": { "alias": "image"; "required": true; }; "tunes": { "alias": "tunes"; "required": false; }; }, {}, never, never, true, never>;
+}

package/editor/components/editor-image-tool/editor-image-tool.options.d.ts

@@ -0,0 +1,26 @@
+import type { API } from '@editorjs/editorjs';
+import type { CuiFileData } from '../../interfaces/file-response-data';
+import { CuiFileUploaderConfig } from '../../utils/file-uploader';
+export declare const EDITOR_IMAGE_TOOL_SELECTOR = "cc-editor-image-tool";
+export type CuiImageKeysObject<V = string> = {
+    [key: string]: V;
+};
+export interface CuiImageToolConfig extends CuiFileUploaderConfig {
+    readonly buttonContent: string;
+}
+export interface CuiImageToolOptions {
+    readonly api: API;
+    readonly config: CuiImageToolConfig;
+    readonly onSelectFile: () => void;
+    readonly readOnly: boolean;
+}
+export interface CuiImageToolData {
+    caption: string;
+    file: CuiFileData;
+    tunes: CuiImageTunes;
+}
+export interface CuiImageTunes {
+    stretched?: boolean;
+    left?: boolean;
+    right?: boolean;
+}

package/editor/components/editor-image-tool/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorImageToolComponent } from './editor-image-tool.component';
+export * from './editor-image-tool.options';

package/editor/components/editor-tool/editor-tool.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from '@angular/core';
+import type { API } from '@editorjs/editorjs';
+import * as i0 from "@angular/core";
+export declare class EditorToolComponent {
+    private readonly window;
+    private readonly document;
+    api: API;
+    preview: string;
+    caption: string;
+    buttonContent: string;
+    readOnly: boolean;
+    isLoading: boolean;
+    fileSelected: EventEmitter<void>;
+    captionChanged: EventEmitter<string>;
+    private previousValue;
+    protected get isCaptionShown(): boolean;
+    protected onSelectFile(): void;
+    protected onTitleChange(event: KeyboardEvent): void;
+    protected onTitlePaste(event: ClipboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorToolComponent, "ng-component", never, { "api": { "alias": "api"; "required": true; }; "preview": { "alias": "preview"; "required": true; }; "caption": { "alias": "caption"; "required": true; }; "buttonContent": { "alias": "buttonContent"; "required": true; }; "readOnly": { "alias": "readOnly"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, { "fileSelected": "fileSelected"; "captionChanged": "captionChanged"; }, never, never, false, never>;
+}

package/editor/components/editor-tool-modal/editor-tool-modal.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import type { Tool } from './editor-tool-modal.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@cuby-ui/cdk";
+export declare class EditorToolModalComponent {
+    private readonly element;
+    private readonly window;
+    private readonly cuiClickOutsideDirective;
+    private readonly SPACE_BETWEEN_TARGET_AND_LIST;
+    isFullscreen: import("@angular/core").WritableSignal<boolean>;
+    isHidden: import("@angular/core").WritableSignal<boolean>;
+    tool: Tool;
+    set marker(value: HTMLElement);
+    closed: EventEmitter<void>;
+    protected get _isHidden(): boolean;
+    protected get _isFullscreen(): boolean;
+    constructor();
+    protected onCloseModal(): void;
+    protected onMaximizeModal(): void;
+    private initClickOutsideSubscription;
+    private calculateModalPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorToolModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorToolModalComponent, "ng-component", never, { "tool": { "alias": "tool"; "required": true; }; "marker": { "alias": "marker"; "required": false; }; }, { "closed": "closed"; }, never, never, true, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }]>;
+}

package/editor/components/editor-tool-modal/editor-tool-modal.options.d.ts

@@ -0,0 +1,8 @@
+import type { MarkerType } from '../../services/markers-service.options';
+export interface Tool {
+    id: string;
+    image?: string;
+    title?: string;
+    type?: MarkerType;
+}
+export declare const EDITOR_TOOL_MODAL_SELECTOR = "cc-editor-tool-modal";

package/editor/components/editor-tool-modal/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorToolModalComponent } from './editor-tool-modal.component';
+export { Tool, EDITOR_TOOL_MODAL_SELECTOR } from './editor-tool-modal.options';

package/editor/components/editor-tooltip/editor-tooltip.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from '@angular/core';
+import type { EditorTooltipButton, EditorTooltipOption, EditorTooltipOptions } from './editor-tooltip.options';
+import * as i0 from "@angular/core";
+export declare class EditorTooltipComponent {
+    protected readonly BUTTONS_OPTIONS: Map<EditorTooltipOption, EditorTooltipButton>;
+    protected _options: EditorTooltipOptions;
+    protected buttons: EditorTooltipButton[];
+    title: string;
+    set options(value: EditorTooltipOptions);
+    readonly copyClicked: EventEmitter<MouseEvent>;
+    readonly editClicked: EventEmitter<MouseEvent>;
+    readonly deleteClicked: EventEmitter<MouseEvent>;
+    private getButtonsFromOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorTooltipComponent, "ng-component", never, { "title": { "alias": "title"; "required": true; }; "options": { "alias": "options"; "required": false; }; }, { "copyClicked": "copyClicked"; "editClicked": "editClicked"; "deleteClicked": "deleteClicked"; }, never, never, true, never>;
+}

package/editor/components/editor-tooltip/editor-tooltip.options.d.ts

@@ -0,0 +1,9 @@
+import type { CuiIcon } from '@cuby-ui/icons';
+export type EditorTooltipOption = 'copy' | 'edit' | 'delete';
+export type EditorTooltipOptions = EditorTooltipOption[];
+export interface EditorTooltipButton {
+    readonly icon: CuiIcon;
+    readonly handler: (event: MouseEvent) => void;
+    readonly class?: string;
+}
+export declare const EDITOR_TOOLTIP_SELECTOR = "cc-editor-tooltip";

package/editor/components/editor-tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorTooltipComponent } from './editor-tooltip.component';
+export * from './editor-tooltip.options';

package/editor/components/editor-video-tool/editor-video-tool.component.d.ts

@@ -0,0 +1,12 @@
+import { EditorToolComponent } from '../editor-tool/editor-tool.component';
+import * as i0 from "@angular/core";
+export declare class EditorVideoToolComponent extends EditorToolComponent {
+    protected isLoaded: import("@angular/core").WritableSignal<boolean>;
+    video: string;
+    protected get isShowLoadButton(): boolean;
+    protected onPlay(): void;
+    protected onPreventEnter(event: KeyboardEvent): void;
+    private checkKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorVideoToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorVideoToolComponent, "ng-component", never, { "video": { "alias": "video"; "required": true; }; }, {}, never, never, true, never>;
+}