@coolon/angular-ui-powerups 0.0.126 → 0.0.128

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

@@ -1,19 +1,20 @@
 import { Injector } from '@angular/core';
-import { ActivatedRouteSnapshot, CanActivate, CanDeactivate, Router, RouterStateSnapshot, UrlSerializer, UrlTree } from '@angular/router';
+import { ActivatedRouteSnapshot, CanActivate, CanDeactivate, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
 import { InteractionService } from '../../interaction/services/interaction.service';
 import { PlaceComponent } from '../place-component';
 import { PlaceDefinition } from '../place-definition';
 import { PlaceHistory } from '../place-history';
 import { PlaceRouter } from '../place-router';
+import { UrlService } from '../url-service';
 import { UrlSnapshot } from '../url-snapshot';
 export declare abstract class PlaceGuard implements CanActivate, CanDeactivate<PlaceComponent> {
     private readonly router;
-    private urlSerializer;
+    private urlService;
     private readonly placeRouter;
     private readonly placeHistory;
     private readonly interactionService;
     private readonly injector;
-    constructor(router: Router, urlSerializer: UrlSerializer, placeRouter: PlaceRouter, placeHistory: PlaceHistory, interactionService: InteractionService, injector: Injector);
+    constructor(router: Router, urlService: UrlService, placeRouter: PlaceRouter, placeHistory: PlaceHistory, interactionService: InteractionService, injector: Injector);
     canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree>;
     canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Promise<boolean | UrlTree>;
     private handleGuardResult;

package/lib/place/index.d.ts

@@ -9,6 +9,7 @@ export * from "./place-history";
 export * from "./place-router";
 export * from "./place.decorator";
 export * from "./place.module";
+export * from "./url-service";
 export * from "./url-snapshot";
 export * from "./visit";
 export * from "./components/abstract-place-navigation.component";
@@ -19,10 +20,22 @@ 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/consolidated-param-map";
-export * from "./guards/navigation-state";
 export * from "./guards/noop-auth-guard.service";
-export * from "./guards/place-component-deactivation-handler";
 export * from "./guards/place.guard";
+export * from "./navigation/place-component-deactivation-handler";
+export * from "./navigation/session/abstract-pop-state-navigation";
+export * from "./navigation/session/navigating";
+export * from "./navigation/session/navigation-context";
+export * from "./navigation/session/navigation-session";
+export * from "./navigation/session/pop-state-navigation";
+export * from "./navigation/session/event-cleanup/event-clean-up-session";
+export * from "./navigation/session/event-cleanup/wait-until-leaving-interaction-transition-cancelled";
+export * from "./navigation/session/event-cleanup/wait-until-link-triggered-interaction-cancelation-finishes";
+export * from "./navigation/session/event-cleanup/wait-until-popstate-during-can-deactivate-transition-finishes";
+export * from "./navigation/session/interactions/navigating-during-interaction";
+export * from "./navigation/session/interactions/pop-state-during-interaction-navigation";
+export * from "./navigation/session/interactions/remove-last-interaction-from-url-navigation-session";
+export * from "./navigation/session/interactions/synchronise-interaction-context-ids-with-route";
 export * from "./route/formatter";
 export * from "./route/json-types";
 export * from "./route/parameter-decorators";

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

@@ -0,0 +1,22 @@
+import { PlaceComponent } from '../place-component';
+import { UrlSnapshot } from '../url-snapshot';
+import { NavigationSession } from './session/navigation-session';
+/**
+ * This class handles the logic around canDeactivate for a given router state transition.  It's core responsibilities are:
+ * 1. Ensure we only ask the component to deactivate once on a given navigation cycle (since visit sanitisation can result in multiple round trips to through the router.)
+ * 2. Ensure only the primary place component is asked when there are nested places.  The primary component is the one at the top
+ *    of the routing change tree.
+ * 3. Automatically handle standard interaction scenarios on the components behalf.
+ */
+export declare class PlaceComponentDeactivationHandler {
+    readonly component: PlaceComponent;
+    readonly navigationSession: NavigationSession;
+    readonly isPrimaryComponent: boolean;
+    private canDeactivatePromise;
+    constructor(component: PlaceComponent, navigationSession: NavigationSession, isPrimaryComponent: boolean);
+    readonly routerInteractionAdapter: import("../../interaction").InteractionServiceRoutingAdapter;
+    readonly urlService: import("..").UrlService;
+    canDeactivate(currentUrl: UrlSnapshot, nextState: UrlSnapshot): Promise<boolean | UrlSnapshot>;
+    protected canDeactivateComponent(currentUrl: UrlSnapshot, nextState: UrlSnapshot): Promise<UrlSnapshot | boolean>;
+    protected isNotJustAChangeInRouteId(nextState: UrlSnapshot): boolean;
+}

package/lib/place/navigation/session/abstract-pop-state-navigation.d.ts

@@ -0,0 +1,9 @@
+import { NavigationContext } from './navigation-context';
+import { NavigationSession } from './navigation-session';
+export declare abstract class AbstractPopStateNavigation extends NavigationSession {
+    readonly poppedHistoryUrl: string;
+    readonly isPopState = true;
+    debugPropertyKeys: string[];
+    constructor(context: NavigationContext, startingUrl: string, poppedHistoryUrl: string);
+    repairBrowserHistoryAndUrlAfterGuardCancellation(): void;
+}

package/lib/place/navigation/session/event-cleanup/event-clean-up-session.d.ts

@@ -0,0 +1,4 @@
+import { NavigationSession } from '../navigation-session';
+export declare abstract class EventCleanUpSession extends NavigationSession {
+    handleCanDeactivateCancelledEventScenario(newUrl: string): void;
+}

package/lib/place/navigation/session/event-cleanup/wait-until-leaving-interaction-transition-cancelled.d.ts

@@ -0,0 +1,27 @@
+import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart } from '@angular/router';
+import { PlaceComponent } from '../../../place-component';
+import { UrlSnapshot } from '../../../url-snapshot';
+import { NavigationContext } from '../navigation-context';
+import { EventCleanUpSession } from './event-clean-up-session';
+/**
+ * The sequence of router events are:
+ * NavigationError -> url = url of navigation link
+ * NavigationEnd
+ * onPopState url = Our currentUrl sans and interaction query params
+ * NavigationCancel url == same as above.
+ */
+export declare class WaitUntilLeavingInteractionTransitionCancelled extends EventCleanUpSession {
+    readonly locationChangeTriggerUrl: string;
+    readonly isPopState = false;
+    firstCancelHandled: boolean;
+    popStateHandled: boolean;
+    popStateEventUrl: string;
+    debugPropertyKeys: string[];
+    constructor(context: NavigationContext, startingUrl: string, locationChangeTriggerUrl: string);
+    onRouterStarted(event: NavigationStart): void;
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterEnd(event: NavigationEnd): void;
+    onRouterError(event: NavigationError): void;
+    onPopState(event: NavigationStart): void;
+    canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot>;
+}

package/lib/place/navigation/session/event-cleanup/wait-until-link-triggered-interaction-cancelation-finishes.d.ts

@@ -0,0 +1,43 @@
+import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart } from '@angular/router';
+import { PlaceComponent } from '../../../place-component';
+import { UrlSnapshot } from '../../../url-snapshot';
+import { EventCleanUpSession } from './event-clean-up-session';
+import { NavigationContext } from '../navigation-context';
+/**
+ * This state handles the scenario where a link navigation triggered an interaction and the user clicked back a to cancel it.
+ * The routing event sequence is different depending on the link that was clicked.
+ *
+ * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl === cancel.url
+ * -> NavigationEnd
+ *
+ * Otherwise if the link is different from teh history location then the sequence is:
+ *
+ * -> Idle -> NavigationTransition
+ * -> confirm dialog shown.
+ * -> click back
+ * -> NavigationCancel -> clickedLinkUrl !== cancel.url
+ * -> NavigationEnd
+ * -> PopState
+ * -> NavigationCancel
+ */
+export declare class WaitUntilLinkTriggeredNavigationInteractionCancellationEventsFinish extends EventCleanUpSession {
+    readonly clickedLinkUrl: string;
+    readonly isPopState = false;
+    firstCancelEventUrl: string;
+    popStateEventUrl: string;
+    clickedLinkMatchedBackButtonUrl: boolean;
+    debugPropertyKeys: string[];
+    constructor(context: NavigationContext, startingUrl: string, clickedLinkUrl: string);
+    onRouterStarted(event: NavigationStart): void;
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterEnd(event: NavigationEnd): void;
+    onRouterError(event: NavigationError): void;
+    onPopState(event: NavigationStart): void;
+    finaliseRouting(): any;
+    canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot>;
+}

