@theseam/ui-common 0.3.15-beta.0 → 0.3.15-beta.1

package/esm2020/popover/popover/popover.component.mjs

@@ -0,0 +1,156 @@
+import { transition, trigger, useAnimation } from '@angular/animations';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
+import { ChangeDetectionStrategy, Component, HostBinding, HostListener, Input } from '@angular/core';
+import { BehaviorSubject, fromEvent, of, Subject } from 'rxjs';
+import { distinctUntilChanged, map, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import { popoverExpandIn, popoverExpandOut } from '../popover-animations';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class PopoverComponent {
+    // @HostBinding('attr.role') get _role() { return this._config.role }
+    get _role() { return 'dialog'; }
+    get _tabindex() { return -1; }
+    /**
+     * Defines a width for a popover that will scale down if the window innerWidth is
+     * smaller than the value.
+     */
+    get baseWidth() { return this._baseWidth.value; }
+    set baseWidth(value) {
+        const _val = coerceNumberProperty(value, null);
+        if (_val !== this._baseWidth.value) {
+            this._baseWidth.next(_val);
+        }
+    }
+    constructor(_changeDetectorRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._ngUnsubscribe = new Subject();
+        /** Duration of the enter animation. Has to be a valid CSS value (e.g. 100ms). */
+        this.enterAnimationDuration = '225ms';
+        /** Duration of the exit animation. Has to be a valid CSS value (e.g. 50ms). */
+        this.exitAnimationDuration = '225ms';
+        /** State of the dialog animation. */
+        this._state = 'enter';
+        /** A subject emitting before the dialog enters the view. */
+        this._beforeEnter = new Subject();
+        /** A subject emitting after the dialog enters the view. */
+        this._afterEnter = new Subject();
+        /** A subject emitting before the dialog exits the view. */
+        this._beforeExit = new Subject();
+        /** A subject emitting after the dialog exits the view. */
+        this._afterExit = new Subject();
+        /** Stream of animation `done` events. */
+        this._animationDone = new Subject();
+        this._baseWidth = new BehaviorSubject(600);
+        // We use a Subject with a distinctUntilChanged, rather than a callback attached to .done,
+        // because some browsers fire the done event twice and we don't want to emit duplicate events.
+        // See: https://github.com/angular/angular/issues/24084
+        this._animationDone.pipe(distinctUntilChanged((x, y) => {
+            return x.fromState === y.fromState && x.toState === y.toState;
+        })).subscribe(event => {
+            // Emit lifecycle events based on animation `done` callback.
+            if (event.toState === 'enter') {
+                this._afterEnter.next();
+                this._afterEnter.complete();
+            }
+            if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {
+                this._afterExit.next();
+                this._afterExit.complete();
+            }
+        });
+    }
+    ngOnInit() {
+        // this._popoverWidth$ =
+        this._baseWidth.pipe(switchMap(baseWidth => {
+            if (baseWidth) {
+                return fromEvent(window, 'resize').pipe(startWith(undefined), map(() => window.innerWidth < baseWidth ? `${window.innerWidth}px` : `${baseWidth}px`));
+            }
+            return of(undefined);
+        }), takeUntil(this._ngUnsubscribe)).subscribe(w => {
+            this._popoverWidth = w;
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        // this.closed.complete()
+        this._animationDone.complete();
+        this._ngUnsubscribe.next(undefined);
+        this._ngUnsubscribe.complete();
+    }
+    /** Starts the dialog exit animation. */
+    _startExiting() {
+        this._state = 'exit';
+        // Mark the container for check so it can react if the
+        // view container is using OnPush change detection.
+        this._changeDetectorRef.markForCheck();
+    }
+    /** Emit lifecycle events based on animation `start` callback. */
+    _onAnimationStart(event) {
+        if (event.toState === 'enter') {
+            this._beforeEnter.next();
+            this._beforeEnter.complete();
+        }
+        if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {
+            this._beforeExit.next();
+            this._beforeExit.complete();
+        }
+    }
+    /** Handle a keyboard event from the menu, delegating to the appropriate action. */
+    _handleKeydown(event) {
+        // tslint:disable-next-line:deprecation
+        const keyCode = event.keyCode;
+        switch (keyCode) {
+            case ESCAPE:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    // this.closed.emit('keydown')
+                    this._startExiting();
+                }
+                break;
+        }
+    }
+}
+PopoverComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PopoverComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PopoverComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: PopoverComponent, selector: "seam-popover", inputs: { template: "template", popoverClass: "popoverClass", baseWidth: "baseWidth" }, host: { listeners: { "@slideDown.start": "_onAnimationStart($event)", "@slideDown.done": "_animationDone.next($event)", "keydown": "_handleKeydown($event)" }, properties: { "@slideDown": "{\n      value: _state,\n      params: {\n        enterAnimationDuration: enterAnimationDuration,\n        exitAnimationDuration: exitAnimationDuration\n      }\n    }", "style.width": "_popoverWidth", "attr.role": "this._role", "attr.tabindex": "this._tabindex" }, classAttribute: "popover show m-2 position-static" }, ngImport: i0, template: "<div class=\"popover-body\">\n  <ng-container *ngIf=\"template; else noTemplate\">\n    <ng-template [ngTemplateOutlet]=\"template\"></ng-template>\n  </ng-container>\n\n  <ng-template #noTemplate>\n    Example\n    <!-- <ng-content></ng-content> -->\n  </ng-template>\n</div>\n", styles: [":host{display:block;max-width:800px;min-width:100%}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], animations: [
+        trigger('slideDown', [
+            transition(':enter', useAnimation(popoverExpandIn)),
+            transition(':leave', useAnimation(popoverExpandOut)),
+        ])
+    ], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PopoverComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-popover', animations: [
+                        trigger('slideDown', [
+                            transition(':enter', useAnimation(popoverExpandIn)),
+                            transition(':leave', useAnimation(popoverExpandOut)),
+                        ])
+                    ], host: {
+                        class: 'popover show m-2 position-static',
+                        '[@slideDown]': `{
+      value: _state,
+      params: {
+        enterAnimationDuration: enterAnimationDuration,
+        exitAnimationDuration: exitAnimationDuration
+      }
+    }`,
+                        '(@slideDown.start)': '_onAnimationStart($event)',
+                        '(@slideDown.done)': '_animationDone.next($event)',
+                        '[style.width]': '_popoverWidth'
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"popover-body\">\n  <ng-container *ngIf=\"template; else noTemplate\">\n    <ng-template [ngTemplateOutlet]=\"template\"></ng-template>\n  </ng-container>\n\n  <ng-template #noTemplate>\n    Example\n    <!-- <ng-content></ng-content> -->\n  </ng-template>\n</div>\n", styles: [":host{display:block;max-width:800px;min-width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { _role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], _tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], template: [{
+                type: Input
+            }], popoverClass: [{
+                type: Input
+            }], baseWidth: [{
+                type: Input
+            }], _handleKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/popover/popover/popover.component.ts","../../../../../projects/ui-common/popover/popover/popover.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AnimationEvent, transition, trigger, useAnimation } from '@angular/animations'\nimport { coerceNumberProperty } from '@angular/cdk/coercion'\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes'\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  HostBinding,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  TemplateRef\n} from '@angular/core'\nimport { BehaviorSubject, fromEvent, Observable, of, Subject } from 'rxjs'\nimport { distinctUntilChanged, map, startWith, switchMap, takeUntil } from 'rxjs/operators'\n\nimport { popoverExpandIn, popoverExpandOut, popoverSlideIn, popoverSlideOut } from '../popover-animations'\n\n@Component({\n  selector: 'seam-popover',\n  templateUrl: './popover.component.html',\n  styleUrls: ['./popover.component.scss'],\n  animations: [\n    trigger('slideDown', [\n      transition(':enter', useAnimation(popoverExpandIn)),\n      transition(':leave', useAnimation(popoverExpandOut)),\n    ])\n  ],\n  host: {\n    class: 'popover show m-2 position-static',\n    '[@slideDown]': `{\n      value: _state,\n      params: {\n        enterAnimationDuration: enterAnimationDuration,\n        exitAnimationDuration: exitAnimationDuration\n      }\n    }`,\n    '(@slideDown.start)': '_onAnimationStart($event)',\n    '(@slideDown.done)': '_animationDone.next($event)',\n    '[style.width]': '_popoverWidth'\n  },\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PopoverComponent implements OnInit, OnDestroy {\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  /** Duration of the enter animation. Has to be a valid CSS value (e.g. 100ms). */\n  enterAnimationDuration?: string = '225ms'\n\n  /** Duration of the exit animation. Has to be a valid CSS value (e.g. 50ms). */\n  exitAnimationDuration?: string = '225ms'\n\n  /** State of the dialog animation. */\n  _state: 'void' | 'enter' | 'exit' = 'enter'\n\n  /** A subject emitting before the dialog enters the view. */\n  _beforeEnter: Subject<void> = new Subject()\n\n  /** A subject emitting after the dialog enters the view. */\n  _afterEnter: Subject<void> = new Subject()\n\n  /** A subject emitting before the dialog exits the view. */\n  _beforeExit: Subject<void> = new Subject()\n\n  /** A subject emitting after the dialog exits the view. */\n  _afterExit: Subject<void> = new Subject()\n\n  /** Stream of animation `done` events. */\n  _animationDone = new Subject<AnimationEvent>()\n\n  // @HostBinding('attr.role') get _role() { return this._config.role }\n  @HostBinding('attr.role') get _role() { return 'dialog' }\n\n  @HostBinding('attr.tabindex') get _tabindex() { return -1 }\n\n  @Input() template: TemplateRef<any> | undefined | null\n\n  // @Output() readonly closed = new EventEmitter<void | 'click' | 'keydown'>()\n\n  @Input() popoverClass: string | undefined | null\n\n  /**\n   * Defines a width for a popover that will scale down if the window innerWidth is\n   * smaller than the value.\n   */\n  @Input()\n  get baseWidth() { return this._baseWidth.value }\n  set baseWidth(value: number | null) {\n    const _val = coerceNumberProperty(value, null)\n    if (_val !== this._baseWidth.value) {\n      this._baseWidth.next(_val)\n    }\n  }\n  private _baseWidth = new BehaviorSubject<number | null>(600)\n  // _popoverWidth$: Observable<string | undefined>\n  _popoverWidth: string | undefined\n\n  constructor(\n    private _changeDetectorRef: ChangeDetectorRef,\n    // TODO: Implement PopoverConfig\n  ) {\n    // We use a Subject with a distinctUntilChanged, rather than a callback attached to .done,\n    // because some browsers fire the done event twice and we don't want to emit duplicate events.\n    // See: https://github.com/angular/angular/issues/24084\n    this._animationDone.pipe(distinctUntilChanged((x, y) => {\n      return x.fromState === y.fromState && x.toState === y.toState\n    })).subscribe(event => {\n      // Emit lifecycle events based on animation `done` callback.\n      if (event.toState === 'enter') {\n        this._afterEnter.next()\n        this._afterEnter.complete()\n      }\n\n      if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {\n        this._afterExit.next()\n        this._afterExit.complete()\n      }\n    })\n  }\n\n  ngOnInit() {\n    // this._popoverWidth$ =\n    this._baseWidth.pipe(\n      switchMap(baseWidth => {\n        if (baseWidth) {\n          return fromEvent(window, 'resize').pipe(\n            startWith(undefined),\n            map(() => window.innerWidth < baseWidth ? `${window.innerWidth}px` : `${baseWidth}px`)\n          )\n        }\n        return of(undefined)\n      }),\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe(w => {\n      this._popoverWidth = w\n      this._changeDetectorRef.markForCheck()\n    })\n  }\n\n  ngOnDestroy() {\n    // this.closed.complete()\n    this._animationDone.complete()\n\n    this._ngUnsubscribe.next(undefined)\n    this._ngUnsubscribe.complete()\n  }\n\n  /** Starts the dialog exit animation. */\n  _startExiting(): void {\n    this._state = 'exit'\n\n    // Mark the container for check so it can react if the\n    // view container is using OnPush change detection.\n    this._changeDetectorRef.markForCheck()\n  }\n\n  /** Emit lifecycle events based on animation `start` callback. */\n  _onAnimationStart(event: AnimationEvent) {\n    if (event.toState === 'enter') {\n      this._beforeEnter.next()\n      this._beforeEnter.complete()\n    }\n    if (event.fromState === 'enter' && (event.toState === 'void' || event.toState === 'exit')) {\n      this._beforeExit.next()\n      this._beforeExit.complete()\n    }\n  }\n\n  /** Handle a keyboard event from the menu, delegating to the appropriate action. */\n  @HostListener('keydown', [ '$event' ])\n  _handleKeydown(event: KeyboardEvent) {\n    // tslint:disable-next-line:deprecation\n    const keyCode = event.keyCode\n\n    switch (keyCode) {\n      case ESCAPE:\n        if (!hasModifierKey(event)) {\n          event.preventDefault()\n          // this.closed.emit('keydown')\n          this._startExiting()\n        }\n        break\n    }\n  }\n\n}\n","<div class=\"popover-body\">\n  <ng-container *ngIf=\"template; else noTemplate\">\n    <ng-template [ngTemplateOutlet]=\"template\"></ng-template>\n  </ng-container>\n\n  <ng-template #noTemplate>\n    Example\n    <!-- <ng-content></ng-content> -->\n  </ng-template>\n</div>\n"]}

