@telesign/boreal-web-components 0.1.0-alpha.0

package/dist/types/mixins/anchored.mixin.d.ts

@@ -0,0 +1,228 @@
+import { IFloatingAdapter, PositioningEngine } from "../services/floating/positioning.service";
+import { MixedInCtor } from '../stencil-public-runtime';
+import { Logger } from "../services/logger/Logger";
+import { FloatingMixinOptions } from "../services/floating/interfaces/Floating";
+/**
+ * Positioning and trigger mixin for anchor-based floating elements.
+ *
+ * Extends `floatingMixin` with two additional responsibilities:
+ * - **Positioning** — computes and maintains the position of the floating element
+ *   relative to a trigger element using `IFloatingAdapter` (wraps Floating UI).
+ *   Position is kept in sync via `autoUpdate` while the element is visible.
+ * - **Triggers** — manages DOM event listeners on the trigger element
+ *   (focus/blur, click) to show and hide the floating element.
+ *
+ * Use this mixin for components whose floating element must be anchored
+ * to a specific DOM element: `Tooltip`, `Popover`, `Dropdown`.
+ *
+ * For viewport-relative components (Dialog, Drawer, Toast),
+ * use `backdropMixin` instead.
+ *
+ * ## Lifecycle flow
+ * ```
+ * showElement() → showPopover() + startAutoUpdate()
+ * hideElement() → hidePopover() + stopAutoUpdate()
+ * ```
+ *
+ * ## Required by the component
+ * - `triggerSlot` — must be assigned to the trigger element before `show()` is called.
+ * - `floatingContent` — must be assigned via `ref` in the render method.
+ * - `options` — override this getter to customize placement, offset and strategy.
+ *
+ * @example
+ * ```typescript
+ * import { Component, Element, Mixin, Prop, h } from '../stencil-public-runtime';
+ * import { anchoredMixin } from '@/mixins/anchored.mixin';
+ * import { FloatingHooks, FloatingMixinOptions } from '@/services/floating/interfaces/Floating';
+ *
+ * @Component({ tag: 'bds-tooltip' })
+ * export class BdsTooltip extends Mixin(anchoredMixin) {
+ *
+ *   get options(): FloatingMixinOptions {
+ *     return { placement: 'bottom', offset: 8, strategy: 'fixed' };
+ *   }
+ *
+ *   get hooks(): FloatingHooks {
+ *     return {
+ *       onBeforeShow: () => !this.disabled,
+ *       onPositionUpdate: result => this.handlePosition(result),
+ *     };
+ *   }
+ *
+ *   componentDidLoad() {
+ *     const trigger = document.getElementById(this.trigger);
+ *     if (trigger) {
+ *       this.triggerSlot = trigger;
+ *       trigger.addEventListener('click', () => this.toggle());
+ *     }
+ *   }
+ *
+ *   render() {
+ *     return (
+ *       <Host>
+ *         <div
+ *           popover="manual"
+ *           ref={el => (this.floatingContent = el as HTMLElement)}
+ *         />
+ *       </Host>
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * @see floatingMixin - base lifecycle mixin
+ * @see IFloatingAdapter - positioning adapter interface
+ * @see FloatingMixinOptions - positioning configuration interface
+ * @see FloatingHooks - lifecycle hook interface, includes `onPositionUpdate`
+ */
+export declare const anchoredMixin: <B extends MixedInCtor>(Base: B) => {
+    new (...args: any[]): {
+        /**
+         * The previously registered trigger element.
+         * Used to detach listeners when the trigger changes.
+         */
+        previousTrigger: HTMLElement | undefined;
+        /**
+         * Cleanup function returned by `autoUpdate`.
+         * Call to stop position syncing when the element is hidden or disconnected.
+         */
+        cleanupAutoUpdate: (() => void) | undefined;
+        /**
+         * Adapter that wraps Floating UI to compute and apply positions.
+         * Initialized in `componentWillLoad`.
+         */
+        positionEngine: IFloatingAdapter;
+        /**
+         * Logger instance for error reporting.
+         * Initialized in `componentWillLoad`.
+         */
+        logger: Logger;
+        /**
+         * Default positioning options.
+         * Override this getter in the component to customize placement,
+         * offset, strategy, flip, shift, and arrow.
+         */
+        readonly options: FloatingMixinOptions;
+        /**
+         * Reference to the DOM element that triggers the floating element.
+         * Must be assigned by the component before `show()` is called —
+         * either via slot change handler or `componentDidLoad`.
+         */
+        triggerSlot: HTMLElement;
+        /**
+         * Shows the floating element using the Popover API
+         * and starts position auto-update relative to `triggerSlot`.
+         *
+         * @override floatingMixin.showElement
+         */
+        showElement(): void;
+        /**
+         * Guards against showing without a valid trigger.
+         * Delegates to `floatingMixin.onBeforeShow` if the guard passes.
+         *
+         * @override floatingMixin.onBeforeShow
+         * @param target - Optional element that triggered the show action
+         * @returns `false` if `triggerSlot` is not set, otherwise delegates to super
+         */
+        onBeforeShow(target?: HTMLElement): boolean;
+        /**
+         * Hides the floating element using the Popover API
+         * and stops position auto-update.
+         *
+         * @override floatingMixin.hideElement
+         */
+        hideElement(): void;
+        /**
+         * Handles slot change events to update the trigger element reference
+         * and re-attach event listeners to the new trigger.
+         *
+         * @param e - The slot change event
+         * @param showFn - Bound show function to attach as listener
+         * @param hideFn - Bound hide function to attach as listener
+         */
+        handleSlotChange(e: Event, showFn: (this: void) => void, hideFn: (this: void) => void): void;
+        /**
+         * Handles keyboard events on the trigger element.
+         * - `Enter` / `Space` — shows the floating element
+         * - `Escape` — hides the floating element
+         *
+         * @param e - The keyboard event
+         * @param showFn - Bound show function
+         * @param hideFn - Bound hide function
+         */
+        handleKeydown(e: KeyboardEvent, showFn: (this: void) => void, hideFn: (this: void) => void): void;
+        /**
+         * Computes the position of the floating element relative to the trigger
+         * using `IFloatingAdapter` and applies the result to the floating element's style.
+         *
+         * @param triggerElement - The anchor element
+         * @param floatingElement - The element to position
+         * @param options - Positioning options (placement, offset, flip, shift, arrow)
+         * @param onPositionUpdate - Optional callback invoked after each position update
+         */
+        updatePosition(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: (result: Awaited<ReturnType<PositioningEngine["computePosition"]>>) => void): Promise<import("../services/floating/interfaces/Positioning").PositioningResult>;
+        /**
+         * Starts automatic position synchronization between the trigger
+         * and the floating element. Runs `updatePosition` once immediately,
+         * then subscribes to DOM/scroll/resize changes via `autoUpdate`.
+         *
+         * @param triggerElement - The anchor element
+         * @param floatingElement - The element to keep in sync
+         * @param options - Positioning options
+         * @param onPositionUpdate - Optional callback after each position update
+         */
+        startAutoUpdate(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: Parameters<(triggerElement: HTMLElement, floatingElement: HTMLElement, options: FloatingMixinOptions, onPositionUpdate?: (result: Awaited<ReturnType<PositioningEngine["computePosition"]>>) => void) => Promise<import("../services/floating/interfaces/Positioning").PositioningResult>>[3]): void;
+        /**
+         * Stops automatic position synchronization and clears the cleanup reference.
+         */
+        stopAutoUpdate(): void;
+        /**
+         * Attaches focus and blur listeners to the trigger element.
+         *
+         * @param trigger - The trigger element
+         * @param showFn - Bound show function
+         * @param hideFn - Bound hide function
+         */
+        attachTriggerListeners(trigger: HTMLElement, showFn: (this: void) => void, hideFn: (this: void) => void): void;
+        /**
+         * Detaches focus and blur listeners from the trigger element.
+         *
+         * @param trigger - The trigger element
+         * @param showFn - Bound show function to remove
+         * @param hideFn - Bound hide function to remove
+         */
+        detachTriggerListeners(trigger: HTMLElement, showFn: (this: void) => void, hideFn: (this: void) => void): void;
+        /**
+         * Detaches trigger listeners and stops auto-update.
+         * Call this when the component disconnects from the DOM.
+         *
+         * @param showFn - Bound show function to remove
+         * @param hideFn - Bound hide function to remove
+         */
+        floatingDisconnect(showFn: (this: void) => void, hideFn: (this: void) => void): void;
+        /**
+         * Initializes the positioning engine, logger, and binds lifecycle methods
+         * so they can be safely passed as event listener callbacks.
+         *
+         * @remarks `show`, `hide`, and `toggle` are bound here — not in `floatingMixin` —
+         * to ensure they resolve to the `anchoredMixin` overrides at call time.
+         */
+        componentWillLoad(): void;
+        /**
+         * Cleans up trigger listeners, stops auto-update, and hides the floating element
+         * when the component is removed from the DOM.
+         */
+        disconnectedCallback(): void;
+        floatingOptions: import("../services/floating/interfaces/Props").FloatingAnchoredProp;
+        floatingContent: HTMLElement;
+        isVisible: boolean;
+        readonly hooks: import("@/services/floating/interfaces/Floating").FloatingHooks;
+        onBeforeHide(target?: HTMLElement): boolean;
+        show(target?: HTMLElement): void;
+        hide(target?: HTMLElement): void;
+        toggle(target?: HTMLElement): void;
+        onAfterShow(target?: HTMLElement): void;
+        onAfterHide(target?: HTMLElement): void;
+    };
+} & B;
+//# sourceMappingURL=anchored.mixin.d.ts.map