package/lib/place/navigation/session/event-cleanup/wait-until-popstate-during-can-deactivate-transition-finishes.d.ts

@@ -0,0 +1,33 @@
+import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart } from '@angular/router';
+import { PlaceComponent } from '../../../place-component';
+import { UrlSnapshot } from '../../../url-snapshot';
+import { NavigationContext } from '../navigation-context';
+import { EventCleanUpSession } from './event-clean-up-session';
+/**
+ * This state handles the scenario where a pop state triggered and interaction and the user clickeb back a second time to cancel it.
+ * The sequence of routing events/state transitions is as follows.
+ * -> Idle -> PopStateTransition (poppedHistoryUrl == page to go to, startingUrl = page to stay on )
+ * -> confirm dialog shown.
+ * -> click back
+ * -> PopStateTransition -> CancelledDuringBackButtonNavigationInteraction(trigger url is the page before the popped history url)
+ * -> NavigationCancel (for the previous back)
+ * -> PopState
+ * -> NavigationCancel
+ */
+export declare class WaitUntilPopStateDuringCanDeactivateInteractionFinishes extends EventCleanUpSession {
+    readonly locationChangeTriggerUrl: string;
+    readonly poppedHistoryUrl: string;
+    readonly isPopState = false;
+    firstCancelHandled: boolean;
+    popStateHandled: boolean;
+    popStateEventUrl: string;
+    debugPropertyKeys: string[];
+    private parentPageUrl;
+    constructor(context: NavigationContext, startingUrl: string, locationChangeTriggerUrl: string, poppedHistoryUrl: string);
+    onRouterStarted(event: NavigationStart): void;
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterEnd(event: NavigationEnd): void;
+    onRouterError(event: NavigationError): void;
+    onPopState(event: NavigationStart): void;
+    canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot>;
+}

