@coolon/angular-ui-powerups 0.0.96 → 0.0.98

package/lib/interaction/components/activity-container/activity-container.component.d.ts

@@ -1,10 +1,9 @@
 import { AfterViewInit, EventEmitter, OnInit, QueryList } from '@angular/core';
 import { MatTabGroup } from '@angular/material';
-import { Constructable, MutableListModel } from '@coolon/pectin';
+import { Constructable, MutableListModel, ValueModel } from '@coolon/pectin';
 import { Activity } from '../../activity';
-import { Alert } from '../../alert';
-import { Confirm } from '../../confirm';
 import { InteractionContext } from '../../interaction-context';
+import { InteractionContextBase } from '../../interaction-context-base';
 import { ActivityOutletContext } from '../activity-outlet/activity-outlet-context';
 import { ActivityOutletComponent } from '../activity-outlet/activity-outlet.component';
 /**
@@ -27,25 +26,21 @@ declare class TabContext<D, R, E> implements ActivityOutletContext<D, R, E> {
     onDone(result: R): void;
     onCancel(error: E): void;
 }
-export declare class ActivityContainerComponent<D, R, E> extends InteractionContext implements OnInit, AfterViewInit {
+export declare class ActivityContainerComponent<D, R, E> extends InteractionContextBase implements OnInit, AfterViewInit {
     private readonly throttledNestedActivityFinishEvents;
-    private _initialActivityOutletContext;
+    private readonly _initialActivityOutletContext;
     initialActivityOutletContext: ActivityOutletContext<D, R, E>;
     initialActivityOutletContextEvent: EventEmitter<ActivityOutletContext<D, R, E>>;
     dynamicHeight: boolean;
     tabs: MatTabGroup;
     outlets: QueryList<ActivityOutletComponent<any, any, any>>;
     readonly activityTabs: MutableListModel<TabContext<any, any, any>>;
+    readonly active: ValueModel<boolean>;
     private readonly _activityList;
     constructor();
-    isActive(): boolean;
-    readonly isFinished: boolean;
     ngOnInit(): void;
     ngAfterViewInit(): void;
-    startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
-    alert(alert: Alert): Promise<void>;
-    confirmOrReject(confirm: Confirm): Promise<void>;
-    confirmThen<D1, R1, E1>(confirm: Confirm, activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
+    _startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
     private finishInitialActivity;
     private onNestedActivityFinished;
     private cleanupStaleNestedActivities;

package/lib/interaction/components/inplace-interaction-context/inplace-interaction-context.component.d.ts

@@ -1,20 +1,15 @@
 import { AfterViewInit } from '@angular/core';
 import { Constructable } from '@coolon/pectin';
 import { Activity } from '../../activity';
-import { Alert } from '../../alert';
-import { Confirm } from '../../confirm';
-import { InteractionContext } from '../../interaction-context';
+import { InteractionContextBase } from '../../interaction-context-base';
 import { ActivityContainerComponent } from '../activity-container/activity-container.component';
 import { ActivityOutletContext } from '../activity-outlet/activity-outlet-context';
-export declare class InplaceInteractionContextComponent<D, R, E> extends InteractionContext implements AfterViewInit {
+export declare class InplaceInteractionContextComponent<D, R, E> extends InteractionContextBase implements AfterViewInit {
     interactionContext: ActivityContainerComponent<any, any, any>;
     initialActivityContext: ActivityOutletContext<D, R, E>;
+    private _active;
     constructor();
     ngAfterViewInit(): void;
-    isActive(): boolean;
-    alert(alert: Alert): Promise<void>;
-    confirmOrReject(confirm: Confirm): Promise<void>;
-    confirmThen<D1, R1, E1>(confirm: Confirm, activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
-    startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
+    readonly active: import("@coolon/pectin").ValueModel<boolean>;
     protected _startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
 }

package/lib/interaction/index.d.ts

@@ -5,6 +5,7 @@ export * from "./abstract-activity";
 export * from "./activity";
 export * from "./alert";
 export * from "./confirm";
+export * from "./interaction-context-base";
 export * from "./interaction-context";
 export * from "./interaction.module";
 export * from "./result";
@@ -16,5 +17,6 @@ export * from "./components/confirm-then-dialog/confirm-then-dialog.component";
 export * from "./components/confirmation-dialog/confirmation-dialog.component";
 export * from "./components/inplace-interaction-context/inplace-interaction-context.component";
 export * from "./components/interaction-outlet/interaction-outlet.component";
-export * from "./guards/interaction-guard.service";
+export * from "./services/dialog-interaction-context";
 export * from "./services/dialog-interaction.service";
+export * from "./services/modal-interaction.service";

package/lib/interaction/interaction-context-base.d.ts

@@ -0,0 +1,27 @@
+import { Constructable, ListModel } from '@coolon/pectin';
+import { Activity } from './activity';
+import { Alert } from './alert';
+import { Confirm } from './confirm';
+import { InteractionContext } from './interaction-context';
+export declare abstract class InteractionContextBase extends InteractionContext {
+    /**
+     * Returns the current list of activities that are in progress.
+     * This model is only updated in the next tick after the view has been updated.
+     */
+    private readonly _activityListDelegate;
+    private deferredGetCurrentActivity;
+    protected constructor();
+    protected setActivityList(activityList: ListModel<Activity<any, any>>): void;
+    readonly activityList: ListModel<Activity<any, any, any>>;
+    /**
+     * Returns the activity that is currently active.
+     * This model is only updated in the next tick after the view has been updated.
+     */
+    getCurrentActivity(): Promise<Activity<any, any>>;
+    protected abstract _startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D, disableClose?: boolean): Promise<R>;
+    startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
+    confirm(confirm: Confirm): Promise<boolean>;
+    alert(alert: Alert): Promise<void>;
+    confirmOrReject(confirm: Confirm): Promise<void>;
+    confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
+}