package/dist/types/mixins/floating.mixin.d.ts

@@ -0,0 +1,158 @@
+import { FloatingHooks } from "../services/floating/interfaces/Floating";
+import { FloatingAnchoredProp } from "../services/floating/interfaces/Props";
+import { MixedInCtor } from '../stencil-public-runtime';
+/**
+ * Core lifecycle mixin for all floating elements in the design system.
+ *
+ * Provides a unified lifecycle contract (`show`, `hide`, `toggle`, `isVisible`)
+ * and an extension mechanism via `FloatingHooks` that allows each component
+ * to inject its own logic at specific lifecycle points without modifying the mixin.
+ *
+ * This mixin is the base for all floating components. It does not handle
+ * positioning or triggers — use `anchoredMixin` for components that need
+ * to be anchored to a DOM element (Tooltip, Popover),
+ * or `backdropMixin` for viewport-relative components (Dialog, Drawer, Toast).
+ *
+ * ## Extension points
+ *
+ * Override `showElement` / `hideElement` to control how the element
+ * mounts and unmounts (e.g. `showPopover()`, `showModal()`, CSS animations).
+ *
+ * Override `hooks` to inject logic at lifecycle points:
+ * - `onBeforeShow` / `onBeforeHide` — return `false` to cancel the action
+ * - `onAfterShow` / `onAfterHide` — side effects after the action completes
+ * - `mounted` / `unmounted` — called after the element is shown or hidden
+ *
+ * ## Lifecycle flow
+ * ```
+ * show(): onBeforeShow() → showElement() → onAfterShow()
+ * hide(): onBeforeHide() → hideElement() → onAfterHide()
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { Component, Mixin, Prop } from '../stencil-public-runtime';
+ * import { floatingMixin } from '@/mixins/floating.mixin';
+ * import { FloatingHooks } from '@/services/floating/interfaces/Floating';
+ *
+ * @Component({ tag: 'bds-dialog' })
+ * export class BdsDialog extends Mixin(floatingMixin) {
+ *   private dialogElement!: HTMLDialogElement;
+ *
+ *   // Override showElement/hideElement to use the native <dialog> API
+ *   showElement(): void {
+ *     this.dialogElement.showModal();
+ *     this.isVisible = true;
+ *   }
+ *   hideElement(): void {
+ *     this.dialogElement.close();
+ *     this.isVisible = false;
+ *   }
+ *
+ *   // Inject component-specific logic via hooks
+ *   get hooks(): FloatingHooks {
+ *     return {
+ *       onBeforeShow: () => !this.disabled,
+ *       onAfterShow: () => this.lockScroll(),
+ *       onAfterHide: () => this.unlockScroll(),
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export declare const floatingMixin: <B extends MixedInCtor>(Base: B) => {
+    new (...args: any[]): {
+        /**
+         * Configuration prop passed by the consumer component.
+         * Allows external control over lifecycle hooks and floating behavior.
+         */
+        floatingOptions: FloatingAnchoredProp;
+        /**
+         * Reference to the floating element in the DOM.
+         * Must be assigned via `ref` in the component's render method.
+         *
+         * @example
+         * ```tsx
+         * <div ref={el => (this.floatingContent = el as HTMLElement)} />
+         * ```
+         */
+        floatingContent: HTMLElement;
+        /**
+         * Tracks the visibility state of the floating element.
+         * Triggers a re-render when changed.
+         */
+        isVisible: boolean;
+        /**
+         * Lifecycle hooks provided by the component.
+         * Override this getter to inject component-specific logic
+         * into the floating lifecycle without modifying the mixin.
+         *
+         * @returns FloatingHooks — an object with optional lifecycle callbacks
+         */
+        readonly hooks: FloatingHooks;
+        /**
+         * Called before the element is shown.
+         * Aggregates both the component `hooks` and `floatingOptions` controls.
+         * If either returns `false`, the show action is cancelled.
+         *
+         * @param target - Optional element that triggered the show action
+         * @returns `true` if the element can be shown, `false` to cancel
+         */
+        onBeforeShow(target?: HTMLElement): boolean;
+        /**
+         * Called before the element is hidden.
+         * Aggregates both the component `hooks` and `floatingOptions` controls.
+         * If either returns `false`, the hide action is cancelled.
+         *
+         * @param target - Optional element the mouse moved to (used for stayOnHover logic)
+         * @returns `true` if the element can be hidden, `false` to cancel
+         */
+        onBeforeHide(target?: HTMLElement): boolean;
+        /**
+         * Mounts the floating element into the visible DOM.
+         * Override in subclasses to use a different mount strategy
+         * (e.g. `showPopover()`, `showModal()`, CSS class toggle).
+         */
+        showElement(): void;
+        /**
+         * Unmounts the floating element from the visible DOM.
+         * Override in subclasses to use a different unmount strategy.
+         */
+        hideElement(): void;
+        /**
+         * Shows the floating element if not already visible.
+         * Runs the full lifecycle: `onBeforeShow` → `showElement` → `onAfterShow`.
+         *
+         * @param target - Optional element that triggered the action
+         */
+        show(target?: HTMLElement): void;
+        /**
+         * Hides the floating element if currently visible.
+         * Runs the full lifecycle: `onBeforeHide` → `hideElement` → `onAfterHide`.
+         *
+         * @param target - Optional element the mouse moved to
+         */
+        hide(target?: HTMLElement): void;
+        /**
+         * Toggles the floating element visibility.
+         *
+         * @param target - Optional element that triggered the action
+         */
+        toggle(target?: HTMLElement): void;
+        /**
+         * Called after the element is shown.
+         * Notifies both `hooks` and `floatingOptions` consumers.
+         *
+         * @param target - Optional element that triggered the action
+         */
+        onAfterShow(target?: HTMLElement): void;
+        /**
+         * Called after the element is hidden.
+         * Notifies both `hooks` and `floatingOptions` consumers.
+         *
+         * @param target - Optional element that triggered the action
+         */
+        onAfterHide(target?: HTMLElement): void;
+    };
+} & B;
+//# sourceMappingURL=floating.mixin.d.ts.map