package/lib/place/navigation/session/interactions/navigating-during-interaction.d.ts

@@ -0,0 +1,15 @@
+import { NavigationCancel, NavigationEnd, NavigationError } from '@angular/router';
+import { NavigationSession } from '../navigation-session';
+/**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into
+ *       different states for different scenarios, e.g. starting model, starting model during route guard etc.
+ */
+export declare class NavigatingDuringInteraction extends NavigationSession {
+    readonly isPopState = false;
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterError(event: NavigationError): void;
+    onRouterEnd(event: NavigationEnd): void;
+    handleCanDeactivateCancelledEventScenario(locationTriggerUrl: string): void;
+}

package/lib/place/navigation/session/interactions/pop-state-during-interaction-navigation.d.ts

@@ -0,0 +1,17 @@
+import { NavigationCancel, NavigationEnd } from '@angular/router';
+import { AbstractPopStateNavigation } from '../abstract-pop-state-navigation';
+import { NavigationContext } from '../navigation-context';
+/**
+ * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
+ * happily ignore interaction contexts.
+ */
+export declare class PopStateDuringInteractionNavigation extends AbstractPopStateNavigation {
+    constructor(context: NavigationContext, startingUrl: string, poppedHistoryUrl: string);
+    /**
+     * Invoked when the place refuses to deactivate because of an unfinished interaction.
+     * @param event
+     */
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterEnd(event: NavigationEnd): void;
+    handleCanDeactivateCancelledEventScenario(newUrl: string): void;
+}

