zavadil-ts-common 1.2.39 → 1.2.41

package/dist/oauth/RestClientWithOAuth.d.ts

@@ -1,30 +1,23 @@
 import { OAuthTokenManager } from "./OAuthTokenManager";
 import { RestClient } from "../client";
 import { IdTokenPayload } from "./OAuthRestClient";
+import { OAuthIdTokenProvider } from "./tokenprovider/OAuthIdTokenProvider";
 export type ServerOAuthInfoPayload = {
     debugMode?: boolean;
     targetAudience: string;
     oauthServerUrl: string;
     version: string;
 };
-export declare class RestClientWithOAuth extends RestClient {
-    private tokenName;
+export declare class RestClientWithOAuth extends RestClient implements OAuthIdTokenProvider {
     private insecureClient;
+    private freshIdTokenProvider;
     private tokenManager;
     private serverInfo;
     private defaultPrivilege;
-    private redirecting?;
-    constructor(url: string, defaultPrivilege?: string);
-    isRedirecting(): boolean;
-    redirectingTo(): string;
-    redirectTo(url: string): Promise<any>;
-    initializeIdToken(): Promise<any>;
+    constructor(url: string, freshIdTokenProvider?: OAuthIdTokenProvider, defaultPrivilege?: string);
+    getIdToken(): Promise<IdTokenPayload>;
     /**
-     * Attempt to get ID token from URL or storage, redirect to login page when not successful
-     */
-    redirectToLogin(): Promise<any>;
-    /**
-     * Attempt to get ID token from URL or storage, redirect to login page when not successful
+     * Attempt to get ID token from token manager
      */
     initialize(): Promise<any>;
     logout(): Promise<any>;
@@ -33,23 +26,11 @@ export declare class RestClientWithOAuth extends RestClient {
      * @param url
      */
     getPrivilege(url: string): string;
-    deleteIdTokenFromUrl(): string;
-    getIdTokenFromUrl(): string | null;
-    getIdTokenFromLocalStorage(): IdTokenPayload | null | undefined;
-    saveIdTokenToLocalStorage(token: IdTokenPayload | null): void;
-    addIdTokenChangedHandler(handler: () => any): void;
-    removeIdTokenChangedHandler(handler: () => any): void;
     private getServerInfoInternal;
     getServerInfo(): Promise<ServerOAuthInfoPayload>;
-    private getTokenManagerInternal;
+    protected getTokenManagerInternal(): Promise<OAuthTokenManager>;
     getTokenManager(): Promise<OAuthTokenManager>;
     login(login: string, password: string): Promise<any>;
     setIdToken(token: IdTokenPayload): Promise<any>;
-    setIdTokenRaw(token: string): Promise<any>;
     getHeaders(endpoint: string): Promise<Headers>;
-    /**
-     * Try to obtain access token, then return if everything is okay.
-     * This is basically only used when initializing and trying to determine whether we need to redirect user to login page
-     */
-    checkAccessToken(privilege?: string): Promise<any>;
 }

package/dist/oauth/tokenprovider/IdTokenProviderDefault.d.ts

@@ -0,0 +1,13 @@
+import { OAuthIdTokenProvider } from "./OAuthIdTokenProvider";
+import { IdTokenPayload } from "../OAuthRestClient";
+import { IdTokenProviderLogin } from "./IdTokenProviderLogin";
+import { RestClientWithOAuth } from "../RestClientWithOAuth";
+import { IdTokenProviderUrl } from "./IdTokenProviderUrl";
+import { IdTokenProviderStorage } from "./IdTokenProviderStorage";
+export declare class IdTokenProviderDefault implements OAuthIdTokenProvider {
+    login: IdTokenProviderLogin;
+    url: IdTokenProviderUrl;
+    storage: IdTokenProviderStorage;
+    constructor(client: RestClientWithOAuth, tokenStorageKey?: string, tokenUrlName?: string);
+    getIdToken(): Promise<IdTokenPayload>;
+}

package/dist/oauth/tokenprovider/IdTokenProviderLogin.d.ts

@@ -0,0 +1,14 @@
+import { OAuthIdTokenProvider } from "./OAuthIdTokenProvider";
+import { IdTokenPayload } from "../OAuthRestClient";
+import { RedirectionProvider } from "./RedirectionProvider";
+import { RestClientWithOAuth } from "../RestClientWithOAuth";
+export declare class IdTokenProviderLogin extends RedirectionProvider implements OAuthIdTokenProvider {
+    client: RestClientWithOAuth;
+    tokenQueryName: string;
+    constructor(client: RestClientWithOAuth, tokenQueryName?: string);
+    /**
+     * Attempt to get ID token from URL or storage, redirect to login page when not successful
+     */
+    redirectToLogin(): Promise<any>;
+    getIdToken(): Promise<IdTokenPayload>;
+}

package/dist/oauth/tokenprovider/IdTokenProviderStorage.d.ts

@@ -0,0 +1,9 @@
+import { OAuthIdTokenProvider } from "./OAuthIdTokenProvider";
+import { IdTokenPayload } from "../OAuthRestClient";
+export declare class IdTokenProviderStorage implements OAuthIdTokenProvider {
+    key: string;
+    constructor(storageKey?: string);
+    saveIdTokenToLocalStorage(token: IdTokenPayload | null): void;
+    getIdTokenFromLocalStorage(): IdTokenPayload | null | undefined;
+    getIdToken(): Promise<IdTokenPayload>;
+}

package/dist/oauth/tokenprovider/IdTokenProviderUrl.d.ts

@@ -0,0 +1,10 @@
+import { OAuthIdTokenProvider } from "./OAuthIdTokenProvider";
+import { IdTokenPayload } from "../OAuthRestClient";
+import { RestClientWithOAuth } from "../RestClientWithOAuth";
+export declare class IdTokenProviderUrl implements OAuthIdTokenProvider {
+    client: RestClientWithOAuth;
+    tokenQueryName: string;
+    constructor(client: RestClientWithOAuth, tokenQueryName?: string);
+    getIdTokenFromUrl(): string | null;
+    getIdToken(): Promise<IdTokenPayload>;
+}

package/dist/oauth/tokenprovider/OAuthIdTokenProvider.d.ts

@@ -0,0 +1,4 @@
+import { IdTokenPayload } from "../OAuthRestClient";
+export interface OAuthIdTokenProvider {
+    getIdToken(): Promise<IdTokenPayload>;
+}

package/dist/oauth/tokenprovider/RedirectionProvider.d.ts

@@ -0,0 +1,6 @@
+export declare class RedirectionProvider {
+    private redirecting?;
+    redirectTo(url: string): Promise<any>;
+    isRedirecting(): boolean;
+    redirectingTo(): string;
+}

package/dist/util/UrlUtil.d.ts

@@ -0,0 +1,5 @@
+export default class UrlUtil {
+    static deleteParamFromUrl(url: string, paramName: string): string;
+    static extractParamFromUrl(url: string, name: string): string | null;
+    static paramExistsInUrl(url: string, name: string): boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "zavadil-ts-common",
-	"version": "1.2.39",
+	"version": "1.2.41",
 	"description": "Common types and components for Typescript UI apps.",
 	"main": "dist/index.js",
 	"module": "dist/index.esm.js",

package/src/oauth/OAuthTokenManager.ts

@@ -1,11 +1,12 @@
 import {AccessTokenPayload, IdTokenPayload, OAuthRestClient} from "./OAuthRestClient";
 import {EventManager} from "../component";
 import {StringUtil} from "../util";
+import {OAuthIdTokenProvider} from "./tokenprovider/OAuthIdTokenProvider";
 
 /**
  * Manages refresh of id and access tokens.
  */
-export class OAuthTokenManager {
+export class OAuthTokenManager implements OAuthIdTokenProvider {
 
 	private eventManager: EventManager = new EventManager();
 
@@ -15,9 +16,12 @@ export class OAuthTokenManager {
 
 	idToken?: IdTokenPayload;
 
+	freshIdTokenProvider: OAuthIdTokenProvider;
+
 	accessTokens: Map<string, AccessTokenPayload>;
 
-	constructor(oAuthServerBaseUrl: string, targetAudience: string) {
+	constructor(oAuthServerBaseUrl: string, targetAudience: string, freshIdTokenProvider: OAuthIdTokenProvider) {
+		this.freshIdTokenProvider = freshIdTokenProvider;
 		this.audience = targetAudience;
 		this.oAuthServer = new OAuthRestClient(oAuthServerBaseUrl);
 		this.accessTokens = new Map<string, AccessTokenPayload>();
@@ -65,21 +69,41 @@ export class OAuthTokenManager {
 		this.accessTokens.clear();
 	}
 
-	getIdToken(): Promise<string> {
+	/**
+	 * Get stored id token or ask the provider, this will trigger redirect to login screen in case of the default provider
+	 */
+	getIdTokenInternal(): Promise<IdTokenPayload> {
 		if (this.idToken === undefined || !this.hasValidIdToken()) {
-			return Promise.reject("No valid ID token!");
+			return this.freshIdTokenProvider.getIdToken();
 		}
-		if (this.isTokenReadyForRefresh(this.idToken.issuedAt, this.idToken.expires)) {
-			return this.oAuthServer
-				.refreshIdToken({idToken: this.idToken.token})
-				.then(
-					(t) => {
-						this.setIdToken(t);
-						return t.token;
+		return Promise.resolve(this.idToken);
+	}
+
+	/**
+	 * Get id token, refresh it if needed
+	 */
+	getIdToken(): Promise<IdTokenPayload> {
+		return this.getIdTokenInternal()
+			.then(
+				(t: IdTokenPayload) => {
+					if (this.isTokenReadyForRefresh(t.issuedAt, t.expires)) {
+						return this.oAuthServer
+							.refreshIdToken({idToken: t.token})
+							.then(
+								(t) => {
+									this.setIdToken(t);
+									return t;
+								}
+							);
 					}
-				);
-		}
-		return Promise.resolve(this.idToken.token);
+					this.setIdToken(t);
+					return Promise.resolve(t);
+				}
+			);
+	}
+
+	getIdTokenRaw(): Promise<string> {
+		return this.getIdToken().then(t => t.token);
 	}
 
 	setIdToken(token?: IdTokenPayload) {
@@ -90,22 +114,19 @@ export class OAuthTokenManager {
 		this.eventManager.triggerEvent('id-token-changed', token);
 	}
 
-	verifyIdToken(token: string): Promise<any> {
-		return this.oAuthServer.verifyIdToken(token)
-			.then((t) => this.setIdToken(t));
+	verifyIdToken(token: string): Promise<IdTokenPayload> {
+		return this.oAuthServer.verifyIdToken(token);
 	}
 
 	login(login: string, password: string): Promise<any> {
 		this.reset();
-		return this.oAuthServer.requestIdTokenFromLogin({login: login, password: password, targetAudience: this.audience})
-			.then(
-				(t) => {
-					this.setIdToken(t);
-				})
+		return this.oAuthServer
+			.requestIdTokenFromLogin({login: login, password: password, targetAudience: this.audience})
+			.then((t) => this.setIdToken(t));
 	}
 
 	private getAccessTokenInternal(privilege: string): Promise<AccessTokenPayload> {
-		return this.getIdToken()
+		return this.getIdTokenRaw()
 			.then(
 				(idToken: string) => this.oAuthServer
 					.requestAccessToken({idToken: idToken, targetAudience: this.audience, privilege: privilege})

package/src/oauth/RestClientWithOAuth.ts

@@ -1,8 +1,9 @@
 import {OAuthTokenManager} from "./OAuthTokenManager";
 import {RestClient} from "../client";
-import {IdTokenPayload} from "./OAuthRestClient";
+import {IdTokenPayload, TokenResponsePayloadBase} from "./OAuthRestClient";
 import {LazyAsync} from "../cache";
-import {StringUtil, JsonUtil} from "../util";
+import {OAuthIdTokenProvider} from "./tokenprovider/OAuthIdTokenProvider";
+import {IdTokenProviderDefault} from "./tokenprovider/IdTokenProviderDefault";
 
 export type ServerOAuthInfoPayload = {
 	debugMode?: boolean;
@@ -11,22 +12,22 @@ export type ServerOAuthInfoPayload = {
 	version: string;
 }
 
-export class RestClientWithOAuth extends RestClient {
-
-	private tokenName = 'token';
+export class RestClientWithOAuth extends RestClient implements OAuthIdTokenProvider {
 
 	private insecureClient: RestClient;
 
+	private freshIdTokenProvider: OAuthIdTokenProvider;
+
 	private tokenManager: LazyAsync<OAuthTokenManager>;
 
 	private serverInfo: LazyAsync<ServerOAuthInfoPayload>;
 
 	private defaultPrivilege: string;
 
-	private redirecting?: string;
-
-	constructor(url: string, defaultPrivilege: string = '*') {
+	constructor(url: string, freshIdTokenProvider?: OAuthIdTokenProvider, defaultPrivilege: string = '*') {
 		super(url);
+
+		this.freshIdTokenProvider = freshIdTokenProvider || new IdTokenProviderDefault(this);
 		this.defaultPrivilege = defaultPrivilege;
 
 		// rest client without OAuth headers
@@ -36,65 +37,15 @@ export class RestClientWithOAuth extends RestClient {
 		this.tokenManager = new LazyAsync<OAuthTokenManager>(() => this.getTokenManagerInternal());
 	}
 
-	isRedirecting(): boolean {
-		return StringUtil.notBlank(this.redirecting);
-	}
-
-	redirectingTo(): string {
-		return StringUtil.getNonEmpty(this.redirecting);
-	}
-
-	redirectTo(url: string): Promise<any> {
-		this.redirecting = url;
-		document.location.href = url;
-		return Promise.reject(`Redirecting to ${url}`);
-	}
-
-	initializeIdToken(): Promise<any> {
-		const urlToken = this.getIdTokenFromUrl();
-		if (urlToken !== null) {
-			return this
-				.setIdTokenRaw(urlToken)
-				.then(
-					() => this.redirectTo(this.deleteIdTokenFromUrl())
-				);
-		} else {
-			const storageToken = this.getIdTokenFromLocalStorage();
-			if (storageToken) return this.setIdToken(storageToken);
-		}
-		return Promise.reject("No valid ID token!");
-	}
-
-	/**
-	 * Attempt to get ID token from URL or storage, redirect to login page when not successful
-	 */
-	redirectToLogin(): Promise<any> {
-		if (this.isRedirecting()) return Promise.reject("Already redirecting!");
-		return this.getServerInfo().then(
-			(si) => {
-				const location = `${si.oauthServerUrl}/login?app_name=${si.targetAudience}&redirect_url=${this.deleteIdTokenFromUrl()}`;
-				return this.redirectTo(location);
-			}
-		).catch((err) => {
-			console.error('Redirection failed: OAuth info not fetched:', err);
-			return Promise.reject(err);
-		});
-	}
+	getIdToken(): Promise<IdTokenPayload> {
+        return this.getTokenManager().then(t => t.getIdToken());
+    }
 
 	/**
-	 * Attempt to get ID token from URL or storage, redirect to login page when not successful
+	 * Attempt to get ID token from token manager
 	 */
 	initialize(): Promise<any> {
-		return this.initializeIdToken()
-			.then(() => {
-				if (!this.isRedirecting()) return this.checkAccessToken();
-			})
-			.catch(
-				(reason) => {
-					console.log('OAuth initialization failed:', reason);
-					return this.redirectToLogin();
-				}
-			);
+		return this.getIdToken();
 	}
 
 	logout(): Promise<any> {
@@ -111,38 +62,6 @@ export class RestClientWithOAuth extends RestClient {
 		return this.defaultPrivilege;
 	}
 
-	deleteIdTokenFromUrl(): string {
-		const url = new URL(document.location.toString());
-		url.searchParams.delete(this.tokenName);
-		return StringUtil.trimTrailingSlashes(url.toString());
-	}
-
-	getIdTokenFromUrl(): string | null {
-		const up = new URLSearchParams(document.location.search);
-		return up.get(this.tokenName);
-	}
-
-	getIdTokenFromLocalStorage(): IdTokenPayload | null | undefined {
-		return JsonUtil.parse(localStorage.getItem('id-token'));
-	}
-
-	saveIdTokenToLocalStorage(token: IdTokenPayload | null) {
-		const raw = token ? JSON.stringify(token) : null;
-		if (raw === null) {
-			localStorage.removeItem('id-token');
-			return;
-		}
-		localStorage.setItem('id-token', raw);
-	}
-
-	addIdTokenChangedHandler(handler: () => any) {
-		this.getTokenManager().then((m) => m.addIdTokenChangedHandler(handler));
-	}
-
-	removeIdTokenChangedHandler(handler: () => any) {
-		this.getTokenManager().then((m) => m.removeIdTokenChangedHandler(handler));
-	}
-
 	private getServerInfoInternal(): Promise<ServerOAuthInfoPayload> {
 		return this.insecureClient.getJson('status/oauth/info');
 	}
@@ -151,15 +70,10 @@ export class RestClientWithOAuth extends RestClient {
 		return this.serverInfo.get();
 	}
 
-	private getTokenManagerInternal(): Promise<OAuthTokenManager> {
-		return this.getServerInfo()
-			.then(
-				(info) => {
-					const tm = new OAuthTokenManager(info.oauthServerUrl, info.targetAudience);
-					tm.addIdTokenChangedHandler((t: IdTokenPayload) => this.saveIdTokenToLocalStorage(t));
-					return tm;
-				}
-			);
+	protected getTokenManagerInternal(): Promise<OAuthTokenManager> {
+		return this
+			.getServerInfo()
+			.then((info) =>  new OAuthTokenManager(info.oauthServerUrl, info.targetAudience, this.freshIdTokenProvider));
 	}
 
 	getTokenManager(): Promise<OAuthTokenManager> {
@@ -175,10 +89,6 @@ export class RestClientWithOAuth extends RestClient {
 			.then((m) => m.setIdToken(token));
 	}
 
-	setIdTokenRaw(token: string): Promise<any> {
-		return this.getTokenManager().then(m => m.verifyIdToken(token))
-	}
-
 	getHeaders(endpoint: string): Promise<Headers> {
 		return this.getTokenManager()
 			.then(tm => tm.getAccessToken(this.getPrivilege(endpoint)))
@@ -193,14 +103,4 @@ export class RestClientWithOAuth extends RestClient {
 			);
 	}
 
-	/**
-	 * Try to obtain access token, then return if everything is okay.
-	 * This is basically only used when initializing and trying to determine whether we need to redirect user to login page
-	 */
-	checkAccessToken(privilege?: string): Promise<any> {
-		return this.getTokenManager()
-			.then(tm => tm.getAccessToken(StringUtil.getNonEmpty(privilege, this.defaultPrivilege)))
-			.catch((e) => Promise.reject(`Access token check failed: ${e}`));
-	}
-
 }

package/src/oauth/tokenprovider/IdTokenProviderDefault.ts

@@ -0,0 +1,44 @@
+import {OAuthIdTokenProvider} from "./OAuthIdTokenProvider";
+import {IdTokenPayload} from "../OAuthRestClient";
+import {IdTokenProviderLogin} from "./IdTokenProviderLogin";
+import {RestClientWithOAuth} from "../RestClientWithOAuth";
+import { IdTokenProviderUrl } from "./IdTokenProviderUrl";
+import {IdTokenProviderStorage} from "./IdTokenProviderStorage";
+
+export class IdTokenProviderDefault implements OAuthIdTokenProvider {
+
+	login: IdTokenProviderLogin;
+
+	url: IdTokenProviderUrl;
+
+	storage: IdTokenProviderStorage;
+
+	constructor(client: RestClientWithOAuth, tokenStorageKey?: string, tokenUrlName?: string) {
+		this.login = new IdTokenProviderLogin(client, tokenUrlName);
+		this.url = new IdTokenProviderUrl(client, tokenUrlName);
+		this.storage = new IdTokenProviderStorage(tokenStorageKey);
+	}
+
+	getIdToken(): Promise<IdTokenPayload> {
+		return this.url
+			.getIdToken()
+			.catch(
+				(err) => {
+					console.log("No token in url, loading from storage", err);
+					return this.storage
+						.getIdToken()
+						.catch(
+							(err) => {
+								console.log("No token in storage, redirecting to login page", err);
+								return this.login.getIdToken();
+							}
+						);
+				}
+			)
+			.then((t) => {
+				this.storage.saveIdTokenToLocalStorage(t);
+				return t;
+			});
+    }
+
+}

package/src/oauth/tokenprovider/IdTokenProviderLogin.ts

@@ -0,0 +1,39 @@
+import {OAuthIdTokenProvider} from "./OAuthIdTokenProvider";
+import {IdTokenPayload} from "../OAuthRestClient";
+import {RedirectionProvider} from "./RedirectionProvider";
+import {RestClientWithOAuth} from "../RestClientWithOAuth";
+import UrlUtil from "../../util/UrlUtil";
+
+export class IdTokenProviderLogin extends RedirectionProvider implements OAuthIdTokenProvider {
+
+	client: RestClientWithOAuth;
+
+	tokenQueryName: string;
+
+	constructor(client: RestClientWithOAuth, tokenQueryName?: string) {
+		super();
+		this.client = client;
+		this.tokenQueryName = tokenQueryName || 'token';
+	}
+
+	/**
+	 * Attempt to get ID token from URL or storage, redirect to login page when not successful
+	 */
+	redirectToLogin(): Promise<any> {
+		return this.client.getServerInfo().then(
+			(si) => {
+				const thisUrl = UrlUtil.deleteParamFromUrl(document.location.toString(), this.tokenQueryName);
+				const location = `${si.oauthServerUrl}/login?app_name=${si.targetAudience}&redirect_url=${thisUrl}`;
+				return this.redirectTo(location);
+			}
+		).catch((err) => {
+			console.error('Redirection failed: OAuth info not fetched:', err);
+			return Promise.reject(err);
+		});
+	}
+
+	getIdToken(): Promise<IdTokenPayload> {
+        return this.redirectToLogin();
+    }
+
+}

package/src/oauth/tokenprovider/IdTokenProviderStorage.ts

@@ -0,0 +1,32 @@
+import {OAuthIdTokenProvider} from "./OAuthIdTokenProvider";
+import {IdTokenPayload} from "../OAuthRestClient";
+import {JsonUtil} from "../../util";
+
+export class IdTokenProviderStorage implements OAuthIdTokenProvider {
+
+	key: string;
+
+	constructor(storageKey?: string) {
+		this.key = storageKey || 'id-token';
+	}
+
+	saveIdTokenToLocalStorage(token: IdTokenPayload | null) {
+		const raw = token ? JSON.stringify(token) : null;
+		if (raw === null) {
+			localStorage.removeItem(this.key);
+			return;
+		}
+		localStorage.setItem(this.key, raw);
+	}
+
+	getIdTokenFromLocalStorage(): IdTokenPayload | null | undefined {
+		return JsonUtil.parse(localStorage.getItem(this.key));
+	}
+
+	getIdToken(): Promise<IdTokenPayload> {
+        const token = this.getIdTokenFromLocalStorage();
+		if (token) return Promise.resolve(token);
+		return Promise.reject("No token found in storage!");
+    }
+
+}

package/src/oauth/tokenprovider/IdTokenProviderUrl.ts

@@ -0,0 +1,30 @@
+import {OAuthIdTokenProvider} from "./OAuthIdTokenProvider";
+import {IdTokenPayload} from "../OAuthRestClient";
+import {RestClientWithOAuth} from "../RestClientWithOAuth";
+import {StringUtil} from "../../util";
+import UrlUtil from "../../util/UrlUtil";
+
+export class IdTokenProviderUrl implements OAuthIdTokenProvider {
+
+	client: RestClientWithOAuth;
+
+	tokenQueryName: string;
+
+	constructor(client: RestClientWithOAuth, tokenQueryName?: string) {
+		this.client = client;
+		this.tokenQueryName = tokenQueryName || 'token';
+	}
+
+	getIdTokenFromUrl(): string | null {
+		return UrlUtil.extractParamFromUrl(document.location.toString(), this.tokenQueryName);
+	}
+
+	getIdToken(): Promise<IdTokenPayload> {
+		const raw = this.getIdTokenFromUrl();
+		if (raw === null || StringUtil.isBlank(raw)) return Promise.reject("No token in URL!");
+		return this.client
+			.getTokenManager()
+			.then(m => m.verifyIdToken(raw));
+    }
+
+}

package/src/oauth/tokenprovider/OAuthIdTokenProvider.ts

@@ -0,0 +1,5 @@
+import {IdTokenPayload} from "../OAuthRestClient";
+
+export interface OAuthIdTokenProvider {
+	getIdToken(): Promise<IdTokenPayload>;
+}

package/src/oauth/tokenprovider/RedirectionProvider.ts

@@ -0,0 +1,21 @@
+import {StringUtil} from "../../util";
+
+export class RedirectionProvider {
+
+	private redirecting?: string;
+
+	redirectTo(url: string): Promise<any> {
+		this.redirecting = url;
+		document.location.href = url;
+		return Promise.reject(`Redirecting to ${url}`);
+	}
+
+	isRedirecting(): boolean {
+		return StringUtil.notBlank(this.redirecting);
+	}
+
+	redirectingTo(): string {
+		return StringUtil.getNonEmpty(this.redirecting);
+	}
+
+}

package/src/util/UrlUtil.ts

@@ -0,0 +1,19 @@
+import {StringUtil} from "./StringUtil";
+
+export default class UrlUtil {
+
+	static deleteParamFromUrl(url: string, paramName: string): string {
+		const urlObj = new URL(url);
+		urlObj.searchParams.delete(paramName);
+		return StringUtil.trimTrailingSlashes(url.toString());
+	}
+
+	static extractParamFromUrl(url: string, name: string): string | null {
+		const usp = new URLSearchParams(new URL(url).search);
+		return usp.get(name);
+	}
+
+	static paramExistsInUrl(url: string, name: string): boolean {
+		return StringUtil.notBlank(UrlUtil.extractParamFromUrl(url, name));
+	}
+}