package/dist/types/mixins/form-associated.mixin.d.ts

@@ -0,0 +1,127 @@
+import { type EventEmitter, type MixedInCtor } from '../stencil-public-runtime';
+/**
+ * Lifecycle callbacks that each Form-Associated Custom Element must implement.
+ *
+ * These callbacks stay outside `formAssociatedMixin` because value semantics
+ * differ per component (for example default value and restore behavior).
+ *
+ * Implement this interface on every component that extends `formAssociatedMixin`.
+ *
+ * @example
+ * ```typescript
+ * import { AttachInternals, Component, Event, EventEmitter, Mixin, Prop } from '../stencil-public-runtime';
+ *
+ * import { setFormValue } from '@/utils/form';
+ * import { formAssociatedMixin, type IFormControl } from '@/mixins/form-associated.mixin';
+ *
+ * @Component({ tag: 'bds-text-field', formAssociated: true })
+ * export class BdsTextField extends Mixin(formAssociatedMixin) implements ITextField, IFormControl<string> {
+ *   @AttachInternals() internals!: ElementInternals;
+ *
+ *   @Prop({ mutable: true, reflect: true }) value: string = '';
+ *
+ *   @Event() valueChange!: EventEmitter<string>;
+ *
+ *   public formAssociatedCallback(): void {
+ *     setFormValue(this.internals, this.value);
+ *   }
+ *
+ *   public formResetCallback(): void {
+ *     this.value = '';
+ *     setFormValue(this.internals, null);
+ *   }
+ *
+ *   public formStateRestoreCallback(state: unknown, _mode: string): void {
+ *     this.value = typeof state === 'string' ? state : '';
+ *     setFormValue(this.internals, this.value);
+ *   }
+ * }
+ * ```
+ */
+export interface IFormAssociatedCallbacks {
+    /**
+     * Called when the component becomes associated with a form, or when its
+     * `form` attribute changes.
+     */
+    formAssociatedCallback(): void;
+    /**
+     * Called when the parent form is reset via `form.reset()`.
+     */
+    formResetCallback(): void;
+    /**
+     * Called when the browser restores form state (e.g. back/forward navigation).
+     *
+     * @param state - The previously saved form value for this component.
+     * @param mode - Either `'restore'` (autofill) or `'autocomplete'`.
+     */
+    formStateRestoreCallback(state: unknown, mode: string): void;
+}
+/**
+ * Contract for form controls that support 2-way binding.
+ *
+ * Implement this interface on every component that extends `formAssociatedMixin`
+ * and owns a `value` prop. The `valueChange` event name is the convention picked
+ * up by `@stencil/vue-output-target`'s `componentModels` config to generate
+ * `v-model` support automatically.
+ *
+ * @typeParam T - The type of the value emitted (e.g. `string`, `boolean`, `string[]`).
+ *
+ * @example
+ * ```typescript
+ * export class BdsTextField extends Mixin(formAssociatedMixin) implements IFormControl<string> {
+ *   @Event() valueChange!: EventEmitter<string>;
+ * }
+ * ```
+ */
+export interface IFormValueEmitter<T> {
+    /**
+     * Emitted whenever the component's value changes.
+     * Used by framework output targets to wire up 2-way binding (e.g. `v-model` in Vue).
+     */
+    valueChange: EventEmitter<T>;
+}
+/**
+ * Composite contract for a fully-featured Boreal DS form control.
+ *
+ * Extends both `IFormAssociatedCallbacks` (lifecycle hooks) and
+ * `IFormValueEmitter<T>` (2-way binding event) into a single interface
+ * so component class declarations stay concise.
+ *
+ * @typeParam T - The type of the value this control works with.
+ *
+ * @example
+ * ```typescript
+ * export class BdsTextField extends Mixin(formAssociatedMixin) implements ITextField, IFormControl<string> {
+ * ```
+ */
+export interface IFormControl<T> extends IFormAssociatedCallbacks, IFormValueEmitter<T> {
+}
+/**
+ * Shared base mixin for Form-Associated Custom Elements in Boreal DS.
+ *
+ * Provides:
+ * - `name`, `disabled`, and `required` form props
+ * - `formDisabledCallback` with universal disabled sync behavior
+ *
+ * Each component must declare `@AttachInternals() internals!: ElementInternals`
+ * directly on its class body — Stencil's compiler requires this decorator to be
+ * statically visible on the component class, not inside a mixin factory.
+ *
+ * Components must also implement `IFormControl<T>` for value registration,
+ * reset, state restoration, and 2-way binding event emission.
+ */
+export declare const formAssociatedMixin: <B extends MixedInCtor>(Base: B) => {
+    new (...args: any[]): {
+        /** Name of the form control, submitted as a key in the form data. */
+        readonly name: string;
+        /** Disables the control. Synced automatically from a parent `<fieldset>` or `<form>` via `formDisabledCallback`. */
+        readonly disabled: boolean;
+        /** Marks the control as required for form submission. */
+        readonly required: boolean;
+        /**
+         * Sync component disabled state with parent form disabled state.
+         */
+        formDisabledCallback(disabled: boolean): void;
+    };
+} & B;
+//# sourceMappingURL=form-associated.mixin.d.ts.map