package/lib/place/navigation/session/interactions/remove-last-interaction-from-url-navigation-session.d.ts

@@ -0,0 +1,24 @@
+import { NavigationCancel, NavigationEnd, NavigationStart } from '@angular/router';
+import { NavigationContext } from '../navigation-context';
+import { NavigationSession } from '../navigation-session';
+/**
+ * This session tracks the process of removing the last interaction context from the URL and provides a promise
+ * the resolves when the process and completed.  This case is special as the process involves a regular routing cycle
+ * followed by a call to location.back().  The later triggers a url change with no other routing events.  So this
+ * class tracks when the first routing cycle finishes and then waits for the subsequent lone url change event.
+ */
+export declare class RemoveLastInteractionFromUrlNavigationSession extends NavigationSession {
+    readonly isPopState = true;
+    debugPropertyKeys: string[];
+    private finished;
+    private gotPopState;
+    constructor(context: NavigationContext, startingUrl: string);
+    onPopState(event: NavigationStart): void;
+    onRouterStarted(event: NavigationStart): void;
+    onRouterCancelled(event: NavigationCancel): void;
+    onUrlChange(url: string): void;
+    private finishUp;
+    onRouterEnd(event: NavigationEnd): void;
+    handleCanDeactivateCancelledEventScenario(locationTriggerUrl: string): void;
+    readonly finishedPromise: Promise<boolean>;
+}

package/lib/place/navigation/session/interactions/synchronise-interaction-context-ids-with-route.d.ts

@@ -0,0 +1,15 @@
+import { NavigationCancel, NavigationEnd } from '@angular/router';
+import { NavigationContext } from '../navigation-context';
+import { NavigationSession } from '../navigation-session';
+export declare class SynchroniseInteractionContextIdsWithRoute extends NavigationSession {
+    readonly wasTriggeredByPopState: boolean;
+    readonly isPopState = false;
+    constructor(context: NavigationContext, startingUrl: string, wasTriggeredByPopState: boolean);
+    notifyActive(): void;
+    onRouterEnd(event: NavigationEnd): void;
+    onRouterCancelled(event: NavigationCancel): void;
+    syncInteractionIdsWithRouter(): void;
+    addActivityContextToRoute(activeInteractionContextIds: string[], isFirst: boolean): void;
+    removeActivityContextFromRoute(activeInteractionContextId: string[]): void;
+    handleCanDeactivateCancelledEventScenario(newUrl: string): void;
+}

package/lib/place/navigation/session/navigating.d.ts

@@ -0,0 +1,11 @@
+import { NavigationCancel, NavigationEnd, NavigationError } from '@angular/router';
+import { NavigationSession } from './navigation-session';
+export declare class Navigating extends NavigationSession {
+    readonly isPopState = false;
+    debugPropertyKeys: string[];
+    private urlAfterRedirects;
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterError(event: NavigationError): void;
+    onRouterEnd(event: NavigationEnd): void;
+    handleCanDeactivateCancelledEventScenario(newUrl: string): void;
+}

package/lib/place/navigation/session/navigation-context.d.ts

