@ngutil/floating 0.0.102 → 0.0.104

package/index.d.ts

@@ -1,7 +1,417 @@
-import { Provider } from "@angular/core";
-export * from "./floating";
-export * from "./layer";
-export interface ProvideFloatingOptions {
+import * as i0 from '@angular/core';
+import { ElementRef, Injector, Provider, ViewContainerRef, TemplateRef, InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, ReplaySubject, ObservableInput } from 'rxjs';
+import { Lifecycle, ElementInput } from '@ngutil/common';
+import { PortalOutlet, ComponentType, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { CoverOptions, CoverRef } from '@ngutil/graphics';
+import { AnimationMetadata } from '@angular/animations';
+import { FloatingPosition, Position, FloatingPositionContentOptions, FloatingPositionAnchorOptions, FloatingPositionPlacementOptions, FloatingPositionAltInput } from '@ngutil/style';
+import { Focusable, FocusState } from '@ngutil/aria';
+import * as _ngutil_floating from '@ngutil/floating';
+import { Primitive } from 'utility-types';
+
+type DisposeHandler<T> = (ref: T) => Observable<void>;
+declare enum AlwaysOnTop {
+    /**
+     * Display as open order
+     */
+    None = 0,
+    /**
+     * Modals
+     */
+    Modal = 2,
+    /**
+     * User access control
+     */
+    UAC = 3,
+    /**
+     * Toast...
+     */
+    Toast = 4,
+    /**
+     * Like select drop down, tooltip, stb...
+     */
+    Control = 5
+}
+declare abstract class ChildRef<T extends HTMLElement = HTMLElement> extends ElementRef<T> {
+    readonly alwaysOnTop: AlwaysOnTop;
+    readonly state: Lifecycle<{
+        showing: {};
+        shown: {};
+        disposing: {
+            cancellable: false;
+        };
+        disposed: {
+            cancellable: false;
+            order: "sequential";
+        };
+    }, "showing" | "shown" | "disposing" | "disposed">;
+    get zIndex(): number;
+    private _zIndex;
+    protected readonly disposed$: Observable<"disposed">;
+    constructor(nativeElement: T, alwaysOnTop?: AlwaysOnTop);
+    dispose(): Observable<void>;
+}
+
+interface ContainerOptions {
+    alwaysOnTop?: AlwaysOnTop;
+    elevation?: number;
+    classes?: string[];
+    attributes?: Record<string, string>;
+    injector?: Injector;
+    providers?: Provider[];
+}
+declare class ContainerRef extends ChildRef {
+    readonly options: ContainerOptions;
+    readonly injector: Injector;
+    protected injectorName: string;
+    constructor(options: ContainerOptions);
+    protected getProviders(): Provider[];
+}
+
+type BackdropOptions = CoverOptions;
+declare class BackdropRef extends ChildRef {
+    #private;
+    readonly coverRef: CoverRef<any>;
+    readonly under: ChildRef;
+    readonly options: CoverOptions;
+    readonly group: string;
+    set visible(visible: boolean);
+    get visible(): boolean;
+    constructor(coverRef: CoverRef<any>, under: ChildRef, options: CoverOptions);
+    show(): rxjs.Observable<void>;
+}
+
+declare class ExternalRef extends ChildRef {
+}
+
+interface PortalOptions extends ContainerOptions {
+}
+declare abstract class PortalRef extends ContainerRef {
+    protected injectorName: string;
+    protected outlet: PortalOutlet;
+    constructor(options: PortalOptions);
+    protected getProviders(): Provider[];
+}
+interface ComponentPortalOptions<T = any> extends PortalOptions {
+    viewContainerRef?: ViewContainerRef;
+}
+declare class ComponentPortalRef<T = any> extends PortalRef {
+    readonly component: ComponentType<T>;
+    protected injectorName: string;
+    protected readonly portal: ComponentPortal<T>;
+    constructor(component: ComponentType<T>, options: ComponentPortalOptions<T>);
+    protected getProviders(): Provider[];
+}
+interface TemplatePortalOptions<T = any> extends PortalOptions {
+    viewContainerRef: ViewContainerRef;
+    context?: T;
+}
+declare class TemplatePortalRef<T = any> extends PortalRef {
+    readonly template: TemplateRef<T>;
+    protected injectorName: string;
+    protected readonly portal: TemplatePortal<T>;
+    constructor(template: TemplateRef<T>, options: TemplatePortalOptions<T>);
+    protected getProviders(): Provider[];
+}
+
+declare class LayerService {
+    #private;
+    get root(): HTMLElement;
+    newComponentPortal<T>(component: ComponentType<T>, options: ComponentPortalOptions<T>): ComponentPortalRef<T>;
+    newTemplatePortal<T>(tpl: TemplateRef<T>, options: TemplatePortalOptions<T>): TemplatePortalRef<T>;
+    newContainer(options: ContainerOptions): ContainerRef;
+    newBackdrop(under: ChildRef, options: BackdropOptions): BackdropRef;
+    addExternal(element: ElementInput, alwaysOnTop?: AlwaysOnTop): ExternalRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayerService>;
+}
+
+type Traits = {
+    [key: string]: FloatingTrait;
+};
+declare const TRAITS: InjectionToken<Traits>;
+interface FloatingChannel {
+    floatingRef: FloatingRef;
+    type: string;
+    data?: any;
+}
+interface FloatingTraitEvent {
+    name: string;
+    data: object;
+}
+type TraitState = {
+    [key: string]: FloatingTraitEvent | null;
+};
+declare class FloatingRef<C extends FloatingChannel = FloatingChannel, T extends HTMLElement = HTMLElement> {
+    #private;
+    readonly layerSvc: LayerService;
+    readonly container: ContainerRef;
+    readonly channel: ReplaySubject<FloatingChannel>;
+    readonly state: Lifecycle<{
+        init: {};
+        showing: {};
+        shown: {};
+        closing: {
+            cancellable: false;
+            order: "sequential";
+        };
+        disposing: {
+            cancellable: false;
+        };
+        disposed: {
+            cancellable: false;
+            order: "sequential";
+        };
+        cleanup: {
+            cancellable: false;
+            order: "sequential";
+        };
+    }, "showing" | "shown" | "disposing" | "disposed" | "init" | "closing" | "cleanup">;
+    readonly traitState$: Observable<TraitState>;
+    readonly uid: string;
+    constructor(layerSvc: LayerService, container: ContainerRef, traits: Traits);
+    show(): Observable<void>;
+    /**
+     * @deprecated
+     */
+    hide(): Observable<void>;
+    close(force?: boolean): Observable<void>;
+    emit(event: Omit<C, "floatingRef">): void;
+    setResult(data: any): void;
+    watchTrait<T>(name: string): Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingRef<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FloatingRef<any, any>>;
+}
+
+interface FloatingTrait<T = any> {
+    readonly name: string;
+    connect(floatingRef: FloatingRef<any>): Observable<T>;
+}
+
+type AnimationSet = {
+    show: AnimationMetadata[];
+    hide: AnimationMetadata[];
+};
+type AnimationTraitParams = (position: FloatingPosition) => object;
+declare class AnimationTrait implements FloatingTrait<void> {
+    readonly animation: AnimationSet;
+    readonly params?: AnimationTraitParams | undefined;
+    readonly name = "animation";
+    constructor(animation: AnimationSet, params?: AnimationTraitParams | undefined);
+    connect(floatingRef: FloatingRef): Observable<void>;
+}
+declare const FallAnimation: AnimationSet;
+declare function fallAnimation(scale?: number): AnimationTrait;
+declare const FadeAnimation: AnimationSet;
+declare function fadeAnimation(): AnimationTrait;
+declare function slideNearAnimation(size?: number): AnimationTrait;
+declare function slideAwayAnimation(size?: number): AnimationTrait;
+type RippleRevealAnimationOptions = {
+    origin: Position;
+    initialRadius?: number;
+    duration?: number;
+};
+declare function rippleRevealAnimation(options: RippleRevealAnimationOptions): AnimationTrait;
+
+declare const LAYER_CONTAINER_ZINDEX_START: InjectionToken<number>;
+declare abstract class LayerContainer {
+    #private;
+    abstract readonly root: HTMLElement;
+    readonly zIndexStart: number;
+    append<T extends ChildRef>(ref: T): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayerContainer, never, never, {}, {}, never, never, true, never>;
+}
+declare class RootLayer extends LayerContainer {
+    readonly root: HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootLayer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RootLayer>;
+}
+declare class IndividualLayer extends LayerContainer {
+    readonly root: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndividualLayer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IndividualLayer, never, never, {}, {}, never, never, true, never>;
+}
+
+interface CommonOptions {
+}
+type BackdropTraitOptions = CoverOptions & CommonOptions;
+declare class BackdropTrait implements FloatingTrait<BackdropRef> {
+    readonly options: BackdropTraitOptions;
+    readonly name = "backdrop";
+    constructor(options: BackdropTraitOptions);
+    connect(floatingRef: FloatingRef<any>): Observable<BackdropRef>;
+}
+declare function backdrop(options: BackdropTraitOptions): BackdropTrait;
+
+interface ClickOutsideOptions {
+    /**
+     * If clicks happened on this element, that not trigger the close event
+     */
+    allowedElements?: ElementInput[];
+}
+interface CloseTriggerOptions {
+    /**
+     * Close floating when click outside of floating element
+     */
+    clickOutside?: boolean | ClickOutsideOptions;
+    /**
+     * Only works when the floating element is focused
+     */
+    keystroke?: boolean;
+    /**
+     * Close when emitting any value
+     */
+    trigger?: ObservableInput<any>;
+}
+interface CloseTriggerEvent {
+    source: "click" | "keystroke" | "backbutton" | "trigger";
+}
+declare class CloseTriggerTrait implements FloatingTrait {
+    readonly options: CloseTriggerOptions;
+    readonly name = "close-trigger";
+    constructor(options?: CloseTriggerOptions);
+    connect(floatingRef: FloatingRef): Observable<CloseTriggerEvent | void>;
+}
+declare function closeTrigger(options?: CloseTriggerOptions): CloseTriggerTrait;
+
+interface FocusOptions {
+    trap?: boolean;
+    connect?: Focusable | FocusState;
+    tabindex?: number;
+    focusOnClose?: ElementInput;
+}
+declare class FocusTrait implements FloatingTrait<void> {
+    #private;
+    readonly options: FocusOptions;
+    readonly name = "focus";
+    constructor(options: FocusOptions);
+    connect(floatingRef: FloatingRef): Observable<void>;
+}
+declare function focus(options: FocusOptions): FocusTrait;
+
+type PositionTraitElementRef = ElementInput | Window | "layer" | "viewport";
+type PositionTraitOptions = {
+    content?: Omit<FloatingPositionContentOptions, "constraints"> & {
+        constraints?: SizeConstraintsInput;
+    };
+    anchor?: FloatingPositionAnchorOptions & {
+        ref: PositionTraitElementRef;
+    };
+    placement?: FloatingPositionPlacementOptions & {
+        ref: PositionTraitElementRef;
+    };
+    horizontalAlt?: FloatingPositionAltInput;
+    verticalAlt?: FloatingPositionAltInput;
+};
+/**
+ * Width ot height input values
+ *
+ * - `number`: excact value
+ * - `ElementInput`: element reference, and take the dimension from it
+ * - `link`: take the dimension from the anchor element and only apply on connection dimension.
+ *    eg.: `anchor.link = "left bottom"` and `content.link = "left top"`, in this case only width will be applied.
+ */
+type SizeInputConst = number | ElementInput | "link" | "viewport";
+type SizeInput = SizeInputConst | Observable<SizeInputConst>;
+interface SizeConstraintsInput {
+    minWidth?: SizeInput;
+    maxWidth?: SizeInput;
+    minHeight?: SizeInput;
+    maxHeight?: SizeInput;
+}
+declare class PositionTrait implements FloatingTrait<FloatingPosition> {
+    readonly name = "position";
+    readonly options: Required<PositionTraitOptions>;
+    constructor(options: PositionTraitOptions);
+    connect(floatingRef: FloatingRef<any>): Observable<FloatingPosition>;
+}
+declare function position(options: PositionTraitOptions): PositionTrait;
+
+declare function modal(): (AnimationTrait | BackdropTrait | {
+    readonly name: "close-trigger";
+    readonly options: CloseTriggerOptions;
+    connect(floatingRef: _ngutil_floating.FloatingRef): rxjs.Observable<CloseTriggerEvent | void>;
+} | FocusTrait | PositionTrait)[];
+
+declare class StyleTrait implements FloatingTrait<Partial<CSSStyleDeclaration>> {
+    readonly styles: Partial<CSSStyleDeclaration>;
+    readonly name = "style";
+    constructor(styles: Partial<CSSStyleDeclaration>);
+    connect(floatingRef: FloatingRef): Observable<Partial<CSSStyleDeclaration>>;
+}
+declare function style(styles: Partial<CSSStyleDeclaration>): StyleTrait;
+
+type Attributes = {
+    [key: string]: Primitive;
+} | {
+    dataset: {
+        [key: string]: Primitive;
+    };
+};
+declare class AttributeTrait implements FloatingTrait<Attributes> {
+    readonly attrs: Attributes;
+    readonly name = "attribute";
+    constructor(attrs: Attributes);
+    connect(floatingRef: FloatingRef): Observable<Attributes>;
+}
+declare function attribute(attrs: Attributes): AttributeTrait;
+
+type FloatingTraitInput = FloatingTrait | Array<FloatingTraitInput>;
+declare abstract class FloatingFactory {
+    #private;
+    protected readonly floatingSvc: FloatingService;
+    protected readonly traits: {
+        [key: string]: FloatingTrait;
+    };
+    constructor(floatingSvc: FloatingService);
+    trait(...traits: Array<FloatingTraitInput>): this;
+    show(): Observable<FloatingChannel>;
+    subscribe: Observable<FloatingChannel>["subscribe"];
+    protected providers(providers?: Provider[]): Provider[];
+    protected abstract create(): FloatingRef<FloatingChannel>;
+    position(options: PositionTraitOptions): this;
+    provides(providers: Provider | Provider[]): this;
+}
+declare class FloatingTemplateFactory<T extends object> extends FloatingFactory {
+    readonly tpl: TemplateRef<T>;
+    readonly options: TemplatePortalOptions<T>;
+    constructor(floatingSvc: FloatingService, tpl: TemplateRef<T>, options: TemplatePortalOptions<T>);
+    protected create(): FloatingRef<FloatingChannel>;
+}
+declare class FloatingComponentFactory<T extends ComponentType<any>> extends FloatingFactory {
+    readonly component: T;
+    readonly options: ComponentPortalOptions<T>;
+    constructor(floatingSvc: FloatingService, component: T, options: ComponentPortalOptions<T>);
+    protected create(): FloatingRef<FloatingChannel>;
+}
+/**
+ * @example
+ * ```typescript
+ * class SomeComponent {}
+ *
+ * class SomeList {
+ *      readonly floating = inject(FloatingService)
+ *
+ *      showComponent() {
+ *          this.floating.from(SomeComponent).traits(position(), backdrop()).subscribe()
+ *      }
+ * ```
+ */
+declare class FloatingService {
+    readonly layer: LayerService;
+    from<T extends ComponentType<any>>(component: T, opts?: ComponentPortalOptions<T>): FloatingComponentFactory<T>;
+    from<T extends object>(tpl: TemplateRef<T>, opts?: TemplatePortalOptions<T>): FloatingTemplateFactory<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FloatingService>;
+}
+
+interface ProvideFloatingOptions {
     zIndexStart?: number;
 }
-export declare function provideFloating(options?: ProvideFloatingOptions): Provider[];
+declare function provideFloating(options?: ProvideFloatingOptions): Provider[];
+
+export { AlwaysOnTop, AnimationTrait, AttributeTrait, BackdropRef, BackdropTrait, ChildRef, ComponentPortalRef, ContainerRef, FadeAnimation, FallAnimation, FloatingComponentFactory, FloatingFactory, FloatingRef, FloatingService, FloatingTemplateFactory, FocusTrait, IndividualLayer, LAYER_CONTAINER_ZINDEX_START, LayerContainer, LayerService, PortalRef, PositionTrait, RootLayer, StyleTrait, TRAITS, TemplatePortalRef, attribute, backdrop, closeTrigger, fadeAnimation, fallAnimation, focus, modal, position, provideFloating, rippleRevealAnimation, slideAwayAnimation, slideNearAnimation, style };
+export type { AnimationSet, AnimationTraitParams, Attributes, BackdropOptions, BackdropTraitOptions, ClickOutsideOptions, CloseTriggerEvent, CloseTriggerOptions, ComponentPortalOptions, ContainerOptions, DisposeHandler, FloatingChannel, FloatingTrait, FloatingTraitEvent, FloatingTraitInput, FocusOptions, PortalOptions, PositionTraitElementRef, PositionTraitOptions, ProvideFloatingOptions, TemplatePortalOptions, Traits };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@ngutil/floating",
-  "version": "0.0.102",
+  "version": "0.0.104",
   "dependencies": {
     "tslib": "^2.6.2"
   },
   "peerDependencies": {
-    "@angular/cdk": "19.2.11",
-    "@angular/common": "19.2.8",
-    "@angular/core": "19.2.8",
+    "@angular/cdk": "20.2.14",
+    "@angular/common": "20.3.13",
+    "@angular/core": "20.3.13",
     "es-toolkit": "^1.35.0",
-    "@ngutil/aria": "0.0.102",
-    "@ngutil/common": "0.0.102",
-    "@ngutil/style": "0.0.102"
+    "@ngutil/style": "0.0.104",
+    "@ngutil/aria": "0.0.104",
+    "@ngutil/common": "0.0.104"
   },
   "publishConfig": {
     "access": "public",

package/floating/floating-ref.d.ts

@@ -1,64 +0,0 @@
-import { InjectionToken } from "@angular/core";
-import { Observable, ReplaySubject } from "rxjs";
-import { Lifecycle } from "@ngutil/common";
-import { ContainerRef } from "../layer/container-ref";
-import { LayerService } from "../layer/layer.service";
-import { FloatingTrait } from "./traits/_base";
-import * as i0 from "@angular/core";
-export type Traits = {
-    [key: string]: FloatingTrait;
-};
-export declare const TRAITS: InjectionToken<Traits>;
-export interface FloatingChannel {
-    floatingRef: FloatingRef;
-    type: string;
-    data?: any;
-}
-export interface FloatingTraitEvent {
-    name: string;
-    data: object;
-}
-type TraitState = {
-    [key: string]: FloatingTraitEvent | null;
-};
-export declare class FloatingRef<C extends FloatingChannel = FloatingChannel, T extends HTMLElement = HTMLElement> {
-    #private;
-    readonly layerSvc: LayerService;
-    readonly container: ContainerRef;
-    readonly channel: ReplaySubject<FloatingChannel>;
-    readonly state: Lifecycle<{
-        init: {};
-        showing: {};
-        shown: {};
-        closing: {
-            cancellable: false;
-            order: "sequential";
-        };
-        disposing: {
-            cancellable: false;
-        };
-        disposed: {
-            cancellable: false;
-            order: "sequential";
-        };
-        cleanup: {
-            cancellable: false;
-            order: "sequential";
-        };
-    }, "showing" | "shown" | "disposing" | "disposed" | "init" | "closing" | "cleanup">;
-    readonly traitState$: Observable<TraitState>;
-    readonly uid: string;
-    constructor(layerSvc: LayerService, container: ContainerRef, traits: Traits);
-    show(): Observable<void>;
-    /**
-     * @deprecated
-     */
-    hide(): Observable<void>;
-    close(force?: boolean): Observable<void>;
-    emit(event: Omit<C, "floatingRef">): void;
-    setResult(data: any): void;
-    watchTrait<T>(name: string): Observable<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingRef<any, any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FloatingRef<any, any>>;
-}
-export {};

package/floating/floating.service.d.ts

@@ -1,57 +0,0 @@
-import { ComponentType } from "@angular/cdk/portal";
-import { Provider, TemplateRef } from "@angular/core";
-import { Observable } from "rxjs";
-import { LayerService } from "../layer/layer.service";
-import { ComponentPortalOptions, TemplatePortalOptions } from "../layer/portal-ref";
-import { FloatingChannel, FloatingRef } from "./floating-ref";
-import { type FloatingTrait } from "./traits/_base";
-import { type PositionTraitOptions } from "./traits/position";
-import * as i0 from "@angular/core";
-export type FloatingTraitInput = FloatingTrait | Array<FloatingTraitInput>;
-export declare abstract class FloatingFactory {
-    #private;
-    protected readonly floatingSvc: FloatingService;
-    protected readonly traits: {
-        [key: string]: FloatingTrait;
-    };
-    constructor(floatingSvc: FloatingService);
-    trait(...traits: Array<FloatingTraitInput>): this;
-    show(): Observable<FloatingChannel>;
-    subscribe: Observable<FloatingChannel>["subscribe"];
-    protected providers(providers?: Provider[]): Provider[];
-    protected abstract create(): FloatingRef<FloatingChannel>;
-    position(options: PositionTraitOptions): this;
-    provides(providers: Provider | Provider[]): this;
-}
-export declare class FloatingTemplateFactory<T extends object> extends FloatingFactory {
-    readonly tpl: TemplateRef<T>;
-    readonly options: TemplatePortalOptions<T>;
-    constructor(floatingSvc: FloatingService, tpl: TemplateRef<T>, options: TemplatePortalOptions<T>);
-    protected create(): FloatingRef<FloatingChannel>;
-}
-export declare class FloatingComponentFactory<T extends ComponentType<any>> extends FloatingFactory {
-    readonly component: T;
-    readonly options: ComponentPortalOptions<T>;
-    constructor(floatingSvc: FloatingService, component: T, options: ComponentPortalOptions<T>);
-    protected create(): FloatingRef<FloatingChannel>;
-}
-/**
- * @example
- * ```typescript
- * class SomeComponent {}
- *
- * class SomeList {
- *      readonly floating = inject(FloatingService)
- *
- *      showComponent() {
- *          this.floating.from(SomeComponent).traits(position(), backdrop()).subscribe()
- *      }
- * ```
- */
-export declare class FloatingService {
-    readonly layer: LayerService;
-    from<T extends ComponentType<any>>(component: T, opts?: ComponentPortalOptions<T>): FloatingComponentFactory<T>;
-    from<T extends object>(tpl: TemplateRef<T>, opts?: TemplatePortalOptions<T>): FloatingTemplateFactory<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FloatingService>;
-}

package/floating/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./traits";
-export * from "./floating-ref";
-export * from "./floating.service";

package/floating/traits/_base.d.ts

@@ -1,6 +0,0 @@
-import { Observable } from "rxjs";
-import type { FloatingRef } from "../floating-ref";
-export interface FloatingTrait<T = any> {
-    readonly name: string;
-    connect(floatingRef: FloatingRef<any>): Observable<T>;
-}

package/floating/traits/animation.d.ts

@@ -1,30 +0,0 @@
-import { AnimationMetadata } from "@angular/animations";
-import { Observable } from "rxjs";
-import { FloatingPosition, Position } from "@ngutil/style";
-import { FloatingRef } from "../floating-ref";
-import { FloatingTrait } from "./_base";
-export type AnimationSet = {
-    show: AnimationMetadata[];
-    hide: AnimationMetadata[];
-};
-export type AnimationTraitParams = (position: FloatingPosition) => object;
-export declare class AnimationTrait implements FloatingTrait<unknown> {
-    readonly animation: AnimationSet;
-    readonly params?: AnimationTraitParams | undefined;
-    readonly name = "animation";
-    constructor(animation: AnimationSet, params?: AnimationTraitParams | undefined);
-    connect(floatingRef: FloatingRef): Observable<unknown>;
-}
-export declare const FallAnimation: AnimationSet;
-export declare function fallAnimation(scale?: number): AnimationTrait;
-export declare const FadeAnimation: AnimationSet;
-export declare function fadeAnimation(): AnimationTrait;
-export declare function slideNearAnimation(size?: number): AnimationTrait;
-export declare function slideAwayAnimation(size?: number): AnimationTrait;
-type RippleRevealAnimationOptions = {
-    origin: Position;
-    initialRadius?: number;
-    duration?: number;
-};
-export declare function rippleRevealAnimation(options: RippleRevealAnimationOptions): AnimationTrait;
-export {};

package/floating/traits/attribute.d.ts

@@ -1,18 +0,0 @@
-import { Observable } from "rxjs";
-import { Primitive } from "utility-types";
-import { FloatingRef } from "../floating-ref";
-import { FloatingTrait } from "./_base";
-export type Attributes = {
-    [key: string]: Primitive;
-} | {
-    dataset: {
-        [key: string]: Primitive;
-    };
-};
-export declare class AttributeTrait implements FloatingTrait<Attributes> {
-    readonly attrs: Attributes;
-    readonly name = "attribute";
-    constructor(attrs: Attributes);
-    connect(floatingRef: FloatingRef): Observable<Attributes>;
-}
-export declare function attribute(attrs: Attributes): AttributeTrait;

package/floating/traits/backdrop.d.ts

@@ -1,16 +0,0 @@
-import { Observable } from "rxjs";
-import { CoverOptions } from "@ngutil/graphics";
-import { BackdropRef } from "../../layer";
-import { type FloatingRef } from "../floating-ref";
-import { FloatingTrait } from "./_base";
-interface CommonOptions {
-}
-export type BackdropTraitOptions = CoverOptions & CommonOptions;
-export declare class BackdropTrait implements FloatingTrait<BackdropRef> {
-    readonly options: BackdropTraitOptions;
-    readonly name = "backdrop";
-    constructor(options: BackdropTraitOptions);
-    connect(floatingRef: FloatingRef<any>): Observable<BackdropRef>;
-}
-export declare function backdrop(options: BackdropTraitOptions): BackdropTrait;
-export {};

package/floating/traits/close-trigger.d.ts

@@ -1,35 +0,0 @@
-import { Observable, ObservableInput } from "rxjs";
-import { ElementInput } from "@ngutil/common";
-import { FloatingRef } from "../floating-ref";
-import { FloatingTrait } from "./_base";
-export interface ClickOutsideOptions {
-    /**
-     * If clicks happened on this element, that not trigger the close event
-     */
-    allowedElements?: ElementInput[];
-}
-export interface CloseTriggerOptions {
-    /**
-     * Close floating when click outside of floating element
-     */
-    clickOutside?: boolean | ClickOutsideOptions;
-    /**
-     * Only works when the floating element is focused
-     */
-    keystroke?: boolean;
-    /**
-     * Close when emitting any value
-     */
-    trigger?: ObservableInput<any>;
-}
-export interface CloseTriggerEvent {
-    source: "click" | "keystroke" | "backbutton" | "trigger";
-}
-declare class CloseTriggerTrait implements FloatingTrait {
-    readonly options: CloseTriggerOptions;
-    readonly name = "close-trigger";
-    constructor(options?: CloseTriggerOptions);
-    connect(floatingRef: FloatingRef): Observable<CloseTriggerEvent | void>;
-}
-export declare function closeTrigger(options?: CloseTriggerOptions): CloseTriggerTrait;
-export {};