@coolon/angular-ui-powerups 0.0.97 → 0.0.101

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

@@ -25,10 +25,11 @@ declare class TabContext<D, R, E> implements ActivityOutletContext<D, R, E> {
     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 _initialActivityOutletContext;
+    private readonly _initialActivityOutletContext;
     initialActivityOutletContext: ActivityOutletContext<D, R, E>;
     initialActivityOutletContextEvent: EventEmitter<ActivityOutletContext<D, R, E>>;
     dynamicHeight: boolean;

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

@@ -2,13 +2,15 @@ import { AfterViewInit } from '@angular/core';
 import { Constructable } from '@coolon/pectin';
 import { Activity } from '../../activity';
 import { InteractionContextBase } from '../../interaction-context-base';
+import { InteractionService } from '../../services/interaction.service';
 import { ActivityContainerComponent } from '../activity-container/activity-container.component';
 import { ActivityOutletContext } from '../activity-outlet/activity-outlet-context';
 export declare class InplaceInteractionContextComponent<D, R, E> extends InteractionContextBase implements AfterViewInit {
+    readonly interactionService: InteractionService;
     interactionContext: ActivityContainerComponent<any, any, any>;
     initialActivityContext: ActivityOutletContext<D, R, E>;
     private _active;
-    constructor();
+    constructor(interactionService: InteractionService);
     ngAfterViewInit(): void;
     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

@@ -17,6 +17,7 @@ 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 "./services/dialog-interaction-context";
-export * from "./services/dialog-interaction.service";
-export * from "./services/modal-interaction.service";
+export * from "./services/interaction.service";
+export * from "./services/modal-interaction-context.factory";
+export * from "./services/mat-dialog-interaction/dialog-interaction-context-factory";
+export * from "./services/mat-dialog-interaction/dialog-interaction-context";

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

@@ -1,18 +1,15 @@
-import { Constructable, Disposable, GarbageCollector, ListModel, ValueModel } from '@coolon/pectin';
+import { Constructable, 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 true if an activity is currently running.
      */
     isActive(): boolean;
-    addActivityListener(listener: InteractionContext.Listener): Disposable;
-    protected notifyActivityStarted(): void;
-    protected notifyActivityFinished(): void;
+    dispose(): void;
     /**
      * Returns the activity that is currently active.
      * This model is only updated in the next tick after the view has been updated.
@@ -30,9 +27,3 @@ export declare abstract class InteractionContext extends GarbageCollector {
      */
     abstract confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
 }
-export declare namespace InteractionContext {
-    interface Listener {
-        onActivityStarted(): void;
-        onActivityFinished(): void;
-    }
-}

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

@@ -0,0 +1,46 @@
+import { BooleanValueModelChain, Disposable, GarbageCollector, ListModelChain, MutableValueModel, ValueModel } from '@coolon/pectin';
+import { Activity } from '../activity';
+import { InteractionContext } from '../interaction-context';
+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;
+    readonly activeInteractionContextIds: ListModelChain<string>;
+    readonly modelInteractionActive: BooleanValueModelChain;
+    readonly inlineInteractionActive: BooleanValueModelChain;
+    constructor(modelInteractionContextFactory: ModalInteractionContextFactory);
+    isActive(): boolean;
+    createModalInteractionContextFor(disposable: Disposable.Collector): InteractionContext;
+    _registerInplaceInteractionContext(interactionContext: InteractionContext): void;
+    getCurrentActivity(): Promise<Activity<any, any, any>>;
+    /**
+     * 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
+     * to PlaceComponent.canDeactivate(interactionContext).  This ensures components don't
+     * try and interact in a way that we can't track and synchronise with the browser back
+     * button.
+     */
+    _createExclusiveModalInteractionContext(): InteractionContext;
+}
+export declare namespace InteractionService {
+    interface Callback {
+        onStarted(monitor: Monitor): any;
+        onFinished(monitor: Monitor): any;
+    }
+    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;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { InjectionToken } from '@angular/core';
+import { MatDialog } from '@angular/material';
+import { MatDialogConfig } from '@angular/material/dialog';
+import { BooleanValueModelChain } from '@coolon/pectin';
+import { InteractionContext } from '../../interaction-context';
+import { ModalInteractionContextFactory } from '../modal-interaction-context.factory';
+export declare const DIALOG_INTERACTION_SERVICE_DEFAULTS: InjectionToken<MatDialogConfig<any>>;
+export declare class DialogInteractionContextFactory extends ModalInteractionContextFactory {
+    private readonly dialogService;
+    readonly dialogServiceDefaults: MatDialogConfig<any>;
+    readonly matDialogDefaultConfig: MatDialogConfig<any>;
+    readonly active: BooleanValueModelChain;
+    constructor(dialogService: MatDialog, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
+    createInteractionContext(): InteractionContext;
+}

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

@@ -1,8 +1,8 @@
 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';
+import { Activity } from '../../activity';
+import { InteractionContextBase } from '../../interaction-context-base';
 export declare class DialogInteractionContext extends InteractionContextBase {
     private readonly dialogService;
     readonly config: MatDialogConfig<any>;

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

@@ -0,0 +1,4 @@
+import { InteractionContext } from '../interaction-context';
+export declare abstract class ModalInteractionContextFactory {
+    abstract createInteractionContext(): InteractionContext;
+}

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

@@ -13,7 +13,7 @@ export declare abstract class AbstractPlaceGuard implements CanActivate, CanDeac
     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>;
+    protected authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, runPlaceGuards: (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/interaction.guard.d.ts

@@ -3,15 +3,15 @@ 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 { ModalInteractionService } from '../../interaction/services/modal-interaction.service';
+import { InteractionService } from '../../interaction/services/interaction.service';
 import { PlaceRouter } from '../place-router';
 export declare class InteractionGuard implements CanDeactivate<NoopComponent>, CanActivate {
     private router;
     private injector;
     private placeRouter;
     private readonly angularLocation;
-    private readonly modalInteractionService;
-    constructor(router: Router, injector: Injector, placeRouter: PlaceRouter, angularLocation: Location, modalInteractionService: ModalInteractionService);
+    private readonly interactionService;
+    constructor(router: Router, injector: Injector, placeRouter: PlaceRouter, angularLocation: Location, interactionService: InteractionService);
     canActivate(route: ActivatedRouteSnapshot, state: 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,124 @@
+import { NavigationCancel, NavigationEnd, NavigationError, NavigationStart, RouterEvent } from '@angular/router';
+import { GarbageCollector } from '@coolon/pectin';
+import { InteractionContext } from '../../interaction/interaction-context';
+import { InteractionService } from '../../interaction/services/interaction.service';
+import { PlaceComponent } from '../place-component';
+import { PlaceDefinition } from '../place-definition';
+import { PlaceRouter } from '../place-router';
+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 isTransitional: boolean;
+    abstract readonly startingUrl: string;
+    abstract readonly isPopState: boolean;
+    constructor(context: NavigationState.Context);
+    readonly idle: boolean;
+    readonly placeRouter: PlaceRouter;
+    readonly interactionService: InteractionService;
+    readonly interactionContext: InteractionContext;
+    storeVisit(visit: Visit): void;
+    getVisitFor(placeDef: PlaceDefinition): Visit;
+    onPopState(event: NavigationStart): NavigationState;
+    onStart(event: NavigationStart): NavigationState;
+    onCancel(event: NavigationCancel): NavigationState;
+    onError(event: NavigationError): NavigationState;
+    onEnd(event: NavigationEnd): NavigationState;
+    onBackClickedDuringNavigationInteraction(newUrl: string): NavigationState;
+    canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean>;
+    getVisits(): Visit[];
+    protected illegalTransition<R>(message: string | RouterEvent): R;
+    protected currentRouterUrl(): string;
+    protected createTransitionStateFor(event: NavigationStart): NavigationState.NavigationBackTransition | NavigationState.NavigationTransition;
+    resetBrowserLocation(url: any): void;
+    toString(): string;
+}
+export declare namespace NavigationState {
+    class Context {
+        readonly placeRouter: PlaceRouter;
+        readonly interactionService: InteractionService;
+        readonly notifySuccess: (success: NavigationState) => void;
+        constructor(placeRouter: PlaceRouter, interactionService: InteractionService, notifySuccess: (success: NavigationState) => void);
+    }
+    class Idle extends NavigationState {
+        readonly isTransitional = false;
+        readonly startingUrl: any;
+        readonly isPopState = false;
+        constructor(context: Context);
+        onStart(event: NavigationStart): NavigationState;
+        onPopState(event: NavigationStart): NavigationState;
+    }
+    abstract class AbstractNavigationTransition extends NavigationState {
+        readonly isPopState: boolean;
+        readonly startingUrl: string;
+        readonly isTransitional = true;
+        private componentDeactivationHandlers;
+        private _interactionContext;
+        constructor(context: Context, isPopState: boolean, startingUrl: string);
+        readonly interactionContext: InteractionContext;
+        onStart(event: NavigationStart): NavigationState;
+        onEnd(event: NavigationEnd): NavigationState;
+        onBackClickedDuringNavigationInteraction(locationTriggerUrl: string): NavigationState;
+        canDeactivatePlace(component: PlaceComponent, nextState: UrlSnapshot): Promise<boolean>;
+        private detachInteractionContext;
+    }
+    class NavigationTransition extends AbstractNavigationTransition {
+        readonly isPopState = false;
+        onStart(event: NavigationStart): NavigationState;
+        onEnd(event: NavigationEnd): NavigationState;
+        onCancel(event: NavigationCancel): NavigationState;
+        onError(event: NavigationError): NavigationState;
+        toString(): string;
+    }
+    class NavigationBackTransition extends AbstractNavigationTransition {
+        readonly isPopState = true;
+        onCancel(event: NavigationCancel): NavigationState;
+        onError(event: NavigationError): NavigationState;
+    }
+    abstract class AbstractInteractionTransition extends NavigationState {
+        readonly startingUrl: string;
+        readonly isTransitional = true;
+        constructor(context: Context, startingUrl: string);
+        protected reinstateInteractionRoute(): void;
+    }
+    /**
+     * 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.
+     */
+    class InteractionTransition extends AbstractInteractionTransition {
+        readonly isPopState = false;
+        onEnd(event: NavigationEnd): NavigationState;
+    }
+    /**
+     * 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.
+     */
+    class InteractionBackTransition extends AbstractInteractionTransition {
+        readonly isPopState = true;
+        onEnd(event: NavigationEnd): NavigationState;
+    }
+    class IdleDuringInteraction extends NavigationState {
+        readonly startingUrl: string;
+        readonly isTransitional = false;
+        readonly isPopState = false;
+        constructor(context: Context, startingUrl: string);
+        onStart(event: NavigationStart): NavigationState;
+        onPopState(event: NavigationStart): NavigationState;
+    }
+    class CancelledDuringNavigationInteraction extends NavigationState {
+        readonly startingUrl: string;
+        readonly locationChangeTriggerUrl: string;
+        readonly isPopState = false;
+        private capturedFauxRouterStart;
+        constructor(context: Context, startingUrl: string, locationChangeTriggerUrl: string);
+        readonly isTransitional: boolean;
+        onStart(event: NavigationStart): NavigationState;
+        onCancel(event: NavigationCancel): NavigationState;
+        onEnd(event: NavigationEnd): NavigationState;
+        onError(event: NavigationError): NavigationState;
+        onPopState(event: NavigationStart): NavigationState;
+        ignore(event: RouterEvent, reason?: string): NavigationState;
+        toString(): string;
+    }
+}

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

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

package/lib/place/index.d.ts

@@ -21,7 +21,7 @@ export * from "./components/tabbed-place-navigation/tabbed-place-navigation.comp
 export * from "./guards/abstract-place.guard";
 export * from "./guards/consolidated-param-map";
 export * from "./guards/interaction.guard";
-export * from "./guards/navigation-session";
+export * from "./guards/navigation-state";
 export * from "./guards/noop-auth-guard.service";
 export * from "./guards/place-component-deactivation-handler";
 export * from "./route/formatter";

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

@@ -1,9 +1,8 @@
 import { Location } from '@angular/common';
-import { ActivatedRoute, ActivatedRouteSnapshot, Router, RouterStateSnapshot, UrlSerializer } from '@angular/router';
+import { ActivatedRoute, ActivatedRouteSnapshot, Router, UrlSerializer } from '@angular/router';
 import { GarbageCollector, HasOneIndexChain, ListModel, ValueModel } from '@coolon/pectin';
-import { InteractionContext } from '../interaction/interaction-context';
-import { ModalInteractionService } from '../interaction/services/modal-interaction.service';
-import { NavigationSession } from './guards/navigation-session';
+import { InteractionService } from '../interaction/services/interaction.service';
+import { NavigationState } from './guards/navigation-state';
 import { PlaceHistory } from './place-history';
 import { UrlSnapshot } from './url-snapshot';
 import { Visit } from './visit';
@@ -12,17 +11,17 @@ export declare class PlaceRouter extends GarbageCollector {
     private readonly urlSerializer;
     private readonly angularLocation;
     private readonly placeHistory;
-    private readonly modalInteractionService;
-    private firstRoute;
-    private readonly _navigationSessionModel;
+    private readonly interactionService;
+    private readonly _navigationStateModel;
     private readonly _activeVisits;
-    readonly navigationSessionActive: ValueModel<boolean>;
+    readonly navigationInProgress: ValueModel<boolean>;
     readonly activeVisitIndex: HasOneIndexChain<'placeDefinition', Visit>;
     private _navigationSessionContext;
-    constructor(router: Router, urlSerializer: UrlSerializer, angularLocation: Location, placeHistory: PlaceHistory, modalInteractionService: ModalInteractionService);
+    private _navigationStateTypeModel;
+    constructor(router: Router, urlSerializer: UrlSerializer, angularLocation: Location, placeHistory: PlaceHistory, interactionService: InteractionService);
     private processNavigationSuccess;
-    readonly navigationSession: NavigationSession;
-    readonly navigationSessionModel: ValueModel<NavigationSession>;
+    readonly navigationState: NavigationState;
+    readonly navigationStateModel: ValueModel<NavigationState>;
     readonly activeVisits: ListModel<Visit>;
     /**
      *  placeRouter.navigate(placeDestinations.somePlace.createVisit(routeId, ...visitParams));
@@ -33,19 +32,13 @@ export declare class PlaceRouter extends GarbageCollector {
     }): Promise<void>;
     pushVisitChangesToRoute(activatedRoute: ActivatedRoute, previous: Visit, next: Visit): Promise<void>;
     doNavigation(visit: Visit, runNavigationCommands: (router: Router) => any): Promise<void>;
-    protected runStateTransition(transition: (navigationSession: NavigationSession) => NavigationSession): void;
+    protected runStateTransition(transition: (navigationSession: NavigationState) => NavigationState): void;
     private createRouteParameters;
     extractChildPath(activatedRoute: ActivatedRouteSnapshot): any[];
-    parseUrl(snapshot: RouterStateSnapshot): UrlSnapshot;
-}
-export declare namespace PlaceRouter {
-    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;
-    }
+    parseUrl(url: string): UrlSnapshot;
+    resetBrowserLocation(url: string): void;
+    getCurrentRouterUrl(): string;
+    getActiveInteractionIdsFromUrl(url: string): string[];
+    hasActiveInteractionIds(url: string): boolean;
+    syncInteractionIdsWithRouter(): void;
 }

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

@@ -1,16 +1,28 @@
-import { UrlSegment, UrlTree } from '@angular/router';
+import { UrlSegment, UrlSerializer } 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[];
+    readonly urlSerializer: UrlSerializer;
+    readonly url: string;
+    private readonly urlTree;
+    constructor(urlSerializer: UrlSerializer, url: string);
+    protected replaceExistingVisitSegmentsWith(visit: Visit): UrlSegment[];
+    private getPrimarySegments;
     /**
      * Converts the visit into segments.  Please not that these segments are not e
      * @param visit
      */
-    convertToUrlSegments(visit: Visit): UrlSegment[];
+    protected getSegmentsFor(visit: Visit): UrlSegment[];
     createRedirectCommandsFor(visit: Visit): any[];
     includesPathOf(placeDef: PlaceDefinition): UrlSegment;
+    getInteractionIds(): string[];
+    addOrReplaceInteractionIds(ids: string[]): UrlSnapshot;
+}
+export declare namespace UrlSnapshot {
+    const INTERACTION_ROUTER_OUTLET = "aup-interactions";
+    const INTERACTION_ROUTER_PATH = "active";
+    const INTERACTION_ID_SEPARATOR = "--";
+    function parseInteractionIds(path: string): string[];
+    function createPathIdFor(interactionIds: string[]): string;
+    function createInteractionOutletRouterCommands(interactionIds: string[]): string[];
 }

package/package.json

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

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

@@ -13,7 +13,7 @@
 
 import { Injectable, Injector } from '@angular/core';
 import { Router, UrlSerializer } from '@angular/router';
-import { AbstractPlaceGuard, PlaceHistory, PlaceRouter, InteractionGuard, NoopComponent } from '@coolon/angular-ui-powerups';
+import { AbstractPlaceGuard, PlaceHistory, PlaceRouter, InteractionGuard, NoopComponent, UrlSnapshot } from '@coolon/angular-ui-powerups';
 import { <%= config.authGuard.className %> } from '<%= config.authGuard.importPath %>';
 
 <% placeDefs.forEach(def => { %>import {<%= def.componentClass %>} from "<%= def.importPath %>";
@@ -41,8 +41,8 @@ export const placeRoutes = [<% placeDefs.filter(def=> !def.isChild()).forEach(de
     <%= def.getRouteTemplate() %>,
 <% }) %>
  {
-   path: "modal",
-   outlet:PlaceRouter.INTERACTION_ROUTER_OUTLET,
+   path: "active/:ids", // Must match `${UrlSnapshot.INTERACTION_ROUTER_PATH}/:ids`
+   outlet:UrlSnapshot.INTERACTION_ROUTER_OUTLET,
    component: NoopComponent,
    canDeactivate: [InteractionGuard],
    canActivate: [InteractionGuard]

package/styles/styles.scss

@@ -2,7 +2,7 @@
   --aup-default-padding: var(--default-padding, 18px);
 }
 
-.dialog-interaction-service {
+.dialog-interaction-context {
   max-width: 95vw !important;
   max-height: 95vh !important;