@@ -0,0 +1,28 @@
+import { InteractionServiceRoutingAdapter } from '../../../interaction/services/interaction-service-routing-adapter';
+import { UrlService } from '../../url-service';
+import { UrlSnapshot } from '../../url-snapshot';
+import { Visit } from '../../visit';
+import { NavigationSession } from './navigation-session';
+export interface NavigationContext {
+    readonly urlService: UrlService;
+    readonly routerInteractionAdapter: InteractionServiceRoutingAdapter;
+    finishRoutingSession(visits?: Visit[]): any;
+    transitionTo(newState: NavigationSession): any;
+    navigateByUrl(urlSnapshot: UrlSnapshot, options: {
+        replaceUrl: boolean;
+    }): Promise<boolean>;
+}
+export declare namespace NavigationContext {
+    class Impl implements NavigationContext {
+        readonly urlService: UrlService;
+        readonly routerInteractionAdapter: InteractionServiceRoutingAdapter;
+        readonly navigateByUrl: (urlSnapshot: UrlSnapshot, options: {
+            replaceUrl: boolean;
+        }) => Promise<boolean>;
+        readonly transitionTo: (newState: NavigationSession) => void;
+        readonly finishRoutingSession: (visits?: Visit[]) => void;
+        constructor(urlService: UrlService, routerInteractionAdapter: InteractionServiceRoutingAdapter, navigateByUrl: (urlSnapshot: UrlSnapshot, options: {
+            replaceUrl: boolean;
+        }) => Promise<boolean>, transitionTo: (newState: NavigationSession) => void, finishRoutingSession: (visits?: Visit[]) => void);
+    }
+}

package/lib/place/navigation/session/navigation-session.d.ts

@@ -0,0 +1,51 @@
+import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart, RouterEvent } from '@angular/router';
+import { GarbageCollector } from '@coolon/pectin';
+import { InteractionContext } from '../../../interaction/interaction-context';
+import { InteractionServiceRoutingAdapter } from '../../../interaction/services/interaction-service-routing-adapter';
+import { PlaceComponent } from '../../place-component';
+import { PlaceDefinition } from '../../place-definition';
+import { UrlService } from '../../url-service';
+import { UrlSnapshot } from '../../url-snapshot';
+import { Visit } from '../../visit';
+import { NavigationContext } from './navigation-context';
+/**
+ * Transient states
+ */
+export declare abstract class NavigationSession extends GarbageCollector {
+    readonly context: NavigationContext;
+    readonly startingUrl: string;
+    debugPropertyKeys: string[];
+    private _visits;
+    private componentDeactivationHandlers;
+    abstract readonly isPopState: boolean;
+    private _interactionContext;
+    constructor(context: NavigationContext, startingUrl: string);
+    readonly name: string;
+    readonly urlService: UrlService;
+    readonly interactionServiceAdapter: InteractionServiceRoutingAdapter;
+    storeVisit(visit: Visit): void;
+    getVisitFor(placeDef: PlaceDefinition): Visit;
+    readonly canDeactivateInteractionContext: InteractionContext;
+    notifyActive(): void;
+    onRouterStarted(event: NavigationStart): void;
+    onUrlChange(url: string): void;
+    onPopState(event: NavigationStart): void;
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterError(event: NavigationError): void;
+    onRouterEnd(event: NavigationEnd): void;
+    getVisits(): Visit[];
+    protected illegalTransition<R>(message: string | RouterEvent): R;
+    protected currentRouterUrl(): string;
+    resetBrowserLocation(url: any, options?: {
+        replaceCurrent: boolean;
+    }): void;
+    protected repairBrowserHistoryAndUrlAfterGuardCancellation(poppedHistoryToReplace: string, activeUrl: string): void;
+    ignore(event: RouterEvent, reason?: string): void;
+    toString(): string;
+    protected debugState(properties?: string[]): string;
+    canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot>;
+    cancelCanDeactivateInteraction(newUrl: string): void;
+    abstract handleCanDeactivateCancelledEventScenario(newUrl: string): void;
+    protected reinstateUrlAfterAngularChangedItOnCancellation(url: string): void;
+    protected detachCanDeactivateInteractionContext(): InteractionContext;
+}

package/lib/place/navigation/session/pop-state-navigation.d.ts

@@ -0,0 +1,7 @@
+import { NavigationCancel, NavigationEnd } from '@angular/router';
+import { AbstractPopStateNavigation } from './abstract-pop-state-navigation';
+export declare class PopStateNavigation extends AbstractPopStateNavigation {
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterEnd(event: NavigationEnd): void;
+    handleCanDeactivateCancelledEventScenario(locationTriggerUrl: string): void;
+}

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