package/dist/types/mixins/index.d.ts

@@ -0,0 +1,4 @@
+export * from './form-associated.mixin';
+export * from './floating.mixin';
+export * from './anchored.mixin';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/services/floating/interfaces/Floating.d.ts

@@ -0,0 +1,38 @@
+import { Placement, Strategy } from '@floating-ui/dom';
+import { PositioningResult } from './Positioning';
+import { FloatingAnchoredProp } from './Props';
+/**
+ * Add methods to the `onBeforeShow`, `onAfterShow`, `onBeforeHide`, and `onAfterHide` to add custom logic.
+ * Pass the element to the method to get the reference to the floating element.
+ */
+export interface FloatingHooks {
+    onAfterShow?: (el?: HTMLElement) => void;
+    onBeforeHide?: (el?: HTMLElement) => boolean;
+    onBeforeShow?: (el?: HTMLElement) => boolean;
+    onAfterHide?: (el?: HTMLElement) => void;
+    mounted?: (el?: HTMLElement) => void;
+    unmounted?: (el?: HTMLElement) => void;
+    onPositionUpdate?: (result: PositioningResult) => void;
+}
+/**
+ * Define the possible options for comunication with the Floating UI library.
+ * Could define how the floating element and arrow will be positioned.
+ */
+export interface FloatingMixinOptions {
+    offset?: number;
+    placement?: Placement;
+    flip?: boolean;
+    shift?: boolean;
+    arrow?: HTMLElement;
+    strategy?: Strategy;
+}
+/**
+ * Implements the hooks and expose the options and hooks to the mixin.
+ * The mixin could provide a getter to able the developer override values.
+ */
+export interface IFloatingMixin extends FloatingHooks {
+    floatingOptions: FloatingAnchoredProp;
+    get options(): FloatingMixinOptions;
+    get hooks(): FloatingHooks;
+}
+//# sourceMappingURL=Floating.d.ts.map

