@lucca-front/ng 19.3.3 → 20.0.0

package/popover/index.d.ts

@@ -1,5 +1,440 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnDestroy, EventEmitter, ElementRef, ViewContainerRef, AfterViewInit } from '@angular/core';
+import * as i2 from '@angular/cdk/overlay';
+import { OverlayRef, HorizontalConnectionPos, VerticalConnectionPos, Overlay, OverlayConfig, FlexibleConnectedPositionStrategy } from '@angular/cdk/overlay';
+import { Observable, Subscription, Subject } from 'rxjs';
+import { Direction } from '@angular/cdk/bidi';
+import { TemplatePortal, ComponentPortal } from '@angular/cdk/portal';
+
+declare const luTransformPopover: AnimationTriggerMetadata;
+
+type LuPopoverScrollStrategy = 'reposition' | 'block' | 'close';
+declare interface ILuPopoverPanel<T = unknown> {
+    scrollStrategy: LuPopoverScrollStrategy;
+    closeOnClick: boolean;
+    panelId?: string;
+    triggerId?: string;
+    templateRef?: TemplateRef<T>;
+    overlayRef: OverlayRef;
+    /** will emit when the panel wants to close */
+    close: Observable<void>;
+    /** will emit when the panel wants to open */
+    open: Observable<void>;
+    /** will emit when the panel is hovered */
+    hovered: Observable<boolean>;
+    /** classes to apply to the panel, uses ' ' for separating values */
+    panelClasses: string;
+    /** class to apply to the panel content, uses ' ' for separating values */
+    contentClasses: string;
+    keydownEvents$: Observable<KeyboardEvent>;
+    setPositionClasses: (posX: HorizontalConnectionPos, posY: VerticalConnectionPos) => void;
+    /** method called by the trigger when it opens the popover */
+    onOpen(): void;
+    /** method called by the trigger when it closes the popover */
+    onClose(): void;
+}
 /**
- * Generated bundle index. Do not edit.
+ * abstract class for basic implementation of a popover panel
  */
