@ethlete/cdk 2.3.1 → 2.3.2

package/esm2022/lib/components/overlay/components/dialog/services/dialog-base.service.mjs

@@ -0,0 +1,110 @@
+import { Dialog as CdkDialog, DialogConfig as CdkDialogConfig } from '@angular/cdk/dialog';
+import { Overlay } from '@angular/cdk/overlay';
+import { Directive, InjectionToken, Injector, Type } from '@angular/core';
+import { defer, startWith, Subject } from 'rxjs';
+import { DIALOG_CONFIG } from '../constants';
+import { createDialogConfig } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+let uniqueId = 0;
+class DialogServiceBase {
+    get openDialogs() {
+        return this._parentDialogService ? this._parentDialogService.openDialogs : this._openDialogsAtThisLevel;
+    }
+    get afterOpened() {
+        return this._parentDialogService ? this._parentDialogService.afterOpened : this._afterOpenedAtThisLevel;
+    }
+    _getAfterAllClosed() {
+        const parent = this._parentDialogService;
+        return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;
+    }
+    constructor(_overlay, injector, _defaultOptions, _parentDialogService, scrollStrategy, _dialogRefConstructor, _dialogContainerType, _dialogDataToken) {
+        this._overlay = _overlay;
+        this._defaultOptions = _defaultOptions;
+        this._parentDialogService = _parentDialogService;
+        this._dialogRefConstructor = _dialogRefConstructor;
+        this._dialogContainerType = _dialogContainerType;
+        this._dialogDataToken = _dialogDataToken;
+        this._openDialogsAtThisLevel = [];
+        this._afterAllClosedAtThisLevel = new Subject();
+        this._afterOpenedAtThisLevel = new Subject();
+        this._idPrefix = 'et-dialog-';
+        this.afterAllClosed = defer(() => this.openDialogs.length ? this._getAfterAllClosed() : this._getAfterAllClosed().pipe(startWith(undefined)));
+        this._scrollStrategy = scrollStrategy;
+        this._dialog = injector.get(CdkDialog);
+    }
+    open(componentOrTemplateRef, config) {
+        let dialogRef;
+        config = createDialogConfig(this._defaultOptions, config);
+        config.id = config.id || `${this._idPrefix}${uniqueId++}`;
+        config.scrollStrategy = config.scrollStrategy || this._scrollStrategy();
+        const cdkRef = this._dialog.open(componentOrTemplateRef, {
+            ...config,
+            positionStrategy: config.positionStrategy ?? this._overlay.position().global().centerHorizontally().centerVertically(),
+            disableClose: true,
+            closeOnDestroy: false,
+            container: {
+                type: this._dialogContainerType,
+                providers: () => [
+                    { provide: DIALOG_CONFIG, useValue: config },
+                    { provide: CdkDialogConfig, useValue: config },
+                ],
+            },
+            templateContext: () => ({ dialogRef }),
+            providers: (ref, cdkConfig, dialogContainer) => {
+                if (config?.overlayClass) {
+                    const overlayRefClasses = Array.isArray(config.overlayClass)
+                        ? config.overlayClass.join(' ')
+                        : config.overlayClass;
+                    ref.overlayRef.hostElement.classList.add(overlayRefClasses);
+                }
+                dialogRef = new this._dialogRefConstructor(ref, config, dialogContainer);
+                dialogRef.updatePosition(config?.position);
+                return [
+                    { provide: this._dialogContainerType, useValue: dialogContainer },
+                    { provide: this._dialogDataToken, useValue: cdkConfig.data },
+                    { provide: this._dialogRefConstructor, useValue: dialogRef },
+                ];
+            },
+        });
+        /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+        dialogRef.componentInstance = cdkRef.componentInstance;
+        this.openDialogs.push(dialogRef);
+        this.afterOpened.next(dialogRef);
+        dialogRef.afterClosed().subscribe(() => {
+            const index = this.openDialogs.indexOf(dialogRef);
+            if (index > -1) {
+                this.openDialogs.splice(index, 1);
+                if (!this.openDialogs.length) {
+                    this._getAfterAllClosed().next();
+                }
+            }
+        });
+        return dialogRef;
+        /* eslint-enable @typescript-eslint/no-non-null-assertion*/
+    }
+    closeAll() {
+        this._closeDialogs(this.openDialogs);
+    }
+    getDialogById(id) {
+        return this.openDialogs.find((dialog) => dialog.id === id);
+    }
+    ngOnDestroy() {
+        this._closeDialogs(this._openDialogsAtThisLevel);
+        this._afterAllClosedAtThisLevel.complete();
+        this._afterOpenedAtThisLevel.complete();
+    }
+    _closeDialogs(dialogs) {
+        let i = dialogs.length;
+        while (i--) {
+            dialogs[i].close();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogServiceBase, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: DialogServiceBase, ngImport: i0 }); }
+}
+export { DialogServiceBase };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogServiceBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: undefined }, { type: undefined }, { type: undefined }, { type: i0.Type }, { type: i0.Type }, { type: i0.InjectionToken }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-base.service.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/dialog/services/dialog-base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Dialog as CdkDialog, DialogConfig as CdkDialogConfig } from '@angular/cdk/dialog';\nimport { ComponentType, Overlay, ScrollStrategy } from '@angular/cdk/overlay';\nimport { Directive, InjectionToken, Injector, OnDestroy, TemplateRef, Type } from '@angular/core';\nimport { defer, Observable, startWith, Subject } from 'rxjs';\nimport { DIALOG_CONFIG } from '../constants';\nimport { DialogContainerBaseComponent } from '../partials';\nimport { DialogConfig } from '../types';\nimport { createDialogConfig, DialogRef } from '../utils';\n\nlet uniqueId = 0;\n\n@Directive()\nexport abstract class DialogServiceBase<C extends DialogContainerBaseComponent> implements OnDestroy {\n  private readonly _openDialogsAtThisLevel: DialogRef[] = [];\n  private readonly _afterAllClosedAtThisLevel = new Subject<void>();\n  private readonly _afterOpenedAtThisLevel = new Subject<DialogRef>();\n  private _scrollStrategy: () => ScrollStrategy;\n  protected _idPrefix = 'et-dialog-';\n  private _dialog: CdkDialog;\n\n  readonly afterAllClosed: Observable<void> = defer(() =>\n    this.openDialogs.length ? this._getAfterAllClosed() : this._getAfterAllClosed().pipe(startWith(undefined)),\n  ) as Observable<void>;\n\n  get openDialogs(): DialogRef[] {\n    return this._parentDialogService ? this._parentDialogService.openDialogs : this._openDialogsAtThisLevel;\n  }\n\n  get afterOpened(): Subject<DialogRef> {\n    return this._parentDialogService ? this._parentDialogService.afterOpened : this._afterOpenedAtThisLevel;\n  }\n\n  private _getAfterAllClosed(): Subject<void> {\n    const parent = this._parentDialogService;\n    return parent ? parent._getAfterAllClosed() : this._afterAllClosedAtThisLevel;\n  }\n\n  constructor(\n    private _overlay: Overlay,\n    injector: Injector,\n    private _defaultOptions: DialogConfig | undefined,\n    private _parentDialogService: DialogServiceBase<C> | undefined,\n    scrollStrategy: () => ScrollStrategy,\n    private _dialogRefConstructor: Type<DialogRef>,\n    private _dialogContainerType: Type<C>,\n    private _dialogDataToken: InjectionToken<unknown>,\n  ) {\n    this._scrollStrategy = scrollStrategy;\n    this._dialog = injector.get(CdkDialog);\n  }\n\n  open<T, D = unknown, R = unknown>(component: ComponentType<T>, config?: DialogConfig<D>): DialogRef<T, R>;\n\n  open<T, D = unknown, R = unknown>(template: TemplateRef<T>, config?: DialogConfig<D>): DialogRef<T, R>;\n\n  open<T, D = unknown, R = unknown>(\n    template: ComponentType<T> | TemplateRef<T>,\n    config?: DialogConfig<D>,\n  ): DialogRef<T, R>;\n\n  open<T, D = unknown, R = unknown>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    config?: DialogConfig<D>,\n  ): DialogRef<T, R> {\n    let dialogRef: DialogRef<T, R>;\n    config = createDialogConfig<D>(this._defaultOptions as DialogConfig<D>, config);\n    config.id = config.id || `${this._idPrefix}${uniqueId++}`;\n    config.scrollStrategy = config.scrollStrategy || this._scrollStrategy();\n\n    const cdkRef = this._dialog.open<R, D, T>(componentOrTemplateRef, {\n      ...config,\n      positionStrategy:\n        config.positionStrategy ?? this._overlay.position().global().centerHorizontally().centerVertically(),\n      disableClose: true,\n      closeOnDestroy: false,\n      container: {\n        type: this._dialogContainerType,\n        providers: () => [\n          { provide: DIALOG_CONFIG, useValue: config },\n          { provide: CdkDialogConfig, useValue: config },\n        ],\n      },\n      templateContext: () => ({ dialogRef }),\n      providers: (ref, cdkConfig, dialogContainer) => {\n        if (config?.overlayClass) {\n          const overlayRefClasses = Array.isArray(config.overlayClass)\n            ? config.overlayClass.join(' ')\n            : config.overlayClass;\n\n          ref.overlayRef.hostElement.classList.add(overlayRefClasses);\n        }\n\n        dialogRef = new this._dialogRefConstructor(ref, config, dialogContainer);\n        dialogRef.updatePosition(config?.position);\n        return [\n          { provide: this._dialogContainerType, useValue: dialogContainer },\n          { provide: this._dialogDataToken, useValue: cdkConfig.data },\n          { provide: this._dialogRefConstructor, useValue: dialogRef },\n        ];\n      },\n    });\n\n    /* eslint-disable @typescript-eslint/no-non-null-assertion*/\n\n    dialogRef!.componentInstance = cdkRef.componentInstance!;\n\n    this.openDialogs.push(dialogRef!);\n    this.afterOpened.next(dialogRef!);\n\n    dialogRef!.afterClosed().subscribe(() => {\n      const index = this.openDialogs.indexOf(dialogRef);\n\n      if (index > -1) {\n        this.openDialogs.splice(index, 1);\n\n        if (!this.openDialogs.length) {\n          this._getAfterAllClosed().next();\n        }\n      }\n    });\n\n    return dialogRef!;\n\n    /* eslint-enable @typescript-eslint/no-non-null-assertion*/\n  }\n\n  closeAll(): void {\n    this._closeDialogs(this.openDialogs);\n  }\n\n  getDialogById(id: string): DialogRef | undefined {\n    return this.openDialogs.find((dialog) => dialog.id === id);\n  }\n\n  ngOnDestroy() {\n    this._closeDialogs(this._openDialogsAtThisLevel);\n    this._afterAllClosedAtThisLevel.complete();\n    this._afterOpenedAtThisLevel.complete();\n  }\n\n  private _closeDialogs(dialogs: DialogRef[]) {\n    let i = dialogs.length;\n\n    while (i--) {\n      dialogs[i].close();\n    }\n  }\n}\n"]}

