@openremote/core 1.0.2 → 1.2.0-snapshot.20240512155932

package/dist/index.js

@@ -1,683 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    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) : new P(function (resolve) { resolve(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 { IconSets } from "@openremote/or-icon";
-import { EventProviderStatus, WebSocketEventProvider } from "./event";
-import i18next from "i18next";
-import i18nextXhr from "i18next-xhr-backend";
-export var ORError;
-(function (ORError) {
-    ORError["NONE"] = "NONE";
-    ORError["MANAGER_FAILED_TO_LOAD"] = "MANAGER_FAILED_TO_LOAD";
-    ORError["KEYCLOAK_FAILED_TO_LOAD"] = "KEYCLOAK_FAILED_TO_LOAD";
-    ORError["AUTH_TYPE_UNSUPPORTED"] = "AUTH_TYPE_UNSUPPORTED";
-    ORError["CONSOLE_ERROR"] = "CONSOLE_INIT_ERROR";
-    ORError["EVENTS_CONNECTION_ERROR"] = "EVENTS_CONNECTION_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 || (OREvent = {}));
-export var EventProviderType;
-(function (EventProviderType) {
-    EventProviderType["WEBSOCKET"] = "WEBSOCKET";
-    EventProviderType["POLLING"] = "POLLING";
-})(EventProviderType || (EventProviderType = {}));
-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 getAssetAttributeDescriptor(assetDescriptor, attributeName) {
-        if (!attributeName || !assetDescriptor || !assetDescriptor.attributeDescriptors) {
-            return;
-        }
-        return assetDescriptor.attributeDescriptors.find((attributeDescriptor) => attributeDescriptor.attributeName === attributeName);
-    }
-    static getAttributeDescriptor(attributeName) {
-        if (!attributeName) {
-            return;
-        }
-        return this._attributeDescriptors.find((attributeDescriptor) => {
-            return attributeDescriptor.attributeName === attributeName;
-        });
-    }
-    static getAttributeValueDescriptor(name) {
-        if (!name) {
-            return;
-        }
-        return this._attributeValueDescriptors.find((attributeValueDescriptor) => {
-            return attributeValueDescriptor.name === name;
-        });
-    }
-    static getMetaItemDescriptor(urn) {
-        if (!urn) {
-            return;
-        }
-        return this._metaItemDescriptors.find((metaItemDescriptor) => {
-            return metaItemDescriptor.urn === urn;
-        });
-    }
-    static attributeValueDescriptorsMatch(attributeValueDescriptor1, attributeValueDescriptor2) {
-        if (attributeValueDescriptor1 === attributeValueDescriptor2) {
-            return true;
-        }
-        if (!attributeValueDescriptor1 || !attributeValueDescriptor2) {
-            return false;
-        }
-        return attributeValueDescriptor1.name === attributeValueDescriptor2.name && attributeValueDescriptor1.valueType === attributeValueDescriptor2.valueType;
-    }
-}
-AssetModelUtil._assetDescriptors = [];
-AssetModelUtil._attributeDescriptors = [];
-AssetModelUtil._attributeValueDescriptors = [];
-AssetModelUtil._metaItemDescriptors = [];
-export class Manager {
-    constructor() {
-        this._error = ORError.NONE;
-        this._authenticated = false;
-        this._ready = false;
-        this._name = "";
-        this._username = "";
-        this._keycloak = null;
-        this._roles = [];
-        this._keycloakUpdateTokenInterval = undefined;
-        this._managerVersion = "";
-        this._listeners = [];
-    }
-    get username() {
-        return this._username;
-    }
-    get error() {
-        return this._error;
-    }
-    get authenticated() {
-        return this._authenticated;
-    }
-    get initialised() {
-        return this._config != null;
-    }
-    get ready() {
-        return this._ready;
-    }
-    get config() {
-        return this._config;
-    }
-    get roles() {
-        return this._roles;
-    }
-    get managerVersion() {
-        return this._managerVersion;
-    }
-    get isManagerAvailable() {
-        return this._managerVersion && this._managerVersion !== "";
-    }
-    get isError() {
-        return this._error != null && this._error !== ORError.NONE;
-    }
-    get connectionStatus() {
-        return this._events && this._events.status;
-    }
-    get console() {
-        return this._console;
-    }
-    get events() {
-        return this._events;
-    }
-    get language() {
-        return i18next.language;
-    }
-    getEventProvider() {
-        return this.events;
-    }
-    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;
-        }
-        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;
-        }
-        return normalisedConfig;
-    }
-    isManagerSameOrigin() {
-        if (!this.initialised) {
-            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();
-            }
-            if (success) {
-                success = yield this.doConsoleInit();
-            }
-            if (success) {
-                success = yield this.doTranslateInit();
-            }
-            if (success) {
-                success = yield this.doDescriptorsInit();
-            }
-            // TODO: Reinstate this once websocket supports anonymous connections
-            // if (success) {
-            //     success = await this.doEventsSubscriptionInit();
-            // }
-            if (success) {
-                this._ready = true;
-                this._emitEvent(OREvent.READY);
-            }
-            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 : "";
-                // Async load material design icons if requested
-                if (this._config.loadIcons) {
-                    const mdiIconSet = yield import(/* webpackChunkName: "mdi-icons" */ "@openremote/or-icon/dist/mdi-icons");
-                    IconSets.addIconSet("mdi", mdiIconSet.default);
-                }
-                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", () => {
-                this._emitEvent(OREvent.TRANSLATE_LANGUAGE_CHANGED);
-            });
-            const initOptions = {
-                lng: "en",
-                fallbackLng: "en",
-                defaultNS: "app",
-                fallbackNS: "or",
-                ns: this.config.loadTranslations,
-                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(i18nextXhr).init(initOptions);
-            }
-            catch (e) {
-                console.error(e);
-                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:
-                    // TODO: Implement Basic auth support
-                    if (this._config.credentials) {
-                        rest.setBasicAuth(this._config.credentials.username, this._config.credentials.password);
-                    }
-                    this._setError(ORError.AUTH_TYPE_UNSUPPORTED);
-                    success = false;
-                    break;
-                case Auth.KEYCLOAK:
-                    success = yield this.loadAndInitialiseKeycloak();
-                    // Add interceptor to inject authorization header on each request
-                    rest.addRequestInterceptor((config) => {
-                        if (!config.headers.Authorization) {
-                            const token = this.getKeycloakToken();
-                            if (token) {
-                                config.headers.Authorization = "Bearer " + token;
-                            }
-                        }
-                        return config;
-                    });
-                    break;
-                case Auth.NONE:
-                    // Nothing for us to do here
-                    break;
-                default:
-                    this._setError(ORError.AUTH_TYPE_UNSUPPORTED);
-                    success = false;
-                    break;
-            }
-            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;
-            }
-        });
-    }
-    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);
-        }
-    }
-    login(options) {
-        if (!this.initialised) {
-            return;
-        }
-        switch (this._config.auth) {
-            case Auth.BASIC:
-                if (options && options.credentials) {
-                    this._config.credentials = Object.assign({}, options.credentials);
-                }
-                const username = this._config.credentials ? this._config.credentials.username : null;
-                const password = this._config.credentials ? this._config.credentials.password : null;
-                if (username && password && username !== "" && password !== "") {
-                    // TODO: Perform some request to check basic auth credentials
-                    this._setAuthenticated(true);
-                }
-                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;
-        }
-    }
-    isSuperUser() {
-        return this.hasRole("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] : "";
-    }
-    hasRole(role) {
-        return this._roles && this._roles.indexOf(role) >= 0;
-    }
-    getAuthorizationHeader() {
-        if (this._keycloak && this.authenticated) {
-            return "Bearer " + this._keycloak.token;
-        }
-        return undefined;
-    }
-    getKeycloakToken() {
-        if (this._keycloak && this.authenticated) {
-            return this._keycloak.token;
-        }
-        return undefined;
-    }
-    getRealm() {
-        if (this._config) {
-            return this._config.realm;
-        }
-        return undefined;
-    }
-    isMobile() {
-        return this.console && this.console.isMobile;
-    }
-    _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.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* () {
-            // Load the keycloak JS API
-            const promise = new Promise((resolve, reject) => {
-                // Load keycloak script from keycloak server
-                const scriptElement = document.createElement("script");
-                scriptElement.src = this._config.keycloakUrl + "/js/keycloak.js";
-                scriptElement.onload = (e) => resolve(e);
-                scriptElement.onerror = (e) => reject(e);
-                document.querySelector("head").appendChild(scriptElement);
-            });
-            try {
-                yield promise;
-                // Should have Keycloak global var now
-                if (!window.Keycloak) {
-                    this._setError(ORError.KEYCLOAK_FAILED_TO_LOAD);
-                    return false;
-                }
-                // Initialise keycloak
-                this._keycloak = window.Keycloak({
-                    clientId: "openremote",
-                    realm: this._config.realm,
-                    url: this._config.keycloakUrl
-                });
-                this._keycloak.onAuthSuccess = () => {
-                    if (keycloakPromise) {
-                        keycloakPromise(true);
-                    }
-                };
-                this._keycloak.onAuthError = () => {
-                    this._setAuthenticated(false);
-                };
-                // 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;
-                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;
-                        this._roles = this._keycloak.resourceAccess.openremote.roles;
-                        // 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.KEYCLOAK_FAILED_TO_LOAD);
-                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");
-            }
-            return null;
-        });
-    }
-    _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 default new Manager();
-//# sourceMappingURL=index.js.map