@openremote/core 1.0.3 → 1.2.0-snapshot.20240512154942

package/dist/index.js

@@ -1,996 +0,0 @@
-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());
-    });
-};
-import "url-search-params-polyfill";
-import { Console } from "./console";
-import rest from "@openremote/rest";
-import { EventProviderStatus, WebSocketEventProvider } from "./event";
-import i18next from "i18next";
-import i18nextXhr from "i18next-xhr-backend";
-import sprintf from 'i18next-sprintf-postprocessor';
-import moment from "moment";
-import * as Util from "./util";
-import orIconSet from "./or-icon-set";
-// Re-exports
-export { Util };
-export * from "./asset-mixin";
-export * from "./console";
-export * from "./event";
-export * from "./defaults";
-export const DEFAULT_ICONSET = "mdi";
-export var ORError;
-(function (ORError) {
-    ORError["MANAGER_FAILED_TO_LOAD"] = "MANAGER_FAILED_TO_LOAD";
-    ORError["AUTH_FAILED"] = "AUTH_FAILED";
-    ORError["AUTH_TYPE_UNSUPPORTED"] = "AUTH_TYPE_UNSUPPORTED";
-    ORError["CONSOLE_ERROR"] = "CONSOLE_INIT_ERROR";
-    ORError["EVENTS_CONNECTION_ERROR"] = "EVENTS_CONNECTION_ERROR";
-    ORError["TRANSLATION_ERROR"] = "TRANSLATION_ERROR";
-})(ORError || (ORError = {}));
-export var Auth;
-(function (Auth) {
-    Auth["KEYCLOAK"] = "KEYCLOAK";
-    Auth["BASIC"] = "BASIC";
-    Auth["NONE"] = "NONE";
-})(Auth || (Auth = {}));
-export var OREvent;
-(function (OREvent) {
-    OREvent["ERROR"] = "ERROR";
-    OREvent["READY"] = "READY";
-    OREvent["CONSOLE_INIT"] = "CONSOLE_INIT";
-    OREvent["CONSOLE_READY"] = "CONSOLE_READY";
-    OREvent["EVENTS_CONNECTED"] = "EVENTS_CONNECTED";
-    OREvent["EVENTS_CONNECTING"] = "EVENTS_CONNECTING";
-    OREvent["EVENTS_DISCONNECTED"] = "EVENTS_DISCONNECTED";
-    OREvent["TRANSLATE_INIT"] = "TRANSLATE_INIT";
-    OREvent["TRANSLATE_LANGUAGE_CHANGED"] = "TRANSLATE_LANGUAGE_CHANGED";
-    OREvent["DISPLAY_REALM_CHANGED"] = "DISPLAY_REALM_CHANGED";
-})(OREvent || (OREvent = {}));
-export var EventProviderType;
-(function (EventProviderType) {
-    EventProviderType["WEBSOCKET"] = "WEBSOCKET";
-    EventProviderType["POLLING"] = "POLLING";
-})(EventProviderType || (EventProviderType = {}));
-export var MapType;
-(function (MapType) {
-    MapType["VECTOR"] = "VECTOR";
-    MapType["RASTER"] = "RASTER";
-})(MapType || (MapType = {}));
-export class IconSetAddedEvent extends CustomEvent {
-    constructor() {
-        super(IconSetAddedEvent.NAME, {
-            bubbles: true,
-            composed: true
-        });
-    }
-}
-IconSetAddedEvent.NAME = "or-iconset-added";
-export class ORIconSets {
-    constructor() {
-        this._icons = {};
-    }
-    addIconSet(name, iconset) {
-        this._icons[name] = iconset;
-        window.dispatchEvent(new IconSetAddedEvent());
-    }
-    getIconSet(name) {
-        return this._icons[name];
-    }
-    getIcon(icon) {
-        if (!icon) {
-            return undefined;
-        }
-        let parts = (icon || "").split(":");
-        let iconName = parts.pop();
-        let iconSetName = parts.pop() || DEFAULT_ICONSET;
-        if (!iconSetName || iconSetName === "" || !iconName || iconName === "") {
-            return;
-        }
-        let iconSet = IconSets.getIconSet(iconSetName);
-        //iconName = iconName.replace(/-([a-z])/g, function (g) { return g[1].toUpperCase(); });
-        if (!iconSet || !iconSet.icons.hasOwnProperty(iconName)) {
-            return;
-        }
-        const iconData = iconSet.icons[iconName];
-        const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-        svg.setAttribute("viewBox", "0 0 " + iconSet.size + " " + iconSet.size);
-        svg.style.cssText = "pointer-events: none; display: block; width: 100%; height: 100%;";
-        svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
-        svg.setAttribute("focusable", "false");
-        if (iconData.startsWith("<")) {
-            svg.innerHTML = iconData;
-        }
-        else {
-            const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
-            path.setAttribute("d", iconData);
-            path.style.pointerEvents = "pointer-events: var(--or-icon-pointer-events, none);";
-            svg.appendChild(path);
-        }
-        return svg;
-    }
-}
-export class AssetModelUtil {
-    static getAssetDescriptors() {
-        return [...this._assetDescriptors];
-    }
-    static getAttributeDescriptors() {
-        return [...this._attributeDescriptors];
-    }
-    static getAttributeValueDescriptors() {
-        return [...this._attributeValueDescriptors];
-    }
-    static getMetaItemDescriptors() {
-        return [...this._metaItemDescriptors];
-    }
-    static getAssetDescriptor(type) {
-        if (!type) {
-            return;
-        }
-        return this._assetDescriptors.find((assetDescriptor) => {
-            return assetDescriptor.type === type;
-        });
-    }
-    static getAttributeDescriptor(attributeName, assetTypeOrDescriptor) {
-        if (!attributeName) {
-            return;
-        }
-        let descriptor = this._attributeDescriptors.find((attributeDescriptor) => {
-            return attributeDescriptor.attributeName === attributeName;
-        });
-        if (descriptor || !assetTypeOrDescriptor) {
-            return descriptor;
-        }
-        let assetDescriptor;
-        if (assetTypeOrDescriptor.name) {
-            assetDescriptor = assetTypeOrDescriptor;
-        }
-        else {
-            assetDescriptor = this.getAssetDescriptor(assetTypeOrDescriptor);
-        }
-        if (assetDescriptor && assetDescriptor.attributeDescriptors) {
-            descriptor = assetDescriptor.attributeDescriptors.find((ad) => ad.attributeName === attributeName);
-        }
-        return descriptor;
-    }
-    static getAttributeValueDescriptor(name, attributeNameOrDescriptor, assetTypeOrDescriptor) {
-        if (!name) {
-            return;
-        }
-        const descriptor = this._attributeValueDescriptors.find((attributeValueDescriptor) => {
-            return attributeValueDescriptor.name === name;
-        });
-        if (descriptor || !attributeNameOrDescriptor) {
-            return descriptor;
-        }
-        let attributeDescriptor;
-        if (attributeNameOrDescriptor.attributeName) {
-            attributeDescriptor = attributeNameOrDescriptor;
-        }
-        else {
-            attributeDescriptor = this.getAttributeDescriptor(attributeNameOrDescriptor, assetTypeOrDescriptor);
-        }
-        if (attributeDescriptor) {
-            return attributeDescriptor.valueDescriptor;
-        }
-    }
-    static getAttributeAndValueDescriptors(assetType, attributeOrNameOrDescriptor) {
-        let attributeDescriptor;
-        let attributeValueDescriptor;
-        let attributeName;
-        let attributeTypeOrDescriptor;
-        if (typeof attributeOrNameOrDescriptor === "string") {
-            attributeName = attributeOrNameOrDescriptor;
-            attributeDescriptor = AssetModelUtil.getAttributeDescriptor(attributeOrNameOrDescriptor, assetType);
-            attributeTypeOrDescriptor = attributeDescriptor ? attributeDescriptor.valueDescriptor : undefined;
-        }
-        else if (attributeOrNameOrDescriptor) {
-            if (attributeOrNameOrDescriptor.type) {
-                attributeName = attributeOrNameOrDescriptor.name;
-                attributeDescriptor = AssetModelUtil.getAttributeDescriptor(attributeName, assetType);
-                attributeTypeOrDescriptor = attributeOrNameOrDescriptor.type;
-            }
-            else {
-                attributeName = attributeOrNameOrDescriptor.attributeName;
-                attributeDescriptor = attributeOrNameOrDescriptor;
-                attributeTypeOrDescriptor = attributeOrNameOrDescriptor.valueDescriptor;
-            }
-        }
-        if (attributeTypeOrDescriptor) {
-            if (typeof attributeTypeOrDescriptor === "string") {
-                attributeValueDescriptor = AssetModelUtil.getAttributeValueDescriptor(attributeTypeOrDescriptor, assetType, attributeName);
-            }
-            else {
-                attributeValueDescriptor = attributeTypeOrDescriptor;
-            }
-        }
-        return [attributeDescriptor, attributeValueDescriptor];
-    }
-    static getMetaItemDescriptor(urn, attributeNameOrDescriptor, assetTypeOrDescriptor) {
-        if (!urn) {
-            return;
-        }
-        let descriptor = this._metaItemDescriptors.find((metaItemDescriptor) => {
-            return metaItemDescriptor.urn === urn;
-        });
-        if (descriptor || !attributeNameOrDescriptor) {
-            return descriptor;
-        }
-        let attributeDescriptor;
-        if (attributeNameOrDescriptor.attributeName) {
-            attributeDescriptor = attributeNameOrDescriptor;
-        }
-        else {
-            attributeDescriptor = this.getAttributeDescriptor(attributeNameOrDescriptor, assetTypeOrDescriptor);
-        }
-        if (attributeDescriptor && attributeDescriptor.metaItemDescriptors) {
-            descriptor = attributeDescriptor.metaItemDescriptors.find((mid) => mid.urn === urn);
-        }
-        return descriptor;
-    }
-    static attributeValueDescriptorsMatch(attributeValueDescriptor1, attributeValueDescriptor2) {
-        if (attributeValueDescriptor1 === attributeValueDescriptor2) {
-            return true;
-        }
-        if (!attributeValueDescriptor1 || !attributeValueDescriptor2) {
-            return false;
-        }
-        return attributeValueDescriptor1.name === attributeValueDescriptor2.name && attributeValueDescriptor1.valueType === attributeValueDescriptor2.valueType;
-    }
-    static getMetaInitialValueFromMetaDescriptors(metaItemUrn, metaItemDescriptors) {
-        if (!metaItemDescriptors) {
-            return;
-        }
-        const matchUrn = typeof metaItemUrn === "string" ? metaItemUrn : metaItemUrn.urn;
-        const metaItemDescriptor = metaItemDescriptors && metaItemDescriptors.find((mid) => mid && mid.urn === matchUrn);
-        if (metaItemDescriptor) {
-            return metaItemDescriptor.initialValue;
-        }
-    }
-    static getMetaItemDescriptorInitialValue(metaItemDescriptor, initialValue) {
-        if (metaItemDescriptor.valueFixed) {
-            return metaItemDescriptor;
-        }
-        const newMetaItem = JSON.parse(JSON.stringify(metaItemDescriptor));
-        newMetaItem.initialValue = initialValue;
-        return newMetaItem;
-    }
-    static getAssetDescriptorColor(descriptor, fallbackColor) {
-        return descriptor && descriptor.color ? descriptor.color : fallbackColor;
-    }
-    static getAssetDescriptorIcon(descriptor, fallbackIcon) {
-        return descriptor && descriptor.icon ? descriptor.icon : fallbackIcon;
-    }
-    static hasMetaItem(descriptor, name) {
-        if (!descriptor || !descriptor.metaItemDescriptors) {
-            return false;
-        }
-        return !!descriptor.metaItemDescriptors.find((mid) => mid.urn === name);
-    }
-}
-AssetModelUtil._assetDescriptors = [];
-AssetModelUtil._attributeDescriptors = [];
-AssetModelUtil._attributeValueDescriptors = [];
-AssetModelUtil._metaItemDescriptors = [];
-export class Manager {
-    constructor() {
-        this._authenticated = false;
-        this._ready = false;
-        this._name = "";
-        this._username = "";
-        this._keycloakUpdateTokenInterval = undefined;
-        this._managerVersion = "";
-        this._listeners = [];
-        this._displayRealm = "";
-    }
-    get username() {
-        return this._username;
-    }
-    get error() {
-        return this._error;
-    }
-    get authenticated() {
-        return this._authenticated;
-    }
-    get ready() {
-        return this._ready;
-    }
-    get config() {
-        return this._config;
-    }
-    get roles() {
-        const roleMap = new Map();
-        if (this._keycloak) {
-            if (this._keycloak.resourceAccess) {
-                if (this._config.clientId && this._keycloak.resourceAccess) {
-                    Object.entries(this._keycloak.resourceAccess).forEach(([client, resourceObj]) => {
-                        const roles = resourceObj.roles;
-                        roleMap.set(client, roles);
-                    });
-                }
-            }
-        }
-        else if (this._basicIdentity && this._basicIdentity.roles) {
-            roleMap.set(this._config.clientId, this._basicIdentity.roles.map((r) => r.name));
-        }
-        return roleMap;
-    }
-    get managerVersion() {
-        return this._managerVersion;
-    }
-    get isManagerAvailable() {
-        return this._managerVersion && this._managerVersion !== "";
-    }
-    get managerUrl() {
-        return this._config.managerUrl;
-    }
-    get keycloakUrl() {
-        return this._config.keycloakUrl;
-    }
-    get isError() {
-        return !!this._error;
-    }
-    get connectionStatus() {
-        return this._events && this._events.status;
-    }
-    get console() {
-        return this._console;
-    }
-    get consoleAppConfig() {
-        return this._consoleAppConfig;
-    }
-    get events() {
-        return this._events;
-    }
-    get rest() {
-        return rest;
-    }
-    get language() {
-        return i18next.language;
-    }
-    set language(lang) {
-        i18next.changeLanguage(lang);
-        this.console.storeData("LANGUAGE", lang);
-    }
-    get displayRealm() {
-        return this._displayRealm || this._config.realm;
-    }
-    set displayRealm(realm) {
-        if (!this.isSuperUser()) {
-            return;
-        }
-        this._displayRealm = realm;
-        this._emitEvent(OREvent.DISPLAY_REALM_CHANGED);
-    }
-    getEventProvider() {
-        return this.events;
-    }
-    get mapType() {
-        return this._config.mapType || MapType.VECTOR;
-    }
-    static normaliseConfig(config) {
-        const normalisedConfig = Object.assign({}, config);
-        if (!normalisedConfig.managerUrl || normalisedConfig.managerUrl === "") {
-            // Assume manager is running on same host as this code
-            normalisedConfig.managerUrl = window.location.protocol + "//" + window.location.hostname + (window.location.port ? ":" + window.location.port : "");
-        }
-        else {
-            // Normalise by stripping any trailing slashes
-            normalisedConfig.managerUrl = normalisedConfig.managerUrl.replace(/\/+$/, "");
-        }
-        if (!normalisedConfig.realm || normalisedConfig.realm === "") {
-            // Assume master realm
-            normalisedConfig.realm = "master";
-        }
-        if (normalisedConfig.auth === Auth.KEYCLOAK) {
-            // Determine URL of keycloak server
-            if (!normalisedConfig.keycloakUrl || normalisedConfig.keycloakUrl === "") {
-                // Assume keycloak is running on same host as the manager
-                normalisedConfig.keycloakUrl = normalisedConfig.managerUrl + "/auth";
-            }
-            else {
-                // Normalise by stripping any trailing slashes
-                normalisedConfig.keycloakUrl = normalisedConfig.keycloakUrl.replace(/\/+$/, "");
-            }
-        }
-        if (normalisedConfig.consoleAutoEnable === undefined) {
-            normalisedConfig.consoleAutoEnable = true;
-        }
-        if (!normalisedConfig.eventProviderType) {
-            normalisedConfig.eventProviderType = EventProviderType.WEBSOCKET;
-        }
-        if (!normalisedConfig.pollingIntervalMillis || normalisedConfig.pollingIntervalMillis < 5000) {
-            normalisedConfig.pollingIntervalMillis = 10000;
-        }
-        if (normalisedConfig.loadIcons === undefined) {
-            normalisedConfig.loadIcons = true;
-        }
-        if (normalisedConfig.loadTranslations === undefined) {
-            normalisedConfig.loadTranslations = ["or"];
-        }
-        if (normalisedConfig.translationsLoadPath === undefined) {
-            normalisedConfig.translationsLoadPath = "locales/{{lng}}/{{ns}}.json";
-        }
-        if (normalisedConfig.loadDescriptors === undefined) {
-            normalisedConfig.loadDescriptors = true;
-        }
-        if (normalisedConfig.clientId === undefined) {
-            normalisedConfig.clientId = "openremote";
-        }
-        return normalisedConfig;
-    }
-    isManagerSameOrigin() {
-        if (!this.ready) {
-            return false;
-        }
-        const managerUrl = new URL(this._config.managerUrl);
-        const windowUrl = window.location;
-        return managerUrl.protocol === windowUrl.protocol
-            && managerUrl.hostname === windowUrl.hostname
-            && managerUrl.port === windowUrl.port;
-    }
-    addListener(callback) {
-        const index = this._listeners.indexOf(callback);
-        if (index < 0) {
-            this._listeners.push(callback);
-        }
-    }
-    removeListener(callback) {
-        const index = this._listeners.indexOf(callback);
-        if (index >= 0) {
-            this._listeners.splice(index, 1);
-        }
-    }
-    init(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._config) {
-                console.log("Already initialised");
-            }
-            this._config = Manager.normaliseConfig(config);
-            let success = yield this.doAuthInit();
-            if (success) {
-                success = yield this.doInit();
-            }
-            if (success) {
-                success = this.doRestApiInit();
-            }
-            success = (yield this.doConsoleInit()) && success;
-            success = (yield this.doTranslateInit()) && success;
-            if (success) {
-                success = yield this.doDescriptorsInit();
-                yield this.getConsoleAppConfig();
-            }
-            // TODO: Reinstate this once websocket supports anonymous connections
-            // if (success) {
-            //     success = await this.doEventsSubscriptionInit();
-            // }
-            if (success) {
-                if (this._readyCallback) {
-                    yield this._readyCallback();
-                }
-                this._ready = true;
-                this._emitEvent(OREvent.READY);
-            }
-            this._displayRealm = config.realm;
-            return success;
-        });
-    }
-    doInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check manager exists by calling the info endpoint
-            try {
-                const json = yield new Promise((resolve, reject) => {
-                    const oReq = new XMLHttpRequest();
-                    oReq.addEventListener("load", () => {
-                        resolve(JSON.parse(oReq.responseText));
-                    });
-                    oReq.addEventListener("error", () => {
-                        reject(new Error("Failed to contact the manager"));
-                    });
-                    oReq.open("GET", this._config.managerUrl + "/api/master/info");
-                    oReq.send();
-                });
-                this._managerVersion = json && json.version ? json.version : "";
-                // Load material design and OR icon sets if requested
-                if (this._config.loadIcons) {
-                    const response = yield fetch(manager.config.managerUrl + "/shared/mdi-icons.json");
-                    const mdiIconSet = yield response.json();
-                    IconSets.addIconSet("mdi", mdiIconSet);
-                    IconSets.addIconSet("or", orIconSet);
-                }
-                return true;
-            }
-            catch (e) {
-                // TODO: Implement auto retry?
-                console.error("Failed to contact the manager", e);
-                this._setError(ORError.MANAGER_FAILED_TO_LOAD);
-                return false;
-            }
-        });
-    }
-    doTranslateInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            i18next.on("initialized", (options) => {
-                this._emitEvent(OREvent.TRANSLATE_INIT);
-            });
-            i18next.on("languageChanged", (lng) => {
-                moment.locale(lng);
-                this._emitEvent(OREvent.TRANSLATE_LANGUAGE_CHANGED);
-            });
-            // Look for language preference in local storage
-            const language = !this.console ? undefined : yield this.console.retrieveData("LANGUAGE");
-            const initOptions = {
-                lng: language,
-                fallbackLng: "en",
-                defaultNS: "app",
-                fallbackNS: "or",
-                ns: this.config.loadTranslations,
-                interpolation: {
-                    format: function (value, format, lng) {
-                        if (format === "uppercase")
-                            return value.toUpperCase();
-                        if (value instanceof Date) {
-                            return moment(value).format(format);
-                        }
-                        return value;
-                    }
-                },
-                backend: {
-                    loadPath: (langs, namespaces) => {
-                        if (namespaces.length === 1 && namespaces[0] === "or") {
-                            return this.config.managerUrl + "/shared/locales/{{lng}}/{{ns}}.json";
-                        }
-                        if (this.config.translationsLoadPath) {
-                            return this.config.translationsLoadPath;
-                        }
-                        return "locales/{{lng}}/{{ns}}.json";
-                    }
-                }
-            };
-            if (this.config.configureTranslationsOptions) {
-                this.config.configureTranslationsOptions(initOptions);
-            }
-            try {
-                yield i18next.use(sprintf).use(i18nextXhr).init(initOptions);
-            }
-            catch (e) {
-                console.error(e);
-                this._setError(ORError.TRANSLATION_ERROR);
-                return false;
-            }
-            return true;
-        });
-    }
-    doDescriptorsInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config.loadDescriptors) {
-                return true;
-            }
-            try {
-                const assetDescriptorResponse = yield rest.api.AssetModelResource.getAssetDescriptors();
-                const attributeDescriptorResponse = yield rest.api.AssetModelResource.getAttributeDescriptors();
-                const attributeValueDescriptorResponse = yield rest.api.AssetModelResource.getAttributeValueDescriptors();
-                const metaItemDescriptorResponse = yield rest.api.AssetModelResource.getMetaItemDescriptors();
-                AssetModelUtil._assetDescriptors = assetDescriptorResponse.data;
-                AssetModelUtil._attributeDescriptors = attributeDescriptorResponse.data;
-                AssetModelUtil._attributeValueDescriptors = attributeValueDescriptorResponse.data;
-                AssetModelUtil._metaItemDescriptors = metaItemDescriptorResponse.data;
-            }
-            catch (e) {
-                console.error(e);
-                return false;
-            }
-            return true;
-        });
-    }
-    doAuthInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let success = true;
-            switch (this._config.auth) {
-                case Auth.BASIC:
-                    success = yield this.initialiseBasicAuth();
-                    break;
-                case Auth.KEYCLOAK:
-                    success = yield this.loadAndInitialiseKeycloak();
-                    if (!success) {
-                        // Try fallback to BASIC
-                        console.log("Falling back to basic auth");
-                        this._config.auth = Auth.BASIC;
-                        return this.doAuthInit();
-                    }
-                    break;
-                case Auth.NONE:
-                    // Nothing for us to do here
-                    return true;
-                default:
-                    this._setError(ORError.AUTH_TYPE_UNSUPPORTED);
-                    return false;
-            }
-            // Add interceptor to inject authorization header on each request
-            rest.addRequestInterceptor((config) => {
-                if (!config.headers.Authorization) {
-                    const authHeader = this.getAuthorizationHeader();
-                    if (authHeader) {
-                        config.headers.Authorization = authHeader;
-                    }
-                }
-                return config;
-            });
-            return success;
-        });
-    }
-    doRestApiInit() {
-        rest.setTimeout(10000);
-        rest.initialise(this.getApiBaseUrl());
-        return true;
-    }
-    doEventsSubscriptionInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let connected = false;
-            switch (this._config.eventProviderType) {
-                case EventProviderType.WEBSOCKET:
-                    this._events = new WebSocketEventProvider(this._config.managerUrl);
-                    this._events.subscribeStatusChange((status) => this._onEventProviderStatusChanged(status));
-                    connected = yield this._events.connect();
-                    break;
-                case EventProviderType.POLLING:
-                    break;
-            }
-            if (!connected) {
-                this._setError(ORError.EVENTS_CONNECTION_ERROR);
-            }
-            return connected;
-        });
-    }
-    _onEventProviderStatusChanged(status) {
-        switch (status) {
-            case EventProviderStatus.DISCONNECTED:
-                this._emitEvent(OREvent.EVENTS_DISCONNECTED);
-                break;
-            case EventProviderStatus.CONNECTED:
-                this._emitEvent(OREvent.EVENTS_CONNECTED);
-                break;
-            case EventProviderStatus.CONNECTING:
-                this._emitEvent(OREvent.EVENTS_CONNECTING);
-                break;
-        }
-    }
-    doConsoleInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let orConsole = new Console(this._config.realm, this._config.consoleAutoEnable, () => {
-                    this._emitEvent(OREvent.CONSOLE_READY);
-                });
-                this._console = orConsole;
-                yield orConsole.initialise();
-                this._emitEvent(OREvent.CONSOLE_INIT);
-                return true;
-            }
-            catch (e) {
-                this._setError(ORError.CONSOLE_ERROR);
-                return false;
-            }
-        });
-    }
-    getConsoleAppConfig() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const consoleAppConfigResponse = yield this.rest.api.ConsoleAppResource.getAppConfig();
-            if (consoleAppConfigResponse.status === 200) {
-                this._consoleAppConfig = consoleAppConfigResponse.data;
-            }
-        });
-    }
-    logout(redirectUrl) {
-        if (this._keycloak) {
-            if (this.console.isMobile) {
-                this.console.storeData("REFRESH_TOKEN", null);
-            }
-            const options = redirectUrl && redirectUrl !== "" ? { redirectUri: redirectUrl } : null;
-            this._keycloak.logout(options);
-        }
-        else if (this._basicIdentity) {
-            this._basicIdentity = undefined;
-            if (redirectUrl) {
-                window.location.href = redirectUrl;
-            }
-            else {
-                window.location.reload();
-            }
-        }
-    }
-    login(options) {
-        switch (this._config.auth) {
-            case Auth.BASIC:
-                if (options && options.credentials) {
-                    this._config.credentials = Object.assign({}, options.credentials);
-                }
-                this.doBasicLogin();
-                break;
-            case Auth.KEYCLOAK:
-                if (this._keycloak) {
-                    const keycloakOptions = {};
-                    if (options && options.redirectUrl && options.redirectUrl !== "") {
-                        keycloakOptions.redirectUri = options.redirectUrl;
-                    }
-                    if (this.isMobile()) {
-                        keycloakOptions.scope = "offline_access";
-                    }
-                    this._keycloak.login(keycloakOptions);
-                }
-                break;
-            case Auth.NONE:
-                break;
-        }
-    }
-    initialiseBasicAuth() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config.basicLoginProvider) {
-                console.log("No basicLoginProvider defined on config so cannot display login UI");
-                return false;
-            }
-            if (this.config.autoLogin) {
-                // Delay basic login until other inits are done
-                this._readyCallback = () => {
-                    return this.doBasicLogin();
-                };
-            }
-            return true;
-        });
-    }
-    doBasicLogin() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config.basicLoginProvider) {
-                return;
-            }
-            let result = {
-                username: this._config.credentials ? this._config.credentials.username : "",
-                password: this._config.credentials ? this._config.credentials.password : "",
-                cancel: false,
-                closeCallback: undefined
-            };
-            let authenticated = false;
-            this._basicIdentity = {
-                roles: undefined,
-                token: undefined,
-                user: undefined
-            };
-            while (!authenticated) {
-                result = yield this.config.basicLoginProvider(result.username, result.password);
-                if (result.cancel) {
-                    console.log("Basic authentication cancelled by user");
-                    if (result.closeCallback) {
-                        result.closeCallback(false);
-                    }
-                    break;
-                }
-                if (!result.username || !result.password) {
-                    continue;
-                }
-                // Update basic token so we can use rest api to make calls
-                this._basicIdentity.token = btoa(result.username + ":" + result.password);
-                const userResponse = yield rest.api.UserResource.getCurrent();
-                const status = userResponse.status;
-                if (status === 200) {
-                    console.log("Basic authentication successful");
-                    authenticated = true;
-                    this._basicIdentity.user = userResponse.data;
-                    // Get user roles
-                    const rolesResponse = yield rest.api.UserResource.getCurrentUserRoles();
-                    this._basicIdentity.roles = rolesResponse.data;
-                    // Undertow incorrectly returns 403 when no authorization header and a 401 when it is set and not valid
-                }
-                else if (status === 401 || status === 403) {
-                    console.log("Basic authentication invalid credentials, trying again");
-                    this._basicIdentity = undefined;
-                }
-                else {
-                    console.log("Unkown response so aborting");
-                    this._basicIdentity = undefined;
-                    break;
-                }
-            }
-            this._setAuthenticated(authenticated);
-            if (result.closeCallback) {
-                result.closeCallback(authenticated);
-            }
-        });
-    }
-    isSuperUser() {
-        return this.getRealm() && this.getRealm() === "master" && this.hasRealmRole("admin");
-    }
-    getApiBaseUrl() {
-        let baseUrl = this._config.managerUrl;
-        baseUrl += "/api/" + this._config.realm + "/";
-        return baseUrl;
-    }
-    getAppName() {
-        let pathArr = location.pathname.split('/');
-        return pathArr.length >= 1 ? pathArr[1] : "";
-    }
-    hasRealmRole(role) {
-        return this._keycloak && this._keycloak.hasRealmRole(role);
-    }
-    hasRole(role, client = this._config.clientId) {
-        const roles = this.roles;
-        return roles && roles.has(client) && roles.get(client).indexOf(role) >= 0;
-    }
-    getAuthorizationHeader() {
-        if (this._keycloak) {
-            return "Bearer " + this._keycloak.token;
-        }
-        if (this.getBasicToken()) {
-            return "Basic " + this.getBasicToken();
-        }
-        return undefined;
-    }
-    getKeycloakToken() {
-        if (this._keycloak) {
-            return this._keycloak.token;
-        }
-        return undefined;
-    }
-    getBasicToken() {
-        return this._basicIdentity ? this._basicIdentity.token : undefined;
-    }
-    getRealm() {
-        if (this._config) {
-            return this._config.realm;
-        }
-        return undefined;
-    }
-    isMobile() {
-        return this.console && this.console.isMobile;
-    }
-    isKeycloak() {
-        return !!this._keycloak;
-    }
-    _onAuthenticated() {
-        // If native shell is enabled, we need an offline refresh token
-        if (this.console && this.console.isMobile && this.config.auth === Auth.KEYCLOAK) {
-            if (this._keycloak && this._keycloak.refreshTokenParsed.typ === "Offline") {
-                console.debug("Storing offline refresh token");
-                this.console.storeData("REFRESH_TOKEN", this._keycloak.refreshToken);
-            }
-            else {
-                this.login();
-            }
-        }
-    }
-    // NOTE: The below works with Keycloak 2.x JS API - They made breaking changes in newer versions
-    // so this will need updating.
-    loadAndInitialiseKeycloak() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // There's a bug in some Keycloak versions which means the init promise doesn't resolve
-                // so putting a check in place; wrap keycloak promise in proper ES6 promise
-                let keycloakPromise = null;
-                // Load the keycloak JS API
-                yield Util.loadJs(this._config.keycloakUrl + "/js/keycloak.js");
-                // Should have Keycloak global var now
-                if (!window.Keycloak) {
-                    console.log("Keycloak global variable not found probably failed to load keycloak or manager doesn't support it");
-                    return false;
-                }
-                // Initialise keycloak
-                this._keycloak = window.Keycloak({
-                    clientId: this._config.clientId,
-                    realm: this._config.realm,
-                    url: this._config.keycloakUrl
-                });
-                this._keycloak.onAuthSuccess = () => {
-                    if (keycloakPromise) {
-                        keycloakPromise(true);
-                    }
-                };
-                this._keycloak.onAuthError = () => {
-                    this._setAuthenticated(false);
-                };
-                try {
-                    // Try to use a stored offline refresh token if defined
-                    const offlineToken = yield this._getNativeOfflineRefreshToken();
-                    const authenticated = yield new Promise(((resolve, reject) => {
-                        keycloakPromise = resolve;
-                        this._keycloak.init({
-                            checkLoginIframe: false,
-                            onLoad: this._config.autoLogin ? "login-required" : "check-sso",
-                            refreshToken: offlineToken
-                        }).success((auth) => {
-                            resolve(auth);
-                        }).error(() => {
-                            reject();
-                        });
-                    }));
-                    keycloakPromise = null;
-                    if (authenticated) {
-                        this._name = this._keycloak.tokenParsed.name;
-                        this._username = this._keycloak.tokenParsed.preferred_username;
-                        // Update the access token every 10s (note keycloak will only update if expiring within configured
-                        // time period.
-                        if (this._keycloakUpdateTokenInterval) {
-                            clearInterval(this._keycloakUpdateTokenInterval);
-                            delete this._keycloakUpdateTokenInterval;
-                        }
-                        this._keycloakUpdateTokenInterval = window.setInterval(() => {
-                            this.updateKeycloakAccessToken();
-                        }, 10000);
-                        this._onAuthenticated();
-                    }
-                    this._setAuthenticated(authenticated);
-                    return true;
-                }
-                catch (e) {
-                    console.error(e);
-                    keycloakPromise = null;
-                    this._setAuthenticated(false);
-                    return false;
-                }
-            }
-            catch (error) {
-                this._setError(ORError.AUTH_FAILED);
-                console.error("Failed to load Keycloak");
-                return false;
-            }
-        });
-    }
-    updateKeycloakAccessToken() {
-        // Access token must be good for X more seconds, should be half of Constants.ACCESS_TOKEN_LIFESPAN_SECONDS
-        return new Promise(() => {
-            this._keycloak.updateToken(30)
-                .success((tokenRefreshed) => {
-                // If refreshed from server, it means the refresh token was still good for another access token
-                console.debug("Access token update success, refreshed from server: " + tokenRefreshed);
-                return tokenRefreshed;
-            })
-                .error(() => {
-                // Refresh token expired (either SSO max session duration or offline idle timeout), see
-                // IDENTITY_SESSION_MAX_MINUTES and IDENTITY_SESSION_OFFLINE_TIMEOUT_MINUTES server config
-                console.info("Access token update failed, refresh token expired, login required");
-                this._keycloak.clearToken();
-                this._keycloak.login();
-            });
-        });
-    }
-    _getNativeOfflineRefreshToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.console && this.console.isMobile) {
-                return yield this.console.retrieveData("REFRESH_TOKEN");
-            }
-        });
-    }
-    _emitEvent(event) {
-        window.setTimeout(() => {
-            let listeners = this._listeners.slice();
-            for (const listener of listeners) {
-                listener(event);
-            }
-        }, 0);
-    }
-    _setError(error) {
-        this._error = error;
-        this._emitEvent(OREvent.ERROR);
-    }
-    // TODO: Remove events logic once websocket supports anonymous connections
-    _setAuthenticated(authenticated) {
-        this._authenticated = authenticated;
-        if (authenticated) {
-            if (!this._events) {
-                this.doEventsSubscriptionInit();
-            }
-        }
-        else {
-            if (this._events) {
-                this._events.disconnect();
-            }
-            this._events = undefined;
-        }
-    }
-}
-export const manager = new Manager(); // Needed for webpack bundling
-export const IconSets = new ORIconSets();
-export default manager;
-//# sourceMappingURL=index.js.map