@hcikn/colibri 1.0.4 → 1.2.0

package/dist/index.cjs

@@ -7,6 +7,41 @@ 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 _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -26,6 +61,25 @@ 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) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -39,9 +93,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,11 +121,128 @@ 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() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = 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(_)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) {
     for(var name in all)__defProp(target, name, {
@@ -93,16 +281,6 @@ 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) {
     return __copyProps(__defProp({}, "__esModule", {
         value: true
@@ -114,12 +292,27 @@ __export(src_exports, {
     Colibri: function() {
         return Colibri;
     },
+    GetRestApi: function() {
+        return GetRestApi;
+    },
+    PutRestApi: function() {
+        return PutRestApi;
+    },
+    RegisterChannel: function() {
+        return RegisterChannel;
+    },
     RegisterModelSync: function() {
         return RegisterModelSync;
     },
+    RegisterOnce: function() {
+        return RegisterOnce;
+    },
     RemoteLogger: function() {
         return RemoteLogger;
     },
+    SendMessage: function() {
+        return SendMessage;
+    },
     Sync: function() {
         return Sync;
     },
@@ -128,57 +321,278 @@ __export(src_exports, {
     },
     Synced: function() {
         return Synced;
+    },
+    UnregisterChannel: function() {
+        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) {
-    server !== null && server !== void 0 ? server : server = location;
-    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);
+    var _super = _create_super(ColibriError);
+    function ColibriError(message) {
+        _class_call_check(this, ColibriError);
+        return _super.call(this, message);
     }
-    server += ":9011";
-    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 _window_location_hostname;
+var _Colibri = /*#__PURE__*/ function() {
+    function _Colibri(app) {
+        var server = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
+            var _window_location, _window;
+            return (_window_location_hostname = (_window = window) === null || _window === void 0 ? void 0 : (_window_location = _window.location) === null || _window_location === void 0 ? void 0 : _window_location.hostname) !== null && _window_location_hostname !== void 0 ? _window_location_hostname : "";
+        }(), 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"
+            ]
         });
-    });
-};
-var Colibri = {
-    init: init
-};
+        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) {
+                var _this = this;
+                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
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            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) {
+                var _this = this;
+                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
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ], [
+        {
+            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(channel, command) {
     var payload = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    socket.emit(channel, {
-        command: command,
-        payload: payload
-    });
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.sendMessage(channel, command, payload);
 };
 var RegisterChannel = function(channel, handler) {
-    socket.on(channel, handler);
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.registerChannel(channel, handler);
+};
+var UnregisterChannel = function(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(channel, handler) {
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.registerOnce(channel, handler);
+};
+var GetRestApi = function(key) {
+    var _Colibri_getInstance;
+    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.getRestObject(key);
+};
+var PutRestApi = function(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) {
@@ -319,58 +733,102 @@ 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(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 === "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");
@@ -599,10 +1057,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