package/dist/types/services/floating/interfaces/Positioning.d.ts

@@ -0,0 +1,22 @@
+import { MiddlewareData, Placement, Strategy } from '@floating-ui/dom';
+/**
+ * Define the possible options to communicate with Floating UI library.
+ */
+export interface PositioningOptions {
+    placement?: Placement;
+    offset?: number;
+    flip?: boolean;
+    shift?: boolean;
+    arrow?: HTMLElement | null;
+    strategy?: Strategy;
+}
+/**
+ * Define the result of the positioning engine. Have the position and the placemen and additional data to define it behavior.
+ */
+export interface PositioningResult {
+    x: number;
+    y: number;
+    placement: Placement;
+    middlewareData: MiddlewareData;
+}
+//# sourceMappingURL=Positioning.d.ts.map

package/dist/types/services/floating/interfaces/Props.d.ts

@@ -0,0 +1,35 @@
+import { Position } from "../../../types/position";
+import { Arrow } from '../types/Arrow';
+import { FloatingHooks, FloatingMixinOptions } from './Floating';
+/**
+ * Interface to define the possible options as props for the floating mixin.
+ * Each floating component extends this interface to add custom logic.
+ * Each of this attributes could be added in "floatingOptions" prop of each component.
+ */
+export interface FloatingProp extends FloatingHooks, FloatingMixinOptions {
+}
+/**
+ * Interface to define the possible options for the anchored components.
+ * Extends the `FloatingProp` interface to able the developer to add custom logic.
+ * Add placement prop to define the position of the anchored element.
+ */
+export interface FloatingAnchoredProp extends FloatingProp, Arrow {
+    placement?: Position;
+}
+/**
+ * Interface to define the possible options for the tooltip components.
+ * Add stayOnHover prop to prevent the tooltip to hide when the mouse is not over the trigger element.
+ */
+export interface FloatingTooltipProp extends FloatingAnchoredProp {
+    stayOnHover?: boolean;
+}
+/**
+ * Interface to define the possible options for the popover components.
+ * add closeOnClick prop to close the popover when the trigger element is clicked.
+ * add clickOutside prop to close the popover when the user click outside the popover.
+ */
+export interface FloatingPopoverProp extends FloatingAnchoredProp {
+    closeOnClick?: boolean;
+    clickOutside?: boolean;
+}
+//# sourceMappingURL=Props.d.ts.map

