@coolon/angular-ui-powerups 0.0.98 → 0.0.101

package/esm5/lib/interaction/services/mat-dialog-interaction/dialog-interaction-context.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { lang, MutableValueModel } from '@coolon/pectin';
+import { assert } from '@coolon/typescript-utilities';
+import { ActivityContainerComponent } from '../../components/activity-container/activity-container.component';
+import { InteractionContextBase } from '../../interaction-context-base';
+var DialogInteractionContext = /** @class */ (function (_super) {
+    tslib_1.__extends(DialogInteractionContext, _super);
+    function DialogInteractionContext(dialogService, config) {
+        var _this = _super.call(this) || this;
+        _this.dialogService = dialogService;
+        _this.config = config;
+        _this._activeModel = new MutableValueModel(false);
+        assert.notNil(dialogService);
+        _this.onDispose((/**
+         * @return {?}
+         */
+        function () {
+            if (_this.isActive()) {
+                lang.illegalState('Dispose called while active.');
+            }
+        }));
+        return _this;
+    }
+    Object.defineProperty(DialogInteractionContext.prototype, "active", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._activeModel.readonly;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @protected
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    DialogInteractionContext.prototype._startActivity = /**
+     * @protected
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    function (activityType, data, disableClose) {
+        var _this = this;
+        if (disableClose === void 0) { disableClose = true; }
+        if (this.isActive()) {
+            lang.illegalState("Activity already in progress: " + this.activityList.value.map((/**
+             * @param {?} a
+             * @return {?}
+             */
+            function (a) { return a.constructor.name; })).join(', '));
+        }
+        this._activeModel.value = true;
+        /** @type {?} */
+        var config = tslib_1.__assign({}, this.config, {
+            data: data,
+            disableClose: disableClose,
+            panelClass: 'dialog-interaction-context'
+        });
+        /** @type {?} */
+        var self = this;
+        /** @type {?} */
+        var matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            /** @type {?} */
+            var activityContainer = matDialogRef.componentInstance;
+            self.safelyUpdateActivityListDelegate(activityContainer.activityList);
+            activityContainer.initialActivityOutletContext = {
+                activityClass: activityType,
+                activityData: data,
+                onDone: /**
+                 * @param {?} result
+                 * @return {?}
+                 */
+                function (result) {
+                    resolve(result);
+                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
+                },
+                onCancel: /**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    reject(error);
+                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
+                }
+            };
+            // we need to check if our onDone/onCancel methods above we called or if we were
+            // closed by the user clicking the backdrop.  If the later then we need to reject
+            // our promise.
+            matDialogRef.afterClosed().subscribe((/**
+             * @param {?} promiseAlreadyFinished
+             * @return {?}
+             */
+            function (promiseAlreadyFinished) {
+                if (!promiseAlreadyFinished) {
+                    reject('auto-closed');
+                }
+            }));
+            matDialogRef.updateSize();
+            matDialogRef.afterOpened().subscribe((/**
+             * @param {?} promiseAlreadyFinished
+             * @return {?}
+             */
+            function (promiseAlreadyFinished) {
+                matDialogRef.updateSize();
+            }));
+        })).finally((/**
+         * @return {?}
+         */
+        function () {
+            self.safelyUpdateActivityListDelegate(null);
+            _this._activeModel.value = false;
+        }));
+    };
+    /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param delegate
+     */
+    /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param {?} delegate
+     * @return {?}
+     */
+    DialogInteractionContext.prototype.safelyUpdateActivityListDelegate = /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param {?} delegate
+     * @return {?}
+     */
+    function (delegate) {
+        var _this = this;
+        setTimeout((/**
+         * @return {?}
+         */
+        function () { return _this.setActivityList(delegate); }));
+    };
+    return DialogInteractionContext;
+}(InteractionContextBase));
+export { DialogInteractionContext };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContext.prototype._activeModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContext.prototype.dialogService;
+    /** @type {?} */
+    DialogInteractionContext.prototype.config;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/interaction/services/modal-interaction-context.factory.js

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @abstract
+ */
+var /**
+ * @abstract
+ */
+ModalInteractionContextFactory = /** @class */ (function () {
+    function ModalInteractionContextFactory() {
+    }
+    return ModalInteractionContextFactory;
+}());
+/**
+ * @abstract
+ */
+export { ModalInteractionContextFactory };
+if (false) {
+    /**
+     * @abstract
+     * @return {?}
+     */
+    ModalInteractionContextFactory.prototype.createInteractionContext = function () { };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtaW50ZXJhY3Rpb24tY29udGV4dC5mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGNvb2xvbi9hbmd1bGFyLXVpLXBvd2VydXBzLyIsInNvdXJjZXMiOlsibGliL2ludGVyYWN0aW9uL3NlcnZpY2VzL21vZGFsLWludGVyYWN0aW9uLWNvbnRleHQuZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBRUE7Ozs7SUFBQTtJQUdBLENBQUM7SUFBRCxxQ0FBQztBQUFELENBQUMsQUFIRCxJQUdDOzs7Ozs7Ozs7O0lBREMsb0ZBQXdEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW50ZXJhY3Rpb25Db250ZXh0IH0gZnJvbSAnLi4vaW50ZXJhY3Rpb24tY29udGV4dCc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBNb2RhbEludGVyYWN0aW9uQ29udGV4dEZhY3Rvcnkge1xuXG4gIGFic3RyYWN0IGNyZWF0ZUludGVyYWN0aW9uQ29udGV4dCgpOiBJbnRlcmFjdGlvbkNvbnRleHQ7XG59XG4iXX0=

package/esm5/lib/place/components/place-outlet/place-outlet.component.js

@@ -100,10 +100,10 @@ var PlaceOutletComponent = /** @class */ (function (_super) {
         function (next, previous) {
             _this.pushVisitChangesToRoute(next, previous);
         }), {
-            unless: _this.placeRouter.navigationSessionActive
+            unless: _this.placeRouter.navigationInProgress
         });
         chain(_this._activePlace)
-            .postponeWhile(placeRouter.navigationSessionActive)
+            .postponeWhile(placeRouter.navigationInProgress)
             .subscribe((/**
          * @param {?} place
          * @return {?}
@@ -447,4 +447,4 @@ if (false) {
     /** @type {?} */
     PlaceOutletComponent.prototype.placeConfig;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-outlet.component.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/components/place-outlet/place-outlet.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Inject, Input, OnInit, Optional, Output, SkipSelf, ViewChild } from '@angular/core';\nimport { ActivatedRoute, Router, RouterOutlet } from '@angular/router';\nimport {\n  BooleanValueModelChain,\n  Constructable,\n  DelegatingValueModel,\n  Dsl,\n  Guard,\n  ListModel,\n  MutableValueModel,\n  StoreInListModel,\n  StoreInValueModel,\n  UseDelegate,\n  ValueModel,\n  ValueModelChain\n} from '@coolon/pectin';\nimport * as _ from 'lodash';\nimport { DisposableComponent } from '../../../components/disposable-component';\nimport { PlaceComponent } from '../../place-component';\nimport { AUP_PLACE_CONFIG, PlaceConfig } from '../../place-config';\nimport { PlaceDefinition } from '../../place-definition';\nimport { PlaceRouter } from '../../place-router';\n\nimport { Visit } from '../../visit';\nimport { LEFT_RIGHT_PLACE_ANIMATION } from './route-animations';\n\n// Quick hack to avoid circular references between this and PlaceComponents.\ninterface PlaceRef {\n  readonly placeDefinition: PlaceDefinition\n\n  initialiseBindings(param: ValueModel<Visit>): void;\n\n  onPlaceReady(): void;\n}\n\n@Component({\n  selector: 'aup-place-outlet',\n  templateUrl: './place-outlet.component.html',\n  styleUrls: ['./place-outlet.component.scss'],\n  animations: [LEFT_RIGHT_PLACE_ANIMATION]\n})\nexport class PlaceOutletComponent extends DisposableComponent implements OnInit {\n\n  @Input() @StoreInValueModel('animateModel')\n  animate: boolean;\n\n  @Input() @UseDelegate({ defaultValue: true })\n  animateModel: ValueModel<boolean>;\n\n  // tslint:disable-next-line:no-input-rename\n  @Input('placeAnimationOrderModel') @UseDelegate()\n  customPlaceAnimationOrderModel: ListModel<Constructable<PlaceComponent>>;\n\n  // tslint:disable-next-line:no-input-rename\n  @Input('placeAnimationOrder') @StoreInListModel('customPlaceAnimationOrderModel')\n  customPlaceAnimationOrder: Constructable<PlaceComponent>[];\n\n  @Output()\n  readonly placeChanged = new EventEmitter<PlaceComponent>();\n\n  @ViewChild('routeOutlet', { static: true })\n  routerOut: RouterOutlet;\n\n  private readonly _activePlace = new MutableValueModel<PlaceComponent>();\n  private readonly _activePlaceVisitModel = new DelegatingValueModel<Visit>();\n\n  private readonly _inOutletActivation = new Guard();\n  private readonly _inOutletDeactivation = new Guard();\n  private readonly _inOutletUpdate: BooleanValueModelChain;\n  private readonly _inRouteVisitUpdate = new Guard();\n  private readonly _activatedRouteModel = new MutableValueModel<ActivatedRoute>();\n\n  private readonly _placeDefinition = new MutableValueModel<PlaceDefinition>();\n  private parentOutletModel: MutableValueModel<PlaceOutletComponent>;\n  public readonly placeAnimationOrder: ValueModelChain<number>;\n\n  private initialPlaceIndex: number = null;\n  private routerVisit: ValueModelChain<Visit>;\n\n  constructor(private readonly router: Router,\n              private readonly placeRouter: PlaceRouter,\n              @Optional() @Inject(AUP_PLACE_CONFIG) readonly placeConfig: PlaceConfig,\n              @SkipSelf() @Optional() parentOutlet: PlaceOutletComponent) {\n    super();\n    const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);\n\n    this.parentOutletModel = new MutableValueModel(parentOutlet);\n    this._activePlaceVisitModel.setDelegate(new MutableValueModel<Visit>());\n    this._inOutletUpdate = valueOf.any(this._inOutletDeactivation, this._inOutletActivation).areTruthy();\n\n    const defaultPlaceAnimationOrder = chain(this.parentOutletModel)\n      .pullValueModel(o => o.activePlaceModel)\n      .pluck('placeDefinition')\n      .pluckList('children')\n      .pluck('component');\n\n    const activatePlaceType = chain(this.activePlaceModel).map(p => p.constructor as Constructable<PlaceComponent>);\n    this.placeAnimationOrder = chain(this.customPlaceAnimationOrderModel)\n      .otherwise(defaultPlaceAnimationOrder)\n      .reduce((placesInOrder) => {\n        let placeIndex = 0;\n        if (activatePlaceType.value) {\n          placeIndex = placesInOrder.indexOf(activatePlaceType.value);\n          if (_.isNil(this.initialPlaceIndex)) {\n            this.initialPlaceIndex = placeIndex;\n          }\n        }\n        return _.isNil(this.initialPlaceIndex) ? 0 : placeIndex - this.initialPlaceIndex;\n      }, { dependsOn: activatePlaceType });\n\n    // Push incoming changes into the component\n    this.routerVisit = chain(this._activePlace).pluck('placeDefinition').findIn(placeRouter.activeVisitIndex);\n    // Our router visit will change when our active is nullified during deactivation, which will push a null visit\n    // the the deactivated component, which will nuke it's view before the animations have finished.\n    // The visit will alway updated after the router session is finsised (when the new visits are registered) so\n    // we can safely ignore it during outlet changes as these always happen before the router session ends.\n    when.valueOf(this.routerVisit).changes(() => this.pushRouteChangesToVisit(), { unless: this._inOutletUpdate });\n\n    // Handle component based changes\n    when.valueOf(this._activePlaceVisitModel).changes((next, previous) => {\n      this.pushVisitChangesToRoute(next, previous);\n    }, {\n      unless: this.placeRouter.navigationSessionActive\n    });\n\n    chain(this._activePlace)\n      .postponeWhile(placeRouter.navigationSessionActive)\n      .subscribe(place => this.placeChanged.emit(place));\n\n  }\n\n  ngOnInit() {\n  }\n\n  // @Trace()\n  getAnimationOrder() {\n    return this.placeAnimationOrder.value;\n  }\n\n  get animationDuration() {\n    return this.placeConfig && this.placeConfig.animationDuration ? this.placeConfig.animationDuration : '500ms';\n  }\n\n  // @Trace()\n  navigate(visit: Visit) {\n    // console.log({ activatedRoute: this._activatedRouteModel.value });\n    this.placeRouter.navigate(visit, {\n      relativeTo: this.parentOutlet ? this.parentOutlet.activatedRouteModel.value : null\n    });\n  }\n\n  get parentOutlet(): PlaceOutletComponent {\n    return this.parentOutletModel.value;\n  }\n\n  // @Trace()\n  pushRouteChangesToVisit() {\n    const visit = this.routerVisit.value;\n    // console.log({\n    //   visit,\n    //   place: visit ? visit.placeDefinition.component : null,\n    //   inOutletActivation: this._inOutletActivation.value,\n    //   inRoutingSession: this.placeRouter.navigationSessionActive.value\n    // });\n    if (visit) { // can be null while the place and index sync up\n      this._inRouteVisitUpdate.whileTrue(() => {\n        this._activePlaceVisitModel.value = visit;\n      });\n    }\n  }\n\n  pushVisitChangesToRoute(next: Visit, previous: Visit) {\n    const activatedRoute = this._activatedRouteModel.value;\n    this.placeRouter.pushVisitChangesToRoute(activatedRoute, previous, next);\n  }\n\n  get activePlaceModel(): ValueModel<PlaceComponent> {\n    return this._activePlace.readonly;\n  }\n\n  get activatedRouteModel(): ValueModel<ActivatedRoute> {\n    return this._activatedRouteModel.readonly;\n  }\n\n  // @Trace()\n  onOutletActivated(routerOutlet: RouterOutlet, place: PlaceComponent) {\n    this._inOutletActivation.whileTrue(() => {\n      try {\n        this._activePlace.value = place;\n        this._activatedRouteModel.value = routerOutlet.activatedRoute;\n        this._placeDefinition.value = place.placeDefinition;\n        const visitModel = new MutableValueModel<Visit>();\n        this._activePlaceVisitModel.setDelegate(visitModel);\n        place.initialiseBindings(visitModel);\n      } catch (error) {\n        console.error(error);\n      }\n    });\n    if (!this.animateModel.value) {\n      // we're not animating so trigger any post animation callbacks now.\n      this.animationDone();\n    }\n  }\n\n  // @Trace()\n  onOutletDeactivated() {\n    this._inOutletDeactivation.whileTrue(() => {\n      this._activePlace.value = null;\n      this._activatedRouteModel.value = null;\n      this._placeDefinition.value = null;\n      this._activePlaceVisitModel.setDelegate(null);\n    });\n  }\n\n  // @Trace()\n  animationStarted() {\n    // console.log({ activePlace: this._activePlace.value });\n  }\n\n  // @Trace()\n  animationDone() {\n    if (this._activePlace.value) {\n      this._activePlace.value.onPlaceReady();\n    }\n  }\n\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-outlet.component.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/components/place-outlet/place-outlet.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Inject, Input, OnInit, Optional, Output, SkipSelf, ViewChild } from '@angular/core';\nimport { ActivatedRoute, Router, RouterOutlet } from '@angular/router';\nimport {\n  BooleanValueModelChain,\n  Constructable,\n  DelegatingValueModel,\n  Dsl,\n  Guard,\n  ListModel,\n  MutableValueModel,\n  StoreInListModel,\n  StoreInValueModel,\n  UseDelegate,\n  ValueModel,\n  ValueModelChain\n} from '@coolon/pectin';\nimport * as _ from 'lodash';\nimport { DisposableComponent } from '../../../components/disposable-component';\nimport { PlaceComponent } from '../../place-component';\nimport { AUP_PLACE_CONFIG, PlaceConfig } from '../../place-config';\nimport { PlaceDefinition } from '../../place-definition';\nimport { PlaceRouter } from '../../place-router';\n\nimport { Visit } from '../../visit';\nimport { LEFT_RIGHT_PLACE_ANIMATION } from './route-animations';\n\n// Quick hack to avoid circular references between this and PlaceComponents.\ninterface PlaceRef {\n  readonly placeDefinition: PlaceDefinition\n\n  initialiseBindings(param: ValueModel<Visit>): void;\n\n  onPlaceReady(): void;\n}\n\n@Component({\n  selector: 'aup-place-outlet',\n  templateUrl: './place-outlet.component.html',\n  styleUrls: ['./place-outlet.component.scss'],\n  animations: [LEFT_RIGHT_PLACE_ANIMATION]\n})\nexport class PlaceOutletComponent extends DisposableComponent implements OnInit {\n\n  @Input() @StoreInValueModel('animateModel')\n  animate: boolean;\n\n  @Input() @UseDelegate({ defaultValue: true })\n  animateModel: ValueModel<boolean>;\n\n  // tslint:disable-next-line:no-input-rename\n  @Input('placeAnimationOrderModel') @UseDelegate()\n  customPlaceAnimationOrderModel: ListModel<Constructable<PlaceComponent>>;\n\n  // tslint:disable-next-line:no-input-rename\n  @Input('placeAnimationOrder') @StoreInListModel('customPlaceAnimationOrderModel')\n  customPlaceAnimationOrder: Constructable<PlaceComponent>[];\n\n  @Output()\n  readonly placeChanged = new EventEmitter<PlaceComponent>();\n\n  @ViewChild('routeOutlet', { static: true })\n  routerOut: RouterOutlet;\n\n  private readonly _activePlace = new MutableValueModel<PlaceComponent>();\n  private readonly _activePlaceVisitModel = new DelegatingValueModel<Visit>();\n\n  private readonly _inOutletActivation = new Guard();\n  private readonly _inOutletDeactivation = new Guard();\n  private readonly _inOutletUpdate: BooleanValueModelChain;\n  private readonly _inRouteVisitUpdate = new Guard();\n  private readonly _activatedRouteModel = new MutableValueModel<ActivatedRoute>();\n\n  private readonly _placeDefinition = new MutableValueModel<PlaceDefinition>();\n  private parentOutletModel: MutableValueModel<PlaceOutletComponent>;\n  public readonly placeAnimationOrder: ValueModelChain<number>;\n\n  private initialPlaceIndex: number = null;\n  private routerVisit: ValueModelChain<Visit>;\n\n  constructor(private readonly router: Router,\n              private readonly placeRouter: PlaceRouter,\n              @Optional() @Inject(AUP_PLACE_CONFIG) readonly placeConfig: PlaceConfig,\n              @SkipSelf() @Optional() parentOutlet: PlaceOutletComponent) {\n    super();\n    const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);\n\n    this.parentOutletModel = new MutableValueModel(parentOutlet);\n    this._activePlaceVisitModel.setDelegate(new MutableValueModel<Visit>());\n    this._inOutletUpdate = valueOf.any(this._inOutletDeactivation, this._inOutletActivation).areTruthy();\n\n    const defaultPlaceAnimationOrder = chain(this.parentOutletModel)\n      .pullValueModel(o => o.activePlaceModel)\n      .pluck('placeDefinition')\n      .pluckList('children')\n      .pluck('component');\n\n    const activatePlaceType = chain(this.activePlaceModel).map(p => p.constructor as Constructable<PlaceComponent>);\n    this.placeAnimationOrder = chain(this.customPlaceAnimationOrderModel)\n      .otherwise(defaultPlaceAnimationOrder)\n      .reduce((placesInOrder) => {\n        let placeIndex = 0;\n        if (activatePlaceType.value) {\n          placeIndex = placesInOrder.indexOf(activatePlaceType.value);\n          if (_.isNil(this.initialPlaceIndex)) {\n            this.initialPlaceIndex = placeIndex;\n          }\n        }\n        return _.isNil(this.initialPlaceIndex) ? 0 : placeIndex - this.initialPlaceIndex;\n      }, { dependsOn: activatePlaceType });\n\n    // Push incoming changes into the component\n    this.routerVisit = chain(this._activePlace).pluck('placeDefinition').findIn(placeRouter.activeVisitIndex);\n    // Our router visit will change when our active is nullified during deactivation, which will push a null visit\n    // the the deactivated component, which will nuke it's view before the animations have finished.\n    // The visit will alway updated after the router session is finsised (when the new visits are registered) so\n    // we can safely ignore it during outlet changes as these always happen before the router session ends.\n    when.valueOf(this.routerVisit).changes(() => this.pushRouteChangesToVisit(), { unless: this._inOutletUpdate });\n\n    // Handle component based changes\n    when.valueOf(this._activePlaceVisitModel).changes((next, previous) => {\n      this.pushVisitChangesToRoute(next, previous);\n    }, {\n      unless: this.placeRouter.navigationInProgress\n    });\n\n    chain(this._activePlace)\n      .postponeWhile(placeRouter.navigationInProgress)\n      .subscribe(place => this.placeChanged.emit(place));\n\n  }\n\n  ngOnInit() {\n  }\n\n  // @Trace()\n  getAnimationOrder() {\n    return this.placeAnimationOrder.value;\n  }\n\n  get animationDuration() {\n    return this.placeConfig && this.placeConfig.animationDuration ? this.placeConfig.animationDuration : '500ms';\n  }\n\n  // @Trace()\n  navigate(visit: Visit) {\n    // console.log({ activatedRoute: this._activatedRouteModel.value });\n    this.placeRouter.navigate(visit, {\n      relativeTo: this.parentOutlet ? this.parentOutlet.activatedRouteModel.value : null\n    });\n  }\n\n  get parentOutlet(): PlaceOutletComponent {\n    return this.parentOutletModel.value;\n  }\n\n  // @Trace()\n  pushRouteChangesToVisit() {\n    const visit = this.routerVisit.value;\n    // console.log({\n    //   visit,\n    //   place: visit ? visit.placeDefinition.component : null,\n    //   inOutletActivation: this._inOutletActivation.value,\n    //   inRoutingSession: this.placeRouter.navigationSessionActive.value\n    // });\n    if (visit) { // can be null while the place and index sync up\n      this._inRouteVisitUpdate.whileTrue(() => {\n        this._activePlaceVisitModel.value = visit;\n      });\n    }\n  }\n\n  pushVisitChangesToRoute(next: Visit, previous: Visit) {\n    const activatedRoute = this._activatedRouteModel.value;\n    this.placeRouter.pushVisitChangesToRoute(activatedRoute, previous, next);\n  }\n\n  get activePlaceModel(): ValueModel<PlaceComponent> {\n    return this._activePlace.readonly;\n  }\n\n  get activatedRouteModel(): ValueModel<ActivatedRoute> {\n    return this._activatedRouteModel.readonly;\n  }\n\n  // @Trace()\n  onOutletActivated(routerOutlet: RouterOutlet, place: PlaceComponent) {\n    this._inOutletActivation.whileTrue(() => {\n      try {\n        this._activePlace.value = place;\n        this._activatedRouteModel.value = routerOutlet.activatedRoute;\n        this._placeDefinition.value = place.placeDefinition;\n        const visitModel = new MutableValueModel<Visit>();\n        this._activePlaceVisitModel.setDelegate(visitModel);\n        place.initialiseBindings(visitModel);\n      } catch (error) {\n        console.error(error);\n      }\n    });\n    if (!this.animateModel.value) {\n      // we're not animating so trigger any post animation callbacks now.\n      this.animationDone();\n    }\n  }\n\n  // @Trace()\n  onOutletDeactivated() {\n    this._inOutletDeactivation.whileTrue(() => {\n      this._activePlace.value = null;\n      this._activatedRouteModel.value = null;\n      this._placeDefinition.value = null;\n      this._activePlaceVisitModel.setDelegate(null);\n    });\n  }\n\n  // @Trace()\n  animationStarted() {\n    // console.log({ activePlace: this._activePlace.value });\n  }\n\n  // @Trace()\n  animationDone() {\n    if (this._activePlace.value) {\n      this._activePlace.value.onPlaceReady();\n    }\n  }\n\n\n}\n"]}

package/esm5/lib/place/guards/abstract-place.guard.js

@@ -51,16 +51,16 @@ var AbstractPlaceGuard = /** @class */ (function () {
                                     // Parse our route params.
                                     params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
                                     parsedParams = placeDefinition.parseRouteParams(params);
-                                    initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                                    initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
                                     sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
                                     return [4 /*yield*/, sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams))];
                                 case 1:
                                     sanitisedVisit = _a.sent();
                                     // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
-                                    this.placeRouter.navigationSession.storeVisit(sanitisedVisit);
+                                    this.placeRouter.navigationState.storeVisit(sanitisedVisit);
                                     if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
                                         // Regenerate the url
-                                        commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);
+                                        commands = this.placeRouter.parseUrl(state.url).createRedirectCommandsFor(sanitisedVisit);
                                         console.log('##### Place Guard Redirect', commands);
                                         return [2 /*return*/, this.router.createUrlTree(commands, {
                                                 replaceUrl: true,
@@ -94,7 +94,7 @@ var AbstractPlaceGuard = /** @class */ (function () {
     function (component, currentRoute, currentState, nextState) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.placeRouter.navigationSession.canDeactivatePlace(component, this.placeRouter.parseUrl(nextState))];
+                return [2 /*return*/, this.placeRouter.navigationState.canDeactivatePlace(component, this.placeRouter.parseUrl(nextState.url))];
             });
         });
     };
