@theseam/ui-common 0.2.9

package/esm2015/menu/menu.component.js

@@ -0,0 +1,174 @@
+import { transition, trigger, useAnimation } from '@angular/animations';
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { DOWN_ARROW, END, ESCAPE, hasModifierKey, HOME, UP_ARROW } from '@angular/cdk/keycodes';
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, Input, Output, TemplateRef, ViewChild } from '@angular/core';
+import { BehaviorSubject, fromEvent, merge, of, Subject, Subscription } from 'rxjs';
+import { distinctUntilChanged, map, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import { menuDropdownPanelIn, menuDropdownPanelOut } from './menu-animations';
+import { THESEAM_MENU_PANEL } from './menu-panel-token';
+export const LIB_MENU = {
+    provide: THESEAM_MENU_PANEL,
+    // tslint:disable-next-line:no-use-before-declare
+    useExisting: forwardRef(() => MenuComponent)
+};
+export class MenuComponent {
+    constructor() {
+        this._ngUnsubscribe = new Subject();
+        this._footer = new BehaviorSubject(undefined);
+        this.hasFooter$ = this._footer.pipe(map(v => v !== null && v !== undefined));
+        this._header = new BehaviorSubject(undefined);
+        this.hasHeader$ = this._header.pipe(map(v => v !== null && v !== undefined));
+        /** Menu items inside the current menu. */
+        this._items = [];
+        /** Emits whenever the amount of menu items changes. */
+        this._itemChanges = new Subject();
+        /** Subscription to tab events on the menu panel */
+        this._tabSubscription = Subscription.EMPTY;
+        this.closed = new EventEmitter();
+        this._baseWidth = new BehaviorSubject(null);
+        this.animationType = 'slide';
+        this._menuWidth$ = 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);
+        }), distinctUntilChanged(), takeUntil(this._ngUnsubscribe));
+    }
+    /**
+     * Defines a width for a menu 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);
+        }
+    }
+    ngOnDestroy() {
+        this._tabSubscription.unsubscribe();
+        this.closed.complete();
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    ngAfterContentInit() {
+        this._keyManager = new FocusKeyManager(this._items).withWrap().withTypeAhead();
+        this._tabSubscription = this._keyManager.tabOut.subscribe(() => this.closed.emit('tab'));
+    }
+    /** Stream that emits whenever the hovered menu item changes. */
+    _hovered() {
+        return this._itemChanges.pipe(startWith(this._items), switchMap(items => merge(...items.map(item => item._hovered))));
+    }
+    /** Handle a keyboard event from the menu, delegating to the appropriate action. */
+    _handleKeydown(event) {
+        // tslint:disable-next-line:deprecation
+        const keyCode = event.keyCode;
+        const manager = this._keyManager;
+        switch (keyCode) {
+            case ESCAPE:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this.closed.emit('keydown');
+                }
+                break;
+            // case LEFT_ARROW:
+            //   if (this.parentMenu && this.direction === 'ltr') {
+            //     this.closed.emit('keydown')
+            //   }
+            //   break
+            // case RIGHT_ARROW:
+            //   if (this.parentMenu && this.direction === 'rtl') {
+            //     this.closed.emit('keydown')
+            //   }
+            //   break
+            case HOME:
+            case END:
+                if (!hasModifierKey(event)) {
+                    keyCode === HOME ? manager === null || manager === void 0 ? void 0 : manager.setFirstItemActive() : manager === null || manager === void 0 ? void 0 : manager.setLastItemActive();
+                    event.preventDefault();
+                }
+                break;
+            default:
+                if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {
+                    manager === null || manager === void 0 ? void 0 : manager.setFocusOrigin('keyboard');
+                }
+                manager === null || manager === void 0 ? void 0 : manager.onKeydown(event);
+        }
+    }
+    /**
+     * Focus the first item in the menu.
+     * @param origin Action from which the focus originated. Used to set the correct styling.
+     */
+    focusFirstItem(origin = 'program') {
+        var _a;
+        (_a = this._keyManager) === null || _a === void 0 ? void 0 : _a.setFocusOrigin(origin).setFirstItemActive();
+    }
+    /**
+     * Resets the active item in the menu. This is used when the menu is opened, allowing
+     * the user to start from the first option when pressing the down arrow.
+     */
+    resetActiveItem() {
+        var _a;
+        (_a = this._keyManager) === null || _a === void 0 ? void 0 : _a.setActiveItem(-1);
+    }
+    /** Registers a menu item with the menu. */
+    addItem(item) {
+        // We register the items through this method, rather than picking them up through
+        // `ContentChildren`, because we need the items to be picked up by their closest
+        // `seam-menu` ancestor. If we used `@ContentChildren(MenuItemComponent, {descendants: true})`,
+        // all descendant items will bleed into the top-level menu in the case where the consumer
+        // has `seam-menu` instances nested inside each other.
+        if (this._items.indexOf(item) === -1) {
+            this._items.push(item);
+            this._itemChanges.next(this._items);
+        }
+    }
+    /** Removes an item from the menu. */
+    removeItem(item) {
+        const index = this._items.indexOf(item);
+        if (this._items.indexOf(item) > -1) {
+            this._items.splice(index, 1);
+            this._itemChanges.next(this._items);
+        }
+    }
+    /** Sets the footer component. */
+    setFooter(footer) {
+        this._footer.next(footer);
+    }
+    /** Sets the header component. */
+    setHeader(header) {
+        this._header.next(header);
+    }
+    _dropdownMenuClick(event) {
+        // This is needed, because some menu's will get stuck open if the component
+        // managing the menu is destroyed before the menu finishes its cleanup. I
+        // may look for a fix to that eventually.
+        this.closed.emit('click');
+    }
+}
+MenuComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-menu',
+                template: "<ng-template>\n  <div class=\"seam-menu-container\" @slideDown\n    [class.seam-menu-anim--slide]=\"animationType==='slide'\"\n    [class.seam-menu-anim--fade]=\"animationType==='fade'\">\n    <div class=\"dropdown-menu show position-static{{ menuClass ? ' ' + menuClass : '' }}\"\n      [style.width]=\"_menuWidth$ | async\"\n      [class.pt-0]=\"hasHeader$ | async\"\n      [class.pb-0]=\"hasFooter$ | async\"\n      (keydown)=\"_handleKeydown($event)\"\n      (click)=\"_dropdownMenuClick($event)\"\n      tabindex=\"-1\"\n      role=\"menu\"\n      >\n      <ng-content></ng-content>\n    </div>\n  </div>\n</ng-template>\n",
+                providers: [LIB_MENU],
+                animations: [
+                    trigger('slideDown', [
+                        transition(':enter', useAnimation(menuDropdownPanelIn)),
+                        transition(':leave', useAnimation(menuDropdownPanelOut)),
+                    ])
+                ],
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                exportAs: 'seamMenu',
+                styles: [".seam-menu-container.seam-menu-anim--slide{overflow:hidden}.dropdown-menu.ng-animating,.seam-menu-container.ng-animating{-webkit-user-select:none;-moz-user-select:none;user-select:none;pointer-events:none}"]
+            },] }
+];
+MenuComponent.ctorParameters = () => [];
+MenuComponent.propDecorators = {
+    templateRef: [{ type: ViewChild, args: [TemplateRef,] }],
+    closed: [{ type: Output }],
+    menuClass: [{ type: Input }],
+    baseWidth: [{ type: Input }],
+    animationType: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.component.js","sourceRoot":"","sources":["../../../../projects/ui-common/menu/menu.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { animate, group, query, style, transition, trigger, useAnimation } from '@angular/animations'\nimport { FocusKeyManager, FocusOrigin } from '@angular/cdk/a11y'\nimport { coerceNumberProperty } from '@angular/cdk/coercion'\nimport { DOWN_ARROW, END, ESCAPE, hasModifierKey, HOME, LEFT_ARROW, RIGHT_ARROW, UP_ARROW } from '@angular/cdk/keycodes'\nimport {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnDestroy,\n  Output,\n  TemplateRef,\n  ViewChild\n} from '@angular/core'\nimport { BehaviorSubject, fromEvent, merge, Observable, of, Subject, Subscription } from 'rxjs'\n\nimport { distinctUntilChanged, map, startWith, switchMap, takeUntil } from 'rxjs/operators'\nimport { menuDropdownPanelIn, menuDropdownPanelOut, menuDropdownPanelSlideIn, menuDropdownPanelSlideOut } from './menu-animations'\nimport { MenuItemComponent } from './menu-item.component'\nimport { ITheSeamMenuPanel } from './menu-panel'\nimport { THESEAM_MENU_PANEL } from './menu-panel-token'\n\nimport { MenuFooterComponent } from './menu-footer/menu-footer.component'\nimport { MenuHeaderComponent } from './menu-header/menu-header.component'\n\nexport const LIB_MENU: any = {\n  provide: THESEAM_MENU_PANEL,\n  // tslint:disable-next-line:no-use-before-declare\n  useExisting: forwardRef(() => MenuComponent)\n}\n\n@Component({\n  selector: 'seam-menu',\n  templateUrl: './menu.component.html',\n  styleUrls: ['./menu.component.scss'],\n  providers: [ LIB_MENU ],\n  animations: [\n    trigger('slideDown', [\n      transition(':enter', useAnimation(menuDropdownPanelIn)),\n      transition(':leave', useAnimation(menuDropdownPanelOut)),\n    ])\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  exportAs: 'seamMenu'\n})\nexport class MenuComponent implements OnDestroy, AfterContentInit, ITheSeamMenuPanel {\n\n  private readonly _ngUnsubscribe = new Subject()\n\n  private _footer = new BehaviorSubject<MenuFooterComponent | undefined | null>(undefined)\n  public hasFooter$ = this._footer.pipe(map(v => v !== null && v !== undefined))\n\n  private _header = new BehaviorSubject<MenuHeaderComponent | undefined | null>(undefined)\n  public hasHeader$ = this._header.pipe(map(v => v !== null && v !== undefined))\n\n  private _keyManager?: FocusKeyManager<MenuItemComponent>\n\n  /** Menu items inside the current menu. */\n  private _items: MenuItemComponent[] = []\n\n  /** Emits whenever the amount of menu items changes. */\n  private _itemChanges = new Subject<MenuItemComponent[]>()\n\n  /** Subscription to tab events on the menu panel */\n  private _tabSubscription = Subscription.EMPTY\n\n  /** Parent menu of the current menu panel. */\n  parentMenu: ITheSeamMenuPanel | undefined\n\n  @ViewChild(TemplateRef) templateRef?: TemplateRef<any>\n\n  @Output() readonly closed = new EventEmitter<void | 'click' | 'keydown' | 'tab'>()\n\n  @Input() menuClass: string  | undefined | null\n\n  /**\n   * Defines a width for a menu 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>(null)\n  _menuWidth$: Observable<string | undefined>\n\n  @Input() animationType: 'slide' | 'fade' = 'slide'\n\n  constructor() {\n    this._menuWidth$ = 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      distinctUntilChanged(),\n      takeUntil(this._ngUnsubscribe)\n    )\n  }\n\n  ngOnDestroy() {\n    this._tabSubscription.unsubscribe()\n    this.closed.complete()\n\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  ngAfterContentInit() {\n    this._keyManager = new FocusKeyManager<MenuItemComponent>(this._items).withWrap().withTypeAhead()\n    this._tabSubscription = this._keyManager.tabOut.subscribe(() => this.closed.emit('tab'))\n  }\n\n  /** Stream that emits whenever the hovered menu item changes. */\n  _hovered(): Observable<MenuItemComponent> {\n    return this._itemChanges.pipe(\n      startWith(this._items),\n      switchMap(items => merge(...items.map(item => item._hovered)))\n    )\n  }\n\n  /** Handle a keyboard event from the menu, delegating to the appropriate action. */\n  _handleKeydown(event: KeyboardEvent) {\n    // tslint:disable-next-line:deprecation\n    const keyCode = event.keyCode\n    const manager = this._keyManager\n\n    switch (keyCode) {\n      case ESCAPE:\n        if (!hasModifierKey(event)) {\n          event.preventDefault()\n          this.closed.emit('keydown')\n        }\n        break\n      // case LEFT_ARROW:\n      //   if (this.parentMenu && this.direction === 'ltr') {\n      //     this.closed.emit('keydown')\n      //   }\n      //   break\n      // case RIGHT_ARROW:\n      //   if (this.parentMenu && this.direction === 'rtl') {\n      //     this.closed.emit('keydown')\n      //   }\n      //   break\n      case HOME:\n      case END:\n        if (!hasModifierKey(event)) {\n          keyCode === HOME ? manager?.setFirstItemActive() : manager?.setLastItemActive()\n          event.preventDefault()\n        }\n        break\n      default:\n        if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {\n          manager?.setFocusOrigin('keyboard')\n        }\n\n        manager?.onKeydown(event)\n    }\n  }\n\n  /**\n   * Focus the first item in the menu.\n   * @param origin Action from which the focus originated. Used to set the correct styling.\n   */\n  focusFirstItem(origin: FocusOrigin = 'program'): void {\n    this._keyManager?.setFocusOrigin(origin).setFirstItemActive()\n  }\n\n  /**\n   * Resets the active item in the menu. This is used when the menu is opened, allowing\n   * the user to start from the first option when pressing the down arrow.\n   */\n  resetActiveItem() {\n    this._keyManager?.setActiveItem(-1)\n  }\n\n  /** Registers a menu item with the menu. */\n  addItem(item: MenuItemComponent) {\n    // We register the items through this method, rather than picking them up through\n    // `ContentChildren`, because we need the items to be picked up by their closest\n    // `seam-menu` ancestor. If we used `@ContentChildren(MenuItemComponent, {descendants: true})`,\n    // all descendant items will bleed into the top-level menu in the case where the consumer\n    // has `seam-menu` instances nested inside each other.\n    if (this._items.indexOf(item) === -1) {\n      this._items.push(item)\n      this._itemChanges.next(this._items)\n    }\n  }\n\n  /** Removes an item from the menu. */\n  removeItem(item: MenuItemComponent) {\n    const index = this._items.indexOf(item)\n\n    if (this._items.indexOf(item) > -1) {\n      this._items.splice(index, 1)\n      this._itemChanges.next(this._items)\n    }\n  }\n\n  /** Sets the footer component. */\n  setFooter(footer?: MenuFooterComponent) {\n    this._footer.next(footer)\n  }\n\n  /** Sets the header component. */\n  setHeader(header?: MenuHeaderComponent) {\n    this._header.next(header)\n  }\n\n  _dropdownMenuClick(event: Event) {\n    // This is needed, because some menu's will get stuck open if the component\n    // managing the menu is destroyed before the menu finishes its cleanup. I\n    // may look for a fix to that eventually.\n    this.closed.emit('click')\n  }\n\n}\n"]}

package/esm2015/menu/menu.module.js

@@ -0,0 +1,43 @@
+import { OverlayModule } from '@angular/cdk/overlay';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TheSeamIconModule } from '@theseam/ui-common/icon';
+import { MenuDividerComponent } from './menu-divider.component';
+import { MenuFooterActionComponent } from './menu-footer-action/menu-footer-action.component';
+import { MenuFooterComponent } from './menu-footer/menu-footer.component';
+import { MenuHeaderComponent } from './menu-header/menu-header.component';
+import { MenuItemComponent } from './menu-item.component';
+import { MenuToggleDirective } from './menu-toggle.directive';
+import { MenuComponent } from './menu.component';
+export class TheSeamMenuModule {
+}
+TheSeamMenuModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    MenuComponent,
+                    MenuToggleDirective,
+                    MenuItemComponent,
+                    MenuDividerComponent,
+                    MenuFooterComponent,
+                    MenuFooterActionComponent,
+                    MenuHeaderComponent,
+                ],
+                imports: [
+                    CommonModule,
+                    OverlayModule,
+                    TheSeamIconModule
+                ],
+                exports: [
+                    MenuComponent,
+                    MenuToggleDirective,
+                    MenuItemComponent,
+                    MenuDividerComponent,
+                    TheSeamIconModule,
+                    OverlayModule,
+                    MenuFooterComponent,
+                    MenuFooterActionComponent,
+                    MenuHeaderComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/menu/public-api.js

@@ -0,0 +1,12 @@
+export * from './menu-animations';
+export * from './menu-divider.component';
+export * from './menu-item.component';
+export * from './menu-panel-token';
+export * from './menu-panel';
+export * from './menu-toggle.directive';
+export * from './menu.component';
+export * from './menu.module';
+export * from './menu-header/menu-header.component';
+export * from './menu-footer/menu-footer.component';
+export * from './menu-footer-action/menu-footer-action.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tZW51L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLDBCQUEwQixDQUFBO0FBQ3hDLGNBQWMsdUJBQXVCLENBQUE7QUFDckMsY0FBYyxvQkFBb0IsQ0FBQTtBQUNsQyxjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLHlCQUF5QixDQUFBO0FBQ3ZDLGNBQWMsa0JBQWtCLENBQUE7QUFDaEMsY0FBYyxlQUFlLENBQUE7QUFFN0IsY0FBYyxxQ0FBcUMsQ0FBQTtBQUNuRCxjQUFjLHFDQUFxQyxDQUFBO0FBQ25ELGNBQWMsbURBQW1ELENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21lbnUtYW5pbWF0aW9ucydcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1kaXZpZGVyLmNvbXBvbmVudCdcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1pdGVtLmNvbXBvbmVudCdcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1wYW5lbC10b2tlbidcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1wYW5lbCdcbmV4cG9ydCAqIGZyb20gJy4vbWVudS10b2dnbGUuZGlyZWN0aXZlJ1xuZXhwb3J0ICogZnJvbSAnLi9tZW51LmNvbXBvbmVudCdcbmV4cG9ydCAqIGZyb20gJy4vbWVudS5tb2R1bGUnXG5cbmV4cG9ydCAqIGZyb20gJy4vbWVudS1oZWFkZXIvbWVudS1oZWFkZXIuY29tcG9uZW50J1xuZXhwb3J0ICogZnJvbSAnLi9tZW51LWZvb3Rlci9tZW51LWZvb3Rlci5jb21wb25lbnQnXG5leHBvcnQgKiBmcm9tICcuL21lbnUtZm9vdGVyLWFjdGlvbi9tZW51LWZvb3Rlci1hY3Rpb24uY29tcG9uZW50J1xuIl19

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

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

package/esm2015/modal/directives/modal-close.directive.js

@@ -0,0 +1,63 @@
+import { Directive, ElementRef, HostBinding, HostListener, Input, Optional } from '@angular/core';
+import { ModalRef } from '../modal-ref';
+import { getClosestModal } from '../modal-utils';
+import { Modal } from '../modal.service';
+export class ModalCloseDirective {
+    constructor(_elementRef, _modal, _modalRef) {
+        this._elementRef = _elementRef;
+        this._modal = _modal;
+        this._modalRef = _modalRef;
+        this.type = 'button';
+        this.modalRef = _modalRef;
+    }
+    // @HostBinding('class.close') _closeCss = true
+    get _attrType() { return this.type; }
+    get _attrAriaLabel() { return this.ariaLabel || null; }
+    _onClick() {
+        if (this.modalRef) {
+            if (this.seamModalNext) {
+                this.modalRef.afterClosed().subscribe(() => {
+                    if (typeof this.seamModalNext === 'string') {
+                        this._modal.openFromLazyComponent(this.seamModalNext, this.seamModalNextConfig).subscribe();
+                    }
+                    else {
+                        this._modal.openFromComponent(this.seamModalNext, this.seamModalNextConfig);
+                    }
+                });
+            }
+            this.modalRef.close(this.seamModalClose);
+        }
+    }
+    ngOnInit() {
+        if (!this.modalRef) {
+            // When this directive is included in a dialog via TemplateRef (rather than being
+            // in a Component), the DialogRef isn't available via injection because embedded
+            // views cannot be given a custom injector. Instead, we look up the DialogRef by
+            // ID. This must occur in `onInit`, as the ID binding for the dialog container won't
+            // be resolved at constructor time.
+            this.modalRef = getClosestModal(this._elementRef, this._modal.openDialogs);
+        }
+    }
+}
+ModalCloseDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'button[seamModalClose]',
+                exportAs: 'seamModalClose'
+            },] }
+];
+ModalCloseDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Modal },
+    { type: ModalRef, decorators: [{ type: Optional }] }
+];
+ModalCloseDirective.propDecorators = {
+    _attrType: [{ type: HostBinding, args: ['attr.type',] }],
+    type: [{ type: Input }],
+    _attrAriaLabel: [{ type: HostBinding, args: ['attr.aria-label',] }],
+    ariaLabel: [{ type: Input, args: ['aria-label',] }],
+    seamModalClose: [{ type: Input }],
+    seamModalNext: [{ type: Input }],
+    seamModalNextConfig: [{ type: Input }],
+    _onClick: [{ type: HostListener, args: ['click',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/modal/directives/modal-footer-tpl.directive.js

@@ -0,0 +1,15 @@
+import { Directive, TemplateRef } from '@angular/core';
+export class ModalFooterTplDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+ModalFooterTplDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[seamModalFooterTpl]'
+            },] }
+];
+ModalFooterTplDirective.ctorParameters = () => [
+    { type: TemplateRef }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtZm9vdGVyLXRwbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kYWwvZGlyZWN0aXZlcy9tb2RhbC1mb290ZXItdHBsLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUt0RCxNQUFNLE9BQU8sdUJBQXVCO0lBRWxDLFlBQW1CLFFBQTBCO1FBQTFCLGFBQVEsR0FBUixRQUFRLENBQWtCO0lBQUksQ0FBQzs7O1lBTG5ELFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsc0JBQXNCO2FBQ2pDOzs7WUFKbUIsV0FBVyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbc2VhbU1vZGFsRm9vdGVyVHBsXSdcbn0pXG5leHBvcnQgY2xhc3MgTW9kYWxGb290ZXJUcGxEaXJlY3RpdmUge1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8YW55PikgeyB9XG5cbn1cbiJdfQ==

package/esm2015/modal/directives/modal-header-icon-tpl.directive.js

@@ -0,0 +1,15 @@
+import { Directive, TemplateRef } from '@angular/core';
+export class ModalHeaderIconTplDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+ModalHeaderIconTplDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[seamModalHeaderIconTpl]'
+            },] }
+];
+ModalHeaderIconTplDirective.ctorParameters = () => [
+    { type: TemplateRef }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtaGVhZGVyLWljb24tdHBsLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tb2RhbC9kaXJlY3RpdmVzL21vZGFsLWhlYWRlci1pY29uLXRwbC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFLdEQsTUFBTSxPQUFPLDJCQUEyQjtJQUV0QyxZQUFtQixRQUEwQjtRQUExQixhQUFRLEdBQVIsUUFBUSxDQUFrQjtJQUFJLENBQUM7OztZQUxuRCxTQUFTLFNBQUM7Z0JBQ1QsUUFBUSxFQUFFLDBCQUEwQjthQUNyQzs7O1lBSm1CLFdBQVciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3NlYW1Nb2RhbEhlYWRlckljb25UcGxdJ1xufSlcbmV4cG9ydCBjbGFzcyBNb2RhbEhlYWRlckljb25UcGxEaXJlY3RpdmUge1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8YW55PikgeyB9XG5cbn1cbiJdfQ==

package/esm2015/modal/directives/modal-header-title-tpl.directive.js

@@ -0,0 +1,15 @@
+import { Directive, TemplateRef } from '@angular/core';
+export class ModalHeaderTitleTplDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+ModalHeaderTitleTplDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[seamModalHeaderTitleTpl]'
+            },] }
+];
+ModalHeaderTitleTplDirective.ctorParameters = () => [
+    { type: TemplateRef }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtaGVhZGVyLXRpdGxlLXRwbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vbW9kYWwvZGlyZWN0aXZlcy9tb2RhbC1oZWFkZXItdGl0bGUtdHBsLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUt0RCxNQUFNLE9BQU8sNEJBQTRCO0lBRXZDLFlBQW1CLFFBQTBCO1FBQTFCLGFBQVEsR0FBUixRQUFRLENBQWtCO0lBQUksQ0FBQzs7O1lBTG5ELFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsMkJBQTJCO2FBQ3RDOzs7WUFKbUIsV0FBVyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbc2VhbU1vZGFsSGVhZGVyVGl0bGVUcGxdJ1xufSlcbmV4cG9ydCBjbGFzcyBNb2RhbEhlYWRlclRpdGxlVHBsRGlyZWN0aXZlIHtcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4pIHsgfVxuXG59XG4iXX0=

package/esm2015/modal/directives/modal-title.directive.js

@@ -0,0 +1,19 @@
+import { Directive, ElementRef, HostBinding } from '@angular/core';
+export class ModalTitleDirective {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        this._modalTitleCss = true;
+    }
+}
+ModalTitleDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[seamModalTitle]'
+            },] }
+];
+ModalTitleDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+ModalTitleDirective.propDecorators = {
+    _modalTitleCss: [{ type: HostBinding, args: ['class.modal-title',] }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtdGl0bGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL21vZGFsL2RpcmVjdGl2ZXMvbW9kYWwtdGl0bGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBZSxNQUFNLGVBQWUsQ0FBQTtBQUsvRSxNQUFNLE9BQU8sbUJBQW1CO0lBSTlCLFlBQ1UsV0FBb0M7UUFBcEMsZ0JBQVcsR0FBWCxXQUFXLENBQXlCO1FBSFosbUJBQWMsR0FBRyxJQUFJLENBQUE7SUFJbkQsQ0FBQzs7O1lBVE4sU0FBUyxTQUFDO2dCQUNULFFBQVEsRUFBRSxrQkFBa0I7YUFDN0I7OztZQUptQixVQUFVOzs7NkJBTzNCLFdBQVcsU0FBQyxtQkFBbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEhvc3RCaW5kaW5nLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tzZWFtTW9kYWxUaXRsZV0nXG59KVxuZXhwb3J0IGNsYXNzIE1vZGFsVGl0bGVEaXJlY3RpdmUge1xuXG4gIEBIb3N0QmluZGluZygnY2xhc3MubW9kYWwtdGl0bGUnKSBfbW9kYWxUaXRsZUNzcyA9IHRydWVcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIF9lbGVtZW50UmVmOiBFbGVtZW50UmVmPEhUTUxFbGVtZW50PlxuICApIHsgfVxuXG59XG4iXX0=

package/esm2015/modal/directives/modal.directive.js

@@ -0,0 +1,25 @@
+import { Directive, TemplateRef } from '@angular/core';
+import { Modal } from '../modal.service';
+// TODO: Make this work for current modal usage.
+export class ModalDirective {
+    constructor(template, modal) {
+        this.template = template;
+        this.modal = modal;
+    }
+    open() {
+        // console.log('[ModalDirective] open')
+        const ref = this.modal.openFromTemplate(this.template);
+        ref.backdropClick().subscribe(e => console.log('backdropClick', e));
+    }
+}
+ModalDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[seamModal]',
+                exportAs: 'seamModal'
+            },] }
+];
+ModalDirective.ctorParameters = () => [
+    { type: TemplateRef },
+    { type: Modal }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL21vZGFsL2RpcmVjdGl2ZXMvbW9kYWwuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBR3RELE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUV4QyxnREFBZ0Q7QUFNaEQsTUFBTSxPQUFPLGNBQWM7SUFFekIsWUFDUyxRQUFrQyxFQUNsQyxLQUFZO1FBRFosYUFBUSxHQUFSLFFBQVEsQ0FBMEI7UUFDbEMsVUFBSyxHQUFMLEtBQUssQ0FBTztJQUNqQixDQUFDO0lBRUwsSUFBSTtRQUNGLHVDQUF1QztRQUN2QyxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUN0RCxHQUFHLENBQUMsYUFBYSxFQUFFLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUNyRSxDQUFDOzs7WUFmRixTQUFTLFNBQUM7Z0JBQ1QsUUFBUSxFQUFFLGFBQWE7Z0JBQ3ZCLFFBQVEsRUFBRSxXQUFXO2FBQ3RCOzs7WUFWbUIsV0FBVztZQUd0QixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IE1vZGFsUmVmIH0gZnJvbSAnLi4vbW9kYWwtcmVmJ1xuaW1wb3J0IHsgTW9kYWwgfSBmcm9tICcuLi9tb2RhbC5zZXJ2aWNlJ1xuXG4vLyBUT0RPOiBNYWtlIHRoaXMgd29yayBmb3IgY3VycmVudCBtb2RhbCB1c2FnZS5cblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3NlYW1Nb2RhbF0nLFxuICBleHBvcnRBczogJ3NlYW1Nb2RhbCdcbn0pXG5leHBvcnQgY2xhc3MgTW9kYWxEaXJlY3RpdmUge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8SFRNTEVsZW1lbnQ+LFxuICAgIHB1YmxpYyBtb2RhbDogTW9kYWxcbiAgKSB7IH1cblxuICBvcGVuKCk6IHZvaWQge1xuICAgIC8vIGNvbnNvbGUubG9nKCdbTW9kYWxEaXJlY3RpdmVdIG9wZW4nKVxuICAgIGNvbnN0IHJlZiA9IHRoaXMubW9kYWwub3BlbkZyb21UZW1wbGF0ZSh0aGlzLnRlbXBsYXRlKVxuICAgIHJlZi5iYWNrZHJvcENsaWNrKCkuc3Vic2NyaWJlKGUgPT4gY29uc29sZS5sb2coJ2JhY2tkcm9wQ2xpY2snLCBlKSlcbiAgfVxuXG59XG4iXX0=

package/esm2015/modal/modal/modal.component.js

@@ -0,0 +1,149 @@
+import { __decorate } from "tslib";
+import { ESCAPE } from '@angular/cdk/keycodes';
+import { Overlay } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Component, ContentChild, EventEmitter, forwardRef, Input, isDevMode, Output, ViewChild, ViewContainerRef } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import { InputBoolean } from '@theseam/ui-common/core';
+import { ModalFooterTplDirective } from '../directives/modal-footer-tpl.directive';
+import { ModalHeaderIconTplDirective } from '../directives/modal-header-icon-tpl.directive';
+import { ModalHeaderTitleTplDirective } from '../directives/modal-header-title-tpl.directive';
+import { THESEAM_MODAL_CONTAINER } from '../modal.models';
+export const LIB_MODAL = {
+    provide: THESEAM_MODAL_CONTAINER,
+    // tslint:disable-next-line:no-use-before-declare
+    useExisting: forwardRef(() => ModalComponent),
+    multi: true,
+};
+export class ModalComponent {
+    constructor(_viewContainerRef, _overlay, _route) {
+        this._viewContainerRef = _viewContainerRef;
+        this._overlay = _overlay;
+        this._route = _route;
+        this._closeOnKeyPressed = [ESCAPE];
+        this.showCloseBtn = true;
+        this.modalClosed = new EventEmitter();
+        this.overlayDetached = new EventEmitter();
+        /** Emit the `(ngSubmit)` event. NOTE: Only if `form` is defined. */
+        this.formSubmit = new EventEmitter();
+        if (isDevMode()) {
+            // tslint:disable-next-line:max-line-length
+            console.warn('seamModal has some issues with its design. Use the Modal service for now, because seamModal will have breaking changes or be removed soon.');
+        }
+    }
+    set closeOnKeyPressed(value) { this._closeOnKeyPressed = Array.isArray(value) ? value : []; }
+    get closeOnKeyPressed() { return this._closeOnKeyPressed; }
+    get icon() { return this._iconUrl || this._iconObj; }
+    set icon(value) {
+        if (typeof value === 'string') {
+            this._iconUrl = value;
+            this._iconObj = undefined;
+        }
+        else {
+            this._iconUrl = undefined;
+            this._iconObj = value;
+        }
+    }
+    get iconTpl() {
+        return this._iconTpl || (this._queryIconTpl && this._queryIconTpl.template);
+    }
+    set iconTpl(value) {
+        this._iconTpl = value;
+    }
+    get titleTpl() {
+        return this._titleTpl || (this._queryTitleTpl && this._queryTitleTpl.template);
+    }
+    set titleTpl(value) {
+        this._titleTpl = value;
+    }
+    get footerTpl() {
+        return this._footerTpl || (this._queryFooterTpl && this._queryFooterTpl.template);
+    }
+    set footerTpl(value) {
+        this._footerTpl = value;
+    }
+    ngOnInit() { }
+    ngOnDestroy() {
+        this.close();
+    }
+    ngAfterViewInit() {
+        if (this.isRouteModal()) {
+            this.open();
+        }
+    }
+    open(portal) {
+        if (this._overlayRef && this._overlayRef.hasAttached()) {
+            return;
+        }
+        const positionStrategy = this._overlay.position()
+            .global()
+            .centerHorizontally()
+            .centerVertically();
+        this._overlayRef = this._overlay.create({
+            hasBackdrop: true,
+            positionStrategy: positionStrategy
+        });
+        this._overlayRef.detachments().subscribe(_ => this.overlayDetached.emit());
+        this._overlayRef.backdropClick().subscribe(_ => this.close());
+        this._overlayRef.keydownEvents()
+            // tslint:disable-next-line:deprecation
+            .pipe(filter(e => e.keyCode === ESCAPE))
+            .subscribe(_ => this.close());
+        let portalToAttach = portal;
+        if (!portalToAttach) {
+            if (!this._modalTpl) {
+                throw new Error(`_modalTpl not found.`);
+            }
+            portalToAttach = new TemplatePortal(this._modalTpl, this._viewContainerRef);
+        }
+        this._overlayRef.attach(portalToAttach);
+    }
+    close() {
+        if (!this._overlayRef || !this._overlayRef.hasAttached()) {
+            return;
+        }
+        this._overlayRef.detach();
+        this.modalClosed.emit();
+    }
+    _onSubmit() {
+        this.formSubmit.emit();
+    }
+    isRouteModal() {
+        return this._route.outlet === 'modal';
+    }
+}
+ModalComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-modal',
+                template: "<ng-template #modalTpl>\n  <form *ngIf=\"form\" [formGroup]=\"form\" (ngSubmit)=\"_onSubmit()\" class=\"p-4\" style=\"max-width: 800px\">\n    <ng-container *ngTemplateOutlet=\"modalContent\"></ng-container>\n  </form>\n\n  <div *ngIf=\"!form\" class=\"p-4\" style=\"max-width: 800px\">\n    <ng-container *ngTemplateOutlet=\"modalContent\"></ng-container>\n  </div>\n\n  <ng-template #modalContent>\n    <div class=\"modal-content\">\n      <div class=\"modal-header py-2\">\n        <h4 class=\"modal-title\">\n          <span class=\"pr-2 modal-header-icon\">\n            <ng-container *ngIf=\"iconTpl; else noIconTpl\">\n              <ng-template\n                [ngTemplateOutlet]=\"iconTpl\"\n                [ngTemplateOutletContext]=\"{ $implicit: icon, icon: icon }\">\n              </ng-template>\n            </ng-container>\n            <ng-template #noIconTpl>\n              <fa-icon *ngIf=\"_iconObj\"\n                class=\"modal-header-icon--fa\"\n                [icon]=\"_iconObj\"\n                size=\"sm\"></fa-icon>\n              <img *ngIf=\"_iconUrl\"\n                class=\"modal-header-icon--img\"\n                [src]=\"_iconUrl\" [alt]=\"titleText\">\n            </ng-template>\n          </span>\n\n          <span class=\"modal-header-title\">\n            <ng-container *ngIf=\"titleTpl; else noTitleTpl\">\n              <ng-template\n                [ngTemplateOutlet]=\"titleTpl\"\n                [ngTemplateOutletContext]=\"{ $implicit: titleText, title: titleText }\">\n              </ng-template>\n            </ng-container>\n            <ng-template #noTitleTpl>{{ titleText }}</ng-template>\n          </span>\n        </h4>\n        <button *ngIf=\"showCloseBtn\"\n          type=\"button\"\n          class=\"close\"\n          (click)=\"close()\"\n          aria-label=\"Close\">\n          <span aria-hidden=\"true\">&times;</span>\n        </button>\n      </div>\n      <div class=\"modal-body\">\n        <ng-content></ng-content>\n      </div>\n      <div *ngIf=\"_queryFooterTpl\" class=\"modal-footer p-2\">\n        <ng-container *ngComponentOutlet=\"$any(_queryFooterTpl.template)\"></ng-container>\n      </div>\n    </div>\n  </ng-template>\n</ng-template>\n",
+                providers: [LIB_MODAL],
+                styles: [""]
+            },] }
+];
+ModalComponent.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: Overlay },
+    { type: ActivatedRoute }
+];
+ModalComponent.propDecorators = {
+    closeOnKeyPressed: [{ type: Input }],
+    showCloseBtn: [{ type: Input }],
+    titleText: [{ type: Input }],
+    icon: [{ type: Input }],
+    iconTpl: [{ type: Input }],
+    titleTpl: [{ type: Input }],
+    footerTpl: [{ type: Input }],
+    modalClosed: [{ type: Output }],
+    overlayDetached: [{ type: Output }],
+    _queryIconTpl: [{ type: ContentChild, args: [ModalHeaderIconTplDirective, { static: true },] }],
+    _queryTitleTpl: [{ type: ContentChild, args: [ModalHeaderTitleTplDirective, { static: true },] }],
+    _queryFooterTpl: [{ type: ContentChild, args: [ModalFooterTplDirective, { static: true },] }],
+    _modalTpl: [{ type: ViewChild, args: ['modalTpl', { static: true },] }],
+    form: [{ type: Input }],
+    formSubmit: [{ type: Output }]
+};
+__decorate([
+    InputBoolean()
+], ModalComponent.prototype, "showCloseBtn", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/modal/modal/modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput } from '@angular/cdk/coercion'\nimport { ESCAPE } from '@angular/cdk/keycodes'\nimport { Overlay, OverlayRef } from '@angular/cdk/overlay'\nimport { ComponentPortal, TemplatePortal } from '@angular/cdk/portal'\nimport {\n  AfterViewInit, Component, ContentChild, EventEmitter, forwardRef, Input,\n  isDevMode, OnDestroy, OnInit, Output, TemplateRef, ViewChild, ViewContainerRef\n} from '@angular/core'\nimport { FormGroup } from '@angular/forms'\nimport { ActivatedRoute } from '@angular/router'\nimport { filter } from 'rxjs/operators'\n\nimport { IconProp } from '@fortawesome/fontawesome-svg-core'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\nimport { SeamIcon } from '@theseam/ui-common/icon'\n\nimport { ModalFooterTplDirective } from '../directives/modal-footer-tpl.directive'\nimport { ModalHeaderIconTplDirective } from '../directives/modal-header-icon-tpl.directive'\nimport { ModalHeaderTitleTplDirective } from '../directives/modal-header-title-tpl.directive'\nimport { IModalContainer, THESEAM_MODAL_CONTAINER } from '../modal.models'\n\nexport const LIB_MODAL: any = {\n  provide: THESEAM_MODAL_CONTAINER,\n  // tslint:disable-next-line:no-use-before-declare\n  useExisting: forwardRef(() => ModalComponent),\n  multi: true,\n}\n\n@Component({\n  selector: 'seam-modal',\n  templateUrl: './modal.component.html',\n  styleUrls: ['./modal.component.scss'],\n  providers: [ LIB_MODAL ]\n})\nexport class ModalComponent implements OnInit, OnDestroy, AfterViewInit, IModalContainer {\n  static ngAcceptInputType_showCloseBtn: BooleanInput\n\n  @Input()\n  set closeOnKeyPressed(value: number[]) { this._closeOnKeyPressed = Array.isArray(value) ? value : [] }\n  get closeOnKeyPressed(): number[] { return this._closeOnKeyPressed }\n  private _closeOnKeyPressed: number[] = [ ESCAPE ]\n\n  @Input() @InputBoolean() showCloseBtn: boolean = true\n\n  @Input() titleText: string | undefined | null\n\n  @Input()\n  get icon(): SeamIcon | undefined { return this._iconUrl || this._iconObj }\n  set icon(value: SeamIcon | undefined) {\n    if (typeof value === 'string') {\n      this._iconUrl = value\n      this._iconObj = undefined\n    } else {\n      this._iconUrl = undefined\n      this._iconObj = value\n    }\n  }\n\n  public _iconUrl: string | undefined\n  public _iconObj: IconProp | undefined\n\n  @Input()\n  get iconTpl(): TemplateRef<HTMLElement> | undefined {\n    return this._iconTpl || (this._queryIconTpl && this._queryIconTpl.template)\n  }\n  set iconTpl(value: TemplateRef<HTMLElement> | undefined) {\n    this._iconTpl = value\n  }\n  private _iconTpl?: TemplateRef<HTMLElement>\n\n  @Input()\n  get titleTpl(): TemplateRef<HTMLElement> | undefined {\n    return this._titleTpl || (this._queryTitleTpl && this._queryTitleTpl.template)\n  }\n  set titleTpl(value: TemplateRef<HTMLElement> | undefined) {\n    this._titleTpl = value\n  }\n  private _titleTpl?: TemplateRef<HTMLElement>\n\n  @Input()\n  get footerTpl(): TemplateRef<HTMLElement> | undefined {\n    return this._footerTpl || (this._queryFooterTpl && this._queryFooterTpl.template)\n  }\n  set footerTpl(value: TemplateRef<HTMLElement> | undefined) {\n    this._footerTpl = value\n  }\n  private _footerTpl?: TemplateRef<HTMLElement>\n\n  @Output() modalClosed = new EventEmitter<void>()\n\n  _overlayRef?: OverlayRef\n\n  @Output() overlayDetached = new EventEmitter<void>()\n\n  @ContentChild(ModalHeaderIconTplDirective, { static: true })  _queryIconTpl?: ModalHeaderIconTplDirective\n  @ContentChild(ModalHeaderTitleTplDirective, { static: true })  _queryTitleTpl?: ModalHeaderTitleTplDirective\n  @ContentChild(ModalFooterTplDirective, { static: true })  _queryFooterTpl?: ModalFooterTplDirective\n\n  @ViewChild('modalTpl', { static: true }) _modalTpl?: TemplateRef<HTMLElement>\n\n  /** Makes the modal container a form with this formGroup. */\n  @Input() form: FormGroup | undefined | null\n\n  /** Emit the `(ngSubmit)` event. NOTE: Only if `form` is defined. */\n  @Output() formSubmit = new EventEmitter<void>()\n\n  constructor(\n    private _viewContainerRef: ViewContainerRef,\n    private _overlay: Overlay,\n    private _route: ActivatedRoute\n  ) {\n    if (isDevMode()) {\n      // tslint:disable-next-line:max-line-length\n      console.warn('seamModal has some issues with its design. Use the Modal service for now, because seamModal will have breaking changes or be removed soon.')\n    }\n  }\n\n  ngOnInit() { }\n\n  ngOnDestroy() {\n    this.close()\n  }\n\n  ngAfterViewInit() {\n    if (this.isRouteModal()) {\n      this.open()\n    }\n  }\n\n  public open(portal?: TemplatePortal | ComponentPortal<{}>) {\n    if (this._overlayRef && this._overlayRef.hasAttached()) { return }\n\n    const positionStrategy = this._overlay.position()\n      .global()\n      .centerHorizontally()\n      .centerVertically()\n\n    this._overlayRef = this._overlay.create({\n      hasBackdrop: true,\n      positionStrategy: positionStrategy\n    })\n\n    this._overlayRef.detachments().subscribe(_ => this.overlayDetached.emit())\n\n    this._overlayRef.backdropClick().subscribe(_ => this.close())\n\n    this._overlayRef.keydownEvents()\n      // tslint:disable-next-line:deprecation\n      .pipe(filter(e => e.keyCode === ESCAPE))\n      .subscribe(_ => this.close())\n\n    let portalToAttach = portal\n    if (!portalToAttach) {\n      if (!this._modalTpl) {\n        throw new Error(`_modalTpl not found.`)\n      }\n      portalToAttach = new TemplatePortal(this._modalTpl, this._viewContainerRef)\n    }\n\n    this._overlayRef.attach(portalToAttach)\n  }\n\n  public close() {\n    if (!this._overlayRef || !this._overlayRef.hasAttached()) { return }\n\n    this._overlayRef.detach()\n\n    this.modalClosed.emit()\n  }\n\n  _onSubmit() {\n    this.formSubmit.emit()\n  }\n\n  public isRouteModal() {\n    return this._route.outlet === 'modal'\n  }\n\n}\n"]}