@coolon/angular-ui-powerups 12.4.8 → 13.0.0

package/esm2020/lib/place/components/place-outlet/place-outlet.component.mjs

@@ -0,0 +1,256 @@
+import { __decorate, __metadata } from "tslib";
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ChangeDetectorRef, Component, EventEmitter, HostBinding, Inject, InjectionToken, Input, Optional, Output, SkipSelf, ViewChild } from '@angular/core';
+import { Router, RouterOutlet } from '@angular/router';
+import { DebugContext, Dsl, lang, ListModel, MutableValueModel, StoreInListModel, StoreInValueModel, TrackExternal, ValueModel } from '@coolon/pectin';
+import { isNil } from 'lodash';
+import { DisposableComponent } from '../../../components/disposable-component';
+import { AUP_PLACE_CONFIG } from '../../place-config';
+import { PlaceRouter } from '../../place-router';
+import { NotAuthorisedNoticeComponent } from '../not-authorised-notice/not-authorised-notice.component';
+import { LEFT_RIGHT_PLACE_ANIMATION } from './route-animations';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../place-router";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/cdk/scrolling";
+import * as i5 from "@angular/cdk/portal";
+export const AUP_UNAUTHORISED_PLACE_NOTICE_COMPONENT = new InjectionToken('AUP_UNAUTHORISED_PLACE_COMPONENT');
+export class PlaceOutletComponent extends DisposableComponent {
+    constructor(router, placeRouter, placeConfig, unauthorisedPlaceNotice, parentOutlet, cdr) {
+        super();
+        this.router = router;
+        this.placeRouter = placeRouter;
+        this.placeConfig = placeConfig;
+        this.cdr = cdr;
+        this.placeChanged = new EventEmitter();
+        this.outletActivated = new MutableValueModel(false);
+        this._activatedRouteModel = new MutableValueModel();
+        this._activePlaceModel = new MutableValueModel();
+        this.initialPlaceIndex = null;
+        this._isPushingVisitToRoute = new MutableValueModel(false);
+        this.isVeryFirstLoad = true;
+        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
+        this.parentOutletModel = new MutableValueModel(parentOutlet);
+        const defaultPlaceAnimationOrder = chain(this.parentOutletModel)
+            .pullValueModel(o => o.activePlaceModel)
+            .pluck('placeDefinition')
+            .pluckList('children')
+            .pluck('component');
+        const activatePlaceType = chain(this.activePlaceModel).map(p => p.constructor);
+        this.placesInAnimationOrder = chain(this.customPlaceAnimationOrderModel)
+            .otherwise(defaultPlaceAnimationOrder);
+        this.activePlaceAnimationPosition = this.placesInAnimationOrder
+            .reduce((placesInOrder) => {
+            let placeIndex = 0;
+            if (activatePlaceType.value) {
+                placeIndex = placesInOrder.indexOf(activatePlaceType.value);
+                if (isNil(this.initialPlaceIndex)) {
+                    this.initialPlaceIndex = placeIndex;
+                }
+            }
+            return isNil(this.initialPlaceIndex) ? 0 : placeIndex - this.initialPlaceIndex;
+        }, { dependsOn: activatePlaceType });
+        this.animationSupported = this.placesInAnimationOrder.count().isGreaterThan(0);
+        this.animationEnabled = valueOf.all(this.animateModel, this.animationSupported).areTruthy();
+        // Extract our visit model from the place router.
+        this._activePlaceDefinition = chain(this._activePlaceModel).pluck('placeDefinition');
+        this.routerVisitModel = chain(placeRouter.state).map(state => state.getVisitFor(this._activePlaceDefinition.value), { dependsOn: this._activePlaceDefinition });
+        this.navigationInProgress = chain(this.placeRouter.navigationInProgress);
+        when(this.navigationInProgress).becomesFalsey(() => {
+            this.checkStateAndInitialise();
+        });
+        when(this.outletActivated).becomesTruthy(() => {
+            this.checkStateAndInitialise();
+        });
+        chain(this._activePlaceModel)
+            .postponeWhile(this.navigationInProgress)
+            .subscribe(place => this.placeChanged.emit(place));
+        this.authorised = chain(placeRouter.accessGuard).map(guard => guard.isAuthorised(this._activePlaceDefinition.value), {
+            dependsOn: this._activePlaceDefinition,
+            postponeWhile: chain(this._activePlaceDefinition).isNil()
+        }).otherwise(true); // if we don't have a place def yet we need to show the outlet so we get one injected.
+        this.notAuthorisedNoticePortal = new ComponentPortal(unauthorisedPlaceNotice ?? NotAuthorisedNoticeComponent);
+    }
+    // @Trace()
+    ngOnInit() {
+    }
+    // @Trace()
+    getAnimationOrder() {
+        return this.activePlaceAnimationPosition.value;
+    }
+    get animationDuration() {
+        return this.placeConfig && this.placeConfig.animationDuration ? this.placeConfig.animationDuration : '500ms';
+    }
+    get isAuthorised() {
+        return this.authorised.value;
+    }
+    // @Trace()
+    navigate(visit) {
+        // const place = this.placesInAnimationOrder.query().findMatching(p => visit.placeDefinition.component === p);
+        // if (!place) {
+        //     lang.illegalState()
+        // }
+        this.placeRouter.navigate(visit, {
+            relativeTo: this.parentOutlet ? this.parentOutlet.activatedRouteModel.value : null
+        });
+    }
+    get parentOutlet() {
+        return this.parentOutletModel.value;
+    }
+    get activePlaceModel() {
+        return this._activePlaceModel.readonly;
+    }
+    get activatedRouteModel() {
+        return this._activatedRouteModel.readonly;
+    }
+    // @Trace()
+    onOutletActivated(routerOutlet, place) {
+        this._activatedRouteModel.value = routerOutlet.activatedRoute;
+        this._activePlaceModel.value = place;
+        this.validateAnimationState(place);
+        this.outletActivated.value = true;
+        this.checkStateAndInitialise();
+    }
+    validateAnimationState(place) {
+        if (this.animateModel.value) {
+            if (this.placesInAnimationOrder.length < 1) {
+                console.error('PlaceOutlet.animate === true but placeAnimationOrder has not been set. Animation is disabled.');
+            }
+            else {
+                if (!this.placesInAnimationOrder.query().includes(place.placeDefinition.component)) {
+                    console.error(`PlaceOutlet.animate === true but placeAnimationOrder doesn't contain ${place.placeDefinition.component.name}.`);
+                }
+            }
+        }
+    }
+    // @Trace()
+    onOutletDeactivated() {
+        this.outletActivated.value = false;
+        this._activePlaceModel.value = null;
+        this._activatedRouteModel.value = null;
+    }
+    // @Trace()
+    checkStateAndInitialise() {
+        const routerVisit = this.routerVisitModel.value;
+        const activePlace = this.activePlaceModel.value;
+        if (routerVisit && activePlace && !activePlace.isInitialised()) {
+            if (routerVisit.placeDefinition !== activePlace.placeDefinition) {
+                lang.illegalState('wrong visit!!!');
+            }
+            this.initialisePlace(routerVisit, activePlace);
+            this.cdr.detectChanges();
+        }
+    }
+    initialisePlace(routerVisit, activePlace) {
+        const visitModel = new MutableValueModel(routerVisit);
+        DebugContext.tag(visitModel, `PlaceOutletComponent[${activePlace.constructor.name})].visitModel`);
+        activePlace.initialiseVisit(routerVisit, (current, previous) => {
+            this.pushVisitChangeToRoute(previous, current);
+        });
+        const finishPlaceLoad = () => {
+            this._activePlaceModel.value._notifyActive(true);
+        };
+        if (!this.animationEnabled.value || this.isVeryFirstLoad) {
+            // if animation is disabled or this is the very first load then
+            // we won't get our animation done callback so we finish the
+            // process here and now.
+            this.isVeryFirstLoad = false;
+            finishPlaceLoad();
+        }
+        else {
+            this.onAnimationFinishedJob = finishPlaceLoad;
+        }
+        const { when, chain, valueOf } = Dsl.disposeWith(activePlace);
+        when(this.routerVisitModel)
+            .changes(visit => {
+            console.log("routerVisitModel.change", { routerVisitModel: this.routerVisitModel.value });
+            this.pushVisitChangeToComponent(activePlace, visit);
+        }, {
+            unless: valueOf.any(this._isPushingVisitToRoute, this.routerVisitModel.isNil()).areTruthy()
+        });
+    }
+    pushVisitChangeToComponent(activePlace, visit) {
+        activePlace.updateVisit(visit);
+    }
+    async pushVisitChangeToRoute(previous, current) {
+        try {
+            this._isPushingVisitToRoute.value = true;
+            await this.placeRouter.pushVisitChangesToRoute(previous, current);
+        }
+        finally {
+            this._isPushingVisitToRoute.value = false;
+        }
+        // sanitisers may have adjusted other values in the visit to we check and write it back.
+        const routerVisit = this.routerVisitModel.value; // this is occasionally null... need to investigate if that's a normal state or not.
+        if (routerVisit && current.hasRoutingChangedFrom(routerVisit)) {
+            this.pushVisitChangeToComponent(this.activePlaceModel.value, routerVisit);
+        }
+    }
+    // @Trace()
+    animationStarted() {
+        // console.log({ activePlace: this._activePlaceModel.value });
+    }
+    // @Trace()
+    animationDone() {
+        if (this.onAnimationFinishedJob) {
+            this.onAnimationFinishedJob();
+            this.onAnimationFinishedJob = undefined;
+        }
+    }
+}
+PlaceOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: PlaceOutletComponent, deps: [{ token: i1.Router }, { token: i2.PlaceRouter }, { token: AUP_PLACE_CONFIG, optional: true }, { token: AUP_UNAUTHORISED_PLACE_NOTICE_COMPONENT, optional: true }, { token: PlaceOutletComponent, optional: true, skipSelf: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PlaceOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: PlaceOutletComponent, selector: "aup-place-outlet", inputs: { animate: "animate", animateModel: "animateModel", customPlaceAnimationOrderModel: ["placeAnimationOrderModel", "customPlaceAnimationOrderModel"], customPlaceAnimationOrder: ["placeAnimationOrder", "customPlaceAnimationOrder"] }, outputs: { placeChanged: "placeChanged" }, host: { properties: { "class.authorised": "this.isAuthorised" } }, viewQueries: [{ propertyName: "routerOut", first: true, predicate: ["routeOutlet"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"animationEnabled.value\">\n  <div class=\"router-outlet-container\"\n       cdkScrollable\n       [@routeAnimations]=\"{value: getAnimationOrder(), params:{duration: animationDuration}}\"\n       (@routeAnimations.start)=\"animationStarted()\"\n       (@routeAnimations.done)=\"animationDone()\"\n  >\n    <router-outlet #routerOutlet=\"outlet\"\n                   (activate)=\"onOutletActivated(routerOutlet, $event)\"\n                   (deactivate)=\"onOutletDeactivated()\">\n    </router-outlet>\n  </div>\n</ng-container>\n\n<ng-container *ngIf=\"!animationEnabled.value\">\n  <div class=\"router-outlet-container\"\n       cdkScrollable>\n    <router-outlet #routerOutlet=\"outlet\"\n                   (activate)=\"onOutletActivated(routerOutlet, $event)\"\n                   (deactivate)=\"onOutletDeactivated()\">\n    </router-outlet>\n  </div>\n</ng-container>\n\n<div  class=\"not-authorised-component-container\" *ngIf=\"!authorised.value\">\n  <ng-template [cdkPortalOutlet]=\"notAuthorisedNoticePortal\"></ng-template>\n</div>\n", styles: [":host{display:flex;flex-direction:column;min-height:0}:host:not(.authorised) .router-outlet-container{display:none}.router-outlet-container{flex:1;display:block;position:relative;min-height:0;overflow-x:hidden;overflow-y:auto}router-outlet{display:none}.not-authorised-component-container{flex:1;display:grid;grid-template-columns:1fr;grid-template-rows:1fr}\n"], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.CdkScrollable, selector: "[cdk-scrollable], [cdkScrollable]" }, { type: i1.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }, { type: i5.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }], animations: [LEFT_RIGHT_PLACE_ANIMATION] });
+__decorate([
+    StoreInValueModel('animateModel'),
+    __metadata("design:type", Boolean)
+], PlaceOutletComponent.prototype, "animate", void 0);
+__decorate([
+    TrackExternal({ defaultValue: true }),
+    __metadata("design:type", ValueModel)
+], PlaceOutletComponent.prototype, "animateModel", void 0);
+__decorate([
+    TrackExternal(),
+    __metadata("design:type", ListModel)
+], PlaceOutletComponent.prototype, "customPlaceAnimationOrderModel", void 0);
+__decorate([
+    StoreInListModel('customPlaceAnimationOrderModel'),
+    __metadata("design:type", Array)
+], PlaceOutletComponent.prototype, "customPlaceAnimationOrder", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: PlaceOutletComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-place-outlet', animations: [LEFT_RIGHT_PLACE_ANIMATION], template: "<ng-container *ngIf=\"animationEnabled.value\">\n  <div class=\"router-outlet-container\"\n       cdkScrollable\n       [@routeAnimations]=\"{value: getAnimationOrder(), params:{duration: animationDuration}}\"\n       (@routeAnimations.start)=\"animationStarted()\"\n       (@routeAnimations.done)=\"animationDone()\"\n  >\n    <router-outlet #routerOutlet=\"outlet\"\n                   (activate)=\"onOutletActivated(routerOutlet, $event)\"\n                   (deactivate)=\"onOutletDeactivated()\">\n    </router-outlet>\n  </div>\n</ng-container>\n\n<ng-container *ngIf=\"!animationEnabled.value\">\n  <div class=\"router-outlet-container\"\n       cdkScrollable>\n    <router-outlet #routerOutlet=\"outlet\"\n                   (activate)=\"onOutletActivated(routerOutlet, $event)\"\n                   (deactivate)=\"onOutletDeactivated()\">\n    </router-outlet>\n  </div>\n</ng-container>\n\n<div  class=\"not-authorised-component-container\" *ngIf=\"!authorised.value\">\n  <ng-template [cdkPortalOutlet]=\"notAuthorisedNoticePortal\"></ng-template>\n</div>\n", styles: [":host{display:flex;flex-direction:column;min-height:0}:host:not(.authorised) .router-outlet-container{display:none}.router-outlet-container{flex:1;display:block;position:relative;min-height:0;overflow-x:hidden;overflow-y:auto}router-outlet{display:none}.not-authorised-component-container{flex:1;display:grid;grid-template-columns:1fr;grid-template-rows:1fr}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.PlaceRouter }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUP_PLACE_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUP_UNAUTHORISED_PLACE_NOTICE_COMPONENT]
+                }] }, { type: PlaceOutletComponent, decorators: [{
+                    type: SkipSelf
+                }, {
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { animate: [{
+                type: Input
+            }], animateModel: [{
+                type: Input
+            }], customPlaceAnimationOrderModel: [{
+                type: Input,
+                args: ['placeAnimationOrderModel']
+            }], customPlaceAnimationOrder: [{
+                type: Input,
+                args: ['placeAnimationOrder']
+            }], placeChanged: [{
+                type: Output
+            }], routerOut: [{
+                type: ViewChild,
+                args: ['routeOutlet', { static: true }]
+            }], isAuthorised: [{
+                type: HostBinding,
+                args: ["class.authorised"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-outlet.component.js","sourceRoot":"","sources":["../../../../../../../../libs/angular-ui-powerups/src/lib/place/components/place-outlet/place-outlet.component.ts","../../../../../../../../libs/angular-ui-powerups/src/lib/place/components/place-outlet/place-outlet.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ComponentPortal } from '@angular/cdk/portal';\nimport {\n  ChangeDetectorRef,\n  Component,\n  EventEmitter, HostBinding,\n  Inject,\n  InjectionToken,\n  Input,\n  OnInit,\n  Optional,\n  Output,\n  SkipSelf,\n  ViewChild\n} from '@angular/core';\nimport { ActivatedRoute, Router, RouterOutlet } from '@angular/router';\nimport {\n  BooleanValueModelChain,\n  Constructable,\n  DebugContext,\n  Dsl,\n  lang,\n  ListModel,\n  ListModelChain,\n  MutableValueModel,\n  StoreInListModel,\n  StoreInValueModel,\n  TrackExternal,\n  ValueModel,\n  ValueModelChain\n} from '@coolon/pectin';\n\nimport { isNil } from 'lodash';\nimport { DisposableComponent } from '../../../components/disposable-component';\nimport { PlaceComponent } from '../../place-component';\n\nimport { AUP_PLACE_CONFIG, PlaceConfig } from '../../place-config';\nimport { PlaceDefinition } from '../../place-definition';\nimport { PlaceRouter } from '../../place-router';\nimport { Visit } from '../../visit';\n\nimport { NotAuthorisedNoticeComponent } from '../not-authorised-notice/not-authorised-notice.component';\nimport { LEFT_RIGHT_PLACE_ANIMATION } from './route-animations';\n\n\nexport const AUP_UNAUTHORISED_PLACE_NOTICE_COMPONENT = new InjectionToken<Constructable<any>>('AUP_UNAUTHORISED_PLACE_COMPONENT');\n\n@Component({\n  selector: 'aup-place-outlet',\n  templateUrl: './place-outlet.component.html',\n  styleUrls: ['./place-outlet.component.scss'],\n  animations: [LEFT_RIGHT_PLACE_ANIMATION]\n})\nexport class PlaceOutletComponent extends DisposableComponent implements OnInit {\n\n  @Input() @StoreInValueModel('animateModel')\n  animate: boolean;\n\n  @Input() @TrackExternal({ defaultValue: true })\n  animateModel: ValueModel<boolean>;\n\n  // tslint:disable-next-line:no-input-rename\n  @Input('placeAnimationOrderModel') @TrackExternal()\n  customPlaceAnimationOrderModel: ListModel<Constructable<PlaceComponent>>;\n\n  // tslint:disable-next-line:no-input-rename\n  @Input('placeAnimationOrder') @StoreInListModel('customPlaceAnimationOrderModel')\n  customPlaceAnimationOrder: Constructable<PlaceComponent>[];\n\n  @Output()\n  readonly placeChanged = new EventEmitter<PlaceComponent>();\n\n  @ViewChild('routeOutlet', { static: true })\n  routerOut: RouterOutlet;\n\n  private onAnimationFinishedJob: () => void;\n\n\n  private outletActivated = new MutableValueModel(false);\n  private readonly _activatedRouteModel = new MutableValueModel<ActivatedRoute>();\n  private readonly _activePlaceModel = new MutableValueModel<PlaceComponent>();\n\n  readonly _activePlaceDefinition: ValueModelChain<PlaceDefinition>;\n\n  private parentOutletModel: MutableValueModel<PlaceOutletComponent>;\n  public readonly activePlaceAnimationPosition: ValueModelChain<number>;\n\n  private initialPlaceIndex: number = null;\n  private routerVisitModel: ValueModelChain<Visit>;\n  private _isPushingVisitToRoute = new MutableValueModel<boolean>(false);\n  private navigationInProgress: ValueModelChain<boolean>;\n\n  private isVeryFirstLoad = true;\n  private placesInAnimationOrder: ListModelChain<Constructable<PlaceComponent>>;\n  private animationSupported: BooleanValueModelChain;\n  readonly animationEnabled: BooleanValueModelChain;\n  readonly authorised: ValueModelChain<boolean>;\n  readonly notAuthorisedNoticePortal: ComponentPortal<any>;\n\n  constructor(private readonly router: Router,\n              private readonly placeRouter: PlaceRouter,\n              @Optional() @Inject(AUP_PLACE_CONFIG) readonly placeConfig: PlaceConfig,\n              @Optional() @Inject(AUP_UNAUTHORISED_PLACE_NOTICE_COMPONENT) unauthorisedPlaceNotice: Constructable<any>,\n              @SkipSelf() @Optional() parentOutlet: PlaceOutletComponent,\n              private readonly cdr: ChangeDetectorRef) {\n    super();\n    const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);\n\n    this.parentOutletModel = new MutableValueModel(parentOutlet);\n\n    const defaultPlaceAnimationOrder = chain(this.parentOutletModel)\n      .pullValueModel(o => o.activePlaceModel)\n      .pluck('placeDefinition')\n      .pluckList('children')\n      .pluck('component');\n\n    const activatePlaceType = chain(this.activePlaceModel).map(p => p.constructor as Constructable<PlaceComponent>);\n\n    this.placesInAnimationOrder = chain(this.customPlaceAnimationOrderModel)\n      .otherwise(defaultPlaceAnimationOrder);\n\n    this.activePlaceAnimationPosition = this.placesInAnimationOrder\n      .reduce((placesInOrder) => {\n        let placeIndex = 0;\n        if (activatePlaceType.value) {\n          placeIndex = placesInOrder.indexOf(activatePlaceType.value);\n          if (isNil(this.initialPlaceIndex)) {\n            this.initialPlaceIndex = placeIndex;\n          }\n        }\n        return isNil(this.initialPlaceIndex) ? 0 : placeIndex - this.initialPlaceIndex;\n      }, { dependsOn: activatePlaceType });\n\n    this.animationSupported = this.placesInAnimationOrder.count().isGreaterThan(0);\n    this.animationEnabled = valueOf.all(\n      this.animateModel,\n      this.animationSupported\n    ).areTruthy();\n\n    // Extract our visit model from the place router.\n    this._activePlaceDefinition = chain(this._activePlaceModel).pluck('placeDefinition');\n    this.routerVisitModel = chain(placeRouter.state).map(state => state.getVisitFor(this._activePlaceDefinition.value), { dependsOn: this._activePlaceDefinition });\n\n    this.navigationInProgress = chain(this.placeRouter.navigationInProgress);\n\n    when(this.navigationInProgress).becomesFalsey(() => {\n      this.checkStateAndInitialise();\n    });\n    when(this.outletActivated).becomesTruthy(() => {\n      this.checkStateAndInitialise();\n    });\n\n    chain(this._activePlaceModel)\n      .postponeWhile(this.navigationInProgress)\n      .subscribe(place => this.placeChanged.emit(place));\n\n    this.authorised = chain(placeRouter.accessGuard).map(guard => guard.isAuthorised(this._activePlaceDefinition.value), {\n      dependsOn: this._activePlaceDefinition,\n      postponeWhile: chain(this._activePlaceDefinition).isNil()\n    }).otherwise(true); // if we don't have a place def yet we need to show the outlet so we get one injected.\n\n    this.notAuthorisedNoticePortal = new ComponentPortal(unauthorisedPlaceNotice ?? NotAuthorisedNoticeComponent);\n  }\n\n  // @Trace()\n  ngOnInit() {\n  }\n\n  // @Trace()\n  getAnimationOrder() {\n    return this.activePlaceAnimationPosition.value;\n  }\n\n  get animationDuration() {\n    return this.placeConfig && this.placeConfig.animationDuration ? this.placeConfig.animationDuration : '500ms';\n  }\n\n  @HostBinding(\"class.authorised\")\n  get isAuthorised() {\n    return this.authorised.value;\n  }\n\n  // @Trace()\n  navigate(visit: Visit) {\n    // const place = this.placesInAnimationOrder.query().findMatching(p => visit.placeDefinition.component === p);\n    // if (!place) {\n    //     lang.illegalState()\n    // }\n    this.placeRouter.navigate(visit, {\n      relativeTo: this.parentOutlet ? this.parentOutlet.activatedRouteModel.value : null\n    });\n  }\n\n  get parentOutlet(): PlaceOutletComponent {\n    return this.parentOutletModel.value;\n  }\n\n\n  get activePlaceModel(): ValueModel<PlaceComponent> {\n    return this._activePlaceModel.readonly;\n  }\n\n  get activatedRouteModel(): ValueModel<ActivatedRoute> {\n    return this._activatedRouteModel.readonly;\n  }\n\n  // @Trace()\n  onOutletActivated(routerOutlet: RouterOutlet, place: PlaceComponent) {\n    this._activatedRouteModel.value = routerOutlet.activatedRoute;\n    this._activePlaceModel.value = place;\n    this.validateAnimationState(place);\n    this.outletActivated.value = true;\n    this.checkStateAndInitialise();\n  }\n\n  private validateAnimationState(place: PlaceComponent) {\n    if (this.animateModel.value) {\n      if (this.placesInAnimationOrder.length < 1) {\n        console.error('PlaceOutlet.animate === true but placeAnimationOrder has not been set. Animation is disabled.');\n      } else {\n        if (!this.placesInAnimationOrder.query().includes(place.placeDefinition.component)) {\n          console.error(`PlaceOutlet.animate === true but placeAnimationOrder doesn't contain ${place.placeDefinition.component.name}.`);\n        }\n      }\n    }\n  }\n\n  // @Trace()\n  onOutletDeactivated() {\n    this.outletActivated.value = false;\n    this._activePlaceModel.value = null;\n    this._activatedRouteModel.value = null;\n  }\n\n  // @Trace()\n  private checkStateAndInitialise() {\n    const routerVisit = this.routerVisitModel.value;\n    const activePlace = this.activePlaceModel.value;\n    if (routerVisit && activePlace && !activePlace.isInitialised()) {\n      if (routerVisit.placeDefinition !== activePlace.placeDefinition) {\n        lang.illegalState('wrong visit!!!');\n      }\n      this.initialisePlace(routerVisit, activePlace);\n      this.cdr.detectChanges()\n    }\n  }\n\n  private initialisePlace(routerVisit: Visit, activePlace: PlaceComponent) {\n    const visitModel = new MutableValueModel<Visit>(routerVisit);\n    DebugContext.tag(visitModel, `PlaceOutletComponent[${activePlace.constructor.name})].visitModel`);\n    activePlace.initialiseVisit(routerVisit, (current, previous) => {\n      this.pushVisitChangeToRoute(previous, current);\n    });\n    const finishPlaceLoad = () => {\n      this._activePlaceModel.value._notifyActive(true);\n    };\n    if (!this.animationEnabled.value || this.isVeryFirstLoad) {\n      // if animation is disabled or this is the very first load then\n      // we won't get our animation done callback so we finish the\n      // process here and now.\n      this.isVeryFirstLoad = false;\n      finishPlaceLoad();\n    } else {\n      this.onAnimationFinishedJob = finishPlaceLoad;\n    }\n    const { when, chain, valueOf } = Dsl.disposeWith(activePlace);\n    when(this.routerVisitModel)\n      .changes(visit => {\n        console.log(\"routerVisitModel.change\", { routerVisitModel: this.routerVisitModel.value })\n        this.pushVisitChangeToComponent(activePlace, visit);\n      }, {\n        unless: valueOf.any(\n          this._isPushingVisitToRoute,\n          this.routerVisitModel.isNil()\n        ).areTruthy()\n      });\n  }\n\n  private pushVisitChangeToComponent(activePlace: PlaceComponent, visit: Visit) {\n    activePlace.updateVisit(visit);\n  }\n\n  private async pushVisitChangeToRoute(previous: Visit, current: Visit) {\n    try {\n      this._isPushingVisitToRoute.value = true;\n      await this.placeRouter.pushVisitChangesToRoute(previous, current);\n    } finally {\n      this._isPushingVisitToRoute.value = false;\n    }\n    // sanitisers may have adjusted other values in the visit to we check and write it back.\n    const routerVisit = this.routerVisitModel.value; // this is occasionally null... need to investigate if that's a normal state or not.\n    if (routerVisit && current.hasRoutingChangedFrom(routerVisit)) {\n      this.pushVisitChangeToComponent(this.activePlaceModel.value, routerVisit)\n    }\n  }\n\n// @Trace()\n  animationStarted() {\n    // console.log({ activePlace: this._activePlaceModel.value });\n  }\n\n  // @Trace()\n  animationDone() {\n    if (this.onAnimationFinishedJob) {\n      this.onAnimationFinishedJob();\n      this.onAnimationFinishedJob = undefined;\n    }\n  }\n\n}\n","<ng-container *ngIf=\"animationEnabled.value\">\n  <div class=\"router-outlet-container\"\n       cdkScrollable\n       [@routeAnimations]=\"{value: getAnimationOrder(), params:{duration: animationDuration}}\"\n       (@routeAnimations.start)=\"animationStarted()\"\n       (@routeAnimations.done)=\"animationDone()\"\n  >\n    <router-outlet #routerOutlet=\"outlet\"\n                   (activate)=\"onOutletActivated(routerOutlet, $event)\"\n                   (deactivate)=\"onOutletDeactivated()\">\n    </router-outlet>\n  </div>\n</ng-container>\n\n<ng-container *ngIf=\"!animationEnabled.value\">\n  <div class=\"router-outlet-container\"\n       cdkScrollable>\n    <router-outlet #routerOutlet=\"outlet\"\n                   (activate)=\"onOutletActivated(routerOutlet, $event)\"\n                   (deactivate)=\"onOutletDeactivated()\">\n    </router-outlet>\n  </div>\n</ng-container>\n\n<div  class=\"not-authorised-component-container\" *ngIf=\"!authorised.value\">\n  <ng-template [cdkPortalOutlet]=\"notAuthorisedNoticePortal\"></ng-template>\n</div>\n"]}

package/esm2020/lib/place/components/side-place-navigation/side-place-navigation.component.mjs

@@ -0,0 +1,93 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ContentChild, HostBinding, Input, TemplateRef } from "@angular/core";
+import { MutableValueModel, StoreInValueModel, TrackExternal } from "@coolon/pectin";
+import { PlaceRouter } from '../../place-router';
+import { AbstractPlaceNavigationComponent } from '../abstract-place-navigation.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../place-router";
+import * as i2 from "@angular/material/list";
+import * as i3 from "../../../components/icon/icon.component";
+import * as i4 from "@angular/common";
+import * as i5 from "../../../directives/command.directive";
+import * as i6 from "@angular/material/tooltip";
+/**
+ * @example
+ * // Usage
+ * <aup-vertical-place-navigation [places]="placeConstructorArray"
+ *                                [placeOutlet]="placeOutletComponent">
+ * </aup-vertical-place-navigation>
+ * <aup-place-outlet #placeOutletComponent></aup-place-outlet>
+ *
+ * // CSS overrides:
+ * aup-side-place-navigation {
+ *   --nav-width: 56px
+ *   --nav-expanded-width: 235px
+ *   --nav-item-height: var(--nav-width)
+ *   --nav-background-color: #555;
+ *   --nav-color: rgba(255, 255, 255, 0.9);
+ * }
+ *
+ * // Content Templates:
+ * #navEndTemplate
+ * <ng-template #navEndTemplate>
+ *    <a mat-list-item (click)="logout()" matTooltip="Logout">
+ *    <mat-icon>exit_to_app</mat-icon>
+ *    <span *ngIf="sideNav.expanded">Logout</span>
+ *    </a>
+ * </nav-template>
+ *
+ * // Place nav item in an i18n.yml
+ * places:
+ *   myPlace:
+ *     nav(NavItem):
+ *       title: "Activities"
+ *       icon: "build"
+ *       tooltip: "Alerts, confirms and dialogs"
+ *
+ * // In your place
+ * (at)Place({
+ *   path: 'myPlace',
+ *   data: {
+ *     nav: I18n.places.myPlace.nav
+ *   }
+ * })
+ */
+export class SidePlaceNavigationComponent extends AbstractPlaceNavigationComponent {
+    constructor(router) {
+        super(router);
+    }
+    expandMenu() {
+        this.expanded = true;
+    }
+    collapseMenu() {
+        this.expanded = false;
+    }
+    toggleMenu() {
+        this.expanded = !this.expanded;
+    }
+}
+SidePlaceNavigationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SidePlaceNavigationComponent, deps: [{ token: i1.PlaceRouter }], target: i0.ɵɵFactoryTarget.Component });
+SidePlaceNavigationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: SidePlaceNavigationComponent, selector: "aup-side-place-navigation", inputs: { expanded$: "expanded$", expanded: "expanded" }, host: { properties: { "class.expanded": "this.expanded" } }, queries: [{ propertyName: "navEndTemplate", first: true, predicate: ["navEndTemplate"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<mat-nav-list>\n  <a mat-list-item (click)=\"toggleMenu()\" class=\"home\">\n    <aup-icon class=\"collapsed-only\" icon=\"mat:menu\"></aup-icon>\n    <aup-icon class=\"expanded-only\" icon=\"mat:arrow_back\"></aup-icon>\n    <span class=\"expanded-only\">Menu</span>\n  </a>\n  <a mat-list-item *ngFor=\"let item of menuItems.value; trackBy: trackByPlaceDef\"\n     [pectinCommand]=\"commandFactory.create(item.place)\"\n     [class.active]=\"item.active\"\n     [matTooltip]=\"getNavigationFace(item.place).tooltip()\">\n    <aup-icon *ngIf=\"getNavigationFace(item.place).icon()\" [icon]=\"getNavigationFace(item.place).icon()\"></aup-icon>\n    <span class=\"expanded-only\">{{getNavigationFace(item.place).text()}}</span>\n  </a>\n  <span [style.flex]=\"1\"></span>\n  <ng-container *ngIf=\"navEndTemplate\" [ngTemplateOutlet]=\"navEndTemplate\"></ng-container>\n</mat-nav-list>\n", styles: [":host{display:flex;flex-direction:column;--resolved-nav-item-width: var(--nav-width, 56px);--resolved-nav-item-height: var(--nav-item-height, var(--resolved-nav-item-width));--resolved-expanded-width: var(--nav-expanded-width, 235px);--resolved-color: var(--nav-color, rgba(255, 255, 255, .9));--resolved-background-color: var(--nav-background-color, #555);width:var(--resolved-nav-item-width);transition:width 125ms linear;background-color:var(--resolved-background-color);color:var(--resolved-color)}:host.expanded{width:var(--resolved-expanded-width);max-width:var(--resolved-expanded-width)}:host-context(.expanded) .expanded-only{max-width:100%}:host-context(.expanded) .collapsed-only{max-width:0}:host-context(.expanded) .mat-list-item aup-icon:not(.collapsed-only){margin-right:12px}:host-context(.expanded) .mat-list-item span{text-wrap:none;white-space:nowrap}.expanded-only{max-width:0;overflow:hidden}.collapsed-only{max-width:100%;overflow:hidden}mat-nav-list{flex:1;display:flex;flex-direction:column}.mat-list-item{width:var(--resolved-nav-item-width);height:var(--resolved-nav-item-height);color:inherit}.mat-list-item.active{background-color:#444}.mat-list-item.home{text-align:left}mat-icon{color:inherit}mat-icon.flip-horizontal{transform:scaleX(-1)}\n"], components: [{ type: i2.MatNavList, selector: "mat-nav-list", inputs: ["disableRipple", "disabled"], exportAs: ["matNavList"] }, { type: i2.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["disableRipple", "disabled"], exportAs: ["matListItem"] }, { type: i3.IconComponent, selector: "aup-icon", inputs: ["icon"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.CommandDirective, selector: "[pectinCommand]", inputs: ["pectinCommand", "commandParameter"] }, { type: i6.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+__decorate([
+    TrackExternal(),
+    __metadata("design:type", MutableValueModel)
+], SidePlaceNavigationComponent.prototype, "expanded$", void 0);
+__decorate([
+    StoreInValueModel("expanded$"),
+    __metadata("design:type", Boolean)
+], SidePlaceNavigationComponent.prototype, "expanded", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SidePlaceNavigationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-side-place-navigation', template: "<mat-nav-list>\n  <a mat-list-item (click)=\"toggleMenu()\" class=\"home\">\n    <aup-icon class=\"collapsed-only\" icon=\"mat:menu\"></aup-icon>\n    <aup-icon class=\"expanded-only\" icon=\"mat:arrow_back\"></aup-icon>\n    <span class=\"expanded-only\">Menu</span>\n  </a>\n  <a mat-list-item *ngFor=\"let item of menuItems.value; trackBy: trackByPlaceDef\"\n     [pectinCommand]=\"commandFactory.create(item.place)\"\n     [class.active]=\"item.active\"\n     [matTooltip]=\"getNavigationFace(item.place).tooltip()\">\n    <aup-icon *ngIf=\"getNavigationFace(item.place).icon()\" [icon]=\"getNavigationFace(item.place).icon()\"></aup-icon>\n    <span class=\"expanded-only\">{{getNavigationFace(item.place).text()}}</span>\n  </a>\n  <span [style.flex]=\"1\"></span>\n  <ng-container *ngIf=\"navEndTemplate\" [ngTemplateOutlet]=\"navEndTemplate\"></ng-container>\n</mat-nav-list>\n", styles: [":host{display:flex;flex-direction:column;--resolved-nav-item-width: var(--nav-width, 56px);--resolved-nav-item-height: var(--nav-item-height, var(--resolved-nav-item-width));--resolved-expanded-width: var(--nav-expanded-width, 235px);--resolved-color: var(--nav-color, rgba(255, 255, 255, .9));--resolved-background-color: var(--nav-background-color, #555);width:var(--resolved-nav-item-width);transition:width 125ms linear;background-color:var(--resolved-background-color);color:var(--resolved-color)}:host.expanded{width:var(--resolved-expanded-width);max-width:var(--resolved-expanded-width)}:host-context(.expanded) .expanded-only{max-width:100%}:host-context(.expanded) .collapsed-only{max-width:0}:host-context(.expanded) .mat-list-item aup-icon:not(.collapsed-only){margin-right:12px}:host-context(.expanded) .mat-list-item span{text-wrap:none;white-space:nowrap}.expanded-only{max-width:0;overflow:hidden}.collapsed-only{max-width:100%;overflow:hidden}mat-nav-list{flex:1;display:flex;flex-direction:column}.mat-list-item{width:var(--resolved-nav-item-width);height:var(--resolved-nav-item-height);color:inherit}.mat-list-item.active{background-color:#444}.mat-list-item.home{text-align:left}mat-icon{color:inherit}mat-icon.flip-horizontal{transform:scaleX(-1)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PlaceRouter }]; }, propDecorators: { expanded$: [{
+                type: Input
+            }], expanded: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.expanded']
+            }], navEndTemplate: [{
+                type: ContentChild,
+                args: ['navEndTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/place/components/tabbed-place-navigation/tabbed-place-navigation.component.mjs

@@ -0,0 +1,22 @@
+import { Component } from '@angular/core';
+import { PlaceRouter } from '../../place-router';
+import { AbstractPlaceNavigationComponent } from '../abstract-place-navigation.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../place-router";
+import * as i2 from "@angular/material/tabs";
+import * as i3 from "../../../components/commands/command-face/command-face.component";
+import * as i4 from "@angular/common";
+import * as i5 from "../../../directives/command.directive";
+import * as i6 from "@angular/material/tooltip";
+export class TabbedPlaceNavigationComponent extends AbstractPlaceNavigationComponent {
+    constructor(router) {
+        super(router);
+    }
+}
+TabbedPlaceNavigationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TabbedPlaceNavigationComponent, deps: [{ token: i1.PlaceRouter }], target: i0.ɵɵFactoryTarget.Component });
+TabbedPlaceNavigationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: TabbedPlaceNavigationComponent, selector: "aup-tabbed-place-navigation", usesInheritance: true, ngImport: i0, template: "<nav mat-tab-nav-bar>\n  <ng-content select=\"[nav-start]\"></ng-content>\n  <a mat-tab-link *ngFor=\"let item of menuItems.value; trackBy: trackByPlaceDef\"\n     [pectinCommand]=\"commandFactory.create(item.place)\"\n     [active]=\"item.active\"\n     [matTooltip]=\"getNavigationFace(item.place).tooltip()\">\n    <aup-command-face [faces]=\"[getNavigationFace(item.place)]\"></aup-command-face>\n  </a>\n  <ng-content select=\"[nav-end]\"></ng-content>\n</nav>\n", styles: [":host{display:block}div.place-holder{border:1px solid green}\n"], components: [{ type: i2.MatTabNav, selector: "[mat-tab-nav-bar]", inputs: ["color"], exportAs: ["matTabNavBar", "matTabNav"] }, { type: i3.CommandFaceComponent, selector: "aup-command-face", inputs: ["faces", "face", "ignoreIcon", "ignoreText", "includeMissingIconInLayout"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.MatTabLink, selector: "[mat-tab-link], [matTabLink]", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matTabLink"] }, { type: i5.CommandDirective, selector: "[pectinCommand]", inputs: ["pectinCommand", "commandParameter"] }, { type: i6.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TabbedPlaceNavigationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-tabbed-place-navigation', template: "<nav mat-tab-nav-bar>\n  <ng-content select=\"[nav-start]\"></ng-content>\n  <a mat-tab-link *ngFor=\"let item of menuItems.value; trackBy: trackByPlaceDef\"\n     [pectinCommand]=\"commandFactory.create(item.place)\"\n     [active]=\"item.active\"\n     [matTooltip]=\"getNavigationFace(item.place).tooltip()\">\n    <aup-command-face [faces]=\"[getNavigationFace(item.place)]\"></aup-command-face>\n  </a>\n  <ng-content select=\"[nav-end]\"></ng-content>\n</nav>\n", styles: [":host{display:block}div.place-holder{border:1px solid green}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PlaceRouter }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/place/guards/consolidated-param-map.js → esm2020/lib/place/guards/consolidated-param-map.mjs}

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from "tslib";
 import { Memoize } from '@typescript-plus/fast-memoize-decorator';
-import { uniq } from 'lodash-es';
+import { uniq } from 'lodash';
 /**
  * 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
@@ -53,4 +53,4 @@ class ParamMapAdapter {
         return Object.keys(this.params);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/place/guards/noop-auth-guard.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NoopAuthGuard {
+    constructor() {
+    }
+    async canActivate(activatedRoute, state) {
+        return true;
+    }
+}
+NoopAuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NoopAuthGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NoopAuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NoopAuthGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NoopAuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC1hdXRoLWd1YXJkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdWktcG93ZXJ1cHMvc3JjL2xpYi9wbGFjZS9ndWFyZHMvbm9vcC1hdXRoLWd1YXJkLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFNM0MsTUFBTSxPQUFPLGFBQWE7SUFFeEI7SUFDQSxDQUFDO0lBRUQsS0FBSyxDQUFDLFdBQVcsQ0FBQyxjQUFzQyxFQUFFLEtBQTBCO1FBQ2xGLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQzs7MEdBUFUsYUFBYTs4R0FBYixhQUFhLGNBRlosTUFBTTsyRkFFUCxhQUFhO2tCQUh6QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIENhbkFjdGl2YXRlLCBSb3V0ZXJTdGF0ZVNuYXBzaG90LCBVcmxUcmVlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTm9vcEF1dGhHdWFyZCBpbXBsZW1lbnRzIENhbkFjdGl2YXRlIHtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgfVxuXG4gIGFzeW5jIGNhbkFjdGl2YXRlKGFjdGl2YXRlZFJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IFByb21pc2U8Ym9vbGVhbiB8IFVybFRyZWU+IHtcbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxufVxuIl19