@coolon/angular-ui-powerups 0.0.67 → 0.0.69

package/lib/components/index.d.ts

@@ -8,6 +8,7 @@ export * from "./forms/number-input/number-input.component";
 export * from "./forms/password-input/password-input.component";
 export * from "./forms/select-input/select-input.component";
 export * from "./forms/string-input/string-input.component";
+export * from "./noop/noop.component";
 export * from "./types/bounds.class";
 export * from "./types/dimension.class";
 export * from "./types/point.class";

package/lib/components/noop/noop.component.d.ts

@@ -0,0 +1,3 @@
+export declare class NoopComponent {
+    constructor();
+}

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

@@ -0,0 +1,3 @@
+export declare class InteractionOutletComponent {
+    constructor();
+}

package/lib/interaction/guards/interaction-guard.service.d.ts

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

package/lib/interaction/index.d.ts

@@ -14,5 +14,6 @@ export * from "./components/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 "./guards/close-interaction.guard";
+export * from "./components/interaction-outlet/interaction-outlet.component";
+export * from "./guards/interaction-guard.service";
 export * from "./services/dialog-interaction.service";

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

@@ -1,6 +1,8 @@
+import { Location } from '@angular/common';
 import { InjectionToken } from '@angular/core';
 import { MatDialog } from '@angular/material';
 import { MatDialogConfig } from '@angular/material/dialog';
+import { Router } from '@angular/router';
 import { Constructable, ListModel } from '@coolon/pectin';
 import { Activity } from '../activity';
 import { Alert } from '../alert';
