@coolon/angular-ui-powerups 0.0.125 → 0.0.128

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

@@ -0,0 +1,24 @@
+import { Constructable, Disposable } from '@coolon/pectin';
+import { Activity } from './activity';
+import { Alert } from './alert';
+import { Confirm } from './confirm';
+import { InteractionContext } from './interaction-context';
+export declare abstract class AbstractInteractionContext implements InteractionContext {
+    abstract readonly identifier: string;
+    abstract cancelActiveActivity(): Promise<boolean>;
+    abstract dispose(): void;
+    abstract registerDisposable<T extends Disposable>(disposable: T): T;
+    abstract isActive(): boolean;
+    protected abstract createAndLaunchActivity<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>;
+    /**
+     * Presents the confirmation to the user and runs the activity only if the user confirms.
+     * @param confirm:Confirm the confirmation to display.
+     * @param activityType the activity to run if confirmed.
+     * @param data the activity data.
+     */
+    confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
+}

package/lib/interaction/activity-ref.d.ts

@@ -0,0 +1,19 @@
+import { Constructable, Deferred } from '@coolon/pectin';
+import { Activity } from './activity';
+import { InteractionContext } from './interaction-context';
+export declare class ActivityRef<D, R, E> {
+    readonly activityClass: Constructable<Activity<D, R, E>>;
+    readonly activityData: D;
+    readonly onComplete: (activityRef: ActivityRef<D, R, E>) => void;
+    private _complete;
+    private _activity;
+    private deferredResult;
+    constructor(activityClass: Constructable<Activity<D, R, E>>, activityData: D, onComplete: (activityRef: ActivityRef<D, R, E>) => void);
+    isActivityRealised(): boolean;
+    isComplete(): boolean;
+    readonly activity: Activity<D, R, E>;
+    notifyActivityCreated(activity: Activity<D, R, E>, nestedInteractionContext: InteractionContext): void;
+    protected finishActivity(resolveOrReject: (deferred: Deferred<R>) => void): void;
+    cancel(): void;
+    readonly activityResult: Promise<R>;
+}

package/lib/interaction/activity.d.ts

@@ -1,16 +1,20 @@
 import { InjectionToken } from '@angular/core';
 import { GarbageCollector, ValueModel } from '@coolon/pectin';