@@ -1,4 +1,4 @@
-import { Constructable, ValueModel } from '@coolon/pectin';
+import { Constructable } from '@coolon/pectin';
 import 'reflect-metadata';
 import { DisposableComponent } from '../components/disposable-component';
 import { InteractionContext } from '../interaction/interaction-context';
@@ -8,11 +8,14 @@ import { Visit } from './visit';
 export declare const DEFINITION_META_DATA_KEY = "PLACE_DEFINITION_OPTIONS";
 export declare const ROUTE_PARAMETER_LIST_KEY: unique symbol;
 export declare class PlaceComponent extends DisposableComponent {
-    private visit;
+    private visitModel;
+    private _inVisitUpdate;
     interactionContext?: InteractionContext;
     canDeactivate?(interactionContext: InteractionContext): boolean | Promise<boolean>;
     constructor();
-    initialiseVisit(visit: ValueModel<Visit>): void;
+    initialiseVisit(visit: Visit, notifyVisitChanged: (current: Visit, previous: Visit) => void): void;
+    updateVisit(visit: Visit): void;
+    isInitialised(): boolean;
     private installBinding;
     readonly placeDefinition: PlaceDefinition;
     readonly childPlaces: Constructable<PlaceComponent>[];

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

@@ -1,50 +1,54 @@
 import { Location } from '@angular/common';
-import { ActivatedRoute, ActivatedRouteSnapshot, NavigationExtras, Router, UrlSerializer } from '@angular/router';
-import { GarbageCollector, HasOneIndexChain, ListModel, ValueModel } from '@coolon/pectin';
+import { ActivatedRoute, NavigationCancel, NavigationEnd, NavigationError, NavigationExtras, NavigationStart, Router } from '@angular/router';
+import { GarbageCollector, HasOneIndexChain, ListModel, MutableValueModel, ValueModelChain } from '@coolon/pectin';
 import { InteractionService } from '../interaction/services/interaction.service';
-import { NavigationState } from './guards/navigation-state';
+import { NavigationSession } from './navigation/session/navigation-session';
 import { PlaceHistory } from './place-history';
+import { UrlService } from './url-service';
 import { UrlSnapshot } from './url-snapshot';
 import { Visit } from './visit';
 export declare class PlaceRouter extends GarbageCollector {
-    private readonly router;
-    private readonly urlSerializer;
+    private readonly angularRouter;
     private readonly angularLocation;
-    private readonly placeHistory;
     private readonly interactionService;
-    private readonly _navigationStateModel;
+    private readonly urlService;
+    private readonly placeHistory;
+    readonly navigationSessionModel: MutableValueModel<NavigationSession>;
+    readonly navigationInProgress: ValueModelChain<boolean>;
+    readonly navigationSessionName: ValueModelChain<string>;
+    private readonly navigationContext;
     private readonly _activeVisits;
-    readonly navigationInProgress: ValueModel<boolean>;
-    readonly activeVisitIndex: HasOneIndexChain<'placeDefinition', Visit>;
-    private _navigationSessionContext;
-    private _navigationStateTypeModel;
-    constructor(router: Router, urlSerializer: UrlSerializer, angularLocation: Location, placeHistory: PlaceHistory, interactionService: InteractionService);
-    private processNavigationSuccess;
-    readonly navigationState: NavigationState;
-    readonly navigationStateModel: ValueModel<NavigationState>;
-    readonly activeVisits: ListModel<Visit>;
-    /**
-     *  placeRouter.navigate(placeDestinations.somePlace.createVisit(routeId, ...visitParams));
-     * @param visit
-     */
+    readonly activeVisitsByPlaceDefinition: HasOneIndexChain<'placeDefinition', Visit>;
+    private routerInteractionAdapter;
+    private sessionFinishedJobs;
+    constructor(angularRouter: Router, angularLocation: Location, interactionService: InteractionService, urlService: UrlService, placeHistory: PlaceHistory);
+    readonly navigationSession: NavigationSession;
+    readonly currentSession: NavigationSession;
+    onPopState(event: NavigationStart): void;
+    onRouterStarted(event: NavigationStart): void;
+    onUrlChanged(newUrl: string): void;
+    onRouterCancelled(event: NavigationCancel): void;
+    onRouterError(event: NavigationError): void;
+    onRouterEnd(event: NavigationEnd): void;
     navigate(visit: Visit, options?: {
         relativeTo: ActivatedRoute;
     }): Promise<void>;
-    pushVisitChangesToRoute(activatedRoute: ActivatedRoute, previous: Visit, next: Visit): Promise<void>;
     doNavigation(visit: Visit, runNavigationCommands: (router: Router) => any): Promise<void>;
-    protected runStateTransition(transition: (navigationSession: NavigationState) => NavigationState): void;
-    private createRouteParameters;
-    extractChildPath(activatedRoute: ActivatedRouteSnapshot): any[];
-    parseUrl(url: string): UrlSnapshot;
-    resetBrowserLocation(url: string, options: {
-        replaceCurrent: boolean;
-    }): void;
-    forward(): void;
-    createUrlSnapshot(...visits: Visit[]): UrlSnapshot;
-    getCurrentRouterUrl(): string;
-    getCurrentRouteSnapshot(): UrlSnapshot;
-    getActiveInteractionIdsFromUrl(url: string): string[];
-    hasActiveInteractionIds(url: string): boolean;
     navigateByUrl(urlSnapshot: UrlSnapshot, navigationExtras?: NavigationExtras): Promise<boolean>;
-    syncInteractionIdsWithRouter(currentIds: string[], previous: string[]): void;
+    readonly activeVisits: ListModel<Visit>;
+    pushVisitChangesToRoute(previous: Visit, next: Visit): Promise<void>;
+    private createNavigationSession;
+    protected transitionTo(next: NavigationSession): void;
+    private routingSessionFinished;
+    private runAfterCurrentRoutingSession;
+    /**
+     * Sync's the current interaction state with the URL.  We need to push something in the URL in order
+     * to be able to capture the back button on the first page.  If we don't then the back click will exit
+     * the app directly and we don't get to ask.
+     */
+    syncInteractionContextIdsWithRouter(): Promise<unknown>;
+    private createRouteParameters;
+}
+export declare namespace NavigationStateMachine {
+    type VisitsUpdatedCallback = (visits: Visit[]) => void;
 }

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

@@ -0,0 +1,30 @@
+import { Location } from '@angular/common';
+import { Router, UrlSerializer } from '@angular/router';
+import { UrlSnapshot } from './url-snapshot';
+import { Visit } from './visit';
+export declare class UrlService {
+    private readonly angularRouter;
+    readonly angularLocation: Location;
+    readonly urlSerializer: UrlSerializer;
+    constructor(angularRouter: Router, angularLocation: Location, urlSerializer: UrlSerializer);
+    parseUrl(url: string): UrlSnapshot;
+    createUrlSnapshot(...visits: Visit[]): UrlSnapshot;
+    getCurrentRouterUrl(): string;
+    getCurrentLocationUrl(): string;
+    /**
+     * Return the a UrlSnapshot using the browsers current location.  Note this may not be the same
+     * as the routers current url.
+     */
+    getCurrentLocationUrlSnapshot(): UrlSnapshot;
+    /**
+     * Return the a UrlSnapshot using the routers current state.  This may not be the same as
+     * the browsers actual url.
+     */
+    getCurrentRouterSnapshot(): UrlSnapshot;
+    getActiveInteractionIdsFromUrl(url: string): string[];
+    hasActiveInteractions(url: string): boolean;
+    resetBrowserLocation(url: string, options: {
+        replaceCurrent: boolean;
+    }): void;
+    back(): void;
+}

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

@@ -15,9 +15,11 @@ export declare class UrlSnapshot {
     protected getSegmentsFor(visit: Visit): UrlSegment[];
     includesPathOf(placeDef: PlaceDefinition): UrlSegment;
     getInteractionIds(): string[];
-    hasInteractionIds(): boolean;
+    hasInteractions(): boolean;
+    hasInteractionIds(ids: string[]): boolean;
     updateInteractionIds(ids: string[]): UrlSnapshot;
     removeInteractionIds(): UrlSnapshot;
+    toString(): string;
 }
 export declare namespace UrlSnapshot {
     const INTERACTION_QUERY_PARAM = "aup-interactions";

package/lib/place/visit.d.ts

@@ -23,5 +23,6 @@ export declare class Visit {
     }): Visit;
     hasRoutingChangedFrom(other: Visit): boolean;
     hasChangedFrom(other: Visit): boolean;
+    toDebugString(): string;
 }
 export {};