package/esm2020/popover/popover.directive.mjs

@@ -0,0 +1,260 @@
+import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { ESCAPE } from '@angular/cdk/keycodes';
+import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Directive, HostListener, Input } from '@angular/core';
+import { BehaviorSubject, merge, of, Subject, Subscription } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { PopoverComponent } from './popover/popover.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/cdk/a11y";
+/** Options for binding a passive event listener. */
+const passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
+export class TheSeamPopoverDirective {
+    /**
+     * Defines a width for a popover that will scale down if the window innerWidth is
+     * smaller than the value.
+     */
+    get seamPopoverBaseWidth() { return this._seamPopoverBaseWidth.value; }
+    set seamPopoverBaseWidth(value) {
+        const _val = coerceNumberProperty(value, null);
+        if (_val !== this._seamPopoverBaseWidth.value) {
+            this._seamPopoverBaseWidth.next(_val);
+        }
+    }
+    get seamPopoverDisabled() { return this._seamPopoverDisabled.value; }
+    set seamPopoverDisabled(val) { this._seamPopoverDisabled.next(coerceBooleanProperty(val)); }
+    _onMouseDown(event) {
+        if (!isFakeMousedownFromScreenReader(event)) {
+            // Since right or middle button clicks won't trigger the `click` event,
+            // we shouldn't consider the menu as opened by mouse in those cases.
+            this._openedBy = event.button === 0 ? 'mouse' : null;
+        }
+    }
+    _onClick(event) {
+        this.toggle();
+    }
+    _onDocumentKeydown(event) {
+        if (event.keyCode === ESCAPE) {
+            this.closePopover();
+        }
+    }
+    constructor(_elementRef, _viewContainerRef, _overlay, _focusMonitor) {
+        this._elementRef = _elementRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._overlay = _overlay;
+        this._focusMonitor = _focusMonitor;
+        this._ngUnsubscribe = new Subject();
+        this._seamPopoverBaseWidth = new BehaviorSubject(null);
+        this._seamPopoverDisabled = new BehaviorSubject(false);
+        // ngOnInit() {
+        //   this._seamPopoverDisabled.pipe(
+        //     switchMap(disabled => {
+        //       if (disabled) {
+        //         this.close()
+        //         return of(undefined)
+        //       }
+        //       if (!(this._elementRef && this._elementRef.nativeElement)) {
+        //         return of(undefined)
+        //       }
+        //       return fromEvent(this._elementRef.nativeElement, 'click')
+        //     })
+        //   ).subscribe()
+        // }
+        this._active = false;
+        this._closing = false;
+        this._popoverClosedSubscription = Subscription.EMPTY;
+        this._closingActionsSubscription = Subscription.EMPTY;
+        this.restoreFocus = true;
+        // Tracking input type is necessary so it's possible to only auto-focus
+        // the first item of the list when the menu is opened via the keyboard
+        this._openedBy = null;
+        /**
+         * Handles touch start events on the trigger.
+         * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.
+         */
+        this._handleTouchStart = () => this._openedBy = 'touch';
+        this._elementRef.nativeElement.addEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
+        this._seamPopoverBaseWidth
+            .pipe(takeUntil(this._ngUnsubscribe))
+            .subscribe(w => {
+            if (this._compRef && this._compRef.instance) {
+                this._compRef.instance.baseWidth = w;
+                this._compRef.changeDetectorRef.markForCheck();
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.closePopover();
+        this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
+        this._popoverClosedSubscription.unsubscribe();
+        this._closingActionsSubscription.unsubscribe();
+        this._ngUnsubscribe.next(undefined);
+        this._ngUnsubscribe.complete();
+    }
+    toggle() {
+        if (this._active || this.seamPopoverDisabled) {
+            this.closePopover();
+        }
+        else {
+            this.openPopover();
+        }
+    }
+    openPopover() {
+        if (this._active || !this.seamPopover) {
+            return;
+        }
+        this._active = true;
+        this._overlayRef = this._overlay.create({
+            hasBackdrop: true,
+            backdropClass: 'transparent',
+            positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),
+        });
+        this._compRef = this._overlayRef.attach(new ComponentPortal(PopoverComponent, this._viewContainerRef));
+        this._closingActionsSubscription = this._popoverClosingActions().subscribe(() => this.closePopover());
+        this._compRef.instance.template = this.seamPopover;
+        this._compRef.instance.baseWidth = this.seamPopoverBaseWidth;
+        this._compRef.changeDetectorRef.markForCheck();
+        this._popoverClosedSubscription = this._compRef.instance._afterExit.subscribe(v => {
+            // console.log('closed', v)
+            if (this._overlayRef?.hasAttached()) {
+                this._overlayRef.detach();
+            }
+            this._resetPopover();
+            this._popoverClosedSubscription.unsubscribe();
+            this._closingActionsSubscription.unsubscribe();
+            this._active = false;
+            this._closing = false;
+        });
+    }
+    closePopover() {
+        if (!this._active) {
+            return;
+        }
+        if (!this._closing) {
+            if (this._compRef && this._compRef.instance) {
+                this._closing = true;
+                this._compRef.instance._startExiting();
+            }
+        }
+    }
+    popoverOpen() {
+        return this._overlayRef?.hasAttached() ?? false;
+    }
+    getOverlayPosition(origin) {
+        const positionStrategy = this._overlay.position()
+            .flexibleConnectedTo(origin)
+            .withPositions(this.getPositions())
+            .withFlexibleDimensions(false)
+            .withPush(true);
+        return positionStrategy;
+    }
+    getPositions() {
+        return [
+            {
+                originX: 'center',
+                originY: 'bottom',
+                overlayX: 'center',
+                overlayY: 'top'
+            },
+            {
+                originX: 'center',
+                originY: 'top',
+                overlayX: 'center',
+                overlayY: 'bottom'
+            },
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+            {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+            },
+            {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom',
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+            },
+        ];
+    }
+    /**
+     * Focuses the popover trigger.
+     * @param origin Source of the popover trigger's focus.
+     */
+    focus(origin = 'program') {
+        if (this._focusMonitor) {
+            this._focusMonitor.focusVia(this._elementRef, origin);
+        }
+        else {
+            this._elementRef.nativeElement.focus();
+        }
+    }
+    /**
+     * 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.
+     */
+    _resetPopover() {
+        // We should reset focus if the user is navigating using a keyboard or
+        // if we have a top-level trigger which might cause focus to be lost
+        // when clicking on the backdrop.
+        if (this.restoreFocus) {
+            if (!this._openedBy) {
+                // Note that the focus style will show up both for `program` and
+                // `keyboard` so we don't have to specify which one it is.
+                this.focus();
+            }
+        }
+        this._openedBy = null;
+    }
+    /** Returns a stream that emits whenever an action that should close the popover occurs. */
+    _popoverClosingActions() {
+        const backdrop = this._overlayRef?.backdropClick() ?? of();
+        const detachments = this._overlayRef?.detachments() ?? of();
+        const hover = of();
+        return merge(backdrop, hover, detachments);
+    }
+}
+TheSeamPopoverDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPopoverDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i1.Overlay }, { token: i2.FocusMonitor }], target: i0.ɵɵFactoryTarget.Directive });
+TheSeamPopoverDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: TheSeamPopoverDirective, selector: "[seamPopover]", inputs: { seamPopover: "seamPopover", seamPopoverBaseWidth: "seamPopoverBaseWidth", seamPopoverDisabled: "seamPopoverDisabled" }, host: { attributes: { "aria-haspopup": "true" }, listeners: { "mousedown": "_onMouseDown($event)", "click": "_onClick($event)", "document:keydown": "_onDocumentKeydown($event)" }, properties: { "attr.aria-expanded": "popoverOpen() || null" } }, exportAs: ["seamPopover"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPopoverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamPopover]',
+                    // tslint:disable-next-line:use-host-property-decorator
+                    host: {
+                        'aria-haspopup': 'true',
+                        '[attr.aria-expanded]': 'popoverOpen() || null'
+                    },
+                    exportAs: 'seamPopover'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i1.Overlay }, { type: i2.FocusMonitor }]; }, propDecorators: { seamPopover: [{
+                type: Input
+            }], seamPopoverBaseWidth: [{
+                type: Input
+            }], seamPopoverDisabled: [{
+                type: Input
+            }], _onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], _onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], _onDocumentKeydown: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.directive.js","sourceRoot":"","sources":["../../../../projects/ui-common/popover/popover.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,+BAA+B,EAAE,MAAM,mBAAmB,CAAA;AAC9F,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACnF,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAE9C,OAAO,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAgB,SAAS,EAAc,YAAY,EAAE,KAAK,EAAoD,MAAM,eAAe,CAAA;AAC1I,OAAO,EAAE,eAAe,EAAa,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AACnF,OAAO,EAAa,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAErD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;;;;AAE9D,oDAAoD;AACpD,MAAM,2BAA2B,GAAG,+BAA+B,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;AAWtF,MAAM,OAAO,uBAAuB;IAMlC;;;OAGG;IACH,IACI,oBAAoB,KAAK,OAAO,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAA,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,KAAoB;QAC3C,MAAM,IAAI,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;QAC9C,IAAI,IAAI,KAAK,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE;YAC7C,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;SACtC;IACH,CAAC;IAGD,IACI,mBAAmB,KAAK,OAAO,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAA,CAAC,CAAC;IACpE,IAAI,mBAAmB,CAAC,GAAY,IAAI,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAA,CAAC,CAAC;IAkCpG,YAAY,CAAC,KAAiB;QAC5B,IAAI,CAAC,+BAA+B,CAAC,KAAK,CAAC,EAAE;YAC3C,uEAAuE;YACvE,oEAAoE;YACpE,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAA;SACrD;IACH,CAAC;IAGD,QAAQ,CAAC,KAAU;QACjB,IAAI,CAAC,MAAM,EAAE,CAAA;IACf,CAAC;IAGD,kBAAkB,CAAC,KAAU;QAC3B,IAAI,KAAK,CAAC,OAAO,KAAK,MAAM,EAAE;YAC5B,IAAI,CAAC,YAAY,EAAE,CAAA;SACpB;IACH,CAAC;IAED,YACU,WAAoC,EACpC,iBAAmC,EACnC,QAAiB,EACjB,aAA2B;QAH3B,gBAAW,GAAX,WAAW,CAAyB;QACpC,sBAAiB,GAAjB,iBAAiB,CAAkB;QACnC,aAAQ,GAAR,QAAQ,CAAS;QACjB,kBAAa,GAAb,aAAa,CAAc;QA9EpB,mBAAc,GAAG,IAAI,OAAO,EAAQ,CAAA;QAgB7C,0BAAqB,GAAG,IAAI,eAAe,CAAgB,IAAI,CAAC,CAAA;QAKhE,yBAAoB,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAA;QAElE,eAAe;QACf,oCAAoC;QACpC,8BAA8B;QAC9B,wBAAwB;QACxB,uBAAuB;QACvB,+BAA+B;QAC/B,UAAU;QAEV,qEAAqE;QACrE,+BAA+B;QAC/B,UAAU;QAEV,kEAAkE;QAClE,SAAS;QACT,kBAAkB;QAClB,IAAI;QAEI,YAAO,GAAG,KAAK,CAAA;QACf,aAAQ,GAAG,KAAK,CAAA;QAGhB,+BAA0B,GAAG,YAAY,CAAC,KAAK,CAAA;QAC/C,gCAA2B,GAAG,YAAY,CAAC,KAAK,CAAA;QAEjD,iBAAY,GAAG,IAAI,CAAA;QAE1B,uEAAuE;QACvE,sEAAsE;QACtE,cAAS,GAA6B,IAAI,CAAA;QAuD1C;;;WAGG;QACK,sBAAiB,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAA;QA9BxD,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,gBAAgB,CAAC,YAAY,EAAE,IAAI,CAAC,iBAAiB,EAChF,2BAA2B,CAAC,CAAA;QAEhC,IAAI,CAAC,qBAAqB;aACvB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;aACpC,SAAS,CAAC,CAAC,CAAC,EAAE;YACb,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;gBAC3C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAA;gBACpC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAA;aAC/C;QACH,CAAC,CAAC,CAAA;IACN,CAAC;IAED,WAAW;QACT,IAAI,CAAC,YAAY,EAAE,CAAA;QAEnB,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,iBAAiB,EACnF,2BAA2B,CAAC,CAAA;QAEhC,IAAI,CAAC,0BAA0B,CAAC,WAAW,EAAE,CAAA;QAC7C,IAAI,CAAC,2BAA2B,CAAC,WAAW,EAAE,CAAA;QAE9C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACnC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAA;IAChC,CAAC;IAQM,MAAM;QACX,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC5C,IAAI,CAAC,YAAY,EAAE,CAAA;SACpB;aAAM;YACL,IAAI,CAAC,WAAW,EAAE,CAAA;SACnB;IACH,CAAC;IAEM,WAAW;QAChB,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YAAE,OAAM;SAAE;QACjD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;QAEnB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;YACtC,WAAW,EAAE,IAAI;YACjB,aAAa,EAAE,aAAa;YAC5B,gBAAgB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;SAC1E,CAAC,CAAA;QAEF,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,eAAe,CAAC,gBAAgB,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAA;QAEtG,IAAI,CAAC,2BAA2B,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAA;QAErG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAA;QAClD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC,oBAAoB,CAAA;QAC5D,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAA;QAE9C,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;YAChF,2BAA2B;YAC3B,IAAI,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,EAAE;gBACnC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAA;aAC1B;YAED,IAAI,CAAC,aAAa,EAAE,CAAA;YAEpB,IAAI,CAAC,0BAA0B,CAAC,WAAW,EAAE,CAAA;YAC7C,IAAI,CAAC,2BAA2B,CAAC,WAAW,EAAE,CAAA;YAE9C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;YACpB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAA;QACvB,CAAC,CAAC,CAAA;IACJ,CAAC;IAEM,YAAY;QACjB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YAAE,OAAM;SAAE;QAE7B,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;gBAC3C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;gBACpB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAA;aACvC;SACF;IACH,CAAC;IAEM,WAAW;QAChB,OAAO,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,KAAK,CAAA;IACjD,CAAC;IAEO,kBAAkB,CAAC,MAAmB;QAC5C,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;aAC9C,mBAAmB,CAAC,MAAM,CAAC;aAC3B,aAAa,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;aAClC,sBAAsB,CAAC,KAAK,CAAC;aAC7B,QAAQ,CAAC,IAAI,CAAC,CAAA;QAEjB,OAAO,gBAAgB,CAAA;IACzB,CAAC;IAEO,YAAY;QAClB,OAAO;YACL;gBACE,OAAO,EAAE,QAAQ;gBACjB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,KAAK;aAChB;YACD;gBACE,OAAO,EAAE,QAAQ;gBACjB,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,QAAQ;aACnB;YACD;gBACE,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,KAAK;gBACf,QAAQ,EAAE,KAAK;aAChB;YACD;gBACE,OAAO,EAAE,OAAO;gBAChB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,OAAO;gBACjB,QAAQ,EAAE,KAAK;aAChB;YACD;gBACE,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE,KAAK;gBACf,QAAQ,EAAE,QAAQ;aACnB;YACD;gBACE,OAAO,EAAE,OAAO;gBAChB,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE,OAAO;gBACjB,QAAQ,EAAE,QAAQ;aACnB;SACF,CAAA;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,SAAsB,SAAS;QACnC,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,CAAA;SACtD;aAAM;YACL,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAA;SACvC;IACH,CAAC;IAED;;;OAGG;IACK,aAAa;QACnB,sEAAsE;QACtE,oEAAoE;QACpE,iCAAiC;QACjC,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBACnB,gEAAgE;gBAChE,0DAA0D;gBAC1D,IAAI,CAAC,KAAK,EAAE,CAAA;aACb;SACF;QAED,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;IACvB,CAAC;IAED,2FAA2F;IACnF,sBAAsB;QAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,EAAE,IAAI,EAAE,EAAE,CAAA;QAC1D,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,CAAA;QAC3D,MAAM,KAAK,GAAG,EAAE,EAAE,CAAA;QAElB,OAAO,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,WAAW,CAAC,CAAA;IAC5C,CAAC;;oHApQU,uBAAuB;wGAAvB,uBAAuB;2FAAvB,uBAAuB;kBATnC,SAAS;mBAAC;oBACT,QAAQ,EAAE,eAAe;oBACzB,uDAAuD;oBACvD,IAAI,EAAE;wBACJ,eAAe,EAAE,MAAM;wBACvB,sBAAsB,EAAE,uBAAuB;qBAChD;oBACD,QAAQ,EAAE,aAAa;iBACxB;iLAKU,WAAW;sBAAnB,KAAK;gBAOF,oBAAoB;sBADvB,KAAK;gBAWF,mBAAmB;sBADtB,KAAK;gBAoCN,YAAY;sBADX,YAAY;uBAAC,WAAW,EAAE,CAAE,QAAQ,CAAE;gBAUvC,QAAQ;sBADP,YAAY;uBAAC,OAAO,EAAE,CAAE,QAAQ,CAAE;gBAMnC,kBAAkB;sBADjB,YAAY;uBAAC,kBAAkB,EAAE,CAAE,QAAQ,CAAE","sourcesContent":["import { FocusMonitor, FocusOrigin, isFakeMousedownFromScreenReader } from '@angular/cdk/a11y'\nimport { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion'\nimport { ESCAPE } from '@angular/cdk/keycodes'\nimport { ConnectionPositionPair, Overlay, OverlayRef, PositionStrategy } from '@angular/cdk/overlay'\nimport { normalizePassiveListenerOptions } from '@angular/cdk/platform'\nimport { ComponentPortal } from '@angular/cdk/portal'\nimport { ComponentRef, Directive, ElementRef, HostListener, Input, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core'\nimport { BehaviorSubject, fromEvent, merge, of, Subject, Subscription } from 'rxjs'\nimport { switchMap, takeUntil } from 'rxjs/operators'\n\nimport { PopoverComponent } from './popover/popover.component'\n\n/** Options for binding a passive event listener. */\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true })\n\n@Directive({\n  selector: '[seamPopover]',\n  // tslint:disable-next-line:use-host-property-decorator\n  host: {\n    'aria-haspopup': 'true',\n    '[attr.aria-expanded]': 'popoverOpen() || null'\n  },\n  exportAs: 'seamPopover'\n})\nexport class TheSeamPopoverDirective implements OnDestroy {\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  @Input() seamPopover?: TemplateRef<any> | null\n\n  /**\n   * Defines a width for a popover that will scale down if the window innerWidth is\n   * smaller than the value.\n   */\n  @Input()\n  get seamPopoverBaseWidth() { return this._seamPopoverBaseWidth.value }\n  set seamPopoverBaseWidth(value: number | null) {\n    const _val = coerceNumberProperty(value, null)\n    if (_val !== this._seamPopoverBaseWidth.value) {\n      this._seamPopoverBaseWidth.next(_val)\n    }\n  }\n  private _seamPopoverBaseWidth = new BehaviorSubject<number | null>(null)\n\n  @Input()\n  get seamPopoverDisabled() { return this._seamPopoverDisabled.value }\n  set seamPopoverDisabled(val: boolean) { this._seamPopoverDisabled.next(coerceBooleanProperty(val)) }\n  private _seamPopoverDisabled = new BehaviorSubject<boolean>(false)\n\n  // ngOnInit() {\n  //   this._seamPopoverDisabled.pipe(\n  //     switchMap(disabled => {\n  //       if (disabled) {\n  //         this.close()\n  //         return of(undefined)\n  //       }\n\n  //       if (!(this._elementRef && this._elementRef.nativeElement)) {\n  //         return of(undefined)\n  //       }\n\n  //       return fromEvent(this._elementRef.nativeElement, 'click')\n  //     })\n  //   ).subscribe()\n  // }\n\n  private _active = false\n  private _closing = false\n  private _overlayRef: OverlayRef | undefined | null\n  private _compRef: ComponentRef<PopoverComponent> | undefined | null\n  private _popoverClosedSubscription = Subscription.EMPTY\n  private _closingActionsSubscription = Subscription.EMPTY\n\n  public restoreFocus = true\n\n  // Tracking input type is necessary so it's possible to only auto-focus\n  // the first item of the list when the menu is opened via the keyboard\n  _openedBy: 'mouse' | 'touch' | null = null\n\n  @HostListener('mousedown', [ '$event' ])\n  _onMouseDown(event: MouseEvent) {\n    if (!isFakeMousedownFromScreenReader(event)) {\n      // Since right or middle button clicks won't trigger the `click` event,\n      // we shouldn't consider the menu as opened by mouse in those cases.\n      this._openedBy = event.button === 0 ? 'mouse' : null\n    }\n  }\n\n  @HostListener('click', [ '$event' ])\n  _onClick(event: any) {\n    this.toggle()\n  }\n\n  @HostListener('document:keydown', [ '$event' ])\n  _onDocumentKeydown(event: any) {\n    if (event.keyCode === ESCAPE) {\n      this.closePopover()\n    }\n  }\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    private _viewContainerRef: ViewContainerRef,\n    private _overlay: Overlay,\n    private _focusMonitor: FocusMonitor\n  ) {\n    this._elementRef.nativeElement.addEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n\n    this._seamPopoverBaseWidth\n      .pipe(takeUntil(this._ngUnsubscribe))\n      .subscribe(w => {\n        if (this._compRef && this._compRef.instance) {\n          this._compRef.instance.baseWidth = w\n          this._compRef.changeDetectorRef.markForCheck()\n        }\n      })\n  }\n\n  ngOnDestroy() {\n    this.closePopover()\n\n    this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n\n    this._popoverClosedSubscription.unsubscribe()\n    this._closingActionsSubscription.unsubscribe()\n\n    this._ngUnsubscribe.next(undefined)\n    this._ngUnsubscribe.complete()\n  }\n\n  /**\n   * Handles touch start events on the trigger.\n   * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.\n   */\n  private _handleTouchStart = () => this._openedBy = 'touch'\n\n  public toggle(): void {\n    if (this._active || this.seamPopoverDisabled) {\n      this.closePopover()\n    } else {\n      this.openPopover()\n    }\n  }\n\n  public openPopover(): void {\n    if (this._active || !this.seamPopover) { return }\n    this._active = true\n\n    this._overlayRef = this._overlay.create({\n      hasBackdrop: true,\n      backdropClass: 'transparent',\n      positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),\n    })\n\n    this._compRef = this._overlayRef.attach(new ComponentPortal(PopoverComponent, this._viewContainerRef))\n\n    this._closingActionsSubscription = this._popoverClosingActions().subscribe(() => this.closePopover())\n\n    this._compRef.instance.template = this.seamPopover\n    this._compRef.instance.baseWidth = this.seamPopoverBaseWidth\n    this._compRef.changeDetectorRef.markForCheck()\n\n    this._popoverClosedSubscription = this._compRef.instance._afterExit.subscribe(v => {\n      // console.log('closed', v)\n      if (this._overlayRef?.hasAttached()) {\n        this._overlayRef.detach()\n      }\n\n      this._resetPopover()\n\n      this._popoverClosedSubscription.unsubscribe()\n      this._closingActionsSubscription.unsubscribe()\n\n      this._active = false\n      this._closing = false\n    })\n  }\n\n  public closePopover(): void {\n    if (!this._active) { return }\n\n    if (!this._closing) {\n      if (this._compRef && this._compRef.instance) {\n        this._closing = true\n        this._compRef.instance._startExiting()\n      }\n    }\n  }\n\n  public popoverOpen(): boolean {\n    return this._overlayRef?.hasAttached() ?? false\n  }\n\n  private getOverlayPosition(origin: HTMLElement): PositionStrategy {\n    const positionStrategy = this._overlay.position()\n      .flexibleConnectedTo(origin)\n      .withPositions(this.getPositions())\n      .withFlexibleDimensions(false)\n      .withPush(true)\n\n    return positionStrategy\n  }\n\n  private getPositions(): ConnectionPositionPair[] {\n    return [\n      {\n        originX: 'center',\n        originY: 'bottom',\n        overlayX: 'center',\n        overlayY: 'top'\n      },\n      {\n        originX: 'center',\n        originY: 'top',\n        overlayX: 'center',\n        overlayY: 'bottom'\n      },\n      {\n        originX: 'end',\n        originY: 'bottom',\n        overlayX: 'end',\n        overlayY: 'top',\n      },\n      {\n        originX: 'start',\n        originY: 'bottom',\n        overlayX: 'start',\n        overlayY: 'top',\n      },\n      {\n        originX: 'end',\n        originY: 'top',\n        overlayX: 'end',\n        overlayY: 'bottom',\n      },\n      {\n        originX: 'start',\n        originY: 'top',\n        overlayX: 'start',\n        overlayY: 'bottom',\n      },\n    ]\n  }\n\n  /**\n   * Focuses the popover trigger.\n   * @param origin Source of the popover trigger's focus.\n   */\n  focus(origin: FocusOrigin = 'program') {\n    if (this._focusMonitor) {\n      this._focusMonitor.focusVia(this._elementRef, origin)\n    } else {\n      this._elementRef.nativeElement.focus()\n    }\n  }\n\n  /**\n   * This method resets the popover when it's closed, most importantly restoring\n   * focus to the popover trigger if the popover was opened via the keyboard.\n   */\n  private _resetPopover(): void {\n    // We should reset focus if the user is navigating using a keyboard or\n    // if we have a top-level trigger which might cause focus to be lost\n    // when clicking on the backdrop.\n    if (this.restoreFocus) {\n      if (!this._openedBy) {\n        // Note that the focus style will show up both for `program` and\n        // `keyboard` so we don't have to specify which one it is.\n        this.focus()\n      }\n    }\n\n    this._openedBy = null\n  }\n\n  /** Returns a stream that emits whenever an action that should close the popover occurs. */\n  private _popoverClosingActions() {\n    const backdrop = this._overlayRef?.backdropClick() ?? of()\n    const detachments = this._overlayRef?.detachments() ?? of()\n    const hover = of()\n\n    return merge(backdrop, hover, detachments)\n  }\n\n}\n"]}

package/esm2020/popover/popover.module.mjs

@@ -0,0 +1,40 @@
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TheSeamPopoverDirective } from './popover.directive';
+import { PopoverComponent } from './popover/popover.component';
+import * as i0 from "@angular/core";
+export class TheSeamPopoverModule {
+}
+TheSeamPopoverModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamPopoverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPopoverModule, declarations: [PopoverComponent,
+        TheSeamPopoverDirective], imports: [CommonModule,
+        OverlayModule,
+        PortalModule], exports: [TheSeamPopoverDirective,
+        OverlayModule,
+        PortalModule] });
+TheSeamPopoverModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPopoverModule, imports: [CommonModule,
+        OverlayModule,
+        PortalModule, OverlayModule,
+        PortalModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        PopoverComponent,
+                        TheSeamPopoverDirective
+                    ],
+                    imports: [
+                        CommonModule,
+                        OverlayModule,
+                        PortalModule
+                    ],
+                    exports: [
+                        TheSeamPopoverDirective,
+                        OverlayModule,
+                        PortalModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/progress/progress-circle/progress-circle.component.mjs

@@ -0,0 +1,65 @@
+import { __decorate } from "tslib";
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { InputBoolean, InputNumber } from '@theseam/ui-common/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export function calcDashoffset(value, circumference) {
+    const progress = value / 100;
+    const dashoffset = circumference * (1 - progress);
+    return dashoffset;
+}
+export class ProgressCircleComponent {
+    constructor() {
+        this._percentage = 0;
+        this.fillBackground = false;
+        this.showText = false;
+        this.hiddenOnEmpty = true;
+        this.pending = false;
+        this.radius = 15;
+        this.circumference = 2 * Math.PI * this.radius;
+    }
+    set percentage(value) {
+        this._percentage = value;
+        this._progressInfo = this._getProgress();
+    }
+    get percentage() { return this._percentage; }
+    _getProgress() {
+        return {
+            dashoffset: calcDashoffset(this.percentage || 0, this.circumference),
+            circumference: this.circumference,
+            percent: Math.floor(this.percentage || 0)
+        };
+    }
+}
+ProgressCircleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProgressCircleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ProgressCircleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: ProgressCircleComponent, selector: "seam-progress-circle", inputs: { fillBackground: "fillBackground", showText: "showText", hiddenOnEmpty: "hiddenOnEmpty", pending: "pending", percentage: "percentage" }, ngImport: i0, template: "<div class=\"seam-progress-circle\" *ngIf=\"_progressInfo as p\"\n  [class.seam-progress-circle--in-complete]=\"p.percent < 100\"\n  [class.seam-progress-circle--fill-bg]=\"fillBackground\">\n  <div class=\"seam-progress-circle-inner\">\n    <ng-container *ngIf=\"p.percent > 0 || !hiddenOnEmpty\">\n      <svg class=\"seam-progress-circle--icon-spinner\" viewBox=\"0 0 40 40\" [attr.data-percent]=\"p.percent\">\n        <circle class=\"seam-progress-circle--icon-spinner-path seam-progress-circle--icon-spinner-path-bg\" cx=\"20\" cy=\"20\" r=\"15\" fill=\"none\"\n          stroke-width=\"4\">\n        </circle>\n        <circle class=\"seam-progress-circle--icon-spinner-path\" cx=\"20\" cy=\"20\" r=\"15\" fill=\"none\"\n          transform=\"rotate(-90, 20, 20)\"\n          stroke-width=\"4\"\n          stroke-miterlimit=\"10\"\n          [attr.stroke-dashoffset]=\"p.dashoffset\"\n          [style.stroke-dasharray]=\"p.circumference\">\n        </circle>\n        <!-- Checkmark -->\n        <path *ngIf=\"!pending && p.percent === 100\"\n          class=\"seam-progress-circle--icon-spinner-path\"\n          fill=\"none\"\n          stroke-width=\"4\"\n          stroke-linecap=\"round\"\n          stroke-linejoin=\"round\"\n          d=\"M 11,22 L 18,28 L 28.5,17\">\n        </path>\n        <!-- Hourglass -->\n        <!-- `p.percent === 101` is still here for backwards compatability, but planing to be removed. -->\n        <path *ngIf=\"pending || p.percent === 101\"\n          class=\"seam-progress-circle--icon-hourglass\"\n          fill=\"none\"\n          d=\"M27.3,25.8c-0.2-2.5-1.6-4.6-3.6-5.8c2-1.2,3.4-3.3,3.6-5.8c0.7-0.3,1.2-1,1.2-1.8c0-1.1-0.9-2-2-2h-13\n          c-1.1,0-2,0.9-2,2c0,0.8,0.5,1.6,1.2,1.8c0.2,2.5,1.6,4.6,3.6,5.8c-2,1.2-3.4,3.3-3.6,5.8c-0.7,0.3-1.2,1-1.2,1.8c0,1.1,0.9,2,2,2\n          h13c1.1,0,2-0.9,2-2C28.6,26.9,28,26.1,27.3,25.8z M24.3,25.7h-8.5c0.3-2.1,2.1-3.6,4.2-3.6S24,23.6,24.3,25.7z M20,18\n          c-2.1,0-3.9-1.6-4.2-3.6h8.5C24,16.5,22.2,18,20,18z\">\n        </path>\n      </svg>\n    </ng-container>\n    <div class=\"seam-progress-circle--icon-text\" *ngIf=\"showText && !pending && p.percent > 0 && p.percent < 100\">\n      <span>{{ p.percent }}</span>\n    </div>\n  </div>\n</div>\n", styles: ["seam-progress-circle{display:block}seam-progress-circle .seam-progress-circle--absolute-fill,seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner,seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-center,seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-text,seam-progress-circle .seam-progress-circle{position:absolute;inset:0}seam-progress-circle .seam-progress-circle{padding:5px}seam-progress-circle .seam-progress-circle .seam-progress-circle-inner{position:relative;height:100%;width:100%}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-check{padding-top:4px;font-size:1.3rem;line-height:1.3rem;color:#55c83c}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-text{text-align:center;align-items:center;display:flex;flex-direction:row;justify-content:center;color:#55c83c;font-size:19px;font-weight:700;transform:translateZ(0)}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-center{transform-origin:center center;text-align:center;align-items:center;display:flex;flex-direction:row;justify-content:center}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner{margin:auto}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path{stroke-linecap:round;stroke:#55c83c;transition:.5s}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path:not(path){stroke-dasharray:0}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-hourglass{fill:#55c83c;transition:.5s}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path-bg{stroke-linecap:round;stroke:#e0f5db}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path{stroke:#f57a15}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path-bg{stroke:#fde9d9}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner[data-percent=\"0\"] .seam-progress-circle--icon-spinner-path{stroke:#6c757d}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner[data-percent=\"0\"] .seam-progress-circle--icon-spinner-path-bg{stroke:#d8dbdd}seam-progress-circle .seam-progress-circle--fill-bg .seam-progress-circle--icon-spinner-path-bg{fill:#fff}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None });
+__decorate([
+    InputBoolean()
+], ProgressCircleComponent.prototype, "fillBackground", void 0);
+__decorate([
+    InputBoolean()
+], ProgressCircleComponent.prototype, "showText", void 0);
+__decorate([
+    InputBoolean()
+], ProgressCircleComponent.prototype, "hiddenOnEmpty", void 0);
+__decorate([
+    InputBoolean()
+], ProgressCircleComponent.prototype, "pending", void 0);
+__decorate([
+    InputNumber()
+], ProgressCircleComponent.prototype, "percentage", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProgressCircleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-progress-circle', encapsulation: ViewEncapsulation.None, template: "<div class=\"seam-progress-circle\" *ngIf=\"_progressInfo as p\"\n  [class.seam-progress-circle--in-complete]=\"p.percent < 100\"\n  [class.seam-progress-circle--fill-bg]=\"fillBackground\">\n  <div class=\"seam-progress-circle-inner\">\n    <ng-container *ngIf=\"p.percent > 0 || !hiddenOnEmpty\">\n      <svg class=\"seam-progress-circle--icon-spinner\" viewBox=\"0 0 40 40\" [attr.data-percent]=\"p.percent\">\n        <circle class=\"seam-progress-circle--icon-spinner-path seam-progress-circle--icon-spinner-path-bg\" cx=\"20\" cy=\"20\" r=\"15\" fill=\"none\"\n          stroke-width=\"4\">\n        </circle>\n        <circle class=\"seam-progress-circle--icon-spinner-path\" cx=\"20\" cy=\"20\" r=\"15\" fill=\"none\"\n          transform=\"rotate(-90, 20, 20)\"\n          stroke-width=\"4\"\n          stroke-miterlimit=\"10\"\n          [attr.stroke-dashoffset]=\"p.dashoffset\"\n          [style.stroke-dasharray]=\"p.circumference\">\n        </circle>\n        <!-- Checkmark -->\n        <path *ngIf=\"!pending && p.percent === 100\"\n          class=\"seam-progress-circle--icon-spinner-path\"\n          fill=\"none\"\n          stroke-width=\"4\"\n          stroke-linecap=\"round\"\n          stroke-linejoin=\"round\"\n          d=\"M 11,22 L 18,28 L 28.5,17\">\n        </path>\n        <!-- Hourglass -->\n        <!-- `p.percent === 101` is still here for backwards compatability, but planing to be removed. -->\n        <path *ngIf=\"pending || p.percent === 101\"\n          class=\"seam-progress-circle--icon-hourglass\"\n          fill=\"none\"\n          d=\"M27.3,25.8c-0.2-2.5-1.6-4.6-3.6-5.8c2-1.2,3.4-3.3,3.6-5.8c0.7-0.3,1.2-1,1.2-1.8c0-1.1-0.9-2-2-2h-13\n          c-1.1,0-2,0.9-2,2c0,0.8,0.5,1.6,1.2,1.8c0.2,2.5,1.6,4.6,3.6,5.8c-2,1.2-3.4,3.3-3.6,5.8c-0.7,0.3-1.2,1-1.2,1.8c0,1.1,0.9,2,2,2\n          h13c1.1,0,2-0.9,2-2C28.6,26.9,28,26.1,27.3,25.8z M24.3,25.7h-8.5c0.3-2.1,2.1-3.6,4.2-3.6S24,23.6,24.3,25.7z M20,18\n          c-2.1,0-3.9-1.6-4.2-3.6h8.5C24,16.5,22.2,18,20,18z\">\n        </path>\n      </svg>\n    </ng-container>\n    <div class=\"seam-progress-circle--icon-text\" *ngIf=\"showText && !pending && p.percent > 0 && p.percent < 100\">\n      <span>{{ p.percent }}</span>\n    </div>\n  </div>\n</div>\n", styles: ["seam-progress-circle{display:block}seam-progress-circle .seam-progress-circle--absolute-fill,seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner,seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-center,seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-text,seam-progress-circle .seam-progress-circle{position:absolute;inset:0}seam-progress-circle .seam-progress-circle{padding:5px}seam-progress-circle .seam-progress-circle .seam-progress-circle-inner{position:relative;height:100%;width:100%}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-check{padding-top:4px;font-size:1.3rem;line-height:1.3rem;color:#55c83c}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-text{text-align:center;align-items:center;display:flex;flex-direction:row;justify-content:center;color:#55c83c;font-size:19px;font-weight:700;transform:translateZ(0)}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-center{transform-origin:center center;text-align:center;align-items:center;display:flex;flex-direction:row;justify-content:center}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner{margin:auto}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path{stroke-linecap:round;stroke:#55c83c;transition:.5s}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path:not(path){stroke-dasharray:0}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-hourglass{fill:#55c83c;transition:.5s}seam-progress-circle .seam-progress-circle .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path-bg{stroke-linecap:round;stroke:#e0f5db}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path{stroke:#f57a15}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner .seam-progress-circle--icon-spinner-path-bg{stroke:#fde9d9}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner[data-percent=\"0\"] .seam-progress-circle--icon-spinner-path{stroke:#6c757d}seam-progress-circle .seam-progress-circle--in-complete .seam-progress-circle--icon-spinner[data-percent=\"0\"] .seam-progress-circle--icon-spinner-path-bg{stroke:#d8dbdd}seam-progress-circle .seam-progress-circle--fill-bg .seam-progress-circle--icon-spinner-path-bg{fill:#fff}\n"] }]
+        }], propDecorators: { fillBackground: [{
+                type: Input
+            }], showText: [{
+                type: Input
+            }], hiddenOnEmpty: [{
+                type: Input
+            }], pending: [{
+                type: Input
+            }], percentage: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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