@monterosa/sdk-interact-kit 0.17.1-rc.6

package/dist/index.cjs.js

@@ -0,0 +1,2709 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkConnectKit = require('@monterosa/sdk-connect-kit');
+var sdkUtil = require('@monterosa/sdk-util');
+var sdkCore = require('@monterosa/sdk-core');
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    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 };
+    }
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __spreadArray(to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+/**
+ * @license
+ * api.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2023-05-24
+ * Copyright © 2023 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Sign in the user to submit data that requires a verified user.
+ *
+ * @example
+ * ```javascript
+ * try {
+ *   const sdk = getSdk();
+ *   const userId = "b236e331-ee62-4238-90d0-47588c7facdc";
+ *   const timestamp = 1684934960;
+ *   const signature = "9ABC4892838DC13986A63B736E95A7D99DF95C72";
+ *
+ *   await login(sdk, userId, timestamp, signature);
+ *
+ *   console.log('logged in successfully!');
+ * } catch (err) {
+ *   console.log(err)
+ * }
+ * ```
+ *
+ * @param sdk - Monterosa SDK instance
+ * @param userId - The unique user UUID
+ * @param timestamp - The timecode when the signature was generated
+ * @param signature - A unique identifier that serves as proof of the user's authenticity.
+ *  The signature must only contain the following characters: 0-9, a-z, A-Z, and must be uppercased
+ * @returns A Promise that resolves with `void` when the login is successful, otherwise it rejects.
+ */
+function login(sdk, userId, timestamp, signature) {
+    return __awaiter(this, void 0, void 0, function () {
+        var connect;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, sdkConnectKit.getConnect(sdk.options.host)];
+                case 1:
+                    connect = _a.sent();
+                    return [2 /*return*/, sdkConnectKit.login(connect, userId, timestamp, signature)];
+            }
+        });
+    });
+}
+
+/**
+ * @license
+ * public-types.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-11-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+exports.State = void 0;
+(function (State) {
+    State["Ok"] = "ok";
+    State["Error"] = "error";
+})(exports.State || (exports.State = {}));
+/**
+ * @internal
+ */
+exports.Klass = void 0;
+(function (Klass) {
+    Klass["Listings"] = "listings";
+    Klass["History"] = "history";
+    Klass["Create"] = "create";
+    Klass["Revoke"] = "revoke";
+    Klass["Stop"] = "stop";
+    Klass["Reveal"] = "reveal";
+    Klass["Poll"] = "p";
+    Klass["Feedback"] = "fb";
+    Klass["Eoc"] = "eoc";
+    Klass["Vote"] = "v";
+})(exports.Klass || (exports.Klass = {}));
+/**
+ * @internal
+ */
+exports.Channel = void 0;
+(function (Channel) {
+    Channel["Poll"] = "p";
+    Channel["Live"] = "l";
+})(exports.Channel || (exports.Channel = {}));
+
+/**
+ * @license
+ * connect_impl.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-11-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var ConnectImpl = /** @class */ (function (_super) {
+    __extends(ConnectImpl, _super);
+    function ConnectImpl(host) {
+        var _this = _super.call(this) || this;
+        _this.host = host;
+        _this._state = exports.State.Ok;
+        _this._enmasse = null;
+        return _this;
+    }
+    Object.defineProperty(ConnectImpl.prototype, "state", {
+        get: function () {
+            return this._state;
+        },
+        set: function (state) {
+            if (state === this._state) {
+                return;
+            }
+            this._state = state;
+            this.emit('state', this._state);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConnectImpl.prototype, "enmasse", {
+        get: function () {
+            if (this._enmasse === null) {
+                throw new Error('Connect is not initialised, init() method should be called first.');
+            }
+            return this._enmasse;
+        },
+        set: function (enmasse) {
+            this._enmasse = enmasse;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConnectImpl.prototype.init = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, sdkConnectKit.getConnect(this.host)];
+                    case 1:
+                        _a.enmasse = _b.sent();
+                        this.enmasse.on('message', this.handleMessage.bind(this));
+                        this.enmasse.on('state', this.handleState.bind(this));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ConnectImpl.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, sdkConnectKit.connect(this.enmasse)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ConnectImpl.prototype.disconnect = function () {
+        sdkConnectKit.disconnect(this.enmasse);
+    };
+    ConnectImpl.prototype.subscribeProject = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, sdkConnectKit.subscribe(this.enmasse, exports.Channel.Live + "-" + id)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ConnectImpl.prototype.unsubscribeProject = function (id) {
+        sdkConnectKit.unsubscribe(this.enmasse, exports.Channel.Live + "-" + id);
+    };
+    ConnectImpl.prototype.subscribeEvent = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            sdkConnectKit.subscribe(this.enmasse, exports.Channel.Live + "-" + id),
+                            sdkConnectKit.subscribe(this.enmasse, exports.Channel.Poll + "-" + id),
+                        ])];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ConnectImpl.prototype.unsubscribeEvent = function (id) {
+        sdkConnectKit.unsubscribe(this.enmasse, exports.Channel.Live + "-" + id);
+        sdkConnectKit.unsubscribe(this.enmasse, exports.Channel.Poll + "-" + id);
+    };
+    ConnectImpl.prototype.sendVote = function (eventId, pollId, answer) {
+        sdkConnectKit.send(this.enmasse, exports.Channel.Poll + "-" + eventId, exports.Klass.Vote, [
+            pollId,
+            answer,
+            '',
+        ]);
+    };
+    ConnectImpl.prototype.handleMessage = function (message) {
+        var klass = message.klass, data = message.body, channel = message.channel;
+        var id = channel.substring(channel.indexOf('-') + 1);
+        this.emit('message', {
+            id: id,
+            klass: klass,
+            data: data,
+        });
+    };
+    ConnectImpl.prototype.handleState = function (state) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        switch (state) {
+            case sdkConnectKit.ConnState.Disconnected:
+                this.state = exports.State.Error;
+                break;
+            case sdkConnectKit.ConnState.Connecting: {
+                var attempt = args[0];
+                if (attempt > 1) {
+                    this.state = exports.State.Error;
+                }
+                break;
+            }
+            case sdkConnectKit.ConnState.Connected:
+                this.state = exports.State.Ok;
+                break;
+        }
+    };
+    return ConnectImpl;
+}(sdkUtil.Emitter));
+
+/**
+ * @license
+ * api.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-11-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var getConnectMemoized = sdkUtil.memoizePromise(function (host) { return __awaiter(void 0, void 0, void 0, function () {
+    var connect;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                connect = new ConnectImpl(host);
+                return [4 /*yield*/, connect.init()];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, connect.connect()];
+            case 2:
+                _a.sent();
+                return [2 /*return*/, connect];
+        }
+    });
+}); }, function (host) { return host; });
+/**
+ * @internal
+ */
+function getConnect(host) {
+    return getConnectMemoized(host);
+}
+
+/**
+ * @license
+ * public-types.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Provides states of the connection health
+ */
+exports.ConnectionHealthState = void 0;
+(function (ConnectionHealthState) {
+    /**
+     * The client is connected and the connection is healthy
+     */
+    ConnectionHealthState["Ok"] = "ok";
+    /**
+     * The client is either trying to establish a connection but failing, or
+     * the client has been explicetily {@link @monterosa/sdk-connect-kit#disconnect() | disconnected}
+     */
+    ConnectionHealthState["Error"] = "error";
+})(exports.ConnectionHealthState || (exports.ConnectionHealthState = {}));
+
+/**
+ * @license
+ * connection_health_impl.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-15
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var ConnectionHealthImpl = /** @class */ (function (_super) {
+    __extends(ConnectionHealthImpl, _super);
+    function ConnectionHealthImpl(connect) {
+        var _this = _super.call(this) || this;
+        _this.connect = connect;
+        _this._state = exports.ConnectionHealthState.Ok;
+        _this.connect.on('state', _this.handleState.bind(_this));
+        return _this;
+    }
+    Object.defineProperty(ConnectionHealthImpl.prototype, "state", {
+        get: function () {
+            return this._state;
+        },
+        set: function (state) {
+            this._state = state;
+            this.emit('state', state);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConnectionHealthImpl.prototype.handleState = function () {
+        switch (this.connect.state) {
+            default:
+            case exports.State.Ok:
+                this.state = exports.ConnectionHealthState.Ok;
+                break;
+            case exports.State.Error:
+                this.state = exports.ConnectionHealthState.Error;
+                break;
+        }
+    };
+    return ConnectionHealthImpl;
+}(sdkUtil.Emitter));
+
+/**
+ * @license
+ * index.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-15
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var getConnectionHealthMemoized = sdkUtil.memoizePromise(function (sdk) { return __awaiter(void 0, void 0, void 0, function () {
+    var connect, connectionHealth;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, getConnect(sdk.options.host)];
+            case 1:
+                connect = _a.sent();
+                connectionHealth = new ConnectionHealthImpl(connect);
+                return [2 /*return*/, connectionHealth];
+        }
+    });
+}); }, function (sdk) { return sdk.options.host; });
+/**
+ * Returns {@link ConnectionHealth | connection health} instance
+ */
+function getConnectionHealth(sdk) {
+    if (sdk === void 0) { sdk = sdkCore.getSdk(); }
+    return getConnectionHealthMemoized(sdk);
+}
+/**
+ * Adds an observer for when
+ * {@link ConnectionHealth.state | connection health state} changed
+ */
+function onConnectionHealthState(connectionHealth, callback) {
+    return sdkUtil.subscribe(connectionHealth, 'state', callback);
+}
+
+/**
+ * @license
+ * internal.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-15
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+function fetchSettings(host, id) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, data;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch("https://" + host + "/projects/" + id.substring(0, 2) + "/" + id + "/settings.json")];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    data = _a.sent();
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+}
+
+/**
+ * @license
+ * constants.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-06-02
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var DEFAULT_IGNORE_TIME = 30;
+
+/**
+ * @license
+ * locale.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-10-18
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Converts tag for identifying languages (rfc5646) into ISO language code
+ */
+function tagToLanguage(tag) {
+    // The tag is split not only by `-` as its stated in the rfc
+    // but also by `_` as it is returned by Studio for some locales
+    var chunks = tag.split(/[-_]/);
+    return chunks[0];
+}
+/**
+ * Returns either:
+ *   * a locale from the list of provided locales that correspond OS locale preferences
+ *   * or default locale if OS locale doesn't correspond to any from the provided list
+ *
+ *  * @internal
+ */
+function getLocale(locales) {
+    // The list of user's preferred language tags,
+    var languageTags = __spreadArray([
+        // where the first item is the user's default language
+        navigator.language
+    ], navigator.languages);
+    // firstly, trying to check if one of languages tag
+    // has a full match with passed locales
+    for (var _i = 0, languageTags_1 = languageTags; _i < languageTags_1.length; _i++) {
+        var tag = languageTags_1[_i];
+        if (locales.includes(tag)) {
+            // if language tag has a match return it right away
+            return tag;
+        }
+    }
+    // secondly, checking if user's language (ISO string)
+    // has occurrences in the list of locales
+    for (var _a = 0, languageTags_2 = languageTags; _a < languageTags_2.length; _a++) {
+        var tag = languageTags_2[_a];
+        var userLang = tagToLanguage(tag);
+        for (var _b = 0, locales_1 = locales; _b < locales_1.length; _b++) {
+            var locale = locales_1[_b];
+            var studioLang = tagToLanguage(locale);
+            if (studioLang === userLang) {
+                // return the first locale that has the same
+                // language ISO string as the user language tag
+                return locale;
+            }
+        }
+    }
+    // if none locales matches users preferred languages tags
+    // return default locale
+    return locales[0];
+}
+function localise(value, locale) {
+    if (Object.prototype.hasOwnProperty.call(value, locale)) {
+        return value[locale];
+    }
+    return value.all;
+}
+
+/**
+ * @license
+ * project_impl.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-15
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+var ProjectImpl = /** @class */ (function (_super) {
+    __extends(ProjectImpl, _super);
+    function ProjectImpl(options, context) {
+        var _this = _super.call(this) || this;
+        _this.id = options.id;
+        _this.host = options.host;
+        _this._context = context;
+        return _this;
+    }
+    Object.defineProperty(ProjectImpl.prototype, "context", {
+        get: function () {
+            return this._context;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "embedUrl", {
+        get: function () {
+            var _a;
+            return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.embed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "uuid", {
+        get: function () {
+            var _a;
+            return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.uuid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "events", {
+        get: function () {
+            var _a;
+            return ((_a = this._listings) === null || _a === void 0 ? void 0 : _a.events) || [];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "listings", {
+        get: function () {
+            return this._listings;
+        },
+        set: function (value) {
+            var _this = this;
+            var createdEvents = [];
+            var deletedEvents = [];
+            if (this._listings) {
+                createdEvents = value.events.filter(function (_a) {
+                    var id = _a.id;
+                    return !_this._listings.events.some(function (event) { return id === event.id; });
+                });
+            }
+            if (this._listings) {
+                deletedEvents = this.listings.events.filter(function (_a) {
+                    var id = _a.id;
+                    return !value.events.some(function (event) { return id === event.id; });
+                });
+            }
+            this._listings = __assign({}, value);
+            this._locales = this._listings.project.locales
+                // clone the array first
+                .map(function (locale) { return (__assign({}, locale)); })
+                // sort an array so that the default locale is the first
+                .sort(function (locale) { return (locale.default ? -1 : 0); })
+                // return only keys of the locales
+                .map(function (locale) { return locale.key; });
+            this._locale = getLocale(this._locales);
+            if (createdEvents.length > 0) {
+                this.emit('listings_events_created', createdEvents);
+            }
+            if (deletedEvents.length > 0) {
+                this.emit('listings_events_deleted', deletedEvents);
+            }
+            this.emit('listings');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "isLocalisationSupported", {
+        get: function () {
+            var _a;
+            return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.is_localisation_supported;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "locale", {
+        get: function () {
+            return this._locale;
+        },
+        set: function (locale) {
+            if (!this.locales.includes(locale)) {
+                throw new Error("Unknown locale name \"" + locale + "\"");
+            }
+            this._locale = locale;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "locales", {
+        get: function () {
+            return this._locales;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "fields", {
+        get: function () {
+            if (this._fields !== undefined) {
+                return localise(this._fields, this.locale);
+            }
+            return {};
+        },
+        /**
+         * Sets custom fields
+         *
+         * It accepts both Localised<Record<string, unknown>> and Record<string, unknown> to
+         * avoid mistyping between setter and getter
+         *
+         * @internal
+         */
+        set: function (value) {
+            var isUpdate = typeof this._fields !== 'undefined';
+            this._fields = __assign({}, value);
+            if (isUpdate) {
+                this.emit('updated');
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "extensions", {
+        get: function () {
+            var _a;
+            return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.assets;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProjectImpl.prototype, "historyIgnore", {
+        get: function () {
+            var _a;
+            var value = (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.history_ignore;
+            if (value && value > 0) {
+                return value;
+            }
+            return DEFAULT_IGNORE_TIME;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // TODO: must be implemented
+    // eslint-disable-next-line
+    ProjectImpl.prototype.delete = function () { };
+    return ProjectImpl;
+}(sdkUtil.Emitter));
+
+/**
+ * @license
+ * factory.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-15
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var projects = new Map();
+var connects = new Map();
+function buildProject(options, context) {
+    return __awaiter(this, void 0, void 0, function () {
+        var id, host, project, setup, _a, err_1, connect;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    id = options.id, host = options.host;
+                    if (projects.has(id)) {
+                        return [2 /*return*/, projects.get(id)];
+                    }
+                    project = new ProjectImpl(options, context);
+                    /**
+                     * Add it to the cache of projects, so that we could find it to populate it
+                     * with the data when /listings/ message is coming from the Enmasse.
+                     */
+                    projects.set(id, project);
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 5, , 6]);
+                    return [4 /*yield*/, setupConnect(host)];
+                case 2:
+                    setup = _b.sent();
+                    return [4 /*yield*/, setup.subscribeProject(id)];
+                case 3:
+                    _b.sent();
+                    /**
+                     * By the time goLive successfully resolved listings must be present
+                     * in project. If they are not, then there is no /listings/ in the channel's cache.
+                     * This might be due to either studio is malfunctioning or project id is incorrect.
+                     */
+                    if (!project.listings) {
+                        throw new Error("Unable to fetch project " + id + " listings. Possibly wrong project id.");
+                    }
+                    _a = project;
+                    return [4 /*yield*/, fetchSettings(project.host, project.id)];
+                case 4:
+                    _a.fields = _b.sent();
+                    return [2 /*return*/, project];
+                case 5:
+                    err_1 = _b.sent();
+                    /**
+                     * If anything goes wrong we need to unsubscribe from the Enmasse project's
+                     * channel by switching it to the offline mode.
+                     */
+                    if (connects.has(id)) {
+                        connect = connects.get(id);
+                        connect.unsubscribeProject(id);
+                    }
+                    /**
+                     * And project should be removed from the list of cached projects so that
+                     * it won't be automatically returned upon consequent buildProject call
+                     */
+                    projects.delete(id);
+                    throw err_1;
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+function setupConnect(host) {
+    return __awaiter(this, void 0, void 0, function () {
+        var connect;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (connects.has(host)) {
+                        return [2 /*return*/, connects.get(host)];
+                    }
+                    return [4 /*yield*/, getConnect(host)];
+                case 1:
+                    connect = _a.sent();
+                    connect.on('message', handleConnectMessage$1);
+                    return [2 /*return*/, connect];
+            }
+        });
+    });
+}
+function handleConnectMessage$1(message) {
+    return __awaiter(this, void 0, void 0, function () {
+        var id, klass, data, project, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    id = message.id, klass = message.klass, data = message.data;
+                    project = projects.get(id);
+                    if (!project) {
+                        return [2 /*return*/];
+                    }
+                    _a = klass;
+                    switch (_a) {
+                        case exports.Klass.Listings: return [3 /*break*/, 1];
+                    }
+                    return [3 /*break*/, 3];
+                case 1: return [4 /*yield*/, handleListings(project, data[0])];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleListings(project, data) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var listings, newDigest, oldDigest, _b;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    listings = JSON.parse(data);
+                    newDigest = listings.project.app_settings_digest;
+                    oldDigest = (_a = project.listings) === null || _a === void 0 ? void 0 : _a.project.app_settings_digest;
+                    project.listings = listings;
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 4, , 5]);
+                    if (!(oldDigest !== undefined && newDigest !== oldDigest)) return [3 /*break*/, 3];
+                    _b = project;
+                    return [4 /*yield*/, fetchSettings(project.host, project.id)];
+                case 2:
+                    _b.fields = _d.sent();
+                    _d.label = 3;
+                case 3: return [3 /*break*/, 5];
+                case 4:
+                    _d.sent();
+                    console.warn("Unable to fetch project " + project.id + " settings");
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+
+/**
+ * @license
+ * api.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-15
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+var getProjectMemoized = sdkUtil.memoizePromise(function (sdk) { return __awaiter(void 0, void 0, void 0, function () {
+    var project;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, buildProject({
+                    id: sdk.options.projectId,
+                    host: sdk.options.host,
+                }, {
+                    sdk: sdk,
+                })];
+            case 1:
+                project = _a.sent();
+                return [2 /*return*/, project];
+        }
+    });
+}); }, function (sdk) { return sdk.options.projectId; });
+/**
+ * Returns {@link InteractProject | project instance} associated
+ * with the {@link @monterosa/sdk-core#MonterosaSdk | configured sdk}
+ */
+function getProject(sdk) {
+    if (sdk === void 0) { sdk = sdkCore.getSdk(); }
+    return getProjectMemoized(sdk);
+}
+/**
+ * @internal
+ */
+function fetchListings(host, projectId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, data;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch("https://" + host + "/projects/" + projectId.substring(0, 2) + "/" + projectId + "/listings.json")];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    data = (_a.sent());
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+}
+/**
+ * Adds an observer for when {@link InteractProject.fields |  project fields}
+ * are updated
+ */
+function onProjectFieldsUpdated(project, callback) {
+    return sdkUtil.subscribe(project, 'updated', callback);
+}
+/**
+ * @internal
+ */
+function onProjectListingsUpdated(project, callback) {
+    return sdkUtil.subscribe(project, 'listings', callback);
+}
+
+/**
+ * @license
+ * internal.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+function fetchHistory(host, id) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, data;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch("https://" + host + "/events/" + id.substring(0, 2) + "/" + id + "/history.json")];
+                case 1:
+                    response = _a.sent();
+                    if (!response.ok) {
+                        throw new Error("Failed to fetch event " + id + " history");
+                    }
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    data = _a.sent();
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+}
+
+/**
+ * @license
+ * public-types.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Describes the event state.
+ */
+exports.EventState = void 0;
+(function (EventState) {
+    /**
+     * The event is in the `upcoming` state when its {@link InteractEvent.startAt | start time}
+     * less than the {@link now | current time}.
+     */
+    EventState["Upcoming"] = "upcoming";
+    /**
+     * The event is in the `active` state when its {@link InteractEvent.startAt | start time}
+     * equal or more than the {@link now | current time} and less than the
+     * {@link InteractEvent.endAt | end time}.
+     */
+    EventState["Active"] = "active";
+    /**
+     * @internal
+     */
+    EventState["Prolonged"] = "prolonged";
+    /**
+     * The event is in the `finished` state when its {@link InteractEvent.endAt | end time}
+     * equal or more than the {@link now | current time}.
+     */
+    EventState["Finished"] = "finished";
+})(exports.EventState || (exports.EventState = {}));
+var InitState;
+(function (InitState) {
+    InitState["Uninitialised"] = "uninitialised";
+    InitState["Initialising"] = "initialising";
+    InitState["Initialised"] = "initialised";
+})(InitState || (InitState = {}));
+
+/**
+ * @license
+ * event_impl.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-15
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+var EventImpl = /** @class */ (function (_super) {
+    __extends(EventImpl, _super);
+    function EventImpl(data, context) {
+        var _this = _super.call(this) || this;
+        _this._initState = InitState.Uninitialised;
+        _this._history = null;
+        _this._data = data;
+        _this._context = context;
+        _this._state = _this.calculateState();
+        _this._internalState = _this.calculateInternalState();
+        _this.unsubscribeStateHandler = sdkUtil.onTick(function () { return _this.handleState(); });
+        _this.unsubscribeInternalStateHandler = sdkUtil.onTick(function () {
+            _this.handleInternalState();
+        });
+        _this.unsubscribeListingsHandler = onProjectListingsUpdated(context.project, function () { return _this.handleListings(); });
+        return _this;
+    }
+    EventImpl.prototype.calculateState = function () {
+        if (!this._data.started || sdkUtil.now() < this.startAt) {
+            return exports.EventState.Upcoming;
+        }
+        if (sdkUtil.now() < this.endAt) {
+            return exports.EventState.Active;
+        }
+        return exports.EventState.Finished;
+    };
+    EventImpl.prototype.calculateInternalState = function () {
+        if (!this._data.started || sdkUtil.now() < this.startAt) {
+            return exports.EventState.Upcoming;
+        }
+        if (sdkUtil.now() < this.endAt) {
+            return exports.EventState.Active;
+        }
+        if (sdkUtil.now() < this.endAt + this._data.extra_time) {
+            return exports.EventState.Prolonged;
+        }
+        return exports.EventState.Finished;
+    };
+    EventImpl.prototype.handleState = function () {
+        var state = this.calculateState();
+        if (state === exports.EventState.Finished) {
+            this.unsubscribeStateHandler();
+        }
+        if (state !== this._state) {
+            this._state = state;
+            this.emit('state', state);
+        }
+    };
+    EventImpl.prototype.handleInternalState = function () {
+        var internalState = this.calculateInternalState();
+        if (internalState === exports.EventState.Finished) {
+            this.unsubscribeInternalStateHandler();
+        }
+        if (internalState !== this._internalState) {
+            this._internalState = internalState;
+            this.emit('internal_state', internalState);
+        }
+    };
+    EventImpl.prototype.handleListings = function () {
+        var _this = this;
+        var project = this.context.project;
+        var data = project.events.find(function (_a) {
+            var id = _a.id;
+            return id === _this.id;
+        });
+        if (data && this._data.digest !== data.digest) {
+            this._data = data;
+            this.emit('updated');
+        }
+    };
+    /** @internal */
+    EventImpl.prototype.destroy = function () {
+        this.unsubscribeStateHandler();
+        this.unsubscribeInternalStateHandler();
+        this.unsubscribeListingsHandler();
+    };
+    Object.defineProperty(EventImpl.prototype, "context", {
+        get: function () {
+            return this._context;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "id", {
+        get: function () {
+            return this._data.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "name", {
+        get: function () {
+            return this._data.name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "startAt", {
+        get: function () {
+            return this._data.start_at;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "startAtIso", {
+        get: function () {
+            return this._data.start_at_iso;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "endAt", {
+        get: function () {
+            return this._data.end_at;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "endAtIso", {
+        get: function () {
+            return this._data.end_at_iso;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "duration", {
+        get: function () {
+            return this._data.duration;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "fields", {
+        get: function () {
+            var locale = this.context.project.locale;
+            return localise(this._data.custom_fields, locale);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "state", {
+        get: function () {
+            return this._state;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "internalState", {
+        get: function () {
+            return this._internalState;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "initState", {
+        get: function () {
+            return this._initState;
+        },
+        set: function (state) {
+            this._initState = state;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "history", {
+        get: function () {
+            return this._history;
+        },
+        set: function (value) {
+            this._history = value;
+            this.emit('history', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "canSubscribe", {
+        get: function () {
+            return (this._internalState === exports.EventState.Active ||
+                this._internalState === exports.EventState.Prolonged);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "canLoadHistory", {
+        get: function () {
+            return sdkUtil.now() >= this.startAt + this.context.project.historyIgnore;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return EventImpl;
+}(sdkUtil.Emitter));
+
+/**
+ * @license
+ * factory.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-22
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var events = new Map();
+var healthListeners = new Map();
+function buildEvent(options, context) {
+    if (events.has(options.id)) {
+        return events.get(options.id);
+    }
+    var event = new EventImpl(options, context);
+    event.on('internal_state', handleEventInternalState.bind(event));
+    events.set(options.id, event);
+    return event;
+}
+function init(event) {
+    return __awaiter(this, void 0, void 0, function () {
+        var history_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (event.initState === InitState.Initialising) {
+                        return [2 /*return*/, Promise.reject(new Error("can't initialise event, event is already being initialised"))];
+                    }
+                    if (event.initState === InitState.Initialised) {
+                        return [2 /*return*/, Promise.reject(new Error("can't initialise event, event is already initialised"))];
+                    }
+                    event.initState = InitState.Initialising;
+                    if (!(event.canLoadHistory && event.history === null)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, fetchHistory(event.context.project.host, event.id)];
+                case 1:
+                    history_1 = _a.sent();
+                    event.history = history_1;
+                    _a.label = 2;
+                case 2:
+                    if (!event.canSubscribe) return [3 /*break*/, 4];
+                    return [4 /*yield*/, subscribe(event)];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4: return [4 /*yield*/, listenConnHealth(event)];
+                case 5:
+                    _a.sent();
+                    event.initState = InitState.Initialised;
+                    return [2 /*return*/, Promise.resolve()];
+            }
+        });
+    });
+}
+function subscribe(event) {
+    return __awaiter(this, void 0, void 0, function () {
+        var connect;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!event.canSubscribe) {
+                        return [2 /*return*/, Promise.reject(new Error("Event can't be subscribed"))];
+                    }
+                    return [4 /*yield*/, getConnect(event.context.project.host)];
+                case 1:
+                    connect = _a.sent();
+                    return [4 /*yield*/, connect.subscribeEvent(event.id)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, Promise.resolve()];
+            }
+        });
+    });
+}
+function unsubscribe(event) {
+    return __awaiter(this, void 0, void 0, function () {
+        var connect;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getConnect(event.context.project.host)];
+                case 1:
+                    connect = _a.sent();
+                    return [4 /*yield*/, connect.unsubscribeEvent(event.id)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, Promise.resolve()];
+            }
+        });
+    });
+}
+function listenConnHealth(event) {
+    return __awaiter(this, void 0, void 0, function () {
+        var project, connect, unsub;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    project = event.context.project;
+                    if (healthListeners.has(project.id)) {
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, getConnect(project.host)];
+                case 1:
+                    connect = _a.sent();
+                    if (connect.enmasse !== null) {
+                        unsub = sdkConnectKit.onConnected(connect.enmasse, handleEnmasseConnected);
+                        healthListeners.set(project.id, unsub);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleEventInternalState(state) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(state === exports.EventState.Finished)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, unsubscribe(this)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleEnmasseConnected() {
+    var e_1, _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var _b, _c, event_1, history_2, e_1_1;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 6, 7, 12]);
+                    _b = __asyncValues(Array.from(events.values()));
+                    _d.label = 1;
+                case 1: return [4 /*yield*/, _b.next()];
+                case 2:
+                    if (!(_c = _d.sent(), !_c.done)) return [3 /*break*/, 5];
+                    event_1 = _c.value;
+                    if (!(event_1.initState === InitState.Initialised)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, fetchHistory(event_1.context.project.host, event_1.id)];
+                case 3:
+                    history_2 = _d.sent();
+                    event_1.history = history_2;
+                    _d.label = 4;
+                case 4: return [3 /*break*/, 1];
+                case 5: return [3 /*break*/, 12];
+                case 6:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 12];
+                case 7:
+                    _d.trys.push([7, , 10, 11]);
+                    if (!(_c && !_c.done && (_a = _b.return))) return [3 /*break*/, 9];
+                    return [4 /*yield*/, _a.call(_b)];
+                case 8:
+                    _d.sent();
+                    _d.label = 9;
+                case 9: return [3 /*break*/, 11];
+                case 10:
+                    if (e_1) throw e_1.error;
+                    return [7 /*endfinally*/];
+                case 11: return [7 /*endfinally*/];
+                case 12: return [2 /*return*/];
+            }
+        });
+    });
+}
+
+/**
+ * @internal
+ */
+var getEventsMemoized = sdkUtil.memoizePromise(function (project) { return __awaiter(void 0, void 0, void 0, function () {
+    var context;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(project === undefined)) return [3 /*break*/, 2];
+                return [4 /*yield*/, getProject()];
+            case 1:
+                project = _a.sent();
+                _a.label = 2;
+            case 2:
+                context = __assign(__assign({}, project.context), { project: project });
+                return [2 /*return*/, (project.events
+                        // Calling builder function that creates an event instance.
+                        // Existing event will be returned if it already exists in the cache
+                        .map(function (data) { return buildEvent(data, context); })
+                        // Sort events so the most recent event is first, and the oldest is last
+                        .sort(function (a, b) { return a.startAt - b.startAt; }))];
+        }
+    });
+}); }, function (project) {
+    if (project === undefined) {
+        var sdk = sdkCore.getSdk();
+        return sdk.options.projectId;
+    }
+    return project.id;
+});
+/**
+ * Returns all events in a project, including all active events and
+ * past/upcoming events, according to Listings settings in Project Setup
+ * in Studio.
+ *
+ * @param project - A project instance. If not provided,
+ *   the one from the default sdk will be fetched.
+ */
+function getEvents(project) {
+    return getEventsMemoized(project);
+}
+/**
+ * @internal
+ */
+var getEventMemoized = sdkUtil.memoizePromise(function (id, project) { return __awaiter(void 0, void 0, void 0, function () {
+    var context, data, event_1, history_1, history_2, event_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(project === undefined)) return [3 /*break*/, 2];
+                return [4 /*yield*/, getProject()];
+            case 1:
+                project = _a.sent();
+                _a.label = 2;
+            case 2:
+                if (events.has(id)) {
+                    return [2 /*return*/, events.get(id)];
+                }
+                context = __assign(__assign({}, project.context), { project: project });
+                data = project.events.find(function (eventData) { return eventData.id === id; });
+                if (!(data !== undefined)) return [3 /*break*/, 5];
+                event_1 = buildEvent(data, context);
+                if (!event_1.canLoadHistory) return [3 /*break*/, 4];
+                return [4 /*yield*/, fetchHistory(project.host, id)];
+            case 3:
+                history_1 = _a.sent();
+                event_1.history = history_1;
+                _a.label = 4;
+            case 4: return [2 /*return*/, event_1];
+            case 5:
+                _a.trys.push([5, 7, , 8]);
+                return [4 /*yield*/, fetchHistory(project.host, id)];
+            case 6:
+                history_2 = _a.sent();
+                event_2 = buildEvent(history_2.config, context);
+                event_2.history = history_2;
+                return [2 /*return*/, event_2];
+            case 7:
+                _a.sent();
+                return [2 /*return*/, null];
+            case 8: return [2 /*return*/];
+        }
+    });
+}); }, function (id) { return id; });
+/**
+ * Returns an event by its id
+ *
+ * @param id - Id of the event
+ * @param project - A project instance. If not provided,
+ *   the one from the default sdk will be fetched.
+ *
+ * @returns A an event associated with the provided id and project or null if no such
+ *   event exists in the project.
+ */
+function getEvent(id, project) {
+    return getEventMemoized(id, project);
+}
+/**
+ * Adds an observer for when {@link InteractEvent.state | event state} changed
+ */
+function onEventState(event, callback) {
+    return sdkUtil.subscribe(event, 'state', callback);
+}
+/**
+ * Adds an observer for when event's data changed
+ */
+function onEventUpdated(event, callback) {
+    return sdkUtil.subscribe(event, 'updated', callback);
+}
+/**
+ * Adds an observer that is called when an event is added to listings.
+ *
+ * @remarks
+ * The following actions will result in adding an event to listings:
+ *
+ * - The start of the event in Studio
+ *
+ * - The scheduling of a future event in Studio, when listings are configured
+ *   to include future events in Project Settings.
+ *
+ * - When a future event starts, a new future event may be added to the list,
+ *   depending on the project configuration, to ensure a minimum number of
+ *   upcoming events are always available.
+ */
+function onEventAdded(project, callback) {
+    var _this = this;
+    return sdkUtil.subscribe(project, 'listings_events_created', function (data) { var data_1, data_1_1; return __awaiter(_this, void 0, void 0, function () {
+        var options, event_3, e_1_1;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 6, 7, 12]);
+                    data_1 = __asyncValues(data);
+                    _b.label = 1;
+                case 1: return [4 /*yield*/, data_1.next()];
+                case 2:
+                    if (!(data_1_1 = _b.sent(), !data_1_1.done)) return [3 /*break*/, 5];
+                    options = data_1_1.value;
+                    return [4 /*yield*/, getEvent(options.id, project)];
+                case 3:
+                    event_3 = _b.sent();
+                    if (event_3 !== null) {
+                        callback(event_3);
+                    }
+                    _b.label = 4;
+                case 4: return [3 /*break*/, 1];
+                case 5: return [3 /*break*/, 12];
+                case 6:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 12];
+                case 7:
+                    _b.trys.push([7, , 10, 11]);
+                    if (!(data_1_1 && !data_1_1.done && (_a = data_1.return))) return [3 /*break*/, 9];
+                    return [4 /*yield*/, _a.call(data_1)];
+                case 8:
+                    _b.sent();
+                    _b.label = 9;
+                case 9: return [3 /*break*/, 11];
+                case 10:
+                    if (e_1) throw e_1.error;
+                    return [7 /*endfinally*/];
+                case 11: return [7 /*endfinally*/];
+                case 12: return [2 /*return*/];
+            }
+        });
+    }); });
+}
+/**
+ * {@link onEventAdded} alias.
+ *
+ * @deprecated Use the new {@link onEventAdded} function instead.
+ */
+function onEventPublished(project, callback) {
+    console.warn('onEventPublished() is deprecated. Please use onEventAdded() instead');
+    return onEventAdded(project, callback);
+}
+/**
+ * Adds an observer that is called when an event is removed from listings.
+ *
+ * @remarks
+ * The following actions will result in removing an event from listings:
+ *
+ * - The deletion of the event from Studio
+ *
+ * - The change of listings confuguration in Project Settings to exclude future
+ *   or past events.
+ *
+ * - The event is removed after a period of time since its completion. This period
+ *   is calculated as 45 seconds plus the Maximum allowed delay (configured in
+ *   Project Settings in Studio).
+ */
+function onEventRemoved(project, callback) {
+    var _this = this;
+    return sdkUtil.subscribe(project, 'listings_events_deleted', function (data) { var data_2, data_2_1; return __awaiter(_this, void 0, void 0, function () {
+        var options, event_4, e_2_1;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 6, 7, 12]);
+                    data_2 = __asyncValues(data);
+                    _b.label = 1;
+                case 1: return [4 /*yield*/, data_2.next()];
+                case 2:
+                    if (!(data_2_1 = _b.sent(), !data_2_1.done)) return [3 /*break*/, 5];
+                    options = data_2_1.value;
+                    return [4 /*yield*/, getEvent(options.id, project)];
+                case 3:
+                    event_4 = _b.sent();
+                    if (event_4 !== null) {
+                        callback(event_4);
+                    }
+                    _b.label = 4;
+                case 4: return [3 /*break*/, 1];
+                case 5: return [3 /*break*/, 12];
+                case 6:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 12];
+                case 7:
+                    _b.trys.push([7, , 10, 11]);
+                    if (!(data_2_1 && !data_2_1.done && (_a = data_2.return))) return [3 /*break*/, 9];
+                    return [4 /*yield*/, _a.call(data_2)];
+                case 8:
+                    _b.sent();
+                    _b.label = 9;
+                case 9: return [3 /*break*/, 11];
+                case 10:
+                    if (e_2) throw e_2.error;
+                    return [7 /*endfinally*/];
+                case 11: return [7 /*endfinally*/];
+                case 12: return [2 /*return*/];
+            }
+        });
+    }); });
+}
+
+/**
+ * @license
+ * public-types.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var _a;
+/**
+ * A map of potential error codes to compare with errors thrown by
+ * vote() or validateAnswer() functions.
+ */
+exports.AnswerError = void 0;
+(function (AnswerError) {
+    AnswerError["OptionIndexOutOfRange"] = "out_of_range";
+    AnswerError["BelowMinVoteOptions"] = "below_min_vote_options";
+    AnswerError["AboveMaxVoteOptions"] = "above_max_vote_options";
+    AnswerError["AboveMaxVotesPerUser"] = "above_max_per_user";
+    AnswerError["AboveMaxVotesPerOption"] = "above_max_per_option";
+    AnswerError["VotedOnNonInteractiveElement"] = "non_interactive_element";
+    AnswerError["VotedOnClosedElement"] = "closed_element";
+    AnswerError["EmptyVote"] = "empty_vote";
+})(exports.AnswerError || (exports.AnswerError = {}));
+var AnswerErrorMessages = (_a = {},
+    _a[exports.AnswerError.OptionIndexOutOfRange] = function (max, idx) {
+        return "Options index " + idx + " is out of range [0.." + max + "]";
+    },
+    _a[exports.AnswerError.BelowMinVoteOptions] = function (min, total) {
+        return "Below min (" + min + ") vote options: " + total;
+    },
+    _a[exports.AnswerError.AboveMaxVoteOptions] = function (max, total) {
+        return "Above max (" + max + ") vote options: " + total;
+    },
+    _a[exports.AnswerError.AboveMaxVotesPerUser] = function (max, total) {
+        return "Above max (" + max + ") votes per user: " + total;
+    },
+    _a[exports.AnswerError.AboveMaxVotesPerOption] = function (max, total) {
+        return "Above max (" + max + ") votes per option: " + total;
+    },
+    _a[exports.AnswerError.VotedOnNonInteractiveElement] = function (id) {
+        return "Non interact element " + id;
+    },
+    _a[exports.AnswerError.VotedOnClosedElement] = function (id) { return "Element " + id + " is closed"; },
+    _a[exports.AnswerError.EmptyVote] = function (indices) {
+        return "Empty value for options indices: " + indices;
+    },
+    _a);
+/**
+ * The ElementState represents the potential states an element is in.
+ */
+exports.ElementState = void 0;
+(function (ElementState) {
+    /**
+     * Element is opened and active. The user can vote if
+     * element is `interactive`
+     */
+    ElementState["Opened"] = "opened";
+    /**
+     * Element is closed and the user can no longer vote for
+     * `interactive` elements
+     */
+    ElementState["Closed"] = "closed";
+})(exports.ElementState || (exports.ElementState = {}));
+
+/**
+ * @license
+ * answer.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-04-13
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * An `Answer` contains data of the user answer. Can be used to manage number of
+ * votes that the user placed for a specific option.
+ */
+var Answer = /** @class */ (function () {
+    function Answer(answers) {
+        if (answers === void 0) { answers = []; }
+        this._answers = new Map();
+        for (var _i = 0, answers_1 = answers; _i < answers_1.length; _i++) {
+            var _a = answers_1[_i], option = _a.option, value = _a.value;
+            this._answers.set(option, value);
+        }
+    }
+    Object.defineProperty(Answer.prototype, "answers", {
+        /**
+         * The array of user answers
+         */
+        get: function () {
+            return Array.from(this._answers.entries()).map(function (_a) {
+                var option = _a[0], value = _a[1];
+                return ({
+                    option: option,
+                    value: value,
+                });
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Instantiate Answer class with the provided options indices. Number
+     * of votes will be set to 1 for all options
+     *
+     * @example
+     * ```javascript
+     * // user votes for the first and fourth options
+     * const answer = Answer.fromIndices([0, 3]);
+     * ```
+     *
+     * @param indices - The array of option indices
+     */
+    Answer.fromIndices = function (indices) {
+        return new Answer(indices.map(function (option) { return ({
+            option: option,
+            value: 1,
+        }); }));
+    };
+    /**
+     * Adds a vote for the provided option index
+     *
+     * @param option - The index of the option, starting with 0
+     * @param value - The number of votes that will be placed against the option
+     */
+    Answer.prototype.set = function (option, value) {
+        this._answers.set(option, value);
+        return this;
+    };
+    /**
+     * Removes the vote for the provided option index
+     *
+     * @param option - The index of the option, starting with 0
+     */
+    Answer.prototype.remove = function (option) {
+        this._answers.delete(option);
+        return this;
+    };
+    /** @internal */
+    Answer.prototype.toJSON = function () {
+        return this.answers;
+    };
+    /** @internal */
+    Answer.fromJSON = function (value) {
+        return new Answer(JSON.parse(value));
+    };
+    return Answer;
+}());
+
+/**
+ * @license
+ * types.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Describes element types
+ */
+exports.ElementType = void 0;
+(function (ElementType) {
+    /**
+     * Data element
+     */
+    ElementType["Data"] = "data";
+    /**
+     * Poll element
+     */
+    ElementType["Poll"] = "poll";
+    /**
+     * Regular poll element
+     */
+    ElementType["RegularPoll"] = "rpoll";
+    /**
+     * Diametric poll element
+     */
+    ElementType["DiametricPoll"] = "dpoll";
+    /**
+     * Emoting poll
+     */
+    ElementType["EmotingPoll"] = "emo";
+    /**
+     * Powerbar element
+     */
+    ElementType["Powerbar"] = "powerbar";
+    /**
+     * Prediction element
+     */
+    ElementType["Prediction"] = "prediction";
+    /**
+     * Trivia element
+     */
+    ElementType["Trivia"] = "trivia";
+})(exports.ElementType || (exports.ElementType = {}));
+var ShowResultsMode;
+(function (ShowResultsMode) {
+    ShowResultsMode["OnVote"] = "vote";
+    ShowResultsMode["OnClose"] = "close";
+    ShowResultsMode["OnEventEnd"] = "event_end";
+    ShowResultsMode["Manual"] = "manual";
+    ShowResultsMode["Never"] = "never";
+    ShowResultsMode["Always"] = "always";
+})(ShowResultsMode || (ShowResultsMode = {}));
+
+/**
+ * @license
+ * element_impl.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+var ElementImpl = /** @class */ (function (_super) {
+    __extends(ElementImpl, _super);
+    function ElementImpl(data, context) {
+        var _a, _b;
+        var _this = _super.call(this) || this;
+        _this._results = null;
+        _this._userAnswer = null;
+        _this._correctOption = null;
+        _this._data = data;
+        _this._context = context;
+        _this._results = ((_a = data.data) === null || _a === void 0 ? void 0 : _a.results) || null;
+        _this._correctOption = ((_b = data.data) === null || _b === void 0 ? void 0 : _b.correct_option)
+            ? data.data.correct_option - 1
+            : null;
+        _this._state = _this.calculateState();
+        _this.unsubscribeStateHandler = sdkUtil.onTick(function () { return _this.handleState(); });
+        return _this;
+    }
+    ElementImpl.prototype.calculateState = function () {
+        if (sdkUtil.now() < this.publishedAt + this.duration) {
+            return exports.ElementState.Opened;
+        }
+        return exports.ElementState.Closed;
+    };
+    ElementImpl.prototype.handleState = function () {
+        var state = this.calculateState();
+        if (state === exports.ElementState.Closed) {
+            this.unsubscribeStateHandler();
+        }
+        if (state !== this._state) {
+            this._state = state;
+            this.emit('state', state);
+        }
+    };
+    ElementImpl.prototype.update = function (data) {
+        this._data = data;
+    };
+    ElementImpl.prototype.destroy = function () {
+        this.unsubscribeStateHandler();
+    };
+    Object.defineProperty(ElementImpl.prototype, "context", {
+        get: function () {
+            return this._context;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "id", {
+        get: function () {
+            return this._data.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "eventId", {
+        get: function () {
+            return this.context.event.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "state", {
+        get: function () {
+            return this._state;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "type", {
+        get: function () {
+            return this._data.type;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "contentType", {
+        get: function () {
+            return this._data.content_type;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "publishedAt", {
+        get: function () {
+            return this._data.published_at;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "publishedAtIso", {
+        get: function () {
+            return this._data.published_at_iso;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "updatedAt", {
+        get: function () {
+            return this._data.updated_at;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "updatedAtIso", {
+        get: function () {
+            return this._data.updated_at_iso;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "duration", {
+        get: function () {
+            return this._data.duration;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "fields", {
+        get: function () {
+            var locale = this.context.project.locale;
+            return localise(this._data.custom_fields, locale);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "interactive", {
+        get: function () {
+            return this.type !== exports.ElementType.Data;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "pollId", {
+        get: function () {
+            return this._data.data.id || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "question", {
+        get: function () {
+            var locale = this.context.project.locale;
+            if (this._data.data.question === undefined) {
+                return null;
+            }
+            return localise(this._data.data.question, locale);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "answerOptions", {
+        get: function () {
+            var locale = this.context.project.locale;
+            if (this._data.data.options === undefined) {
+                return null;
+            }
+            return localise(this._data.data.options, locale);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "minOptionsPerVote", {
+        get: function () {
+            return this._data.data.min_options_per_vote || 1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "maxOptionsPerVote", {
+        get: function () {
+            return this._data.data.max_options_per_vote || 1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "maxVotesPerOption", {
+        get: function () {
+            return this._data.data.max_votes_per_option || 1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "maxVotesPerUser", {
+        get: function () {
+            return this._data.data.max_votes_per_user || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "userAnswer", {
+        get: function () {
+            return this._userAnswer;
+        },
+        set: function (value) {
+            this._userAnswer = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "hasBeenAnswered", {
+        get: function () {
+            return this._userAnswer !== null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "showResultsMode", {
+        get: function () {
+            return this._data.data.reveal_results_mode || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "canShowResults", {
+        get: function () {
+            switch (this.showResultsMode) {
+                case ShowResultsMode.OnVote:
+                    return this.hasBeenAnswered || this.state === exports.ElementState.Closed;
+                case ShowResultsMode.OnClose:
+                    return this.state === exports.ElementState.Closed;
+                case ShowResultsMode.Manual:
+                    return this._results !== null;
+                case ShowResultsMode.OnEventEnd:
+                    return this.context.event.state === exports.EventState.Finished;
+                case ShowResultsMode.Never:
+                    return false;
+                case ShowResultsMode.Always:
+                default:
+                    return true;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "results", {
+        get: function () {
+            if (!this.canShowResults) {
+                return null;
+            }
+            return this._results;
+        },
+        set: function (results) {
+            // skip setting results if they weren't changed
+            if (JSON.stringify(results) === JSON.stringify(this.results)) {
+                return;
+            }
+            this._results = results;
+            if (this.canShowResults) {
+                this.emit('results');
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "correctOption", {
+        get: function () {
+            return this._correctOption;
+        },
+        set: function (value) {
+            this._correctOption = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "isCorrectOptionRevealed", {
+        get: function () {
+            return this._correctOption !== null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ElementImpl;
+}(sdkUtil.Emitter));
+
+/**
+ * @license
+ * calculate_percentage.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-04-07
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var calculatePercentage = function (values) {
+    // Calculate sum of all votes
+    var sum = values.reduce(function (memo, value) { return memo + value; }, 0);
+    // create array of hashes
+    var results = values.map(function (value, idx) { return ({
+        idx: idx,
+        votes: value,
+        percentage: Math.round((100 * value) / sum) || 0,
+    }); });
+    // Sum them all up - this can be less, equal or greater than a 100%
+    var total = results.reduce(function (memo, _a) {
+        var percentage = _a.percentage;
+        return memo + percentage;
+    }, 0);
+    total = total || 100;
+    // Calculate number of percent that we are missing or that we need to lose
+    var delta = 100 - total;
+    var sign = delta >= 0 ? 1 : -1;
+    // Order all options by number of votes
+    results.sort(function (a, b) {
+        var result = sign * (b.votes - a.votes);
+        if (result !== 0) {
+            return result;
+        }
+        return sign * (a.idx - b.idx);
+    });
+    // If we have percents to lose then take one percent off lowest options
+    // If we are missing percents then add one percent to highest options
+    var i = 0;
+    while (delta !== 0) {
+        if (results[i].votes > 0) {
+            results[i].percentage += sign;
+            delta -= sign;
+        }
+        i++;
+    }
+    // Restore options order
+    results.sort(function (a, b) { return a.idx - b.idx; });
+    return results.map(function (item) { return item.percentage; });
+};
+
+/**
+ * @license
+ * factory.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var elements = new Map();
+var storageAvailable = sdkUtil.checkAvailability();
+function buildElement(options, context) {
+    if (elements.has(options.id)) {
+        return elements.get(options.id);
+    }
+    var element = new ElementImpl(options, context);
+    restoreAnswer(element);
+    elements.set(element.id, element);
+    return element;
+}
+function getElementByPolld(pollId) {
+    return Array.from(elements.values()).find(function (element) { return element.pollId === pollId; });
+}
+var configureEventMemoized = sdkUtil.memoizePromise(function (event) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                event.on('history', handleEventHistory);
+                if (event.history !== null) {
+                    handleEventHistory(event.history);
+                }
+                return [4 /*yield*/, configureConnect(event.context.sdk.options.host)];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, init(event)];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); }, function (event) { return event.id; });
+function configureEvent(event) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, configureEventMemoized(event)];
+        });
+    });
+}
+var configureConnectMemoized = sdkUtil.memoizePromise(function (host) { return __awaiter(void 0, void 0, void 0, function () {
+    var connect;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, getConnect(host)];
+            case 1:
+                connect = _a.sent();
+                connect.on('message', handleConnectMessage);
+                return [2 /*return*/];
+        }
+    });
+}); }, function (host) { return host; });
+function configureConnect(host) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, configureConnectMemoized(host)];
+        });
+    });
+}
+function handleConnectMessage(message) {
+    return __awaiter(this, void 0, void 0, function () {
+        var klass, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    klass = message.klass;
+                    _a = klass;
+                    switch (_a) {
+                        case exports.Klass.Create: return [3 /*break*/, 1];
+                        case exports.Klass.Revoke: return [3 /*break*/, 3];
+                        case exports.Klass.Feedback: return [3 /*break*/, 5];
+                        case exports.Klass.Reveal: return [3 /*break*/, 7];
+                    }
+                    return [3 /*break*/, 9];
+                case 1: return [4 /*yield*/, handleCreateMessage(message)];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 9];
+                case 3: return [4 /*yield*/, handleRevokeMessage(message)];
+                case 4:
+                    _b.sent();
+                    return [3 /*break*/, 9];
+                case 5: return [4 /*yield*/, handleFeedbackMessage(message)];
+                case 6:
+                    _b.sent();
+                    return [3 /*break*/, 9];
+                case 7: return [4 /*yield*/, handleRevealMessage(message)];
+                case 8:
+                    _b.sent();
+                    return [3 /*break*/, 9];
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleCreateMessage(message) {
+    return __awaiter(this, void 0, void 0, function () {
+        var id, data, options, event, element, context, element;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    id = message.id, data = message.data;
+                    options = JSON.parse(data[0]);
+                    return [4 /*yield*/, getEvent(id)];
+                case 1:
+                    event = _a.sent();
+                    if (event === null) {
+                        return [2 /*return*/];
+                    }
+                    if (elements.has(options.id)) {
+                        element = elements.get(options.id);
+                        if (options.updated_at > element.updatedAt) {
+                            element.update(options);
+                            event.emit('update', element);
+                        }
+                    }
+                    else {
+                        context = __assign(__assign({}, event.context), { event: event });
+                        element = buildElement(options, context);
+                        event.emit('publish', element);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function handleRevokeMessage(message) {
+    var data = message.data;
+    var id = JSON.parse(data[0]).id;
+    if (!elements.has(id)) {
+        return;
+    }
+    var element = elements.get(id);
+    elements.delete(id);
+    element.destroy();
+    element.context.event.emit('revoke', element);
+}
+function handleFeedbackMessage(message) {
+    return __awaiter(this, void 0, void 0, function () {
+        var data, pollId, counters, element, votes, percentages, results;
+        return __generator(this, function (_a) {
+            data = message.data;
+            pollId = +data[0];
+            counters = data[3];
+            element = getElementByPolld(pollId);
+            if (!element) {
+                return [2 /*return*/];
+            }
+            votes = counters.split(':').map(function (value) { return +value; });
+            percentages = calculatePercentage(votes);
+            results = votes.map(function (item, idx) { return ({
+                percentage: percentages[idx],
+                votes: item,
+            }); });
+            element.results = results;
+            return [2 /*return*/];
+        });
+    });
+}
+function handleRevealMessage(message) {
+    var data = message.data;
+    // Reveal message format:
+    //
+    // [pollId, index (1-based), timestamp]
+    var pollId = +data[0];
+    var correctOption = +data[1] - 1;
+    var element = getElementByPolld(pollId);
+    if (!element) {
+        return;
+    }
+    element.correctOption = correctOption;
+    element.context.event.emit('update', element);
+}
+function handleEventHistory(history) {
+    return __awaiter(this, void 0, void 0, function () {
+        var event, context, _i, _a, snapshot;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (history.timeline.length === 0) {
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, getEvent(history.config.id)];
+                case 1:
+                    event = _b.sent();
+                    if (event === null) {
+                        return [2 /*return*/];
+                    }
+                    context = __assign(__assign({}, event.context), { event: event });
+                    for (_i = 0, _a = history.timeline; _i < _a.length; _i++) {
+                        snapshot = _a[_i];
+                        if (!elements.has(snapshot.id)) {
+                            buildElement(snapshot, context);
+                        }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function sendAnswer(element, userAnswer) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, project, event, connect, answer;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = element.context, project = _a.project, event = _a.event;
+                    return [4 /*yield*/, getConnect(project.host)];
+                case 1:
+                    connect = _b.sent();
+                    answer = userAnswer.answers
+                        .map(function (_a) {
+                        var option = _a.option, value = _a.value;
+                        return [option + 1, value];
+                    })
+                        .flat()
+                        .join(':');
+                    connect.sendVote(event.id, element.pollId, answer);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function storeAnswer(element, userAnswer) {
+    try {
+        element.userAnswer = userAnswer;
+        if (storageAvailable) {
+            // Can throw a "QuotaExceededError" DOMException exception
+            // if the quota has been exceeded.
+            sdkUtil.setItem("element_" + element.id + "_vote", JSON.stringify(userAnswer));
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            console.warn("Can't store user answer: " + err.message);
+        }
+    }
+}
+function restoreAnswer(element) {
+    if (storageAvailable) {
+        var userAnswer = sdkUtil.getItem("element_" + element.id + "_vote");
+        if (userAnswer !== null) {
+            element.userAnswer = Answer.fromJSON(userAnswer);
+        }
+    }
+}
+
+/**
+ * @license
+ * api.ts
+ * interact-kit
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+var getElementMemoized = sdkUtil.memoizePromise(function (event, id) { return __awaiter(void 0, void 0, void 0, function () {
+    var element;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, configureEvent(event)];
+            case 1:
+                _a.sent();
+                element = Array.from(elements.values()).find(function (el) { return el.id === id; });
+                return [2 /*return*/, element || null];
+        }
+    });
+}); }, function (event, id) { return id; });
+/**
+ * Returns an element of a specific event by its id
+ */
+function getElement(event, id) {
+    return getElementMemoized(event, id);
+}
+/**
+ * @internal
+ */
+var getElementsMemoized = sdkUtil.memoizePromise(function (event) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, configureEvent(event)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/, (Array.from(elements.values())
+                        // Get elements which belong only to the provided event
+                        .filter(function (element) { return element.eventId === event.id; })
+                        // Sort elements so the most recent event is first, and the oldest is last
+                        .sort(function (a, b) { return a.publishedAt - b.publishedAt; }))];
+        }
+    });
+}); }, function (event) { return event.id; }, {
+    clearOnResolve: true,
+});
+/**
+ * Returns the list of elements published in a specific event
+ */
+function getElements(event) {
+    return getElementsMemoized(event);
+}
+function answer(element) {
+    var value = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        value[_i - 1] = arguments[_i];
+    }
+    var answerObj = answerParametersToAnswer.apply(void 0, value);
+    validateAnswer.apply(void 0, __spreadArray([element], value));
+    sendAnswer(element, answerObj);
+    storeAnswer(element, answerObj);
+}
+function validateAnswer(element) {
+    var value = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        value[_i - 1] = arguments[_i];
+    }
+    var answerObj = answerParametersToAnswer.apply(void 0, value);
+    var answers = answerObj.answers;
+    var indices = answers.map(function (_a) {
+        var option = _a.option;
+        return option;
+    });
+    var values = answers.map(function (_a) {
+        var v = _a.value;
+        return v;
+    });
+    var maxIndex = Math.max.apply(Math, indices);
+    var maxValue = Math.max.apply(Math, values);
+    var sumValues = values.reduce(function (memo, val) { return memo + val; }, 0);
+    var emptyIndices = values.reduce(function (memo, val, idx) {
+        if (val === 0) {
+            memo.push(indices[idx]);
+        }
+        return memo;
+    }, []);
+    if (!element.interactive) {
+        throw sdkUtil.createError(exports.AnswerError.VotedOnNonInteractiveElement, AnswerErrorMessages, element.id);
+    }
+    if (element.state === exports.ElementState.Closed) {
+        throw sdkUtil.createError(exports.AnswerError.VotedOnClosedElement, AnswerErrorMessages, element.id);
+    }
+    if (maxIndex > element.answerOptions.length - 1) {
+        throw sdkUtil.createError(exports.AnswerError.OptionIndexOutOfRange, AnswerErrorMessages, element.answerOptions.length - 1, maxIndex);
+    }
+    if (element.minOptionsPerVote !== null &&
+        indices.length < element.minOptionsPerVote) {
+        throw sdkUtil.createError(exports.AnswerError.BelowMinVoteOptions, AnswerErrorMessages, element.minOptionsPerVote, indices.length);
+    }
+    if (element.maxOptionsPerVote !== null &&
+        indices.length > element.maxOptionsPerVote) {
+        throw sdkUtil.createError(exports.AnswerError.AboveMaxVoteOptions, AnswerErrorMessages, element.maxOptionsPerVote, indices.length);
+    }
+    if (sumValues > element.maxVotesPerUser) {
+        throw sdkUtil.createError(exports.AnswerError.AboveMaxVotesPerUser, AnswerErrorMessages, element.maxVotesPerUser, sumValues);
+    }
+    if (maxValue > element.maxVotesPerOption) {
+        throw sdkUtil.createError(exports.AnswerError.AboveMaxVotesPerOption, AnswerErrorMessages, element.maxVotesPerOption, maxValue);
+    }
+    if (emptyIndices.length > 0) {
+        throw sdkUtil.createError(exports.AnswerError.EmptyVote, AnswerErrorMessages, emptyIndices.join(', '));
+    }
+}
+function answerParametersToAnswer() {
+    var value = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        value[_i] = arguments[_i];
+    }
+    var answerValues = value.flat();
+    if (isAnswer(answerValues[0])) {
+        return answerValues[0];
+    }
+    if (isNumbers(answerValues)) {
+        return Answer.fromIndices(answerValues);
+    }
+    if (isAnswerValues(answerValues)) {
+        return new Answer(answerValues);
+    }
+    return new Answer();
+}
+function isAnswer(value) {
+    return value instanceof Answer;
+}
+function isAnswerValues(value) {
+    return value.every(function (v) {
+        return Object.prototype.hasOwnProperty.call(v, 'option') &&
+            Object.prototype.hasOwnProperty.call(v, 'value');
+    });
+}
+function isNumbers(value) {
+    return value.every(function (v) { return typeof v === 'number'; });
+}
+/**
+ * Adds an observer for when {@link InteractElement.results | element results}
+ * are updated
+ */
+function onElementResults(element, callback) {
+    return sdkUtil.subscribe(element, 'results', callback);
+}
+/**
+ * Adds an observer for when {@link InteractElement.state | element state}
+ * changed
+ */
+function onElementStateChanged(element, callback) {
+    return sdkUtil.subscribe(element, 'state', callback);
+}
+/**
+ * Adds an observer for when {@link InteractElement.fields | element's data}
+ * is updated
+ */
+function onElementUpdated(event, callback) {
+    configureEvent(event);
+    return sdkUtil.subscribe(event, 'update', callback);
+}
+/**
+ * Adds an observer for when a new element is published
+ */
+function onElementPublished(event, callback) {
+    configureEvent(event);
+    return sdkUtil.subscribe(event, 'publish', function (element) {
+        if (event.initState === InitState.Initialised) {
+            callback(element);
+        }
+    });
+}
+/**
+ * Adds an observer for when an element is revoked
+ */
+function onElementRevoked(event, callback) {
+    configureEvent(event);
+    return sdkUtil.subscribe(event, 'revoke', callback);
+}
+
+exports.Answer = Answer;
+exports.ElementImpl = ElementImpl;
+exports.EventImpl = EventImpl;
+exports.ProjectImpl = ProjectImpl;
+exports.answer = answer;
+exports.fetchListings = fetchListings;
+exports.getConnect = getConnect;
+exports.getConnectionHealth = getConnectionHealth;
+exports.getElement = getElement;
+exports.getElementMemoized = getElementMemoized;
+exports.getElements = getElements;
+exports.getElementsMemoized = getElementsMemoized;
+exports.getEvent = getEvent;
+exports.getEventMemoized = getEventMemoized;
+exports.getEvents = getEvents;
+exports.getEventsMemoized = getEventsMemoized;
+exports.getProject = getProject;
+exports.getProjectMemoized = getProjectMemoized;
+exports.login = login;
+exports.onConnectionHealthState = onConnectionHealthState;
+exports.onElementPublished = onElementPublished;
+exports.onElementResults = onElementResults;
+exports.onElementRevoked = onElementRevoked;
+exports.onElementStateChanged = onElementStateChanged;
+exports.onElementUpdated = onElementUpdated;
+exports.onEventAdded = onEventAdded;
+exports.onEventPublished = onEventPublished;
+exports.onEventRemoved = onEventRemoved;
+exports.onEventState = onEventState;
+exports.onEventUpdated = onEventUpdated;
+exports.onProjectFieldsUpdated = onProjectFieldsUpdated;
+exports.onProjectListingsUpdated = onProjectListingsUpdated;
+exports.validateAnswer = validateAnswer;
+//# sourceMappingURL=index.cjs.js.map