bruce-models 0.7.7 → 0.7.9

package/dist/bruce-models.umd.js

@@ -902,6 +902,149 @@
         CamApi.Api = Api$$1;
     })(exports.CamApi || (exports.CamApi = {}));
 
+    (function (MessageBroker) {
+        var Action;
+        (function (Action) {
+            Action["SUBSCRIBE"] = "subscribe";
+            Action["SUBSCRIBE_SHADOW"] = "subscribeShadow";
+            Action["UNSUBSCRIBE"] = "unsubscribe";
+            Action["BROADCAST"] = "broadcast";
+            Action["GET_TOPIC_SUBSCRIBERS"] = "getTopicSubscribers"; // requests topic subscribers without subscribing
+        })(Action = MessageBroker.Action || (MessageBroker.Action = {}));
+        /** Events types any component may get from server */
+        var Event;
+        (function (Event) {
+            Event["SAVED"] = "saved";
+            Event["UPDATED"] = "updated";
+            Event["DELETED"] = "deleted";
+            Event["EDIT_STARTED"] = "editStarted";
+            Event["EDIT_FINISHED"] = "editFinished";
+            Event["USERS_UPDATE"] = "usersUpdate";
+        })(Event = MessageBroker.Event || (MessageBroker.Event = {}));
+        /** Communicates with a server message broker */
+        var WebSocketBroker = /** @class */ (function () {
+            function WebSocketBroker(uri, env) {
+                this.uri = uri;
+                this.env = env;
+                this.subscriptions = new Map();
+                this.reconnects = 0;
+                this.maxReconnects = 5;
+                this.connect();
+            }
+            WebSocketBroker.prototype.connect = function () {
+                try {
+                    this.ws = new WebSocket(this.formatApiUri(this.uri));
+                    this.ws.onopen = this.onOpen.bind(this);
+                    this.ws.onmessage = this.onMessage.bind(this);
+                    this.ws.onerror = this.onError.bind(this);
+                    this.ws.onclose = this.onClose.bind(this);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            };
+            WebSocketBroker.prototype.formatApiUri = function (uri) {
+                var ws = document.location.protocol === "https:" ? "wss" : "ws";
+                return uri.replace(/^(https|http)/, ws) + "websocket";
+            };
+            WebSocketBroker.prototype.setUser = function (user) {
+                this.user = this.user ? this.user : user;
+            };
+            WebSocketBroker.prototype.onOpen = function (ev) {
+                if (this.env === exports.Api.EEnv.DEV) {
+                    console.log("MessageBroker connection opened: ", ev);
+                }
+            };
+            WebSocketBroker.prototype.onClose = function (ev) {
+                var _this = this;
+                if (this.env === exports.Api.EEnv.DEV) {
+                    console.log("MessageBroker connection closed, trying to reconnect: ", ev);
+                }
+                if (this.reconnects < this.maxReconnects) {
+                    this.reconnects += 1;
+                    setTimeout(function () { return _this.connect(); }, 5000 * this.reconnects);
+                }
+            };
+            WebSocketBroker.prototype.onMessage = function (ev) {
+                var _a;
+                var data = JSON.parse(ev.data);
+                (_a = this.subscriptions.get(data.topic)) === null || _a === void 0 ? void 0 : _a.forEach(function (cb) { return cb(data); });
+            };
+            WebSocketBroker.prototype.onError = function (ev) {
+                console.error("MessageBroker connection error: ", ev);
+            };
+            WebSocketBroker.prototype.addSubscriber = function (topic, callback) {
+                var subscribers = this.subscriptions.get(topic) || [];
+                if (subscribers.includes(callback)) {
+                    return;
+                }
+                subscribers.push(callback);
+                this.subscriptions.set(topic, subscribers);
+                if (this.env === exports.Api.EEnv.DEV) {
+                    console.groupCollapsed("MessageBroker subscription added: ", topic);
+                    console.table(Array.from(this.subscriptions.entries()));
+                    console.groupEnd();
+                }
+            };
+            /** Send message to server */
+            WebSocketBroker.prototype.sendMessage = function (msg) {
+                if (this.ws.readyState !== WebSocket.OPEN) {
+                    return;
+                }
+                if (!this.user) {
+                    console.error("Set user first!");
+                }
+                try {
+                    var outgoingMessage = __assign(__assign({}, msg), { user: this.user, time: Date.now() });
+                    this.ws.send(JSON.stringify(outgoingMessage));
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+            };
+            Object.defineProperty(WebSocketBroker.prototype, "connected", {
+                get: function () {
+                    return this.ws.readyState === WebSocket.OPEN;
+                },
+                enumerable: false,
+                configurable: true
+            });
+            /** Add a subscriber to a topic */
+            WebSocketBroker.prototype.subscribe = function (topic, callback, action) {
+                if (action === void 0) { action = Action.SUBSCRIBE; }
+                this.addSubscriber(topic, callback);
+                this.sendMessage({ topic: topic, action: action });
+                if (this.env === exports.Api.EEnv.DEV) {
+                    console.log("Subscribe [" + action + "] called for topic", topic);
+                }
+            };
+            /** Add a shadow subscriber to a topic */
+            WebSocketBroker.prototype.subscribeShadow = function (topic, callback) {
+                this.subscribe(topic, callback, Action.SUBSCRIBE_SHADOW);
+            };
+            /** Remove a subscriber from a topic */
+            WebSocketBroker.prototype.unsubscribe = function (topic, callback) {
+                var subscribers = this.subscriptions.get(topic) || [];
+                this.subscriptions.set(topic, subscribers.filter(function (fn) { return fn != callback; }));
+                this.sendMessage({ topic: topic, action: Action.UNSUBSCRIBE });
+                if (this.env === exports.Api.EEnv.DEV) {
+                    console.groupCollapsed("MessageBroker subscription removed: ", topic);
+                    console.table(Array.from(this.subscriptions.entries()));
+                    console.groupEnd();
+                }
+            };
+            WebSocketBroker.prototype.sendBroadcastMessage = function (msg) {
+                this.sendMessage(__assign(__assign({}, msg), { action: Action.BROADCAST }));
+            };
+            WebSocketBroker.prototype.requestTopicUsers = function (topic, callback) {
+                this.addSubscriber(topic, callback);
+                this.sendMessage({ topic: topic, action: Action.GET_TOPIC_SUBSCRIBERS });
+            };
+            return WebSocketBroker;
+        }());
+        MessageBroker.WebSocketBroker = WebSocketBroker;
+    })(exports.MessageBroker || (exports.MessageBroker = {}));
+
     (function (BruceApi) {
         /**
          * This is the request handler for Bruce Api,
@@ -920,19 +1063,31 @@
                 _this.loadCancelled = false;
                 _this.accountId = accountId;
                 _this.env = env !== null && env !== void 0 ? env : exports.Api.EEnv.PROD;
-                _this.loadProm = _this.setBaseUrl(cam);
+                _this.loadProm = _this.init(cam);
                 return _this;
             }
+            Object.defineProperty(Api$$1.prototype, "MessageBroker", {
+                get: function () {
+                    return this.messageBroker;
+                },
+                enumerable: false,
+                configurable: true
+            });
             Object.defineProperty(Api$$1.prototype, "Loading", {
                 // Indicates if the init process has finished loading.
-                // This means the regional base url has been set.
+                // This means the regional base url has been set and message broker is ready.
                 get: function () {
                     return this.loadProm;
                 },
                 enumerable: false,
                 configurable: true
             });
-            Api$$1.prototype.setBaseUrl = function (cam) {
+            /**
+             * Loads regional base url and sets up message broker.
+             * @param cam
+             * @returns
+             */
+            Api$$1.prototype.init = function (cam) {
                 var _a;
                 return __awaiter(this, void 0, void 0, function () {
                     var prefix, url, env, camApi, settings, endpoint, e_1;
@@ -981,7 +1136,9 @@
                                 e_1 = _b.sent();
                                 console.error(e_1);
                                 return [3 /*break*/, 4];
-                            case 4: return [2 /*return*/];
+                            case 4:
+                                this.messageBroker = new exports.MessageBroker.WebSocketBroker(this.baseUrl, this.env);
+                                return [2 /*return*/];
                         }
                     });
                 });
@@ -1862,7 +2019,8 @@
             if (typeof value == "string") {
                 try {
                     value = BruceVariable.SwapValues(value, entity);
-                    return eval(value);
+                    var eval2 = eval; // https://rollupjs.org/guide/en/#avoiding-eval
+                    return eval2(value);
                 }
                 catch (exception) {
                     var e = exception;