@coolon/angular-ui-powerups 0.0.92 → 0.0.94

package/esm5/lib/place/guards/abstract-enter-place.guard.js

@@ -0,0 +1,372 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { lang } from '@coolon/pectin';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
+import { Observable } from 'rxjs';
+import { PlaceComponent } from '../place-component';
+import { VisitSanitiser } from '../route/visit-sanitiser';
+import { Visit } from '../visit';
+/**
+ * @abstract
+ */
+var /**
+ * @abstract
+ */
+AbstractEnterPlaceGuard = /** @class */ (function () {
+    function AbstractEnterPlaceGuard(router, urlSerializer, placeRouter, placeHistory, injector) {
+        this.router = router;
+        this.urlSerializer = urlSerializer;
+        this.placeRouter = placeRouter;
+        this.placeHistory = placeHistory;
+        this.injector = injector;
+    }
+    // @Trace()
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    AbstractEnterPlaceGuard.prototype.canActivate = 
+    // @Trace()
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    function (activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this.interceptInitialRouteOtherwise(activatedRoute, state, (/**
+                     * @return {?}
+                     */
+                    function () {
+                        return _this.authorisePlaceThen(activatedRoute, state, (/**
+                         * @param {?} placeDefinition
+                         * @return {?}
+                         */
+                        function (placeDefinition) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var params, parsedParams, initialVisit, sanitiser, sanitisedVisit, commands;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        // Parse our route params.
+                                        params = new AbstractEnterPlaceGuard.ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);
+                                        parsedParams = placeDefinition.parseRouteParams(params);
+                                        initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);
+                                        sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);
+                                        return [4 /*yield*/, sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams))];
+                                    case 1:
+                                        sanitisedVisit = _a.sent();
+                                        // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters
+                                        this.placeRouter.navigationSession.storeVisit(sanitisedVisit);
+                                        if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {
+                                            // Regenerate the url
+                                            commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);
+                                            console.log('##### Place Guard Redirect', commands);
+                                            return [2 /*return*/, this.router.createUrlTree(commands, {
+                                                    replaceUrl: true,
+                                                    skipLocationChange: false
+                                                })];
+                                        }
+                                        else {
+                                            return [2 /*return*/, true];
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }));
+                    }))];
+            });
+        });
+    };
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} canActivate
+     * @return {?}
+     */
+    AbstractEnterPlaceGuard.prototype.authorisePlaceThen = /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} canActivate
+     * @return {?}
+     */
+    function (activatedRoute, state, canActivate) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var placeDefinition, authorised, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) return [3 /*break*/, 4];
+                        placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);
+                        if (!placeDefinition.authenticate) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.isAuthorised(activatedRoute, state)];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = true;
+                        _b.label = 3;
+                    case 3:
+                        authorised = _a;
+                        return [2 /*return*/, authorised === true ? canActivate(placeDefinition) : authorised];
+                    case 4: return [2 /*return*/, lang.illegalState("expected component to be an instance of PlaceComponent, got " + activatedRoute.component)];
+                }
+            });
+        });
+    };
+    /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} canActivate
+     * @return {?}
+     */
+    AbstractEnterPlaceGuard.prototype.interceptInitialRouteOtherwise = /**
+     * @protected
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @param {?} canActivate
+     * @return {?}
+     */
+    function (activatedRoute, state, canActivate) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                // TODO: this all only sort of works.  Opening dialogs and clicking back multiple times breaks things.
+                // TODO: next stage is to investigate tracking dialog state in a different placeoutlet and keeping those
+                // TODO: urls out of the history.
+                if (this.placeRouter.isInitialNavigation()) {
+                    // This is the very first entry into our app so we redirect to a dummy place so we can get bump our
+                    // history by one.  This ensures that we can capture back button presses on the initial page without
+                    // leaving our app.
+                    return [2 /*return*/, this.placeRouter.performInitialNavigationIntercept(activatedRoute, state)];
+                }
+                else {
+                    return [2 /*return*/, canActivate()];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    AbstractEnterPlaceGuard.prototype.isAuthorised = /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    function (activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var authorised;
+            return tslib_1.__generator(this, function (_a) {
+                authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);
+                return [2 /*return*/, (authorised instanceof Observable) ? authorised.toPromise() : authorised];
+            });
+        });
+    };
+    return AbstractEnterPlaceGuard;
+}());
+/**
+ * @abstract
+ */
+export { AbstractEnterPlaceGuard };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.urlSerializer;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.placeRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.placeHistory;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractEnterPlaceGuard.prototype.injector;
+    /**
+     * @abstract
+     * @param {?} injector
+     * @return {?}
+     */
+    AbstractEnterPlaceGuard.prototype.getAuthGuard = function (injector) { };
+}
+(function (AbstractEnterPlaceGuard) {
+    /**
+     * 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.
+     */
+    var ConsolidatedParameterMap = /** @class */ (function () {
+        function ConsolidatedParameterMap(paramMap, urlSegments) {
+            this.paramMaps = [paramMap].concat((urlSegments || []).map((/**
+             * @param {?} s
+             * @return {?}
+             */
+            function (s) { return new ParamMapAdapter(s.parameters); }))).filter((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return !!m; })); // the activated route param map can be null
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ConsolidatedParameterMap.prototype.get = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            /** @type {?} */
+            var paramMap = this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return m.has(name); }));
+            return paramMap.get(name);
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ConsolidatedParameterMap.prototype.getAll = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            /** @type {?} */
+            var paramMap = this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return m.has(name); }));
+            return paramMap.getAll(name);
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ConsolidatedParameterMap.prototype.has = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            return !!this.paramMaps.find((/**
+             * @param {?} m
+             * @return {?}
+             */
+            function (m) { return m.has(name); }));
+        };
+        Object.defineProperty(ConsolidatedParameterMap.prototype, "keys", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this.paramMaps.reduce((/**
+                 * @param {?} result
+                 * @param {?} params
+                 * @return {?}
+                 */
+                function (result, params) { return result.concat(params.keys); }), []);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        tslib_1.__decorate([
+            Memoize(),
+            tslib_1.__metadata("design:type", Array),
+            tslib_1.__metadata("design:paramtypes", [])
+        ], ConsolidatedParameterMap.prototype, "keys", null);
+        return ConsolidatedParameterMap;
+    }());
+    AbstractEnterPlaceGuard.ConsolidatedParameterMap = ConsolidatedParameterMap;
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ConsolidatedParameterMap.prototype.paramMaps;
+    }
+    var ParamMapAdapter = /** @class */ (function () {
+        function ParamMapAdapter(params) {
+            this.params = params;
+        }
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ParamMapAdapter.prototype.get = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            return this.params[name];
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ParamMapAdapter.prototype.getAll = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            /** @type {?} */
+            var value = this.get(name);
+            return Array.isArray(value) ? value : [value];
+        };
+        /**
+         * @param {?} name
+         * @return {?}
+         */
+        ParamMapAdapter.prototype.has = /**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            return this.keys.includes(name);
+        };
+        Object.defineProperty(ParamMapAdapter.prototype, "keys", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return Object.keys(this.params);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return ParamMapAdapter;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ParamMapAdapter.prototype.params;
+    }
+})(AbstractEnterPlaceGuard || (AbstractEnterPlaceGuard = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-enter-place.guard.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/guards/abstract-enter-place.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport {\n  ActivatedRouteSnapshot,\n  CanActivate,\n  ParamMap,\n  Router,\n  RouterStateSnapshot,\n  UrlSegment,\n  UrlSerializer,\n  UrlTree\n} from '@angular/router';\nimport { lang } from '@coolon/pectin';\nimport { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';\nimport { Observable } from 'rxjs';\nimport { PlaceComponent } from '../place-component';\nimport { PlaceDefinition } from '../place-definition';\nimport { PlaceHistory } from '../place-history';\nimport { PlaceRouter } from '../place-router';\nimport { NoopGatewayPlace } from '../places/noop-gateway-place.component';\nimport { VisitSanitiser } from '../route/visit-sanitiser';\nimport { Visit } from '../visit';\n\n\nexport abstract class AbstractEnterPlaceGuard implements CanActivate {\n\n\n  constructor(private readonly router: Router,\n              private urlSerializer: UrlSerializer,\n              private readonly placeRouter: PlaceRouter,\n              private readonly placeHistory: PlaceHistory,\n              private readonly injector: Injector) {\n  }\n\n  // @Trace()\n  async canActivate(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n\n    return this.interceptInitialRouteOtherwise(activatedRoute, state, () => {\n\n      return this.authorisePlaceThen(activatedRoute, state, async placeDefinition => {\n\n        // Parse our route params.\n        const params = new AbstractEnterPlaceGuard.ConsolidatedParameterMap(activatedRoute.paramMap, activatedRoute.url);\n        const parsedParams = placeDefinition.parseRouteParams(params);\n\n        const initialVisit = this.placeRouter.navigationSession.getVisitFor(placeDefinition) || new Visit(placeDefinition, parsedParams);\n        const sanitiser = new VisitSanitiser(activatedRoute, this.router, this.placeHistory, this.injector);\n        const sanitisedVisit = await sanitiser.sanitise(initialVisit.mergeRouteParameters(parsedParams));\n\n        // Save the visit with any updated parameters.  We need to save it so we remember any non route parameters\n        this.placeRouter.navigationSession.storeVisit(sanitisedVisit);\n        if (initialVisit.hasRoutingChangedFrom(sanitisedVisit)) {\n          // Regenerate the url\n          const commands = this.placeRouter.parseUrl(state).createRedirectCommandsFor(sanitisedVisit);\n          console.log('##### Place Guard Redirect', commands);\n          return this.router.createUrlTree(commands, {\n            replaceUrl: true,\n            skipLocationChange: false\n          });\n        } else {\n          return true;\n        }\n      });\n\n    });\n  }\n\n  protected async authorisePlaceThen(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, canActivate: (placeDefinition: PlaceDefinition) => Promise<boolean | UrlTree>) {\n    if (PlaceComponent.isPlaceComponentConstructor(activatedRoute.component)) {\n      const placeDefinition = PlaceComponent.getDefinition(activatedRoute.component);\n      const authorised = placeDefinition.authenticate ? await this.isAuthorised(activatedRoute, state) : true;\n      return authorised === true ? canActivate(placeDefinition) : authorised;\n    } else {\n      return lang.illegalState(`expected component to be an instance of PlaceComponent, got ${activatedRoute.component}`);\n    }\n  }\n\n  protected async interceptInitialRouteOtherwise(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot, canActivate: () => Promise<boolean | UrlTree>) {\n    // TODO: this all only sort of works.  Opening dialogs and clicking back multiple times breaks things.\n    // TODO: next stage is to investigate tracking dialog state in a different placeoutlet and keeping those\n    // TODO: urls out of the history.\n    if (this.placeRouter.isInitialNavigation()) {\n      // This is the very first entry into our app so we redirect to a dummy place so we can get bump our\n      // history by one.  This ensures that we can capture back button presses on the initial page without\n      // leaving our app.\n      return this.placeRouter.performInitialNavigationIntercept(activatedRoute, state);\n    } else {\n      return canActivate();\n    }\n  }\n\n  async isAuthorised(activatedRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree> {\n    const authorised = this.getAuthGuard(this.injector).canActivate(activatedRoute, state);\n    return (authorised instanceof Observable) ? authorised.toPromise() : authorised;\n  }\n\n  abstract getAuthGuard(injector: Injector): CanActivate;\n}\n\nexport namespace AbstractEnterPlaceGuard {\n  /**\n   * This a work around for the fact that an activated route with multiple segments doesn't\n   * include the segment params in the paramMap as well as each segment returns an empty\n   * param map even when `parameter`s has content.\n   */\n  export class ConsolidatedParameterMap implements ParamMap {\n\n    private paramMaps: ParamMap[];\n\n    constructor(paramMap: ParamMap, urlSegments: UrlSegment[]) {\n      this.paramMaps = [paramMap].concat(\n        (urlSegments || []).map(s => new ParamMapAdapter(s.parameters))\n      ).filter(m => !!m); // the activated route param map can be null\n    }\n\n    get(name: string): string | null {\n      const paramMap = this.paramMaps.find(m => m.has(name));\n      return paramMap.get(name);\n    }\n\n    getAll(name: string): string[] {\n      const paramMap = this.paramMaps.find(m => m.has(name));\n      return paramMap.getAll(name);\n    }\n\n    has(name: string): boolean {\n      return !!this.paramMaps.find(m => m.has(name));\n    }\n\n    @Memoize()\n    get keys(): string[] {\n      return this.paramMaps.reduce((result, params) => result.concat(params.keys), []);\n    }\n  }\n\n  class ParamMapAdapter implements ParamMap {\n    constructor(private readonly params: { [p: string]: string }) {\n    }\n\n    get(name: string): string | null {\n      return this.params[name];\n    }\n\n    getAll(name: string): string[] {\n      const value = this.get(name);\n      return Array.isArray(value) ? value : [value];\n    }\n\n    has(name: string): boolean {\n      return this.keys.includes(name);\n    }\n\n    get keys(): string[] {\n      return Object.keys(this.params);\n    }\n\n  }\n}\n"]}

package/esm5/lib/place/guards/leave-place.guard.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { PlaceRouter } from '../place-router';
+import * as i0 from "@angular/core";
+import * as i1 from "../place-router";
+var LeavePlaceGuard = /** @class */ (function () {
+    function LeavePlaceGuard(placeRouter) {
+        this.placeRouter = placeRouter;
+    }
+    /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    LeavePlaceGuard.prototype.canDeactivate = /**
+     * @param {?} component
+     * @param {?} currentRoute
+     * @param {?} currentState
+     * @param {?=} nextState
+     * @return {?}
+     */
+    function (component, currentRoute, currentState, nextState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this.placeRouter.navigationSession.canDeactivate(component, this.placeRouter.parseUrl(nextState))];
+            });
+        });
+    };
+    LeavePlaceGuard.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    LeavePlaceGuard.ctorParameters = function () { return [
+        { type: PlaceRouter }
+    ]; };
+    /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(i0.ɵɵinject(i1.PlaceRouter)); }, token: LeavePlaceGuard, providedIn: "root" });
+    return LeavePlaceGuard;
+}());
+export { LeavePlaceGuard };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LeavePlaceGuard.prototype.placeRouter;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/place/guards/noop-auth-guard.service.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+var NoopAuthGuard = /** @class */ (function () {
+    function NoopAuthGuard() {
+    }
+    /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    NoopAuthGuard.prototype.canActivate = /**
+     * @param {?} activatedRoute
+     * @param {?} state
+     * @return {?}
+     */
+    function (activatedRoute, state) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, true];
+            });
+        });
+    };
+    NoopAuthGuard.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    NoopAuthGuard.ctorParameters = function () { return []; };
+    /** @nocollapse */ NoopAuthGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function NoopAuthGuard_Factory() { return new NoopAuthGuard(); }, token: NoopAuthGuard, providedIn: "root" });
+    return NoopAuthGuard;
+}());
+export { NoopAuthGuard };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC1hdXRoLWd1YXJkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvcGxhY2UvZ3VhcmRzL25vb3AtYXV0aC1ndWFyZC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHM0M7SUFLRTtJQUNBLENBQUM7Ozs7OztJQUVLLG1DQUFXOzs7OztJQUFqQixVQUFrQixjQUFzQyxFQUFFLEtBQTBCOzs7Z0JBQ2xGLHNCQUFPLElBQUksRUFBQzs7O0tBQ2I7O2dCQVZGLFVBQVUsU0FBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7Ozs7O3dCQUxEO0NBY0MsQUFYRCxJQVdDO1NBUlksYUFBYSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIENhbkFjdGl2YXRlLCBSb3V0ZXJTdGF0ZVNuYXBzaG90LCBVcmxUcmVlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTm9vcEF1dGhHdWFyZCBpbXBsZW1lbnRzIENhbkFjdGl2YXRlIHtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgfVxuXG4gIGFzeW5jIGNhbkFjdGl2YXRlKGFjdGl2YXRlZFJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IFByb21pc2U8Ym9vbGVhbiB8IFVybFRyZWU+IHtcbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxufVxuIl19