package/dist/types/services/floating/positioning.service.d.ts

@@ -0,0 +1,45 @@
+import { PositioningOptions, PositioningResult } from './interfaces/Positioning';
+import { ILogger } from '../logger/Logger';
+/**
+ * Adapter class to handle the positioning logic.
+ * This class is responsible for computing the position of the floating element and connect with the Floating UI library.
+ *
+ * All logic refered to the Floating UI library is encapsulated in this class.
+ *
+ * If you need add some Floating UI logic you can add a new methods to this class.
+ */
+export interface IFloatingAdapter {
+    computePosition(reference: HTMLElement | null, floating: HTMLElement | null, options: PositioningOptions): Promise<PositioningResult>;
+    applyPosition(element: HTMLElement, result: PositioningResult): void;
+}
+declare class FloatingAdapter implements IFloatingAdapter {
+    private readonly logger;
+    /**
+     * Constructor of the adapter.
+     * @param logger Inject the logger service to normalize the error messages.
+     */
+    constructor(logger: ILogger);
+    /**
+     *  Compute the position of the floating element making it responsive to the reference element.
+     * @param {HTMLElement} reference The reference element to position the floating element. Could be a trigger element or a container.
+     * @param {HTMLElement} floating The floating element to position, Will be positioned relative to the reference element.
+     * @param {PositioningOptions} options Manage the logic of the positioning and some props that are own of the Floating UI library.
+     * @returns {Promise<PositioningResult>} The positioning result with the position and the placement.
+     */
+    computePosition(reference: HTMLElement | null, floating: HTMLElement | null, options: PositioningOptions): Promise<PositioningResult>;
+    /**
+     * Apply the position of the floating element to the element.
+     * @param {HTMLElement} element Is the floating element to apply the position.
+     * @param {PositioningResult} result Is the positioning result with the position and the placement.
+     */
+    applyPosition(element: HTMLElement, result: PositioningResult): void;
+}
+/**
+ * Export a simple class to use the adapter.
+ * This class is responsible for handling the positioning logic exported to the mixin or some other floating logic.
+ */
+export declare class PositioningEngine extends FloatingAdapter {
+    constructor();
+}
+export {};
+//# sourceMappingURL=positioning.service.d.ts.map

package/dist/types/services/floating/types/Arrow.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Includes any attribute that could be used to modify the arrow.
+ */
+export interface Arrow {
+    hideArrow?: boolean;
+}
+//# sourceMappingURL=Arrow.d.ts.map