package/esm2022/lib/components/overlay/components/dialog/services/dialog.service.mjs

@@ -0,0 +1,32 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { Inject, Injectable, Injector, Optional, SkipSelf } from '@angular/core';
+import { DialogContainerComponent } from '../components';
+import { DIALOG_DATA, DIALOG_DEFAULT_OPTIONS, DIALOG_SCROLL_STRATEGY } from '../constants';
+import { DialogRef } from '../utils';
+import { DialogServiceBase } from './dialog-base.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+class DialogService extends DialogServiceBase {
+    constructor(overlay, injector, defaultOptions, scrollStrategy, parentDialogService) {
+        super(overlay, injector, defaultOptions, parentDialogService, scrollStrategy, DialogRef, DialogContainerComponent, DIALOG_DATA);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogService, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: DIALOG_DEFAULT_OPTIONS, optional: true }, { token: DIALOG_SCROLL_STRATEGY }, { token: DialogService, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogService }); }
+}
+export { DialogService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DIALOG_DEFAULT_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DIALOG_SCROLL_STRATEGY]
+                }] }, { type: DialogService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/components/overlay/components/dialog/utils/dialog-ref.mjs

@@ -1,5 +1,5 @@
 import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
-import { filter, merge, skipUntil, Subject, take } from 'rxjs';
+import { Subject, filter, merge, skipUntil, take } from 'rxjs';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class DialogRef {
     constructor(_ref, config, _containerInstance) {
@@ -111,4 +111,4 @@ export class DialogRef {
         return ref.close(result);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-ref.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/dialog/utils/dialog-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusOrigin } from '@angular/cdk/a11y';\nimport { DialogRef as CdkDialogRef } from '@angular/cdk/dialog';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { GlobalPositionStrategy } from '@angular/cdk/overlay';\nimport { filter, merge, Observable, skipUntil, Subject, take } from 'rxjs';\nimport { DialogContainerBaseComponent } from '../partials';\nimport { DialogConfig, DialogPosition, DialogState } from '../types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class DialogRef<T = any, R = any> {\n  componentInstance: T | null = null;\n  disableClose: boolean | undefined;\n  id: string;\n\n  private readonly _afterOpened = new Subject<void>();\n  private readonly _beforeClosed = new Subject<R | undefined>();\n\n  private _result: R | undefined;\n  private _state = DialogState.OPEN;\n  private _closeInteractionType: FocusOrigin | undefined;\n\n  constructor(\n    private _ref: CdkDialogRef<R, T>,\n    config: DialogConfig,\n    public _containerInstance: DialogContainerBaseComponent,\n  ) {\n    this.disableClose = config.disableClose;\n    this.id = _ref.id;\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'entered'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._afterOpened.next();\n        this._afterOpened.complete();\n      });\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._finishDialogClose();\n      });\n\n    _ref.overlayRef.detachments().subscribe(() => {\n      this._beforeClosed.next(this._result);\n      this._beforeClosed.complete();\n      this._finishDialogClose();\n    });\n\n    merge(\n      this.backdropClick(),\n      this.keydownEvents().pipe(\n        filter((event) => event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)),\n      ),\n    )\n      .pipe(skipUntil(_containerInstance._animatedLifecycle.state$.pipe(filter((e) => e === 'entering'))))\n      .subscribe((event) => {\n        if (!this.disableClose) {\n          event.preventDefault();\n          this._closeDialogVia(this, event.type === 'keydown' ? 'keyboard' : 'mouse');\n        }\n      });\n  }\n\n  close(dialogResult?: R): void {\n    if (this._state === DialogState.CLOSING || this._state === DialogState.CLOSED) {\n      return;\n    }\n\n    this._result = dialogResult;\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'leaving'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._beforeClosed.next(dialogResult);\n        this._beforeClosed.complete();\n        this._ref.overlayRef.detachBackdrop();\n      });\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => this._finishDialogClose());\n\n    this._state = DialogState.CLOSING;\n    this._containerInstance._animatedLifecycle.leave();\n  }\n\n  afterOpened(): Observable<void> {\n    return this._afterOpened;\n  }\n\n  afterClosed(): Observable<R | undefined> {\n    return this._ref.closed;\n  }\n\n  beforeClosed(): Observable<R | undefined> {\n    return this._beforeClosed;\n  }\n\n  backdropClick(): Observable<MouseEvent> {\n    return this._ref.backdropClick;\n  }\n\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._ref.keydownEvents;\n  }\n\n  updatePosition(position?: DialogPosition): this {\n    const strategy = this._ref.config.positionStrategy as GlobalPositionStrategy;\n\n    if (position && (position.left || position.right)) {\n      position.left ? strategy.left(position.left) : strategy.right(position.right);\n    } else {\n      strategy.centerHorizontally();\n    }\n\n    if (position && (position.top || position.bottom)) {\n      position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);\n    } else {\n      strategy.centerVertically();\n    }\n\n    this._ref.updatePosition();\n\n    return this;\n  }\n\n  updateSize(width: string = '', height: string = ''): this {\n    this._ref.updateSize(width, height);\n    return this;\n  }\n\n  addPanelClass(classes: string | string[]): this {\n    this._ref.addPanelClass(classes);\n    return this;\n  }\n\n  removePanelClass(classes: string | string[]): this {\n    this._ref.removePanelClass(classes);\n    return this;\n  }\n\n  getState(): DialogState {\n    return this._state;\n  }\n\n  private _finishDialogClose() {\n    this._state = DialogState.CLOSED;\n    this._ref.close(this._result, { focusOrigin: this._closeInteractionType });\n    this.componentInstance = null;\n  }\n\n  _closeDialogVia<R>(ref: DialogRef<R>, interactionType: FocusOrigin, result?: R) {\n    (ref as unknown as { _closeInteractionType: FocusOrigin })._closeInteractionType = interactionType;\n    return ref.close(result);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-ref.js","sourceRoot":"","sources":["../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/dialog/utils/dialog-ref.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAc,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAI3E,8DAA8D;AAC9D,MAAM,OAAO,SAAS;IAYpB,YACU,IAAwB,EAChC,MAAoB,EACb,kBAAgD;QAF/C,SAAI,GAAJ,IAAI,CAAoB;QAEzB,uBAAkB,GAAlB,kBAAkB,CAA8B;QAdzD,sBAAiB,GAAa,IAAI,CAAC;QAIlB,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QACnC,kBAAa,GAAG,IAAI,OAAO,EAAiB,CAAC;QAGtD,WAAM,4BAAoB;QAQhC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QAElB,kBAAkB,CAAC,kBAAkB,CAAC,MAAM;aACzC,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,EACtC,IAAI,CAAC,CAAC,CAAC,CACR;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEL,kBAAkB,CAAC,kBAAkB,CAAC,MAAM;aACzC,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,EACnC,IAAI,CAAC,CAAC,CAAC,CACR;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE;YAC3C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,KAAK,CACH,IAAI,CAAC,aAAa,EAAE,EACpB,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,CACvB,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAC5F,CACF;aACE,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC;aACnG,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;gBACtB,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;aAC7E;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,YAAgB;QACpB,IAAI,IAAI,CAAC,MAAM,gCAAwB,IAAI,IAAI,CAAC,MAAM,+BAAuB,EAAE;YAC7E,OAAO;SACR;QAED,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC;QAE5B,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,MAAM;aAC9C,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,EACtC,IAAI,CAAC,CAAC,CAAC,CACR;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACtC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;QACxC,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,MAAM;aAC9C,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,EACnC,IAAI,CAAC,CAAC,CAAC,CACR;aACA,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC;QAE9C,IAAI,CAAC,MAAM,8BAAsB,CAAC;QAClC,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;IACrD,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IAC1B,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;IACjC,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;IACjC,CAAC;IAED,cAAc,CAAC,QAAyB;QACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gBAA0C,CAAC;QAE7E,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;YACjD,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SAC/E;aAAM;YACL,QAAQ,CAAC,kBAAkB,EAAE,CAAC;SAC/B;QAED,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;YACjD,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;SAC9E;aAAM;YACL,QAAQ,CAAC,gBAAgB,EAAE,CAAC;SAC7B;QAED,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;QAE3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,UAAU,CAAC,KAAK,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE;QAChC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,aAAa,CAAC,OAA0B;QACtC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gBAAgB,CAAC,OAA0B;QACzC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAEO,kBAAkB;QACxB,IAAI,CAAC,MAAM,6BAAqB,CAAC;QACjC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,qBAAqB,EAAE,CAAC,CAAC;QAC3E,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,eAAe,CAAI,GAAiB,EAAE,eAA4B,EAAE,MAAU;QAC3E,GAAyD,CAAC,qBAAqB,GAAG,eAAe,CAAC;QACnG,OAAO,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3B,CAAC;CACF","sourcesContent":["import { FocusOrigin } from '@angular/cdk/a11y';\nimport { DialogRef as CdkDialogRef } from '@angular/cdk/dialog';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { GlobalPositionStrategy } from '@angular/cdk/overlay';\nimport { Observable, Subject, filter, merge, skipUntil, take } from 'rxjs';\nimport { DialogContainerBaseComponent } from '../partials';\nimport { DialogConfig, DialogPosition, DialogState } from '../types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class DialogRef<T = any, R = any> {\n  componentInstance: T | null = null;\n  disableClose: boolean | undefined;\n  id: string;\n\n  private readonly _afterOpened = new Subject<void>();\n  private readonly _beforeClosed = new Subject<R | undefined>();\n\n  private _result: R | undefined;\n  private _state = DialogState.OPEN;\n  private _closeInteractionType: FocusOrigin | undefined;\n\n  constructor(\n    private _ref: CdkDialogRef<R, T>,\n    config: DialogConfig,\n    public _containerInstance: DialogContainerBaseComponent,\n  ) {\n    this.disableClose = config.disableClose;\n    this.id = _ref.id;\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'entered'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._afterOpened.next();\n        this._afterOpened.complete();\n      });\n\n    _containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._finishDialogClose();\n      });\n\n    _ref.overlayRef.detachments().subscribe(() => {\n      this._beforeClosed.next(this._result);\n      this._beforeClosed.complete();\n      this._finishDialogClose();\n    });\n\n    merge(\n      this.backdropClick(),\n      this.keydownEvents().pipe(\n        filter((event) => event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event)),\n      ),\n    )\n      .pipe(skipUntil(_containerInstance._animatedLifecycle.state$.pipe(filter((e) => e === 'entering'))))\n      .subscribe((event) => {\n        if (!this.disableClose) {\n          event.preventDefault();\n          this._closeDialogVia(this, event.type === 'keydown' ? 'keyboard' : 'mouse');\n        }\n      });\n  }\n\n  close(dialogResult?: R): void {\n    if (this._state === DialogState.CLOSING || this._state === DialogState.CLOSED) {\n      return;\n    }\n\n    this._result = dialogResult;\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'leaving'),\n        take(1),\n      )\n      .subscribe(() => {\n        this._beforeClosed.next(dialogResult);\n        this._beforeClosed.complete();\n        this._ref.overlayRef.detachBackdrop();\n      });\n\n    this._containerInstance._animatedLifecycle.state$\n      .pipe(\n        filter((event) => event === 'left'),\n        take(1),\n      )\n      .subscribe(() => this._finishDialogClose());\n\n    this._state = DialogState.CLOSING;\n    this._containerInstance._animatedLifecycle.leave();\n  }\n\n  afterOpened(): Observable<void> {\n    return this._afterOpened;\n  }\n\n  afterClosed(): Observable<R | undefined> {\n    return this._ref.closed;\n  }\n\n  beforeClosed(): Observable<R | undefined> {\n    return this._beforeClosed;\n  }\n\n  backdropClick(): Observable<MouseEvent> {\n    return this._ref.backdropClick;\n  }\n\n  keydownEvents(): Observable<KeyboardEvent> {\n    return this._ref.keydownEvents;\n  }\n\n  updatePosition(position?: DialogPosition): this {\n    const strategy = this._ref.config.positionStrategy as GlobalPositionStrategy;\n\n    if (position && (position.left || position.right)) {\n      position.left ? strategy.left(position.left) : strategy.right(position.right);\n    } else {\n      strategy.centerHorizontally();\n    }\n\n    if (position && (position.top || position.bottom)) {\n      position.top ? strategy.top(position.top) : strategy.bottom(position.bottom);\n    } else {\n      strategy.centerVertically();\n    }\n\n    this._ref.updatePosition();\n\n    return this;\n  }\n\n  updateSize(width = '', height = ''): this {\n    this._ref.updateSize(width, height);\n    return this;\n  }\n\n  addPanelClass(classes: string | string[]): this {\n    this._ref.addPanelClass(classes);\n    return this;\n  }\n\n  removePanelClass(classes: string | string[]): this {\n    this._ref.removePanelClass(classes);\n    return this;\n  }\n\n  getState(): DialogState {\n    return this._state;\n  }\n\n  private _finishDialogClose() {\n    this._state = DialogState.CLOSED;\n    this._ref.close(this._result, { focusOrigin: this._closeInteractionType });\n    this.componentInstance = null;\n  }\n\n  _closeDialogVia<R>(ref: DialogRef<R>, interactionType: FocusOrigin, result?: R) {\n    (ref as unknown as { _closeInteractionType: FocusOrigin })._closeInteractionType = interactionType;\n    return ref.close(result);\n  }\n}\n"]}

