@coolon/angular-ui-powerups 0.0.1

package/fesm2015/coolon-angular-ui-powerups.js

@@ -0,0 +1,2687 @@
+import { DOCUMENT, CommonModule } from '@angular/common';
+import { EventEmitter, Input, Output, HostListener, Component, Directive, ElementRef, Inject, NgZone, NgModule, InjectionToken, ViewChild, Injector, ComponentFactoryResolver, ViewContainerRef, Injectable, ɵɵdefineInjectable, ɵɵinject, INJECTOR } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatInputModule, MatFormFieldModule, MatSelectModule, MatDialog, MatButtonModule, MatDialogModule, MatTabsModule, MatProgressSpinnerModule } from '@angular/material';
+import { BrowserModule } from '@angular/platform-browser';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { __decorate, __metadata, __awaiter } from 'tslib';
+import { GarbageCollector, MutableListModel, Constant, UseDelegate, MutableValueModel, assert, Dsl, Logger, ListModel, StoreInListModel, ValueHolder, EventListenerList, DelegatingValueModel, lang, Trace, TransactionObserver, Binding, UseDelegatingValueModel, ValueModel, StoreInValueModel } from '@coolon/pectin';
+import ResizeObserver from 'resize-observer-polyfill';
+import { PortalModule } from '@angular/cdk/portal';
+import { Deferred } from '@coolon/pectin/lib/promise/deferred.class';
+import { MatDialog as MatDialog$1 } from '@angular/material/dialog';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator';
+import { isNil } from 'lodash';
+import 'reflect-metadata';
+import { Router, ActivatedRoute, RouterModule, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { Klass, Opts } from '@coolon/typescript-utilities';
+import { Memoize as Memoize$1 } from '@typescript-plus/fast-memoize-decorator/dist/src';
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class DisposableComponent extends GarbageCollector {
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.dispose();
+    }
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+const EMPTY_ERRORS = new MutableListModel().readonly;
+/**
+ * @abstract
+ * @template T
+ */
+class AbstractInputComponent extends DisposableComponent {
+    constructor() {
+        super();
+        this.focus = new EventEmitter();
+        this.blur = new EventEmitter();
+        this.enterKey = new EventEmitter();
+        this.escapeKey = new EventEmitter();
+        /** @type {?} */
+        const self = this;
+        this.errorStateMatcher = {
+            /**
+             * @param {?} control
+             * @param {?} form
+             * @return {?}
+             */
+            isErrorState(control, form) {
+                return self.hasErrors();
+            }
+        };
+    }
+    /**
+     * @return {?}
+     */
+    notifyClick() {
+        this.safelyInvoke(this.clickCommand);
+    }
+    /**
+     * @return {?}
+     */
+    notifyFocusIn() {
+        this.safelyInvoke(this.focusCommand);
+        this.focus.emit();
+    }
+    /**
+     * @return {?}
+     */
+    notifyFocusOut() {
+        this.safelyInvoke(this.blurCommand);
+        this.blur.emit();
+    }
+    /**
+     * @return {?}
+     */
+    notifyEnterKey() {
+        this.safelyInvoke(this.enterCommand);
+        this.enterKey.emit();
+    }
+    /**
+     * @return {?}
+     */
+    notifyEscapeKey() {
+        this.safelyInvoke(this.escapeCommand);
+        this.escapeKey.emit();
+    }
+    /**
+     * @protected
+     * @param {?} command
+     * @return {?}
+     */
+    safelyInvoke(command) {
+        if (command && command.isEnabled()) {
+            command.execute();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        // this._focused = this.valueModel['focused'] || new ValueHolder();
+    }
+    /**
+     * @return {?}
+     */
+    isEnabled() {
+        return this.enabled.value;
+    }
+    /**
+     * @return {?}
+     */
+    get enabled() {
+        // @ts-ignore
+        return ((/** @type {?} */ (this.valueModel))).enabled || Constant.TRUE;
+    }
+    /**
+     * @return {?}
+     */
+    hasErrors() {
+        return !this.errorList.query().isEmpty();
+    }
+    /**
+     * @return {?}
+     */
+    get errorList() {
+        return ((/** @type {?} */ (this.valueModel))).errorList || EMPTY_ERRORS;
+    }
+    /**
+     * @return {?}
+     */
+    get firstError() {
+        return this.hasErrors() ? this.errorList.value[0] : null;
+    }
+}
+AbstractInputComponent.propDecorators = {
+    valueModel: [{ type: Input }],
+    label: [{ type: Input }],
+    floatLabel: [{ type: Input }],
+    hint: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    focusCommand: [{ type: Input, args: ['command.focus',] }],
+    blurCommand: [{ type: Input, args: ['command.blur',] }],
+    enterCommand: [{ type: Input, args: ['command.enter',] }],
+    escapeCommand: [{ type: Input, args: ['command.escape',] }],
+    clickCommand: [{ type: Input, args: ['command.click',] }],
+    focus: [{ type: Output }],
+    blur: [{ type: Output }],
+    enterKey: [{ type: Output }],
+    escapeKey: [{ type: Output }],
+    notifyClick: [{ type: HostListener, args: ['click',] }],
+    notifyFocusIn: [{ type: HostListener, args: ['focusin',] }],
+    notifyFocusOut: [{ type: HostListener, args: ['focusout',] }]
+};
+__decorate([
+    UseDelegate(),
+    __metadata("design:type", MutableValueModel)
+], AbstractInputComponent.prototype, "valueModel", void 0);
+if (false) {
+    /** @type {?} */
+    AbstractInputComponent.prototype.valueModel;
+    /** @type {?} */
+    AbstractInputComponent.prototype.label;
+    /** @type {?} */
+    AbstractInputComponent.prototype.floatLabel;
+    /** @type {?} */
+    AbstractInputComponent.prototype.hint;
+    /** @type {?} */
+    AbstractInputComponent.prototype.placeholder;
+    /** @type {?} */
+    AbstractInputComponent.prototype.focusCommand;
+    /** @type {?} */
+    AbstractInputComponent.prototype.blurCommand;
+    /** @type {?} */
+    AbstractInputComponent.prototype.enterCommand;
+    /** @type {?} */
+    AbstractInputComponent.prototype.escapeCommand;
+    /** @type {?} */
+    AbstractInputComponent.prototype.clickCommand;
+    /** @type {?} */
+    AbstractInputComponent.prototype.focus;
+    /** @type {?} */
+    AbstractInputComponent.prototype.blur;
+    /** @type {?} */
+    AbstractInputComponent.prototype.enterKey;
+    /** @type {?} */
+    AbstractInputComponent.prototype.escapeKey;
+    /** @type {?} */
+    AbstractInputComponent.prototype.errorStateMatcher;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class NumberInputComponent extends AbstractInputComponent {
+    constructor() {
+        super();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+}
+NumberInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-number-input',
+                template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <input type=\"number\"\n         matInput\n         placeholder=\"{{placeholder}}\"\n         [(ngModel)]=\"valueModel.value\"\n         [disabled]=\"!enabled.value\"\n         (keydown.enter)=\"notifyEnterKey()\"\n         (keydown.escape)=\"notifyEscapeKey()\"\n         [pectinFocusBinding]=\"valueModel\"\n         [errorStateMatcher]=\"errorStateMatcher\"\n  >\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n",
+                styles: [":host{display:block}input,mat-form-field{width:100%}input mat-hint.faux-error,mat-form-field mat-hint.faux-error{color:#f44336}"]
+            }] }
+];
+/** @nocollapse */
+NumberInputComponent.ctorParameters = () => [];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class CommandDirective extends GarbageCollector {
+    /**
+     * @param {?} elementRef
+     */
+    constructor(elementRef) {
+        super();
+        this.elementRef = elementRef;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        assert.notNil(this.pectinCommand);
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        // for some reason mat-buttons kills the disabled host binding.  It works on a regular button but for now
+        // we need to do this.
+        const { chain } = Dsl.disposeWith(this);
+        chain.value(this.pectinCommand.enabled).subscribe((/**
+         * @param {?} enabled
+         * @return {?}
+         */
+        enabled => {
+            if (enabled) {
+                this.elementRef.nativeElement.removeAttribute('disabled');
+                if (this.elementRef.nativeElement.tagName === 'A') {
+                    this.elementRef.nativeElement.setAttribute('href', 'javascript:void');
+                }
+            }
+            else {
+                this.elementRef.nativeElement.setAttribute('disabled', 'disabled');
+                if (this.elementRef.nativeElement.tagName === 'A') {
+                    this.elementRef.nativeElement.removeAttribute('href');
+                }
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.dispose();
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    notifyClick($event) {
+        $event.preventDefault();
+        $event.stopPropagation();
+        if (this.pectinCommand.isEnabled()) {
+            this.pectinCommand.execute({ event: $event });
+        }
+        else {
+            console.warn('disabled command clicked, ignoring.');
+        }
+    }
+}
+CommandDirective.decorators = [
+    { type: Directive, args: [{
+                // tslint:disable-next-line:directive-selector
+                selector: '[pectinCommand]'
+            },] }
+];
+/** @nocollapse */
+CommandDirective.ctorParameters = () => [
+    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] }
+];
+CommandDirective.propDecorators = {
+    pectinCommand: [{ type: Input }],
+    notifyClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+if (false) {
+    /** @type {?} */
+    CommandDirective.prototype.pectinCommand;
+    /**
+     * @type {?}
+     * @private
+     */
+    CommandDirective.prototype.elementRef;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FocusBindingDirective extends DisposableComponent {
+    /**
+     * @param {?} el
+     * @param {?} ngZone
+     * @param {?} document
+     */
+    constructor(el, ngZone, document) {
+        super();
+        this.el = el;
+        this.ngZone = ngZone;
+        // @see https://stackoverflow.com/questions/49513359/could-not-resolve-type-document-in-angular5/53715642#53715642
+        this.document = (/** @type {?} */ (document));
+    }
+    /**
+     * @return {?}
+     */
+    onFocusIn() {
+        this.pectinFocusBinding.focusCallbacks.notifyFocusIn();
+    }
+    /**
+     * @return {?}
+     */
+    onFocusOut() {
+        this.pectinFocusBinding.focusCallbacks.notifyFocusOut();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        // TODO: Make this also track the current enabled/disabled state.
+        const { chain } = Dsl.disposeWith(this);
+        chain.value(this.pectinFocusBinding.focused).subscribe((/**
+         * @param {?} focused
+         * @return {?}
+         */
+        (focused) => {
+            if (focused && !this.alreadyHasFocus()) {
+                this.tryAndFocus();
+            }
+        }));
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @return {?}
+     */
+    alreadyHasFocus() {
+        return this.isFocused(this.focusTarget);
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    isFocused(element) {
+        return this.document.activeElement === element;
+    }
+    /**
+     * @param {?=} retries
+     * @return {?}
+     */
+    tryAndFocus(retries = 5) {
+        if (this.modelShouldStillHaveFocus() && this.canFocus()) {
+            if (!this.alreadyHasFocus()) {
+                this.focusTarget.focus();
+            }
+            // if we didn't get the focus we try again later.
+            if (!this.alreadyHasFocus()) {
+                Logger.get(this).log(`focus failed, trying ${retries} more times`);
+                if (retries > 0) {
+                    // try again on the next paint
+                    // TODO: is there an angular way of doing this without calling a window function.
+                    requestAnimationFrame((/**
+                     * @return {?}
+                     */
+                    () => {
+                        this.tryAndFocus(retries - 1);
+                    }));
+                }
+                else {
+                    Logger.get(this).warn(`Tried to focus but gave up as the component wasn't enabled or visible.`);
+                }
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    get focusTarget() {
+        return this.focusBindingTarget || this.el.nativeElement;
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @return {?}
+     */
+    modelShouldStillHaveFocus() {
+        return this.pectinFocusBinding.focused.value;
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @return {?}
+     */
+    canFocus() {
+        /** @type {?} */
+        const dimension = this.focusTarget.getBoundingClientRect();
+        /** @type {?} */
+        const hasSize = dimension.height >= 0 && dimension.height >= 0;
+        // tslint:disable-next-line:no-string-literal
+        return hasSize && !this.focusTarget['disabled'];
+    }
+}
+FocusBindingDirective.decorators = [
+    { type: Directive, args: [{
+                // tslint:disable-next-line:directive-selector
+                selector: '[pectinFocusBinding]'
+            },] }
+];
+/** @nocollapse */
+FocusBindingDirective.ctorParameters = () => [
+    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
+    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+FocusBindingDirective.propDecorators = {
+    pectinFocusBinding: [{ type: Input }],
+    focusBindingTarget: [{ type: Input }],
+    onFocusIn: [{ type: HostListener, args: ['focusin',] }],
+    onFocusOut: [{ type: HostListener, args: ['focusout',] }]
+};
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    FocusBindingDirective.prototype.document;
+    /** @type {?} */
+    FocusBindingDirective.prototype.pectinFocusBinding;
+    /** @type {?} */
+    FocusBindingDirective.prototype.focusBindingTarget;
+    /**
+     * @type {?}
+     * @private
+     */
+    FocusBindingDirective.prototype.el;
+    /**
+     * @type {?}
+     * @private
+     */
+    FocusBindingDirective.prototype.ngZone;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class StringInputComponent extends AbstractInputComponent {
+    constructor() {
+        super();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+}
+StringInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-string-input',
+                template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <input matInput\n         placeholder=\"{{placeholder}}\"\n         [(ngModel)]=\"valueModel.value\"\n         [disabled]=\"!enabled.value\"\n         (keydown.enter)=\"notifyEnterKey()\"\n         (keydown.escape)=\"notifyEscapeKey()\"\n         [pectinFocusBinding]=\"valueModel\"\n         [errorStateMatcher]=\"errorStateMatcher\"\n  >\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n\n",
+                styles: [":host{display:block}input,mat-form-field{width:100%}input mat-hint.faux-error,mat-form-field mat-hint.faux-error{color:#f44336}"]
+            }] }
+];
+/** @nocollapse */
+StringInputComponent.ctorParameters = () => [];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class PasswordInputComponent extends AbstractInputComponent {
+    constructor() {
+        super();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+}
+PasswordInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-password-input',
+                template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <input type=\"password\"\n         matInput\n         placeholder=\"{{placeholder}}\"\n         [(ngModel)]=\"valueModel.value\"\n         [disabled]=\"!enabled.value\"\n         (keydown.enter)=\"notifyEnterKey()\"\n         (keydown.escape)=\"notifyEscapeKey()\"\n         [pectinFocusBinding]=\"valueModel\"\n         [errorStateMatcher]=\"errorStateMatcher\"\n  >\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n\n",
+                styles: [":host{display:block}input,mat-form-field{width:100%}input mat-hint.faux-error,mat-form-field mat-hint.faux-error{color:#f44336}"]
+            }] }
+];
+/** @nocollapse */
+PasswordInputComponent.ctorParameters = () => [];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @template T
+ */
+class SelectInputComponent extends AbstractInputComponent {
+    constructor() {
+        super();
+        this.optionLabelFormat = (/**
+         * @param {?} option
+         * @return {?}
+         */
+        (option) => (option && this.optionLabel) ? option[this.optionLabel] : option);
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+}
+SelectInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-select-input',
+                template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <mat-select placeholder=\"{{placeholder}}\"\n              [(ngModel)]=\"valueModel.value\"\n              [disabled]=\"!enabled.value\"\n              (keydown.enter)=\"notifyEnterKey()\"\n              (keydown.escape)=\"notifyEscapeKey()\"\n              [pectinFocusBinding]=\"valueModel\"\n              [errorStateMatcher]=\"errorStateMatcher\"\n  >\n    <mat-option *ngFor=\"let option of optionsModel.value\" [value]=\"option\">{{optionLabelFormat(option)}}\n    </mat-option>\n  </mat-select>\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n",
+                styles: [":host{display:inline-block}mat-form-field{width:100%}"]
+            }] }
+];
+/** @nocollapse */
+SelectInputComponent.ctorParameters = () => [];
+SelectInputComponent.propDecorators = {
+    optionsModel: [{ type: Input }],
+    options: [{ type: Input }],
+    optionLabel: [{ type: Input }],
+    optionLabelFormat: [{ type: Input }]
+};
+__decorate([
+    UseDelegate(),
+    __metadata("design:type", ListModel)
+], SelectInputComponent.prototype, "optionsModel", void 0);
+__decorate([
+    StoreInListModel('optionsModel'),
+    __metadata("design:type", Array)
+], SelectInputComponent.prototype, "options", void 0);
+if (false) {
+    /** @type {?} */
+    SelectInputComponent.prototype.optionsModel;
+    /** @type {?} */
+    SelectInputComponent.prototype.options;
+    /** @type {?} */
+    SelectInputComponent.prototype.optionLabel;
+    /** @type {?} */
+    SelectInputComponent.prototype.optionLabelFormat;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class AngularUiPowerupsModule {
+}
+AngularUiPowerupsModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    CommandDirective,
+                    FocusBindingDirective,
+                    NumberInputComponent,
+                    StringInputComponent,
+                    PasswordInputComponent,
+                    SelectInputComponent,
+                ],
+                imports: [
+                    CommonModule,
+                    BrowserModule,
+                    BrowserAnimationsModule,
+                    FormsModule,
+                    MatInputModule,
+                    MatFormFieldModule,
+                    MatSelectModule
+                ],
+                exports: [
+                    CommandDirective,
+                    FocusBindingDirective,
+                    NumberInputComponent,
+                    StringInputComponent,
+                    PasswordInputComponent,
+                    SelectInputComponent,
+                ]
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class Dimension {
+    /**
+     * @param {?} width
+     * @param {?} height
+     */
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+    }
+}
+if (false) {
+    /** @type {?} */
+    Dimension.prototype.width;
+    /** @type {?} */
+    Dimension.prototype.height;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class Point {
+    /**
+     * @param {?} x
+     * @param {?} y
+     */
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    static from(data) {
+        return new Point(data.x, data.y);
+    }
+    /**
+     * @param {?} x
+     * @param {?} y
+     * @return {?}
+     */
+    translate(x, y) {
+        return new Point(this.x + x, this.y + y);
+    }
+}
+if (false) {
+    /** @type {?} */
+    Point.prototype.x;
+    /** @type {?} */
+    Point.prototype.y;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class Bounds extends Dimension {
+    /**
+     * @param {?} top
+     * @param {?} left
+     * @param {?} width
+     * @param {?} height
+     */
+    constructor(top, left, width, height) {
+        super(width, height);
+        this.top = top;
+        this.left = left;
+        this.width = width;
+        this.height = height;
+    }
+    /**
+     * @param {?} point
+     * @return {?}
+     */
+    relativePositionOf(point) {
+        if (point instanceof MouseEvent) {
+            return new Point(point.clientX - this.left, point.clientY - this.top);
+        }
+        else {
+            return new Point(point.x - this.left, point.y - this.top);
+        }
+    }
+}
+if (false) {
+    /** @type {?} */
+    Bounds.prototype.top;
+    /** @type {?} */
+    Bounds.prototype.left;
+    /** @type {?} */
+    Bounds.prototype.width;
+    /** @type {?} */
+    Bounds.prototype.height;
+}
+(function (Bounds) {
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    function ofElement(element) {
+        /** @type {?} */
+        const rect = element.getBoundingClientRect();
+        return new Bounds(rect.top, rect.left, rect.width, rect.height);
+    }
+    Bounds.ofElement = ofElement;
+})(Bounds || (Bounds = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class ResizeAwareComponent extends DisposableComponent {
+    /**
+     * @param {?} elementRef
+     * @param {?} ngZone
+     */
+    constructor(elementRef, ngZone) {
+        super();
+        this.elementRef = elementRef;
+        this.ngZone = ngZone;
+        this._boundsModel = new ValueHolder(new Bounds(0, 0, 0, 0));
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        this.updateBounds();
+        /** @type {?} */
+        const element = this.elementRef.nativeElement;
+        /** @type {?} */
+        const ro = new ResizeObserver((/**
+         * @param {?} entries
+         * @param {?} observer
+         * @return {?}
+         */
+        (entries, observer) => {
+            this.ngZone.run((/**
+             * @return {?}
+             */
+            () => this.updateBounds()));
+        }));
+        ro.observe(element);
+        this.onDispose((/**
+         * @return {?}
+         */
+        () => ro.disconnect()));
+    }
+    /**
+     * @return {?}
+     */
+    get boundsModel() {
+        return this._boundsModel.readonly;
+    }
+    /**
+     * @return {?}
+     */
+    get nativeElement() {
+        return this.elementRef.nativeElement;
+    }
+    // TODO: Make this handle body scroll
+    /**
+     * @param {?} point
+     * @return {?}
+     */
+    relativePositionOf(point) {
+        return this.bounds.relativePositionOf(point);
+    }
+    /**
+     * @return {?}
+     */
+    get bounds() {
+        return this._boundsModel.value;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    updateBounds() {
+        this._boundsModel.value = Bounds.ofElement(this.nativeElement);
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    ResizeAwareComponent.prototype._boundsModel;
+    /**
+     * @type {?}
+     * @protected
+     */
+    ResizeAwareComponent.prototype.elementRef;
+    /**
+     * @type {?}
+     * @protected
+     */
+    ResizeAwareComponent.prototype.ngZone;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @template D, R, E
+ */
+class AbstractActivity extends DisposableComponent {
+    constructor() {
+        super(...arguments);
+        this._doneListeners = new EventListenerList();
+        this._cancelListeners = new EventListenerList();
+        this._finishListeners = new EventListenerList();
+        this._busyModel = new DelegatingValueModel().withDefault(false);
+    }
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    onDone(callback) {
+        this._doneListeners.add(callback);
+    }
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    onCancel(callback) {
+        this._cancelListeners.add(callback);
+    }
+    /**
+     * @param {?=} result
+     * @return {?}
+     */
+    done(result) {
+        return this._doneListeners
+            .fireAndWait((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l(result)))
+            .finally((/**
+         * @return {?}
+         */
+        () => this.finalizeAndDispose()));
+    }
+    /**
+     * @param {?=} error
+     * @return {?}
+     */
+    cancel(error) {
+        return this._cancelListeners
+            .fireAndWait((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l(error)))
+            .finally((/**
+         * @return {?}
+         */
+        () => this.finalizeAndDispose()));
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    finalizeAndDispose() {
+        // this._activeModel.value = false;
+        this._finishListeners.fire((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l()));
+        // this._interactionContext = null;
+        // this._initialized = false;
+        [
+            this._finishListeners,
+            this._doneListeners,
+            this._cancelListeners
+        ].forEach((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l.dispose()));
+    }
+    /**
+     * @return {?}
+     */
+    get busy() {
+        return this._busyModel.readonly;
+    }
+    /**
+     * @param {?} busyModel
+     * @return {?}
+     */
+    busyWhile(busyModel) {
+        this._busyModel.setDelegate(busyModel);
+    }
+    /**
+     * @return {?}
+     */
+    isBusy() {
+        return this._busyModel.value;
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._doneListeners;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._cancelListeners;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._finishListeners;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._busyModel;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+const ACTIVITY_DATA = new InjectionToken('InteractionActivityData');
+/**
+ * @record
+ * @template D, R, E
+ */
+function Activity() { }
+if (false) {
+    /** @type {?} */
+    Activity.prototype.busy;
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    Activity.prototype.onDone = function (callback) { };
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    Activity.prototype.onCancel = function (callback) { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ */
+function Alert() { }
+if (false) {
+    /**
+     * @return {?}
+     */
+    Alert.prototype.title = function () { };
+    /**
+     * @return {?}
+     */
+    Alert.prototype.content = function () { };
+    /**
+     * @return {?}
+     */
+    Alert.prototype.ok = function () { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ */
+function Confirm() { }
+if (false) {
+    /** @type {?|undefined} */
+    Confirm.prototype.destructive;
+    /**
+     * @return {?}
+     */
+    Confirm.prototype.cancel = function () { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+const INTERACTION_CONTEXT = new InjectionToken('InteractionContext');
+/**
+ * @abstract
+ */
+class InteractionContext {
+}
+if (false) {
+    /**
+     * @abstract
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?=} data
+     * @return {?}
+     */
+    InteractionContext.prototype.startActivity = function (activityType, data) { };
+    /**
+     * @abstract
+     * @param {?} confirm
+     * @return {?}
+     */
+    InteractionContext.prototype.confirm = function (confirm) { };
+    /**
+     * @abstract
+     * @param {?} alert
+     * @return {?}
+     */
+    InteractionContext.prototype.alert = function (alert) { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class AlertDialogComponent extends AbstractActivity {
+    /**
+     * @param {?} alert
+     */
+    constructor(alert) {
+        super();
+        this.alert = alert;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+}
+AlertDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-alert-dialog',
+                template: "<h3 matDialogTitle *ngIf=\"alert.title\">{{alert.title()}}</h3>\n<div matDialogContent>\n  <p *ngFor=\"let line of alert.content()\">{{line}}</p>\n</div>\n<p matDialogActions>\n  <button mat-raised-button color=\"primary\" (click)=\"done()\">{{alert.ok()}}</button>\n</p>\n",
+                styles: [":host{display:block;padding:var(--default-padding)}.mat-dialog-actions{justify-content:flex-end}"]
+            }] }
+];
+/** @nocollapse */
+AlertDialogComponent.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [ACTIVITY_DATA,] }] }
+];
+if (false) {
+    /** @type {?} */
+    AlertDialogComponent.prototype.alert;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class ConfirmationDialogComponent extends AbstractActivity {
+    /**
+     * @param {?} confirm
+     */
+    constructor(confirm) {
+        super();
+        this.confirm = confirm;
+        assert.notNil(confirm);
+        console.log(confirm);
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @return {?}
+     */
+    isDestructive() {
+        return this.confirm.destructive && this.confirm.destructive();
+    }
+}
+ConfirmationDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-confirmation-dialog',
+                template: "<h3 matDialogTitle *ngIf=\"confirm.title\">{{confirm.title()}}</h3>\n<div matDialogContent>\n  <p *ngFor=\"let line of confirm.content()\">{{line}}</p>\n</div>\n<p matDialogActions>\n  <button mat-button (click)=\"cancel()\">{{confirm.cancel()}}</button>\n  <button mat-raised-button [color]=\"isDestructive() ? 'warn' : 'primary'\" (click)=\"done(true)\">{{confirm.ok()}}</button>\n</p>\n\n",
+                styles: [":host{display:block;padding:var(--default-padding)}.mat-dialog-actions{justify-content:flex-end}"]
+            }] }
+];
+/** @nocollapse */
+ConfirmationDialogComponent.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [ACTIVITY_DATA,] }] }
+];
+if (false) {
+    /** @type {?} */
+    ConfirmationDialogComponent.prototype.confirm;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class ActivityContainerComponent extends DisposableComponent {
+    constructor() {
+        super();
+        this.activityTabs = new MutableListModel();
+        this.obsoleteTabs = [];
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        const { observe } = Dsl.disposeWith(this);
+        observe.valuesFrom(this.tabs.animationDone).subscribe((/**
+         * @return {?}
+         */
+        () => this.cleanUpTabs()));
+    }
+    /**
+     * @template D, R, E
+     * @param {?} options
+     * @return {?}
+     */
+    initialise(options) {
+        this.initialActivity = Object.assign({}, options, { interactionContext: this });
+    }
+    /**
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?=} data
+     * @return {?}
+     */
+    startActivity(activityType, data) {
+        /** @type {?} */
+        const deferred = Deferred.defer();
+        /** @type {?} */
+        const context = {
+            interactionContext: this,
+            activityClass: activityType,
+            activityData: data,
+            onDone: deferred.resolve,
+            onCancel: deferred.reject
+        };
+        this.activityTabs.push(context);
+        this.tabs.selectedIndex = this.activityTabs.length;
+        return deferred.promise.finally((/**
+         * @return {?}
+         */
+        () => {
+            this.obsoleteTabs.push(context);
+            this.tabs.selectedIndex = this.activityTabs.length - 1;
+        }));
+    }
+    /**
+     * @param {?} alert
+     * @return {?}
+     */
+    alert(alert) {
+        return this.startActivity(AlertDialogComponent, alert);
+    }
+    /**
+     * @param {?} confirm
+     * @return {?}
+     */
+    confirm(confirm) {
+        return this.startActivity(ConfirmationDialogComponent, confirm);
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    cleanUpTabs() {
+        this.activityTabs.value = this.activityTabs.value.filter((/**
+         * @param {?} tab
+         * @return {?}
+         */
+        tab => {
+            return !this.obsoleteTabs.includes(tab);
+        }));
+    }
+}
+ActivityContainerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-activity-container',
+                template: "<mat-tab-group #tabs no-tab-header [dynamicHeight]=\"true\">\n  <mat-tab>\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\" [activityContext]=\"initialActivity\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n  <mat-tab *ngFor=\"let tab of activityTabs.value\">\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\" [activityContext]=\"tab\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n</mat-tab-group>\n",
+                styles: [":host{display:block}"]
+            }] }
+];
+/** @nocollapse */
+ActivityContainerComponent.ctorParameters = () => [];
+ActivityContainerComponent.propDecorators = {
+    parentInteractionContext: [{ type: Input }],
+    initialActivity: [{ type: Input }],
+    tabs: [{ type: ViewChild, args: ['tabs', { static: true },] }]
+};
+if (false) {
+    /** @type {?} */
+    ActivityContainerComponent.prototype.parentInteractionContext;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.initialActivity;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.tabs;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.activityTabs;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityContainerComponent.prototype.obsoleteTabs;
+}
+(function (ActivityContainerComponent) {
+    /**
+     * @record
+     * @template D, R, E
+     */
+    function ActivityContext() { }
+    ActivityContainerComponent.ActivityContext = ActivityContext;
+    if (false) {
+        /** @type {?} */
+        ActivityContext.prototype.activityClass;
+        /** @type {?} */
+        ActivityContext.prototype.activityData;
+        /** @type {?} */
+        ActivityContext.prototype.onDone;
+        /** @type {?} */
+        ActivityContext.prototype.onCancel;
+    }
+})(ActivityContainerComponent || (ActivityContainerComponent = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @template D, R, E
+ */
+class ActivityOutletComponent {
+    /**
+     * @param {?} componentFactoryResolver
+     * @param {?} viewContainerRef
+     * @param {?} injector
+     */
+    constructor(componentFactoryResolver, viewContainerRef, injector) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.viewContainerRef = viewContainerRef;
+        this.injector = injector;
+    }
+    /**
+     * @param {?} activityContext
+     * @return {?}
+     */
+    set activityContext(activityContext) {
+        this.loadActivity(activityContext);
+    }
+    ;
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @param {?} activityContext
+     * @return {?}
+     */
+    loadActivity(activityContext) {
+        /** @type {?} */
+        const injector = Injector.create({
+            providers: [
+                {
+                    provide: InteractionContext,
+                    useValue: this
+                },
+                { provide: ACTIVITY_DATA, useValue: activityContext.activityData }
+            ],
+            parent: this.injector
+        });
+        /** @type {?} */
+        const componentFactory = this.componentFactoryResolver.resolveComponentFactory(activityContext.activityClass);
+        this.viewContainerRef.clear();
+        this.activityComponent = this.viewContainerRef.createComponent(componentFactory, 0, injector);
+        this.activityComponent.instance.onDone(activityContext.onDone);
+        this.activityComponent.instance.onCancel(activityContext.onCancel);
+    }
+    /**
+     * @param {?} alert
+     * @return {?}
+     */
+    alert(alert) {
+        return this.interactionContext.alert(alert);
+    }
+    /**
+     * @param {?} confirm
+     * @return {?}
+     */
+    confirm(confirm) {
+        return this.interactionContext.confirm(confirm);
+    }
+    /**
+     * @template D1, R1, E1
+     * @param {?} activityType
+     * @param {?=} data
+     * @return {?}
+     */
+    startActivity(activityType, data) {
+        return this.interactionContext.startActivity(activityType, data);
+    }
+}
+ActivityOutletComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-activity-outlet',
+                template: '',
+                styles: [":host{display:block}"]
+            }] }
+];
+/** @nocollapse */
+ActivityOutletComponent.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: ViewContainerRef },
+    { type: Injector }
+];
+ActivityOutletComponent.propDecorators = {
+    interactionContext: [{ type: Input }],
+    activityContext: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    ActivityOutletComponent.prototype.interactionContext;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype.activityComponent;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype.componentFactoryResolver;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype.viewContainerRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype.injector;
+    /* Skipping unhandled member: ;*/
+}
+(function (ActivityOutletComponent) {
+    /**
+     * @template D, R, E
+     */
+    class OutletInteractionContext {
+        /**
+         * @param {?} context
+         */
+        constructor(context) {
+            this.context = context;
+        }
+        /**
+         * @param {?} alert
+         * @return {?}
+         */
+        alert(alert) {
+            return lang.notImplemented();
+        }
+        /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        confirm(confirm) {
+            return lang.notImplemented();
+        }
+        /**
+         * @template D1, R1, E1
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        startActivity(activityType, data) {
+            return lang.notImplemented();
+        }
+    }
+    ActivityOutletComponent.OutletInteractionContext = OutletInteractionContext;
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        OutletInteractionContext.prototype.context;
+    }
+})(ActivityOutletComponent || (ActivityOutletComponent = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class DialogInteractionService extends InteractionContext {
+    /**
+     * @param {?} dialogService
+     */
+    constructor(dialogService) {
+        super();
+        this.dialogService = dialogService;
+    }
+    /**
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?=} data
+     * @return {?}
+     */
+    startActivity(activityType, data) {
+        return this._startActivity(activityType, data);
+    }
+    /**
+     * @private
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    _startActivity(activityType, data, disableClose = true) {
+        /** @type {?} */
+        const config = {
+            data,
+            disableClose,
+            panelClass: 'dialog-interaction-service',
+            autoFocus: false
+        };
+        /** @type {?} */
+        const matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            /** @type {?} */
+            const activityContainer = matDialogRef.componentInstance;
+            activityContainer.parentInteractionContext = this;
+            activityContainer.initialise({
+                activityClass: activityType,
+                activityData: data,
+                /**
+                 * @param {?} result
+                 * @return {?}
+                 */
+                onDone(result) {
+                    resolve(result);
+                    matDialogRef.close(result);
+                },
+                /**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                onCancel(error) {
+                    reject(error);
+                    matDialogRef.close(error);
+                }
+            });
+            matDialogRef.updateSize();
+        }));
+    }
+    /**
+     * @param {?} alert
+     * @return {?}
+     */
+    alert(alert) {
+        return this._startActivity(AlertDialogComponent, alert, false);
+    }
+    /**
+     * @param {?} confirm
+     * @return {?}
+     */
+    confirm(confirm) {
+        return this._startActivity(ConfirmationDialogComponent, confirm, true);
+    }
+}
+DialogInteractionService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+DialogInteractionService.ctorParameters = () => [
+    { type: MatDialog }
+];
+/** @nocollapse */ DialogInteractionService.ngInjectableDef = ɵɵdefineInjectable({ factory: function DialogInteractionService_Factory() { return new DialogInteractionService(ɵɵinject(MatDialog$1)); }, token: DialogInteractionService, providedIn: "root" });
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionService.prototype.dialogService;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class InteractionModule {
+}
+InteractionModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    MatButtonModule,
+                    MatDialogModule,
+                    MatTabsModule,
+                    PortalModule
+                ],
+                declarations: [
+                    ActivityContainerComponent,
+                    ConfirmationDialogComponent,
+                    AlertDialogComponent,
+                    ActivityOutletComponent
+                ],
+                entryComponents: [
+                    ActivityContainerComponent,
+                    ConfirmationDialogComponent,
+                    AlertDialogComponent
+                ],
+                providers: [
+                    DialogInteractionService
+                ]
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ * @template R, E
+ */
+function Result() { }
+(function (Result) {
+    /**
+     * @record
+     * @template R, E
+     */
+    function Callback() { }
+    Result.Callback = Callback;
+    if (false) {
+        /** @type {?} */
+        Callback.prototype.then;
+        /** @type {?} */
+        Callback.prototype.catch;
+    }
+})(Result || (Result = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ * @template D, R, E
+ */
+function ActivityOutletContext() { }
+if (false) {
+    /** @type {?} */
+    ActivityOutletContext.prototype.interactionContext;
+    /** @type {?} */
+    ActivityOutletContext.prototype.activityClass;
+    /** @type {?} */
+    ActivityOutletContext.prototype.activityData;
+    /** @type {?} */
+    ActivityOutletContext.prototype.onDone;
+    /** @type {?} */
+    ActivityOutletContext.prototype.onCancel;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @param {?} options
+ * @return {?}
+ */
+function Place(options) {
+    return (/**
+     * @param {?} target
+     * @return {?}
+     */
+    (target) => {
+        Reflect.defineMetadata('place.options', options, target);
+    });
+}
+(function (Place) {
+    /**
+     * @record
+     */
+    function Options() { }
+    Place.Options = Options;
+    if (false) {
+        /** @type {?} */
+        Options.prototype.path;
+        /** @type {?} */
+        Options.prototype.title;
+        /** @type {?|undefined} */
+        Options.prototype.authenticate;
+    }
+    class Descriptor {
+        /**
+         * @param {?} placeClass
+         * @param {?} options
+         */
+        constructor(placeClass, options) {
+            assert.notNil(options);
+            this.path = options.path;
+            this.title = options.title;
+            this.authenticate = isNil(options.authenticate) || options.authenticate;
+        }
+    }
+    Place.Descriptor = Descriptor;
+    if (false) {
+        /** @type {?} */
+        Descriptor.prototype.path;
+        /** @type {?} */
+        Descriptor.prototype.authenticate;
+        /** @type {?} */
+        Descriptor.prototype.title;
+    }
+    /**
+     * @param {?} klass
+     * @return {?}
+     */
+    function getDescriptor(klass) {
+        /** @type {?} */
+        const placeOptions = Reflect.getMetadata('place.options', klass);
+        return new Descriptor(klass, placeOptions);
+    }
+    Place.getDescriptor = getDescriptor;
+})(Place || (Place = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ * @template T
+ */
+function ResolvedParameter() { }
+if (false) {
+    /** @type {?} */
+    ResolvedParameter.prototype.parameter;
+    /** @type {?} */
+    ResolvedParameter.prototype.resolvedValue;
+}
+class ResolvedParameters {
+    /**
+     * @param {?} parameters
+     */
+    constructor(parameters) {
+        this.parameters = parameters;
+    }
+    /**
+     * @template T
+     * @param {?} parameter
+     * @return {?}
+     */
+    get(parameter) {
+        /** @type {?} */
+        const resolved = this.parameters.find((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.parameter === parameter));
+        return resolved ? resolved.resolvedValue : null;
+    }
+    /**
+     * @template T
+     * @param {?} parameter
+     * @param {?} value
+     * @return {?}
+     */
+    replace(parameter, value) {
+        return new ResolvedParameters(this.parameters.filter((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.parameter !== parameter)).concat({
+            parameter,
+            resolvedValue: value
+        }));
+    }
+    /**
+     * @protected
+     * @return {?}
+     */
+    getFormattedRouteId() {
+        /** @type {?} */
+        const routeIdParam = this.getRouteIdParam();
+        return routeIdParam ? routeIdParam.parameter.type.format(routeIdParam.resolvedValue) : null;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getRouteIdParam() {
+        return this.parameters.find((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.parameter.isRouteId));
+    }
+    /**
+     * @protected
+     * @return {?}
+     */
+    getFormattedParameters() {
+        /** @type {?} */
+        const params = {};
+        /** @type {?} */
+        const routeIdParam = this.parameters.filter((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => !p.parameter.isRouteId)).forEach((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => {
+            params[p.parameter.name] = p.parameter.type.format(p.resolvedValue);
+        }));
+        return params;
+    }
+    /**
+     * @return {?}
+     */
+    hasRouteId() {
+        return !!this.getRouteIdParam();
+    }
+    /**
+     * @param {?} previous
+     * @param {?} router
+     * @param {?} activatedRoute
+     * @return {?}
+     */
+    redirect(previous, router, activatedRoute) {
+        /** @type {?} */
+        const routeId = this.getFormattedRouteId();
+        /** @type {?} */
+        const relativePath = !!previous.hasRouteId() ? '..' : '.';
+        /** @type {?} */
+        const path = routeId ? [relativePath, routeId, this.getFormattedParameters()] : [relativePath, this.getFormattedParameters()];
+        router.navigate(path, {
+            relativeTo: activatedRoute,
+        });
+    }
+}
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ResolvedParameters.prototype, "getFormattedRouteId", null);
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ResolvedParameters.prototype, "getFormattedParameters", null);
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ResolvedParameters, Router, ActivatedRoute]),
+    __metadata("design:returntype", void 0)
+], ResolvedParameters.prototype, "redirect", null);
+if (false) {
+    /** @type {?} */
+    ResolvedParameters.prototype.parameters;
+}
+class RouteParameterBindings extends GarbageCollector {
+    /**
+     * @param {?} component
+     * @param {?} router
+     * @param {?} activatedRoute
+     */
+    constructor(component, router, activatedRoute) {
+        super();
+        this.component = component;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this._incomingRouteChange = new MutableValueModel(false);
+        this.resolvedParameters = new MutableValueModel();
+        const { chain, valueOf, before, when, after, observe } = Dsl.disposeWith(this);
+        this.txo = new TransactionObserver(); //.onEvent(e => console.log(e.toString()));
+        //.onEvent(e => console.log(e.toString()));
+        /** @type {?} */
+        const routeParameterDefs = Klass.get(component).getMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY);
+        routeParameterDefs.forEach((/**
+         * @param {?} parameter
+         * @return {?}
+         */
+        parameter => this.installBinding(parameter)));
+        /** @type {?} */
+        const incomingResolvedRouteParameters = observe.valuesFrom(activatedRoute.paramMap)
+            .last()
+            .map((/**
+         * @param {?} params
+         * @return {?}
+         */
+        params => {
+            /** @type {?} */
+            const result = [];
+            routeParameterDefs.forEach((/**
+             * @param {?} parameter
+             * @return {?}
+             */
+            parameter => {
+                result.push({ parameter, resolvedValue: parameter.type.parse(params.get(parameter.name)) });
+            }));
+            return new ResolvedParameters(result);
+        }));
+        incomingResolvedRouteParameters.subscribe((/**
+         * @param {?} resolvedParameters
+         * @return {?}
+         */
+        resolvedParameters => {
+            this._incomingRouteChange.value = true;
+            this.resolvedParameters.value = resolvedParameters;
+            this._incomingRouteChange.value = false;
+        }));
+        when.valueOf(this.resolvedParameters).changes((/**
+         * @param {?} params
+         * @param {?} previous
+         * @return {?}
+         */
+        (params, previous) => {
+            params.redirect(previous, router, activatedRoute);
+        }), { unless: this.incomingRouteChange });
+        this.txo.observe('incomingResolvedRouteParameters', incomingResolvedRouteParameters);
+        this.txo.observe('this.routeIsChanging', this.incomingRouteChange);
+    }
+    /**
+     * @return {?}
+     */
+    get incomingRouteChange() {
+        return this._incomingRouteChange.readonly;
+    }
+    /**
+     * @protected
+     * @template T
+     * @param {?} parameter
+     * @return {?}
+     */
+    installBinding(parameter) {
+        /** @type {?} */
+        const model = this.getModelFor(parameter);
+        this.txo.observe(parameter.propertyName, model);
+        this.registerDisposable(new Binding(this.resolvedParameters, model, {
+            /**
+             * @param {?} parameters
+             * @return {?}
+             */
+            toRight(parameters) {
+                return parameters.get(parameter);
+            },
+            /**
+             * @param {?} value
+             * @param {?=} currentParameters
+             * @return {?}
+             */
+            toLeft(value, currentParameters) {
+                return currentParameters.replace(parameter, value);
+            }
+        }));
+    }
+    /**
+     * @private
+     * @template T
+     * @param {?} parameter
+     * @return {?}
+     */
+    getModelFor(parameter) {
+        return this.component[parameter.propertyName];
+    }
+}
+if (false) {
+    /** @type {?} */
+    RouteParameterBindings.prototype._incomingRouteChange;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.txo;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.resolvedParameters;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.component;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.activatedRoute;
+}
+(function (RouteParameterBindings) {
+    RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY = Symbol('place:route:parameters');
+})(RouteParameterBindings || (RouteParameterBindings = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class AbstractPlaceComponent extends DisposableComponent {
+    /**
+     * @param {?} activatedRoute
+     * @param {?} router
+     */
+    constructor(activatedRoute, router) {
+        super();
+        this.activatedRoute = activatedRoute;
+        this.routeBindingMediator = this.registerDisposable(new RouteParameterBindings(this, router, activatedRoute));
+        // See https://coolon.atlassian.net/browse/PEC-59
+        ((/** @type {?} */ ((/** @type {?} */ (this.titleModel))))).setDefault(this.placeConfig.title);
+    }
+    /**
+     * @return {?}
+     */
+    get placeConfig() {
+        return Place.getDescriptor((/** @type {?} */ ((/** @type {?} */ (this.constructor)))));
+    }
+    /**
+     * @return {?}
+     */
+    canDeactivate() {
+        return true;
+    }
+}
+__decorate([
+    UseDelegate(),
+    __metadata("design:type", MutableValueModel)
+], AbstractPlaceComponent.prototype, "titleModel", void 0);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Place.Descriptor),
+    __metadata("design:paramtypes", [])
+], AbstractPlaceComponent.prototype, "placeConfig", null);
+if (false) {
+    /** @type {?} */
+    AbstractPlaceComponent.prototype.titleModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractPlaceComponent.prototype.routeBindingMediator;
+    /**
+     * @type {?}
+     * @protected
+     */
+    AbstractPlaceComponent.prototype.activatedRoute;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ */
+function PlaceComponent() { }
+if (false) {
+    /** @type {?} */
+    PlaceComponent.prototype.titleModel;
+    /**
+     * @return {?}
+     */
+    PlaceComponent.prototype.canDeactivate = function () { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class BusyOverlayComponent {
+    constructor() {
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+}
+BusyOverlayComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'aup-busy-overlay',
+                template: "<ng-content></ng-content>\n<div class=\"busy-overlay-backdrop\" *ngIf=\"busyModel.value\">\n  <mat-progress-spinner mode=\"indeterminate\" [diameter]=\"52\"></mat-progress-spinner>\n</div>\n",
+                styles: [":host{position:relative}div.busy-overlay-backdrop{position:absolute;background-color:rgba(0,0,0,.2);top:0;left:0;bottom:0;right:0;display:-ms-grid;display:grid;-ms-grid-columns:auto;grid-template-columns:auto;-ms-grid-rows:auto;grid-template-rows:auto;place-content:center}"]
+            }] }
+];
+/** @nocollapse */
+BusyOverlayComponent.ctorParameters = () => [];
+BusyOverlayComponent.propDecorators = {
+    busyModel: [{ type: Input }],
+    busy: [{ type: Input }]
+};
+__decorate([
+    UseDelegatingValueModel(),
+    __metadata("design:type", ValueModel)
+], BusyOverlayComponent.prototype, "busyModel", void 0);
+__decorate([
+    StoreInValueModel('busyModel'),
+    __metadata("design:type", Boolean)
+], BusyOverlayComponent.prototype, "busy", void 0);
+if (false) {
+    /** @type {?} */
+    BusyOverlayComponent.prototype.busyModel;
+    /** @type {?} */
+    BusyOverlayComponent.prototype.busy;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class EmptyStateComponent {
+    constructor() {
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+}
+EmptyStateComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-empty-state',
+                template: `
+      <div class="container">
+          <ng-content></ng-content>
+      </div>
+  `,
+                styles: [":host{display:flex;flex-direction:column;justify-content:center;align-items:center}.container{padding:var(--default-padding);border:2px dashed rgba(0,0,0,.2);border-radius:5px;font-size:14px;font-weight:300}"]
+            }] }
+];
+/** @nocollapse */
+EmptyStateComponent.ctorParameters = () => [];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class PlaceService {
+    constructor() {
+        this._activePlaces = new MutableListModel();
+    }
+    /**
+     * @return {?}
+     */
+    get activePlaces() {
+        return this._activePlaces.readonly;
+    }
+    /**
+     * @param {?} place
+     * @return {?}
+     */
+    onActivate(place) {
+        this._activePlaces.push(place);
+    }
+    /**
+     * @param {?} place
+     * @return {?}
+     */
+    onDeactivate(place) {
+        this._activePlaces.remove(place);
+    }
+}
+PlaceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+PlaceService.ctorParameters = () => [];
+/** @nocollapse */ PlaceService.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceService_Factory() { return new PlaceService(); }, token: PlaceService, providedIn: "root" });
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], PlaceService.prototype, "onActivate", null);
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], PlaceService.prototype, "onDeactivate", null);
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceService.prototype._activePlaces;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class PlaceOutletComponent {
+    /**
+     * @param {?} placeService
+     */
+    constructor(placeService) {
+        this.placeService = placeService;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    onActivate($event) {
+        this.placeService.onActivate($event);
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    onDeactivate($event) {
+        this.placeService.onDeactivate($event);
+    }
+}
+PlaceOutletComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-place-outlet',
+                template: "<router-outlet (activate)=\"onActivate($event)\" (deactivate)=\"onDeactivate($event)\"></router-outlet>\n",
+                styles: [":host{grid-area:main;display:-ms-grid;display:grid;-ms-grid-rows:0 1fr;grid-template-rows:0 1fr;min-height:0}"]
+            }] }
+];
+/** @nocollapse */
+PlaceOutletComponent.ctorParameters = () => [
+    { type: PlaceService }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceOutletComponent.prototype.placeService;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class PlaceModule {
+}
+PlaceModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    MatProgressSpinnerModule,
+                    RouterModule
+                ],
+                declarations: [
+                    EmptyStateComponent,
+                    BusyOverlayComponent,
+                    PlaceOutletComponent
+                ],
+                entryComponents: [BusyOverlayComponent],
+                exports: [
+                    BusyOverlayComponent,
+                    PlaceOutletComponent,
+                    EmptyStateComponent
+                ],
+                providers: [
+                    PlaceService
+                ]
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class LeavePlaceGuard {
+    /**
+     * @param {?} router
+     * @param {?} injector
+     */
+    constructor(router, injector) {
+        this.router = router;
+        this.injector = injector;
+    }
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    canDeactivate(component, currentRoute, currentState, nextState) {
+        return component.canDeactivate();
+    }
+}
+LeavePlaceGuard.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+LeavePlaceGuard.ctorParameters = () => [
+    { type: Router },
+    { type: Injector }
+];
+/** @nocollapse */ LeavePlaceGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(ɵɵinject(Router), ɵɵinject(INJECTOR)); }, token: LeavePlaceGuard, providedIn: "root" });
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LeavePlaceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    LeavePlaceGuard.prototype.injector;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class RouteParameterSanitiser {
+    /**
+     * @param {?} parameterDefs
+     * @param {?} injector
+     */
+    constructor(parameterDefs, injector) {
+        this.parameterDefs = parameterDefs;
+        this.injector = injector;
+        this.sanitisedParameters = [];
+        this.routeParameter = parameterDefs.find((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.isRouteId));
+        this.queryParameters = parameterDefs.filter((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => !p.isRouteId));
+    }
+    /**
+     * @param {?} snapshot
+     * @return {?}
+     */
+    sanitise(snapshot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.routeParameter) {
+                /** @type {?} */
+                const routeOk = yield this.sanitiseParameter(this.routeParameter, snapshot.paramMap.get(this.routeParameter.name));
+                if (!routeOk) {
+                    // if the route id isn't ok we redirect immediately as the query params may need to be sanitised in the
+                    // context of the route id.
+                    return false;
+                }
+            }
+            for (const param of this.queryParameters) {
+                yield this.sanitiseParameter(param, snapshot.queryParamMap.get(param.name));
+            }
+            return this.sanitisedParameters.length === 0;
+        });
+    }
+    /**
+     * @template T
+     * @param {?} def
+     * @param {?} formattedInitialValue
+     * @return {?}
+     */
+    sanitiseParameter(def, formattedInitialValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (def) {
+                /** @type {?} */
+                const sanitiser = this.getSanitiser(def);
+                if (sanitiser) {
+                    /** @type {?} */
+                    const initialValue = def.type.parse(formattedInitialValue);
+                    /** @type {?} */
+                    const sanitisedValue = yield sanitiser.sanitise(initialValue);
+                    if (initialValue !== sanitisedValue) {
+                        this.sanitisedParameters.push({ def, value: def.type.format(sanitisedValue) });
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * @param {?} router
+     * @return {?}
+     */
+    redirect(router) {
+        assert.isTruthy(this.sanitisedParameters.length !== 0);
+        /** @type {?} */
+        const sanitisedRouteId = this.sanitisedParameters.find((/**
+         * @param {?} s
+         * @return {?}
+         */
+        s => s.def === this.routeParameter));
+        if (sanitisedRouteId) {
+            return router.navigate(['..', sanitisedRouteId.value]);
+        }
+        else {
+            /** @type {?} */
+            const queryParams = this.sanitisedParameters.filter((/**
+             * @param {?} s
+             * @return {?}
+             */
+            s => s.def !== this.routeParameter))
+                .reduce((/**
+             * @param {?} params
+             * @param {?} item
+             * @return {?}
+             */
+            (params, item) => (Object.assign({}, params, { [item.def.name]: item.value }))), {});
+            return router.navigate(['.', queryParams]);
+        }
+    }
+    /**
+     * @private
+     * @template T
+     * @param {?} def
+     * @return {?}
+     */
+    getSanitiser(def) {
+        return def.sanitiser ? this.injector.get(def.sanitiser, new def.sanitiser()) : null;
+    }
+}
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], RouteParameterSanitiser.prototype, "sanitiseParameter", null);
+__decorate([
+    Memoize$1(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], RouteParameterSanitiser.prototype, "getSanitiser", null);
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterSanitiser.prototype.routeParameter;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterSanitiser.prototype.queryParameters;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterSanitiser.prototype.sanitisedParameters;
+    /** @type {?} */
+    RouteParameterSanitiser.prototype.parameterDefs;
+    /** @type {?} */
+    RouteParameterSanitiser.prototype.injector;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class PlaceRouteGuard {
+    /**
+     * @param {?} router
+     * @param {?} injector
+     */
+    constructor(router, injector) {
+        this.router = router;
+        this.injector = injector;
+    }
+    /**
+     * @param {?} route
+     * @param {?} state
+     * @return {?}
+     */
+    canActivate(route, state) {
+        /** @type {?} */
+        const routeParameters = Klass.get(route.component).getMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY);
+        /** @type {?} */
+        const sanitiser = new RouteParameterSanitiser(routeParameters, this.injector);
+        return sanitiser.sanitise(route).then((/**
+         * @param {?} proceed
+         * @return {?}
+         */
+        proceed => {
+            if (!proceed) {
+                sanitiser.redirect(this.router);
+            }
+            return proceed;
+        }));
+    }
+}
+PlaceRouteGuard.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+PlaceRouteGuard.ctorParameters = () => [
+    { type: Router },
+    { type: Injector }
+];
+/** @nocollapse */ PlaceRouteGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouteGuard_Factory() { return new PlaceRouteGuard(ɵɵinject(Router), ɵɵinject(INJECTOR)); }, token: PlaceRouteGuard, providedIn: "root" });
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ActivatedRouteSnapshot, RouterStateSnapshot]),
+    __metadata("design:returntype", Object)
+], PlaceRouteGuard.prototype, "canActivate", null);
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouteGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouteGuard.prototype.injector;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ */
+function JsonArray() { }
+/**
+ * @record
+ */
+function JsonMap() { }
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ * @template T
+ */
+function ParameterOptions() { }
+if (false) {
+    /** @type {?|undefined} */
+    ParameterOptions.prototype.as;
+    /** @type {?|undefined} */
+    ParameterOptions.prototype.sanitiser;
+}
+/**
+ * @template T
+ * @param {?} type
+ * @param {?=} options
+ * @return {?}
+ */
+function RouteId(type, options) {
+    // assert.isTruthy(type.isValid());
+    return (/**
+     * @param {?} prototype
+     * @param {?} propertyKey
+     * @return {?}
+     */
+    (prototype, propertyKey) => {
+        /** @type {?} */
+        const param = createDefinition(propertyKey, type, options, true);
+        Klass.get(prototype).addToOwnMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY, param);
+        UseDelegate()(prototype, propertyKey);
+    });
+}
+/**
+ * @template T
+ * @param {?} type
+ * @param {?=} options
+ * @return {?}
+ */
+function QueryParameter(type, options) {
+    // assert.isTruthy(type.isValid());
+    return (/**
+     * @param {?} prototype
+     * @param {?} propertyKey
+     * @return {?}
+     */
+    (prototype, propertyKey) => {
+        /** @type {?} */
+        const param = createDefinition(propertyKey, type, options, false);
+        Klass.get(prototype).addToOwnMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY, param);
+        UseDelegate()(prototype, propertyKey);
+    });
+}
+/**
+ * @template T
+ * @param {?} propertyName
+ * @param {?} type
+ * @param {?} options
+ * @param {?} routeId
+ * @return {?}
+ */
+function createDefinition(propertyName, type, options, routeId) {
+    /** @type {?} */
+    const opts = Opts.get(options);
+    /** @type {?} */
+    const propertyNameAsString = assert.notNil(propertyName).toString();
+    /** @type {?} */
+    const def = {
+        name: opts.getOptional('as', propertyNameAsString),
+        propertyName: propertyNameAsString,
+        type: assert.notNil(type),
+        sanitiser: opts.getOptional('sanitiser', null),
+        isRouteId: routeId
+    };
+    return def;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ * @template T
+ */
+function ParameterDefinition() { }
+if (false) {
+    /** @type {?} */
+    ParameterDefinition.prototype.name;
+    /** @type {?} */
+    ParameterDefinition.prototype.propertyName;
+    /** @type {?} */
+    ParameterDefinition.prototype.type;
+    /** @type {?} */
+    ParameterDefinition.prototype.sanitiser;
+    /** @type {?} */
+    ParameterDefinition.prototype.isRouteId;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ * @template T
+ */
+function ParameterSanitiser() { }
+if (false) {
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    ParameterSanitiser.prototype.sanitise = function (value) { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+// WARNING: interface has both a type and a value, skipping emit
+var ParameterType;
+(function (ParameterType) {
+    class StringType {
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        format(value) {
+            return value;
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        parse(value) {
+            return value;
+        }
+    }
+    class NumberType {
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        format(value) {
+            return `${value}`;
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        parse(value) {
+            return +value;
+        }
+    }
+    ParameterType.STRING = new StringType();
+    ParameterType.NUMBER = new NumberType();
+})(ParameterType || (ParameterType = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+export { ACTIVITY_DATA, AbstractActivity, AbstractInputComponent, AbstractPlaceComponent, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ConfirmationDialogComponent, DialogInteractionService, Dimension, DisposableComponent, EmptyStateComponent, FocusBindingDirective, INTERACTION_CONTEXT, InteractionContext, InteractionModule, LeavePlaceGuard, NumberInputComponent, ParameterType, PasswordInputComponent, Place, PlaceModule, PlaceOutletComponent, PlaceRouteGuard, PlaceService, Point, QueryParameter, ResizeAwareComponent, RouteId, RouteParameterBindings, RouteParameterSanitiser, SelectInputComponent, StringInputComponent, CommandDirective as ɵa, FocusBindingDirective as ɵb, DisposableComponent as ɵc, NumberInputComponent as ɵd, AbstractInputComponent as ɵe, StringInputComponent as ɵf, PasswordInputComponent as ɵg, SelectInputComponent as ɵh };
+//# sourceMappingURL=coolon-angular-ui-powerups.js.map