@@ -104,7 +104,7 @@ var AbstractPlaceGuard = /** @class */ (function () {
      * @protected
      * @param {?} activatedRoute
      * @param {?} state
-     * @param {?} canActivate
+     * @param {?} runPlaceGuards
      * @return {?}
      */
     AbstractPlaceGuard.prototype.authorisePlaceThen = 
@@ -113,12 +113,12 @@ var AbstractPlaceGuard = /** @class */ (function () {
      * @protected
      * @param {?} activatedRoute
      * @param {?} state
-     * @param {?} canActivate
+     * @param {?} runPlaceGuards
      * @return {?}
      */
-    function (activatedRoute, state, canActivate) {
+    function (activatedRoute, state, runPlaceGuards) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var placeDefinition, authorised, _a;
+            var placeDefinition, authoriseResult, _a;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -133,13 +133,14 @@ var AbstractPlaceGuard = /** @class */ (function () {
                         _a = true;
                         _b.label = 3;
                     case 3:
-                        authorised = _a;
-                        if (authorised === true) {
-                            return [2 /*return*/, canActivate(placeDefinition)];
+                        authoriseResult = _a;
+                        if (authoriseResult === true) {
+                            // we're authorised, now run the place guards.
+                            return [2 /*return*/, runPlaceGuards(placeDefinition)];
                         }
                         else {
-                            console.log('not authorised result', authorised);
-                            return [2 /*return*/, authorised];
+                            console.log('not authorised result', authoriseResult);
+                            return [2 /*return*/, authoriseResult];
                         }
                         return [3 /*break*/, 5];
                     case 4: return [2 /*return*/, lang.illegalState("expected component to be an instance of PlaceComponent, got " + activatedRoute.component)];
@@ -209,4 +210,4 @@ if (false) {
      */
     AbstractPlaceGuard.prototype.getAuthGuard = function (injector) { };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/abstract-place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport {\n  ActivatedRouteSnapshot,\n  CanActivate, CanDeactivate,\n  Router,\n  RouterStateSnapshot,\n  UrlSerializer,\n  UrlTree\n} from '@angular/router';\nimport { lang, Trace } from '@coolon/pectin';\nimport { Observable } from 'rxjs';\nimport { ModalInteractionService } from '../../interaction/services/modal-interaction.service';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { PlaceHistory } from '../place-history';\nimport { PlaceRouter } from '../place-router';\nimport { VisitSanitiser } from '../route/visit-sanitiser';\nimport { Visit } from '../visit';\nimport { ConsolidatedParameterMap } from './consolidated-param-map';\n\n\nexport abstract class AbstractPlaceGuard implements CanActivate, CanDeactivate<PlaceComponent> {\n\n\n  constructor(private readonly router: Router,\n              private urlSerializer: UrlSerializer,\n              private readonly placeRouter: PlaceRouter,\n              private readonly placeHistory: PlaceHistory,\n              private readonly injector: Injector) {\n  }\n\n  // @Trace()\n  async canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    return this.authorisePlaceThen(activatedRoute, state, async placeDefinition => {\n\n      // Parse our route params.\n      const params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);\n      const parsedParams = placeDefinition.parseRouteParams(params);\n\n      const initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);\n      const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);\n      const sanitisedVisit = await sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));\n\n      // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters\n      this.placeRouter.navigationSession.storeVisit(sanitisedVisit);\n      if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {\n        // Regenerate the url\n        const commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);\n        console.log('##### Place Guard Redirect', commands);\n        return this.router.createUrlTree(commands, {\n          replaceUrl: true,\n          skipLocationChange: false\n        });\n      } else {\n        return true;\n      }\n    });\n  }\n\n  async canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean> {\n    return this.placeRouter.navigationSession.canDeactivatePlace(component, this.placeRouter.parseUrl(nextState));\n  }\n\n  // @Trace()\n  protected async authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, canActivate: (placeDefinition: PlaceDefinition) => Promise<boolean | UrlTree>) {\n    if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {\n      const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);\n      const authorised = placeDefinition.authenticate ? await this.isAuthorised(activatedRoute, state) : true;\n      if (authorised === true) {\n        return canActivate(placeDefinition);\n      } else {\n        console.log('not authorised result', authorised);\n        return authorised;\n      }\n    } else {\n      return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);\n    }\n  }\n\n  @Trace()\n  async isAuthorised(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);\n    return (authorised instanceof Observable) ? authorised.toPromise() : authorised;\n  }\n\n  abstract getAuthGuard(injector: Injector): CanActivate;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/abstract-place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport {\n  ActivatedRouteSnapshot,\n  CanActivate, CanDeactivate,\n  Router,\n  RouterStateSnapshot,\n  UrlSerializer,\n  UrlTree\n} from '@angular/router';\nimport { lang, Trace } from '@coolon/pectin';\nimport { Observable } from 'rxjs';\nimport { InteractionService } from '../../interaction/services/interaction.service';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { PlaceHistory } from '../place-history';\nimport { PlaceRouter } from '../place-router';\nimport { VisitSanitiser } from '../route/visit-sanitiser';\nimport { Visit } from '../visit';\nimport { ConsolidatedParameterMap } from './consolidated-param-map';\n\n\nexport abstract class AbstractPlaceGuard implements CanActivate, CanDeactivate<PlaceComponent> {\n\n\n  constructor(private readonly router: Router,\n              private urlSerializer: UrlSerializer,\n              private readonly placeRouter: PlaceRouter,\n              private readonly placeHistory: PlaceHistory,\n              private readonly injector: Injector) {\n  }\n\n  // @Trace()\n  async canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    return this.authorisePlaceThen(activatedRoute, state, async placeDefinition => {\n\n      // Parse our route params.\n      const params = new ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);\n      const parsedParams = placeDefinition.parseRouteParams(params);\n\n      const initialVisit = this.placeRouter.navigationState.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);\n      const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);\n      const sanitisedVisit = await sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));\n\n      // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters\n      this.placeRouter.navigationState.storeVisit(sanitisedVisit);\n      if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {\n        // Regenerate the url\n        const commands = this.placeRouter.parseUrl(state.url).createRedirectCommandsFor(sanitisedVisit);\n        console.log('##### Place Guard Redirect', commands);\n        return this.router.createUrlTree(commands, {\n          replaceUrl: true,\n          skipLocationChange: false\n        });\n      } else {\n        return true;\n      }\n    });\n  }\n\n  async canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean> {\n    return this.placeRouter.navigationState.canDeactivatePlace(component, this.placeRouter.parseUrl(nextState.url));\n  }\n\n  // @Trace()\n  protected async authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, runPlaceGuards: (placeDefinition: PlaceDefinition) => Promise<boolean | UrlTree>) {\n    if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {\n      const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);\n      const authoriseResult = placeDefinition.authenticate ? await this.isAuthorised(activatedRoute, state) : true;\n      if (authoriseResult === true) {\n        // we're authorised, now run the place guards.\n        return runPlaceGuards(placeDefinition);\n      } else {\n        console.log('not authorised result', authoriseResult);\n        return authoriseResult;\n      }\n    } else {\n       return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);\n    }\n  }\n\n  @Trace()\n  async isAuthorised(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);\n    return (authorised instanceof Observable) ? authorised.toPromise() : authorised;\n  }\n\n  abstract getAuthGuard(injector: Injector): CanActivate;\n}\n"]}

package/esm5/lib/place/guards/interaction.guard.js

@@ -6,20 +6,22 @@ import * as tslib_1 from "tslib";
 import { Location } from '@angular/common';
 import { Injectable, Injector } from '@angular/core';
 import { Router } from '@angular/router';
-import { ModalInteractionService } from '../../interaction/services/modal-interaction.service';
+import { InteractionService } from '../../interaction/services/interaction.service';
 import { PlaceRouter } from '../place-router';
+import * as _ from 'lodash';
+import { UrlSnapshot } from '../url-snapshot';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
 import * as i2 from "../place-router";
 import * as i3 from "@angular/common";
-import * as i4 from "../../interaction/services/modal-interaction.service";
+import * as i4 from "../../interaction/services/interaction.service";
 var InteractionGuard = /** @class */ (function () {
-    function InteractionGuard(router, injector, placeRouter, angularLocation, modalInteractionService) {
+    function InteractionGuard(router, injector, placeRouter, angularLocation, interactionService) {
         this.router = router;
         this.injector = injector;
         this.placeRouter = placeRouter;
         this.angularLocation = angularLocation;
-        this.modalInteractionService = modalInteractionService;
+        this.interactionService = interactionService;
     }
     /**
      * @param {?} route
@@ -34,10 +36,10 @@ var InteractionGuard = /** @class */ (function () {
     function (route, state) {
         /** @type {?} */
         var url = this.router.parseUrl(state.url);
-        if (!this.modalInteractionService.isActive() && url.root.children[PlaceRouter.INTERACTION_ROUTER_OUTLET]) {
+        if (!this.interactionService.isActive() && url.root.children[UrlSnapshot.INTERACTION_ROUTER_OUTLET]) {
             // This happens if we reload the page or the url was pasted as the route should only be activated
             // after the interaction context has become active.
-            delete url.root.children[PlaceRouter.INTERACTION_ROUTER_OUTLET];
+            delete url.root.children[UrlSnapshot.INTERACTION_ROUTER_OUTLET];
             return url;
         }
         else {
@@ -60,20 +62,26 @@ var InteractionGuard = /** @class */ (function () {
      */
     function (component, currentRoute, currentState, nextState) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var popstateReturnUrl, activity;
+            var currentIds, routeIds, activity;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        popstateReturnUrl = this.placeRouter.navigationSession.startingUrl;
-                        if (!this.modalInteractionService.isActive()) return [3 /*break*/, 2];
+                        if (!this.interactionService.isActive()) return [3 /*break*/, 2];
+                        currentIds = this.interactionService.activeInteractionContextIds.value;
+                        routeIds = this.placeRouter.getActiveInteractionIdsFromUrl(nextState.url);
+                        if (!!_.isEqual(currentIds, routeIds)) return [3 /*break*/, 2];
                         // The activity is still active so the route change was triggered by the back button.
-                        return [4 /*yield*/, this.modalInteractionService.getCurrentActivity()];
+                        return [4 /*yield*/, this.interactionService.getCurrentActivity()];
                     case 1:
                         activity = _a.sent();
                         activity.cancel();
-                        // See ModalInteractionSession#onStart() for the url updating.
-                        return [2 /*return*/, false];
-                    case 2: return [2 /*return*/, true];
+                        _a.label = 2;
+                    case 2: 
+                    // IMPORTANT:
+                    // We always return true, the router state engine will redirect as required.  Return false
+                    // during the guard causes all kinds of grief.  It might be worth trying a redirect here
+                    // again now that our state engine is more thorough.
+                    return [2 /*return*/, true];
                 }
             });
         });
@@ -89,9 +97,9 @@ var InteractionGuard = /** @class */ (function () {
         { type: Injector },
         { type: PlaceRouter },
         { type: Location },
-        { type: ModalInteractionService }
+        { type: InteractionService }
     ]; };
-    /** @nocollapse */ InteractionGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function InteractionGuard_Factory() { return new InteractionGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i2.PlaceRouter), i0.ɵɵinject(i3.Location), i0.ɵɵinject(i4.ModalInteractionService)); }, token: InteractionGuard, providedIn: "root" });
+    /** @nocollapse */ InteractionGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function InteractionGuard_Factory() { return new InteractionGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i2.PlaceRouter), i0.ɵɵinject(i3.Location), i0.ɵɵinject(i4.InteractionService)); }, token: InteractionGuard, providedIn: "root" });
     return InteractionGuard;
 }());
 export { InteractionGuard };
@@ -120,6 +128,6 @@ if (false) {
      * @type {?}
      * @private
      */
-    InteractionGuard.prototype.modalInteractionService;
+    InteractionGuard.prototype.interactionService;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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