@monterosa/sdk-launcher-kit 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/index.cjs

@@ -0,0 +1,1945 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkCore = require('@monterosa/sdk-core');
+var sdkUtil = require('@monterosa/sdk-util');
+var sdkInteractInterop = require('@monterosa/sdk-interact-interop');
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-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 RESIZE_THROTTLE_TIMEOUT = 25;
+/**
+ * Duration of the loader fade IN/OUT animation
+ */
+const LOADER_ANIMATION_DURATION = 750;
+/**
+ * Final cut off timeout for the loader after which it will be hidden even
+ * though Experience UI may ne not yet ready
+ */
+const LOADER_TIMEOUT = 5000;
+/**
+ * Bumper timeout during which the loader still visible even though Experience
+ * UI may be ready
+ *
+ * (!) At the moment its value is 0 as loader has a fade in effect what already
+ * adds a small bumper delay before Experience is injected on the page
+ */
+const LOADER_BUMPER_TIMEOUT = 0;
+const DEFAULT_HEIGHT = 250;
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-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-launcher-kit');
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * A list of possible actions in communications between
+ * parent application and child Experience
+ *
+ * @internal
+ */
+exports.Action = void 0;
+(function (Action) {
+    /**
+     * Notifies that the communication bridge transport is ready.
+     * Auto-sent when the child bridge is created — no developer action needed.
+     */
+    Action["OnBridgeInitialised"] = "onBridgeInitialised";
+    /**
+     * Notifies that the Experience has initialised and is ready to receive messages.
+     * Sent explicitly by the developer via `sendInitialised()`.
+     * This triggers the `initialised` lifecycle state.
+     */
+    Action["OnExperienceInitialised"] = "onExperienceInitialised";
+    /**
+     * Notifies that UI of child Experience is loaded and ready to be visible.
+     * When this action is fired the loader will be hidden and
+     * the `ready` lifecycle state is triggered.
+     */
+    Action["OnReady"] = "onReady";
+    /**
+     * Notifies that intrinsic size of child Experience has changed
+     */
+    Action["OnResize"] = "onIntrinsicSizeChanged";
+    /**
+     * Notifies child Experience about the request to load more data
+     */
+    Action["OnMoreDataRequested"] = "onMoreDataRequested";
+    /**
+     * Notifies about a share request
+     */
+    Action["OnShare"] = "onShare";
+})(exports.Action || (exports.Action = {}));
+/**
+ * @internal
+ */
+exports.Source = void 0;
+(function (Source) {
+    Source["Sdk"] = "sdk";
+    Source["User"] = "user";
+})(exports.Source || (exports.Source = {}));
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Reserved query parameter names for controlling the behaviour of Experience.
+ */
+exports.QueryParam = void 0;
+(function (QueryParam) {
+    /**
+     * Represents the host of the application. This parameter is added by Studio
+     * and the embed URL already contains it.
+     */
+    QueryParam["Host"] = "h";
+    /**
+     * Represents the Project ID of the application. This parameter is added by
+     * Studio and the embed URL already contains it.
+     */
+    QueryParam["Project"] = "p";
+    /**
+     * Represents the Event ID of the application. This parameter is added to the
+     * Experience URL when the eventId is provided in the Experience config.
+     */
+    QueryParam["Event"] = "e";
+    /**
+     * Used to identify the unique ID of the communication bridge between
+     * the parent application and the child experience.
+     */
+    QueryParam["BridgeId"] = "micBridgeId";
+    /**
+     * Determines whether the header and footer views of the application should be
+     * hidden. This parameter can be used to control the visibility of the
+     * application's header and footer components.
+     */
+    QueryParam["HideHeaderAndFooter"] = "micHideHeaderAndFooter";
+    /**
+     * Determines whether autoresize is enabled for the application. When autoresize
+     * is enabled, the application's height will adjust automatically based on its
+     * content.
+     */
+    QueryParam["AutoresizesHeight"] = "micAutoresizesHeight";
+})(exports.QueryParam || (exports.QueryParam = {}));
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2024 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Defines a set of error codes that may be encountered when using the
+ * Launcher Kit bridge
+ *
+ * @example
+ * ```javascript
+ * try {
+ *   // some code that uses the LauncherKit's bridge
+ * } catch (err) {
+ *   if (err.code === BridgeError.InvalidRequestTimeoutError) {
+ *     // handle invalid request timeout error
+ *   } else {
+ *     // handle other error types
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * - The `BridgeError` enum provides a convenient way to handle errors
+ *   encountered when using the `LauncherKit` module. By checking the code
+ *   property of the caught error against the values of the enum, the error
+ *   type can be determined and appropriate action taken.
+ *
+ * - The `BridgeError` enum is not intended to be instantiated or extended.
+ */
+exports.BridgeError = void 0;
+(function (BridgeError) {
+    /**
+     * Indicates an error occurred due to an invalid timeout value being provided.
+     * This error is thrown when the specified timeout is not a positive number.
+     */
+    BridgeError["InvalidRequestTimeoutError"] = "invalid_request_timeout_error";
+    /**
+     * Indicates a request timed out waiting for a response.
+     * This error is thrown when a bridge request exceeds the specified timeout duration.
+     */
+    BridgeError["RequestTimeoutError"] = "request_timeout_error";
+})(exports.BridgeError || (exports.BridgeError = {}));
+const BridgeErrorMessages = {
+    [exports.BridgeError.InvalidRequestTimeoutError]: () => 'Request timeout must be greater than 0',
+    [exports.BridgeError.RequestTimeoutError]: (action, timeout) => `Request timeout: action "${action}" did not receive a response within ${timeout}ms`,
+};
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2024 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+const Config = {
+    requestTimeout: 20000,
+};
+/**
+ * Sets a new timeout value for requests (default is 20,000 ms).
+ *
+ * @remarks
+ * This function updates the request timeout in the application's configuration.
+ * It ensures that the new timeout value is a positive number, and throws
+ * an error if the value is non-positive.
+ *
+ * @param newTimeout - The new timeout value in milliseconds. Must be
+ *   a positive number.
+ *
+ * @throws
+ * Throws {@link BridgeError | BridgeError.InvalidRequestTimeoutError}
+ * if `newTimeout` is less than or equal to 0.
+ *
+ * @example
+ * ```javascript
+ * // Set the request timeout to 3000 milliseconds
+ * setRequestTimeout(3000);
+ * ```
+ */
+function setRequestTimeout(newTimeout) {
+    if (newTimeout <= 0) {
+        throw sdkUtil.createError(exports.BridgeError.InvalidRequestTimeoutError, BridgeErrorMessages);
+    }
+    Config.requestTimeout = newTimeout;
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+function isMessage(message) {
+    return (message instanceof Object &&
+        Object.prototype.hasOwnProperty.call(message, 'bridgeId'));
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var _a$1, _b$1, _c$1, _d$1;
+var _e, _f, _g;
+const globals$2 = sdkUtil.getGlobal();
+const receiveMessage = (message) => {
+    if (!isMessage(message)) {
+        // data does not match message format
+        return;
+    }
+    globals$2.monterosaSdk.emitter.emit('message', message);
+};
+function handleWindowMessage({ data }) {
+    try {
+        if (typeof data !== 'string') {
+            // ignore non string data
+            return;
+        }
+        const message = JSON.parse(data);
+        receiveMessage(message);
+    }
+    catch (err) {
+        console.error(sdkUtil.getErrorMessage(err));
+    }
+}
+/**
+ * Since this code operates as a side effect while updating the global space,
+ * we must be very careful because it may run twice, for example, when two apps
+ * using the SDK run on the same page. Additionally, the global namespace may
+ * already be updated by the Android or iOS SDKs.
+ */
+// The Monterosa SDK namespace may already exist, either because it was created
+// by a native SDK or by another web app using the JS SDK from the same scope.
+(_a$1 = globals$2.monterosaSdk) !== null && _a$1 !== void 0 ? _a$1 : (globals$2.monterosaSdk = {
+    initialised: false,
+    emitter: new sdkUtil.Emitter(),
+    receiveMessage,
+});
+// Each of nullish coalescing assignments will only be applied when
+// the Monterosa SDK namespace exists at that moment and one of its properties
+// is not defined.
+(_b$1 = (_e = globals$2.monterosaSdk).initialised) !== null && _b$1 !== void 0 ? _b$1 : (_e.initialised = false);
+(_c$1 = (_f = globals$2.monterosaSdk).emitter) !== null && _c$1 !== void 0 ? _c$1 : (_f.emitter = new sdkUtil.Emitter());
+(_d$1 = (_g = globals$2.monterosaSdk).receiveMessage) !== null && _d$1 !== void 0 ? _d$1 : (_g.receiveMessage = receiveMessage);
+if (!globals$2.monterosaSdk.initialised) {
+    // Subscribe to the message only once for each app that uses the SDK on this page.
+    if (typeof globals$2.addEventListener !== 'undefined') {
+        globals$2.addEventListener('message', handleWindowMessage);
+    }
+    globals$2.monterosaSdk.initialised = true;
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var _a, _b, _c, _d;
+const globals$1 = sdkUtil.getGlobal();
+/**
+ * @internal
+ */
+const IFRAME_ID_PREFIX = 'micBridge';
+const IS_IOS = !!((_c = (_b = (_a = globals$1.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.monterosaSdk) === null || _c === void 0 ? void 0 : _c.postMessage);
+const IS_ANDROID = !!((_d = globals$1.monterosaSdk) === null || _d === void 0 ? void 0 : _d.postMessage);
+const IS_WEB = globals$1.self !== globals$1.parent;
+/**
+ * @internal
+ */
+const VERSION$1 = '1.0.0';
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const globals = sdkUtil.getGlobal();
+/**
+ * @internal
+ */
+class BridgeImpl extends sdkUtil.Emitter {
+    constructor(id = sdkUtil.generateUUID()) {
+        super();
+        this.id = id;
+        this.recipientInitialised = false;
+        this.messagesQueue = [];
+        globals.monterosaSdk.emitter.on('message', this.handleMessage.bind(this));
+    }
+    static isMessage(message) {
+        return (message instanceof Object &&
+            Object.prototype.hasOwnProperty.call(message, 'bridgeId') &&
+            Object.prototype.hasOwnProperty.call(message, 'action'));
+    }
+    get iFrameId() {
+        return `${IFRAME_ID_PREFIX}-${this.id}`;
+    }
+    get iFrameSelector() {
+        return `iframe#${this.iFrameId}`;
+    }
+    get childIFrame() {
+        return document.querySelector(this.iFrameSelector);
+    }
+    handleMessage(message) {
+        const { id, bridgeId, action, respondingTo } = message;
+        if (bridgeId !== this.id) {
+            return;
+        }
+        logger.log(`Received a ${respondingTo === null ? 'message' : 'response'}`, message);
+        if (action === exports.Action.OnBridgeInitialised) {
+            this.recipientInitialised = true;
+            if (respondingTo === null) {
+                this.send(exports.Action.OnBridgeInitialised, {}, exports.Source.Sdk, id);
+            }
+            while (this.messagesQueue.length > 0) {
+                this.postMessage(this.messagesQueue.shift());
+            }
+            return;
+        }
+        this.emit('message', message);
+    }
+    createMessage(action, payload, sourceName, respondingTo = null) {
+        return {
+            id: sdkUtil.generateUUID(),
+            respondingTo,
+            action,
+            sourceName,
+            bridgeId: this.id,
+            payload,
+            version: VERSION$1,
+            timestamp: Date.now(),
+        };
+    }
+    postMessage(message) {
+        var _a, _b, _c, _d;
+        if (!this.recipientInitialised &&
+            message.action !== exports.Action.OnBridgeInitialised) {
+            this.messagesQueue.push(message);
+            return;
+        }
+        const json = JSON.stringify(message);
+        if (IS_IOS) {
+            (_b = (_a = globals.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.monterosaSdk.postMessage(json);
+        }
+        if (IS_ANDROID) {
+            if ((_c = globals.monterosaSdk) === null || _c === void 0 ? void 0 : _c.postMessage) {
+                globals.monterosaSdk.postMessage(json);
+            }
+        }
+        if (IS_WEB) {
+            globals.parent.postMessage(json, '*');
+        }
+        if (this.childIFrame) {
+            (_d = this.childIFrame.contentWindow) === null || _d === void 0 ? void 0 : _d.postMessage(json, '*');
+        }
+    }
+    send(action, payload = {}, sourceName = exports.Source.Sdk, respondingTo) {
+        const message = this.createMessage(action, payload, sourceName, respondingTo);
+        logger.log(`Sending a ${message.respondingTo === null ? 'message' : 'response'}`, message);
+        this.postMessage(message);
+        return message;
+    }
+    async request(action, payload = {}, timeout = Config.requestTimeout, sourceName = exports.Source.Sdk) {
+        let timeoutRef;
+        let handler;
+        const message = this.createMessage(action, payload, sourceName);
+        logger.log('Sending a request', message);
+        /**
+         * Start the timeout, when it finishes it should reject Promise.race below
+         */
+        const countdown = new Promise((_, reject) => {
+            timeoutRef = setTimeout(() => {
+                reject(sdkUtil.createError(exports.BridgeError.RequestTimeoutError, BridgeErrorMessages, action, timeout));
+            }, timeout);
+        });
+        /**
+         * Start the request and wait for the message with the respondingTo
+         * equal to message id we sent
+         */
+        const request = new Promise((resolve) => {
+            handler = (responseMessage) => {
+                if (responseMessage.respondingTo === message.id) {
+                    resolve(responseMessage);
+                }
+            };
+            globals.monterosaSdk.emitter.on('message', handler);
+            this.postMessage(message);
+        });
+        /**
+         * Start race between timeout and request
+         *   - if timeout wins the promise will be rejected
+         *   - if request wins then Message will be resolved
+         */
+        return (Promise.race([countdown, request])
+            /**
+             * As the matter of clean up we need to clear timeout id
+             * and unsubscribe from the message event
+             */
+            .finally(() => {
+            clearTimeout(timeoutRef);
+            globals.monterosaSdk.emitter.off('message', handler);
+        }));
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+let parentBridge;
+const bridges = new Map();
+/**
+ * @internal
+ */
+function getBridge(id) {
+    if (bridges.has(id)) {
+        return bridges.get(id);
+    }
+    const bridge = new BridgeImpl(id);
+    bridges.set(id, bridge);
+    return bridge;
+}
+/**
+ * Returns true if the page is inside an iframe.
+ *
+ * @internal
+ */
+function isInsideIframe() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    try {
+        return window.self !== window.top;
+    }
+    catch (_a) {
+        // SecurityError is thrown when accessing window.top in a cross-origin iframe.
+        // If we can't access it, we're definitely in an iframe.
+        return true;
+    }
+}
+/**
+ * @internal
+ */
+function getParentBridge() {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    if (parentBridge !== undefined) {
+        return parentBridge;
+    }
+    if (!isInsideIframe()) {
+        return null;
+    }
+    const url = new URL(window.location.href);
+    const bridgeId = url.searchParams.get(exports.QueryParam.BridgeId);
+    if (bridgeId === null) {
+        return null;
+    }
+    parentBridge = new BridgeImpl(bridgeId);
+    parentBridge.send(exports.Action.OnBridgeInitialised, {}, exports.Source.Sdk);
+    return parentBridge;
+}
+/**
+ * @internal
+ */
+function sendSdkMessage(bridged, action, payload = {}) {
+    return bridged.bridge.send(action, payload, exports.Source.Sdk);
+}
+/**
+ * Sends a message with an action name and payload to a parent application or child Experience.
+ *
+ * @remarks
+ * Usage example in parent application:
+ *
+ * @example
+ * ```typescript
+ * const experience = getExperience();
+ *
+ * // message to Experience can be sent only when its initialised
+ * onStateChanged(experience, (state) => {
+ *   if (state === 'initialised') {
+ *     sendMessage(
+ *       experience,
+ *       'my_action',
+ *       { key: 'value' }
+ *     );
+ *   }
+ * });
+ *
+ * embed(experience);
+ * ```
+ *
+ * Usage example in child Experience:
+ *
+ * @example
+ * ```typescript
+ * const parentApp = getParentApplication();
+ *
+ * if (parentApp !== null) {
+ *   sendMessage(
+ *     parentApp,
+ *     'my_action',
+ *     { key: 'value' }
+ *   );
+ * }
+ * ```
+ *
+ * @param bridged - Instance of either {@link ParentApplication} or {@link Experience}
+ * @param action - Arbitrary action name that defines purpose of the message
+ * @param payload - A key-value object that is sent in a message
+ * @returns Returns {@link Message | message}
+ */
+function sendMessage(bridged, action, payload = {}) {
+    return bridged.bridge.send(action, payload, exports.Source.User);
+}
+/**
+ * @internal
+ */
+function sendSdkRequest(bridged, action, payload = {}, timeout = Config.requestTimeout) {
+    return bridged.bridge.request(action, payload, timeout, exports.Source.Sdk);
+}
+/**
+ * Sends a request and returns a Promise that resolves when the recipient responds.
+ *
+ * @remarks
+ * Similar to {@link sendMessage} but returns a Promise which
+ * resolves if the recipient responds with {@link respondToMessage}. Otherwise it
+ * rejects after a certain timeout.
+ *
+ * Usage example in parent application:
+ *
+ * @example
+ * ```typescript
+ * const experience = getExperience();
+ *
+ * // request to Experience can be sent only when its initialised
+ * onStateChanged(experience, async (state) => {
+ *   if (state === 'initialised') {
+ *     const response = await sendRequest(
+ *       experience,
+ *       'my_action',
+ *       { key: 'value' }
+ *     );
+ *
+ *     console.log(response);
+ *   }
+ * });
+ *
+ * embed(experience);
+ * ```
+ *
+ * Usage example in child Experience:
+ *
+ * @example
+ * ```typescript
+ * const parentApp = getParentApplication();
+ *
+ * // parent application can be null if Experience is running stand alone
+ * if (parentApp !== null) {
+ *   const response = await sendRequest(
+ *     parentApp,
+ *     'my_action',
+ *     { key: 'value' }
+ *   );
+ *
+ *   console.log(response);
+ * }
+ * ```
+ *
+ * @param bridged - Instance of either {@link ParentApplication} or {@link Experience}
+ * @param action - Arbitrary action name that defines purpose of the message
+ * @param payload - A key-value object that is sent as in request
+ * @param timeout - Configurable request timeout, if there is no response by
+ * the end of this timeout then returned Promise will be rejected.
+ */
+function sendRequest(bridged, action, payload = {}, timeout = Config.requestTimeout) {
+    return bridged.bridge.request(action, payload, timeout, exports.Source.User);
+}
+/**
+ * @internal
+ */
+function respondToSdkMessage(bridged, message, payload = {}) {
+    bridged.bridge.send(message.action, payload, exports.Source.Sdk, message.id);
+}
+/**
+ * Respond to a received message. It is used to reply to a
+ * {@link sendRequest | user request}.
+ *
+ * @param bridged - Instance of either {@link ParentApplication} or {@link Experience}
+ * @param message - {@link Message | Message} to respond to
+ * @param payload - A key-value object that is sent as in response
+ */
+function respondToMessage(bridged, message, payload = {}) {
+    bridged.bridge.send(message.action, payload, exports.Source.User, message.id);
+}
+function onMessageFunc(bridged, source, callback) {
+    return sdkUtil.subscribe(bridged.bridge, 'message', (message) => {
+        if (message.sourceName === source) {
+            callback(message);
+        }
+    });
+}
+/**
+ * @internal
+ */
+function onSdkMessage(bridged, callback) {
+    return onMessageFunc(bridged, exports.Source.Sdk, callback);
+}
+/**
+ * @internal
+ *
+ * Adds an observer for when user message is received
+ *
+ * @param bridged - Instance of either {@link ParentApplication} or {@link Experience}
+ * @param callback - The callback that is triggered when user message is received
+ * @returns The unsubscribe function. When it's called,
+ * the observer will be removed and user messages will no longer be received
+ */
+function onMessage(bridged, callback) {
+    return onMessageFunc(bridged, exports.Source.User, callback);
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+class ExperienceImpl {
+    constructor(sdk, config) {
+        this.sdk = sdk;
+        this._parameters = {};
+        this.id = sdkUtil.generateUUID();
+        this.state = 'unmounted';
+        this.customElement = null;
+        this._config = config;
+        this.bridge = getBridge(this.id);
+        if (config.parameters !== undefined) {
+            const reserved = Object.values(exports.QueryParam);
+            const ignored = [];
+            Object.entries(config.parameters).forEach(([key, value]) => {
+                if (reserved.includes(key)) {
+                    ignored.push(key);
+                }
+                else {
+                    this._parameters[key] = value;
+                }
+            });
+            if (ignored.length === 1) {
+                console.warn(`Parameter "${ignored[0]}" ignored as it matches reserved words`);
+            }
+            if (ignored.length > 1) {
+                console.warn(`Parameters "${ignored.join('", "')}" ignored as they match reserved words`);
+            }
+        }
+    }
+    get config() {
+        var _a, _b, _c, _d;
+        return Object.assign(this._config, {
+            autoresizesHeight: (_a = this._config.autoresizesHeight) !== null && _a !== void 0 ? _a : false,
+            hidesHeadersAndFooters: (_b = this._config.hidesHeadersAndFooters) !== null && _b !== void 0 ? _b : true,
+            supportsLoadingState: (_c = this._config.supportsLoadingState) !== null && _c !== void 0 ? _c : true,
+            experienceUrl: (_d = this._config.experienceUrl) !== null && _d !== void 0 ? _d : null,
+        });
+    }
+    async getEmbedUrl() {
+        if (this.embedUrl) {
+            return Promise.resolve(this.embedUrl);
+        }
+        const { options: { host, projectId }, } = this.sdk;
+        const listings = await sdkInteractInterop.fetchListings(host, projectId);
+        this.embedUrl = listings.project.embed;
+        return this.embedUrl;
+    }
+    async getUrl() {
+        const embedUrl = await this.getEmbedUrl();
+        // sanitise and create an object from an url
+        let url = new URL(ExperienceImpl.sanitiseUrl(embedUrl));
+        // override host and project with those that are set in SDK instance
+        url.searchParams.set(exports.QueryParam.Host, this.sdk.options.host);
+        url.searchParams.set(exports.QueryParam.Project, this.sdk.options.projectId);
+        // if custom experienceUrl is set:
+        // * take experienceUrl as the base
+        // * search params from experienceUrl have priority
+        if (this.config.experienceUrl !== null) {
+            // sanitise and create an object from a custom url
+            const customUrl = new URL(ExperienceImpl.sanitiseUrl(this.config.experienceUrl));
+            // apply embedUrl query parameters if they don't exist in experienceUrl
+            Array.from(url.searchParams.entries())
+                .filter(([key]) => !customUrl.searchParams.has(key))
+                .forEach(([key, value]) => customUrl.searchParams.set(key, value));
+            url = customUrl;
+        }
+        // Prepare a final list of query parameters
+        const queryParameters = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (this.config.host !== undefined && {
+            [exports.QueryParam.Host]: this.config.host,
+        })), (this.config.projectId !== undefined && {
+            [exports.QueryParam.Project]: this.config.projectId,
+        })), (this.config.eventId !== undefined && {
+            [exports.QueryParam.Event]: this.config.eventId,
+        })), { [exports.QueryParam.BridgeId]: this.bridge.id, [exports.QueryParam.HideHeaderAndFooter]: this.config.hidesHeadersAndFooters
+                ? '1'
+                : '0', [exports.QueryParam.AutoresizesHeight]: this.config.autoresizesHeight ? '1' : '0' }), this._parameters);
+        Object.entries(queryParameters).forEach(([key, value]) => {
+            url.searchParams.set(key, value);
+        });
+        return url.href;
+    }
+    static sanitiseUrl(url, options) {
+        const stripReservedParameters = (options === null || options === void 0 ? void 0 : options.stripReservedParameters) || 'mic';
+        // Ensure the URL includes a protocol.
+        if (/^http/.test(url) === false) {
+            // If none are found, use the same as the document.
+            url = `${document.location.protocol}${url}`;
+        }
+        const urlObj = new URL(url);
+        Object.values(exports.QueryParam)
+            .filter((key) => {
+            if (stripReservedParameters === 'mic') {
+                return key.startsWith('mic');
+            }
+            return key;
+        })
+            .forEach((key) => urlObj.searchParams.delete(key));
+        return urlObj.href;
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2025-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const integrations = new Map();
+function addIntegration(container, integration) {
+    integrations.set(container, integration);
+}
+function getIntegration(containerOrExperience) {
+    if (containerOrExperience instanceof HTMLElement) {
+        return integrations.get(containerOrExperience);
+    }
+    return Array.from(integrations.values()).find((integration) => integration.experience === containerOrExperience);
+}
+function deleteIntegration(container) {
+    integrations.delete(container);
+}
+function hasIntegration(containerOrExperience) {
+    if (containerOrExperience instanceof HTMLElement) {
+        return integrations.has(containerOrExperience);
+    }
+    return Array.from(integrations.values()).some((integration) => integration.experience === containerOrExperience);
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Event emitter for Experience state changes.
+ *
+ * @internal
+ */
+const stateEmitter = new sdkUtil.Emitter();
+/**
+ * Updates the Experience state and emits a state change event.
+ *
+ * @param experience - The Experience instance to update
+ * @param newState - The target state to transition to
+ *
+ * @internal
+ */
+function updateExperienceState(experience, newState) {
+    const currentState = experience.state;
+    // No-op if already in the target state
+    if (currentState === newState) {
+        return;
+    }
+    // Cast to ExperienceImpl to access the mutable state property
+    experience.state = newState;
+    stateEmitter.emit('stateChanged', experience, newState);
+}
+function onStateChanged(experienceOrCallback, callback) {
+    if (typeof experienceOrCallback === 'function') {
+        // Global handler: onStateChanged(callback)
+        const globalCallback = experienceOrCallback;
+        stateEmitter.on('stateChanged', globalCallback);
+        return () => {
+            stateEmitter.off('stateChanged', globalCallback);
+        };
+    }
+    // Instance handler: onStateChanged(experience, callback)
+    const experience = experienceOrCallback;
+    const instanceCallback = callback;
+    const wrappedCallback = (exp, state) => {
+        if (exp === experience) {
+            instanceCallback(state);
+        }
+    };
+    stateEmitter.on('stateChanged', wrappedCallback);
+    return () => {
+        stateEmitter.off('stateChanged', wrappedCallback);
+    };
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/* eslint-enable  */
+function getLoadingTemplate() {
+    return `
+    <div>
+      <style type="text/css">
+        .__mic-loader {
+          position: absolute;
+          width: 100%;
+          height: 100%;
+          z-index: 9;
+          box-sizing: border-box;
+          text-align: center;
+          background: #fff;
+        }
+
+        .__mic-loader__container {
+          padding: 20px 0;
+          gap: 20px;
+          min-height: ${DEFAULT_HEIGHT}px;
+          display: flex;
+          flex-direction: column;
+          justify-content: center;
+          align-items: center;
+        }
+
+        .__mic-loader__spinner {
+          position: relative;
+          width: 10px;
+          height: 10px;
+          border-radius: 5px;
+          background-color: #0b0f1c;
+          color: #0b0f1c;
+          animation: mic-loader__animation 1s infinite linear alternate;
+          animation-delay: 0.5s;          
+        }
+
+        .__mic-loader__spinner::before,
+        .__mic-loader__spinner::after {
+          content: "";
+          display: inline-block;
+          position: absolute;
+          top: 0;
+        }
+
+        .__mic-loader__spinner::before {
+          left: -15px;
+          width: 10px;
+          height: 10px;
+          border-radius: 5px;
+          background-color: #0b0f1c;
+          color: #0b0f1c;
+          animation: mic-loader__animation 1s infinite alternate;
+          animation-delay: 0s;
+        }
+
+        .__mic-loader__spinner::after {
+          left: 15px;
+          width: 10px;
+          height: 10px;
+          border-radius: 5px;
+          background-color: #0b0f1c;
+          color: #0b0f1c;
+          animation: mic-loader__animation 1s infinite alternate;
+          animation-delay: 1s;
+        }
+
+        @keyframes mic-loader__animation {
+          0% {
+            background-color: #0b0f1c;
+          }
+          50%, 100% {
+            background-color: rgba(11, 15, 28, 0.2);
+          }
+        }
+      </style>
+      <div class="__mic-loader">
+        <div class="__mic-loader__container">
+          <div class="__mic-loader__spinner"></div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+function embed$1(container, loadingTemplate = getLoadingTemplate) {
+    /**
+     * Return existing element if it exists
+     */
+    let loaderElement = container.querySelector('[data-role=loader]');
+    if (loaderElement !== null) {
+        return loaderElement;
+    }
+    /**
+     * Stash and apply some custom styles to container element
+     */
+    stashStyles(container, ['minHeight', 'position']);
+    container.style.minHeight = `${DEFAULT_HEIGHT}px`;
+    /**
+     * Inject loader element built from the html markup template
+     */
+    const templateElement = document.createElement('template');
+    templateElement.innerHTML = loadingTemplate().trim();
+    loaderElement = container.appendChild(templateElement.content.firstElementChild);
+    /**
+     * Setting custom data attribute to be able to distinguish element along
+     * other injected html elements if any
+     */
+    loaderElement.setAttribute('data-role', 'loader');
+    return loaderElement;
+}
+function unmount$1(container) {
+    var _a;
+    const loaderElement = container.querySelector('[data-role=loader]');
+    if (loaderElement === null) {
+        return;
+    }
+    (_a = loaderElement.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(loaderElement);
+    unstashStyles(container);
+}
+async function show(container, loadingTemplate = getLoadingTemplate) {
+    const loaderElement = embed$1(container, loadingTemplate);
+    const { position } = getComputedStyle(container);
+    /**
+     * In order to properly position the loader,
+     * the container's position should be anything but 'static'.
+     */
+    if (position === 'static') {
+        container.style.position = 'relative';
+    }
+    /**
+     * Setting styles to the loader for a nice fade in animation
+     */
+    loaderElement.style.opacity = '0';
+    /**
+     * Kicking fade animation in.
+     */
+    setTimeout(() => {
+        loaderElement.style.transition = `all ${LOADER_ANIMATION_DURATION}ms`;
+        loaderElement.style.opacity = '1';
+    }, 0);
+    /**
+     * Wait until the animation is finished. We do not use "transitionend" event
+     * here as it will just make the code more bloated and unnecessary complex.
+     */
+    await sdkUtil.delay(LOADER_ANIMATION_DURATION);
+}
+async function hide(container) {
+    const loaderElement = container.querySelector('[data-role=loader]');
+    if (loaderElement === null) {
+        return;
+    }
+    /**
+     * Kicking fade out animation.
+     */
+    setTimeout(() => {
+        loaderElement.style.opacity = '0';
+    }, 0);
+    /**
+     * Wait until the animation is finished. We do not use "transitionend" event
+     * here as it will just make the code more bloated and unnecessary complex.
+     */
+    await sdkUtil.delay(LOADER_ANIMATION_DURATION);
+    unstashStyles(container);
+    unmount$1(container);
+}
+function stashStyles(element, props) {
+    const styles = getComputedStyle(element);
+    const stash = props
+        .map((prop) => `${String(prop)}=${styles[prop]}`)
+        .join(';');
+    element.setAttribute('data-stash', stash);
+}
+function unstashStyles(element) {
+    const stash = element.getAttribute('data-stash');
+    if (stash === null) {
+        return;
+    }
+    const attributes = stash
+        .split(';')
+        .map((attr) => attr.split('='));
+    for (const [attr, value] of attributes) {
+        element.style[attr] = value;
+    }
+    element.removeAttribute('data-stash');
+}
+
+var version = "2.0.0-rc.4";
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * The current SDK version.
+ *
+ * @internal
+ */
+const VERSION = version;
+/**
+ * Creates an iframe with the provided parameters.
+ *
+ * @param url Url of the web app.
+ *
+ * @private
+ */
+function createIFrame(url, options = {}) {
+    const iframe = document.createElement('iframe');
+    iframe.style.width = '100%';
+    iframe.style.height = '100%';
+    iframe.style.border = '0';
+    iframe.style.display = 'block';
+    iframe.style.boxSizing = 'border-box';
+    iframe.setAttribute('src', url);
+    if (options.id !== undefined) {
+        iframe.setAttribute('id', options.id);
+    }
+    if (options.allow !== undefined) {
+        iframe.setAttribute('allow', options.allow);
+    }
+    if (options.allowFullScreen === true) {
+        iframe.setAttribute('allowfullscreen', '');
+    }
+    if (options.title !== undefined) {
+        iframe.setAttribute('title', options.title);
+    }
+    /**
+     * Though scrolling attribute is deprecated we still have to rely on it as some
+     * browsers (e.g. Chrome, as of now version 103) just ignores overflow: hidden.
+     * Hence we are setting scrolling to no in order to eliminate scroll and calculate
+     * width of the child Experience correctly. If scroll persists it appears on each
+     * content change what leads to incorrect width calculation.
+     *
+     * Later we will look into alternatives such as iframeless Experience embed
+     */
+    if (!options.scrolling) {
+        iframe.style.overflow = 'hidden';
+        iframe.setAttribute('scrolling', 'no');
+    }
+    return iframe;
+}
+function concealIFrame(iframe) {
+    iframe.style.opacity = '0';
+}
+function revealIFrame(iframe) {
+    iframe.style.opacity = '1';
+}
+function isSdk(value) {
+    return value instanceof sdkCore.Sdk;
+}
+function getExperience(sdkOrConfig, config) {
+    let sdk;
+    let experienceConfig;
+    if (isSdk(sdkOrConfig)) {
+        /**
+         * Interface: getExperience(sdk, config?)
+         */
+        sdk = sdkOrConfig;
+        if (config !== undefined) {
+            experienceConfig = config;
+        }
+        else {
+            experienceConfig = {};
+        }
+    }
+    else if (sdkOrConfig !== undefined) {
+        /**
+         * Interface: getExperience(config)
+         */
+        sdk = sdkCore.getSdk();
+        experienceConfig = sdkOrConfig;
+    }
+    else {
+        /**
+         * Interface: getExperience()
+         */
+        sdk = sdkCore.getSdk();
+        experienceConfig = {};
+    }
+    const experience = new ExperienceImpl(sdk, experienceConfig);
+    return experience;
+}
+async function waitForAction(experience, action) {
+    return new Promise((resolve) => {
+        const unsubscribe = onSdkMessage(experience, (message) => {
+            if (message.action === action) {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+}
+async function experienceReady(experience) {
+    /**
+     * Bumper delay during which loading state can't be hidden even
+     * if Experience loaded earlier than timer reached bumper timeout
+     */
+    const bumper = sdkUtil.delay(LOADER_BUMPER_TIMEOUT);
+    /**
+     * Final cut off timeout delay after which loading state must
+     * be hidden even if Experience is still loading
+     */
+    const timeout = sdkUtil.delay(LOADER_TIMEOUT);
+    const loaded = waitForAction(experience, exports.Action.OnReady);
+    const hasFullyLoadedExperience = Promise.all([bumper, loaded]);
+    const eitherTimeoutOrFullyLoaded = Promise.race([
+        timeout,
+        hasFullyLoadedExperience,
+    ]);
+    return eitherTimeoutOrFullyLoaded;
+}
+/**
+ * Embeds a web Experience app into an iframe.
+ *
+ * @remarks
+ * There is only one app that can be associated with an Experience and it is
+ * configured in Monterosa / Interaction Cloud. Please refer to the developer
+ * guide for more information:
+ * {@link https://products.monterosa.co/mic/developer-guides/whats-an-app}
+ *
+ * @example
+ * ```javascript
+ * const experience = getExperience();
+ *
+ * embed(experience, 'container-id');
+ * ```
+ * @param experience - An instance of Experience
+ * @param containerOrId - HTML element instance or
+ *     element id where iframe is embedded into.
+ *
+ * @public
+ */
+async function embed(experience, containerOrId) {
+    const container = containerOrId instanceof HTMLElement
+        ? containerOrId
+        : document.getElementById(containerOrId);
+    if (container === null) {
+        throw new Error(`Container element "${containerOrId}" not found in DOM. ` +
+            'Please ensure the element exists before calling embed().');
+    }
+    if (hasIntegration(container)) {
+        throw new Error('Container already contains an embedded experience. Use unmount() first ' +
+            'to remove the existing experience before embedding a new one.');
+    }
+    if (hasIntegration(experience)) {
+        throw new Error('This experience is already embedded in another container. Use unmount() ' +
+            'to remove it from that container before embedding it into this one.');
+    }
+    const controller = new AbortController();
+    const integration = {
+        container,
+        experience,
+        controller,
+    };
+    addIntegration(container, integration);
+    if (experience.config.supportsLoadingState === true) {
+        // Although showLoader is an asynchronous function, we execute
+        // it synchronously to embed the iframe as quickly as possible.
+        show(container, experience.config.loadingTemplate);
+    }
+    const url = await experience.getUrl();
+    if (controller.signal.aborted) {
+        return;
+    }
+    const iframe = createIFrame(url, {
+        id: experience.bridge.iFrameId,
+        scrolling: !experience.config.autoresizesHeight,
+        allow: experience.config.allow,
+        allowFullScreen: experience.config.allowFullScreen,
+        title: experience.config.title,
+    });
+    container.appendChild(iframe);
+    concealIFrame(iframe);
+    updateExperienceState(experience, 'mounted');
+    await waitForAction(experience, exports.Action.OnExperienceInitialised);
+    if (controller.signal.aborted) {
+        return;
+    }
+    updateExperienceState(experience, 'initialised');
+    await experienceReady(experience);
+    if (controller.signal.aborted) {
+        return;
+    }
+    updateExperienceState(experience, 'ready');
+    revealIFrame(iframe);
+    if (experience.config.supportsLoadingState === true) {
+        await hide(container);
+    }
+}
+/**
+ * Removes an Experience from its container and resets its state to `unmounted`.
+ *
+ * This is the preferred method for removing an embedded Experience.
+ * Use {@link onStateChanged} to observe when the Experience transitions
+ * to the `unmounted` state.
+ *
+ * @example
+ * ```javascript
+ * const experience = getExperience(sdk, { eventId: 'poll-123' });
+ * embed(experience, container);
+ *
+ * // Later, to remove:
+ * unembed(experience);
+ * ```
+ *
+ * @param experience - The Experience instance to unembed
+ *
+ * @public
+ */
+function unembed(experience) {
+    const integration = getIntegration(experience);
+    if (!integration) {
+        throw new Error('This Experience is not currently embedded. ' +
+            'Please ensure the Experience is embedded before calling unembed().');
+    }
+    const { container } = integration;
+    integration.controller.abort();
+    while (container.lastElementChild) {
+        container.removeChild(container.lastElementChild);
+    }
+    deleteIntegration(container);
+    container.style.height = '';
+    updateExperienceState(experience, 'unmounted');
+}
+/**
+ * Unmounts web Experience app which was previously embedded in the container.
+ *
+ * @deprecated Use {@link unembed} instead, which takes an Experience instance
+ * rather than a container.
+ *
+ * @example
+ * ```javascript
+ * unmount('container-id');
+ * ```
+ *
+ * @param {HTMLElement | string} containerOrId - HTML element instance or
+ *     element id where iframe is embedded into.
+ *
+ * @public
+ */
+function unmount(containerOrId) {
+    console.warn('[launcher-kit] unmount() is deprecated. Use unembed(experience) instead.');
+    const container = containerOrId instanceof HTMLElement
+        ? containerOrId
+        : document.getElementById(containerOrId);
+    if (container === null) {
+        throw new Error(`Container element "${containerOrId}" not found in DOM. ` +
+            'Please ensure the element exists before calling unmount().');
+    }
+    const integration = getIntegration(container);
+    if (!integration) {
+        throw new Error(`No Experience found embedded in container "${containerOrId}". ` +
+            'Please ensure the Experience is embedded before calling unmount().');
+    }
+    integration.controller.abort();
+    while (container.lastElementChild) {
+        container.removeChild(container.lastElementChild);
+    }
+    deleteIntegration(container);
+    container.style.height = '';
+    updateExperienceState(integration.experience, 'unmounted');
+}
+/**
+ * Informs the Experience that more data should be loaded and displayed on the UI.
+ *
+ * @remarks
+ * One example is when Experience renders items feed partially. Once a user scrolled
+ * to the bottom edge of the app, more elements to load is requested.
+ *
+ * @param experience - Experience instance
+ */
+function requestMoreData(experience) {
+    sendSdkMessage(experience, exports.Action.OnMoreDataRequested);
+}
+function enableLogging(logLevelOrFlag = true) {
+    if (typeof logLevelOrFlag === 'boolean') {
+        logger.logLevel = logLevelOrFlag ? sdkCore.LogLevel.Verbose : sdkCore.LogLevel.Silent;
+        return;
+    }
+    logger.logLevel = logLevelOrFlag;
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const ELEMENT_NAME = 'monterosa-experience';
+class MonterosaExperienceElement extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        this._experience = null;
+    }
+    /**
+     * The host URL for the Experience.
+     */
+    get host() {
+        return this.getAttribute('host') || '';
+    }
+    /**
+     * The project identifier.
+     */
+    get projectId() {
+        return this.getAttribute('projectId') || '';
+    }
+    /**
+     * The event identifier (optional).
+     */
+    get eventId() {
+        return this.getAttribute('eventId') || undefined;
+    }
+    async connectedCallback() {
+        const host = this.getAttribute('host');
+        if (host === null) {
+            throw new Error('Host attribute is not set for Experience element');
+        }
+        const projectId = this.getAttribute('projectId');
+        if (projectId === null) {
+            throw new Error('Project attribute is not set  for Experience element');
+        }
+        const autoresizesHeight = this.getAttribute('autoresizesHeight') !== null;
+        const hidesHeadersAndFooters = this.getAttribute('hidesHeadersAndFooters') !== null;
+        const eventId = this.getAttribute('eventId') !== null
+            ? this.getAttribute('eventId')
+            : undefined;
+        const experienceUrl = this.getAttribute('experienceUrl') !== null
+            ? this.getAttribute('experienceUrl')
+            : undefined;
+        const allow = this.getAttribute('allow') !== null
+            ? this.getAttribute('allow')
+            : undefined;
+        const allowFullScreen = this.getAttribute('allowFullScreen') !== null;
+        const parameters = {};
+        for (let i = 0; i < this.attributes.length; i++) {
+            const attr = this.attributes[i];
+            if (attr.name.startsWith('param-')) {
+                const paramName = attr.name.split('param-')[1];
+                parameters[paramName] = attr.value;
+            }
+        }
+        const title = this.getAttribute('title') !== null
+            ? this.getAttribute('title')
+            : undefined;
+        const sdk = sdkCore.configure({
+            host,
+            projectId,
+        }, `${host}-${projectId}`);
+        const experience = getExperience(sdk, {
+            autoresizesHeight,
+            eventId,
+            hidesHeadersAndFooters,
+            experienceUrl,
+            allow,
+            allowFullScreen,
+            parameters,
+            title,
+        });
+        // Link the custom element to the experience
+        experience.customElement = this;
+        this._experience = experience;
+        embed(experience, this);
+        // eslint-disable-next-line
+        onSdkMessage(experience, ({ payload, action }) => {
+            switch (action) {
+                case exports.Action.OnExperienceInitialised:
+                    break;
+                case exports.Action.OnResize: {
+                    // const { width, height } = payload;
+                    break;
+                }
+                case exports.Action.OnReady:
+                    this.dispatchEvent(new CustomEvent('ready', {
+                        bubbles: true,
+                        cancelable: false,
+                        composed: true,
+                    }));
+                    break;
+            }
+        });
+    }
+    disconnectedCallback() {
+        const experience = this._experience;
+        this._experience = null;
+        if (experience) {
+            try {
+                unembed(experience);
+            }
+            catch (_a) {
+                // Experience may already have been unembedded
+            }
+        }
+    }
+}
+if (!customElements.get(ELEMENT_NAME)) {
+    customElements.define(ELEMENT_NAME, MonterosaExperienceElement);
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2025-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+const unsubs$1 = new Map();
+function handleExperienceEmbedded$1(experience) {
+    if (!experience.config.autoresizesHeight) {
+        return;
+    }
+    const integration = getIntegration(experience);
+    if (!integration) {
+        return;
+    }
+    const { container } = integration;
+    const unsub = onSdkMessage(experience, ({ action, payload }) => {
+        if (action === exports.Action.OnResize) {
+            /**
+             * Container width is maintained the same as it is defined in the parent
+             * page to preserve its behaviour. Only the height is updated
+             */
+            // container.style.width = `${payload.width}px`;
+            container.style.height = `${payload.height}px`;
+        }
+    });
+    unsubs$1.set(experience.id, unsub);
+}
+function handleExperienceUnmounted$1(experience) {
+    const unsub = unsubs$1.get(experience.id);
+    if (unsub) {
+        unsub();
+        unsubs$1.delete(experience.id);
+    }
+}
+onStateChanged((experience, state) => {
+    if (state === 'mounted') {
+        handleExperienceEmbedded$1(experience);
+    }
+    else if (state === 'unmounted') {
+        handleExperienceUnmounted$1(experience);
+    }
+});
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-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 ParentApplicationImpl {
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2023 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+let parentApplication;
+/**
+ * Returns instance of parent application.
+ *
+ * @returns Returns {@link ParentApplication}
+ * if an Experience resides within the parent application, and it was embedded
+ * using {@link embed} function. Otherwise it returns `null`.
+ */
+function getParentApplication() {
+    if (parentApplication !== undefined) {
+        return parentApplication;
+    }
+    const parentBridge = getParentBridge();
+    if (parentBridge === null) {
+        return null;
+    }
+    parentApplication = new ParentApplicationImpl(parentBridge);
+    return parentApplication;
+}
+
+/**
+ * @license
+ * @monterosa/sdk-launcher-kit
+ *
+ * Copyright © 2022-2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+function getUrlParam(param) {
+    let queryString = {};
+    if (typeof window !== 'undefined') {
+        queryString = window.location.search;
+    }
+    const urlParams = new URLSearchParams(queryString);
+    return urlParams.get(param);
+}
+/**
+ * Returns whether the Experience should hide its header and footer.
+ *
+ * @remarks
+ * The SDK on the parent application will by default request a child
+ * Experience to hide its header and footer by setting a query parameter called
+ * `micHideHeaderAndFooter` to `1`.
+ *
+ * When true, the developer of a child Experience is expected to hide it's headers
+ * and footers as the parent application is actively providing them.
+ *
+ * You can test whether you are respecting this correctly by adding the following query
+ * to your URL:
+ *
+ * "?micHideHeaderAndFooter=1"
+ *
+ * @returns Whether the header and footer views should be hidden.
+ */
+function shouldHideHeaderAndFooter() {
+    return getUrlParam(exports.QueryParam.HideHeaderAndFooter) === '1';
+}
+/**
+ * This function will returns true if experience is embedded in autoresize height mode.
+ */
+function isAutoresizesHeight() {
+    return getUrlParam(exports.QueryParam.AutoresizesHeight) === '1';
+}
+/**
+ * Notifies the parent application that the Experience has initialised and
+ * is ready to receive messages. This triggers the `initialised` lifecycle state.
+ *
+ * Call this method when your Experience has completed its initial setup and
+ * is ready to receive configuration or other messages from the parent application.
+ *
+ * @example
+ * ```javascript
+ * import { sendInitialised } from '@monterosa/sdk-launcher-kit';
+ *
+ * // After your Experience has initialised
+ * sendInitialised();
+ * ```
+ */
+function sendInitialised() {
+    const parentApp = getParentApplication();
+    if (parentApp === null) {
+        console.log('Unable to send initialised message, as there is no parent application');
+        return;
+    }
+    sendSdkMessage(parentApp, exports.Action.OnExperienceInitialised);
+}
+/**
+ * Notifies the parent application that the Experience UI is fully loaded
+ * and ready to be displayed. This triggers the `ready` lifecycle state.
+ *
+ * @remarks
+ * Call this method when your UI has completed loading and you are ready to
+ * display data to the user. This can be when your network calls have successfully
+ * requested data and you have updated the DOM, or when an error has occurred and
+ * you want to take over the UI to provide details to the user.
+ *
+ * The SDK will use this message to dismiss the loading indicator, allowing a
+ * seamless transition between a native loading UI and the fully loaded Experience.
+ *
+ * If this call is not made, the parent SDK will add a grace period to ensure
+ * the web app has sufficient time to load, and eventually dismiss the loading
+ * state to avoid infinite loading scenarios.
+ *
+ * @example
+ * ```javascript
+ * import { sendReady } from '@monterosa/sdk-launcher-kit';
+ *
+ * // After your UI has finished loading
+ * sendReady();
+ * ```
+ */
+function sendReady() {
+    const parentApp = getParentApplication();
+    if (parentApp === null) {
+        console.log('Unable to send ready message, as there is no parent application');
+        return;
+    }
+    sendSdkMessage(parentApp, exports.Action.OnReady);
+}
+/**
+ * @deprecated Use {@link sendReady} instead.
+ *
+ * Sends a message to the SDK of the parent application informing it that
+ * the UI of this Experience has completed loading.
+ */
+function sendFinishedLoadingUI() {
+    console.warn('[launcher-kit] sendFinishedLoadingUI() is deprecated. Use sendReady() instead.');
+    sendReady();
+}
+/**
+ * Adds an observer for when more data is requested by the parent application
+ *
+ * @param callback - The callback that is triggered when a request for more data
+ * is received
+ * @returns The unsubscribe function. When it's called,
+ * the observer will be removed and requests for data will no longer be received
+ */
+function onMoreDataRequested(callback) {
+    const parentApp = getParentApplication();
+    if (parentApp === null) {
+        console.log('Unable to subscribe to more data event, as there is no parent application');
+        return () => { };
+    }
+    return onSdkMessage(parentApp, ({ action }) => {
+        if (action === exports.Action.OnMoreDataRequested) {
+            callback();
+        }
+    });
+}
+/**
+ * Adds an observer for when experience is fully embedded and ready to accept
+ * incoming messages
+ *
+ * @deprecated Use `onStateChanged(experience, (state) => {
+ *   if (state === 'initialised') ...
+ * })` instead.
+ *
+ * @param experience - Experience instance
+ * @param callback - The callback that is triggered when experience is embedded
+ * @returns The unsubscribe function. When it's called, the observer will be
+ * removed and ready event will not be received
+ */
+function onReady(experience, callback) {
+    console.warn('[launcher-kit] onReady() is deprecated. Use onStateChanged(' +
+        "experience, (state) => { if (state === 'initialised') ... }) instead.");
+    return onSdkMessage(experience, ({ action }) => {
+        if (action === exports.Action.OnExperienceInitialised) {
+            callback();
+        }
+    });
+}
+/**
+ * @internal
+ */
+const sendExperienceSizeThrottled = sdkUtil.throttle((width, height) => {
+    const parentApp = getParentApplication();
+    if (parentApp !== null) {
+        sendSdkMessage(parentApp, exports.Action.OnResize, { width, height });
+    }
+}, RESIZE_THROTTLE_TIMEOUT, {
+    leading: true,
+    trailing: true,
+});
+/**
+ * Sends the Experience size to the parent page.
+ *
+ * @param width - The width of the Experience.
+ * @param height - The height of the Experience.
+ */
+function sendExperienceSize(width, height) {
+    sendExperienceSizeThrottled(width, height);
+}
+/**
+ * Sets up an observer to watch for the element dimensions change and
+ * automatically reports their changes to the parent application.
+ *
+ * @param element - HTML element whose dimensions need to be watched
+ * @returns The unsubscribe function. When it's called,
+ * the observer will be removed and element dimensions are no longer tracked
+ */
+function reportExperienceSizeChanges(element) {
+    const observer = new ResizeObserver(() => {
+        const width = Math.max(element.offsetWidth, element.scrollWidth);
+        const height = Math.max(element.offsetHeight, element.scrollHeight);
+        sendExperienceSize(width, height);
+    });
+    observer.observe(element);
+    return () => observer.unobserve(element);
+}
+
+/**
+ * @license
+ * share.ts
+ * launcher-kit
+ *
+ * Copyright © 2026 Monterosa Productions Limited. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Share requests block on the native share tray which waits for user
+ * interaction (composing a message, picking a target app, etc.). The default
+ * bridge timeout of 20 seconds is too short for this. 5 minutes gives users
+ * ample time while still acting as a safety net against lost messages.
+ */
+const SHARE_REQUEST_TIMEOUT = 300000;
+exports.ShareError = void 0;
+(function (ShareError) {
+    ShareError["ParentAppError"] = "parent_app_error";
+    ShareError["ShareFailed"] = "share_failed";
+})(exports.ShareError || (exports.ShareError = {}));
+const ShareErrorMessages = {
+    [exports.ShareError.ParentAppError]: (error) => `Parent application error: ${error}`,
+    [exports.ShareError.ShareFailed]: (error) => `Share failed: ${error}`,
+};
+/**
+ * Executes share using the Web Share API.
+ *
+ * @internal
+ */
+async function executeShare(data) {
+    try {
+        await navigator.share({
+            url: data.url,
+            title: data.title,
+            text: data.description,
+        });
+        return 'success';
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === 'AbortError') {
+            return 'cancelled';
+        }
+        throw sdkUtil.createError(exports.ShareError.ShareFailed, ShareErrorMessages, sdkUtil.getErrorMessage(err));
+    }
+}
+/**
+ * Initiates a share action. When running inside a parent application,
+ * the share request is sent to the parent via the communication bridge.
+ * When running standalone, `navigator.share()` is called directly.
+ *
+ * @param data - The data to share
+ */
+async function share(data) {
+    const parentApp = getParentApplication();
+    if (parentApp !== null) {
+        const response = await sendSdkRequest(parentApp, exports.Action.OnShare, data, SHARE_REQUEST_TIMEOUT);
+        if (response.payload.error !== undefined) {
+            throw sdkUtil.createError(exports.ShareError.ParentAppError, ShareErrorMessages, response.payload.error);
+        }
+        // 'success' and 'cancelled' both resolve silently
+        return;
+    }
+    await executeShare(data);
+}
+/**
+ * Registers a callback to be called when a share request is received
+ * from a child Experience.
+ *
+ * @param experience - The Experience instance to listen on
+ * @param callback - Called with ShareData when a share request is received
+ * @returns Unsubscribe function
+ */
+function onShare(experience, callback) {
+    return onSdkMessage(experience, (message) => {
+        if (message.action === exports.Action.OnShare) {
+            callback(message.payload);
+        }
+    });
+}
+const unsubs = new Map();
+function handleExperienceEmbedded(experience) {
+    const unsub = onSdkMessage(experience, async (message) => {
+        if (message.action !== exports.Action.OnShare) {
+            return;
+        }
+        try {
+            const parentApp = getParentApplication();
+            let payload;
+            if (parentApp !== null) {
+                const response = await sendSdkRequest(parentApp, exports.Action.OnShare, message.payload, SHARE_REQUEST_TIMEOUT);
+                payload = response.payload;
+            }
+            else {
+                const result = await executeShare(message.payload);
+                payload = {
+                    result,
+                    message: result === 'success' ? 'Share successful' : 'Share cancelled',
+                    data: {},
+                };
+            }
+            respondToSdkMessage(experience, message, payload);
+        }
+        catch (err) {
+            respondToSdkMessage(experience, message, {
+                error: sdkUtil.getErrorMessage(err),
+            });
+        }
+    });
+    unsubs.set(experience.id, unsub);
+}
+function handleExperienceUnmounted(experience) {
+    const unsub = unsubs.get(experience.id);
+    if (unsub) {
+        unsub();
+        unsubs.delete(experience.id);
+    }
+}
+onStateChanged((experience, state) => {
+    if (state === 'mounted') {
+        handleExperienceEmbedded(experience);
+    }
+    else if (state === 'unmounted') {
+        handleExperienceUnmounted(experience);
+    }
+});
+
+exports.BRIDGE_VERSION = VERSION$1;
+exports.BridgeImpl = BridgeImpl;
+exports.ExperienceImpl = ExperienceImpl;
+exports.ParentApplicationImpl = ParentApplicationImpl;
+exports.ShareErrorMessages = ShareErrorMessages;
+exports.VERSION = VERSION;
+exports.embed = embed;
+exports.enableLogging = enableLogging;
+exports.executeShare = executeShare;
+exports.getBridge = getBridge;
+exports.getExperience = getExperience;
+exports.getParentApplication = getParentApplication;
+exports.getParentBridge = getParentBridge;
+exports.isAutoresizesHeight = isAutoresizesHeight;
+exports.isInsideIframe = isInsideIframe;
+exports.onMessage = onMessage;
+exports.onMoreDataRequested = onMoreDataRequested;
+exports.onReady = onReady;
+exports.onSdkMessage = onSdkMessage;
+exports.onShare = onShare;
+exports.onStateChanged = onStateChanged;
+exports.reportExperienceSizeChanges = reportExperienceSizeChanges;
+exports.requestMoreData = requestMoreData;
+exports.respondToMessage = respondToMessage;
+exports.respondToSdkMessage = respondToSdkMessage;
+exports.sendExperienceSize = sendExperienceSize;
+exports.sendExperienceSizeThrottled = sendExperienceSizeThrottled;
+exports.sendFinishedLoadingUI = sendFinishedLoadingUI;
+exports.sendInitialised = sendInitialised;
+exports.sendMessage = sendMessage;
+exports.sendReady = sendReady;
+exports.sendRequest = sendRequest;
+exports.sendSdkMessage = sendSdkMessage;
+exports.sendSdkRequest = sendSdkRequest;
+exports.setRequestTimeout = setRequestTimeout;
+exports.share = share;
+exports.shouldHideHeaderAndFooter = shouldHideHeaderAndFooter;
+exports.stateEmitter = stateEmitter;
+exports.unembed = unembed;
+exports.unmount = unmount;
+exports.updateExperienceState = updateExperienceState;
+//# sourceMappingURL=index.cjs.map