@sisense/sdk-rest-client 1.21.0 → 1.23.0

package/dist/authenticator.d.ts

@@ -9,5 +9,5 @@ declare type AuthenticatorConfig = {
     enableSilentPreAuth?: boolean;
     useFusionAuth?: boolean;
 };
-export declare function getAuthenticator({ url, username, password, token, wat, ssoEnabled, enableSilentPreAuth, useFusionAuth, }: AuthenticatorConfig): Authenticator | null;
+export declare function getAuthenticator({ url: rawUrl, username, password, token, wat, ssoEnabled, enableSilentPreAuth, useFusionAuth, }: AuthenticatorConfig): Authenticator | null;
 export {};

package/dist/authenticator.js

@@ -1,9 +1,12 @@
+/* eslint-disable max-params */
+import { normalizeUrl } from '@sisense/sdk-common';
 import { PasswordAuthenticator } from './password-authenticator.js';
 import { BearerAuthenticator } from './bearer-authenticator.js';
 import { WatAuthenticator } from './wat-authenticator.js';
 import { SsoAuthenticator } from './sso-authenticator.js';
 import { FusionAuthenticator } from './fusion-authenticator.js';
-export function getAuthenticator({ url, username, password, token, wat, ssoEnabled = false, enableSilentPreAuth = false, useFusionAuth = false, }) {
+export function getAuthenticator({ url: rawUrl, username, password, token, wat, ssoEnabled = false, enableSilentPreAuth = false, useFusionAuth = false, }) {
+    const url = normalizeUrl(rawUrl);
     // sso overrides all other auth methods
     if (ssoEnabled) {
         return new SsoAuthenticator(url, enableSilentPreAuth);

package/dist/cjs/authenticator.d.ts

@@ -0,0 +1,13 @@
+import { Authenticator } from './interfaces.js';
+declare type AuthenticatorConfig = {
+    url: string;
+    username?: string;
+    password?: string;
+    token?: string | null;
+    wat?: string | null;
+    ssoEnabled?: boolean;
+    enableSilentPreAuth?: boolean;
+    useFusionAuth?: boolean;
+};
+export declare function getAuthenticator({ url: rawUrl, username, password, token, wat, ssoEnabled, enableSilentPreAuth, useFusionAuth, }: AuthenticatorConfig): Authenticator | null;
+export {};

package/dist/cjs/authenticator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthenticator = void 0;
+/* eslint-disable max-params */
+const sdk_common_1 = require("@sisense/sdk-common");
+const password_authenticator_js_1 = require("./password-authenticator.js");
+const bearer_authenticator_js_1 = require("./bearer-authenticator.js");
+const wat_authenticator_js_1 = require("./wat-authenticator.js");
+const sso_authenticator_js_1 = require("./sso-authenticator.js");
+const fusion_authenticator_js_1 = require("./fusion-authenticator.js");
+function getAuthenticator({ url: rawUrl, username, password, token, wat, ssoEnabled = false, enableSilentPreAuth = false, useFusionAuth = false, }) {
+    const url = (0, sdk_common_1.normalizeUrl)(rawUrl);
+    // sso overrides all other auth methods
+    if (ssoEnabled) {
+        return new sso_authenticator_js_1.SsoAuthenticator(url, enableSilentPreAuth);
+    }
+    // username/password or tokens are chosen relative to priority
+    if (username && password) {
+        return new password_authenticator_js_1.PasswordAuthenticator(url, username, password);
+    }
+    if (token) {
+        return new bearer_authenticator_js_1.BearerAuthenticator(url, token);
+    }
+    if (wat) {
+        return new wat_authenticator_js_1.WatAuthenticator(url, wat);
+    }
+    if (useFusionAuth) {
+        return new fusion_authenticator_js_1.FusionAuthenticator();
+    }
+    return null;
+}
+exports.getAuthenticator = getAuthenticator;

package/dist/cjs/base-authenticator.d.ts

@@ -0,0 +1,16 @@
+import { Authenticator } from './interfaces.js';
+export declare class BaseAuthenticator implements Authenticator {
+    readonly type: Authenticator['type'];
+    private _valid;
+    protected _authenticating: boolean;
+    protected _tried: boolean;
+    protected _resolve: (value: boolean) => void;
+    protected readonly _result: Promise<boolean>;
+    protected constructor(type: Authenticator['type']);
+    isValid(): boolean;
+    invalidate(): void;
+    authenticate(): Promise<boolean>;
+    isAuthenticating(): boolean;
+    authenticated(): Promise<boolean>;
+    applyHeader(headers: HeadersInit): void;
+}

package/dist/cjs/base-authenticator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAuthenticator = void 0;
+class BaseAuthenticator {
+    constructor(type) {
+        this._valid = true;
+        this._authenticating = false;
+        this._tried = false;
+        this._result = new Promise((resolve) => {
+            this._resolve = resolve;
+        });
+        this.type = type;
+    }
+    isValid() {
+        return this._valid;
+    }
+    invalidate() {
+        this._valid = false;
+    }
+    authenticate() {
+        return this._result;
+    }
+    isAuthenticating() {
+        return this._authenticating;
+    }
+    authenticated() {
+        return this._result;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+    applyHeader(headers) {
+        // Do nothing
+    }
+}
+exports.BaseAuthenticator = BaseAuthenticator;

package/dist/cjs/bearer-authenticator.d.ts

@@ -0,0 +1,16 @@
+import { Authenticator } from './interfaces.js';
+import { BaseAuthenticator } from './base-authenticator.js';
+export declare class BearerAuthenticator extends BaseAuthenticator {
+    readonly bearer: string;
+    constructor(url: string, bearer: string);
+    applyHeader(headers: HeadersInit): void;
+    authenticate(): Promise<boolean>;
+    authenticated(): Promise<boolean>;
+}
+/**
+ * Checks if an authenticator is a BearerAuthenticator.
+ *
+ * @param authenticator - The authenticator to check.
+ * @internal
+ */
+export declare function isBearerAuthenticator(authenticator: Authenticator): authenticator is BearerAuthenticator;

package/dist/cjs/bearer-authenticator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBearerAuthenticator = exports.BearerAuthenticator = void 0;
+const base_authenticator_js_1 = require("./base-authenticator.js");
+const helpers_js_1 = require("./helpers.js");
+class BearerAuthenticator extends base_authenticator_js_1.BaseAuthenticator {
+    constructor(url, bearer) {
+        super('bearer');
+        this.bearer = bearer;
+        this._resolve(true);
+    }
+    applyHeader(headers) {
+        const authHeader = 'Bearer ' + this.bearer;
+        (0, helpers_js_1.appendHeaders)(headers, { Authorization: authHeader });
+    }
+    authenticate() {
+        // TODO: implement authentication test
+        return this._result;
+    }
+    authenticated() {
+        return this._result;
+    }
+}
+exports.BearerAuthenticator = BearerAuthenticator;
+/**
+ * Checks if an authenticator is a BearerAuthenticator.
+ *
+ * @param authenticator - The authenticator to check.
+ * @internal
+ */
+function isBearerAuthenticator(authenticator) {
+    return authenticator.type === 'bearer';
+}
+exports.isBearerAuthenticator = isBearerAuthenticator;

package/dist/cjs/constants.d.ts

@@ -0,0 +1 @@
+export declare const ERROR_PREFIX = "[request-error]";

package/dist/cjs/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_PREFIX = void 0;
+exports.ERROR_PREFIX = '[request-error]';

package/dist/cjs/fusion-authenticator.d.ts

@@ -0,0 +1,23 @@
+/// <reference lib="dom" />
+import { Authenticator } from './interfaces.js';
+import { BaseAuthenticator } from './base-authenticator.js';
+export declare type FusionWindow = Window & typeof globalThis & {
+    prism: {
+        user: {
+            _id: string | undefined;
+        };
+    } | undefined;
+};
+export declare class FusionAuthenticator extends BaseAuthenticator {
+    constructor();
+    private antiCsrfToken;
+    authenticate(): Promise<boolean>;
+    applyHeader(headers: HeadersInit): void;
+}
+/**
+ * Checks if the authenticator is SSO authenticator
+ *
+ * @param authenticator - authenticator to check
+ * @internal
+ */
+export declare function isFusionAuthenticator(authenticator: Authenticator): authenticator is FusionAuthenticator;

package/dist/cjs/fusion-authenticator.js

@@ -0,0 +1,38 @@
+"use strict";
+/// <reference lib="dom" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFusionAuthenticator = exports.FusionAuthenticator = void 0;
+const base_authenticator_js_1 = require("./base-authenticator.js");
+const helpers_js_1 = require("./helpers.js");
+class FusionAuthenticator extends base_authenticator_js_1.BaseAuthenticator {
+    constructor() {
+        super('fusion');
+    }
+    authenticate() {
+        var _a, _b, _c, _d, _e;
+        const hasUser = !!((_b = (_a = window.prism) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b._id);
+        this._resolve(hasUser);
+        const antiCsrfToken = (_e = (_d = (_c = window.document) === null || _c === void 0 ? void 0 : _c.cookie) === null || _d === void 0 ? void 0 : _d.match(/(?:^|;\s*)XSRF-TOKEN=([^;]+)/)) === null || _e === void 0 ? void 0 : _e[1];
+        if (antiCsrfToken)
+            this.antiCsrfToken = antiCsrfToken;
+        return this._result;
+    }
+    applyHeader(headers) {
+        if (this.antiCsrfToken) {
+            (0, helpers_js_1.appendHeaders)(headers, {
+                'X-Xsrf-Token': this.antiCsrfToken,
+            });
+        }
+    }
+}
+exports.FusionAuthenticator = FusionAuthenticator;
+/**
+ * Checks if the authenticator is SSO authenticator
+ *
+ * @param authenticator - authenticator to check
+ * @internal
+ */
+function isFusionAuthenticator(authenticator) {
+    return authenticator.type === 'fusion';
+}
+exports.isFusionAuthenticator = isFusionAuthenticator;

package/dist/cjs/helpers.d.ts

@@ -0,0 +1,14 @@
+export declare const appendHeaders: (existingHeaders: HeadersInit, additionalHeaders: {
+    [key: string]: string;
+}) => void;
+export declare const addQueryParamsToUrl: (url: string, params: {
+    [key: string]: string;
+}) => string;
+/**
+ * Checks if API token or WAT token is pending (e.g., being generated)
+ *
+ * @param token - API token
+ * @param wat - WAT token
+ * @returns true if the token is pending
+ */
+export declare const isAuthTokenPending: (token?: string | null, wat?: string | null) => boolean;

package/dist/cjs/helpers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthTokenPending = exports.addQueryParamsToUrl = exports.appendHeaders = void 0;
+const appendHeaders = (existingHeaders, additionalHeaders) => {
+    for (const [headerName, headerValue] of Object.entries(additionalHeaders)) {
+        if (Array.isArray(existingHeaders)) {
+            existingHeaders.push([headerName, headerValue]);
+        }
+        else if (typeof existingHeaders.set === 'function') {
+            existingHeaders.set(headerName, headerValue);
+        }
+        else {
+            // eslint-disable-next-line security/detect-object-injection
+            existingHeaders[headerName] = headerValue;
+        }
+    }
+};
+exports.appendHeaders = appendHeaders;
+const addQueryParamsToUrl = (url, params) => {
+    if (!url || typeof url !== 'string')
+        return url;
+    // can't just append to the url because it might already have a query string
+    const urlObject = new URL(url);
+    for (const [paramName, paramValue] of Object.entries(params)) {
+        urlObject.searchParams.append(paramName, paramValue);
+    }
+    // replace the trailing slash if there is one
+    return urlObject.toString().replace(/\/([?&])/, '$1');
+};
+exports.addQueryParamsToUrl = addQueryParamsToUrl;
+/**
+ * Checks if API token or WAT token is pending (e.g., being generated)
+ *
+ * @param token - API token
+ * @param wat - WAT token
+ * @returns true if the token is pending
+ */
+const isAuthTokenPending = (token, wat) => {
+    return token === null || wat === null;
+};
+exports.isAuthTokenPending = isAuthTokenPending;

package/dist/cjs/http-client.d.ts

@@ -0,0 +1,19 @@
+/// <reference lib="dom" />
+import { Authenticator } from './interfaces.js';
+export interface HttpClientRequestConfig {
+    skipTrackingParam?: boolean;
+    nonJSONBody?: boolean;
+    returnBlob?: boolean;
+}
+export declare class HttpClient {
+    readonly auth: Authenticator;
+    readonly url: string;
+    readonly env: string;
+    constructor(url: string, auth: Authenticator, env: string);
+    login(): Promise<boolean>;
+    call<T>(url: string, config: RequestInit, requestConfig?: HttpClientRequestConfig): Promise<T | undefined>;
+    post<T = unknown>(endpoint: string, data: unknown, options?: RequestInit, abortSignal?: AbortSignal, config?: HttpClientRequestConfig): Promise<T | undefined>;
+    patch<T = unknown>(endpoint: string, data: unknown, options?: RequestInit, abortSignal?: AbortSignal, config?: HttpClientRequestConfig): Promise<T | undefined>;
+    get<T = unknown>(endpoint: string, request?: RequestInit, config?: HttpClientRequestConfig): Promise<T | undefined>;
+    delete<T = void>(endpoint: string, request?: RequestInit, config?: HttpClientRequestConfig): Promise<T | undefined>;
+}

package/dist/cjs/http-client.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+/// <reference lib="dom" />
+const sdk_common_1 = require("@sisense/sdk-common");
+const interceptors_js_1 = require("./interceptors.js");
+const sso_authenticator_js_1 = require("./sso-authenticator.js");
+const helpers_js_1 = require("./helpers.js");
+class HttpClient {
+    constructor(url, auth, env) {
+        this.url = (0, sdk_common_1.normalizeUrl)(url);
+        this.auth = auth;
+        this.env = env;
+    }
+    login() {
+        return this.auth.authenticate();
+    }
+    call(url, config, requestConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.auth.isAuthenticating()) {
+                yield this.auth.authenticated();
+            }
+            config.headers = config.headers || {};
+            if ((0, sso_authenticator_js_1.isSsoAuthenticator)(this.auth)) {
+                // allows cookies to be sent
+                config.credentials = 'include';
+            }
+            this.auth.applyHeader(config.headers);
+            const fetchUrl = (requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.skipTrackingParam)
+                ? url
+                : (0, helpers_js_1.addQueryParamsToUrl)(url, {
+                    trc: this.env,
+                });
+            const response = yield fetch(fetchUrl, config)
+                .then((0, interceptors_js_1.getResponseInterceptor)(this.auth))
+                .catch(interceptors_js_1.errorInterceptor);
+            if (response.status === 204 || // No content
+                response.status === 304 // Not modified
+            ) {
+                return;
+            }
+            return ((requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.returnBlob)
+                ? response.blob()
+                : response.json().catch((e) => {
+                    var _a, _b;
+                    // some of APIs in Sisense returns 200 with empty body - so it's not possible
+                    // to understand definitely is it empty or not until you will try to parse it
+                    if (!((_b = (_a = e === null || e === void 0 ? void 0 : e.message) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, 'Unexpected end of JSON input'))) {
+                        throw e;
+                    }
+                }));
+        });
+    }
+    // eslint-disable-next-line max-params
+    post(endpoint, data, options = {}, abortSignal, config) {
+        const request = Object.assign({ method: 'POST', body: ((config === null || config === void 0 ? void 0 : config.nonJSONBody) ? data : JSON.stringify(data)), headers: {
+                Accept: 'application/json, text/plain, */*',
+                'Content-Type': 'application/json;charset=UTF-8',
+            }, signal: abortSignal }, options);
+        return this.call(this.url + endpoint, request, config);
+    }
+    patch(endpoint, data, options = {}, abortSignal, config) {
+        const request = Object.assign({ method: 'PATCH', body: ((config === null || config === void 0 ? void 0 : config.nonJSONBody) ? data : JSON.stringify(data)), headers: {
+                Accept: 'application/json, text/plain, */*',
+                'Content-Type': 'application/json;charset=UTF-8',
+            }, signal: abortSignal }, options);
+        return this.call(this.url + endpoint, request, config);
+    }
+    get(endpoint, request = {}, config) {
+        return this.call(this.url + endpoint, Object.assign(Object.assign({}, request), { method: 'GET' }), config);
+    }
+    delete(endpoint, request = {}, config) {
+        return this.call(this.url + endpoint, Object.assign(Object.assign({}, request), { method: 'DELETE' }), config);
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/cjs/index.d.ts

@@ -0,0 +1,11 @@
+import './translation/initialize-i18n.js';
+export * from './interfaces.js';
+export { PasswordAuthenticator } from './password-authenticator.js';
+export { SsoAuthenticator, isSsoAuthenticator } from './sso-authenticator.js';
+export { FusionAuthenticator, isFusionAuthenticator } from './fusion-authenticator.js';
+export { BearerAuthenticator, isBearerAuthenticator } from './bearer-authenticator.js';
+export { WatAuthenticator, isWatAuthenticator } from './wat-authenticator.js';
+export { getAuthenticator } from './authenticator.js';
+export { isAuthTokenPending } from './helpers.js';
+export { HttpClient } from './http-client.js';
+export type { TranslationDictionary, PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = exports.isAuthTokenPending = exports.getAuthenticator = exports.isWatAuthenticator = exports.WatAuthenticator = exports.isBearerAuthenticator = exports.BearerAuthenticator = exports.isFusionAuthenticator = exports.FusionAuthenticator = exports.isSsoAuthenticator = exports.SsoAuthenticator = exports.PasswordAuthenticator = void 0;
+require("./translation/initialize-i18n.js");
+__exportStar(require("./interfaces.js"), exports);
+var password_authenticator_js_1 = require("./password-authenticator.js");
+Object.defineProperty(exports, "PasswordAuthenticator", { enumerable: true, get: function () { return password_authenticator_js_1.PasswordAuthenticator; } });
+var sso_authenticator_js_1 = require("./sso-authenticator.js");
+Object.defineProperty(exports, "SsoAuthenticator", { enumerable: true, get: function () { return sso_authenticator_js_1.SsoAuthenticator; } });
+Object.defineProperty(exports, "isSsoAuthenticator", { enumerable: true, get: function () { return sso_authenticator_js_1.isSsoAuthenticator; } });
+var fusion_authenticator_js_1 = require("./fusion-authenticator.js");
+Object.defineProperty(exports, "FusionAuthenticator", { enumerable: true, get: function () { return fusion_authenticator_js_1.FusionAuthenticator; } });
+Object.defineProperty(exports, "isFusionAuthenticator", { enumerable: true, get: function () { return fusion_authenticator_js_1.isFusionAuthenticator; } });
+var bearer_authenticator_js_1 = require("./bearer-authenticator.js");
+Object.defineProperty(exports, "BearerAuthenticator", { enumerable: true, get: function () { return bearer_authenticator_js_1.BearerAuthenticator; } });
+Object.defineProperty(exports, "isBearerAuthenticator", { enumerable: true, get: function () { return bearer_authenticator_js_1.isBearerAuthenticator; } });
+var wat_authenticator_js_1 = require("./wat-authenticator.js");
+Object.defineProperty(exports, "WatAuthenticator", { enumerable: true, get: function () { return wat_authenticator_js_1.WatAuthenticator; } });
+Object.defineProperty(exports, "isWatAuthenticator", { enumerable: true, get: function () { return wat_authenticator_js_1.isWatAuthenticator; } });
+var authenticator_js_1 = require("./authenticator.js");
+Object.defineProperty(exports, "getAuthenticator", { enumerable: true, get: function () { return authenticator_js_1.getAuthenticator; } });
+var helpers_js_1 = require("./helpers.js");
+Object.defineProperty(exports, "isAuthTokenPending", { enumerable: true, get: function () { return helpers_js_1.isAuthTokenPending; } });
+var http_client_js_1 = require("./http-client.js");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return http_client_js_1.HttpClient; } });

package/dist/cjs/interceptors.d.ts

@@ -0,0 +1,3 @@
+import { Authenticator } from './interfaces.js';
+export declare const getResponseInterceptor: (auth: Authenticator) => (response: Response) => Response;
+export declare const errorInterceptor: (error: Error) => Promise<never>;

package/dist/cjs/interceptors.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorInterceptor = exports.getResponseInterceptor = void 0;
+const bearer_authenticator_js_1 = require("./bearer-authenticator.js");
+const wat_authenticator_js_1 = require("./wat-authenticator.js");
+const password_authenticator_js_1 = require("./password-authenticator.js");
+const sso_authenticator_js_1 = require("./sso-authenticator.js");
+const translatable_error_js_1 = require("./translation/translatable-error.js");
+function handleErrorResponse(response) {
+    if (!response.ok) {
+        throw new translatable_error_js_1.TranslatableError('errors.responseError', {
+            status: response.status.toString(),
+            statusText: response.statusText,
+            context: response.statusText ? 'withStatusText' : 'onlyStatus',
+        });
+    }
+    return response;
+}
+function handleUnauthorizedResponse(response, auth) {
+    auth.invalidate();
+    // skip login redirect for token auth
+    if ((0, password_authenticator_js_1.isPasswordAuthenticator)(auth)) {
+        throw new translatable_error_js_1.TranslatableError('errors.passwordAuthFailed');
+    }
+    if ((0, bearer_authenticator_js_1.isBearerAuthenticator)(auth) || (0, wat_authenticator_js_1.isWatAuthenticator)(auth)) {
+        throw new translatable_error_js_1.TranslatableError('errors.tokenAuthFailed');
+    }
+    if ((0, sso_authenticator_js_1.isSsoAuthenticator)(auth) && !auth.isAuthenticating()) {
+        // try to reauthenticate
+        void auth.authenticate();
+    }
+    return response;
+}
+/**
+ * Checks if the given response error indicates a Network error.
+ *
+ * It is impossible to distinguish between a CORS error and other network errors, such as
+ * 'net::ERR_SSL_PROTOCOL_ERROR' and 'net::ERR_EMPTY_RESPONSE'. This information is hidden by the browser.
+ *
+ * @param responseError - The error object received from the failed response.
+ */
+function isNetworkError(responseError) {
+    return !!(responseError.message === 'Failed to fetch' && responseError.name === 'TypeError');
+}
+/**
+ * Handles a Network error.
+ *
+ * @returns A promise that rejects with an error message.
+ */
+function handleNetworkError() {
+    return Promise.reject(new translatable_error_js_1.TranslatableError('errors.networkError'));
+}
+const getResponseInterceptor = (auth) => (response) => {
+    if (response.status === 401) {
+        return handleUnauthorizedResponse(response, auth);
+    }
+    if (!response.ok) {
+        return handleErrorResponse(response);
+    }
+    return response;
+};
+exports.getResponseInterceptor = getResponseInterceptor;
+const errorInterceptor = (error) => {
+    if (isNetworkError(error)) {
+        return handleNetworkError();
+    }
+    return Promise.reject(error);
+};
+exports.errorInterceptor = errorInterceptor;

package/dist/cjs/interfaces.d.ts

@@ -0,0 +1,9 @@
+export interface Authenticator {
+    readonly type: 'password' | 'bearer' | 'wat' | 'sso' | 'base' | 'fusion';
+    isValid: () => boolean;
+    invalidate: () => void;
+    authenticate: () => Promise<boolean>;
+    isAuthenticating: () => boolean;
+    authenticated: () => Promise<boolean>;
+    applyHeader: (headers: HeadersInit) => void;
+}

package/dist/cjs/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/package.json

@@ -0,0 +1,12 @@
+{
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  }
+}

package/dist/cjs/password-authenticator.d.ts

@@ -0,0 +1,18 @@
+/// <reference lib="dom" />
+import { Authenticator } from './interfaces.js';
+import { BaseAuthenticator } from './base-authenticator.js';
+export declare class PasswordAuthenticator extends BaseAuthenticator {
+    private readonly url;
+    private readonly body;
+    private _authheader;
+    constructor(url: string, user: string, pass: string);
+    authenticate(): Promise<boolean>;
+    applyHeader(headers: HeadersInit): void;
+}
+/**
+ * Checks if an authenticator is a PasswordAuthenticator.
+ *
+ * @param authenticator - the authenticator to check
+ * @internal
+ */
+export declare function isPasswordAuthenticator(authenticator: Authenticator): authenticator is PasswordAuthenticator;