@hcikn/colibri 1.1.1 → 1.3.2

package/dist/index.cjs

@@ -7,6 +7,45 @@ function _array_like_to_array(arr, len) {
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -26,7 +65,27 @@ function _create_class(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties(Constructor, staticProps);
     return Constructor;
 }
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
 function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -39,9 +98,26 @@ function _iterable_to_array(iter) {
 function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -50,26 +126,131 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-var __create = Object.create;
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = function(target, all) {
+var __export = function __export(target, all) {
     for(var name in all)__defProp(target, name, {
         get: all[name],
         enumerable: true
     });
 };
-var __copyProps = function(to, from, except, desc) {
-    if (from && typeof from === "object" || typeof from === "function") {
+var __copyProps = function __copyProps(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
             var _loop = function() {
                 var key = _step.value;
                 if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-                    get: function() {
+                    get: function get() {
                         return from[key];
                     },
                     enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
@@ -93,17 +274,7 @@ var __copyProps = function(to, from, except, desc) {
     }
     return to;
 };
-var __toESM = function(mod, isNodeMode, target) {
-    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
-    // file that has been converted to a CommonJS file using a Babel-
-    // compatible transform (i.e. "__esModule" has not been set), then set
-    // "default" to the CommonJS "module.exports" for node compatibility.
-    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-        value: mod,
-        enumerable: true
-    }) : target, mod);
-};
-var __toCommonJS = function(mod) {
+var __toCommonJS = function __toCommonJS(mod) {
     return __copyProps(__defProp({}, "__esModule", {
         value: true
     }), mod);
@@ -111,118 +282,352 @@ var __toCommonJS = function(mod) {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-    Colibri: function() {
+    Colibri: function Colibri1() {
         return Colibri;
     },
-    RegisterModelSync: function() {
+    GetRestApi: function GetRestApi1() {
+        return GetRestApi;
+    },
+    PutRestApi: function PutRestApi1() {
+        return PutRestApi;
+    },
+    RegisterChannel: function RegisterChannel1() {
+        return RegisterChannel;
+    },
+    RegisterModelSync: function RegisterModelSync1() {
         return RegisterModelSync;
     },
-    RemoteLogger: function() {
+    RegisterOnce: function RegisterOnce1() {
+        return RegisterOnce;
+    },
+    RemoteLogger: function RemoteLogger1() {
         return RemoteLogger;
     },
-    Sync: function() {
+    SendMessage: function SendMessage1() {
+        return SendMessage;
+    },
+    Sync: function Sync1() {
         return Sync;
     },
-    SyncModel: function() {
+    SyncModel: function SyncModel1() {
         return SyncModel;
     },
-    Synced: function() {
+    Synced: function Synced1() {
         return Synced;
+    },
+    UnregisterChannel: function UnregisterChannel1() {
+        return UnregisterChannel;
     }
 });
 module.exports = __toCommonJS(src_exports);
-// src/Networking.ts
-var import_rxjs = require("rxjs");
-var io = __toESM(require("socket.io-client"), 1);
-var messageSubject = new import_rxjs.Subject();
-var Messages = messageSubject.asObservable();
-var location = "";
-if (typeof window !== "undefined") {
-    location = window.location.hostname || "";
-}
-var socket = io.connect({
-    autoConnect: false
-});
-var init = function(app, server, port) {
-    server !== null && server !== void 0 ? server : server = location;
-    port !== null && port !== void 0 ? port : port = 9011;
-    if (!server.startsWith("http")) {
-        server = "http://" + server;
+// src/Colibri.ts
+var import_socket = require("socket.io-client");
+// src/ColibriError.ts
+var import_ts_custom_error = require("ts-custom-error");
+var ColibriError = /*#__PURE__*/ function(_import_ts_custom_error_CustomError) {
+    _inherits(ColibriError, _import_ts_custom_error_CustomError);
+    function ColibriError(message) {
+        _class_call_check(this, ColibriError);
+        return _call_super(this, ColibriError, [
+            message
+        ]);
     }
-    server += ":".concat(port);
-    socket.io.uri = server;
-    socket.io.opts.query = {
-        app: app,
-        version: "1"
-    };
-    socket.connect();
-    console.debug("Connecting to colibri server on ".concat(server));
-    socket.on("connect", function() {
-        console.debug("Connected to colibri server on ".concat(server));
-    });
-    socket.onAny(function(channel, msg) {
-        messageSubject.next({
-            channel: channel,
-            command: msg.command,
-            payload: msg.payload
+    return ColibriError;
+}(import_ts_custom_error.CustomError);
+// src/Colibri.ts
+var import_rxjs = require("rxjs");
+var _Colibri = /*#__PURE__*/ function() {
+    function _Colibri(app) {
+        var server = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
+            var _ref;
+            var _window_location, _window;
+            return (_ref = (_window = window) === null || _window === void 0 ? void 0 : (_window_location = _window.location) === null || _window_location === void 0 ? void 0 : _window_location.hostname) !== null && _ref !== void 0 ? _ref : "";
+        }(), port = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 9011;
+        _class_call_check(this, _Colibri);
+        this.app = app;
+        this.server = server;
+        this.port = port;
+        this.messageSubject = new import_rxjs.Subject();
+        this.messages = this.messageSubject.asObservable();
+        if (server.trim().length <= 0) {
+            throw new ColibriError("Server Address missing or empty!");
+        }
+        if (port < 1 || port > 65535) {
+            throw new ColibriError("Port out of allowed range (0 - 65535)");
+        }
+        this.uri = "".concat(server, ":").concat(port);
+        if (!new RegExp("wss?://", "i").test(this.uri)) {
+            this.uri = "ws://".concat(this.uri);
+        }
+        this.uriRestApi = "".concat(this.uri, "/api/store/").concat(app, "/");
+        if (_Colibri.instance) throw new ColibriError("A Colibri instance already exists!");
+        else _Colibri.instance = this;
+        this.socket = (0, import_socket.connect)(this.uri, {
+            query: {
+                app: app,
+                version: "1"
+            },
+            transports: [
+                "websocket"
+            ]
         });
-    });
+        this.socket.on("connect", this.onSocketConnect.bind(this));
+        this.socket.onAny(this.onSocketAny.bind(this));
+        this.registerChannel("colibri", function(msg) {
+            if (msg.command === "latency") {
+                SendMessage("colibri", "latency", msg.payload);
+            }
+        });
+    }
+    _create_class(_Colibri, [
+        {
+            key: "onSocketConnect",
+            value: function onSocketConnect() {
+                console.debug("Connected to colibri server on ".concat(this.server));
+            }
+        },
+        {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            key: "onSocketAny",
+            value: function onSocketAny(channel, msg) {
+                this.messageSubject.next({
+                    channel: channel,
+                    command: msg.command,
+                    payload: msg.payload
+                });
+            }
+        },
+        {
+            /**
+   * Sends a single message in the given `channel`.
+   * @param channel message channel
+   * @param command message command
+   * @param payload message payload
+   */ key: "sendMessage",
+            value: function sendMessage(channel, command) {
+                var payload = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+                this.socket.emit(channel, {
+                    command: command,
+                    payload: payload
+                });
+            }
+        },
+        {
+            //#region Socket Events
+            /**
+   * Adds a `handler` function listening for messages in `channel`.
+   * @param channel message channel
+   * @param handler handler to be executed when a message is received
+   */ key: "registerChannel",
+            value: function registerChannel(channel, handler) {
+                this.socket.on(channel, handler);
+            }
+        },
+        {
+            /**
+   * Removes the `handler` function listening for messages in `channel`.
+   * @param channel message channel
+   * @param handler handler to be executed when a message is received
+   */ key: "unregisterChannel",
+            value: function unregisterChannel(channel, handler) {
+                this.socket.off(channel, handler);
+            }
+        },
+        {
+            /**
+   * Adds a one-time `handler` function listening for the next message in `channel`.
+   * @param channel message channel
+   * @param handler handler to be executed when a message is received
+   */ key: "registerOnce",
+            value: function registerOnce(channel, handler) {
+                this.socket.once(channel, handler);
+            }
+        },
+        {
+            //#endregion
+            //#region Rest API
+            /**
+   * Returns the REST API Endpoint for a given `key` or null of the key is empty.
+   * @param key REST API storage key
+   * @returns
+   */ key: "getRestUri",
+            value: function getRestUri(key) {
+                key = key.trim();
+                while(key.startsWith("/"))key = key.substring(1);
+                return key.length === 0 ? null : this.uriRestApi + key;
+            }
+        },
+        {
+            key: "getRestObject",
+            value: /**
+   * Queries an object from the REST API identified by `key`.
+   * @param key REST API storage key
+   * @returns JSON object with data or null if object does not exist or any other error occurrs
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            function getRestObject(key) {
+                return _async_to_generator(function() {
+                    var uri, response;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                uri = this.getRestUri(key);
+                                if (!uri) return [
+                                    2,
+                                    null
+                                ];
+                                return [
+                                    4,
+                                    fetch(uri, {
+                                        method: "GET",
+                                        headers: {
+                                            "Content-Type": "application/json"
+                                        }
+                                    })
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                if (response.status >= 400) return [
+                                    2,
+                                    null
+                                ];
+                                else return [
+                                    2,
+                                    response.json()
+                                ];
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "setRestObject",
+            value: /**
+   * Sets or updatees an object in the REST API identified by `key`.
+   * @param key REST API storage key
+   * @param data JSON data to write
+   * @returns true if data was written to REST API
+   */ function setRestObject(key, data) {
+                return _async_to_generator(function() {
+                    var uri, response;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                uri = this.getRestUri(key);
+                                if (!uri) return [
+                                    2,
+                                    false
+                                ];
+                                return [
+                                    4,
+                                    fetch(uri, {
+                                        method: "PUT",
+                                        headers: {
+                                            "Content-Type": "application/json"
+                                        },
+                                        body: JSON.stringify(data)
+                                    })
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                return [
+                                    2,
+                                    response.status >= 200 && response.status < 300
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ], [
+        {
+            key: "getInstance",
+            value: /**
+   * Returns the existing Colibri instance or null if there's none yet
+   * @param warnIfNotInitialized true => print Log message if Colibri has not been initialized yet
+   * @returns
+   */ function getInstance() {
+                var warnIfNotInitialized = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                if (warnIfNotInitialized && !_Colibri.instance) {
+                    console.warn("Colibri not initialized yet! (Instance is null)");
+                }
+                return _Colibri.instance;
+            }
+        }
+    ]);
+    return _Colibri;
+}();
+_Colibri.instance = null;
+var Colibri = _Colibri;
+var SendMessage = function SendMessage(channel, command) {
+    var payload = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.sendMessage(channel, command, payload);
 };
-var Colibri = {
-    init: init
+var RegisterChannel = function RegisterChannel(channel, handler) {
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.registerChannel(channel, handler);
 };
-var SendMessage = function(channel, command) {
-    var payload = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    socket.emit(channel, {
-        command: command,
-        payload: payload
-    });
+var UnregisterChannel = function UnregisterChannel(channel, handler) {
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.unregisterChannel(channel, handler);
+};
+var RegisterOnce = function RegisterOnce(channel, handler) {
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.registerOnce(channel, handler);
 };
-var RegisterChannel = function(channel, handler) {
-    socket.on(channel, handler);
+var GetRestApi = function GetRestApi(key) {
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.getRestObject(key);
+};
+var PutRestApi = function PutRestApi(key, data) {
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.setRestObject(key, data);
 };
 // src/Broadcasting.ts
-var sendBool = function(channel, val) {
+var sendBool = function sendBool(channel, val) {
     SendMessage(channel, "broadcast::bool", val);
 };
-var sendBoolArray = function(channel, val) {
+var sendBoolArray = function sendBoolArray(channel, val) {
     SendMessage(channel, "broadcast::bool[]", val);
 };
-var sendNumber = function(channel, val) {
+var sendNumber = function sendNumber(channel, val) {
     SendMessage(channel, "broadcast::float", val);
 };
-var sendNumberArray = function(channel, val) {
+var sendNumberArray = function sendNumberArray(channel, val) {
     SendMessage(channel, "broadcast::float[]", val);
 };
-var sendString = function(channel, val) {
+var sendString = function sendString(channel, val) {
     SendMessage(channel, "broadcast::string", val);
 };
-var sendStringArray = function(channel, val) {
+var sendStringArray = function sendStringArray(channel, val) {
     SendMessage(channel, "broadcast::string[]", val);
 };
-var sendVector3 = function(channel, val) {
+var sendVector3 = function sendVector3(channel, val) {
     SendMessage(channel, "broadcast::vector3", val);
 };
-var sendVector3Array = function(channel, val) {
+var sendVector3Array = function sendVector3Array(channel, val) {
     SendMessage(channel, "broadcast::vector3[]", val);
 };
-var sendQuaternion = function(channel, val) {
+var sendQuaternion = function sendQuaternion(channel, val) {
     SendMessage(channel, "broadcast::quaternion", val);
 };
-var sendQuaternionArray = function(channel, val) {
+var sendQuaternionArray = function sendQuaternionArray(channel, val) {
     SendMessage(channel, "broadcast::quaternion[]", val);
 };
-var sendColor = function(channel, val) {
+var sendColor = function sendColor(channel, val) {
     SendMessage(channel, "broadcast::color", val);
 };
-var sendColorArray = function(channel, val) {
+var sendColorArray = function sendColorArray(channel, val) {
     SendMessage(channel, "broadcast::color[]", val);
 };
-var sendJson = function(channel, val) {
+var sendJson = function sendJson(channel, val) {
     SendMessage(channel, "broadcast::json", val);
 };
 var listeners = {};
-var registerListener = function(channel, type, callback) {
+var registerListener = function registerListener(channel, type, callback) {
     if (listeners[channel] === void 0) {
         listeners[channel] = {};
         RegisterChannel(channel, function(msg) {
@@ -238,46 +643,46 @@ var registerListener = function(channel, type, callback) {
     }
     listeners[channel][type].push(callback);
 };
-var receiveBool = function(channel, callback) {
+var receiveBool = function receiveBool(channel, callback) {
     registerListener(channel, "broadcast::bool", callback);
 };
-var receiveBoolArray = function(channel, callback) {
+var receiveBoolArray = function receiveBoolArray(channel, callback) {
     registerListener(channel, "broadcast::bool[]", callback);
 };
-var receiveNumber = function(channel, callback) {
+var receiveNumber = function receiveNumber(channel, callback) {
     registerListener(channel, "broadcast::float", callback);
 };
-var receiveNumberArray = function(channel, callback) {
+var receiveNumberArray = function receiveNumberArray(channel, callback) {
     registerListener(channel, "broadcast::float[]", callback);
 };
-var receiveString = function(channel, callback) {
+var receiveString = function receiveString(channel, callback) {
     registerListener(channel, "broadcast::string", callback);
 };
-var receiveStringArray = function(channel, callback) {
+var receiveStringArray = function receiveStringArray(channel, callback) {
     registerListener(channel, "broadcast::string[]", callback);
 };
-var receiveVector3 = function(channel, callback) {
+var receiveVector3 = function receiveVector3(channel, callback) {
     registerListener(channel, "broadcast::vector3", callback);
 };
-var receiveVector3Array = function(channel, callback) {
+var receiveVector3Array = function receiveVector3Array(channel, callback) {
     registerListener(channel, "broadcast::vector3[]", callback);
 };
-var receiveQuaternion = function(channel, callback) {
+var receiveQuaternion = function receiveQuaternion(channel, callback) {
     registerListener(channel, "broadcast::quaternion", callback);
 };
-var receiveQuaternionArray = function(channel, callback) {
+var receiveQuaternionArray = function receiveQuaternionArray(channel, callback) {
     registerListener(channel, "broadcast::quaternion[]", callback);
 };
-var receiveColor = function(channel, callback) {
+var receiveColor = function receiveColor(channel, callback) {
     registerListener(channel, "broadcast::color", callback);
 };
-var receiveColorArray = function(channel, callback) {
+var receiveColorArray = function receiveColorArray(channel, callback) {
     registerListener(channel, "broadcast::color[]", callback);
 };
-var receiveJson = function(channel, callback) {
+var receiveJson = function receiveJson(channel, callback) {
     registerListener(channel, "broadcast::json", callback);
 };
-var unregister = function(channel, callback) {
+var unregister = function unregister(channel, callback) {
     for(var command in listeners[channel]){
         var index = listeners[channel][command].indexOf(callback);
         if (index >= 0) {
@@ -320,62 +725,106 @@ var Sync = {
     sendIntArray: sendNumberArray
 };
 // src/RemoteLogger.ts
-var init2 = function() {
-    var consoleDebug = console.debug;
-    var consoleLog = console.log;
-    var consoleWarn = console.warn;
-    var consoleError = console.error;
-    var stringify = function(obj) {
-        if (_instanceof(obj, Error)) {
-            return obj.message + "\n" + obj.stack;
-        }
-        var cache = [];
-        var str = JSON.stringify(obj, function(_, value) {
-            if (typeof value === "object" && value !== null) {
-                if (cache.indexOf(value) !== -1) {
-                    return;
-                }
-                cache.push(value);
+var RemoteLogger = /*#__PURE__*/ function() {
+    function _RemoteLogger() {
+        var enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+        var _this = this;
+        _class_call_check(this, _RemoteLogger);
+        this.enabled = enabled;
+        this.consoleDebug = console.debug;
+        this.consoleLog = console.log;
+        this.consoleInfo = console.info;
+        this.consoleWarn = console.warn;
+        this.consoleError = console.error;
+        console.debug = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            _this.consoleDebug.apply(_this, _to_consumable_array(args));
+            _this.sendMessage("debug", args);
+        };
+        console.log = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            _this.consoleLog.apply(_this, _to_consumable_array(args));
+            _this.sendMessage("info", args);
+        };
+        console.info = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            _this.consoleInfo.apply(_this, _to_consumable_array(args));
+            _this.sendMessage("info", args);
+        };
+        console.warn = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            _this.consoleWarn.apply(_this, _to_consumable_array(args));
+            _this.sendMessage("warn", args);
+        };
+        console.error = function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            _this.consoleError.apply(_this, _to_consumable_array(args));
+            _this.sendMessage("error", args);
+        };
+    }
+    _create_class(_RemoteLogger, [
+        {
+            key: "sendMessage",
+            value: function sendMessage(level, args) {
+                if (!this.enabled) return;
+                SendMessage("log", level, _to_consumable_array(args).map(stringify).join().trim());
+            }
+        },
+        {
+            key: "enable",
+            value: function enable() {
+                this.enabled = true;
+            }
+        },
+        {
+            key: "disable",
+            value: function disable() {
+                this.enabled = false;
             }
-            return value;
-        }, 2);
-        return str;
-    };
-    console.debug = function init2() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
-        }
-        consoleDebug.apply(this, Array.prototype.slice.call(args));
-        SendMessage("log", "debug", _to_consumable_array(args).map(stringify).join().trim());
-    };
-    console.log = function() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
         }
-        consoleLog.apply(this, Array.prototype.slice.call(args));
-        SendMessage("log", "info", _to_consumable_array(args).map(stringify).join().trim());
-    };
-    console.warn = function() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
+    ], [
+        {
+            key: "init",
+            value: /**
+   * @deprecated use new class constructor directly
+   */ function init() {
+                var enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                return new _RemoteLogger(enabled);
+            }
         }
-        consoleWarn.apply(this, Array.prototype.slice.call(args));
-        SendMessage("log", "warning", _to_consumable_array(args).map(stringify).join().trim());
-    };
-    console.error = function() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
+    ]);
+    return _RemoteLogger;
+}();
+var stringify = function stringify(obj) {
+    if (_instanceof(obj, Error)) {
+        return obj.message + "\n" + obj.stack;
+    }
+    if (typeof obj === "string") return obj;
+    var cache = [];
+    var str = JSON.stringify(obj, function(_, value) {
+        if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null) {
+            if (cache.indexOf(value) !== -1) {
+                return;
+            }
+            cache.push(value);
         }
-        consoleError.apply(this, Array.prototype.slice.call(args));
-        SendMessage("log", "error", _to_consumable_array(args).map(stringify).join().trim());
-    };
-};
-var RemoteLogger = {
-    init: init2
+        return value;
+    }, 2);
+    return str;
 };
 // src/ModelSynchronization.ts
 var import_rxjs2 = require("rxjs");
-var RegisterModelSync = function(registration) {
+var RegisterModelSync = function RegisterModelSync(registration) {
     var name = registration.name || registration.type.name.toLowerCase();
     SendMessage(name, "model::request");
     console.log("Registering model '".concat(name, "'"));
@@ -390,7 +839,7 @@ var RegisterModelSync = function(registration) {
         }
     });
     var models = new import_rxjs2.BehaviorSubject([]);
-    var onUpdate = function(modelData) {
+    var onUpdate = function onUpdate(modelData) {
         var model = models.value.find(function(m) {
             return m.id === modelData.id;
         });
@@ -412,7 +861,7 @@ var RegisterModelSync = function(registration) {
             ]));
         }
     };
-    var onDelete = function(id) {
+    var onDelete = function onDelete(id) {
         var model = models.value.find(function(m) {
             return m.id === id;
         });
@@ -421,7 +870,7 @@ var RegisterModelSync = function(registration) {
             return m.id !== id;
         }));
     };
-    var registerModel = function(model) {
+    var registerModel = function registerModel(model) {
         model.modelChanges$.subscribe(function(changes) {
             if (!model.ignoreNextChange) {
                 SendMessage("".concat(name), "model::update", model.toJson(changes));
@@ -554,9 +1003,9 @@ var SyncModel = /*#__PURE__*/ function() {
     return SyncModel;
 }();
 // src/Synced.ts
-var Synced = function() {
+var Synced = function Synced() {
     var syncedName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
-    return function Synced(target, key, descriptor) {
+    return function(target, key, descriptor) {
         if (!syncedName) syncedName = key.toString();
         syncedName = syncedName.toLowerCase();
         if (!_instanceof(target, SyncModel)) {
@@ -568,10 +1017,10 @@ var Synced = function() {
         if (!(descriptor === null || descriptor === void 0 ? void 0 : descriptor.get)) {
             Reflect.deleteProperty(target, key);
             Reflect.defineProperty(target, key, {
-                get: function() {
+                get: function get() {
                     return original;
                 },
-                set: function(newVal) {
+                set: function set(newVal) {
                     console.log("Set ".concat(key.toString(), " to ").concat(newVal));
                     original = newVal;
                 },
@@ -600,10 +1049,16 @@ var Synced = function() {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
     Colibri: Colibri,
+    GetRestApi: GetRestApi,
+    PutRestApi: PutRestApi,
+    RegisterChannel: RegisterChannel,
     RegisterModelSync: RegisterModelSync,
+    RegisterOnce: RegisterOnce,
     RemoteLogger: RemoteLogger,
+    SendMessage: SendMessage,
     Sync: Sync,
     SyncModel: SyncModel,
-    Synced: Synced
+    Synced: Synced,
+    UnregisterChannel: UnregisterChannel
 });
 //# sourceMappingURL=index.cjs.map