package/lib/interaction/interaction-context.d.ts

@@ -1,28 +1,26 @@
-import { Constructable, GarbageCollector, ListModel } from '@coolon/pectin';
+import { Constructable, Disposable, GarbageCollector, ListModel, ValueModel } from '@coolon/pectin';
 import { Activity } from './activity';
 import { Alert } from './alert';
 import { Confirm } from './confirm';
 export declare abstract class InteractionContext extends GarbageCollector {
+    private readonly activityListeners;
+    abstract readonly activityList: ListModel<Activity<any, any, any>>;
+    abstract readonly active: ValueModel<boolean>;
     /**
-     * Returns the current list of activities that are in progress.
-     * This model is only updated in the next tick after the view has been updated.
+     * Returns true if an activity is currently running.
      */
-    private readonly _activityListDelegate;
-    private deferredGetCurrentActivity;
-    protected constructor();
-    protected setActivityList(activityList: ListModel<Activity<any, any>>): void;
-    readonly activityList: ListModel<Activity<any, any, any>>;
+    isActive(): boolean;
+    addActivityListener(listener: InteractionContext.Listener): Disposable;
+    protected notifyActivityStarted(): void;
+    protected notifyActivityFinished(): void;
     /**
      * Returns the activity that is currently active.
      * This model is only updated in the next tick after the view has been updated.
      */
-    getCurrentActivity(): Promise<Activity<any, any>>;
-    /**
-     * Returns true if an activity is currently running.
-     */
-    abstract isActive(): boolean;
+    abstract getCurrentActivity(): Promise<Activity<any, any>>;
     abstract startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
-    confirm(confirm: Confirm): Promise<boolean>;
+    abstract alert(alert: Alert): Promise<void>;
+    abstract confirm(confirm: Confirm): Promise<boolean>;
     abstract confirmOrReject(confirm: Confirm): Promise<void>;
     /**
      * Presents the confirmation to the user and runs the activity only if the user confirms.
@@ -31,5 +29,10 @@ export declare abstract class InteractionContext extends GarbageCollector {
      * @param data the activity data.
      */
     abstract confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
-    abstract alert(alert: Alert): Promise<void>;
+}
+export declare namespace InteractionContext {
+    interface Listener {
+        onActivityStarted(): void;
+        onActivityFinished(): void;
+    }
 }

package/lib/interaction/services/dialog-interaction-context.d.ts

@@ -0,0 +1,18 @@
+import { MatDialog } from '@angular/material';
+import { MatDialogConfig } from '@angular/material/dialog';
+import { Constructable, ListModel, ValueModel } from '@coolon/pectin';
+import { Activity } from '../activity';
+import { InteractionContextBase } from '../interaction-context-base';
+export declare class DialogInteractionContext extends InteractionContextBase {
+    private readonly dialogService;
+    readonly config: MatDialogConfig<any>;
+    private readonly _activeModel;
+    constructor(dialogService: MatDialog, config: MatDialogConfig<any>);
+    readonly active: ValueModel<boolean>;
+    protected _startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data: D, disableClose?: boolean): Promise<R>;
+    /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param delegate
+     */
+    safelyUpdateActivityListDelegate(delegate: ListModel<Activity<any, any>>): void;
+}

