@remix_labs/hub-client 1.1457.0-dev

package/index.js

@@ -0,0 +1,528 @@
+let terminate = function(f) {};
+if (globalThis.ThisIsNode) {
+    terminate = function(f) {
+        Process.on("exit", () => {
+            console.log("terminating hub worker");
+            f()
+        })
+    }
+};
+
+class JSONMessage {
+    constructor(rmxType, sender, payload) {
+        this.rmxType = rmxType;
+        this.sender = sender;
+        this.payload = typeof(payload) === "string" ? JSON.parse(payload) : payload;
+        this.eof = false;
+        this.localOnly = false;
+        this.header = { _rmx_type: rmxType,
+                        _rmx_encoding: "json",
+                        _rmx_sender: sender
+                      };
+        this.topic = "";
+        this.retained = false;
+    }
+
+    received(topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return this;
+    }
+
+    publish(reqId, topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return { _rmx_type: "msg_hub_publish",
+                 header: this.header,
+                 reqId: reqId,
+                 topic: topic,
+                 payload: JSON.stringify(this.payload),
+                 retained: retained,
+                 localOnly: false
+               }
+    }
+}
+
+class TextMessage {
+    constructor(rmxType, sender, payload) {
+        this.rmxType = rmxType;
+        this.sender = sender;
+        this.payload = payload;
+        this.eof = false;
+        this.localOnly = false;
+        this.header = { _rmx_type: rmxType,
+                        _rmx_encoding: "text",
+                        _rmx_sender: sender
+                      };
+        this.topic = "";
+        this.retained = false;
+    }
+
+    received(topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return this;
+    }
+
+    publish(reqId, topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return { _rmx_type: "msg_hub_publish",
+                 header: this.header,
+                 reqId: reqId,
+                 topic: topic,
+                 payload: this.payload,
+                 retained: retained,
+                 localOnly: false
+               }
+    }
+}
+
+class BinaryMessage {
+    constructor(rmxType, sender, payload) {
+        this.rmxType = rmxType;
+        this.sender = sender;
+        this.payload = payload;
+        this.eof = false;
+        this.localOnly = false;
+        this.header = { _rmx_type: rmxType,
+                        _rmx_encoding: "binary",
+                        _rmx_sender: sender
+                      };
+        this.topic = "";
+        this.retained = false;
+    }
+
+    received(topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return this;
+    }
+
+    publish(reqId, topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return { _rmx_type: "msg_hub_publish",
+                 header: this.header,
+                 reqId: reqId,
+                 topic: topic,
+                 payload: this.payload,
+                 retained: retained,
+                 localOnly: false
+               }
+    }
+}
+
+class LocalMessage {
+    constructor(rmxType, sender, payload) {
+        this.rmxType = rmxType;
+        this.sender = sender;
+        this.payload = payload;
+        this.eof = false;
+        this.localOnly = true;
+        this.header = { _rmx_type: rmxType,
+                        _rmx_encoding: "local",
+                        _rmx_sender: sender
+                      };
+        this.topic = "";
+        this.retained = false;
+    }
+
+    received(topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return this;
+    }
+
+    publish(reqId, topic, retained) {
+        this.topic = topic;
+        this.retained = retained;
+        return { _rmx_type: "msg_hub_publish",
+                 header: this.header,
+                 reqId: reqId,
+                 topic: topic,
+                 payload: this.payload,
+                 retained: retained,
+                 localOnly: true
+               }
+    }
+}
+
+class EOF {
+    constructor() {
+        this.rmxType = "";
+        this.sender = "";
+        this.payload = null;
+        this.eof = true;
+        this.localOnly = false;
+        this.header = { _rmx_type: "",
+                        _rmx_encoding: "eof",
+                        _rmx_sender: ""
+                      };
+        this.topic = "";
+        this.retained = false;
+    }
+}
+
+function decodeMessage(msg) {
+    if (msg.eof) {
+        return new EOF()
+    };
+    switch (msg.header._rmx_encoding) {
+    case "text":
+        return new TextMessage(msg.header._rmx_type,
+                               msg.header._rmx_sender,
+                               msg.payload).received(msg.topic, msg.retained)
+    case "json":
+        return new JSONMessage(msg.header._rmx_type,
+                               msg.header._rmx_sender,
+                               msg.payload).received(msg.topic, msg.retained)
+    case "binary":
+        return new BinaryMessage(msg.header._rmx_type,
+                                 msg.header._rmx_sender,
+                                 msg.payload).received(msg.topic, msg.retained)
+    case "local":
+        return new LocalMessage(msg.header._rmx_type,
+                                msg.header._rmx_sender,
+                                msg.payload).received(msg.topic, msg.retained)
+    default:
+        throw new Error("bad _rmx_encoding: " + msg.header._rmx_encoding)
+    }
+}
+
+class Subscription {
+    constructor(channel, topic, subId) {
+        this.channel = channel;
+        this.topic = topic;
+        this.subId = subId;
+        this.buffer = new Array();
+        this.eof = false;
+        this.notify = (() => null);
+        channel.expect.set(subId, (resp => {
+            if (resp.data.error != null) {
+                console.warn("got an unexpected error message: " + resp.data.error)
+            } else {
+                this.buffer.push(decodeMessage(resp.data));
+                this.eof = this.eof || resp.data.eof;
+                this.notify()
+            }
+        }))
+    }
+    next() {
+        return new Promise((resolve, reject) => {
+            if (this.buffer.length > 0) {
+                resolve(this.buffer.shift())
+            } else {
+                this.notify = (() => {
+                    this.notify = (() => null);
+                    if (this.buffer.length > 0) {
+                        resolve(this.buffer.shift())
+                    }
+                })
+            }
+        })
+    }
+
+    unsubscribe() {
+        return new Promise((resolve, reject) => {
+            let reqId = this.channel.reqId + 1;
+            this.channel.reqId = reqId;
+            this.channel.expect.set(reqId, (resp => {
+                this.channel.expect.delete(reqId);
+                if (resp.data.error == null) {
+                    resolve(resp.data)
+                } else
+                    reject(resp.data);
+            }));
+            let unsubMsg =
+                { _rmx_type: "msg_hub_unsubscribe",
+                  topic: this.topic,
+                  reqId: reqId,
+                  subId: this.subId
+                };
+            this.channel.port.postMessage(unsubMsg)
+        })
+    }
+}
+
+// The class Channel connects to the web worker implementing the hub.
+// If you want to send channels to further web workers, you can do so
+// by sending the port as transferable object, e.g.
+//    otherWorker.postMessage(..., [ channel.port ])
+// and in the implementation of onmessage of otherWorker restore the channel:
+//    onmessage(ev => { let channel = new Channel(ev.ports[0]) ... })
+// The restored channel talks then to the same hub.
+class Channel {
+    constructor(port) {
+        this.port = port;
+        this.expect = new Map();
+        this.reqId = 0;
+
+        this.port.onmessage = (ev => {
+            try {
+                let f = this.expect.get(ev.data.reqId);
+                if (ev.eof) {
+                    this.expect.delete(ev.data.reqId);
+                };
+                f(ev);
+            } catch (e) {
+                console.error("Exception when receiving a message in hub-client: ", e);
+            }
+        })
+    }
+
+    publish(topic, msg, retained) {
+        return new Promise((resolve, reject) => {
+            let reqId = this.reqId + 1;
+            this.reqId = reqId;
+            this.expect.set(reqId, (resp => {
+                this.expect.delete(reqId);
+                if (resp.data.error == null)
+                    resolve(null);
+                else
+                    reject(resp.data);
+            }));
+            let publishMsg = msg.publish(reqId, topic, retained);
+            this.port.postMessage(publishMsg)
+        })
+    }
+
+    send(topic, msg) {
+        return this.publish(topic, msg, false);
+    }
+
+    set(topic, msg) {
+        return this.publish(topic, msg, true);
+    }
+
+    get(topic) {
+        // so far this only works for local topics
+        return new Promise((resolve, reject) => {
+            let reqId = this.reqId + 1;
+            this.reqId = reqId;
+            this.expect.set(reqId, (resp => {
+                this.expect.delete(reqId);
+                if (resp.data.error == null) {
+                    if (resp.data.payload !== undefined) {
+                        resolve(decodeMessage(resp.data.payload));
+                    } else {
+                        resolve(undefined);
+                    }
+                } else
+                    reject(resp.data);
+            }));
+            let getMsg =
+                { _rmx_type: "msg_hub_get",
+                  header: { _rmx_type: "msg_hub_get",
+                            _rmx_encoding: "json",
+                            _rmx_sender: this.sender
+                          },
+                  reqId: reqId,
+                  topic: topic,
+                  payload: "null",
+                  retained: false,
+                  localOnly: true
+                };
+            this.port.postMessage(getMsg)
+        })
+    }
+
+    subscribe(topic) {
+        return new Promise((resolve, reject) => {
+            let reqId = this.reqId + 1;
+            let subId = reqId + 1;
+            this.reqId = subId;
+            let sub = new Subscription(this, topic, subId);
+            this.expect.set(reqId, (resp => {
+                this.expect.delete(reqId);
+                if (resp.data.error == null)
+                    resolve(sub);
+                else
+                    reject(resp.data);
+            }));
+            let subMsg =
+                { _rmx_type: "msg_hub_subscribe",
+                  topic: topic,
+                  reqId: reqId,
+                  subId: subId
+                };
+            this.port.postMessage(subMsg)
+        })
+    }
+
+    setLocalPubTopic(topic) {
+        return new Promise((resolve, reject) => {
+            let reqId = this.reqId + 1;
+            this.reqId = reqId;
+            this.expect.set(reqId, (resp => {
+                this.expect.delete(reqId);
+                if (resp.data.error == null)
+                    resolve(null);
+                else
+                    reject(resp.data);
+            }));
+            let m = { _rmx_type:"msg_hub_setLocalPubTopic",
+                      topic: topic,
+                      reqId: reqId
+                    };
+            this.port.postMessage(m)
+        })
+    }
+
+    setLocalSubTopic(topic) {
+        return new Promise((resolve, reject) => {
+            let reqId = this.reqId + 1;
+            this.reqId = reqId;
+            this.expect.set(reqId, (resp => {
+                this.expect.delete(reqId);
+                if (resp.data.error == null)
+                    resolve(null);
+                else
+                    reject(resp.data);
+            }));
+            let m = { _rmx_type:"msg_hub_setLocalSubTopic",
+                      topic: topic,
+                      reqId: reqId
+                    };
+            this.port.postMessage(m)
+        })
+    }
+
+    newChannel() {
+        return new Promise((resolve, reject) => {
+            let reqId = this.reqId + 1;
+            this.reqId = reqId;
+            this.expect.set(reqId, (resp => {
+                this.expect.delete(reqId);
+                if (resp.data.error == null) {
+                    let port = resp.ports !== undefined ? resp.ports[0] : resp.dara.port;
+                    let hubch = new Channel(port);
+                    resolve(hubch);
+                } else
+                    reject(resp.data)
+            }));
+            let msg =
+                { _rmx_type: "msg_hub_newChannel",
+                  reqId: reqId
+                };
+            this.port.postMessage(msg);
+        })
+    }
+
+    newJSONMessage(rmxType, sender, payload) {
+        return new JSONMessage(rmxType, sender, payload);
+    }
+
+    newTextMessage(rmxType, sender, payload) {
+        return new TextMessage(rmxType, sender, payload);
+    }
+
+    newBinaryMessage(rmxType, sender, payload) {
+        return new BinaryMessage(rmxType, sender, payload);
+    }
+
+    newLocalMessage(rmxType, sender, payload) {
+        return new LocalMessage(rmxType, sender, payload);
+    }
+
+    newEOF(rmxType, sender, payload) {
+        return new EOF(rmxType, sender, payload);
+    }
+}
+
+// This class starts the web worker for the hub. Should only be instantiated
+// once.
+class Worker {
+    constructor() {
+        if (globalThis.RmxMessagingHub) {
+            this.worker = globalThis.RmxMessagingHub.worker;
+            this.expect = globalThis.RmxMessagingHub.expect;
+            this.noreconfigure = true;
+            return;
+        };
+        let bundle;
+        if (globalThis.ThisIsNode) {
+            bundle = new URL("../../hub-worker/src/node.js", import.meta.url);
+        } else if (globalThis.GROOVEBOX_URL_PREFIX) {
+            // FIXME: Stopgap solution until we figure out a way to bundle groovebox correctly
+            bundle = new URL(`${globalThis.GROOVEBOX_URL_PREFIX}/hub-worker.js`, window.location.href);
+        } else {
+            bundle = new URL("/g/hub-worker.js", window.location.href);
+        }
+        this.worker = new globalThis.Worker(bundle);
+        globalThis.RmxMessagingHub = this;
+        let thisworker = this;
+        this.expect = new Array(0);
+        this.worker.onmessage = (ev => {
+            let f = thisworker.expect.shift();
+            f(ev)
+        });
+        this.noreconfigure = false;
+        terminate(() => thisworker.worker.terminate());
+    }
+
+    configure(config_obj) {
+        if (this.noreconfigure) {
+            console.warn("The global hub-client is already configured");
+            return;
+        };
+        let thisworker = this;
+        return new Promise((resolve, reject) => {
+            thisworker.expect.push(resp => {
+                if (resp.data.error == null)
+                    resolve(resp.data);
+                else
+                    reject(resp.data)
+            });
+            let config_msg = 
+                { "_rmx_type": "msg_hub_configure",
+                  "baseURL": config_obj.baseURL,
+                  "wsURL": config_obj.wsURL,
+                  "user": config_obj.user,
+                  "token": config_obj.token,
+                  "standalone": config_obj.standalone === true
+                };
+            thisworker.worker.postMessage(config_msg);
+        })
+    }
+
+    newChannel() {
+        let thisworker = this;
+        return new Promise((resolve, reject) => {
+            thisworker.expect.push(resp => {
+                if (resp.data.error == null) {
+                    let port = resp.ports !== undefined ? resp.ports[0] : resp.data.port;
+                    let hubch = new Channel(port);
+                    resolve(hubch);
+                } else
+                    reject(resp.data)
+            });
+            let msg =
+                { "_rmx_type": "msg_hub_newChannel" };
+            thisworker.worker.postMessage(msg);
+        })
+    }
+
+    newJSONMessage(rmxType, sender, payload) {
+        return new JSONMessage(rmxType, sender, payload);
+    }
+
+    newTextMessage(rmxType, sender, payload) {
+        return new TextMessage(rmxType, sender, payload);
+    }
+
+    newBinaryMessage(rmxType, sender, payload) {
+        return new BinaryMessage(rmxType, sender, payload);
+    }
+
+    newLocalMessage(rmxType, sender, payload) {
+        return new LocalMessage(rmxType, sender, payload);
+    }
+
+    newEOF(rmxType, sender, payload) {
+        return new EOF(rmxType, sender, payload);
+    }
+}
+
+export { Worker, Channel, JSONMessage, TextMessage, BinaryMessage, LocalMessage,
+         EOF }

package/node.js

@@ -0,0 +1,6 @@
+globalThis.ThisIsNode = true;
+import Worker from "@remix_labs/web-worker-onlymain";
+globalThis.Worker = Worker;
+import Process from "process";
+globalThis.Process = Process;
+export * from "./index.js";

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@remix_labs/hub-client",
+  "version": "1.1457.0-dev",
+  "description": "talk to the Hub web worker",
+  "main": "node.js",
+  "browser": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Remixlabs staff",
+  "license": "ISC",
+  "dependencies": {
+    "@remix_labs/web-worker-onlymain": "1.1457.0-dev"
+  },
+  "repository": "https://github.com/remixlabs/groovebox.git"
+}

package/package_pub.json

@@ -0,0 +1,17 @@
+{
+  "name": "@remix_labs/hub-client",
+  "version": "_FULLVERSION_",
+  "description": "talk to the Hub web worker",
+  "main": "node.js",
+  "browser": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Remixlabs staff",
+  "license": "ISC",
+  "dependencies": {
+    "@remix_labs/web-worker-onlymain": "_FULLVERSION_"
+  },
+  "repository": "https://github.com/remixlabs/groovebox.git"
+}