package/package.json

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

package/schematics/place-routes/templates/place-routes.ts.template

@@ -17,7 +17,8 @@ import {
   InteractionService,
   PlaceGuard as AbstractPlaceGuard,
   PlaceHistory,
-  PlaceRouter
+  PlaceRouter,
+  UrlService
 } from '@coolon/angular-ui-powerups';
 import { <%= config.authGuard.className %> } from '<%= config.authGuard.importPath %>';
 
@@ -30,12 +31,12 @@ import { <%= config.authGuard.className %> } from '<%= config.authGuard.importPa
 export class PlaceGuard extends AbstractPlaceGuard {
   // Note: We need an explicit constructor or the angular injector dies trying to instantiate us.
   constructor(router: Router,
-              urlSerializer: UrlSerializer,
+              urlService: UrlService,
               placeRouter: PlaceRouter,
               placeHistory: PlaceHistory,
               interactionService:InteractionService,
               injector: Injector) {
-    super(router, urlSerializer, placeRouter, placeHistory,interactionService, injector);
+    super(router, urlService, placeRouter, placeHistory,interactionService, injector);
   }
 
   getAuthGuard(injector:Injector) {

package/esm2015/lib/interaction/abstract-activity.js

@@ -1,13 +0,0 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-import { Activity } from './activity';
-/**
- * Deprecated. You can now extend the Activity class directly.
- * @abstract
- * @template D, R, E
- */
-export class AbstractActivity extends Activity {
-}
-//# sourceMappingURL=abstract-activity.js.map

package/esm2015/lib/interaction/abstract-activity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract-activity.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/interaction/abstract-activity.ts"],"names":[],"mappings":";;;;AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;;;;;;AAOtC,MAAM,OAAgB,gBAAgC,SAAQ,QAAiB;CAC9E","sourcesContent":["import { DelegatingValueModel, EventListenerList, Trace, ValueModel } from '@coolon/pectin';\nimport { assert } from '@coolon/typescript-utilities';\nimport { DisposableComponent } from '../components/disposable-component';\nimport { Activity } from './activity';\nimport { ActivityOutletContext } from './components/activity-outlet/activity-outlet-context';\nimport { InteractionContext } from './interaction-context';\n\n/**\n * Deprecated. You can now extend the Activity class directly.\n */\nexport abstract class AbstractActivity<D, R, E = any> extends Activity<D, R, E> {\n}\n"]}

package/esm2015/lib/interaction/abstract-activity.metadata.json

@@ -1 +0,0 @@
-[{"__symbolic":"module","version":4,"metadata":{"AbstractActivity":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"./activity","name":"Activity","line":10,"character":62},"arity":3}}}]

package/esm2015/lib/interaction/components/activity-outlet/activity-outlet-context.js

@@ -1,21 +0,0 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template D, R, E
- */
-export function ActivityOutletContext() { }
-if (false) {
-    /** @type {?} */
-    ActivityOutletContext.prototype.activityClass;
-    /** @type {?} */
-    ActivityOutletContext.prototype.activityData;
-    /**
-     * @param {?} component
-     * @return {?}
-     */
-    ActivityOutletContext.prototype.componentReady = function (component) { };
-}
-//# sourceMappingURL=activity-outlet-context.js.map