package/esm2022/lib/components/overlay/components/toggletip/components/toggletip/toggletip.component.mjs

@@ -0,0 +1,63 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, HostBinding, inject, InjectionToken, Injector, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { AnimatedLifecycleDirective, ANIMATED_LIFECYCLE_TOKEN } from '@ethlete/core';
+import { TOGGLETIP_CONFIG, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT } from '../../constants';
+import { TOGGLETIP_DIRECTIVE } from '../../directives';
+import * as i0 from "@angular/core";
+export const TOGGLETIP = new InjectionToken('Toggletip');
+// TODO(TRB): The focus should get trapped inside the toggletip.
+// The toggletip trigger should get a aria-haspopup="true" and aria-expanded="true" attribute.
+class ToggletipComponent {
+    constructor() {
+        this._config = inject(TOGGLETIP_CONFIG);
+        this.toggletipText = inject(TOGGLETIP_TEXT, { optional: true });
+        this.toggletipTemplate = inject(TOGGLETIP_TEMPLATE, { optional: true });
+        this.injector = inject(Injector);
+        this._cdr = inject(ChangeDetectorRef);
+        this._trigger = inject(TOGGLETIP_DIRECTIVE);
+    }
+    get attrAriaHidden() {
+        return true;
+    }
+    get usesDefaultAnimation() {
+        return !this._config.customAnimated;
+    }
+    get containerClass() {
+        return this._config.containerClass;
+    }
+    _markForCheck() {
+        this._cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ToggletipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ToggletipComponent, isStandalone: true, selector: "et-toggletip", host: { properties: { "attr.aria-hidden": "this.attrAriaHidden", "class.et-with-default-animation": "this.usesDefaultAnimation", "class": "this.containerClass" }, classAttribute: "et-toggletip" }, providers: [
+            {
+                provide: TOGGLETIP,
+                useExisting: ToggletipComponent,
+            },
+        ], viewQueries: [{ propertyName: "_animatedLifecycle", first: true, predicate: ANIMATED_LIFECYCLE_TOKEN, descendants: true, static: true }], ngImport: i0, template: "<div class=\"et-toggletip-container\" etAnimatedLifecycle>\n  <ng-container *ngIf=\"toggletipText\">\n    {{ toggletipText }}\n  </ng-container>\n\n  <ng-container *ngIf=\"toggletipTemplate\">\n    <ng-container *ngTemplateOutlet=\"toggletipTemplate; injector: injector\" />\n  </ng-container>\n\n  <div class=\"toggletip-arrow\" data-popper-arrow></div>\n</div>\n", styles: [":where(.et-toggletip){--background-color: hsl(0 0% 20%);--foreground-color: CanvasText;--border-radius: 4px;--padding-inline: 1.5ch;--padding-block: .75ch;--inline-max-size: 25ch;--arrow-size: 10px;--arrow-radius: 2px}.et-toggletip[data-popper-placement^=top] .toggletip-arrow{bottom:-4px}.et-toggletip[data-popper-placement^=right] .toggletip-arrow{left:-4px}.et-toggletip[data-popper-placement^=bottom] .toggletip-arrow{top:-4px}.et-toggletip[data-popper-placement^=left] .toggletip-arrow{right:-4px}.et-toggletip-container{z-index:1;inline-size:max-content;max-inline-size:var(--inline-max-size);padding:var(--padding-block) var(--padding-inline);border-radius:var(--border-radius);background:var(--background-color);color:var(--foreground-color)}.et-toggletip-container:before{content:\"; Has toggletip: \";clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;width:1px;margin:-1px;overflow:hidden;padding:0;position:absolute}.toggletip-arrow{inline-size:var(--arrow-size);block-size:var(--arrow-size);position:absolute;z-index:-1}.toggletip-arrow:before{inline-size:var(--arrow-size);block-size:var(--arrow-size);border-radius:var(--arrow-radius);position:absolute;z-index:-1;transform:rotate(45deg);background:var(--background-color);top:0;left:0;content:\"\"}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to{opacity:0}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from .toggletip-arrow:before,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to .toggletip-arrow:before{transform:rotate(45deg) scale(0)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active{transition:transform .2s var(--ease-out-5),opacity .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active .toggletip-arrow:before{transition:transform .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active{transition:transform .15s var(--ease-in-5),opacity .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active .toggletip-arrow:before{transition:transform .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation[data-popper-placement^=top] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=top] .et-toggletip-container.et-animation-leave-to{transform:translateY(5px)}.et-toggletip.et-with-default-animation[data-popper-placement^=right] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=right] .et-toggletip-container.et-animation-leave-to{transform:translate(-5px)}.et-toggletip.et-with-default-animation[data-popper-placement^=bottom] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=bottom] .et-toggletip-container.et-animation-leave-to{transform:translateY(-5px)}.et-toggletip.et-with-default-animation[data-popper-placement^=left] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=left] .et-toggletip-container.et-animation-leave-to{transform:translate(5px)}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: AnimatedLifecycleDirective, selector: "[etAnimatedLifecycle]", exportAs: ["etAnimatedLifecycle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { ToggletipComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ToggletipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-toggletip', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [NgIf, NgTemplateOutlet, AnimatedLifecycleDirective], host: {
+                        class: 'et-toggletip',
+                    }, providers: [
+                        {
+                            provide: TOGGLETIP,
+                            useExisting: ToggletipComponent,
+                        },
+                    ], template: "<div class=\"et-toggletip-container\" etAnimatedLifecycle>\n  <ng-container *ngIf=\"toggletipText\">\n    {{ toggletipText }}\n  </ng-container>\n\n  <ng-container *ngIf=\"toggletipTemplate\">\n    <ng-container *ngTemplateOutlet=\"toggletipTemplate; injector: injector\" />\n  </ng-container>\n\n  <div class=\"toggletip-arrow\" data-popper-arrow></div>\n</div>\n", styles: [":where(.et-toggletip){--background-color: hsl(0 0% 20%);--foreground-color: CanvasText;--border-radius: 4px;--padding-inline: 1.5ch;--padding-block: .75ch;--inline-max-size: 25ch;--arrow-size: 10px;--arrow-radius: 2px}.et-toggletip[data-popper-placement^=top] .toggletip-arrow{bottom:-4px}.et-toggletip[data-popper-placement^=right] .toggletip-arrow{left:-4px}.et-toggletip[data-popper-placement^=bottom] .toggletip-arrow{top:-4px}.et-toggletip[data-popper-placement^=left] .toggletip-arrow{right:-4px}.et-toggletip-container{z-index:1;inline-size:max-content;max-inline-size:var(--inline-max-size);padding:var(--padding-block) var(--padding-inline);border-radius:var(--border-radius);background:var(--background-color);color:var(--foreground-color)}.et-toggletip-container:before{content:\"; Has toggletip: \";clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;width:1px;margin:-1px;overflow:hidden;padding:0;position:absolute}.toggletip-arrow{inline-size:var(--arrow-size);block-size:var(--arrow-size);position:absolute;z-index:-1}.toggletip-arrow:before{inline-size:var(--arrow-size);block-size:var(--arrow-size);border-radius:var(--arrow-radius);position:absolute;z-index:-1;transform:rotate(45deg);background:var(--background-color);top:0;left:0;content:\"\"}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to{opacity:0}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-from .toggletip-arrow:before,.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-to .toggletip-arrow:before{transform:rotate(45deg) scale(0)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active{transition:transform .2s var(--ease-out-5),opacity .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-enter-active .toggletip-arrow:before{transition:transform .2s var(--ease-out-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active{transition:transform .15s var(--ease-in-5),opacity .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation .et-toggletip-container.et-animation-leave-active .toggletip-arrow:before{transition:transform .15s var(--ease-in-5)}.et-toggletip.et-with-default-animation[data-popper-placement^=top] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=top] .et-toggletip-container.et-animation-leave-to{transform:translateY(5px)}.et-toggletip.et-with-default-animation[data-popper-placement^=right] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=right] .et-toggletip-container.et-animation-leave-to{transform:translate(-5px)}.et-toggletip.et-with-default-animation[data-popper-placement^=bottom] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=bottom] .et-toggletip-container.et-animation-leave-to{transform:translateY(-5px)}.et-toggletip.et-with-default-animation[data-popper-placement^=left] .et-toggletip-container.et-animation-enter-from,.et-toggletip.et-with-default-animation[data-popper-placement^=left] .et-toggletip-container.et-animation-leave-to{transform:translate(5px)}\n"] }]
+        }], propDecorators: { _animatedLifecycle: [{
+                type: ViewChild,
+                args: [ANIMATED_LIFECYCLE_TOKEN, { static: true }]
+            }], attrAriaHidden: [{
+                type: HostBinding,
+                args: ['attr.aria-hidden']
+            }], usesDefaultAnimation: [{
+                type: HostBinding,
+                args: ['class.et-with-default-animation']
+            }], containerClass: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/toggletip/directives/toggletip/toggletip.directive.mjs

@@ -0,0 +1,197 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Overlay } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Directive, ElementRef, EventEmitter, inject, InjectionToken, Injector, Input, NgZone, Output, ViewContainerRef, } from '@angular/core';
+import { ClickObserverService, nextFrame } from '@ethlete/core';
+import { createPopper } from '@popperjs/core';
+import { filter, fromEvent, take, tap } from 'rxjs';
+import { ToggletipComponent } from '../../components';
+import { TOGGLETIP_CONFIG, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT } from '../../constants';
+import { createToggletipConfig } from '../../utils';
+import * as i0 from "@angular/core";
+export const TOGGLETIP_DIRECTIVE = new InjectionToken('TOGGLETIP_DIRECTIVE');
+class ToggletipDirective {
+    constructor() {
+        this._defaultConfig = inject(TOGGLETIP_CONFIG, { optional: true }) ?? createToggletipConfig();
+        this._toggletip = null;
+        this._showToggletip = false;
+        this.placement = this._defaultConfig.placement;
+        this.toggletipClose = new EventEmitter();
+        this._hostElementRef = inject(ElementRef);
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._overlayService = inject(Overlay);
+        this._clickObserverService = inject(ClickObserverService);
+        this._injector = inject(Injector);
+        this._zone = inject(NgZone);
+        this._overlayRef = null;
+        this._portal = null;
+        this._toggletipRef = null;
+        this._popper = null;
+        this._listenerSubscriptions = [];
+    }
+    get toggletip() {
+        return this._toggletip;
+    }
+    set toggletip(v) {
+        this._toggletip = v;
+    }
+    get showToggletip() {
+        return this._showToggletip;
+    }
+    set showToggletip(value) {
+        this._showToggletip = coerceBooleanProperty(value);
+        if (this._showToggletip && !this._overlayRef) {
+            nextFrame(() => {
+                this._mountToggletip();
+                this._addListeners();
+            });
+        }
+        else if (!this._showToggletip && this._overlayRef) {
+            this._animateUnmount();
+            this._removeListeners();
+        }
+    }
+    ngOnDestroy() {
+        this._unmountToggletip();
+        this._removeListeners();
+    }
+    _addListeners() {
+        const keyupEscSub = fromEvent(document, 'keyup')
+            .pipe(filter((e) => e.key === 'Escape'), tap(() => this._animateUnmount()))
+            .subscribe();
+        const clickOutsideSub = this._clickObserverService
+            .observe(this._toggletipRef?.location.nativeElement)
+            .subscribe((e) => {
+            const targetElement = e.target;
+            const isInside = this._toggletipRef?.location.nativeElement.contains(targetElement);
+            if (!isInside) {
+                this._animateUnmount();
+            }
+        });
+        this._listenerSubscriptions.push(keyupEscSub, clickOutsideSub);
+    }
+    _removeListeners() {
+        this._listenerSubscriptions.forEach((s) => s.unsubscribe());
+        this._listenerSubscriptions.length = 0;
+    }
+    _mountToggletip() {
+        this._overlayRef = this._createOverlay();
+        const injector = Injector.create({
+            parent: this._injector,
+            providers: [
+                {
+                    provide: TOGGLETIP_CONFIG,
+                    useValue: this._defaultConfig,
+                },
+                ...[
+                    typeof this.toggletip === 'string'
+                        ? {
+                            provide: TOGGLETIP_TEXT,
+                            useValue: this.toggletip,
+                        }
+                        : {
+                            provide: TOGGLETIP_TEMPLATE,
+                            useValue: this.toggletip,
+                        },
+                ],
+            ],
+        });
+        this._portal = this._portal ?? new ComponentPortal(ToggletipComponent, this._viewContainerRef, injector);
+        this._toggletipRef = this._overlayRef.attach(this._portal);
+        this._toggletipRef.instance._markForCheck();
+        this._zone.runOutsideAngular(() => {
+            if (!this._toggletipRef) {
+                return;
+            }
+            this._popper = createPopper(this._hostElementRef.nativeElement, this._toggletipRef.location.nativeElement, {
+                placement: this.placement,
+                modifiers: [
+                    ...(this._defaultConfig.offset
+                        ? [
+                            {
+                                name: 'offset',
+                                options: {
+                                    offset: this._defaultConfig.offset,
+                                },
+                            },
+                        ]
+                        : []),
+                    ...(this._defaultConfig.arrowPadding
+                        ? [
+                            {
+                                name: 'arrow',
+                                options: {
+                                    padding: this._defaultConfig.arrowPadding,
+                                },
+                            },
+                        ]
+                        : []),
+                ],
+            });
+            // We need to wait for the toggletip content to be rendered
+            nextFrame(() => {
+                if (!this._toggletipRef) {
+                    return;
+                }
+                this._popper?.update();
+                this._toggletipRef.instance._animatedLifecycle?.enter();
+            });
+        });
+    }
+    _animateUnmount() {
+        if (!this._toggletipRef || this._toggletipRef.instance._animatedLifecycle?.state === 'leaving') {
+            return;
+        }
+        this._toggletipRef.instance._animatedLifecycle?.leave();
+        this._toggletipRef.instance._animatedLifecycle?.state$
+            .pipe(filter((s) => s === 'left'), take(1))
+            .subscribe(() => this._unmountToggletip());
+    }
+    _unmountToggletip() {
+        this._zone.runOutsideAngular(() => {
+            this._popper?.destroy();
+            this._popper = null;
+        });
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
+            this._overlayRef = null;
+        }
+        this._removeListeners();
+        this.toggletipClose.emit();
+    }
+    _createOverlay() {
+        const overlay = this._overlayService.create();
+        return overlay;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ToggletipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: ToggletipDirective, isStandalone: true, selector: "[etToggletip]", inputs: { toggletip: ["etToggletip", "toggletip"], showToggletip: "showToggletip", placement: "placement" }, outputs: { toggletipClose: "toggletipClose" }, providers: [
+            {
+                provide: TOGGLETIP_DIRECTIVE,
+                useExisting: ToggletipDirective,
+            },
+        ], ngImport: i0 }); }
+}
+export { ToggletipDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ToggletipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etToggletip]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: TOGGLETIP_DIRECTIVE,
+                            useExisting: ToggletipDirective,
+                        },
+                    ],
+                }]
+        }], propDecorators: { toggletip: [{
+                type: Input,
+                args: ['etToggletip']
+            }], showToggletip: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], toggletipClose: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toggletip.directive.js","sourceRoot":"","sources":["../../../../../../../../../../../libs/cdk/src/lib/components/overlay/components/toggletip/directives/toggletip/toggletip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Overlay, OverlayRef } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport {\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  inject,\n  InjectionToken,\n  Injector,\n  Input,\n  NgZone,\n  OnDestroy,\n  Output,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport { ClickObserverService, nextFrame } from '@ethlete/core';\nimport { createPopper, Instance as PopperInstance, Placement as PopperPlacement } from '@popperjs/core';\nimport { filter, fromEvent, Subscription, take, tap } from 'rxjs';\nimport { ToggletipComponent } from '../../components';\nimport { TOGGLETIP_CONFIG, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT } from '../../constants';\nimport { ToggletipConfig } from '../../types';\nimport { createToggletipConfig } from '../../utils';\n\ntype ToggletipTemplate = string | TemplateRef<unknown>;\n\nexport const TOGGLETIP_DIRECTIVE = new InjectionToken<ToggletipDirective>('TOGGLETIP_DIRECTIVE');\n\n@Directive({\n  selector: '[etToggletip]',\n  standalone: true,\n  providers: [\n    {\n      provide: TOGGLETIP_DIRECTIVE,\n      useExisting: ToggletipDirective,\n    },\n  ],\n})\nexport class ToggletipDirective implements OnDestroy {\n  private _defaultConfig = inject<ToggletipConfig>(TOGGLETIP_CONFIG, { optional: true }) ?? createToggletipConfig();\n\n  @Input('etToggletip')\n  get toggletip() {\n    return this._toggletip;\n  }\n  set toggletip(v: ToggletipTemplate | null) {\n    this._toggletip = v;\n  }\n  private _toggletip: ToggletipTemplate | null = null;\n\n  @Input()\n  get showToggletip(): boolean {\n    return this._showToggletip;\n  }\n  set showToggletip(value: BooleanInput) {\n    this._showToggletip = coerceBooleanProperty(value);\n\n    if (this._showToggletip && !this._overlayRef) {\n      nextFrame(() => {\n        this._mountToggletip();\n        this._addListeners();\n      });\n    } else if (!this._showToggletip && this._overlayRef) {\n      this._animateUnmount();\n      this._removeListeners();\n    }\n  }\n  private _showToggletip = false;\n\n  @Input()\n  placement: PopperPlacement = this._defaultConfig.placement;\n\n  @Output()\n  toggletipClose = new EventEmitter();\n\n  private _hostElementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private _viewContainerRef = inject(ViewContainerRef);\n  private _overlayService = inject(Overlay);\n  private _clickObserverService = inject(ClickObserverService);\n  private _injector = inject(Injector);\n  private _zone = inject(NgZone);\n\n  private _overlayRef: OverlayRef | null = null;\n  private _portal: ComponentPortal<ToggletipComponent> | null = null;\n  private _toggletipRef: ComponentRef<ToggletipComponent> | null = null;\n  private _popper: PopperInstance | null = null;\n\n  private readonly _listenerSubscriptions: Subscription[] = [];\n\n  ngOnDestroy(): void {\n    this._unmountToggletip();\n    this._removeListeners();\n  }\n\n  private _addListeners() {\n    const keyupEscSub = fromEvent<KeyboardEvent>(document, 'keyup')\n      .pipe(\n        filter((e) => e.key === 'Escape'),\n        tap(() => this._animateUnmount()),\n      )\n      .subscribe();\n\n    const clickOutsideSub = this._clickObserverService\n      .observe(this._toggletipRef?.location.nativeElement)\n      .subscribe((e) => {\n        const targetElement = e.target as HTMLElement;\n        const isInside = this._toggletipRef?.location.nativeElement.contains(targetElement);\n\n        if (!isInside) {\n          this._animateUnmount();\n        }\n      });\n\n    this._listenerSubscriptions.push(keyupEscSub, clickOutsideSub);\n  }\n\n  private _removeListeners() {\n    this._listenerSubscriptions.forEach((s) => s.unsubscribe());\n    this._listenerSubscriptions.length = 0;\n  }\n\n  private _mountToggletip() {\n    this._overlayRef = this._createOverlay();\n\n    const injector = Injector.create({\n      parent: this._injector,\n      providers: [\n        {\n          provide: TOGGLETIP_CONFIG,\n          useValue: this._defaultConfig,\n        },\n        ...[\n          typeof this.toggletip === 'string'\n            ? {\n                provide: TOGGLETIP_TEXT,\n                useValue: this.toggletip,\n              }\n            : {\n                provide: TOGGLETIP_TEMPLATE,\n                useValue: this.toggletip,\n              },\n        ],\n      ],\n    });\n\n    this._portal = this._portal ?? new ComponentPortal(ToggletipComponent, this._viewContainerRef, injector);\n    this._toggletipRef = this._overlayRef.attach(this._portal);\n\n    this._toggletipRef.instance._markForCheck();\n\n    this._zone.runOutsideAngular(() => {\n      if (!this._toggletipRef) {\n        return;\n      }\n\n      this._popper = createPopper(this._hostElementRef.nativeElement, this._toggletipRef.location.nativeElement, {\n        placement: this.placement,\n        modifiers: [\n          ...(this._defaultConfig.offset\n            ? [\n                {\n                  name: 'offset',\n                  options: {\n                    offset: this._defaultConfig.offset,\n                  },\n                },\n              ]\n            : []),\n          ...(this._defaultConfig.arrowPadding\n            ? [\n                {\n                  name: 'arrow',\n                  options: {\n                    padding: this._defaultConfig.arrowPadding,\n                  },\n                },\n              ]\n            : []),\n        ],\n      });\n\n      // We need to wait for the toggletip content to be rendered\n      nextFrame(() => {\n        if (!this._toggletipRef) {\n          return;\n        }\n\n        this._popper?.update();\n        this._toggletipRef.instance._animatedLifecycle?.enter();\n      });\n    });\n  }\n\n  _animateUnmount() {\n    if (!this._toggletipRef || this._toggletipRef.instance._animatedLifecycle?.state === 'leaving') {\n      return;\n    }\n\n    this._toggletipRef.instance._animatedLifecycle?.leave();\n\n    this._toggletipRef.instance._animatedLifecycle?.state$\n      .pipe(\n        filter((s) => s === 'left'),\n        take(1),\n      )\n      .subscribe(() => this._unmountToggletip());\n  }\n\n  private _unmountToggletip() {\n    this._zone.runOutsideAngular(() => {\n      this._popper?.destroy();\n      this._popper = null;\n    });\n\n    if (this._overlayRef) {\n      this._overlayRef.dispose();\n      this._overlayRef = null;\n    }\n\n    this._removeListeners();\n\n    this.toggletipClose.emit();\n  }\n\n  private _createOverlay() {\n    const overlay = this._overlayService.create();\n\n    return overlay;\n  }\n}\n"]}