+import { InteractionContext } from './interaction-context';
 export declare const ACTIVITY_DATA: InjectionToken<any>;
 export declare abstract class Activity<D, R, E = any> extends GarbageCollector {
     private readonly _busyModel;
     private _activityContext;
-    initialise(activityContext: Activity.Callbacks<R, E>): void;
+    private _interactionContext;
+    initialise(nestedInteractionContext: InteractionContext, activityContext: Activity.Callbacks<R, E>): void;
+    readonly interactionContext: InteractionContext;
     done(result?: R): void;
     cancel(error?: E): void;
     onActivityReady(): void;
     readonly busy: ValueModel<boolean>;
     busyWhile(busyModel: ValueModel<boolean>): void;
     isBusy(): boolean;
+    isInitialised(): boolean;
 }
 export declare namespace Activity {
     interface Callbacks<R, E> {

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

@@ -1,56 +1,55 @@
-import { AfterViewInit, EventEmitter, OnInit, QueryList } from '@angular/core';
+import { AfterViewInit, OnInit, QueryList } from '@angular/core';
 import { MatTabGroup } from '@angular/material';
-import { Constructable, MutableListModel, ValueModel } from '@coolon/pectin';
+import { Constructable, Disposable } from '@coolon/pectin';
+import { AbstractInteractionContext } from '../../abstract-interaction-context';
 import { Activity } from '../../activity';
-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';
-/**
- * Note: this class is mutable and is stored in a list model.  This is normally a big no no but
- *  we're manually deriving other models from the list after view state changes.  I.e. we not
- *  using pectin chains on any of the mutable fields.
- */
-declare class TabContext<D, R, E> implements ActivityOutletContext<D, R, E> {
-    readonly activityData: D;
-    readonly activityClass: Constructable<Activity<D, R, E>>;
-    readonly interactionContext: InteractionContext;
-    readonly activityCallbacks: Activity.Callbacks<R, E>;
-    private _complete;
-    private _component;
-    constructor(activityData: D, activityClass: Constructable<Activity<D, R, E>>, interactionContext: InteractionContext, activityCallbacks: Activity.Callbacks<R, E>);
-    isComponentRealised(): boolean;
-    isComplete(): boolean;
-    componentReady(component: Activity<D, R, E>): void;
-    readonly component: Activity<D, R, E>;
-    onDone(result: R): void;
-    onCancel(error: E): void;
-    dispose(): void;
-}
-export declare class ActivityContainerComponent<D, R, E> extends InteractionContextBase implements OnInit, AfterViewInit {
-    private readonly throttledNestedActivityFinishEvents;
-    private readonly _initialActivityOutletContext;
-    initialActivityOutletContext: ActivityOutletContext<D, R, E>;
-    initialActivityOutletContextEvent: EventEmitter<ActivityOutletContext<D, R, E>>;
+import { ActivityRef } from '../../activity-ref';
+import { InteractionService } from '../../services/interaction.service';
+import { ActivityOutletComponent } from './activity-outlet/activity-outlet.component';
+export declare class ActivityContainerComponent<D, R, E> extends AbstractInteractionContext implements OnInit, AfterViewInit {
     dynamicHeight: boolean;
     tabs: MatTabGroup;
-    outlets: QueryList<ActivityOutletComponent<any, any, any>>;
-    readonly activityTabs: MutableListModel<TabContext<any, any, any>>;
-    readonly active: ValueModel<boolean>;
-    private readonly _activityList;
+    activityOutlets: QueryList<ActivityOutletComponent<any, any, any>>;
+    activityTabs: ActivityRef<any, any, any>[];
+    private _identifier;
+    private _deferredCleanUp;
+    private interactionServiceApi;
+    private garbage;
+    private syncSelectedTabTimeout;
     constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
-    _startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
-    private finishInitialActivity;
-    private onNestedActivityFinished;
-    private cleanupStaleNestedActivities;
+    initialise(identifier: string, api: InteractionService.Api): void;
+    readonly identifier: string;
+    isInitialised(): boolean;
+    /**
+     * Returns true if an activity is currently running.
+     */
+    isActive(): boolean;
+    registerDisposable<T extends Disposable>(disposable: T): T;
+    dispose(): void;
+    getActiveActivityRef(): ActivityRef<any, any, any>;
+    /**
+     * Cancels the current activity and returns true the context is no longer active, false if
+     * there is still another activity running.
+     */
+    cancelActiveActivity(): Promise<boolean>;
+    protected createAndLaunchActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data: D1, disableClose: boolean): Promise<R1>;
+    private getActiveActivityCount;
+    /**
+     * Checks if this interaction context has finished an is in the process of waiting
+     * for all the infrastructure (including route updates) to be completed.
+     */
+    isCleaningUp(): boolean;
+    waitForInteractionContextCleanupToFinish(): Promise<any>;
+    private finishAndStartCleanup;
+    launchActivity<D1, R1, E1>(activityRef: ActivityRef<D1, R1, E1>): void;
+    activityIndex(index: number, activityRef: ActivityRef<any, any, any>): number;
+    private onAnimationFinished;
     /**
      * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
      */
     private synchroniseSelectedTabIndex;
-    private onAnimationFinished;
-    private updateActivityList;
     private getSelectedOutlet;
+    private triggerTabSynchronisation;
 }
-export {};

package/lib/interaction/components/{activity-outlet → activity-container/activity-outlet}/activity-outlet.component.d.ts

@@ -1,24 +1,21 @@
 import { ComponentFactoryResolver, Injector, OnInit, ViewContainerRef } from '@angular/core';
-import { Activity } from '../../activity';
-import { InteractionContext } from '../../interaction-context';
-import { ActivityOutletContext } from './activity-outlet-context';
+import { Activity } from '../../../activity';
+import { ActivityRef } from '../../../activity-ref';
+import { InteractionContext } from '../../../interaction-context';
 /**
  * ActivityOutletComponent creates and displays an activity and delegates the interaction context functionality to an
  * external service.
- *
- * It might be nice to have wrapper component that allows more declarative use, i.e.
- * <activity-view [activityClass]="...", [activityData]="..." (done)=".." (cancel)="..."></activity-view>
  */
 export declare class ActivityOutletComponent<D, R, E> implements OnInit {
     private componentFactoryResolver;
     private viewContainerRef;
     private injector;
-    interactionContext: InteractionContext;
-    private _activityContext;
-    activityContext: ActivityOutletContext<D, R, E>;
     private activityComponentRef;
+    nestedInteractionContext: InteractionContext;
+    private _activityRef;
+    activityRef: ActivityRef<D, R, E>;
     constructor(componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, injector: Injector);
     ngOnInit(): void;
-    loadActivity(activityContext: ActivityOutletContext<D, R, E>): void;
+    loadActivity(activityRef: ActivityRef<D, R, E>): void;
     readonly component: Activity<D, R, E>;
 }

package/lib/interaction/components/alert-dialog/alert-dialog.component.d.ts

@@ -1,7 +1,7 @@
 import { OnInit } from '@angular/core';
-import { AbstractActivity } from '../../abstract-activity';
+import { Activity } from '../../activity';
 import { Alert } from '../../alert';
-export declare class AlertDialogComponent extends AbstractActivity<Alert, void> implements OnInit {
+export declare class AlertDialogComponent extends Activity<Alert, void> implements OnInit {
     readonly alert: Alert;
     constructor(alert: Alert);
     ngOnInit(): void;

package/lib/interaction/components/confirm-then-dialog/confirm-then-dialog.component.d.ts

@@ -1,13 +1,10 @@
 import { OnInit } from '@angular/core';
 import { Constructable } from '@coolon/pectin';
-import { AbstractActivity } from '../../abstract-activity';
 import { Activity } from '../../activity';
 import { Confirm } from '../../confirm';
-import { InteractionContext } from '../../interaction-context';
-export declare class ConfirmThenDialogComponent<D, R, E> extends AbstractActivity<ConfirmThenDialogComponent.Data<D, R, E>, R, E> implements OnInit {
+export declare class ConfirmThenDialogComponent<D, R, E> extends Activity<ConfirmThenDialogComponent.Data<D, R, E>, R, E> implements OnInit {
     readonly config: ConfirmThenDialogComponent.Data<D, R, E>;
-    readonly interactionContext: InteractionContext;
-    constructor(config: ConfirmThenDialogComponent.Data<D, R, E>, interactionContext: InteractionContext);
+    constructor(config: ConfirmThenDialogComponent.Data<D, R, E>);
     ngOnInit(): void;
     readonly confirm: Confirm;
     isDestructive(): boolean;

package/lib/interaction/components/confirmation-dialog/confirmation-dialog.component.d.ts

@@ -1,7 +1,7 @@
 import { OnInit } from '@angular/core';
-import { AbstractActivity } from '../../abstract-activity';
+import { Activity } from '../../activity';
 import { Confirm } from '../../confirm';
-export declare class ConfirmationDialogComponent extends AbstractActivity<Confirm, void> implements OnInit {
+export declare class ConfirmationDialogComponent extends Activity<Confirm, void> implements OnInit {
     readonly confirm: Confirm;
     constructor(confirm: Confirm);
     ngOnInit(): void;

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

@@ -0,0 +1,24 @@
+import { AfterViewInit } from '@angular/core';
+import { Constructable } from '@coolon/pectin';
+import { DisposableComponent } from '../../../components/disposable-component';
+import { Activity } from '../../activity';
+import { Alert } from '../../alert';
+import { Confirm } from '../../confirm';
+import { InteractionContext } from '../../interaction-context';
+import { InteractionService } from '../../services/interaction.service';
+import { ActivityContainerComponent } from '../activity-container/activity-container.component';
+export declare class InPlaceInteractionContextComponent<D, R, E> extends DisposableComponent implements InteractionContext, AfterViewInit {
+    readonly interactionService: InteractionService;
+    activityContainerComponent: ActivityContainerComponent<any, any, any>;
+    constructor(interactionService: InteractionService);
+    ngAfterViewInit(): void;
+    initialise(id: string, api: InteractionService.Api): void;
+    readonly identifier: string;
+    alert(alert: Alert): Promise<void>;
+    cancelActiveActivity(): Promise<boolean>;
+    confirm(confirm: Confirm): Promise<boolean>;
+    confirmOrReject(confirm: Confirm): Promise<void>;
+    confirmThen<D1, R1, E1>(confirm: Confirm, activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
+    isActive(): boolean;
+    startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
+}

package/lib/interaction/index.d.ts

@@ -1,21 +1,22 @@
 /**
  * @file Automatically generated by barrelsby.
  */
-export * from "./abstract-activity";
+export * from "./abstract-interaction-context";
+export * from "./activity-ref";
 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";
+export * from "./route-synchronisation-adapter";
 export * from "./components/activity-container/activity-container.component";
-export * from "./components/activity-outlet/activity-outlet-context";
-export * from "./components/activity-outlet/activity-outlet.component";
+export * from "./components/activity-container/activity-outlet/activity-outlet.component";
 export * from "./components/alert-dialog/alert-dialog.component";
 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/inplace-interaction-context/in-place-interaction-context.component";
+export * from "./services/interaction-service-routing-adapter";
 export * from "./services/interaction.service";
 export * from "./services/modal-interaction-context.factory";
 export * from "./services/mat-dialog-interaction/dialog-interaction-context-factory";

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

@@ -1,35 +1,14 @@
-import { Constructable, GarbageCollector, ListModel, ValueModel } from '@coolon/pectin';
+import { Constructable, Disposable } from '@coolon/pectin';
 import { Activity } from './activity';
 import { Alert } from './alert';
 import { Confirm } from './confirm';
-export declare abstract class InteractionContext extends GarbageCollector {
-    abstract readonly active: ValueModel<boolean>;
-    abstract readonly activityList: ListModel<Activity<any, any, any>>;
-    abstract readonly activeActivity: ValueModel<Activity<any, any, any>>;
-    /**
-     * Returns true if an activity is currently running.
-     */
+export interface InteractionContext extends Disposable, Disposable.Collector {
+    readonly identifier: string;
     isActive(): boolean;
-    dispose(): void;
-    /**
-     * Cancels the current activity and returns true the context is no longer active, false if
-     * there is still another activity running.
-     */
+    startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
     cancelActiveActivity(): Promise<boolean>;
-    /**
-     * Returns the activity that is currently active.
-     * This model is only updated in the next tick after the view has been updated.
-     */
-    abstract getActiveActivity(): Promise<Activity<any, any>>;
-    abstract startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
-    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.
-     * @param confirm:Confirm the confirmation to display.
-     * @param activityType the activity to run if confirmed.
-     * @param data the activity data.
-     */
-    abstract confirmThen<D, R, E>(confirm: Confirm, 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/route-synchronisation-adapter.d.ts

@@ -0,0 +1,5 @@
+import { Activity } from './activity';
+import { InteractionContext } from './interaction-context';
+export interface RouteSynchronisationAdapter {
+    synchroniseRoute(interactionContext: InteractionContext, activities: Activity<any, any>[]): any;
+}

package/lib/interaction/services/interaction-service-routing-adapter.d.ts

@@ -0,0 +1,15 @@
+import { ListModel, ValueModel } from '@coolon/pectin';
+import { PlaceComponent } from '../../place/place-component';
+import { InteractionContext } from '../interaction-context';
+export declare class InteractionServiceRoutingAdapter {
+    private readonly activeInteractionContextIds;
+    private readonly activeModalContext;
+    readonly createExclusiveInteractionContext: () => InteractionContext;
+    constructor(activeInteractionContextIds: ListModel<string>, activeModalContext: ValueModel<InteractionContext>, createExclusiveInteractionContext: () => InteractionContext);
+    isActive(): boolean;
+    isModalActive(): boolean;
+    isComponentInteracting(component: PlaceComponent): boolean;
+    getActiveInteractionContextIds(): string[];
+    cancelCurrentModalInteraction(): Promise<boolean>;
+    cancelComponentInteraction(component: PlaceComponent): Promise<boolean>;
+}

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

@@ -1,20 +1,23 @@
-import { BooleanValueModelChain, Disposable, GarbageCollector, ListModelChain, MutableValueModel, ValueModel } from '@coolon/pectin';
+import { BooleanValueModelChain, Disposable, GarbageCollector, ListModel, ListModelChain, ValueModel } from '@coolon/pectin';
+import { PlaceRouter } from '../../place/place-router';
+import { InPlaceInteractionContextComponent } from '../components/inplace-interaction-context/in-place-interaction-context.component';
 import { InteractionContext } from '../interaction-context';
+import { InteractionServiceRoutingAdapter } from './interaction-service-routing-adapter';
 import { ModalInteractionContextFactory } from './modal-interaction-context.factory';
 export declare class InteractionService {
     readonly modelInteractionContextFactory: ModalInteractionContextFactory;
     private readonly garbage;
     readonly active: BooleanValueModelChain;
-    private readonly exclusiveContext;
-    private readonly _activeModalInteractionContextModel;
-    private readonly _activeInlineInteractionContextModel;
-    private readonly _activeInteractionContext;
+    private readonly _navigationInProgress;
+    private placeRouter;
+    private exclusiveInteractionRegistry;
+    private modalInteractionRegistry;
+    private inPlaceInteractionRegistry;
+    private activeModalContext;
     readonly activeInteractionContextIds: ListModelChain<string>;
-    readonly modelInteractionActive: BooleanValueModelChain;
-    readonly inlineInteractionActive: BooleanValueModelChain;
+    readonly inModalInteraction: BooleanValueModelChain;
     constructor(modelInteractionContextFactory: ModalInteractionContextFactory);
     isActive(): boolean;
-    isModalActive(): boolean;
     /**
      * @deprecated use #createModalInteractionContextDisposedWith instead.
      * @param disposable
@@ -25,8 +28,7 @@ export declare class InteractionService {
      * @param disposable
      */
     createModalInteractionContextDisposedWith(disposable: Disposable.Collector): InteractionContext;
-    _registerInplaceInteractionContext(interactionContext: InteractionContext): void;
-    getActiveContext(): InteractionContext;
+    registerInplaceInteractionContext(interactionContext: InPlaceInteractionContextComponent<any, any, any>): void;
     /**
      * Creates an interaction context that will prevent any other contexts from starting an
      * activity until it is disposed.  This is intended for use by the router for passing
@@ -34,22 +36,48 @@ export declare class InteractionService {
      * try and interact in a way that we can't track and synchronise with the browser back
      * button.
      */
-    _createExclusiveModalInteractionContext(): InteractionContext;
+    registerPlaceRouter(router: PlaceRouter): InteractionServiceRoutingAdapter;
 }
 export declare namespace InteractionService {
-    interface Callback {
-        onStarted(monitor: Monitor): any;
-        onFinished(monitor: Monitor): any;
+    interface Api {
+        /**
+         * Notifies the interaction service that a particular interactionContext has become active. The interaction
+         * services will then push changes to the router to track state.  If the router is idle, the promise will
+         * resolve when the routing has finished updating.  Otherwise it will return immediately.
+         * @param interactionContext
+         */
+        notifyActive(interactionContext: InteractionContext): Promise<unknown>;
+        /**
+         * Notifies the interaction service that a particular interactionContext has become idle. The interaction
+         * services will then push changes to the router to track state.  If the router is idle, the promise will
+         * resolve when the routing has finished updating.  Otherwise it will return immediately.
+         * @param interactionContext
+         */
+        notifyFinished(interactionContext: InteractionContext): Promise<unknown>;
     }
-    class Monitor extends GarbageCollector {
-        readonly id: string;
-        readonly interactionContext: InteractionContext;
-        readonly currentActiveMonitor: MutableValueModel<Monitor>;
-        readonly exclusiveContext: ValueModel<InteractionContext>;
-        constructor(id: string, interactionContext: InteractionContext, currentActiveMonitor: MutableValueModel<Monitor>, exclusiveContext: ValueModel<InteractionContext>);
-        protected onStarted(): void;
-        private assertCanStart;
-        protected onFinished(): void;
-        private assertCurrentlyActive;
+    /**
+     * Provides a mechanism for the service to keep track of what the API adapters are doing to
+     * ensure the rules are followed, i.e. modal or in-place interaction aren't started while
+     * an exclusive routing interaction is active.
+     */
+    class ContextRegistry extends GarbageCollector {
+        private _interactions;
+        private _disabledDelegate;
+        readonly active: BooleanValueModelChain;
+        readonly interactionContextIds: ListModelChain<string>;
+        constructor();
+        readonly interactionContexts: ListModel<InteractionContext>;
+        start(context: InteractionContext): void;
+        finish(context: InteractionContext): void;
+        isActive(): boolean;
+        disableWhen(disabled: ValueModel<boolean>): void;
+    }
+    class ApiAdapter implements Api {
+        private readonly placeRouter;
+        private readonly contextRegistry;
+        constructor(placeRouter: PlaceRouter, contextRegistry: ContextRegistry);
+        notifyActive(context: InteractionContext): Promise<any>;
+        private isNavigationInProgress;
+        notifyFinished(context: InteractionContext): Promise<any>;
     }
 }

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

@@ -3,6 +3,7 @@ import { MatDialog } from '@angular/material';
 import { MatDialogConfig } from '@angular/material/dialog';
 import { BooleanValueModelChain } from '@coolon/pectin';
 import { InteractionContext } from '../../interaction-context';
+import { InteractionService } from '../interaction.service';
 import { ModalInteractionContextFactory } from '../modal-interaction-context.factory';
 export declare const DIALOG_INTERACTION_SERVICE_DEFAULTS: InjectionToken<MatDialogConfig<any>>;
 export declare class DialogInteractionContextFactory extends ModalInteractionContextFactory {
@@ -11,5 +12,5 @@ export declare class DialogInteractionContextFactory extends ModalInteractionCon
     readonly matDialogDefaultConfig: MatDialogConfig<any>;
     readonly active: BooleanValueModelChain;
     constructor(dialogService: MatDialog, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
-    createInteractionContext(): InteractionContext;
+    createInteractionContext(identifier: string, api: InteractionService.Api): InteractionContext;
 }

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

@@ -1,18 +1,21 @@
 import { MatDialog } from '@angular/material';
 import { MatDialogConfig } from '@angular/material/dialog';
-import { Constructable, ListModel, ValueModel } from '@coolon/pectin';
+import { Constructable, Disposable } from '@coolon/pectin';
+import { AbstractInteractionContext } from '../../abstract-interaction-context';
 import { Activity } from '../../activity';
-import { InteractionContextBase } from '../../interaction-context-base';
-export declare class DialogInteractionContext extends InteractionContextBase {
+import { InteractionService } from '../interaction.service';
+export declare class DialogInteractionContext extends AbstractInteractionContext {
+    readonly identifier: string;
+    private readonly api;
     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;
+    private garbage;
+    private _currentActivityRef;
+    private activityContainer;
+    constructor(identifier: string, api: InteractionService.Api, dialogService: MatDialog, config: MatDialogConfig<any>);
+    cancelActiveActivity(): Promise<boolean>;
+    dispose(): void;
+    registerDisposable<T extends Disposable>(disposable: T): T;
+    isActive(): boolean;
+    protected createAndLaunchActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data: D, disableClose: boolean): Promise<R>;
 }

package/lib/interaction/services/modal-interaction-context.factory.d.ts

@@ -1,4 +1,5 @@
 import { InteractionContext } from '../interaction-context';
+import { InteractionService } from './interaction.service';
 export declare abstract class ModalInteractionContextFactory {
-    abstract createInteractionContext(): InteractionContext;
+    abstract createInteractionContext(identifier: string, api: InteractionService.Api): InteractionContext;
 }

package/lib/place/components/abstract-place-navigation.component.d.ts

@@ -1,9 +1,10 @@
 import { OnInit } from '@angular/core';
-import { Command, Constructable, ListModel, ListModelChain, ValueModel, ValueModelChain } from '@coolon/pectin';
+import { Command, Constructable, DelegatingValueModel, ListModel, ListModelChain, ValueModel } from '@coolon/pectin';
 import { DisposableComponent } from '../../components/disposable-component';
 import { NavItem } from '../nav-item';
 import { PlaceComponent } from '../place-component';
 import { PlaceDefinition } from '../place-definition';
+import { PlaceRouter } from '../place-router';
 import { PlaceOutletComponent } from './place-outlet/place-outlet.component';
 export declare class AbstractPlaceNavigationComponent extends DisposableComponent implements OnInit {
     places: Constructable<PlaceComponent>[];
@@ -12,8 +13,9 @@ export declare class AbstractPlaceNavigationComponent extends DisposableComponen
     placeOutletModel: ValueModel<PlaceOutletComponent>;
     readonly placeDefinitions: ListModelChain<PlaceDefinition>;
     readonly commandFactory: Command.Factory<PlaceDefinition, void>;
-    readonly activePlaceDefinition: ValueModelChain<PlaceDefinition>;
-    constructor();
+    readonly _activePlaceComponent: DelegatingValueModel<PlaceComponent>;
+    private activePlaceDefinition;
+    constructor(placeRouter: PlaceRouter);
     getNav(placeDef: PlaceDefinition): NavItem;
     isActive(place: PlaceDefinition): boolean;
     ngOnInit(): void;

package/lib/place/components/list-place-nav/list-place-nav.component.d.ts

@@ -1,7 +1,8 @@
+import { PlaceRouter } from '../../place-router';
 import { AbstractPlaceNavigationComponent } from '../abstract-place-navigation.component';
 export declare class ListPlaceNavComponent extends AbstractPlaceNavigationComponent {
     expanded: boolean;
-    constructor();
+    constructor(placeRouter: PlaceRouter);
     expandMenu(): void;
     collapseMenu(): void;
     toggleMenu(): void;

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

@@ -16,30 +16,29 @@ export declare class PlaceOutletComponent extends DisposableComponent implements
     customPlaceAnimationOrder: Constructable<PlaceComponent>[];
     readonly placeChanged: EventEmitter<PlaceComponent>;
     routerOut: RouterOutlet;
-    private readonly _activePlace;
-    private readonly _activePlaceVisitModel;
-    private readonly _inOutletActivation;
-    private readonly _inOutletDeactivation;
-    private readonly _inOutletUpdate;
-    private readonly _inRouteVisitUpdate;
+    private outletActivated;
     private readonly _activatedRouteModel;
-    private readonly _placeDefinition;
+    private readonly _activePlaceModel;
+    private readonly _activePlaceDefinition;
     private parentOutletModel;
     readonly placeAnimationOrder: ValueModelChain<number>;
     private initialPlaceIndex;
-    private routerVisit;
+    private routerVisitModel;
+    private _isPushingVisitToRoute;
+    private navigationInProgress;
     constructor(router: Router, placeRouter: PlaceRouter, placeConfig: PlaceConfig, parentOutlet: PlaceOutletComponent);
     ngOnInit(): void;
     getAnimationOrder(): number;
     readonly animationDuration: string;
     navigate(visit: Visit): void;
     readonly parentOutlet: PlaceOutletComponent;
-    pushRouteChangesToVisit(): void;
-    pushVisitChangesToRoute(next: Visit, previous: Visit): void;
     readonly activePlaceModel: ValueModel<PlaceComponent>;
     readonly activatedRouteModel: ValueModel<ActivatedRoute>;
     onOutletActivated(routerOutlet: RouterOutlet, place: PlaceComponent): void;
     onOutletDeactivated(): void;
+    private checkStateAndInitialise;
+    private initialisePlace;
+    private pushVisitChangeToRoute;
     animationStarted(): void;
     animationDone(): void;
 }

package/lib/place/components/tabbed-place-navigation/tabbed-place-navigation.component.d.ts

@@ -1,4 +1,5 @@
+import { PlaceRouter } from '../../place-router';
 import { AbstractPlaceNavigationComponent } from '../abstract-place-navigation.component';
 export declare class TabbedPlaceNavigationComponent extends AbstractPlaceNavigationComponent {
-    constructor();
+    constructor(placeRouter: PlaceRouter);
 }