-/// <amd-module name="@lucca-front/ng/popover" />
-export * from './public-api';
+declare abstract class ALuPopoverPanel<T = unknown> implements ILuPopoverPanel<T> {
+    panelId: string;
+    triggerId: string;
+    protected _isOpen: boolean;
+    get isOpen(): boolean;
+    protected _closeOnClick: boolean;
+    get closeOnClick(): boolean;
+    set closeOnClick(coc: boolean);
+    protected _trapFocus: boolean;
+    get trapFocus(): boolean;
+    set trapFocus(tf: boolean);
+    protected _scrollStrategy: LuPopoverScrollStrategy;
+    get scrollStrategy(): LuPopoverScrollStrategy;
+    set scrollStrategy(ss: LuPopoverScrollStrategy);
+    protected _templateRef: TemplateRef<T>;
+    get templateRef(): TemplateRef<T>;
+    set templateRef(tr: TemplateRef<T>);
+    protected _positionClassesMap: Record<string, boolean>;
+    protected _panelClasses: string;
+    get panelClasses(): string;
+    set panelClasses(cl: string);
+    get panelClassesMap(): Record<string, boolean>;
+    protected _contentClasses: string;
+    get contentClasses(): string;
+    set contentClasses(cl: string);
+    get contentClassesMap(): Record<string, boolean>;
+    overlayRef: OverlayRef;
+    /** Classes to be passed into the popover's overlay */
+    protected _overlayPaneClass: string | string[];
+    get overlayPaneClass(): string | string[];
+    set overlayPaneClass(opc: string | string[]);
+    protected _keydownEventsSub: Subscription;
+    set keydownEvents$(evt$: Observable<KeyboardEvent>);
+    close: Observable<void>;
+    open: Observable<void>;
+    hovered: Observable<boolean>;
+    abstract _emitCloseEvent(): void;
+    abstract _emitOpenEvent(): void;
+    abstract _emitHoveredEvent(hovered: boolean): void;
+    setPositionClasses(posX: HorizontalConnectionPos, posY: VerticalConnectionPos): void;
+    onClick(): void;
+    onOpen(): void;
+    onClose(): void;
+    /**
+     * TODO: Refactor when @angular/cdk includes feature I mentioned on github see link below.
+     * https://github.com/angular/material2/pull/5493#issuecomment-313085323
+     */
+    /** Disables close of popover when leaving trigger element and mouse over the popover */
+    onMouseOver(): void;
+    /** Enables close of popover when mouse leaving popover element */
+    onMouseLeave(): void;
+    /** does nothing but must be overridable */
+    onMouseDown(): void;
+    _handleKeydown(event: KeyboardEvent): void;
+}
+
+declare class LuPopoverPanelComponent extends ALuPopoverPanel implements ILuPopoverPanel, OnDestroy {
+    protected _template: TemplateRef<unknown>;
+    protected _templateContext: unknown;
+    /** Template to Use for the popover */
+    get template(): TemplateRef<unknown>;
+    set template(value: TemplateRef<unknown>);
+    /** Template context to use for the popover when created using a template */
+    get templateContext(): unknown;
+    set templateContext(value: unknown);
+    /**
+     * Popover container close on click
+     * default: false
+     */
+    set inputCloseOnClick(v: boolean);
+    /**
+     * Popover focus trap using cdkTrapFocus
+     * default: false
+     */
+    set inputTrapFocus(v: boolean);
+    /**
+     * Popover scrollStrategy
+     * default: reposition
+     */
+    set inputScrollStrategy(v: LuPopoverScrollStrategy);
+    /**
+     * This method takes classes set on the host lu-popover element and applies them on the
+     * popover template that displays in the overlay container.  Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @param classes list of class names
+     */
+    set inputPanelClasses(classes: string);
+    /**
+     * This method takes classes set on the host lu-popover element and applies them on the
+     * popover template that displays in the overlay container. Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @param classes list of class names
+     */
+    set inputContentClasses(classes: string);
+    /** Event emitted when the popover is closed. */
+    close: EventEmitter<void>;
+    open: EventEmitter<void>;
+    hovered: EventEmitter<boolean>;
+    set vcTemplateRef(tr: TemplateRef<unknown>);
+    constructor();
+    ngOnDestroy(): void;
+    _emitCloseEvent(): void;
+    _emitOpenEvent(): void;
+    _emitHoveredEvent(hovered: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopoverPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuPopoverPanelComponent, "lu-popover", ["LuPopoverPanel"], { "template": { "alias": "template"; "required": false; }; "templateContext": { "alias": "template-context"; "required": false; }; "inputCloseOnClick": { "alias": "close-on-click"; "required": false; }; "inputTrapFocus": { "alias": "trap-focus"; "required": false; }; "inputScrollStrategy": { "alias": "scroll-strategy"; "required": false; }; "inputPanelClasses": { "alias": "panel-classes"; "required": false; }; "inputContentClasses": { "alias": "content-classes"; "required": false; }; }, { "close": "close"; "open": "open"; "hovered": "hovered"; }, never, ["*"], true, never>;
+}
+
+declare class LuPopoverPanelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopoverPanelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuPopoverPanelModule, never, [typeof LuPopoverPanelComponent], [typeof LuPopoverPanelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuPopoverPanelModule>;
+}
+
+type LuPopoverPosition = 'above' | 'below' | 'before' | 'after';
+type LuPopoverAlignment = 'top' | 'bottom' | 'left' | 'right' | 'center';
+/**
+ * anchor for a popover panel
+ */
+interface ILuPopoverTarget {
+    /** how the panel will be align with the target, allowed values: top, bottom, left, right */
+    alignment: LuPopoverAlignment;
+    /** the element used to position the panel */
+    elementRef: ElementRef;
+    overlap: boolean;
+    /** how you want to position the panel relative to the target, allowed values: above, below, before, after */
+    position: LuPopoverPosition;
+    offsetX: number;
+    offsetY: number;
+}
+declare abstract class ALuPopoverTarget implements ILuPopoverTarget {
+    protected _elementRef: ElementRef;
+    /** the element used to position the panel */
+    get elementRef(): ElementRef;
+    set elementRef(ref: ElementRef);
+    protected _position: LuPopoverPosition;
+    /** how you want to position the panel relative to the target, allowed values: above, below, before, after */
+    get position(): LuPopoverPosition;
+    set position(position: LuPopoverPosition | string);
+    protected _alignment: LuPopoverAlignment;
+    /** how the panel will be align with the target, allowed values: top, bottom, left, right */
+    get alignment(): LuPopoverAlignment;
+    set alignment(alignment: LuPopoverAlignment | string);
+    protected _overlap: boolean;
+    /** set to true if you want the panel to appear on top of the target */
+    get overlap(): boolean;
+    set overlap(ot: boolean);
+    protected _offsetX: number;
+    get offsetX(): number;
+    set offsetX(ox: number);
+    protected _offsetY: number;
+    get offsetY(): number;
+    set offsetY(oy: number);
+}
+declare class LuPopoverTarget extends ALuPopoverTarget {
+    constructor();
+}
+
+declare class LuPopoverTargetDirective extends ALuPopoverTarget {
+    constructor(ref: ElementRef);
+    /** how you want to position the panel relative to the target, allowed values: above, below, before, after */
+    set inputPosition(pos: LuPopoverPosition);
+    /** how the panel will be align with the target, allowed values: top, bottom, left, right */
+    set inputAlignment(al: LuPopoverAlignment);
+    /** set to true if you want the panel to appear on top of the target */
+    set inputOverlap(ov: boolean);
+    set inputOffsetX(ox: number);
+    set inputOffsetY(oy: number);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopoverTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuPopoverTargetDirective, "[luPopoverTarget]", ["LuPopoverTarget"], { "inputPosition": { "alias": "luPopoverPosition"; "required": false; }; "inputAlignment": { "alias": "luPopoverAlignment"; "required": false; }; "inputOverlap": { "alias": "luPopoverOverlap"; "required": false; }; "inputOffsetX": { "alias": "luPopoverOffsetX"; "required": false; }; "inputOffsetY": { "alias": "luPopoverOffsetY"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LuPopoverTargetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopoverTargetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuPopoverTargetModule, never, [typeof LuPopoverTargetDirective], [typeof LuPopoverTargetDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuPopoverTargetModule>;
+}
+
+type LuPopoverTriggerEvent = 'click' | 'hover' | 'none' | 'focus';
+/**
+ * component that will decide when to show the popover and attach it to the target
+ */
+declare interface ILuPopoverTrigger<TPanel extends ILuPopoverPanel = ILuPopoverPanel, TTarget extends ILuPopoverTarget = ILuPopoverTarget> {
+    /** the popover panel to display */
+    panel: TPanel;
+    /** the popover target to attach the panel */
+    target: TTarget;
+    /** when to display the popover */
+    triggerEvent: LuPopoverTriggerEvent;
+    /** delay before popover apparition when trigger is 'hover' */
+    enterDelay: number;
+    /** delay before popover disparition when trigger is 'hover' */
+    leaveDelay: number;
+    /** disable popover apparition */
+    disabled: boolean;
+    /** Event emitted when the associated popover is opened. */
+    onOpen: Observable<void>;
+    /** Event emitted when the associated popover is closed. */
+    onClose: Observable<void>;
+    openPopover(): any;
+    closePopover(): any;
+    togglePopover(): any;
+    destroyPopover(): any;
+}
+declare abstract class ALuPopoverTrigger<TPanel extends ILuPopoverPanel = ILuPopoverPanel, TTarget extends ILuPopoverTarget = ILuPopoverTarget> implements ILuPopoverTrigger<TPanel, TTarget> {
+    protected _overlay: Overlay;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _viewContainerRef: ViewContainerRef;
+    protected _portal: TemplatePortal<unknown> | ComponentPortal<TPanel>;
+    protected _overlayRef: OverlayRef | null;
+    protected _popoverOpen: boolean;
+    protected _backdropSubscription: Subscription;
+    protected _positionSubscription: Subscription;
+    protected _mouseoverTimer: unknown;
+    protected _hovered$: Subject<unknown>;
+    protected _hoveredSubscription: Subscription;
+    protected _panelEventsSubscriptions: Subscription;
+    protected _overlayDetachmentsSubscription: Subscription;
+    protected _openedByMouse: boolean;
+    protected _panel: TPanel;
+    /** References the popover instance that the trigger is associated with. */
+    get panel(): TPanel;
+    set panel(p: TPanel);
+    protected _target: TTarget;
+    /** References the popover target instance that the trigger is associated with. */
+    get target(): TTarget;
+    set target(t: TTarget);
+    protected _triggerEvent: LuPopoverTriggerEvent;
+    get triggerEvent(): LuPopoverTriggerEvent;
+    set triggerEvent(te: LuPopoverTriggerEvent);
+    protected _enterDelay: number;
+    get enterDelay(): number;
+    set enterDelay(d: number);
+    protected _leaveDelay: number;
+    get leaveDelay(): number;
+    set leaveDelay(d: number);
+    protected _disabled: boolean;
+    get disabled(): boolean;
+    set disabled(d: boolean);
+    protected _whenEllipsis: boolean;
+    get whenEllipsis(): boolean;
+    set whenEllipsis(we: boolean);
+    protected _triggerId: string;
+    protected _panelId: string;
+    /** Event emitted when the associated popover is opened. */
+    abstract onOpen: Observable<void>;
+    /** Event emitted when the associated popover is closed. */
+    abstract onClose: Observable<void>;
+    protected abstract _emitOpen(): void;
+    protected abstract _emitClose(): void;
+    constructor(_overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef);
+    onClick(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    /** Toggles the popover between the open and closed states. */
+    togglePopover(): void;
+    /** Opens the popover. */
+    openPopover(): void;
+    /** Closes the popover. */
+    closePopover(): void;
+    /** Removes the popover from the DOM. */
+    destroyPopover(): void;
+    /** Focuses the popover trigger. */
+    focus(): void;
+    _handleMousedown(event: MouseEvent): void;
+    /** The text direction of the containing app. */
+    get dir(): Direction;
+    /** Return if the popover main positionning is vertical */
+    get isVerticallyPositionned(): boolean;
+    protected _attachPortalToOverlay(): void;
+    protected _getPanelScrollStrategy(): LuPopoverScrollStrategy;
+    /**
+     * This method ensures that the popover
+     */
+    protected _subscribeToPanelEvents(): void;
+    /**
+     * This method ensures that the popover closes when the overlay has been detached
+     * Detach can occur if we scroll while popover is opened
+     */
+    protected _subscribeToOverlayDetachments(): void;
+    /**
+     * This method ensures that the popover closes when the overlay backdrop is clicked.
+     * We do not use first() here because doing so would not catch clicks from within
+     * the popover, and it would fail to unsubscribe properly. Instead, we unsubscribe
+     * explicitly when the popover is closed or destroyed.
+     */
+    protected _subscribeToBackdrop(): void;
+    /**
+     * This method sets the popover state to open and focuses the first item if
+     * the popover was opened via the keyboard.
+     */
+    protected _initPopover(): void;
+    /**
+     * This method resets the popover when it's closed, most importantly restoring
+     * focus to the popover trigger if the popover was opened via the keyboard.
+     */
+    protected _resetPopover(): void;
+    /** set state rather than toggle to support triggers sharing a popover */
+    protected _setIsPopoverOpen(isOpen: boolean): void;
+    /**
+     *  This method checks that a valid instance of MdPopover has been passed into
+     *  mdPopoverTriggerFor. If not, an exception is thrown.
+     */
+    protected _checkPanel(): void;
+    protected _checkTarget(): void;
+    /**
+     *  This method creates the overlay from the provided popover's template and saves its
+     *  OverlayRef so that it can be attached to the DOM when openPopover is called.
+     */
+    protected _createOverlay(): OverlayRef;
+    /**
+     * This method builds the configuration object needed to create the overlay, the OverlayConfig.
+     * @returns OverlayConfig
+     */
+    protected _getOverlayConfig(): OverlayConfig;
+    /**
+     * Listens to changes in the position of the overlay and sets the correct classes
+     * on the popover based on the new position. This ensures the animation origin is always
+     * correct, even if a fallback position is used for the overlay.
+     */
+    protected _subscribeToPositions(position: FlexibleConnectedPositionStrategy): void;
+    /**
+     * This method builds the position strategy for the overlay, so the popover is properly connected
+     * to the trigger.
+     * @returns FlexibleConnectedPositionStrategy
+     */
+    protected _getPosition(): FlexibleConnectedPositionStrategy;
+    protected _invertVerticalPos(y: VerticalConnectionPos): VerticalConnectionPos;
+    protected _invertHorizontalPos(x: HorizontalConnectionPos): HorizontalConnectionPos;
+    protected _cleanUpSubscriptions(): void;
+    protected _hasEllipsis(): boolean;
+}
+
+/**
+ * This directive is intended to be used in conjunction with an lu-popover tag.  It is
+ * responsible for toggling the display of the provided popover instance.
+ */
+declare class LuPopoverTriggerDirective<TPanel extends ILuPopoverPanel = ILuPopoverPanel, TTarget extends ILuPopoverTarget = ILuPopoverTarget> extends ALuPopoverTrigger<TPanel, TTarget> implements ILuPopoverTrigger<TPanel, TTarget>, AfterViewInit, OnDestroy {
+    protected _overlay: Overlay;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _viewContainerRef: ViewContainerRef;
+    /** References the popover instance that the trigger is associated with. */
+    set inputPanel(p: TPanel);
+    /** References the popover target instance that the trigger is associated with. */
+    set inputTarget(t: TTarget);
+    /** References the popover target instance that the trigger is associated with. */
+    set inputTriggerEvent(te: LuPopoverTriggerEvent);
+    /** Event emitted when the associated popover is opened. */
+    onOpen: EventEmitter<void>;
+    /** Event emitted when the associated popover is closed. */
+    onClose: EventEmitter<void>;
+    /** how you want to position the panel relative to the target, allowed values: above, below, before, after */
+    set inputPosition(pos: LuPopoverPosition);
+    /** how the panel will be align with the target, allowed values: top, bottom, left, right */
+    set inputAlignment(al: LuPopoverAlignment);
+    /** when trigger = hover, delay before the popover panel appears */
+    set inputEnterDelay(d: number);
+    /** when trigger = hover, delay before the popover panel disappears */
+    set inputLeaveDelay(d: number);
+    /** disable popover apparition */
+    set inputDisabled(d: boolean);
+    /** set to true if you want the panel to appear on top of the target */
+    set inputOverlap(ov: boolean);
+    set inputOffsetX(ox: number);
+    set inputOffsetY(oy: number);
+    /** accessibility attribute - dont override */
+    get _attrAriaExpanded(): boolean;
+    /** accessibility attribute - dont override */
+    get _attrId(): string;
+    /** accessibility attribute - dont override */
+    get _attrAriaControls(): string;
+    constructor(_overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef);
+    onClick(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected _emitOpen(): void;
+    protected _emitClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopoverTriggerDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuPopoverTriggerDirective<any, any>, "[luPopover]", ["LuPopoverTrigger"], { "inputPanel": { "alias": "luPopover"; "required": false; }; "inputTarget": { "alias": "luPopoverTarget"; "required": false; }; "inputTriggerEvent": { "alias": "luPopoverTrigger"; "required": false; }; "inputPosition": { "alias": "luPopoverPosition"; "required": false; }; "inputAlignment": { "alias": "luPopoverAlignment"; "required": false; }; "inputEnterDelay": { "alias": "luPopoverEnterDelay"; "required": false; }; "inputLeaveDelay": { "alias": "luPopoverLeaveDelay"; "required": false; }; "inputDisabled": { "alias": "luPopoverDisabled"; "required": false; }; "inputOverlap": { "alias": "luPopoverOverlap"; "required": false; }; "inputOffsetX": { "alias": "luPopoverOffsetX"; "required": false; }; "inputOffsetY": { "alias": "luPopoverOffsetY"; "required": false; }; }, { "onOpen": "luPopoverOnOpen"; "onClose": "luPopoverOnClose"; }, never, never, true, never>;
+}
+
+declare class LuPopoverTriggerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopoverTriggerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuPopoverTriggerModule, never, [typeof LuPopoverTriggerDirective, typeof i2.OverlayModule], [typeof LuPopoverTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuPopoverTriggerModule>;
+}
+
+declare class LuPopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuPopoverModule, never, [typeof LuPopoverPanelComponent, typeof LuPopoverTargetDirective, typeof LuPopoverTriggerDirective], [typeof LuPopoverPanelComponent, typeof LuPopoverTargetDirective, typeof LuPopoverTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuPopoverModule>;
+}
+
+export { ALuPopoverPanel, ALuPopoverTarget, ALuPopoverTrigger, LuPopoverModule, LuPopoverPanelComponent, LuPopoverPanelModule, LuPopoverTarget, LuPopoverTargetDirective, LuPopoverTargetModule, LuPopoverTriggerDirective, LuPopoverTriggerModule, luTransformPopover };
+export type { ILuPopoverPanel, ILuPopoverTarget, ILuPopoverTrigger, LuPopoverAlignment, LuPopoverPosition, LuPopoverScrollStrategy, LuPopoverTriggerEvent };

package/popover2/index.d.ts

@@ -1,5 +1,64 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/popover2" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef, InputSignal, EnvironmentProviders, InjectionToken } from '@angular/core';
+import { ConnectionPositionPair, FlexibleConnectedPositionStrategyOrigin } from '@angular/cdk/overlay';
+import { Subject } from 'rxjs';
+import { LuTranslation } from '@lucca-front/ng/core';
+
+interface LuCalloutLabel {
+    screenReaderDescription: string;
+}
+
+type PopoverPosition = 'above' | 'below' | 'before' | 'after';
+declare class PopoverDirective implements OnDestroy {
+    #private;
+    intl: LuCalloutLabel;
+    content: TemplateRef<unknown>;
+    luPopoverPosition: PopoverPosition;
+    luPopoverDisabled: boolean;
+    luPopoverTrigger: InputSignal<"click" | "click+hover" | "hover+focus">;
+    customPositions?: ConnectionPositionPair[];
+    /**
+     * Removes close button entirely, this is bad for a11y but sometimes we want it.
+     */
+    luPopoverNoCloseButton: boolean;
+    /**
+     * Allows to anchor the popover to another element instead of the trigger one
+     * for placement purpose
+     */
+    luPopoverAnchor: InputSignal<FlexibleConnectedPositionStrategyOrigin>;
+    luPopoverOpenDelay: InputSignal<number>;
+    luPopoverCloseDelay: InputSignal<number>;
+    open$: Subject<"click" | "focus" | "hover">;
+    close$: Subject<void>;
+    luPopoverClosed: _angular_core.OutputEmitterRef<void>;
+    luPopoverOpened: _angular_core.OutputEmitterRef<void>;
+    positionPairs: Record<PopoverPosition, ConnectionPositionPair>;
+    opened: _angular_core.WritableSignal<boolean>;
+    ariaControls: string;
+    constructor();
+    ngOnDestroy(): void;
+    onMouseEnter(): void;
+    onFocus(): void;
+    onMouseLeave(): void;
+    click(): void;
+    close(): void;
+    openPopover(withBackdrop?: boolean, disableFocusHandler?: boolean): void;
+    focusBackToContent(event: Event): void;
+    focusOutBefore(): void;
+    updatePosition(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverDirective, "[luPopover2]", ["luPopover2"], { "content": { "alias": "luPopover2"; "required": false; }; "luPopoverPosition": { "alias": "luPopoverPosition"; "required": false; }; "luPopoverDisabled": { "alias": "luPopoverDisabled"; "required": false; }; "luPopoverTrigger": { "alias": "luPopoverTrigger"; "required": false; "isSignal": true; }; "customPositions": { "alias": "customPositions"; "required": false; }; "luPopoverNoCloseButton": { "alias": "luPopoverNoCloseButton"; "required": false; }; "luPopoverAnchor": { "alias": "luPopoverAnchor"; "required": false; "isSignal": true; }; "luPopoverOpenDelay": { "alias": "luPopoverOpenDelay"; "required": false; "isSignal": true; }; "luPopoverCloseDelay": { "alias": "luPopoverCloseDelay"; "required": false; "isSignal": true; }; }, { "luPopoverClosed": "luPopoverClosed"; "luPopoverOpened": "luPopoverOpened"; }, never, never, true, never>;
+    static ngAcceptInputType_luPopoverDisabled: unknown;
+    static ngAcceptInputType_luPopoverNoCloseButton: unknown;
+}
+
+declare function configureLuPopover(): EnvironmentProviders;
+
+declare const LU_POPOVER2_TRANSLATIONS: InjectionToken<LuTranslation<ILuPopover2Label>>;
+interface ILuPopover2Label {
+    close: string;
+}
+declare const luPopoverTranslations: LuTranslation<ILuPopover2Label>;
+
+export { LU_POPOVER2_TRANSLATIONS, PopoverDirective, configureLuPopover, luPopoverTranslations };
+export type { ILuPopover2Label, PopoverPosition };

package/popup/index.d.ts

@@ -1,5 +1,106 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/popup" />
-export * from './public-api';
+import * as i1 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef, OverlayConfig, ComponentType as ComponentType$1 } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { Injector, ComponentRef, InjectionToken } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { Observable, Subject, Subscription } from 'rxjs';
+
+interface ILuPopupConfig {
+    position?: 'center' | 'top' | 'bottom' | 'left' | 'right';
+    noBackdrop?: boolean;
+    /** popup dismisses if `esc` is pressed or backdrop is clicked, set it to true if you want to prevent it but be aware that your popup might become unclosable */
+    undismissable?: boolean;
+    backdropClass?: string | string[];
+    panelClass?: string | string[];
+    size?: string;
+}
+
+declare const luDefaultPopupConfig: ILuPopupConfig;
+
+interface ILuPopupRef<D = unknown, R = unknown> {
+    onOpen: Observable<D>;
+    onClose: Observable<R>;
+    onDismiss: Observable<void>;
+    onBackdropClick: Observable<void>;
+    open(data: D): void;
+    close(result: R): void;
+    dismiss(): void;
+}
+interface ILuPopupRefFactory<TComponent = unknown, TConfig extends ILuPopupConfig = ILuPopupConfig> {
+    forge<T extends TComponent, C extends TConfig, D, R>(component: ComponentType<T>, config: C): ILuPopupRef<D, R>;
+}
+declare abstract class ALuPopupRef<T = unknown, D = unknown, R = unknown, C extends ILuPopupConfig = ILuPopupConfig> implements ILuPopupRef<D, R> {
+    protected _overlay: Overlay;
+    protected _injector: Injector;
+    protected _component: ComponentType<T>;
+    protected _config: C;
+    onOpen: Subject<D>;
+    onClose: Subject<R>;
+    onDismiss: Subject<void>;
+    onBackdropClick: Subject<void>;
+    protected _overlayRef: OverlayRef;
+    protected _componentRef: ComponentRef<T>;
+    protected _subs: Subscription;
+    constructor(_overlay: Overlay, _injector: Injector, _component: ComponentType<T>, _config: C);
+    open(data?: D): void;
+    close(result?: R): void;
+    dismiss(): void;
+    /**
+     *  This method creates the overlay from the provided popover's template and saves its
+     *  OverlayRef so that it can be attached to the DOM when openPopover is called.
+     */
+    protected _createOverlay(): void;
+    /**
+     * This method builds the configuration object needed to create the overlay, the OverlayConfig.
+     * @returns OverlayConfig
+     */
+    protected _getOverlayConfig(): OverlayConfig;
+    protected _openPopup(data?: D): void;
+    protected _getOverlayPanelClasses(): string[];
+    protected _destroy(): void;
+    protected _completeSubjects(): void;
+    protected _destroyOverlay(): void;
+    protected _closePopup(): void;
+    protected _subToCloseEvents(): void;
+    protected _subToEscapeKeydownEvent(): void;
+    protected _subToBackdropClickEvent(): void;
+    protected _cleanSubscription(): void;
+}
+
+declare class LuPopupRef<T = unknown, D = unknown, R = unknown> extends ALuPopupRef<T, D, R> {
+    protected _overlay: Overlay;
+    protected _injector: Injector;
+    protected _component: ComponentType$1<T>;
+    protected _config: ILuPopupConfig;
+    constructor(_overlay: Overlay, _injector: Injector, _component: ComponentType$1<T>, _config: ILuPopupConfig);
+}
+declare class LuPopupRefFactory implements ILuPopupRefFactory {
+    protected _overlay: Overlay;
+    protected _injector: Injector;
+    constructor(_overlay: Overlay, _injector: Injector);
+    forge<T, D, R>(component: ComponentType$1<T>, config: ILuPopupConfig): LuPopupRef<T, D, R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopupRefFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuPopupRefFactory>;
+}
+
+declare class LuPopupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuPopupModule, never, [typeof i1.OverlayModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuPopupModule>;
+}
+
+declare class LuPopup {
+    protected _factory: ILuPopupRefFactory<unknown, ILuPopupConfig>;
+    protected _config: ILuPopupConfig;
+    open<T, D, R>(component: ComponentType$1<T>, data?: D, config?: Partial<ILuPopupConfig>): ILuPopupRef<D, R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopup, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuPopup>;
+}
+
+declare const LU_POPUP_REF_FACTORY: InjectionToken<ILuPopupRefFactory<unknown, ILuPopupConfig>>;
+/** Injection token that can be used to access the data that was passed in to a dialog. */
+declare const LU_POPUP_DATA: InjectionToken<unknown>;
+declare const LU_POPUP_CONFIG: InjectionToken<ILuPopupConfig>;
+
+export { ALuPopupRef, LU_POPUP_CONFIG, LU_POPUP_DATA, LU_POPUP_REF_FACTORY, LuPopup, LuPopupModule, LuPopupRef, LuPopupRefFactory, luDefaultPopupConfig };
+export type { ILuPopupConfig, ILuPopupRef, ILuPopupRefFactory };