@singularsystems/neo-react 1.0.22 → 1.1.1

package/dist/Routing/NavigationHelper.js

@@ -1,20 +1,72 @@
-import { __decorate, __metadata, __param } from "tslib";
+import { __awaiter, __decorate, __generator, __metadata, __param } from "tslib";
 import { ViewParameterList } from './ViewParameterList';
 import { injectable, inject } from 'inversify';
 import { NeoReactTypes } from '../Modules/Types';
 import { RoutingState } from './RoutingState';
 var NavigationHelper = /** @class */ (function () {
-    function NavigationHelper(routingState) {
+    function NavigationHelper(routingState, pageLeaveHandler) {
         this.routingState = routingState;
+        this.pageLeaveHandler = pageLeaveHandler;
+        // PrevUrls is required since the popstate event tells you the new path, not the previous path
+        this.prevUrls = [];
+        this.isPrompting = false;
+        window.addEventListener("beforeunload", this.windowUnload.bind(this));
+        window.addEventListener("popstate", this.historyPopState.bind(this));
     }
-    NavigationHelper.prototype.navigateInternal = function (url, replace) {
-        if (replace === void 0) { replace = false; }
-        if (replace) {
-            this.currentRouteProps.history.replace(url);
-        }
-        else {
-            this.currentRouteProps.history.push(url);
-        }
+    NavigationHelper.prototype.navigateInternal = function (url_1) {
+        return __awaiter(this, arguments, void 0, function (url, replace) {
+            var basePath, prevUrl, path, route, leavePrompt, canNavigate;
+            if (replace === void 0) { replace = false; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        basePath = this.routingState.basePath;
+                        prevUrl = this.prevUrls.length === 0 ? undefined : this.prevUrls[this.prevUrls.length - 1];
+                        path = url;
+                        if (basePath) {
+                            if (path.startsWith(basePath)) {
+                                path = path.substring(basePath.length);
+                            }
+                            else {
+                                url = basePath + url;
+                            }
+                        }
+                        if (!(prevUrl !== url)) return [3 /*break*/, 5];
+                        route = this.routingState.appRouteProvider.getRouteForPath(path);
+                        if (!this.routingState.currentRoute) return [3 /*break*/, 4];
+                        leavePrompt = this.beforeLocationChanged(route, false);
+                        if (!(leavePrompt !== undefined)) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        this.isPrompting = true;
+                        return [4 /*yield*/, this.pageLeaveHandler.onLeavePage(this.routingState.currentView, leavePrompt)];
+                    case 2:
+                        canNavigate = _a.sent();
+                        if (!canNavigate) {
+                            return [2 /*return*/, false];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this.isPrompting = false;
+                        return [7 /*endfinally*/];
+                    case 4:
+                        if (replace) {
+                            if (this.prevUrls.length > 0) {
+                                this.prevUrls[this.prevUrls.length - 1] = url;
+                            }
+                            window.history.replaceState(null, "", url);
+                        }
+                        else {
+                            this.prevUrls.push(url);
+                            window.history.pushState(null, "", url);
+                        }
+                        this.routingState.updateRoute(route);
+                        _a.label = 5;
+                    case 5: return [2 /*return*/, true];
+                }
+            });
+        });
     };
     NavigationHelper.prototype.navigateToView = function (view, paramValues) {
         this.navigateInternal(this.getPathForView(view, paramValues));
@@ -34,27 +86,71 @@ var NavigationHelper = /** @class */ (function () {
         }
     };
     NavigationHelper.prototype.getCurrentViewPath = function () {
-        var basePath = this.currentRouteProps.match.path;
-        var paramIndex = basePath.indexOf(":");
-        if (paramIndex > 0) {
-            basePath = basePath.substring(0, paramIndex);
-            if (basePath.endsWith("/")) {
-                basePath = basePath.substring(0, basePath.length - 1);
+        if (this.routingState.currentRoute) {
+            return this.routingState.currentRoute.route.path;
+        }
+        else {
+            return "";
+        }
+    };
+    NavigationHelper.prototype.historyPopState = function (e) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.isPrompting;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.navigateInternal(window.location.pathname, true)];
+                    case 1:
+                        _a = !(_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        if (_a) {
+                            // cancel navigation by pushing the previous state back into history.
+                            window.history.pushState(null, "", this.prevUrls[this.prevUrls.length - 1]);
+                        }
+                        else {
+                            // remove our state to match browsers state.
+                            this.prevUrls.pop();
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NavigationHelper.prototype.windowUnload = function (e) {
+        var leavePrompt = this.beforeLocationChanged(null, true);
+        if (leavePrompt !== undefined) {
+            this.pageLeaveHandler.onWindowUnload(this.routingState.currentView, leavePrompt, e);
+        }
+    };
+    NavigationHelper.prototype.beforeLocationChanged = function (newRoute, isUnload) {
+        var _a;
+        var currentRoute = this.routingState.currentRoute;
+        var changeProps = {
+            isNewView: !currentRoute || currentRoute.route !== (newRoute === null || newRoute === void 0 ? void 0 : newRoute.route),
+            isUnload: isUnload !== null && isUnload !== void 0 ? isUnload : false,
+            currentView: (_a = this.routingState.currentView) !== null && _a !== void 0 ? _a : undefined,
+            newRoute: newRoute === null || newRoute === void 0 ? void 0 : newRoute.route,
+            params: newRoute === null || newRoute === void 0 ? void 0 : newRoute.params
+        };
+        if (this.routingState.currentView) {
+            this.routingState.currentView.beforeRouteChanged(changeProps);
+            if (changeProps.leavePrompt === undefined && (changeProps.isNewView || changeProps.isUnload)) {
+                changeProps.leavePrompt = this.routingState.currentView.onLeave();
             }
         }
-        return basePath;
+        if (changeProps.isNewView) {
+            this.pageLeaveHandler.beforeLeavePage(changeProps);
+        }
+        return changeProps.leavePrompt;
     };
-    Object.defineProperty(NavigationHelper.prototype, "currentRouteProps", {
-        get: function () {
-            return this.routingState.currentRouteProps;
-        },
-        enumerable: false,
-        configurable: true
-    });
     NavigationHelper = __decorate([
         injectable(),
         __param(0, inject(NeoReactTypes.Routing.GlobalRoutingState.symbol)),
-        __metadata("design:paramtypes", [RoutingState])
+        __param(1, inject(NeoReactTypes.Routing.PageLeaveHandler.symbol)),
+        __metadata("design:paramtypes", [RoutingState, Object])
     ], NavigationHelper);
     return NavigationHelper;
 }());

package/dist/Routing/PageLeaveHandler.d.ts

@@ -1,13 +1,30 @@
-import { Routing, Views } from '@singularsystems/neo-core';
+import { Views } from '@singularsystems/neo-core';
 import { RoutingState } from './RoutingState';
-export declare class PageLeaveHandler implements Routing.IPageLeaveHandler {
-    private routingState;
-    constructor(routingState: RoutingState);
+import { IViewBase } from "../Views/ViewBase";
+import { IRouteChangedProps, RouteChangedLeavePrompt } from "./IRouteChangedProps";
+export interface IPageLeaveHandler {
     /**
-     * Handler for react-routers BrowserRouter.getUserConfirmation
+     * Called after `ViewBase.beforeRouteChanged` and `ViewBase.onLeave` are called.
+     * @param changeProps
      */
-    static showNavigationConfirmation(prompt: string, callback: (ok: boolean) => void): Promise<void>;
-    onWindowUnload(view: Views.IViewBase | null, e: BeforeUnloadEvent): void;
-    onLeavePage(view: Views.IViewBase | null, prompt: string, location: Routing.NavigateLocation): Promise<boolean>;
-    protected showDefaultConfirmation(view: Views.IViewBase | null, prompt: string, location: Routing.NavigateLocation): Promise<boolean>;
+    beforeLeavePage(changeProps: IRouteChangedProps): void;
+    /**
+     * Called when the user tries to leave the page, and the page / leave handler has indicated the user must be prompted.
+     * @returns A boolean promise with a value indicating whether the user wants to leave the page.
+     */
+    onLeavePage(view: Views.IViewBase | null, leavePrompt: RouteChangedLeavePrompt): Promise<boolean>;
+    /**
+     * Called when the windows beforeunload event fires, and the page / leave handler has indicated the user must be prompted.
+     * @param view The currently active view.
+     * @param e beforeunload event.
+     */
+    onWindowUnload(view: IViewBase | null, leavePrompt: RouteChangedLeavePrompt, e: BeforeUnloadEvent): void;
+}
+export declare class PageLeaveHandler implements IPageLeaveHandler {
+    private routingState;
+    constructor(routingState: RoutingState);
+    beforeLeavePage(changeProps: IRouteChangedProps): void;
+    onLeavePage(view: Views.IViewBase | null, leavePrompt: RouteChangedLeavePrompt): Promise<boolean>;
+    onWindowUnload(view: Views.IViewBase | null, leavePrompt: RouteChangedLeavePrompt, e: BeforeUnloadEvent): void;
+    protected showDefaultConfirmation(view: Views.IViewBase | null, prompt: string): Promise<boolean>;
 }

package/dist/Routing/PageLeaveHandler.js

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate, __generator, __metadata, __param } from "tslib";
-import { Routing, ModalUtils, Misc, AppServices } from '@singularsystems/neo-core';
+import { ModalUtils, Misc } from '@singularsystems/neo-core';
 import { inject, injectable } from 'inversify';
 import { NeoReactTypes } from '../Modules/Types';
 import { RoutingState } from './RoutingState';
@@ -7,55 +7,32 @@ var PageLeaveHandler = /** @class */ (function () {
     function PageLeaveHandler(routingState) {
         this.routingState = routingState;
     }
-    /**
-     * Handler for react-routers BrowserRouter.getUserConfirmation
-     */
-    PageLeaveHandler.showNavigationConfirmation = function (prompt, callback) {
+    PageLeaveHandler.prototype.beforeLeavePage = function (changeProps) {
+    };
+    PageLeaveHandler.prototype.onLeavePage = function (view, leavePrompt) {
         return __awaiter(this, void 0, void 0, function () {
-            var pageLeaveHandler, routingState, result;
+            var result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        pageLeaveHandler = Misc.Globals.appService.get(AppServices.NeoTypes.Routing.PageLeaveHandler), routingState = Misc.Globals.appService.get(NeoReactTypes.Routing.GlobalRoutingState);
-                        return [4 /*yield*/, pageLeaveHandler.onLeavePage(routingState.currentView, prompt, Routing.NavigateLocation.Internal)];
+                        if (!(leavePrompt === false)) return [3 /*break*/, 1];
+                        return [2 /*return*/, Promise.resolve(false)];
                     case 1:
+                        if (!(typeof leavePrompt === "string")) return [3 /*break*/, 2];
+                        return [2 /*return*/, this.showDefaultConfirmation(view, leavePrompt)];
+                    case 2: return [4 /*yield*/, leavePrompt];
+                    case 3:
                         result = _a.sent();
-                        callback(result);
-                        return [2 /*return*/];
+                        return [2 /*return*/, result === true || result === Misc.ModalResult.Yes];
                 }
             });
         });
     };
-    PageLeaveHandler.prototype.onWindowUnload = function (view, e) {
-        if (view) {
-            var routeView = Misc.Globals.appService.get(NeoReactTypes.Routing.GlobalRoutingState).currentRouteView;
-            var prompt_1 = routeView.beforeLocationChanged(undefined, "PUSH", true);
-            if (prompt_1 || prompt_1 === false || prompt_1 === "") {
-                e.preventDefault();
-                e.returnValue = !prompt_1 ? "Are you sure you want to continue?" : prompt_1;
-            }
-        }
-    };
-    PageLeaveHandler.prototype.onLeavePage = function (view, prompt, location) {
-        if (this.routingState.leavePromise) {
-            var promise_1 = this.routingState.leavePromise;
-            this.routingState.leavePromise = undefined;
-            return new Promise(function (resolve) {
-                promise_1.then(function (result) {
-                    if (result) {
-                        resolve(result === true || result === Misc.ModalResult.Yes);
-                    }
-                    else {
-                        resolve(false);
-                    }
-                });
-            });
-        }
-        else {
-            return this.showDefaultConfirmation(view, prompt, location);
-        }
+    PageLeaveHandler.prototype.onWindowUnload = function (view, leavePrompt, e) {
+        e.preventDefault();
+        e.returnValue = typeof leavePrompt === "string" ? leavePrompt : "Are you sure you want to continue?";
     };
-    PageLeaveHandler.prototype.showDefaultConfirmation = function (view, prompt, location) {
+    PageLeaveHandler.prototype.showDefaultConfirmation = function (view, prompt) {
         var title = view ? view.viewName : "Un-saved Changes";
         return new Promise(function (resolve) {
             ModalUtils.showModal(title, prompt, {

package/dist/Routing/RouteProvider.d.ts

@@ -1,25 +1,45 @@
 import { Routing } from '@singularsystems/neo-core';
 import React from 'react';
+import { IRouteParameter } from "./IRouteParameter";
+interface INamedRouteParameter extends IRouteParameter {
+    name: string;
+}
 export interface IProcessedRoute extends Routing.IRoute {
     key: number;
-    /** Path including parameters */
-    routePath: string;
+    /** Lower case base path without trailing / */
+    path: string;
+    /** Route params in order, excluding query parameters. */
+    params: INamedRouteParameter[];
+}
+type ParamsObject = {
+    [index: string]: string | undefined;
+};
+/**
+ * A route which has matched, with its parameter values populated from the path.
+ */
+export interface IMatchedRoute {
+    route: IProcessedRoute;
+    /** Path used for the route match. Including parameter path values. Will not include the query string. */
+    path: string;
+    /** Param values matched from the path. */
+    params?: ParamsObject;
 }
 export default class RouteProvider {
     menuRoutes: Routing.IMenuRoute[];
     pureRoutes?: Routing.IRoute[] | undefined;
-    notFoundRoute?: React.ComponentType<{}> | undefined;
+    notFoundComponent?: React.ComponentType | undefined;
     private key;
     private routeIndex;
-    private paramRoutes;
-    flattenedRoutes: IProcessedRoute[];
+    private staticRoutes;
+    private parameterisedRoutes;
+    readonly allRoutes: IProcessedRoute[];
     /**
      * Creates a route provider which provides a list of flattened routes.
      * @param menuRoutes Routes which appear on the main menu.
      * @param pureRoutes Routes which don't have a menu item.
-     * @param notFoundRoute Route to render when the url doesn't match any of the above routes.
+     * @param notFoundComponent Component to render when the url doesn't match any of the above routes.
      */
-    constructor(menuRoutes: Routing.IMenuRoute[], pureRoutes?: Routing.IRoute[] | undefined, notFoundRoute?: React.ComponentType<{}> | undefined);
+    constructor(menuRoutes: Routing.IMenuRoute[], pureRoutes?: Routing.IRoute[] | undefined, notFoundComponent?: React.ComponentType | undefined);
     /** Gets the path the component is bound to. If the component is bound to multiple paths, the first path is returned. */
     getPathForComponent(component: any): string | undefined;
     private flatten;
@@ -29,3 +49,4 @@ export default class RouteProvider {
      */
     private processRoute;
 }
+export {};

package/dist/Routing/RouteProvider.js

@@ -5,39 +5,85 @@ var RouteProvider = /** @class */ (function () {
      * Creates a route provider which provides a list of flattened routes.
      * @param menuRoutes Routes which appear on the main menu.
      * @param pureRoutes Routes which don't have a menu item.
-     * @param notFoundRoute Route to render when the url doesn't match any of the above routes.
+     * @param notFoundComponent Component to render when the url doesn't match any of the above routes.
      */
-    function RouteProvider(menuRoutes, pureRoutes, notFoundRoute) {
-        var _a;
+    function RouteProvider(menuRoutes, pureRoutes, notFoundComponent) {
         this.menuRoutes = menuRoutes;
         this.pureRoutes = pureRoutes;
-        this.notFoundRoute = notFoundRoute;
+        this.notFoundComponent = notFoundComponent;
         this.key = 1;
         this.routeIndex = {};
-        this.paramRoutes = [];
-        this.flattenedRoutes = [];
-        this.flatten(menuRoutes);
+        this.staticRoutes = [];
+        this.parameterisedRoutes = [];
+        this.allRoutes = [];
+        this.flatten(this.allRoutes, menuRoutes);
         if (pureRoutes)
-            this.flatten(pureRoutes);
-        /*
-        Routes with template parameters must be added last so concrete routes resolve first.
-        E.g.
-            /clients/subview - SubViewComponent
-            /clients/:param - ClientsComponent
-
-        If the above was swapped around, ClientsComponent would match instead of SubViewComponent for /clients/subview.
-        */
-        (_a = this.flattenedRoutes).push.apply(_a, this.paramRoutes.sortBy("order", "desc").map(function (c) { return c.route; }));
-        if (notFoundRoute) {
-            this.flattenedRoutes.push({ component: notFoundRoute, key: -1, allowAnonymous: true, routePath: "" });
-        }
+            this.flatten(this.allRoutes, pureRoutes);
+        this.staticRoutes = this.allRoutes.filter(function (c) { return c.params.length === 0; });
+        this.parameterisedRoutes = this.allRoutes
+            .filter(function (c) { return c.params.length > 0; })
+            .map(function (route) { return ({ route: route, order: route.path.split("/").length }); })
+            .sortBy(function (c) { return c.order; }, "desc")
+            .map(function (c) { return c.route; });
     }
     /** Gets the path the component is bound to. If the component is bound to multiple paths, the first path is returned. */
     RouteProvider.prototype.getPathForComponent = function (component) {
         var _a;
-        return (_a = this.flattenedRoutes.find(function (c) { return c.component === component; })) === null || _a === void 0 ? void 0 : _a.path;
+        return (_a = this.allRoutes.find(function (c) { return c.component === component; })) === null || _a === void 0 ? void 0 : _a.path;
+    };
+    /** @internal */
+    RouteProvider.prototype.getRouteForPath = function (path) {
+        return RouteProvider.getRouteForPath(this.staticRoutes, this.parameterisedRoutes, path);
     };
-    RouteProvider.prototype.flatten = function (routes, parent) {
+    /** @internal */
+    RouteProvider.getRouteForPath = function (staticRoutes, parameterisedRoutes, path) {
+        var queryIndex = path.indexOf("?");
+        if (queryIndex >= 0) {
+            path = path.substring(0, queryIndex);
+        }
+        var lcPath = path.toLowerCase();
+        var found = staticRoutes.find(function (route) { return route.path === lcPath; });
+        if (found) {
+            return { route: found, path: path };
+        }
+        if (path.endsWith("/")) {
+            // special case for where an extra "/" is added to the url by mistake.
+            var trimmedPath_1 = lcPath.substring(0, path.length - 1);
+            var found_1 = staticRoutes.find(function (route) { return route.path === trimmedPath_1; });
+            if (found_1) {
+                return { route: found_1, path: path };
+            }
+        }
+        var matches = parameterisedRoutes.filter(function (route) { return lcPath.startsWith(route.path); });
+        for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
+            var match = matches_1[_i];
+            var paramString = path.substring(match.path.length);
+            var parts = paramString.split("/").slice(1);
+            var partCount = parts.length;
+            // Allow extra "/" 
+            if (partCount > 0 && parts[partCount - 1] === "") {
+                partCount -= 1;
+            }
+            if (match.params.length >= partCount) {
+                var paramValues = {};
+                var isValid = true;
+                for (var i = 0; i < match.params.length; i++) {
+                    var param = match.params[i];
+                    var value = parts[i];
+                    paramValues[param.name] = value;
+                    if (param.required && !value) {
+                        isValid = false;
+                        break;
+                    }
+                }
+                if (isValid) {
+                    return { route: match, path: path, params: paramValues };
+                }
+            }
+        }
+        return null;
+    };
+    RouteProvider.prototype.flatten = function (into, routes, parent) {
         var _a, _b;
         for (var _i = 0, routes_1 = routes; _i < routes_1.length; _i++) {
             var route = routes_1[_i];
@@ -46,45 +92,38 @@ var RouteProvider = /** @class */ (function () {
                 if (parent && !route.breadCrumbParent) {
                     route.breadCrumbParent = parent;
                 }
-                this.processRoute(route);
+                this.processRoute(into, route);
             }
             var menuRoute = route;
             var children = __spreadArray(__spreadArray([], ((_a = route.routeChildren) !== null && _a !== void 0 ? _a : []), true), ((_b = menuRoute.children) !== null && _b !== void 0 ? _b : []), true);
-            this.flatten(children, (hasComponent && menuRoute.showInBreadCrumb !== false) ? menuRoute : undefined);
+            this.flatten(into, children, (hasComponent && menuRoute.showInBreadCrumb !== false) ? menuRoute : undefined);
         }
     };
     /**
      * Create a copy of the route info, and process it.
      * Adds a unique key, and adds route parameters extracted from the component static params object.
      */
-    RouteProvider.prototype.processRoute = function (route) {
-        var processed = __assign(__assign({}, route), { routePath: route.path, key: this.key++ });
-        var isParamRoute = false;
+    RouteProvider.prototype.processRoute = function (into, route) {
+        var processed = __assign(__assign({}, route), { path: route.path, params: [], key: this.key++ });
         if (route instanceof MenuRoute) {
-            processed.routePath = route.basePath;
+            processed.path = route.basePath;
+        }
+        processed.path = processed.path.toLowerCase();
+        if (processed.path.length > 1 && processed.path.endsWith("/")) {
+            processed.path = processed.path.substring(0, processed.path.length - 1);
         }
         var viewBaseComponent = route.component;
         if (viewBaseComponent.params) {
-            if (processed.routePath.endsWith("/")) {
-                processed.routePath = processed.routePath.substring(0, processed.routePath.length - 1);
-            }
             for (var param in viewBaseComponent.params) {
                 var routeParam = viewBaseComponent.params[param];
                 if (!routeParam.isQuery) {
-                    isParamRoute = true;
-                    processed.routePath += "/:" + param + (routeParam.required ? "" : "?");
+                    processed.params.push(__assign(__assign({}, routeParam), { name: param }));
                 }
             }
         }
-        if (!this.routeIndex[processed.routePath]) {
-            this.routeIndex[processed.routePath] = true;
-            if (isParamRoute) {
-                // Must be ordered later by the number of slashes in the path. Root path is a special case.
-                this.paramRoutes.push({ route: processed, order: route.path === "/" ? 0 : (route.path.match(/\//g) || []).length });
-            }
-            else {
-                this.flattenedRoutes.push(processed);
-            }
+        if (!this.routeIndex[processed.path]) {
+            this.routeIndex[processed.path] = true;
+            into.push(processed);
         }
     };
     return RouteProvider;

package/dist/Routing/RouteView.d.ts

@@ -1,40 +1,18 @@
 import * as React from 'react';
-import { RouteComponentProps, Switch, Route } from 'react-router';
-import { Location, Action } from 'history';
 import { Routing } from '@singularsystems/neo-core';
 import RouteProvider from './RouteProvider';
-import { IRouteChangedProps } from './IRouteChangedProps';
-export interface IRouteViewInternal {
-    beforeLocationChanged(location: Location | undefined, action: Action, isUnload?: boolean): string | false | void;
-}
-export default abstract class RouteView extends React.Component<RouteComponentProps> {
-    private historyListenDisposer?;
-    private historyBlockDisposer?;
-    protected switchComponent: typeof Switch;
-    protected routeComponent: typeof Route;
+export default abstract class RouteView extends React.Component<unknown> {
+    private routeProvider;
+    private hasMounted;
     protected _routes: RouteProvider;
     protected getForbiddenComponent: (route: Routing.IRoute) => JSX.Element;
     protected getSigningInComponent: (route: Routing.IRoute) => JSX.Element;
     protected securityService: import("@singularsystems/neo-core/dist/Security/ISecurityService").default;
     protected routeSecurityService: Routing.IRouteSecurityService;
     protected routingState: import("./RoutingState").RoutingState;
-    constructor(props: RouteComponentProps);
-    get routes(): RouteProvider;
-    set routes(value: RouteProvider);
+    constructor(props: unknown, routeProvider: RouteProvider);
     componentDidMount(): void;
-    componentDidUpdate(): void;
-    componentWillUnmount(): void;
-    private beforeLocationChanged;
-    /**
-     * Called when the url changes, before the router renders the new view.
-     * Return a string to block navigation.
-     * @param isNewView True if the view is changing. False if a view parameter value is changing.
-     * @param currentView The current view before change.
-     */
-    protected beforeRouteChanged(props: IRouteChangedProps): void;
-    private getMatch;
-    static isExact(route: Routing.IRoute): boolean;
-    render(): React.CElement<import("react-router").SwitchProps, Switch>;
+    render(): JSX.Element | null;
     private getRouteComponent;
     /**
      * Creates the routes component after authentication and authorisation checks have been done.