@theseam/ui-common 0.3.10 → 0.4.0-beta.0

package/esm2020/modal/route-modal/route-modal.component.mjs

@@ -0,0 +1,63 @@
+import { Component } from '@angular/core';
+// import { ModalComponent } from '../modal/modal.component'
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../modal.service";
+export class RouteModalComponent {
+    // @ViewChild(ModalComponent, { static: true }) _modal: ModalComponent
+    constructor(_route, _router, _modal) {
+        this._route = _route;
+        this._router = _router;
+        this._modal = _modal;
+        this._ngUnsubscribe = new Subject();
+    }
+    ngOnInit() {
+        this._route.data
+            .pipe(takeUntil(this._ngUnsubscribe))
+            .subscribe(data => {
+            // console.log('data', data)
+            if (data.routeComponent) {
+                // console.log(this._route.snapshot)
+                const modalRef = this._modal.openFromComponent(data.routeComponent, {
+                    modalSize: 'lg',
+                    data
+                });
+                modalRef.afterClosed().subscribe(() => {
+                    const parent = this.getOutletParent();
+                    this._router.navigate([{ outlets: { modal: null, primary: ['.'] } }], 
+                    // { relativeTo: this._route.parent }
+                    { relativeTo: parent });
+                });
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._ngUnsubscribe.next(undefined);
+        this._ngUnsubscribe.complete();
+    }
+    ngAfterViewInit() { }
+    getOutletParent() {
+        let route = this._route;
+        while (route && route.outlet !== 'modal') {
+            route = route.parent;
+        }
+        return route ? route.parent : route;
+    }
+    _onDetached() {
+        if (this.isRouteModal()) {
+            this._router.navigate([{ outlets: { modal: null, primary: ['.'] } }], { relativeTo: this._route.parent });
+        }
+    }
+    isRouteModal() {
+        return this._route.outlet === 'modal';
+    }
+}
+RouteModalComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: RouteModalComponent, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }, { token: i2.Modal }], target: i0.ɵɵFactoryTarget.Component });
+RouteModalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: RouteModalComponent, selector: "seam-route-modal", ngImport: i0, template: "<!-- <seam-modal (overlayDetached)=\"_onDetached()\">\n  <router-outlet></router-outlet>\n</seam-modal> -->\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: RouteModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-route-modal', template: "<!-- <seam-modal (overlayDetached)=\"_onDetached()\">\n  <router-outlet></router-outlet>\n</seam-modal> -->\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i1.Router }, { type: i2.Modal }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtbW9kYWwuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL21vZGFsL3JvdXRlLW1vZGFsL3JvdXRlLW1vZGFsLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tb2RhbC9yb3V0ZS1tb2RhbC9yb3V0ZS1tb2RhbC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWlCLFNBQVMsRUFBZ0MsTUFBTSxlQUFlLENBQUE7QUFHdEYsNERBQTREO0FBQzVELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFDOUIsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFBOzs7O0FBUTFDLE1BQU0sT0FBTyxtQkFBbUI7SUFJOUIsc0VBQXNFO0lBRXRFLFlBQ1UsTUFBc0IsRUFDdEIsT0FBZSxFQUNmLE1BQWE7UUFGYixXQUFNLEdBQU4sTUFBTSxDQUFnQjtRQUN0QixZQUFPLEdBQVAsT0FBTyxDQUFRO1FBQ2YsV0FBTSxHQUFOLE1BQU0sQ0FBTztRQVBOLG1CQUFjLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQTtJQVFqRCxDQUFDO0lBRUwsUUFBUTtRQUNOLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSTthQUNiLElBQUksQ0FDSCxTQUFTLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUMvQjthQUNBLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUNoQiw0QkFBNEI7WUFDNUIsSUFBSSxJQUFJLENBQUMsY0FBYyxFQUFFO2dCQUN2QixvQ0FBb0M7Z0JBQ3BDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRTtvQkFDbEUsU0FBUyxFQUFFLElBQUk7b0JBQ2YsSUFBSTtpQkFDTCxDQUFDLENBQUE7Z0JBQ0YsUUFBUSxDQUFDLFdBQVcsRUFBRSxDQUFDLFNBQVMsQ0FBQyxHQUFHLEVBQUU7b0JBQ3BDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQTtvQkFDckMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQ25CLENBQUMsRUFBRSxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsQ0FBQztvQkFDOUMscUNBQXFDO29CQUNyQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsQ0FDdkIsQ0FBQTtnQkFDSCxDQUFDLENBQUMsQ0FBQTthQUNIO1FBQ0gsQ0FBQyxDQUFDLENBQUE7SUFDTixDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFBO1FBQ25DLElBQUksQ0FBQyxjQUFjLENBQUMsUUFBUSxFQUFFLENBQUE7SUFDaEMsQ0FBQztJQUVELGVBQWUsS0FBSyxDQUFDO0lBRXJCLGVBQWU7UUFDYixJQUFJLEtBQUssR0FBMEIsSUFBSSxDQUFDLE1BQU0sQ0FBQTtRQUM5QyxPQUFPLEtBQUssSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLE9BQU8sRUFBRTtZQUFFLEtBQUssR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFBO1NBQUU7UUFDbEUsT0FBTyxLQUFLLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQTtJQUNyQyxDQUFDO0lBRU0sV0FBVztRQUNoQixJQUFJLElBQUksQ0FBQyxZQUFZLEVBQUUsRUFBRTtZQUN2QixJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FDbkIsQ0FBQyxFQUFFLE9BQU8sRUFBRSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQzlDLEVBQUUsVUFBVSxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQ25DLENBQUE7U0FDRjtJQUNILENBQUM7SUFFTSxZQUFZO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEtBQUssT0FBTyxDQUFBO0lBQ3ZDLENBQUM7O2dIQTdEVSxtQkFBbUI7b0dBQW5CLG1CQUFtQix3RENiaEMsK0dBR0E7MkZEVWEsbUJBQW1CO2tCQUwvQixTQUFTOytCQUNFLGtCQUFrQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFmdGVyVmlld0luaXQsIENvbXBvbmVudCwgT25EZXN0cm95LCBPbkluaXQsIFZpZXdDaGlsZCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBBY3RpdmF0ZWRSb3V0ZSwgQWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgUm91dGVyIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJ1xuXG4vLyBpbXBvcnQgeyBNb2RhbENvbXBvbmVudCB9IGZyb20gJy4uL21vZGFsL21vZGFsLmNvbXBvbmVudCdcbmltcG9ydCB7IFN1YmplY3QgfSBmcm9tICdyeGpzJ1xuaW1wb3J0IHsgdGFrZVVudGlsIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnXG5pbXBvcnQgeyBNb2RhbCB9IGZyb20gJy4uL21vZGFsLnNlcnZpY2UnXG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3NlYW0tcm91dGUtbW9kYWwnLFxuICB0ZW1wbGF0ZVVybDogJy4vcm91dGUtbW9kYWwuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9yb3V0ZS1tb2RhbC5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIFJvdXRlTW9kYWxDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQsIE9uRGVzdHJveSwgQWZ0ZXJWaWV3SW5pdCB7XG5cbiAgcHJpdmF0ZSByZWFkb25seSBfbmdVbnN1YnNjcmliZSA9IG5ldyBTdWJqZWN0PHZvaWQ+KClcblxuICAvLyBAVmlld0NoaWxkKE1vZGFsQ29tcG9uZW50LCB7IHN0YXRpYzogdHJ1ZSB9KSBfbW9kYWw6IE1vZGFsQ29tcG9uZW50XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBfcm91dGU6IEFjdGl2YXRlZFJvdXRlLFxuICAgIHByaXZhdGUgX3JvdXRlcjogUm91dGVyLFxuICAgIHByaXZhdGUgX21vZGFsOiBNb2RhbFxuICApIHsgfVxuXG4gIG5nT25Jbml0KCkge1xuICAgIHRoaXMuX3JvdXRlLmRhdGFcbiAgICAgIC5waXBlKFxuICAgICAgICB0YWtlVW50aWwodGhpcy5fbmdVbnN1YnNjcmliZSlcbiAgICAgIClcbiAgICAgIC5zdWJzY3JpYmUoZGF0YSA9PiB7XG4gICAgICAgIC8vIGNvbnNvbGUubG9nKCdkYXRhJywgZGF0YSlcbiAgICAgICAgaWYgKGRhdGEucm91dGVDb21wb25lbnQpIHtcbiAgICAgICAgICAvLyBjb25zb2xlLmxvZyh0aGlzLl9yb3V0ZS5zbmFwc2hvdClcbiAgICAgICAgICBjb25zdCBtb2RhbFJlZiA9IHRoaXMuX21vZGFsLm9wZW5Gcm9tQ29tcG9uZW50KGRhdGEucm91dGVDb21wb25lbnQsIHtcbiAgICAgICAgICAgIG1vZGFsU2l6ZTogJ2xnJyxcbiAgICAgICAgICAgIGRhdGFcbiAgICAgICAgICB9KVxuICAgICAgICAgIG1vZGFsUmVmLmFmdGVyQ2xvc2VkKCkuc3Vic2NyaWJlKCgpID0+IHtcbiAgICAgICAgICAgIGNvbnN0IHBhcmVudCA9IHRoaXMuZ2V0T3V0bGV0UGFyZW50KClcbiAgICAgICAgICAgIHRoaXMuX3JvdXRlci5uYXZpZ2F0ZShcbiAgICAgICAgICAgICAgW3sgb3V0bGV0czogeyBtb2RhbDogbnVsbCwgcHJpbWFyeTogWycuJ10gfSB9XSxcbiAgICAgICAgICAgICAgLy8geyByZWxhdGl2ZVRvOiB0aGlzLl9yb3V0ZS5wYXJlbnQgfVxuICAgICAgICAgICAgICB7IHJlbGF0aXZlVG86IHBhcmVudCB9XG4gICAgICAgICAgICApXG4gICAgICAgICAgfSlcbiAgICAgICAgfVxuICAgICAgfSlcbiAgfVxuXG4gIG5nT25EZXN0cm95KCkge1xuICAgIHRoaXMuX25nVW5zdWJzY3JpYmUubmV4dCh1bmRlZmluZWQpXG4gICAgdGhpcy5fbmdVbnN1YnNjcmliZS5jb21wbGV0ZSgpXG4gIH1cblxuICBuZ0FmdGVyVmlld0luaXQoKSB7IH1cblxuICBnZXRPdXRsZXRQYXJlbnQoKSB7XG4gICAgbGV0IHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZSB8IG51bGwgPSB0aGlzLl9yb3V0ZVxuICAgIHdoaWxlIChyb3V0ZSAmJiByb3V0ZS5vdXRsZXQgIT09ICdtb2RhbCcpIHsgcm91dGUgPSByb3V0ZS5wYXJlbnQgfVxuICAgIHJldHVybiByb3V0ZSA/IHJvdXRlLnBhcmVudCA6IHJvdXRlXG4gIH1cblxuICBwdWJsaWMgX29uRGV0YWNoZWQoKSB7XG4gICAgaWYgKHRoaXMuaXNSb3V0ZU1vZGFsKCkpIHtcbiAgICAgIHRoaXMuX3JvdXRlci5uYXZpZ2F0ZShcbiAgICAgICAgW3sgb3V0bGV0czogeyBtb2RhbDogbnVsbCwgcHJpbWFyeTogWycuJ10gfSB9XSxcbiAgICAgICAgeyByZWxhdGl2ZVRvOiB0aGlzLl9yb3V0ZS5wYXJlbnQgfVxuICAgICAgKVxuICAgIH1cbiAgfVxuXG4gIHB1YmxpYyBpc1JvdXRlTW9kYWwoKSB7XG4gICAgcmV0dXJuIHRoaXMuX3JvdXRlLm91dGxldCA9PT0gJ21vZGFsJ1xuICB9XG5cbn1cbiIsIjwhLS0gPHNlYW0tbW9kYWwgKG92ZXJsYXlEZXRhY2hlZCk9XCJfb25EZXRhY2hlZCgpXCI+XG4gIDxyb3V0ZXItb3V0bGV0Pjwvcm91dGVyLW91dGxldD5cbjwvc2VhbS1tb2RhbD4gLS0+XG4iXX0=

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 {
+    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();
+            }
+        });
+    }
+    // @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);
+        }
+    }
+    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.3", ngImport: i0, type: PopoverComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PopoverComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", 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.3", 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 {
+    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();
+            }
+        });
+    }
+    /**
+     * 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();
+        }
+    }
+    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.3", 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.3", 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.3", 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":"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","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\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\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.3", ngImport: i0, type: TheSeamPopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamPopoverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.3", 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.3", ngImport: i0, type: TheSeamPopoverModule, imports: [CommonModule,
+        OverlayModule,
+        PortalModule, OverlayModule,
+        PortalModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", 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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