@theseam/ui-common 0.2.9

package/esm2015/modal/route-modal/route-modal.component.js

@@ -0,0 +1,68 @@
+import { Component } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+// import { ModalComponent } from '../modal/modal.component'
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { Modal } 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();
+        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.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-route-modal',
+                template: "<!-- <seam-modal (overlayDetached)=\"_onDetached()\">\n  <router-outlet></router-outlet>\n</seam-modal> -->\n",
+                styles: [""]
+            },] }
+];
+RouteModalComponent.ctorParameters = () => [
+    { type: ActivatedRoute },
+    { type: Router },
+    { type: Modal }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/modal/theseam-ui-common-modal.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlc2VhbS11aS1jb21tb24tbW9kYWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kYWwvdGhlc2VhbS11aS1jb21tb24tbW9kYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/models/component-type.js

@@ -0,0 +1,4 @@
+// Redefining this, instead of importing from cdk, because the way the interface
+// is exported in the cdk causes problems with cli build in some situations.
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LXR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kZWxzL2NvbXBvbmVudC10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdGQUFnRjtBQUNoRiw0RUFBNEUiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBSZWRlZmluaW5nIHRoaXMsIGluc3RlYWQgb2YgaW1wb3J0aW5nIGZyb20gY2RrLCBiZWNhdXNlIHRoZSB3YXkgdGhlIGludGVyZmFjZVxuLy8gaXMgZXhwb3J0ZWQgaW4gdGhlIGNkayBjYXVzZXMgcHJvYmxlbXMgd2l0aCBjbGkgYnVpbGQgaW4gc29tZSBzaXR1YXRpb25zLlxuXG4vKiogSW50ZXJmYWNlIHRoYXQgY2FuIGJlIHVzZWQgdG8gZ2VuZXJpY2FsbHkgdHlwZSBhIGNsYXNzLiAqL1xuZXhwb3J0IHR5cGUgQ29tcG9uZW50VHlwZTxUPiA9IG5ldyAoLi4uYXJnczogYW55W10pID0+IFRcbiJdfQ==

package/esm2015/models/http-status-codes.js

@@ -0,0 +1,20 @@
+/**
+ * Most of the status code packages seemed to be incomplete, so instead of
+ * importing a possibly incomplete package for the few status codes we currently
+ * would need, just add them to them as necessary.
+ */
+/** Http Status Codes Enum */
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatus[HttpStatus["Forbidden"] = 403] = "Forbidden";
+    HttpStatus[HttpStatus["NotFound"] = 404] = "NotFound";
+    HttpStatus[HttpStatus["RequestTimeout"] = 408] = "RequestTimeout";
+    HttpStatus[HttpStatus["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    HttpStatus[HttpStatus["InternalServerError"] = 500] = "InternalServerError";
+    HttpStatus[HttpStatus["NotImplemented"] = 501] = "NotImplemented";
+    HttpStatus[HttpStatus["BadGateway"] = 502] = "BadGateway";
+    HttpStatus[HttpStatus["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    HttpStatus[HttpStatus["GatewayTimeout"] = 502] = "GatewayTimeout";
+})(HttpStatus || (HttpStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1zdGF0dXMtY29kZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kZWxzL2h0dHAtc3RhdHVzLWNvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCw2QkFBNkI7QUFDN0IsTUFBTSxDQUFOLElBQVksVUFXWDtBQVhELFdBQVksVUFBVTtJQUNwQiw2REFBa0IsQ0FBQTtJQUNsQix1REFBZSxDQUFBO0lBQ2YscURBQWMsQ0FBQTtJQUNkLGlFQUFvQixDQUFBO0lBQ3BCLDJFQUF5QixDQUFBO0lBQ3pCLDJFQUF5QixDQUFBO0lBQ3pCLGlFQUFvQixDQUFBO0lBQ3BCLHlEQUFnQixDQUFBO0lBQ2hCLHlFQUF3QixDQUFBO0lBQ3hCLGlFQUFvQixDQUFBO0FBQ3RCLENBQUMsRUFYVyxVQUFVLEtBQVYsVUFBVSxRQVdyQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTW9zdCBvZiB0aGUgc3RhdHVzIGNvZGUgcGFja2FnZXMgc2VlbWVkIHRvIGJlIGluY29tcGxldGUsIHNvIGluc3RlYWQgb2ZcbiAqIGltcG9ydGluZyBhIHBvc3NpYmx5IGluY29tcGxldGUgcGFja2FnZSBmb3IgdGhlIGZldyBzdGF0dXMgY29kZXMgd2UgY3VycmVudGx5XG4gKiB3b3VsZCBuZWVkLCBqdXN0IGFkZCB0aGVtIHRvIHRoZW0gYXMgbmVjZXNzYXJ5LlxuICovXG5cbi8qKiBIdHRwIFN0YXR1cyBDb2RlcyBFbnVtICovXG5leHBvcnQgZW51bSBIdHRwU3RhdHVzIHtcbiAgVW5hdXRob3JpemVkID0gNDAxLFxuICBGb3JiaWRkZW4gPSA0MDMsXG4gIE5vdEZvdW5kID0gNDA0LFxuICBSZXF1ZXN0VGltZW91dCA9IDQwOCxcbiAgVW5wcm9jZXNzYWJsZUVudGl0eSA9IDQyMixcbiAgSW50ZXJuYWxTZXJ2ZXJFcnJvciA9IDUwMCxcbiAgTm90SW1wbGVtZW50ZWQgPSA1MDEsXG4gIEJhZEdhdGV3YXkgPSA1MDIsXG4gIFNlcnZpY2VVbmF2YWlsYWJsZSA9IDUwMyxcbiAgR2F0ZXdheVRpbWVvdXQgPSA1MDJcbn1cbiJdfQ==

package/esm2015/models/public-api.js

@@ -0,0 +1,8 @@
+export * from './http-status-codes';
+export * from './theme-types';
+export * from './theme-names';
+export * from './theme-prefixes';
+export * from './size-prefixes';
+export * from './size-types';
+export * from './component-type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tb2RlbHMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsZUFBZSxDQUFBO0FBQzdCLGNBQWMsZUFBZSxDQUFBO0FBQzdCLGNBQWMsa0JBQWtCLENBQUE7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQTtBQUMvQixjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGtCQUFrQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9odHRwLXN0YXR1cy1jb2RlcydcbmV4cG9ydCAqIGZyb20gJy4vdGhlbWUtdHlwZXMnXG5leHBvcnQgKiBmcm9tICcuL3RoZW1lLW5hbWVzJ1xuZXhwb3J0ICogZnJvbSAnLi90aGVtZS1wcmVmaXhlcydcbmV4cG9ydCAqIGZyb20gJy4vc2l6ZS1wcmVmaXhlcydcbmV4cG9ydCAqIGZyb20gJy4vc2l6ZS10eXBlcydcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50LXR5cGUnXG4iXX0=

package/esm2015/models/size-prefixes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2l6ZS1wcmVmaXhlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tb2RlbHMvc2l6ZS1wcmVmaXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgU2l6ZVByZWZpeGVzID0gJ2J0bidcbiJdfQ==

package/esm2015/models/size-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2l6ZS10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tb2RlbHMvc2l6ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgU2l6ZVR5cGVzID1cbiAgJ2RlZmF1bHQnXG4gIHwgJ3ByaW1hcnknXG4gIHwgJ3NlY29uZGFyeSdcbiAgfCAnc3VjY2VzcydcbiAgfCAnZGFuZ2VyJ1xuICB8ICd3YXJuaW5nJ1xuICB8ICdpbmZvJ1xuICB8ICdsaWdodCdcbiAgfCAnZGFyaydcbiAgfCAnbGlnaHRncmF5J1xuICB8ICdsaWdodGJsdWUnXG4iXX0=

package/esm2015/models/theme-names.js

@@ -0,0 +1,26 @@
+export const ThemeNames = [
+    'default',
+    'primary',
+    'secondary',
+    'success',
+    'danger',
+    'warning',
+    'info',
+    'light',
+    'dark',
+    'lightgray',
+    'lightblue'
+];
+export const OutlineThemeNames = [
+    'outline-primary',
+    'outline-secondary',
+    'outline-success',
+    'outline-danger',
+    'outline-warning',
+    'outline-info',
+    'outline-light',
+    'outline-dark',
+    'outline-lightgray',
+    'outline-lightblue'
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtbmFtZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kZWxzL3RoZW1lLW5hbWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBYTtJQUNsQyxTQUFTO0lBQ1QsU0FBUztJQUNULFdBQVc7SUFDWCxTQUFTO0lBQ1QsUUFBUTtJQUNSLFNBQVM7SUFDVCxNQUFNO0lBQ04sT0FBTztJQUNQLE1BQU07SUFDTixXQUFXO0lBQ1gsV0FBVztDQUNaLENBQUE7QUFFRCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBYTtJQUN6QyxpQkFBaUI7SUFDakIsbUJBQW1CO0lBQ25CLGlCQUFpQjtJQUNqQixnQkFBZ0I7SUFDaEIsaUJBQWlCO0lBQ2pCLGNBQWM7SUFDZCxlQUFlO0lBQ2YsY0FBYztJQUNkLG1CQUFtQjtJQUNuQixtQkFBbUI7Q0FDcEIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBUaGVtZU5hbWVzOiBzdHJpbmdbXSA9IFtcbiAgJ2RlZmF1bHQnLFxuICAncHJpbWFyeScsXG4gICdzZWNvbmRhcnknLFxuICAnc3VjY2VzcycsXG4gICdkYW5nZXInLFxuICAnd2FybmluZycsXG4gICdpbmZvJyxcbiAgJ2xpZ2h0JyxcbiAgJ2RhcmsnLFxuICAnbGlnaHRncmF5JyxcbiAgJ2xpZ2h0Ymx1ZSdcbl1cblxuZXhwb3J0IGNvbnN0IE91dGxpbmVUaGVtZU5hbWVzOiBzdHJpbmdbXSA9IFtcbiAgJ291dGxpbmUtcHJpbWFyeScsXG4gICdvdXRsaW5lLXNlY29uZGFyeScsXG4gICdvdXRsaW5lLXN1Y2Nlc3MnLFxuICAnb3V0bGluZS1kYW5nZXInLFxuICAnb3V0bGluZS13YXJuaW5nJyxcbiAgJ291dGxpbmUtaW5mbycsXG4gICdvdXRsaW5lLWxpZ2h0JyxcbiAgJ291dGxpbmUtZGFyaycsXG4gICdvdXRsaW5lLWxpZ2h0Z3JheScsXG4gICdvdXRsaW5lLWxpZ2h0Ymx1ZSdcbl1cbiJdfQ==

package/esm2015/models/theme-prefixes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtcHJlZml4ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kZWxzL3RoZW1lLXByZWZpeGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBUaGVtZVByZWZpeGVzID0gJ2J0bicgfCAndGV4dCcgfCAnYmcnIHwgJ2JhZGdlJyB8ICdsaXN0LWdyb3VwLWl0ZW0nXG4iXX0=

package/esm2015/models/theme-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kZWxzL3RoZW1lLXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBUaGVtZVR5cGVzID1cbiAgJ2RlZmF1bHQnXG4gIHwgJ3ByaW1hcnknXG4gIHwgJ3NlY29uZGFyeSdcbiAgfCAnc3VjY2VzcydcbiAgfCAnZGFuZ2VyJ1xuICB8ICd3YXJuaW5nJ1xuICB8ICdpbmZvJ1xuICB8ICdsaWdodCdcbiAgfCAnZGFyaydcbiAgfCAnbGlnaHRncmF5J1xuICB8ICdsaWdodGJsdWUnXG5cbmV4cG9ydCB0eXBlIE91dGxpbmVUaGVtZVR5cGVzID1cbiAgfCAnb3V0bGluZS1wcmltYXJ5J1xuICB8ICdvdXRsaW5lLXNlY29uZGFyeSdcbiAgfCAnb3V0bGluZS1zdWNjZXNzJ1xuICB8ICdvdXRsaW5lLWRhbmdlcidcbiAgfCAnb3V0bGluZS13YXJuaW5nJ1xuICB8ICdvdXRsaW5lLWluZm8nXG4gIHwgJ291dGxpbmUtbGlnaHQnXG4gIHwgJ291dGxpbmUtZGFyaydcbiAgfCAnb3V0bGluZS1saWdodGdyYXknXG4gIHwgJ291dGxpbmUtbGlnaHRibHVlJ1xuIl19

package/esm2015/models/theseam-ui-common-models.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlc2VhbS11aS1jb21tb24tbW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL21vZGVscy90aGVzZWFtLXVpLWNvbW1vbi1tb2RlbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/popover/popover/popover.component.js

@@ -0,0 +1,149 @@
+import { transition, trigger, useAnimation } from '@angular/animations';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
+import { ChangeDetectionStrategy, ChangeDetectorRef, 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';
+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();
+        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.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-popover',
+                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",
+                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,
+                styles: [":host{display:block;max-width:800px;min-width:100%}"]
+            },] }
+];
+PopoverComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+PopoverComponent.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"],"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()\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()\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"]}

package/esm2015/popover/popover-animations.js

@@ -0,0 +1,46 @@
+import { animate, animation, group, query, style } from '@angular/animations';
+export const popoverSlideIn = animation([
+    query(':self', [
+        style({
+            opacity: 0,
+            transform: 'translateY(-70%)'
+        }),
+        group([
+            animate('170ms linear', style({ opacity: 1 })),
+            animate('220ms ease', style({ transform: 'translateY(0)' })),
+        ])
+    ])
+]);
+export const popoverSlideOut = animation([
+    query(':self', [
+        style({
+            opacity: 1,
+            transform: 'translateY(0)'
+        }),
+        group([
+            animate('170ms linear', style({ opacity: 0 })),
+            animate('220ms ease', style({ transform: 'translateY(-70%)' })),
+        ])
+    ])
+]);
+export const popoverExpandIn = animation([
+    style({
+        opacity: 0,
+        transform: 'scale(0.8)'
+    }),
+    group([
+        animate('100ms linear', style({ opacity: 1 })),
+        animate('120ms ease', style({ transform: 'scale(1)' })),
+    ])
+]);
+export const popoverExpandOut = animation([
+    style({
+        opacity: 1,
+        transform: 'scale(1)'
+    }),
+    group([
+        animate('100ms linear', style({ opacity: 0 })),
+        animate('120ms ease', style({ transform: 'scale(0.8)' })),
+    ])
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/popover/popover.directive.js

@@ -0,0 +1,257 @@
+import { FocusMonitor, isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { ESCAPE } from '@angular/cdk/keycodes';
+import { Overlay } from '@angular/cdk/overlay';
+import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Directive, ElementRef, HostListener, Input, ViewContainerRef } from '@angular/core';
+import { BehaviorSubject, merge, of, Subject, Subscription } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { PopoverComponent } from './popover/popover.component';
+/** 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();
+        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 => {
+            var _a;
+            // console.log('closed', v)
+            if ((_a = this._overlayRef) === null || _a === void 0 ? void 0 : _a.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() {
+        var _a, _b;
+        return (_b = (_a = this._overlayRef) === null || _a === void 0 ? void 0 : _a.hasAttached()) !== null && _b !== void 0 ? _b : 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() {
+        var _a, _b, _c, _d;
+        const backdrop = (_b = (_a = this._overlayRef) === null || _a === void 0 ? void 0 : _a.backdropClick()) !== null && _b !== void 0 ? _b : of();
+        const detachments = (_d = (_c = this._overlayRef) === null || _c === void 0 ? void 0 : _c.detachments()) !== null && _d !== void 0 ? _d : of();
+        const hover = of();
+        return merge(backdrop, hover, detachments);
+    }
+}
+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'
+            },] }
+];
+TheSeamPopoverDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: ViewContainerRef },
+    { type: Overlay },
+    { type: FocusMonitor }
+];
+TheSeamPopoverDirective.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()\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()\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"]}