@openremote/core 1.0.3 → 1.2.0-snapshot.20240512160221

package/dist/event.js

@@ -1,567 +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 manager from "./index";
-import { arrayRemove, Deferred } from "./util";
-export var EventProviderStatus;
-(function (EventProviderStatus) {
-    EventProviderStatus["DISCONNECTED"] = "DISCONNECTED";
-    EventProviderStatus["CONNECTED"] = "CONNECTED";
-    EventProviderStatus["CONNECTING"] = "CONNECTING";
-})(EventProviderStatus || (EventProviderStatus = {}));
-const SUBSCRIBE_MESSAGE_PREFIX = "SUBSCRIBE:";
-const SUBSCRIBED_MESSAGE_PREFIX = "SUBSCRIBED:";
-const UNSUBSCRIBE_MESSAGE_PREFIX = "UNSUBSCRIBE:";
-const UNAUTHORIZED_MESSAGE_PREFIX = "UNAUTHORIZED:";
-const TRIGGERED_MESSAGE_PREFIX = "TRIGGERED:";
-const EVENT_MESSAGE_PREFIX = "EVENT:";
-const EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX = "REQUESTRESPONSE:";
-class EventProviderImpl {
-    constructor() {
-        this._disconnectRequested = false;
-        this._reconnectDelayMillis = WebSocketEventProvider.MIN_RECONNECT_DELAY;
-        this._reconnectTimer = null;
-        this._status = EventProviderStatus.DISCONNECTED;
-        this._connectingDeferred = null;
-        this._statusCallbacks = [];
-        this._pendingSubscription = null;
-        this._queuedSubscriptions = [];
-        this._subscriptionMap = {};
-        this._assetSubscriptionMap = new Map();
-    }
-    get status() {
-        return this._status;
-    }
-    subscribeStatusChange(callback) {
-        this._statusCallbacks.push(callback);
-    }
-    unsubscribeStatusChange(callback) {
-        arrayRemove(this._statusCallbacks, callback);
-    }
-    connect() {
-        if (this._status === EventProviderStatus.CONNECTED) {
-            return Promise.resolve(true);
-        }
-        this._disconnectRequested = false;
-        if (this._connectingDeferred) {
-            return this._connectingDeferred.promise;
-        }
-        this._onStatusChanged(EventProviderStatus.CONNECTING);
-        this._connectingDeferred = new Deferred();
-        this._doConnect().then((connected) => {
-            if (this._connectingDeferred) {
-                const deferred = this._connectingDeferred;
-                this._connectingDeferred = null;
-                if (this._reconnectTimer) {
-                    window.clearTimeout(this._reconnectTimer);
-                    this._reconnectTimer = null;
-                }
-                if (connected) {
-                    console.debug("Connected to event service: " + this.endpointUrl);
-                    this._reconnectDelayMillis = WebSocketEventProvider.MIN_RECONNECT_DELAY;
-                    this._onStatusChanged(EventProviderStatus.CONNECTED);
-                    window.setTimeout(() => {
-                        this._onConnect();
-                    }, 0);
-                }
-                else {
-                    console.debug("Failed to connect to event service: " + this.endpointUrl);
-                    this._onStatusChanged(EventProviderStatus.DISCONNECTED);
-                }
-                deferred.resolve(connected);
-            }
-        });
-        return this._connectingDeferred.promise;
-    }
-    disconnect() {
-        if (this._disconnectRequested) {
-            return;
-        }
-        this._disconnectRequested = true;
-        if (this._reconnectTimer) {
-            window.clearTimeout(this._reconnectTimer);
-            this._reconnectTimer = null;
-        }
-        if (this.status === EventProviderStatus.DISCONNECTED) {
-            return;
-        }
-        this._doDisconnect();
-    }
-    subscribe(eventSubscription, callback) {
-        const subscriptionInfo = {
-            eventSubscription: eventSubscription,
-            callback: callback,
-            deferred: new Deferred()
-        };
-        if (this._pendingSubscription != null || this._status !== EventProviderStatus.CONNECTED) {
-            this._queuedSubscriptions.push(subscriptionInfo);
-            return subscriptionInfo.deferred.promise;
-        }
-        this._pendingSubscription = subscriptionInfo;
-        this._doSubscribe(eventSubscription).then(subscriptionId => {
-            if (this._pendingSubscription) {
-                const subscription = this._pendingSubscription;
-                this._pendingSubscription = null;
-                // Store subscriptionId and callback
-                this._subscriptionMap[subscriptionId] = subscription;
-                this._processNextSubscription();
-                const deferred = subscription.deferred;
-                subscription.deferred = null;
-                if (deferred) {
-                    deferred.resolve(subscriptionId);
-                }
-            }
-        }, (reason) => {
-            if (this._pendingSubscription) {
-                const subscription = this._pendingSubscription;
-                this._pendingSubscription = null;
-                this._processNextSubscription();
-                const deferred = subscription.deferred;
-                subscription.deferred = null;
-                if (deferred) {
-                    deferred.reject(reason);
-                }
-            }
-        });
-        return this._pendingSubscription.deferred.promise;
-    }
-    unsubscribe(subscriptionId) {
-        const callback = this._subscriptionMap[subscriptionId];
-        if (callback) {
-            delete this._subscriptionMap[subscriptionId];
-            this._doUnsubscribe(subscriptionId);
-        }
-        else {
-            const removeSubscriptions = [];
-            this._assetSubscriptionMap.forEach((info, key) => {
-                const callbackMap = info.callbacks;
-                callbackMap.delete(subscriptionId);
-                if (callbackMap.size === 0) {
-                    removeSubscriptions.push(key);
-                }
-            });
-            removeSubscriptions.forEach((subscriptionIdToRemove) => {
-                this._assetSubscriptionMap.delete(subscriptionIdToRemove);
-                this.unsubscribe(subscriptionIdToRemove);
-            });
-        }
-    }
-    sendEvent(event) {
-        if (this._status === EventProviderStatus.CONNECTED) {
-            this._doSend(event);
-        }
-    }
-    sendEventWithReply(event) {
-        if (this._status !== EventProviderStatus.CONNECTED) {
-            return Promise.reject("Not connected");
-        }
-        return this._doSendWithReply(event);
-    }
-    subscribeAssetEvents(ids, requestCurrentValues, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const subscription = {
-                eventType: "asset"
-            };
-            const isAttributeRef = ids && typeof ids[0] !== "string";
-            const assetIds = isAttributeRef ? ids.map((id) => id.entityId) : ids;
-            if (assetIds && assetIds.length > 0) {
-                subscription.filter = {
-                    filterType: "asset",
-                    assetIds: ids
-                };
-            }
-            let subscriptionId = null;
-            try {
-                subscriptionId = yield this.subscribe(subscription, callback);
-                // Get the current state of the assets
-                if (assetIds && requestCurrentValues) {
-                    const readRequest = {
-                        messageId: "read-assets:" + assetIds.join(",") + ":" + subscriptionId,
-                        event: {
-                            eventType: "read-assets",
-                            assetQuery: {
-                                ids: assetIds
-                            }
-                        }
-                    };
-                    const response = yield this.sendEventWithReply(readRequest);
-                    if (response.assets) {
-                        response.assets.forEach((asset) => {
-                            const assetEvent = {
-                                eventType: "asset",
-                                asset: asset,
-                                cause: "READ" /* READ */
-                            };
-                            callback(assetEvent);
-                        });
-                    }
-                }
-            }
-            catch (e) {
-                console.error("Failed to subscribe to asset events for assets: " + ids);
-                if (subscriptionId) {
-                    this.unsubscribe(subscriptionId);
-                }
-                throw e;
-            }
-            return subscriptionId;
-        });
-    }
-    /**
-     * Subscribe for updates to a particular attribute; internally this creates subscriptions for all attributes of an
-     * asset and manages delivery of the update attributes to the subscribers
-     */
-    subscribeAttributeEvents(ids, requestCurrentValues, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!ids || ids.length === 0) {
-                throw new Error("At least one ID must be provided");
-            }
-            const isAttributeRef = typeof ids[0] !== "string";
-            const assetIds = isAttributeRef ? [...new Set(ids.map((id) => id.entityId))] : [...new Set(ids)];
-            const attributes = isAttributeRef ? ids : undefined;
-            const subscriptionId = "AttributeEvent" + EventProviderImpl._subscriptionCounter++;
-            // Check if we have an existing subscription for each asset, otherwise create one
-            const assetSubscriptions = assetIds.map((assetId) => {
-                const assetAttributes = attributes ? attributes.filter((attributeRef) => attributeRef.entityId === assetId) : undefined;
-                let info = this._assetSubscriptionMap.get(assetId);
-                let promise = Promise.resolve(assetId);
-                if (!info) {
-                    info = {
-                        callbacks: new Map()
-                    };
-                    this._assetSubscriptionMap.set(assetId, info);
-                    const subscription = {
-                        subscriptionId: assetId,
-                        eventType: "attribute",
-                        filter: {
-                            filterType: "asset",
-                            assetIds: [assetId]
-                        }
-                    };
-                    promise = this.subscribe(subscription, (evt) => {
-                        const assetSubscription = this._assetSubscriptionMap.get(assetId);
-                        if (!assetSubscription) {
-                            return;
-                        }
-                        // Keep cached asset in sync
-                        if (assetSubscription.asset) {
-                            if (evt.attributeState.deleted) {
-                                delete assetSubscription.asset.attributes[evt.attributeState.attributeRef.attributeName];
-                            }
-                            else {
-                                const attr = assetSubscription.asset.attributes[evt.attributeState.attributeRef.attributeName];
-                                attr.value = evt.attributeState.value;
-                                attr.valueTimestamp = evt.timestamp;
-                            }
-                        }
-                        assetSubscription.callbacks.forEach((cb, key) => {
-                            cb(evt);
-                        });
-                    }).then((sId) => {
-                        // Get and store the asset so we can quickly provide the current value of attributes
-                        const readEvent = {
-                            event: {
-                                eventType: "read-assets",
-                                assetQuery: {
-                                    ids: [assetId],
-                                    select: {
-                                        excludeParentInfo: true,
-                                        excludePath: true
-                                    }
-                                }
-                            }
-                        };
-                        return this.sendEventWithReply(readEvent);
-                    }).then((response) => {
-                        const assetsEvent = response;
-                        if (assetsEvent.assets && assetsEvent.assets.length === 1) {
-                            info.asset = assetsEvent.assets[0];
-                        }
-                        info.promise = undefined;
-                    });
-                    info.promise = promise;
-                }
-                else if (info.promise) {
-                    promise = info.promise;
-                }
-                info.callbacks.set(subscriptionId, (evt) => {
-                    if (assetAttributes) {
-                        if (assetAttributes.find((attributeRef) => evt.attributeState.attributeRef.attributeName === attributeRef.attributeName)) {
-                            callback(evt);
-                        }
-                    }
-                    else {
-                        callback(evt);
-                    }
-                });
-                return promise;
-            });
-            yield Promise.all(assetSubscriptions);
-            if (requestCurrentValues) {
-                assetIds.forEach((assetId) => {
-                    const info = this._assetSubscriptionMap.get(assetId);
-                    if (info && info.asset) {
-                        Object.entries(info.asset.attributes).forEach(([attributeName, v]) => {
-                            const attr = v;
-                            if (!attributes || attributes.find((attributeRef) => attributeRef.entityId === info.asset.id && attributeRef.attributeName === attributeName)) {
-                                callback({
-                                    eventType: "attribute",
-                                    timestamp: attr.valueTimestamp,
-                                    attributeState: {
-                                        value: attr.value,
-                                        attributeRef: {
-                                            entityId: assetId,
-                                            attributeName: attributeName
-                                        }
-                                    }
-                                });
-                            }
-                        });
-                    }
-                });
-            }
-            return subscriptionId;
-        });
-    }
-    _processNextSubscription() {
-        if (this._status !== EventProviderStatus.CONNECTED || this._queuedSubscriptions.length === 0) {
-            return;
-        }
-        setTimeout(() => {
-            const subscriptionInfo = this._queuedSubscriptions.shift();
-            if (subscriptionInfo) {
-                this.subscribe(subscriptionInfo.eventSubscription, subscriptionInfo.callback)
-                    .then((id) => {
-                    const deferred = subscriptionInfo.deferred;
-                    subscriptionInfo.deferred = null;
-                    if (deferred) {
-                        deferred.resolve(id);
-                    }
-                }, reason => {
-                    const deferred = subscriptionInfo.deferred;
-                    subscriptionInfo.deferred = null;
-                    if (deferred) {
-                        deferred.reject(reason);
-                    }
-                });
-            }
-        }, 0);
-    }
-    _onStatusChanged(status) {
-        if (status === this._status) {
-            return;
-        }
-        console.debug("Event provider status changed: " + status);
-        this._status = status;
-        window.setTimeout(() => {
-            this._statusCallbacks.forEach((cb) => cb(status));
-        }, 0);
-    }
-    _onMessageReceived(subscriptionId, event) {
-        const subscriptionInfo = this._subscriptionMap[subscriptionId];
-        if (subscriptionInfo) {
-            subscriptionInfo.callback(event);
-        }
-    }
-    _onConnect() {
-        console.debug("Event provider connected: " + this.constructor.name);
-        if (Object.keys(this._subscriptionMap).length > 0) {
-            for (const subscriptionId in this._subscriptionMap) {
-                if (this._subscriptionMap.hasOwnProperty(subscriptionId)) {
-                    this._queuedSubscriptions.unshift(this._subscriptionMap[subscriptionId]);
-                }
-            }
-            this._subscriptionMap = {};
-        }
-        this._processNextSubscription();
-    }
-    _onDisconnect() {
-        console.debug("Event provider disconnected");
-        this._onStatusChanged(EventProviderStatus.DISCONNECTED);
-        if (this._pendingSubscription) {
-            this._queuedSubscriptions.unshift(this._pendingSubscription);
-            this._pendingSubscription = null;
-        }
-        this._scheduleReconnect();
-    }
-    _scheduleReconnect() {
-        if (this._reconnectTimer) {
-            return;
-        }
-        if (this._disconnectRequested) {
-            return;
-        }
-        console.debug("Event provider scheduling reconnect in " + this._reconnectDelayMillis + "ms");
-        this._reconnectTimer = window.setTimeout(() => {
-            if (this._disconnectRequested) {
-                return;
-            }
-            this.connect().then(connected => {
-                if (!connected) {
-                    this._scheduleReconnect();
-                }
-            }).catch(error => {
-                this._scheduleReconnect();
-            });
-        }, this._reconnectDelayMillis);
-        if (this._reconnectDelayMillis < WebSocketEventProvider.MAX_RECONNECT_DELAY) {
-            this._reconnectDelayMillis = Math.min(WebSocketEventProvider.MAX_RECONNECT_DELAY, this._reconnectDelayMillis + 3000);
-        }
-    }
-}
-EventProviderImpl.MIN_RECONNECT_DELAY = 0;
-EventProviderImpl.MAX_RECONNECT_DELAY = 30000;
-EventProviderImpl._subscriptionCounter = 0;
-export class WebSocketEventProvider extends EventProviderImpl {
-    constructor(managerUrl) {
-        super();
-        this._webSocket = undefined;
-        this._connectDeferred = null;
-        this._subscribeDeferred = null;
-        this._repliesDeferred = new Map();
-        this._endpointUrl = (managerUrl.startsWith("https:") ? "wss" : "ws") + "://" + managerUrl.substr(managerUrl.indexOf("://") + 3) + "/websocket/events";
-        // Close socket on unload/refresh of page
-        window.addEventListener("beforeunload", () => {
-            this.disconnect();
-        });
-    }
-    get endpointUrl() {
-        return this._endpointUrl;
-    }
-    _doConnect() {
-        let authorisedUrl = this._endpointUrl + "?Auth-Realm=" + manager.config.realm;
-        if (manager.authenticated) {
-            authorisedUrl += "&Authorization=" + manager.getAuthorizationHeader();
-        }
-        this._webSocket = new WebSocket(authorisedUrl);
-        this._connectDeferred = new Deferred();
-        this._webSocket.onopen = () => {
-            if (this._connectDeferred) {
-                const deferred = this._connectDeferred;
-                this._connectDeferred = null;
-                deferred.resolve(true);
-            }
-        };
-        this._webSocket.onerror = () => {
-            if (this._connectDeferred) {
-                const deferred = this._connectDeferred;
-                this._connectDeferred = null;
-                deferred.resolve(false);
-            }
-            else {
-                console.debug("Event provider error");
-                // Could have inconsistent state so disconnect and let consumers decide what to do and when to reconnect
-                this._beforeDisconnect();
-            }
-        };
-        this._webSocket.onclose = () => {
-            this._webSocket = undefined;
-            if (this._connectDeferred) {
-                const deferred = this._connectDeferred;
-                this._connectDeferred = null;
-                deferred.resolve(false);
-            }
-            else {
-                this._beforeDisconnect();
-            }
-        };
-        this._webSocket.onmessage = (e) => {
-            const msg = e.data;
-            if (msg && msg.startsWith(SUBSCRIBED_MESSAGE_PREFIX)) {
-                const jsonStr = msg.substring(SUBSCRIBED_MESSAGE_PREFIX.length);
-                const subscription = JSON.parse(jsonStr);
-                const deferred = this._subscribeDeferred;
-                this._subscribeDeferred = null;
-                if (deferred) {
-                    deferred.resolve(subscription.subscriptionId);
-                }
-            }
-            else if (msg.startsWith(UNAUTHORIZED_MESSAGE_PREFIX)) {
-                const jsonStr = msg.substring(UNAUTHORIZED_MESSAGE_PREFIX.length);
-                const subscription = JSON.parse(jsonStr);
-                const deferred = this._subscribeDeferred;
-                this._subscribeDeferred = null;
-                if (deferred) {
-                    console.warn("Unauthorized event subscription: " + subscription);
-                    deferred.reject("Unauthorized");
-                }
-            }
-            else if (msg.startsWith(TRIGGERED_MESSAGE_PREFIX)) {
-                const str = msg.substring(TRIGGERED_MESSAGE_PREFIX.length);
-                const triggered = JSON.parse(str);
-                if (triggered.events) {
-                    triggered.events.forEach((event) => {
-                        this._onMessageReceived(triggered.subscriptionId, event);
-                    });
-                }
-            }
-            else if (msg.startsWith(EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX)) {
-                const str = msg.substring(EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX.length);
-                const event = JSON.parse(str);
-                if (event.messageId && event.event) {
-                    const deferred = this._repliesDeferred.get(event.messageId);
-                    this._repliesDeferred.delete(event.messageId);
-                    if (deferred) {
-                        deferred.resolve(event.event);
-                    }
-                }
-            }
-        };
-        return this._connectDeferred.promise;
-    }
-    _beforeDisconnect() {
-        this._onDisconnect();
-    }
-    _doDisconnect() {
-        this._webSocket.close();
-        this._subscribeDeferred = null;
-        this._repliesDeferred.clear();
-    }
-    _doSubscribe(subscription) {
-        if (!this._webSocket) {
-            return Promise.reject("Not connected");
-        }
-        if (this._subscribeDeferred) {
-            return Promise.reject("There's already a pending subscription");
-        }
-        this._subscribeDeferred = new Deferred();
-        if (!subscription.subscriptionId) {
-            subscription.subscriptionId = WebSocketEventProvider._subscriptionCounter++ + "";
-        }
-        this._webSocket.send(SUBSCRIBE_MESSAGE_PREFIX + JSON.stringify(subscription));
-        return this._subscribeDeferred.promise;
-    }
-    _doUnsubscribe(subscriptionId) {
-        if (!this._webSocket) {
-            return;
-        }
-        const cancelSubscription = {
-            subscriptionId: subscriptionId
-        };
-        this._webSocket.send(UNSUBSCRIBE_MESSAGE_PREFIX + JSON.stringify(cancelSubscription));
-    }
-    _doSend(event) {
-        const message = EVENT_MESSAGE_PREFIX + JSON.stringify(event);
-        this._webSocket.send(message);
-    }
-    _doSendWithReply(event) {
-        if (!event.messageId) {
-            event.messageId = (new Date().getTime() + (Math.random() * 10)).toString(10);
-        }
-        if (this._repliesDeferred.has(event.messageId)) {
-            return Promise.reject("There's already a pending send and reply with this ID");
-        }
-        const deferred = new Deferred();
-        this._repliesDeferred.set(event.messageId, deferred);
-        this._webSocket.send(EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX + JSON.stringify(event));
-        return deferred.promise;
-    }
-}
-WebSocketEventProvider._subscriptionCounter = 1;
-//# sourceMappingURL=event.js.map