@monterosa/sdk-interact-kit 2.0.0-rc.2 → 2.0.0-rc.3

package/dist/index.cjs

@@ -0,0 +1,2095 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkUtil = require('@monterosa/sdk-util');
+var sdkConnectKit = require('@monterosa/sdk-connect-kit');
+var sdkCore = require('@monterosa/sdk-core');
+var sdkInteractInterop = require('@monterosa/sdk-interact-interop');
+var sdkStorageKit = require('@monterosa/sdk-storage-kit');
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. 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";
+    Klass["SubsCounter"] = "subscounter";
+})(exports.Klass || (exports.Klass = {}));
+/**
+ * @internal
+ */
+exports.Channel = void 0;
+(function (Channel) {
+    Channel["Poll"] = "p";
+    Channel["Live"] = "l";
+})(exports.Channel || (exports.Channel = {}));
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+class ConnectImpl extends sdkUtil.Emitter {
+    constructor(host) {
+        super();
+        this.host = host;
+        this._state = exports.State.Ok;
+        this._enmasse = null;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(state) {
+        if (state === this._state) {
+            return;
+        }
+        this._state = state;
+        this.emit('state', this._state);
+    }
+    get enmasse() {
+        if (this._enmasse === null) {
+            throw new Error('Connect is not initialised, init() method should be called first.');
+        }
+        return this._enmasse;
+    }
+    set enmasse(enmasse) {
+        this._enmasse = enmasse;
+    }
+    async init() {
+        this.enmasse = await sdkConnectKit.getConnect(this.host);
+        this.enmasse.on('message', this.handleMessage.bind(this));
+        this.enmasse.on('state', this.handleState.bind(this));
+    }
+    async connect() {
+        await sdkConnectKit.connect(this.enmasse);
+    }
+    disconnect() {
+        sdkConnectKit.disconnect(this.enmasse);
+    }
+    async subscribeProject(id) {
+        await sdkConnectKit.subscribe(this.enmasse, `${exports.Channel.Live}-${id}`);
+    }
+    unsubscribeProject(id) {
+        sdkConnectKit.unsubscribe(this.enmasse, `${exports.Channel.Live}-${id}`);
+    }
+    async subscribeEvent(id) {
+        await Promise.all([
+            sdkConnectKit.subscribe(this.enmasse, `${exports.Channel.Live}-${id}`),
+            sdkConnectKit.subscribe(this.enmasse, `${exports.Channel.Poll}-${id}`),
+        ]);
+    }
+    unsubscribeEvent(id) {
+        sdkConnectKit.unsubscribe(this.enmasse, `${exports.Channel.Live}-${id}`);
+        sdkConnectKit.unsubscribe(this.enmasse, `${exports.Channel.Poll}-${id}`);
+    }
+    sendVote(eventId, pollId, answer) {
+        sdkConnectKit.send(this.enmasse, `${exports.Channel.Poll}-${eventId}`, exports.Klass.Vote, [
+            pollId,
+            answer,
+            '',
+        ]);
+    }
+    handleMessage(message) {
+        const { klass, body: data, channel } = message;
+        const id = channel.substring(channel.indexOf('-') + 1);
+        this.emit('message', {
+            id,
+            klass,
+            data,
+        });
+    }
+    handleState(state, ...args) {
+        switch (state) {
+            case sdkConnectKit.ConnState.Disconnected:
+                this.state = exports.State.Error;
+                break;
+            case sdkConnectKit.ConnState.Connecting: {
+                const [attempt] = args;
+                if (attempt > 1) {
+                    this.state = exports.State.Error;
+                }
+                break;
+            }
+            case sdkConnectKit.ConnState.Connected:
+                this.state = exports.State.Ok;
+                break;
+        }
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const getConnectMemoized = sdkUtil.memoizePromise(async (host) => {
+    const connect = new ConnectImpl(host);
+    await connect.init();
+    await connect.connect();
+    return connect;
+}, (host) => host);
+/**
+ * @internal
+ */
+function getConnect(host) {
+    return getConnectMemoized(host);
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. 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 explicitly {@link @monterosa/sdk-connect-kit#disconnect() | disconnected}
+     */
+    ConnectionHealthState["Error"] = "error";
+})(exports.ConnectionHealthState || (exports.ConnectionHealthState = {}));
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+class ConnectionHealthImpl extends sdkUtil.Emitter {
+    constructor(connect) {
+        super();
+        this.connect = connect;
+        this._state = exports.ConnectionHealthState.Ok;
+        this.connect.on('state', this.handleState.bind(this));
+    }
+    get state() {
+        return this._state;
+    }
+    set state(state) {
+        this._state = state;
+        this.emit('state', state);
+    }
+    handleState() {
+        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;
+        }
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022-2024 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const getConnectionHealthMemoized = sdkUtil.memoizePromise(async (sdk) => {
+    const connect = await getConnect(sdk.options.host);
+    const connectionHealth = new ConnectionHealthImpl(connect);
+    return connectionHealth;
+}, (sdk) => sdk.options.host);
+/**
+ * Returns {@link ConnectionHealth | connection health} instance
+ *
+ * @param sdk - The SDK instance to monitor
+ * @returns The connection health instance.
+ */
+function getConnectionHealth(sdk = sdkCore.getSdk()) {
+    return getConnectionHealthMemoized(sdk);
+}
+/**
+ * Adds an observer for when
+ * {@link ConnectionHealth | connection health state} changed
+ *
+ * @param connectionHealth - The instance to observe
+ * @param callback - Called with the new state
+ */
+function onConnectionHealthState(connectionHealth, callback) {
+    return sdkUtil.subscribe(connectionHealth, 'state', callback);
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const DEFAULT_IGNORE_TIME = 30;
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. 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
+    const 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,
+    const languageTags = [
+        // where the first item is the user's default language
+        navigator.language,
+        // and others are the user's preferred languages
+        ...navigator.languages,
+    ];
+    // firstly, trying to check if one of languages tag
+    // has a full match with passed locales
+    for (const tag of languageTags) {
+        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 (const tag of languageTags) {
+        const userLang = tagToLanguage(tag);
+        for (const locale of locales) {
+            const 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
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+class ProjectImpl extends sdkUtil.Emitter {
+    constructor(options, context) {
+        super();
+        this.eventsChecksum = null;
+        this.id = options.id;
+        this.host = options.host;
+        this._context = context;
+    }
+    get context() {
+        return this._context;
+    }
+    get embedUrl() {
+        var _a;
+        return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.embed;
+    }
+    get uuid() {
+        var _a;
+        return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.uuid;
+    }
+    get events() {
+        var _a;
+        return ((_a = this._listings) === null || _a === void 0 ? void 0 : _a.events) || [];
+    }
+    get listings() {
+        return this._listings;
+    }
+    set listings(newListings) {
+        const createdEvents = this._calculateCreatedEvents(newListings);
+        const updatedEvents = this._calculateUpdatedEvents(newListings);
+        const deletedEvents = this._calculateDeletedEvents(newListings);
+        this._listings = Object.assign({}, newListings);
+        this._updateLocales(newListings);
+        this._updateEventsChecksum(newListings);
+        this._emitListingsEvents(createdEvents, updatedEvents, deletedEvents);
+    }
+    /**
+     * Calculates events that were created (present in new listings but not in old)
+     */
+    _calculateCreatedEvents(newListings) {
+        if (!this._listings) {
+            return [];
+        }
+        return newListings.events.filter(({ id }) => !this._listings.events.some((event) => id === event.id));
+    }
+    /**
+     * Calculates events that were updated (present in old listings and new,
+     * but with different digest)
+     */
+    _calculateUpdatedEvents(newListings) {
+        if (!this._listings) {
+            return [];
+        }
+        return newListings.events.filter((event) => {
+            // find event data in new listings
+            const existingEvent = this._listings.events.find(({ id }) => event.id === id);
+            // return true if event data is found and digest is different
+            return existingEvent && event.digest !== existingEvent.digest;
+        });
+    }
+    /**
+     * Calculates events that were deleted (present in old listings but not in new)
+     */
+    _calculateDeletedEvents(newListings) {
+        if (!this._listings) {
+            return [];
+        }
+        return this._listings.events.filter(({ id }) => !newListings.events.some((event) => id === event.id));
+    }
+    /**
+     * Processes and updates locales from project listings
+     */
+    _updateLocales(newListings) {
+        this._locales = newListings.project.locales
+            // clone the array first
+            .map((locale) => (Object.assign({}, locale)))
+            // sort an array so that the default locale is the first
+            .sort((locale) => (locale.default ? -1 : 0))
+            // return only keys of the locales
+            .map((locale) => locale.key);
+        this._locale = getLocale(this._locales);
+    }
+    /**
+     * Updates the events checksum based on new listings
+     */
+    _updateEventsChecksum(newListings) {
+        this.eventsChecksum = sdkUtil.checksum(newListings.events.map((event) => event.digest).join(''));
+    }
+    /**
+     * Emits events based on created and deleted events
+     */
+    _emitListingsEvents(createdEvents, updatedEvents, deletedEvents) {
+        const hasCreatedEvents = createdEvents.length > 0;
+        const hasDeletedEvents = deletedEvents.length > 0;
+        const hasUpdatedEvents = updatedEvents.length > 0;
+        const hasChanges = hasCreatedEvents || hasDeletedEvents || hasUpdatedEvents;
+        if (hasCreatedEvents) {
+            this.emit('listings_events_created', createdEvents);
+        }
+        if (hasDeletedEvents) {
+            this.emit('listings_events_deleted', deletedEvents);
+        }
+        if (hasUpdatedEvents) {
+            this.emit('listings_events_updated', updatedEvents);
+        }
+        if (hasChanges) {
+            this.emit('listings');
+        }
+    }
+    get isLocalisationSupported() {
+        var _a;
+        return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.is_localisation_supported;
+    }
+    get locale() {
+        return this._locale;
+    }
+    set locale(locale) {
+        if (!this.locales.includes(locale)) {
+            throw new Error(`Unknown locale name "${locale}"`);
+        }
+        this._locale = locale;
+    }
+    get locales() {
+        return this._locales;
+    }
+    get fields() {
+        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 fields(value) {
+        const isUpdate = typeof this._fields !== 'undefined';
+        this._fields = Object.assign({}, value);
+        if (isUpdate) {
+            this.emit('updated');
+        }
+    }
+    get extensions() {
+        var _a;
+        return (_a = this._listings) === null || _a === void 0 ? void 0 : _a.assets;
+    }
+    get historyIgnore() {
+        var _a;
+        const value = (_a = this._listings) === null || _a === void 0 ? void 0 : _a.project.history_ignore;
+        if (value && value > 0) {
+            return value;
+        }
+        return DEFAULT_IGNORE_TIME;
+    }
+    // TODO: must be implemented
+    // eslint-disable-next-line
+    delete() { }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const projects = new Map();
+const connects = new Map();
+async function buildProject(options, context) {
+    const { id, host } = options;
+    if (projects.has(id)) {
+        return projects.get(id);
+    }
+    /**
+     * Create "bare" instance of the project. Until listings and settings are
+     * loaded it can't be used
+     */
+    const 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);
+    /**
+     * Waiting when the listings and the project settings come and we would be
+     * able to populate the project instance
+     */
+    try {
+        const setup = await setupConnect(host);
+        await setup.subscribeProject(id);
+        /**
+         * 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.`);
+        }
+        project.fields = await sdkInteractInterop.fetchSettings(project.host, project.id);
+        return project;
+    }
+    catch (err) {
+        /**
+         * 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)) {
+            const 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;
+    }
+}
+async function setupConnect(host) {
+    if (connects.has(host)) {
+        return connects.get(host);
+    }
+    const connect = await getConnect(host);
+    connect.on('message', handleConnectMessage$1);
+    return connect;
+}
+async function handleConnectMessage$1(message) {
+    const { id, klass, data } = message;
+    const project = projects.get(id);
+    if (!project) {
+        return;
+    }
+    switch (klass) {
+        case exports.Klass.Listings:
+            await handleListings(project, data[0]);
+            break;
+    }
+}
+async function handleListings(project, data) {
+    var _a;
+    const listings = JSON.parse(data);
+    const newDigest = listings.project.app_settings_digest;
+    const oldDigest = (_a = project.listings) === null || _a === void 0 ? void 0 : _a.project.app_settings_digest;
+    project.listings = listings;
+    try {
+        if (oldDigest !== undefined && newDigest !== oldDigest) {
+            project.fields = await sdkInteractInterop.fetchSettings(project.host, project.id);
+        }
+    }
+    catch (_b) {
+        console.warn(`Unable to fetch project ${project.id} settings`);
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022-2024 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+const getProjectMemoized = sdkUtil.memoizePromise(async (sdk) => {
+    const project = await buildProject({
+        id: sdk.options.projectId,
+        host: sdk.options.host,
+    }, {
+        sdk,
+    });
+    return project;
+}, (sdk) => sdk.options.projectId);
+/**
+ * Returns {@link InteractProject | Project instance} associated
+ * with the
+ * {@link @monterosa/sdk-core#MonterosaSdk | configured SDK}
+ *
+ * @param sdk - The SDK instance. Defaults to the default SDK.
+ * @returns The Project instance.
+ */
+function getProject(sdk = sdkCore.getSdk()) {
+    return getProjectMemoized(sdk);
+}
+/**
+ * Adds an observer for when
+ * {@link InteractProject | Project fields} are updated
+ *
+ * @param project - The Project to observe
+ * @param callback - Called when Project fields change
+ */
+function onProjectFieldsUpdated(project, callback) {
+    return sdkUtil.subscribe(project, 'updated', callback);
+}
+
+/******************************************************************************
+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.
+***************************************************************************** */
+
+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 __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); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+async function fetchHistory(host, id) {
+    const response = await fetch(`https://${host}/events/${id.substring(0, 2)}/${id}/history.json`);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch event ${id} history`);
+    }
+    const data = await response.json();
+    return data;
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. 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}
+     * less than the {@link @monterosa/sdk-util#now | current time}.
+     */
+    EventState["Upcoming"] = "upcoming";
+    /**
+     * The Event is in the `active` state when its {@link InteractEvent | startAt}
+     * equal or more than the {@link @monterosa/sdk-util#now | current time} and less than the
+     * {@link InteractEvent | endAt}.
+     */
+    EventState["Active"] = "active";
+    /**
+     * @internal
+     */
+    EventState["Prolonged"] = "prolonged";
+    /**
+     * The Event is in the `finished` state when its {@link InteractEvent | endAt}
+     * equal or more than the {@link @monterosa/sdk-util#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
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+class EventImpl extends sdkUtil.Emitter {
+    constructor(data, context) {
+        super();
+        this._initState = InitState.Uninitialised;
+        this._history = null;
+        this._data = data;
+        this._context = context;
+        this._state = this.calculateState();
+        this._internalState = this.calculateInternalState();
+        this.boundHandleState = this.handleState.bind(this);
+        this.boundHandleInternalState = this.handleInternalState.bind(this);
+        this.boundHandleEventsUpdated = this.handleEventsUpdated.bind(this);
+        this.unsubscribeStateHandler = sdkUtil.onTick(this.boundHandleState);
+        this.unsubscribeInternalStateHandler = sdkUtil.onTick(this.boundHandleInternalState);
+        this.unsubscribeListingsHandler = sdkUtil.subscribe(this.context.project, 'listings_events_updated', this.boundHandleEventsUpdated);
+    }
+    calculateState() {
+        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;
+    }
+    calculateInternalState() {
+        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;
+    }
+    handleState() {
+        const state = this.calculateState();
+        if (state === exports.EventState.Finished) {
+            this.unsubscribeStateHandler();
+        }
+        if (state !== this._state) {
+            this._state = state;
+            this.emit('state', state);
+        }
+    }
+    handleInternalState() {
+        const internalState = this.calculateInternalState();
+        if (internalState === exports.EventState.Finished) {
+            this.unsubscribeInternalStateHandler();
+        }
+        if (internalState !== this._internalState) {
+            this._internalState = internalState;
+            this.emit('internal_state', internalState);
+        }
+    }
+    handleEventsUpdated(events) {
+        const data = events.find(({ id }) => id === this.id);
+        if (data && this._data.digest !== data.digest) {
+            this._data = data;
+            // Forcing state recalculation to ensure the event is in the correct state
+            this.handleState();
+            this.handleInternalState();
+            this.emit('updated');
+        }
+    }
+    /** @internal */
+    destroy() {
+        this.unsubscribeStateHandler();
+        this.unsubscribeInternalStateHandler();
+        this.unsubscribeListingsHandler();
+    }
+    get context() {
+        return this._context;
+    }
+    get id() {
+        return this._data.id;
+    }
+    get name() {
+        return this._data.name;
+    }
+    get startAt() {
+        return this._data.start_at;
+    }
+    get startAtIso() {
+        return this._data.start_at_iso;
+    }
+    get endAt() {
+        return this._data.end_at;
+    }
+    get endAtIso() {
+        return this._data.end_at_iso;
+    }
+    get duration() {
+        return this._data.duration;
+    }
+    get fields() {
+        const { locale } = this.context.project;
+        return localise(this._data.custom_fields, locale);
+    }
+    get state() {
+        return this._state;
+    }
+    get internalState() {
+        return this._internalState;
+    }
+    get initState() {
+        return this._initState;
+    }
+    set initState(state) {
+        this._initState = state;
+    }
+    get history() {
+        return this._history;
+    }
+    set history(value) {
+        this._history = value;
+        this.emit('history', value);
+    }
+    get canSubscribe() {
+        return (this._internalState === exports.EventState.Active ||
+            this._internalState === exports.EventState.Prolonged);
+    }
+    get canLoadHistory() {
+        return sdkUtil.now() >= this.startAt + this.context.project.historyIgnore;
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const events = new Map();
+const healthListeners = new Map();
+function buildEvent(options, context) {
+    if (events.has(options.id)) {
+        return events.get(options.id);
+    }
+    const event = new EventImpl(options, context);
+    event.on('internal_state', handleEventInternalState.bind(event));
+    events.set(options.id, event);
+    return event;
+}
+async function init(event) {
+    if (event.initState === InitState.Initialising) {
+        return Promise.reject(new Error("can't initialise event, event is already being initialised"));
+    }
+    if (event.initState === InitState.Initialised) {
+        return Promise.reject(new Error("can't initialise event, event is already initialised"));
+    }
+    event.initState = InitState.Initialising;
+    if (event.canLoadHistory && event.history === null) {
+        const history = await fetchHistory(event.context.project.host, event.id);
+        event.history = history;
+    }
+    if (event.canSubscribe) {
+        await subscribe(event);
+    }
+    await listenConnHealth(event);
+    event.initState = InitState.Initialised;
+    return Promise.resolve();
+}
+async function subscribe(event) {
+    if (!event.canSubscribe) {
+        return Promise.reject(new Error("Event can't be subscribed"));
+    }
+    const connect = await getConnect(event.context.project.host);
+    await connect.subscribeEvent(event.id);
+    return Promise.resolve();
+}
+async function unsubscribe(event) {
+    const connect = await getConnect(event.context.project.host);
+    await connect.unsubscribeEvent(event.id);
+    return Promise.resolve();
+}
+async function listenConnHealth(event) {
+    const { project } = event.context;
+    if (healthListeners.has(project.id)) {
+        return;
+    }
+    const connect = await getConnect(project.host);
+    if (connect.enmasse !== null) {
+        const unsub = sdkConnectKit.onConnected(connect.enmasse, handleEnmasseConnected);
+        healthListeners.set(project.id, unsub);
+    }
+}
+async function handleEventInternalState(state) {
+    if (state === exports.EventState.Finished) {
+        await unsubscribe(this);
+    }
+}
+async function handleEnmasseConnected() {
+    var _a, e_1, _b, _c;
+    try {
+        for (var _d = true, _e = __asyncValues(Array.from(events.values())), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+            _c = _f.value;
+            _d = false;
+            try {
+                const event = _c;
+                if (event.initState === InitState.Initialised) {
+                    const history = await fetchHistory(event.context.project.host, event.id);
+                    event.history = history;
+                }
+            }
+            finally {
+                _d = true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+
+/**
+ * @internal
+ */
+const getEventsMemoized = sdkUtil.memoizePromise(async (project) => {
+    if (project === undefined) {
+        project = await getProject();
+    }
+    const context = Object.assign(Object.assign({}, project.context), { project });
+    return (project.events
+        // Calling builder function that creates an Event instance.
+        // Existing Event will be returned if it already exists in the cache
+        .map((data) => buildEvent(data, context))
+        // Sort Events so the oldest Event is first, and the most recent is last
+        .sort((a, b) => a.startAt - b.startAt));
+}, 
+/**
+ * Resolver function that determines the cache key for memoization.
+ *
+ * The cache key is used to determine whether a cached result can be reused.
+ * It prioritizes `eventsChecksum` over `id` to ensure cache invalidation when
+ * the events list changes, even if the project ID remains the same.
+ *
+ * @param project - Optional project instance. If not provided, attempts to
+ *   resolve using the default project from the SDK.
+ * @returns A cache key string derived from the project's checksum/id or SDK projectId
+ */
+(project) => {
+    var _a, _b;
+    // If project is provided, use its checksum (if available) or id as cache key
+    if (project !== undefined) {
+        return (_a = project.eventsChecksum) !== null && _a !== void 0 ? _a : project.id;
+    }
+    // If no project provided, try to get default project from SDK
+    const sdk = sdkCore.getSdk();
+    const defaultProject = projects.get(sdk.options.projectId);
+    // Use default project's checksum/id if available
+    if (defaultProject) {
+        return (_b = defaultProject.eventsChecksum) !== null && _b !== void 0 ? _b : defaultProject.id;
+    }
+    // Fallback to SDK's projectId option
+    return sdk.options.projectId;
+});
+/**
+ * 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.
+ * @returns A promise that resolves to an array of Events.
+ */
+function getEvents(project) {
+    return getEventsMemoized(project);
+}
+/**
+ * @internal
+ */
+const getEventMemoized = sdkUtil.memoizePromise(async (id, project) => {
+    if (events.has(id)) {
+        return events.get(id);
+    }
+    if (project === undefined) {
+        project = await getProject();
+    }
+    const context = Object.assign(Object.assign({}, project.context), { project });
+    const data = project.events.find((eventData) => eventData.id === id);
+    if (data !== undefined) {
+        const event = buildEvent(data, context);
+        if (event.canLoadHistory) {
+            const history = await fetchHistory(project.host, id);
+            event.history = history;
+        }
+        return event;
+    }
+    try {
+        const history = await fetchHistory(project.host, id);
+        const event = buildEvent(history.config, context);
+        event.history = history;
+        return event;
+    }
+    catch (err) {
+        return null;
+    }
+}, (id) => 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 The Event associated with the provided id,
+ *   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 | Event state} changed
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the new state
+ */
+function onEventState(event, callback) {
+    return sdkUtil.subscribe(event, 'state', callback);
+}
+/**
+ * Adds an observer for when Event's data changed
+ *
+ * @param event - The Event to observe
+ * @param callback - Called when the Event data changes
+ */
+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.
+ *
+ * @param project - The Project to observe
+ * @param callback - Called with the added Event
+ */
+function onEventAdded(project, callback) {
+    return sdkUtil.subscribe(project, 'listings_events_created', async (data) => {
+        var _a, e_1, _b, _c;
+        try {
+            for (var _d = true, data_1 = __asyncValues(data), data_1_1; data_1_1 = await data_1.next(), _a = data_1_1.done, !_a;) {
+                _c = data_1_1.value;
+                _d = false;
+                try {
+                    const options = _c;
+                    const event = await getEvent(options.id, project);
+                    if (event !== null) {
+                        callback(event);
+                    }
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = data_1.return)) await _b.call(data_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+/**
+ * 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 configuration 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).
+ *
+ * @param project - The Project to observe
+ * @param callback - Called with the removed Event
+ */
+function onEventRemoved(project, callback) {
+    return sdkUtil.subscribe(project, 'listings_events_deleted', async (data) => {
+        var _a, e_2, _b, _c;
+        try {
+            for (var _d = true, data_2 = __asyncValues(data), data_2_1; data_2_1 = await data_2.next(), _a = data_2_1.done, !_a;) {
+                _c = data_2_1.value;
+                _d = false;
+                try {
+                    const options = _c;
+                    const event = await getEvent(options.id, project);
+                    if (event !== null) {
+                        callback(event);
+                    }
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = data_2.return)) await _b.call(data_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    });
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * A map of potential error codes to compare with errors thrown by
+ * vote() or validateAnswer() functions.
+ */
+exports.AnswerError = void 0;
+(function (AnswerError) {
+    /** Selected option index is out of range. */
+    AnswerError["OptionIndexOutOfRange"] = "out_of_range";
+    /** Fewer options selected than the minimum required. */
+    AnswerError["BelowMinVoteOptions"] = "below_min_vote_options";
+    /** More options selected than the maximum allowed. */
+    AnswerError["AboveMaxVoteOptions"] = "above_max_vote_options";
+    /** User has exceeded the maximum votes allowed. */
+    AnswerError["AboveMaxVotesPerUser"] = "above_max_per_user";
+    /** A single option received more votes than allowed. */
+    AnswerError["AboveMaxVotesPerOption"] = "above_max_per_option";
+    /** Attempted to vote on a non-interactive element. */
+    AnswerError["VotedOnNonInteractiveElement"] = "non_interactive_element";
+    /** Attempted to vote on a closed element. */
+    AnswerError["VotedOnClosedElement"] = "closed_element";
+    /** No vote value was provided. */
+    AnswerError["EmptyVote"] = "empty_vote";
+})(exports.AnswerError || (exports.AnswerError = {}));
+const AnswerErrorMessages = {
+    [exports.AnswerError.OptionIndexOutOfRange]: (max, idx) => `Options index ${idx} is out of range [0..${max}]`,
+    [exports.AnswerError.BelowMinVoteOptions]: (min, total) => `Below min (${min}) vote options: ${total}`,
+    [exports.AnswerError.AboveMaxVoteOptions]: (max, total) => `Above max (${max}) vote options: ${total}`,
+    [exports.AnswerError.AboveMaxVotesPerUser]: (max, total) => `Above max (${max}) votes per user: ${total}`,
+    [exports.AnswerError.AboveMaxVotesPerOption]: (max, total) => `Above max (${max}) votes per option: ${total}`,
+    [exports.AnswerError.VotedOnNonInteractiveElement]: (id) => `Non interact element ${id}`,
+    [exports.AnswerError.VotedOnClosedElement]: (id) => `Element ${id} is closed`,
+    [exports.AnswerError.EmptyVote]: (indices) => `Empty value for options indices: ${indices}`,
+};
+/**
+ * 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
+     * the 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
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. 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.
+ */
+class Answer {
+    constructor(answers = []) {
+        this._answers = new Map();
+        for (const { option, value } of answers) {
+            this._answers.set(option, value);
+        }
+    }
+    /**
+     * The array of user answers
+     */
+    get answers() {
+        return Array.from(this._answers.entries()).map(([option, value]) => ({
+            option,
+            value,
+        }));
+    }
+    /**
+     * 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
+     */
+    static fromIndices(indices) {
+        return new Answer(indices.map((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
+     */
+    set(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
+     */
+    remove(option) {
+        this._answers.delete(option);
+        return this;
+    }
+    /** @internal */
+    toJSON() {
+        return this.answers;
+    }
+    /** @internal */
+    static fromJSON(value) {
+        return new Answer(JSON.parse(value));
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. 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 Element
+     */
+    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
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+class ElementImpl extends sdkUtil.Emitter {
+    constructor(data, context) {
+        var _a, _b;
+        super();
+        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(() => this.handleState());
+    }
+    calculateState() {
+        if (sdkUtil.now() < this.publishedAt + this.duration) {
+            return exports.ElementState.Opened;
+        }
+        return exports.ElementState.Closed;
+    }
+    handleState() {
+        const state = this.calculateState();
+        if (state === exports.ElementState.Closed) {
+            this.unsubscribeStateHandler();
+        }
+        if (state !== this._state) {
+            this._state = state;
+            this.emit('state', state);
+        }
+    }
+    update(data) {
+        this._data = data;
+        this.handleState();
+    }
+    destroy() {
+        this.unsubscribeStateHandler();
+    }
+    get context() {
+        return this._context;
+    }
+    get id() {
+        return this._data.id;
+    }
+    get eventId() {
+        return this.context.event.id;
+    }
+    get state() {
+        return this._state;
+    }
+    get type() {
+        return this._data.type;
+    }
+    get contentType() {
+        return this._data.content_type;
+    }
+    get publishedAt() {
+        return this._data.published_at;
+    }
+    get publishedAtIso() {
+        return this._data.published_at_iso;
+    }
+    get updatedAt() {
+        return this._data.updated_at;
+    }
+    get updatedAtIso() {
+        return this._data.updated_at_iso;
+    }
+    get duration() {
+        return this._data.duration;
+    }
+    get fields() {
+        const { locale } = this.context.project;
+        return localise(this._data.custom_fields, locale);
+    }
+    get interactive() {
+        return this.type !== exports.ElementType.Data;
+    }
+    get pollId() {
+        return this._data.data.id || null;
+    }
+    get question() {
+        const { locale } = this.context.project;
+        if (this._data.data.question === undefined) {
+            return null;
+        }
+        return localise(this._data.data.question, locale);
+    }
+    get answerOptions() {
+        const { locale } = this.context.project;
+        if (this._data.data.options === undefined) {
+            return null;
+        }
+        return localise(this._data.data.options, locale);
+    }
+    get minOptionsPerVote() {
+        return this._data.data.min_options_per_vote || 1;
+    }
+    get maxOptionsPerVote() {
+        return this._data.data.max_options_per_vote || 1;
+    }
+    get maxVotesPerOption() {
+        return this._data.data.max_votes_per_option || 1;
+    }
+    get maxVotesPerUser() {
+        return this._data.data.max_votes_per_user || null;
+    }
+    get userAnswer() {
+        return this._userAnswer;
+    }
+    set userAnswer(value) {
+        this._userAnswer = value;
+    }
+    get hasBeenAnswered() {
+        return this._userAnswer !== null;
+    }
+    get showResultsMode() {
+        return this._data.data.reveal_results_mode || null;
+    }
+    get canShowResults() {
+        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;
+        }
+    }
+    get results() {
+        if (!this.canShowResults) {
+            return null;
+        }
+        return this._results;
+    }
+    set results(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');
+        }
+    }
+    get correctOption() {
+        return this._correctOption;
+    }
+    set correctOption(value) {
+        this._correctOption = value;
+    }
+    get isCorrectOptionRevealed() {
+        return this._correctOption !== null;
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022-2024 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const elements = new Map();
+async function buildElement(options, context) {
+    if (elements.has(options.id)) {
+        return elements.get(options.id);
+    }
+    const element = new ElementImpl(options, context);
+    await restoreAnswer(element);
+    elements.set(element.id, element);
+    return element;
+}
+function getElementByPolld(pollId) {
+    return Array.from(elements.values()).find((element) => element.pollId === pollId);
+}
+const configureEventMemoized = sdkUtil.memoizePromise(async (event) => {
+    event.on('history', handleEventHistory);
+    if (event.history !== null) {
+        handleEventHistory(event.history);
+    }
+    await configureConnect(event.context.sdk.options.host);
+    await init(event);
+}, (event) => event.id);
+async function configureEvent(event) {
+    return configureEventMemoized(event);
+}
+const configureConnectMemoized = sdkUtil.memoizePromise(async (host) => {
+    const connect = await getConnect(host);
+    connect.on('message', handleConnectMessage);
+}, (host) => host);
+async function configureConnect(host) {
+    return configureConnectMemoized(host);
+}
+async function handleConnectMessage(message) {
+    const { klass } = message;
+    switch (klass) {
+        case exports.Klass.Create:
+            await handleCreateMessage(message);
+            break;
+        case exports.Klass.Revoke:
+            await handleRevokeMessage(message);
+            break;
+        case exports.Klass.Feedback:
+            await handleFeedbackMessage(message);
+            break;
+        case exports.Klass.Reveal:
+            await handleRevealMessage(message);
+            break;
+    }
+}
+async function handleCreateMessage(message) {
+    const { id, data } = message;
+    const options = JSON.parse(data[0]);
+    const event = await getEvent(id);
+    if (event === null) {
+        return;
+    }
+    if (elements.has(options.id)) {
+        const element = elements.get(options.id);
+        if (options.updated_at > element.updatedAt ||
+            // This is a workaround to handle a Studio issue when two /create/ messages
+            // are sent upon correct option reveal. The first /create/ message contains
+            // the same duration but a different updated_at timestamp. The second /create/
+            // message contains the same updated_at timestamp but a different duration.
+            // Therefore, we need to check if the duration is different to ensure that
+            // the element is updated correctly.
+            options.duration !== element.duration) {
+            element.update(options);
+            event.emit('update', element);
+        }
+    }
+    else {
+        const context = Object.assign(Object.assign({}, event.context), { event });
+        const element = await buildElement(options, context);
+        event.emit('publish', element);
+    }
+}
+function handleRevokeMessage(message) {
+    const { data } = message;
+    const { id } = JSON.parse(data[0]);
+    if (!elements.has(id)) {
+        return;
+    }
+    const element = elements.get(id);
+    elements.delete(id);
+    element.destroy();
+    element.context.event.emit('revoke', element);
+}
+async function handleFeedbackMessage(message) {
+    const { data } = message;
+    // Feedback message format:
+    //
+    // [pollId, isFinal, sources, counters, timestamp]
+    const pollId = +data[0];
+    const counters = data[3];
+    const element = getElementByPolld(pollId);
+    if (!element) {
+        return;
+    }
+    const votes = counters.split(':').map((value) => +value);
+    const percentages = sdkUtil.calculatePercentage(votes);
+    const results = votes.map((item, idx) => ({
+        percentage: percentages[idx],
+        votes: item,
+    }));
+    element.results = results;
+}
+function handleRevealMessage(message) {
+    const { data } = message;
+    // Reveal message format:
+    //
+    // [pollId, index (1-based), timestamp]
+    const pollId = +data[0];
+    const correctOption = +data[1] - 1;
+    const element = getElementByPolld(pollId);
+    if (!element) {
+        return;
+    }
+    if (element.correctOption !== correctOption) {
+        element.correctOption = correctOption;
+        element.context.event.emit('update', element);
+    }
+}
+async function handleEventHistory(history) {
+    var _a, e_1, _b, _c;
+    if (history.timeline.length === 0) {
+        return;
+    }
+    const event = await getEvent(history.config.id);
+    if (event === null) {
+        return;
+    }
+    const context = Object.assign(Object.assign({}, event.context), { event });
+    try {
+        for (var _d = true, _e = __asyncValues(history.timeline), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+            _c = _f.value;
+            _d = false;
+            try {
+                const snapshot = _c;
+                if (!elements.has(snapshot.id)) {
+                    await buildElement(snapshot, context);
+                }
+            }
+            finally {
+                _d = true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+async function sendAnswer(element, userAnswer) {
+    const { project, event } = element.context;
+    const connect = await getConnect(project.host);
+    const answer = userAnswer.answers
+        .map(({ option, value }) => [option + 1, value])
+        .flat()
+        .join(':');
+    connect.sendVote(event.id, element.pollId, answer);
+}
+async function storeAnswer(element, userAnswer) {
+    try {
+        element.userAnswer = userAnswer;
+        await sdkStorageKit.storageWrite(`element_${element.id}_vote`, JSON.stringify(userAnswer));
+    }
+    catch (err) {
+        console.warn(`Failed to store user answer: ${sdkUtil.getErrorMessage(err)}`);
+    }
+}
+async function restoreAnswer(element) {
+    const userAnswer = await sdkStorageKit.storageRead(`element_${element.id}_vote`);
+    if (userAnswer !== null) {
+        element.userAnswer = Answer.fromJSON(userAnswer);
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+const getElementMemoized = sdkUtil.memoizePromise(async (event, id) => {
+    await configureEvent(event);
+    const element = Array.from(elements.values()).find((el) => el.id === id);
+    return element || null;
+}, (event, id) => id);
+/**
+ * Returns an Element of a specific Event by its id.
+ *
+ * @param event - The Event that owns the Element
+ * @param id - The Element identifier
+ */
+function getElement(event, id) {
+    return getElementMemoized(event, id);
+}
+/**
+ * @internal
+ */
+const getElementsMemoized = sdkUtil.memoizePromise(async (event) => {
+    await configureEvent(event);
+    return (Array.from(elements.values())
+        // Get Elements which belong only to the provided Event
+        .filter((element) => element.eventId === event.id)
+        // Sort Elements so the oldest Element is first, and the most recent is last
+        .sort((a, b) => a.publishedAt - b.publishedAt));
+}, (event) => event.id, {
+    clearOnResolve: true,
+});
+/**
+ * Returns the list of Elements published in a specific Event
+ *
+ * @param event - The Event to fetch Elements for
+ * @returns The published Elements, sorted oldest first.
+ */
+function getElements(event) {
+    return getElementsMemoized(event);
+}
+function answer(element, ...value) {
+    const answerObj = answerParametersToAnswer(...value);
+    validateAnswer(element, ...value);
+    sendAnswer(element, answerObj);
+    storeAnswer(element, answerObj);
+}
+function validateAnswer(element, ...value) {
+    const answerObj = answerParametersToAnswer(...value);
+    const { answers } = answerObj;
+    const indices = answers.map(({ option }) => option);
+    const values = answers.map(({ value: v }) => v);
+    const maxIndex = Math.max(...indices);
+    const maxValue = Math.max(...values);
+    const sumValues = values.reduce((memo, val) => memo + val, 0);
+    const emptyIndices = values.reduce((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(...value) {
+    const 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((v) => Object.prototype.hasOwnProperty.call(v, 'option') &&
+        Object.prototype.hasOwnProperty.call(v, 'value'));
+}
+function isNumbers(value) {
+    return value.every((v) => typeof v === 'number');
+}
+/**
+ * Adds an observer for when
+ * {@link InteractElement | Element results} are updated
+ *
+ * @param element - The Element to observe
+ * @param callback - Called when results are updated
+ */
+function onElementResults(element, callback) {
+    return sdkUtil.subscribe(element, 'results', callback);
+}
+/**
+ * Adds an observer for when
+ * {@link InteractElement | Element state} changed
+ *
+ * @param element - The Element to observe
+ * @param callback - Called when the state changes
+ */
+function onElementStateChanged(element, callback) {
+    return sdkUtil.subscribe(element, 'state', callback);
+}
+/**
+ * Adds an observer for when
+ * {@link InteractElement | Element fields} are updated
+ *
+ * @param event - The Event containing the Elements
+ * @param callback - Called with the updated Element
+ */
+function onElementUpdated(event, callback) {
+    configureEvent(event);
+    return sdkUtil.subscribe(event, 'update', callback);
+}
+/**
+ * Adds an observer for when a new Element is published
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the published Element
+ */
+function onElementPublished(event, callback) {
+    configureEvent(event);
+    return sdkUtil.subscribe(event, 'publish', (element) => {
+        if (event.initState === InitState.Initialised) {
+            callback(element);
+        }
+    });
+}
+/**
+ * Adds an observer for when an Element is revoked
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the revoked Element
+ */
+function onElementRevoked(event, callback) {
+    configureEvent(event);
+    return sdkUtil.subscribe(event, 'revoke', callback);
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2025 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+exports.PresenceCounterState = void 0;
+(function (PresenceCounterState) {
+    PresenceCounterState["Opened"] = "opened";
+    PresenceCounterState["Closed"] = "closed";
+})(exports.PresenceCounterState || (exports.PresenceCounterState = {}));
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2023 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const logger = new sdkCore.Logger('@monterosa/sdk-interact-kit');
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2025 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+class PresenceCounterImpl extends sdkUtil.Emitter {
+    constructor(host, id) {
+        super();
+        this.host = host;
+        this.id = id;
+        this.state = exports.PresenceCounterState.Closed;
+        this.lastCount = 0;
+        this.connect = null;
+        this.boundHandleMessage = this.handleMessage.bind(this);
+        this.boundHandleTimeout = this.handleTimeout.bind(this);
+    }
+    async init() {
+        this.connect = await getConnect(this.host);
+        this.connect.on('message', this.boundHandleMessage);
+    }
+    get isOpened() {
+        return this.state === exports.PresenceCounterState.Opened;
+    }
+    async handleMessage(message) {
+        const { id, klass, data } = message;
+        if (id !== this.id || klass !== exports.Klass.SubsCounter) {
+            return;
+        }
+        try {
+            const subsData = JSON.parse(data[0]);
+            this.handleCounterUpdate(subsData.counter);
+            this.resetTimeout(subsData.next_update_at);
+        }
+        catch (e) {
+            logger.warn("Couldn't parse subscounter message.");
+        }
+    }
+    handleCounterUpdate(count) {
+        if (count < 0) {
+            return;
+        }
+        let shouldEmitUpdated = false;
+        let shouldEmitState = false;
+        if (this.lastCount !== count) {
+            shouldEmitUpdated = true;
+            this.lastCount = count;
+        }
+        if (this.state === exports.PresenceCounterState.Closed) {
+            shouldEmitState = true;
+            this.state = exports.PresenceCounterState.Opened;
+        }
+        if (shouldEmitUpdated) {
+            this.emit('updated', this.lastCount);
+        }
+        if (shouldEmitState) {
+            this.emit('state', exports.PresenceCounterState.Opened);
+        }
+    }
+    handleTimeout() {
+        this.state = exports.PresenceCounterState.Closed;
+        this.emit('state', exports.PresenceCounterState.Closed);
+    }
+    resetTimeout(nextUpdateAt) {
+        clearTimeout(this.closeTimeout);
+        this.closeTimeout = setTimeout(this.boundHandleTimeout, 
+        // because of the time difference between the server and the client,
+        // we need to add 3 seconds to the timeout
+        (nextUpdateAt - sdkUtil.now() + 3) * 1000);
+    }
+    destroy() {
+        if (this.connect !== null) {
+            this.connect.off('message', this.boundHandleMessage);
+        }
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-interact-kit
+ *
+ * Copyright © 2025 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const presenceCounters = new Map();
+const getPresenceCounterMemoized = sdkUtil.memoizePromise(async (host, id) => {
+    if (presenceCounters.has(id)) {
+        return presenceCounters.get(id);
+    }
+    const presenceCounter = new PresenceCounterImpl(host, id);
+    await presenceCounter.init();
+    presenceCounters.set(id, presenceCounter);
+    return presenceCounter;
+}, (_, id) => id);
+async function getPresenceCounter(project) {
+    if (project === undefined) {
+        project = await getProject();
+    }
+    return getPresenceCounterMemoized(project.context.sdk.options.host, project.id);
+}
+function onPresenceCounterUpdate(presenceCounter, callback) {
+    presenceCounter.on('updated', callback);
+    return () => presenceCounter.off('updated', callback);
+}
+function onPresenceCounterOpen(presenceCounter, callback) {
+    const handler = (state) => {
+        if (state === exports.PresenceCounterState.Opened) {
+            callback();
+        }
+    };
+    presenceCounter.on('state', handler);
+    return () => presenceCounter.off('state', handler);
+}
+function onPresenceCounterClose(presenceCounter, callback) {
+    const handler = (state) => {
+        if (state === exports.PresenceCounterState.Closed) {
+            callback();
+        }
+    };
+    presenceCounter.on('state', handler);
+    return () => presenceCounter.off('state', handler);
+}
+
+exports.Answer = Answer;
+exports.ElementImpl = ElementImpl;
+exports.EventImpl = EventImpl;
+exports.ProjectImpl = ProjectImpl;
+exports.answer = answer;
+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.getPresenceCounter = getPresenceCounter;
+exports.getProject = getProject;
+exports.getProjectMemoized = getProjectMemoized;
+exports.onConnectionHealthState = onConnectionHealthState;
+exports.onElementPublished = onElementPublished;
+exports.onElementResults = onElementResults;
+exports.onElementRevoked = onElementRevoked;
+exports.onElementStateChanged = onElementStateChanged;
+exports.onElementUpdated = onElementUpdated;
+exports.onEventAdded = onEventAdded;
+exports.onEventRemoved = onEventRemoved;
+exports.onEventState = onEventState;
+exports.onEventUpdated = onEventUpdated;
+exports.onPresenceCounterClose = onPresenceCounterClose;
+exports.onPresenceCounterOpen = onPresenceCounterOpen;
+exports.onPresenceCounterUpdate = onPresenceCounterUpdate;
+exports.onProjectFieldsUpdated = onProjectFieldsUpdated;
+exports.validateAnswer = validateAnswer;
+//# sourceMappingURL=index.cjs.map