package/lib/interaction/services/dialog-interaction.service.d.ts

@@ -1,33 +1,24 @@
-import { Location } from '@angular/common';
 import { InjectionToken } from '@angular/core';
 import { MatDialog } from '@angular/material';
 import { MatDialogConfig } from '@angular/material/dialog';
-import { Router } from '@angular/router';
-import { Constructable, ListModel, ValueModel } from '@coolon/pectin';
+import { BooleanValueModelChain, Disposable } from '@coolon/pectin';
 import { Activity } from '../activity';
-import { Alert } from '../alert';
-import { Confirm } from '../confirm';
 import { InteractionContext } from '../interaction-context';
+import { DialogInteractionContext } from './dialog-interaction-context';
+import { ModalInteractionService } from './modal-interaction.service';
 export declare const DIALOG_INTERACTION_SERVICE_DEFAULTS: InjectionToken<MatDialogConfig<any>>;
-export declare class DialogInteractionService extends InteractionContext {
+export declare class DialogInteractionService extends ModalInteractionService {
     private readonly dialogService;
-    readonly location: Location;
-    readonly router: Router;
     readonly dialogServiceDefaults: MatDialogConfig<any>;
     readonly matDialogDefaultConfig: MatDialogConfig<any>;
-    private startingGuard;
-    private readonly _inActivityPromise;
-    constructor(dialogService: MatDialog, location: Location, router: Router, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
-    isActive(): boolean;
-    readonly active: ValueModel<boolean>;
-    startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
-    private _startActivity;
-    /**
-     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
-     * @param delegate
-     */
-    safelyUpdateActivityListDelegate(delegate: ListModel<Activity<any, any>>): void;
-    alert(alert: Alert): Promise<void>;
-    confirmOrReject(confirm: Confirm): Promise<void>;
-    confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
+    private _activeInteractionContextModel;
+    readonly active: BooleanValueModelChain;
+    private exclusiveContext;
+    constructor(dialogService: MatDialog, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
+    createInteractionContextFor(disposable: Disposable.Collector): InteractionContext;
+    _createInteractionContext(): InteractionContext;
+    createExclusiveInteractionContext(): InteractionContext;
+    onActivityStarted(dialogInteractionContext: DialogInteractionContext): void;
+    onActivityFinished(dialogInteractionContext: DialogInteractionContext): void;
+    getCurrentActivity(): Promise<Activity<any, any, any>>;
 }

package/lib/interaction/services/modal-interaction.service.d.ts

@@ -0,0 +1,15 @@
+import { Disposable, GarbageCollector, ValueModel } from '@coolon/pectin';
+import { Activity } from '../activity';
+import { InteractionContext } from '../interaction-context';
+export declare abstract class ModalInteractionService extends GarbageCollector {
+    private readonly _activityListeners;
+    constructor();
+    abstract readonly active: ValueModel<boolean>;
+    isActive(): boolean;
+    abstract createInteractionContextFor(disposable: Disposable.Collector): InteractionContext;
+    abstract createExclusiveInteractionContext(): InteractionContext;
+    abstract getCurrentActivity(): Promise<Activity<any, any, any>>;
+    addActivityListener(listener: InteractionContext.Listener): Disposable;
+    protected notifyActivityStarted(): void;
+    protected notifyActivityFinished(): void;
+}

package/lib/place/components/place-outlet/place-outlet.component.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter, OnInit } from '@angular/core';
 import { ActivatedRoute, Router, RouterOutlet } from '@angular/router';
-import { BooleanValueModelChain, Constructable, ListModel, ValueModel, ValueModelChain } from '@coolon/pectin';
+import { Constructable, ListModel, ValueModel, ValueModelChain } from '@coolon/pectin';
 import { DisposableComponent } from '../../../components/disposable-component';
 import { PlaceComponent } from '../../place-component';
 import { PlaceConfig } from '../../place-config';
@@ -17,7 +17,6 @@ export declare class PlaceOutletComponent extends DisposableComponent implements
     readonly placeChanged: EventEmitter<PlaceComponent>;
     routerOut: RouterOutlet;
     private readonly _activePlace;
-    private readonly _previousPlace;
     private readonly _activePlaceVisitModel;
     private readonly _inOutletActivation;
     private readonly _inOutletDeactivation;
@@ -29,8 +28,6 @@ export declare class PlaceOutletComponent extends DisposableComponent implements
     readonly placeAnimationOrder: ValueModelChain<number>;
     private initialPlaceIndex;
     private routerVisit;
-    readonly ready: ValueModelChain<boolean>;
-    readonly enableAnimation: BooleanValueModelChain;
     constructor(router: Router, placeRouter: PlaceRouter, placeConfig: PlaceConfig, parentOutlet: PlaceOutletComponent);
     ngOnInit(): void;
     getAnimationOrder(): number;

package/lib/place/guards/abstract-place.guard.d.ts

@@ -0,0 +1,19 @@
+import { Injector } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, CanDeactivate, Router, RouterStateSnapshot, UrlSerializer, UrlTree } from '@angular/router';
+import { PlaceComponent } from '../place-component';
+import { PlaceDefinition } from '../place-definition';
+import { PlaceHistory } from '../place-history';
+import { PlaceRouter } from '../place-router';
+export declare abstract class AbstractPlaceGuard implements CanActivate, CanDeactivate<PlaceComponent> {
+    private readonly router;
+    private urlSerializer;
+    private readonly placeRouter;
+    private readonly placeHistory;
+    private readonly injector;
+    constructor(router: Router, urlSerializer: UrlSerializer, placeRouter: PlaceRouter, placeHistory: PlaceHistory, injector: Injector);
+    canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree>;
+    canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean>;
+    protected authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, canActivate: (placeDefinition: PlaceDefinition) => Promise<boolean | UrlTree>): Promise<boolean | UrlTree>;
+    isAuthorised(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree>;
+    abstract getAuthGuard(injector: Injector): CanActivate;
+}

package/lib/place/guards/consolidated-param-map.d.ts

@@ -0,0 +1,14 @@
+import { ParamMap, UrlSegment } from '@angular/router';
+/**
+ * This a work around for the fact that an activated route with multiple segments doesn't
+ * include the segment params in the paramMap as well as each segment returns an empty
+ * param map even when `parameter`s has content.
+ */
+export declare class ConsolidatedParameterMap implements ParamMap {
+    private paramMaps;
+    constructor(paramMap: ParamMap, urlSegments: UrlSegment[]);
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string): boolean;
+    readonly keys: string[];
+}