package/esm5/lib/place/index.js

@@ -22,6 +22,10 @@ export { ListPlaceNavComponent } from "./components/list-place-nav/list-place-na
 export { PlaceOutletComponent } from "./components/place-outlet/place-outlet.component";
 export { leftRightPlaceAnimation, LEFT_RIGHT_PLACE_ANIMATION } from "./components/place-outlet/route-animations";
 export { TabbedPlaceNavigationComponent } from "./components/tabbed-place-navigation/tabbed-place-navigation.component";
+export { AbstractEnterPlaceGuard } from "./guards/abstract-enter-place.guard";
+export { LeavePlaceGuard } from "./guards/leave-place.guard";
+export { NoopAuthGuard } from "./guards/noop-auth-guard.service";
+export { NoopGatewayPlace } from "./places/noop-gateway-place.component";
 export { Formatter } from "./route/formatter";
 export {} from "./route/json-types";
 export { RouteId, VisitParameter, VisitParameterList } from "./route/parameter-decorators";
@@ -29,6 +33,4 @@ export { ParameterDefinition } from "./route/parameter-definition.class";
 export {} from "./route/parameter-sanitiser";
 export {} from "./route/parameter-snapshot";
 export { VisitSanitiser } from "./route/visit-sanitiser";
-export { EnterPlaceGuard } from "./route/guards/enter-place-guard.service";
-export { LeavePlaceGuard } from "./route/guards/leave-place.guard";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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