@@ -9,12 +11,14 @@ import { InteractionContext } from '../interaction-context';
 export declare const DIALOG_INTERACTION_SERVICE_DEFAULTS: InjectionToken<MatDialogConfig<any>>;
 export declare class DialogInteractionService extends InteractionContext {
     private readonly dialogService;
+    readonly location: Location;
+    readonly router: Router;
     readonly dialogServiceDefaults: MatDialogConfig<any>;
     readonly matDialogDefaultConfig: MatDialogConfig<any>;
     private readonly _activityList;
     private startingGuard;
     private currentActivityId;
-    constructor(dialogService: MatDialog, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
+    constructor(dialogService: MatDialog, location: Location, router: Router, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
     isActive(): boolean;
     cancelActivity(): void;
     readonly activityList: ListModel<Activity<any, any>>;

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

@@ -1,38 +1,38 @@
-import { OnInit } from '@angular/core';
-import { RouterOutlet } from '@angular/router';
+import { EventEmitter, OnInit } from '@angular/core';
+import { Router, RouterOutlet } from '@angular/router';
 import { MutableValueModel, ValueModel } from '@coolon/pectin';
 import { DisposableComponent } from '../../../components/disposable-component';
 import { PlaceComponent } from '../../place-component';
 import { PlaceDefinition } from '../../place-definition';
 import { PlaceHistory } from '../../place-history';
 import { PlaceRouter } from '../../place-router';
-import { ParameterSnapshot } from '../../route/parameter-snapshot';
+import { Visit } from '../../visit';
 interface PlaceRef {
     readonly placeDefinition: PlaceDefinition;
-    initialiseBindings(param: ValueModel<ParameterSnapshot>): void;
+    initialiseBindings(param: ValueModel<Visit>): void;
     onPlaceReady(): void;
 }
 export declare class PlaceOutletComponent extends DisposableComponent implements OnInit {
     private readonly router;
+    private readonly placeRouter;
     private readonly placeHistory;
     animate: boolean;
+    readonly placeChanged: EventEmitter<PlaceComponent>;
     routerOut: RouterOutlet;
     private readonly _activePlace;
-    private readonly _incomingRouteChange;
     private readonly _inOutletUpdate;
     private readonly _activatedRouteModel;
     private readonly _placeDefinition;
-    readonly _resolvedParameters: MutableValueModel<ParameterSnapshot>;
-    private placeConfigured;
-    constructor(router: PlaceRouter, placeHistory: PlaceHistory);
+    /** TODO: This is now really a visit */
+    readonly _placeVisit: MutableValueModel<Visit>;
+    constructor(router: Router, placeRouter: PlaceRouter, placeHistory: PlaceHistory);
     ngOnInit(): void;
-    readonly incomingRouteChange: ValueModel<boolean>;
-    readonly activePlace: ValueModel<PlaceComponent>;
+    pushVisitChangesToRoute(next: Visit, previous: Visit): void;
+    readonly activePlaceModel: ValueModel<PlaceComponent>;
     onOutletActivated(routerOutlet: RouterOutlet, place: PlaceComponent): void;
     onOutletDeactivated(routerOutlet: RouterOutlet, $event: PlaceRef): void;
     getPlaceOrder(outlet: RouterOutlet): any;
     animationDone(): void;
-    pushChangesToRoute(next: ParameterSnapshot, previous: ParameterSnapshot): void;
-    sanitise(snapshot: ParameterSnapshot, callback: (sanitised: ParameterSnapshot) => void): ParameterSnapshot;
+    activate(placeDestination: Visit): void;
 }
 export {};

package/lib/place/index.d.ts

@@ -2,6 +2,7 @@
  * @file Automatically generated by barrelsby.
  */
 export * from "./nav-item";
+export * from "./navigation-session";
 export * from "./place-component";
 export * from "./place-definition";
 export * from "./place-history";
@@ -16,12 +17,12 @@ export * from "./components/list-place-nav/list-place-nav.component";
 export * from "./components/place-outlet/place-outlet.component";
 export * from "./components/place-outlet/route-animations";
 export * from "./components/tabbed-place-navigation/tabbed-place-navigation.component";
-export * from "./guards/leave-place.guard";
-export * from "./guards/place-route.guard";
+export * from "./route/formatter";
 export * from "./route/json-types";
 export * from "./route/parameter-decorators";
 export * from "./route/parameter-definition.class";
 export * from "./route/parameter-sanitiser";
 export * from "./route/parameter-snapshot";
-export * from "./route/parameter-type";
-export * from "./route/route-parameter-value";
+export * from "./route/visit-sanitiser";
+export * from "./route/guards/leave-place.guard";
+export * from "./route/guards/place-route.guard";

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

@@ -0,0 +1,26 @@
+import { PlaceComponent } from './place-component';
+import { PlaceDefinition } from './place-definition';
+import { Visit } from './visit';
+export declare abstract class NavigationSession {
+    readonly firstNavigation: boolean;
+    private _alreadyAccepted;
+    private _visits;
+    private _popStateReturnUrl;
+    abstract readonly isExternal: boolean;
+    protected constructor(firstNavigation: boolean);
+    storeVisit(visit: Visit): void;
+    getVisitFor(placeDef: PlaceDefinition): Visit;
+    mergePrivatePlaceParameters(params: {
+        [p: string]: any;
+    }): NavigationSession;
+    alreadyAccepted(placeComponent: PlaceComponent): boolean;
+    rememberAcceptanceOf(component: PlaceComponent): void;
+    setPopstateReturn(url: string): void;
+    readonly isPopState: boolean;
+    readonly popStateReturnUrl: string;
+    getVisits(): Visit[];
+}
+export declare namespace NavigationSession {
+    function createInternal(visit: Visit): NavigationSession;
+    function createExternal(firstTimeRoute: boolean): NavigationSession;
+}

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

@@ -3,13 +3,13 @@ import 'reflect-metadata';
 import { DisposableComponent } from '../components/disposable-component';
 import { PlaceDefinition } from './place-definition';
 import { ParameterDefinition } from './route/parameter-definition.class';
-import { ParameterSnapshot } from './route/parameter-snapshot';
+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 resolvedParameters;
+    private visit;
     constructor();
-    initialiseBindings(resolvedParameters: ValueModel<ParameterSnapshot>): void;
+    initialiseBindings(visit: ValueModel<Visit>): void;
     private installBinding;
     readonly placeDefinition: PlaceDefinition;
     readonly childPlaces: Constructable<PlaceComponent>[];

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

@@ -1,6 +1,8 @@
+import { ParamMap } from '@angular/router';
 import { Constructable } from '@coolon/pectin';
 import { PlaceComponent } from './place-component';
 import { ParameterDefinition } from './route/parameter-definition.class';
+import { Visit } from './visit';
 export declare class PlaceDefinition {
     readonly component: Constructable<PlaceComponent>;
     readonly path: string;
@@ -14,7 +16,32 @@ export declare class PlaceDefinition {
     constructor(component: Constructable<PlaceComponent>, path: string, authenticate: boolean, order: number, data: {
         [key: string]: any;
     }, routeParameters: ParameterDefinition<any>[], children: PlaceDefinition[]);
-    getRouteParameters(): ParameterDefinition<any>[];
-    getData<T>(key: string, defaultValue?: T): T;
-    searchData<T>(keys: string[], defaultValue?: T): T;
+    hasRouteId(): boolean;
+    getRouteIdParameterDef(): ParameterDefinition<any>;
+    getRouteParameterDefs(includeRouteId?: boolean): ParameterDefinition<any>[];
+    getVisitParameterDefs(include?: PlaceDefinition.ParameterOptions): ParameterDefinition<any>[];
+    getPlaceData<T>(key: string, defaultValue?: T): T;
+    searchPlaceData<T>(keys: string[], defaultValue?: T): T;
+    getRouteIdFrom(visit: Visit): any;
+    /**
+     * Returns angular router commands that specify the route id and any route parameters.  The result does
+     * not include any path information.
+     */
+    getFormattedRouteId(visit: Visit): any;
+    getFormattedRouteParameters(visit: Visit, includeRouteId?: boolean): {
+        [p: string]: string;
+    };
+    getNonRouteParameters(visit: Visit): {
+        [p: string]: string;
+    };
+    parseRouteParams(params: ParamMap): {
+        [p: string]: any;
+    };
+}
+export declare namespace PlaceDefinition {
+    interface ParameterOptions {
+        includeRouteId?: boolean;
+        includeRouteParameters?: boolean;
+        includeNonRouteParameters?: boolean;
+    }
 }

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

@@ -1,12 +1,12 @@
 import { Router } from '@angular/router';
 import { PlaceDefinition } from './place-definition';
-import { ParameterSnapshot } from './route/parameter-snapshot';
+import { Visit } from './visit';
 export declare class PlaceHistory {
     private readonly router;
     private _history;
     constructor(router: Router);
-    add(state: ParameterSnapshot): void;
-    getHistory(placeDef: PlaceDefinition): ParameterSnapshot[];
+    add(state: Visit): void;
+    getHistory(placeDef: PlaceDefinition): Visit[];
     private setHistory;
 }
 export declare namespace VisitHistory {

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

@@ -1,24 +1,30 @@
 import { Location } from '@angular/common';
-import { ActivatedRoute, ActivatedRouteSnapshot, Router, UrlTree } from '@angular/router';
-import { PlaceComponent } from './place-component';
-import { ParameterSnapshot } from './route/parameter-snapshot';
-declare class NavigationSession {
-    readonly isPopState: boolean;
-    readonly initialUrl: string;
-    private _alreadyAccepted;
-    constructor(isPopState: boolean, initialUrl: string);
-    alreadyAccepted(placeComponent: PlaceComponent): boolean;
-    rememberAcceptanceOf(component: PlaceComponent): void;
-}
-export declare class PlaceRouter {
+import { ActivatedRoute, ActivatedRouteSnapshot, Router } from '@angular/router';
+import { BooleanValueModelChain, GarbageCollector, HasOneIndexChain, ListModel, ValueModel } from '@coolon/pectin';
+import { NavigationSession } from './navigation-session';
+import { PlaceHistory } from './place-history';
+import { Visit } from './visit';
+export declare class PlaceRouter extends GarbageCollector {
     private readonly router;
     readonly angularLocation: Location;
-    private readonly _navigationSession;
-    constructor(router: Router, angularLocation: Location);
+    readonly placeHistory: PlaceHistory;
+    private firstRoute;
+    private readonly _navigationSessionModel;
+    private readonly _activeVisits;
+    readonly navigationSessionActive: BooleanValueModelChain;
+    readonly activeVisitIndex: HasOneIndexChain<'placeDefinition', Visit>;
+    constructor(router: Router, angularLocation: Location, placeHistory: PlaceHistory);
     readonly navigationSession: NavigationSession;
-    pushParameterChangesToRoute(activatedRoute: ActivatedRoute, previous: ParameterSnapshot, next: ParameterSnapshot): void;
-    getRedirectUrlTree(activatedRoute: ActivatedRouteSnapshot, sanitised: ParameterSnapshot): UrlTree;
-    protected getChildPath(activatedRoute: ActivatedRouteSnapshot): any[];
-    protected createRouteParameters(parameters: ParameterSnapshot): any[];
+    readonly navigationSessionModel: ValueModel<NavigationSession>;
+    readonly activeVisits: ListModel<Visit>;
+    /**
+     *  placeRouter.navigate(placeDestinations.somePlace.createVisit(routeId, ...visitParams));
+     * @param visit
+     */
+    navigate(visit: Visit): Promise<void>;
+    pushVisitChangesToRoute(activatedRoute: ActivatedRoute, previous: Visit, next: Visit): Promise<void>;
+    doNavigation(visit: Visit, customNavigation?: (router: Router) => any): Promise<void>;
+    private onAngularRouterStarted;
+    private onAngularRouterFinished;
+    getChildPath(activatedRoute: ActivatedRouteSnapshot): any[];
 }
-export {};

package/lib/place/route/{parameter-type.d.ts → formatter.d.ts}

@@ -1,17 +1,17 @@
-export interface ParameterType<T> {
+export interface Formatter<T> {
     format(value: T): string;
     parse(value: string): T;
 }
-export declare namespace ParameterType {
-    class StringType implements ParameterType<string> {
+export declare namespace Formatter {
+    class StringType implements Formatter<string> {
         format(value: string): string;
         parse(value: string): string;
     }
-    class NumberType implements ParameterType<number> {
+    class NumberType implements Formatter<number> {
         format(value: number): string;
         parse(value: string): number;
     }
-    class BooleanType implements ParameterType<boolean> {
+    class BooleanType implements Formatter<boolean> {
         format(value: boolean): string;
         parse(value: string): boolean;
     }

package/lib/place/{guards → route/guards}/leave-place.guard.d.ts

@@ -1,9 +1,9 @@
 import { Location } from '@angular/common';
 import { Injector } from '@angular/core';
 import { ActivatedRouteSnapshot, CanDeactivate, Router, RouterStateSnapshot } from '@angular/router';
-import { InteractionContext } from '../../interaction/interaction-context';
-import { PlaceComponent } from '../place-component';
-import { PlaceRouter } from '../place-router';
+import { InteractionContext } from '../../../interaction/interaction-context';
+import { PlaceComponent } from '../../place-component';
+import { PlaceRouter } from '../../place-router';
 export declare class LeavePlaceGuard implements CanDeactivate<PlaceComponent> {
     private router;
     private injector;

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

@@ -0,0 +1,27 @@
+import { Injector } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, ParamMap, Router, RouterStateSnapshot, UrlSegment, UrlTree } from '@angular/router';
+import { PlaceHistory } from '../../place-history';
+import { PlaceRouter } from '../../place-router';
+export declare class PlaceRouteGuard implements CanActivate {
+    private readonly router;
+    private readonly placeRouter;
+    private readonly placeHistory;
+    private readonly injector;
+    constructor(router: Router, placeRouter: PlaceRouter, placeHistory: PlaceHistory, injector: Injector);
+    canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree>;
+}
+export declare namespace PlaceRouteGuard {
+    /**
+     * This a work around for the fact that an activated route with multiple segments doesn't
+     * include the segment params in the paramMap as well as each segment returns an empty
+     * param map even when `parameter`s has content.
+     */
+    class ConsolidatedParameterMap implements ParamMap {
+        private paramMaps;
+        constructor(paramMap: ParamMap, urlSegments: UrlSegment[]);
+        get(name: string): string | null;
+        getAll(name: string): string[];
+        has(name: string): boolean;
+        readonly keys: string[];
+    }
+}

package/lib/place/route/parameter-decorators.d.ts

@@ -1,16 +1,24 @@
-import { ParameterType } from './parameter-type';
-export interface ParameterOptions<T> {
+import { Formatter } from './formatter';
+export interface RouteIdOptions<T> {
     as?: string;
     optional?: boolean;
     remember?: boolean;
     defaultValue?: T;
 }
-export interface ListParameterOptions<T> {
+export interface RouteParameterOptions<T> {
+    as?: string;
+    optional?: boolean;
+    remember?: boolean;
+    defaultValue?: T;
+    storeInUrl?: Formatter<T>;
+}
+export interface RouteListParameterOptions<T> {
     as?: string;
     optional?: boolean;
     remember?: boolean;
     defaultValue?: T[];
+    storeInUrl?: Formatter<T>;
 }
-export declare function RouteId<T extends string | number>(type: ParameterType<T>, options?: ParameterOptions<T>): PropertyDecorator;
-export declare function RouteParameter<T>(type: ParameterType<T>, options?: ParameterOptions<T>): PropertyDecorator;
-export declare function RouteParameterList<E>(elementType: ParameterType<E>, options?: ListParameterOptions<E>): PropertyDecorator;
+export declare function RouteId<T extends string | number>(type: Formatter<T>, options?: RouteIdOptions<T>): PropertyDecorator;
+export declare function VisitParameter<T>(options?: RouteParameterOptions<T>): PropertyDecorator;
+export declare function VisitParameterList<E>(options?: RouteListParameterOptions<E>): PropertyDecorator;

package/lib/place/route/parameter-definition.class.d.ts

@@ -1,19 +1,23 @@
 import { Injector } from '@angular/core';
 import { PlaceHistory } from '../place-history';
 import { Visit } from '../visit';
-import { ParameterSanitiser } from './parameter-sanitiser';
-import { ParameterType } from './parameter-type';
-import { RouteParameterValue } from './route-parameter-value';
-export declare abstract class ParameterDefinition<T, S = T> {
+import { Formatter } from './formatter';
+export declare abstract class ParameterDefinition<T, E = T> {
     readonly propertyName: string;
-    readonly type: ParameterType<T>;
+    readonly urlFormat?: Formatter<E>;
     abstract readonly isRouteId: boolean;
     abstract readonly isArray: boolean;
+    readonly remember: boolean;
+    readonly defaultValue: T;
+    private options;
+    constructor(propertyName: string, options: ParameterDefinition.Options<T>, urlFormat?: Formatter<E>);
     readonly name: string;
-    private remember;
-    private defaultValue;
-    constructor(propertyName: string, type: ParameterType<T>, options: ParameterDefinition.Options<S>);
-    getSanitiser(injector: Injector): ParameterSanitiser<S>;
+    readonly isRouteParameter: boolean;
+    abstract isEmptyValue(value: T): boolean;
+    abstract hasChanged(a: any, b: any): boolean;
+    protected getOptionValue<K extends keyof ParameterDefinition.Options<T>>(key: K): ParameterDefinition.Options<T>[K];
+    sanitise(value: T, visit: Visit, placeHistory: PlaceHistory, injector: Injector): Promise<T>;
+    private isMissingFrom;
 }
 export declare namespace ParameterDefinition {
     interface Options<T> {
@@ -25,20 +29,20 @@ export declare namespace ParameterDefinition {
     class RouteId<T> extends ParameterDefinition<T> {
         readonly isRouteId = true;
         readonly isArray = false;
+        isEmptyValue(value: T): boolean;
+        hasChanged(a: any, b: any): boolean;
     }
     class ValueParameter<T> extends ParameterDefinition<T> {
         readonly isRouteId = false;
         readonly isArray = false;
+        isEmptyValue(value: T): boolean;
+        hasChanged(a: any, b: any): boolean;
     }
-    class ArrayParameter<T> extends ParameterDefinition<T, T[]> {
+    class ArrayParameter<T> extends ParameterDefinition<T[], T> {
         readonly isRouteId = false;
         readonly isArray = true;
-    }
-    class DefaultParameterSanitiser<T, S> implements ParameterSanitiser<S> {
-        readonly remember: boolean;
-        readonly defaultValue: S;
-        readonly placeHistory: PlaceHistory;
-        constructor(remember: boolean, defaultValue: S, placeHistory: PlaceHistory);
-        sanitise(parameter: RouteParameterValue<S, any, any>, visit?: Visit): Promise<S> | S;
+        constructor(parameterName: string, options: Options<T[]>, urlFormat: Formatter<T>);
+        isEmptyValue(value: T[]): boolean;
+        hasChanged(a: T[], b: T[]): boolean;
     }
 }

package/lib/place/route/parameter-sanitiser.d.ts

@@ -1,5 +1,6 @@
+import { Injector } from '@angular/core';
 import { Visit } from '../visit';
-import { RouteParameterValue } from './route-parameter-value';
+import { ParameterSnapshot } from './parameter-snapshot';
 export interface ParameterSanitiser<S> {
-    sanitise(paramter: RouteParameterValue<S, any, any>, visit?: Visit): Promise<S> | S;
+    sanitise(parameterValue: ParameterSnapshot<S>, visit?: Visit, injector?: Injector): Promise<S> | S;
 }

package/lib/place/route/parameter-snapshot.d.ts

@@ -1,28 +1,6 @@
-import { Injector } from '@angular/core';
-import { ParamMap, UrlSegment } from '@angular/router';
-import { PlaceDefinition } from '../place-definition';
-import { Visit } from '../visit';
 import { ParameterDefinition } from './parameter-definition.class';
-import { RouteParameterValue } from './route-parameter-value';
-export declare class ParameterSnapshot implements Visit {
-    readonly placeDefinition: PlaceDefinition;
-    private readonly parameters;
-    constructor(placeDefinition: PlaceDefinition, parameters: RouteParameterValue<any, any, any>[]);
-    hasChanged(other: ParameterSnapshot, debug?: boolean): boolean;
-    getParameter<T, S>(parameterDef: ParameterDefinition<T, S>): RouteParameterValue<S, T, any>;
-    getValueOf<T, S>(parameterDef: ParameterDefinition<T, S>): S;
-    getRouteIdValue(): any;
-    getParameterValue(name: string): any;
-    private getRouteIdParameter;
-    private getRouteParameters;
-    hasRouteId(): boolean;
-    getFormattedRouteId(): string;
-    getNonEmptyParameters(): RouteParameterValue<any, any, any>[];
-    getFormattedParameters(): {};
-    getAllParameters(): {};
-    replace<T, S>(parameter: ParameterDefinition<T, S>, value: S): ParameterSnapshot;
-    sanitise(injector: Injector): Promise<ParameterSnapshot>;
-}
-export declare namespace ParameterSnapshot {
-    function create(placeDef: PlaceDefinition, params: ParamMap, urlSegments: UrlSegment[]): ParameterSnapshot;
+export interface ParameterSnapshot<T> {
+    definition: ParameterDefinition<T, any>;
+    readonly value: T;
+    isMissing(): boolean;
 }

package/lib/place/route/visit-sanitiser.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '@angular/core';
+import { ActivatedRouteSnapshot, Router } from '@angular/router';
+import { PlaceHistory } from '../place-history';
+import { Visit } from '../visit';
+export declare class VisitSanitiser {
+    private activatedRoute;
+    private router;
+    private placeHistory;
+    private injector;
+    constructor(activatedRoute: ActivatedRouteSnapshot, router: Router, placeHistory: PlaceHistory, injector: Injector);
+    sanitise(visit: Visit): Promise<Visit>;
+}

package/lib/place/visit.d.ts

@@ -1,6 +1,27 @@
 import { PlaceDefinition } from './place-definition';
-export interface Visit {
+import { ParameterDefinition } from './route/parameter-definition.class';
+interface Params {
+    [p: string]: any;
+}
+export declare class Visit {
     readonly placeDefinition: PlaceDefinition;
-    getRouteIdValue(): any;
-    getParameterValue(name: string): any;
+    private readonly visitParameters;
+    constructor(placeDefinition: PlaceDefinition, visitParameters?: Params);
+    getRouteId(): any;
+    hasRouteId(): boolean;
+    /**
+     * Returns the value of the place parameter with the specified name.  The parameter
+     * name is taken from the `as` option, e.g. {as: 'aCustomName'} otherwise it is the
+     * same as the the ValueModel property name.
+     * @param parameterName the field name of the property model or the `as` option if specified.
+     */
+    getParameter(parameterName: string): any;
+    hasParameter(parameterName: string): boolean;
+    replace<S>(parameter: ParameterDefinition<any, S>, value: S): Visit;
+    mergeRouteParameters<S>(routeParams: {
+        [p: string]: any;
+    }): Visit;
+    hasRoutingChangedFrom(other: Visit): boolean;
+    hasChangedFrom(other: Visit): boolean;
 }
+export {};

package/package.json

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

package/schematics/place-routes/place-class-scanner.d.ts

@@ -16,8 +16,8 @@ export declare class PlaceClassScanner {
     private extractChildComponentClassNames;
     protected getRouteIdParameter(): PlaceClassScanner.RouteParameterInfo;
     protected getRouteParameters(): PlaceDef.Parameter[];
-    private getValueModelRouteProperties;
-    private getListModelRouteProperties;
+    private getVisitValueParameters;
+    private getVisitListParameters;
     protected getDecoratedProperties(annotation: string): {
         decorator: Decorator;
         property: PropertyDeclaration;

package/schematics/place-routes/place-class-scanner.js

@@ -94,23 +94,23 @@ class PlaceClassScanner {
         return null;
     }
     getRouteParameters() {
-        return this.getValueModelRouteProperties().concat(this.getListModelRouteProperties());
+        return this.getVisitValueParameters().concat(this.getVisitListParameters());
     }
-    getValueModelRouteProperties() {
-        return this.getDecoratedProperties('@RouteParameter')
+    getVisitValueParameters() {
+        return this.getDecoratedProperties('@VisitParameter')
             .map(p => {
             const routeOptions = PlaceClassScanner.getOptionsArg(p.decorator, { as: p.property.getName() }, {
-                position: 1,
+                position: 0,
                 required: false
             });
             return new PlaceClassScanner.RouteParameterInfo(routeOptions.as, p.property);
         });
     }
-    getListModelRouteProperties() {
-        return this.getDecoratedProperties('@RouteParameterList')
+    getVisitListParameters() {
+        return this.getDecoratedProperties('@VisitParameterList')
             .map(p => {
             const routeOptions = PlaceClassScanner.getOptionsArg(p.decorator, { as: p.property.getName() }, {
-                position: 1,
+                position: 0,
                 required: false
             });
             return new PlaceClassScanner.RouteParameterInfo(routeOptions.as, p.property);