package/lib/{interaction/guards/interaction-guard.service.d.ts → place/guards/interaction.guard.d.ts}

@@ -1,13 +1,17 @@
+import { Location } from '@angular/common';
 import { Injector } from '@angular/core';
 import { ActivatedRouteSnapshot, CanActivate, CanDeactivate, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
 import { Observable } from 'rxjs';
 import { NoopComponent } from '../../components/noop/noop.component';
-import { InteractionContext } from '../interaction-context';
+import { ModalInteractionService } from '../../interaction/services/modal-interaction.service';
+import { PlaceRouter } from '../place-router';
 export declare class InteractionGuard implements CanDeactivate<NoopComponent>, CanActivate {
     private router;
     private injector;
-    private readonly interactionContext;
-    constructor(router: Router, injector: Injector, interactionContext: InteractionContext);
+    private placeRouter;
+    private readonly angularLocation;
+    private readonly modalInteractionService;
+    constructor(router: Router, injector: Injector, placeRouter: PlaceRouter, angularLocation: Location, modalInteractionService: ModalInteractionService);
     canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
-    canDeactivate(component: NoopComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    canDeactivate(component: NoopComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean | UrlTree>;
 }

package/lib/place/guards/navigation-state.d.ts

@@ -0,0 +1,96 @@
+import { Location } from '@angular/common';
+import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart, Router, RouterEvent } from '@angular/router';
+import { GarbageCollector } from '@coolon/pectin';
+import { InteractionContext } from '../../interaction/interaction-context';
+import { ModalInteractionService } from '../../interaction/services/modal-interaction.service';
+import { PlaceComponent } from '../place-component';
+import { PlaceDefinition } from '../place-definition';
+import { UrlSnapshot } from '../url-snapshot';
+import { Visit } from '../visit';
+export declare abstract class NavigationState extends GarbageCollector {
+    protected readonly context: NavigationState.Context;
+    private _visits;
+    abstract readonly isPopState: boolean;
+    abstract readonly active: boolean;
+    abstract readonly startingUrl: string;
+    constructor(context: NavigationState.Context);
+    readonly interactionContext: InteractionContext;
+    storeVisit(visit: Visit): void;
+    getVisitFor(placeDef: PlaceDefinition): Visit;
+    abstract onStart(event: NavigationStart): NavigationState;
+    abstract onCancel(event: NavigationCancel): NavigationState;
+    abstract onError(event: NavigationError): NavigationState;
+    abstract onEnd(event: NavigationEnd): NavigationState;
+    onBackClickedDuringNavigationInteraction(newUrl: string): NavigationState;
+    abstract canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean>;
+    getVisits(): Visit[];
+    protected illegalTransition<R>(message: string | RouterEvent): R;
+    protected currentRouterUrl(): string;
+    protected createActiveSession(event: NavigationStart): NavigationState.Active;
+    protected updateLocation(url: any): void;
+    toString(): string;
+}
+export declare namespace NavigationState {
+    class Context {
+        readonly router: Router;
+        readonly modalInteractionService: ModalInteractionService;
+        readonly angularLocation: Location;
+        readonly notifySuccess: (success: NavigationState) => void;
+        constructor(router: Router, modalInteractionService: ModalInteractionService, angularLocation: Location, notifySuccess: (success: NavigationState) => void);
+    }
+    class Idle extends NavigationState {
+        readonly isPopState: boolean;
+        readonly active = false;
+        readonly startingUrl: any;
+        constructor(context: Context);
+        canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean>;
+        onStart(event: NavigationStart): NavigationState;
+        onCancel(event: NavigationCancel): NavigationState;
+        onEnd(event: NavigationEnd): NavigationState;
+        onError(event: NavigationError): NavigationState;
+    }
+    class Active extends NavigationState {
+        readonly isPopState: boolean;
+        readonly startingUrl: string;
+        readonly active = true;
+        private componentDeactivationHandlers;
+        private _interactionContext;
+        constructor(context: Context, isPopState: boolean, startingUrl: string);
+        readonly interactionContext: InteractionContext;
+        onStart(event: NavigationStart): NavigationState;
+        onEnd(event: NavigationEnd): NavigationState;
+        onCancel(event: NavigationCancel): NavigationState;
+        onError(event: NavigationError): NavigationState;
+        onBackClickedDuringNavigationInteraction(locationTriggerUrl: string): NavigationState;
+        canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean>;
+        private detachInteractionContext;
+        toString(): string;
+    }
+    class ModalInteractionSession extends NavigationState {
+        readonly startingUrl: string;
+        readonly active = false;
+        readonly isPopState = false;
+        static hasInteraction(url: string): boolean;
+        constructor(context: Context, startingUrl: string);
+        onStart(event: NavigationStart): NavigationState;
+        onCancel(event: NavigationCancel): NavigationState;
+        onEnd(event: NavigationEnd): NavigationState;
+        onError(event: NavigationError): NavigationState;
+        canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean>;
+    }
+    class CancelledDuringNavigationInteraction extends NavigationState {
+        readonly startingUrl: string;
+        readonly locationChangeTriggerUrl: string;
+        readonly active = false;
+        readonly isPopState: boolean;
+        private capturedFauxRouterStart;
+        constructor(context: Context, startingUrl: string, locationChangeTriggerUrl: string);
+        canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean>;
+        onCancel(event: NavigationCancel): NavigationState;
+        onEnd(event: NavigationEnd): NavigationState;
+        onError(event: NavigationError): NavigationState;
+        onStart(event: NavigationStart): NavigationState;
+        ignore(event: RouterEvent, reason?: string): NavigationState;
+        toString(): string;
+    }
+}

package/lib/place/guards/place-component-deactivation-handler.d.ts

@@ -0,0 +1,12 @@
+import { PlaceComponent } from '../place-component';
+import { UrlSnapshot } from '../url-snapshot';
+import { NavigationState } from './navigation-state';
+export declare class PlaceComponentDeactivationHandler {
+    readonly component: PlaceComponent;
+    readonly navigationSession: NavigationState;
+    private canDeactivatePromise;
+    constructor(component: PlaceComponent, navigationSession: NavigationState);
+    canDeactivate(nextState: UrlSnapshot): Promise<boolean>;
+    protected canDeactivateComponent(nextState: UrlSnapshot): Promise<boolean>;
+    protected isNotJustAChangeInRouteId(nextState: UrlSnapshot): boolean;
+}

package/lib/place/index.d.ts

@@ -2,7 +2,6 @@
  * @file Automatically generated by barrelsby.
  */
 export * from "./nav-item";
-export * from "./navigation-session";
 export * from "./place-component";
 export * from "./place-config";
 export * from "./place-definition";
@@ -10,6 +9,7 @@ export * from "./place-history";
 export * from "./place-router";
 export * from "./place.decorator";
 export * from "./place.module";
+export * from "./url-snapshot";
 export * from "./visit";
 export * from "./components/abstract-place-navigation.component";
 export * from "./components/busy-overlay/busy-overlay.component";
@@ -18,10 +18,12 @@ export * from "./components/list-place-nav/list-place-nav.component";
 export * from "./components/place-outlet/place-outlet.component";
 export * from "./components/place-outlet/route-animations";
 export * from "./components/tabbed-place-navigation/tabbed-place-navigation.component";
-export * from "./guards/abstract-enter-place.guard";
-export * from "./guards/leave-place.guard";
+export * from "./guards/abstract-place.guard";
+export * from "./guards/consolidated-param-map";
+export * from "./guards/interaction.guard";
+export * from "./guards/navigation-state";
 export * from "./guards/noop-auth-guard.service";
-export * from "./places/noop-gateway-place.component";
+export * from "./guards/place-component-deactivation-handler";
 export * from "./route/formatter";
 export * from "./route/json-types";
 export * from "./route/parameter-decorators";

package/lib/place/place-component.d.ts

@@ -10,7 +10,7 @@ export declare const ROUTE_PARAMETER_LIST_KEY: unique symbol;
 export declare class PlaceComponent extends DisposableComponent {
     private visit;
     interactionContext?: InteractionContext;
-    canDeactivate?(): boolean | Promise<boolean>;
+    canDeactivate?(interactionContext: InteractionContext): boolean | Promise<boolean>;
     constructor();
     initialiseBindings(visit: ValueModel<Visit>): void;
     private installBinding;

package/lib/place/place-router.d.ts

@@ -1,28 +1,28 @@
 import { Location } from '@angular/common';
-import { ActivatedRoute, ActivatedRouteSnapshot, NavigationExtras, Router, RouterStateSnapshot, UrlSegment, UrlSerializer, UrlTree } from '@angular/router';
-import { BooleanValueModelChain, GarbageCollector, HasOneIndexChain, ListModel, ValueModel } from '@coolon/pectin';
+import { ActivatedRoute, ActivatedRouteSnapshot, Router, RouterStateSnapshot, UrlSerializer } from '@angular/router';
+import { GarbageCollector, HasOneIndexChain, ListModel, ValueModel } from '@coolon/pectin';
 import { InteractionContext } from '../interaction/interaction-context';
-import { NavigationSession } from './navigation-session';
-import { PlaceDefinition } from './place-definition';
+import { ModalInteractionService } from '../interaction/services/modal-interaction.service';
+import { NavigationState } from './guards/navigation-state';
 import { PlaceHistory } from './place-history';
+import { UrlSnapshot } from './url-snapshot';
 import { Visit } from './visit';
 export declare class PlaceRouter extends GarbageCollector {
     private readonly router;
     private readonly urlSerializer;
-    private interactionContext;
-    readonly angularLocation: Location;
-    readonly placeHistory: PlaceHistory;
+    private readonly angularLocation;
+    private readonly placeHistory;
+    private readonly modalInteractionService;
     private firstRoute;
     private readonly _navigationSessionModel;
     private readonly _activeVisits;
-    readonly navigationSessionActive: BooleanValueModelChain;
+    readonly navigationSessionActive: ValueModel<boolean>;
     readonly activeVisitIndex: HasOneIndexChain<'placeDefinition', Visit>;
-    private readonly navigationSessionFactory;
-    private initialRedirectStarted;
-    private initialRedirectFinished;
-    constructor(router: Router, urlSerializer: UrlSerializer, interactionContext: InteractionContext, angularLocation: Location, placeHistory: PlaceHistory);
-    readonly navigationSession: NavigationSession;
-    readonly navigationSessionModel: ValueModel<NavigationSession>;
+    private _navigationSessionContext;
+    constructor(router: Router, urlSerializer: UrlSerializer, angularLocation: Location, placeHistory: PlaceHistory, modalInteractionService: ModalInteractionService);
+    private processNavigationSuccess;
+    readonly navigationSession: NavigationState;
+    readonly navigationSessionModel: ValueModel<NavigationState>;
     readonly activeVisits: ListModel<Visit>;
     /**
      *  placeRouter.navigate(placeDestinations.somePlace.createVisit(routeId, ...visitParams));
@@ -31,29 +31,21 @@ export declare class PlaceRouter extends GarbageCollector {
     navigate(visit: Visit, options?: {
         relativeTo: ActivatedRoute;
     }): Promise<void>;
-    createRedirectFor(visit: Visit, navigationExtras?: NavigationExtras): UrlTree;
     pushVisitChangesToRoute(activatedRoute: ActivatedRoute, previous: Visit, next: Visit): Promise<void>;
-    doNavigation(visit: Visit, customNavigation: (router: Router) => any): Promise<void>;
+    doNavigation(visit: Visit, runNavigationCommands: (router: Router) => any): Promise<void>;
+    protected runStateTransition(transition: (navigationSession: NavigationState) => NavigationState): void;
     private createRouteParameters;
-    private onAngularRouterStarted;
-    private onAngularRouterFinished;
     extractChildPath(activatedRoute: ActivatedRouteSnapshot): any[];
-    parseUrl(snapshot: RouterStateSnapshot): PlaceRouter.UrlHelper;
-    performInitialNavigationIntercept(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): UrlTree;
-    isInitialNavigation(): boolean;
+    parseUrl(snapshot: RouterStateSnapshot): UrlSnapshot;
 }
 export declare namespace PlaceRouter {
-    class UrlHelper {
-        private urlTree;
-        constructor(urlTree: UrlTree);
-        cloneUrlSegmentList(): UrlSegment[];
-        updateVisitSegments(visit: Visit): UrlSegment[];
-        /**
-         * Converts the visit into segments.  Please not that these segments are not e
-         * @param visit
-         */
-        convertToUrlSegments(visit: Visit): UrlSegment[];
-        createRedirectCommandsFor(visit: Visit): any[];
-        includesPathOf(placeDef: PlaceDefinition): UrlSegment;
+    const INTERACTION_ROUTER_OUTLET = "aup-interaction";
+    class InteractionRouteMediator implements InteractionContext.Listener {
+        readonly navigationSessionModelActive: ValueModel<boolean>;
+        readonly router: Router;
+        constructor(navigationSessionModelActive: ValueModel<boolean>, router: Router);
+        readonly isNavigating: boolean;
+        onActivityStarted(): void;
+        onActivityFinished(): void;
     }
 }

package/lib/place/url-snapshot.d.ts

@@ -0,0 +1,16 @@
+import { UrlSegment, UrlTree } from '@angular/router';
+import { PlaceDefinition } from './place-definition';
+import { Visit } from './visit';
+export declare class UrlSnapshot {
+    readonly urlTree: UrlTree;
+    constructor(urlTree: UrlTree);
+    cloneUrlSegmentList(): UrlSegment[];
+    updateVisitSegments(visit: Visit): UrlSegment[];
+    /**
+     * Converts the visit into segments.  Please not that these segments are not e
+     * @param visit
+     */
+    convertToUrlSegments(visit: Visit): UrlSegment[];
+    createRedirectCommandsFor(visit: Visit): any[];
+    includesPathOf(placeDef: PlaceDefinition): UrlSegment;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coolon/angular-ui-powerups",
-  "version": "0.0.96",
+  "version": "0.0.98",
   "schematics": "./schematics/collection.json",
   "dependencies": {
     "ts-morph": "^3.1.3",

package/schematics/place-routes/place-def.js

@@ -96,8 +96,8 @@ class PlaceDef {
         bits.push(`{
     path: "${this.fullPath}",
     component: ${this.componentClass},
-    canActivate: [EnterPlaceGuard],
-    canDeactivate: [LeavePlaceGuard],
+    canActivate: [PlaceGuard],
+    canDeactivate: [PlaceGuard],
     children:[
       ${this.getChildRouteTemplates().join(', ')}
     ]