@elliemae/ssf-host 2.0.0-next.29

package/dist/cjs/host.js

@@ -0,0 +1,930 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var host_exports = {};
+__export(host_exports, {
+  SSFHost: () => SSFHost
+});
+module.exports = __toCommonJS(host_exports);
+var import_uuid = require("uuid");
+var import_ssf_common = require("@elliemae/ssf-common");
+var import_types = require("./types.js");
+var import_guest = require("./guest.js");
+var import_utils = require("./utils.js");
+var _remoting, _correlationId, _logger, _nextGuestId, _guests, _publishedObjects, _readyStateCallback, _popupGuestMonitor, _closeAllPopupGuests, _getGuestForWindow, _getGuestForUrl, _isScriptingObject, _encodeResponse, _encodeException, _dispatchConfigEvent, _invoke, _handleGuestReadyComplete, _handleGuestReady, _handleGuestClose, _handleObjectGet, _handleGuestResize, _handleObjectInvoke, _subscribeToGuestResizeEvent, _connect, _isProxyEvent, _attachGuest, _monitorPopupGuests, _openPopupGuest, _openEmbedGuest, _getGuestUrl;
+const SANDBOX_DEFAULT = [
+  import_types.IFrameSandboxValues.AllowScripts,
+  import_types.IFrameSandboxValues.AllowPopups,
+  import_types.IFrameSandboxValues.AllowModals,
+  import_types.IFrameSandboxValues.AllowForms,
+  import_types.IFrameSandboxValues.AllowDownloads,
+  import_types.IFrameSandboxValues.AllowSameOrigin
+].join(" ");
+class SSFHost {
+  /**
+   * Create a new host
+   *
+   * @param hostId unique identifier for the host
+   * @param {HostOption} option - options for the host
+   */
+  constructor(hostId, option) {
+    /* eslint-enable indent */
+    /**
+     * unique identifier for the host
+     */
+    __publicField(this, "hostId");
+    /**
+     * reference to the remoting object
+     */
+    __privateAdd(this, _remoting, void 0);
+    __privateAdd(this, _correlationId, void 0);
+    /**
+     * reference to the logger
+     */
+    __privateAdd(this, _logger, void 0);
+    /**
+     * next guest id
+     */
+    __privateAdd(this, _nextGuestId, 1);
+    /**
+     * list of guests
+     */
+    __privateAdd(this, _guests, /* @__PURE__ */ new Map());
+    /**
+     * list of published scripting objects
+     */
+    __privateAdd(this, _publishedObjects, /* @__PURE__ */ new Map());
+    /**
+     * callback for ready state
+     */
+    __privateAdd(this, _readyStateCallback, null);
+    /**
+     *
+     */
+    __privateAdd(this, _popupGuestMonitor, null);
+    __privateAdd(this, _closeAllPopupGuests, () => {
+      for (const guest of __privateGet(this, _guests).values()) {
+        if (guest.openMode === import_types.OpenMode.Popup) {
+          this.unloadGuest(guest.id);
+        }
+      }
+    });
+    /**
+     * get the reference to the guest application by its window
+     *
+     * @param guestWindow reference to the guest window
+     * @returns reference to the guest
+     */
+    __privateAdd(this, _getGuestForWindow, (guestWindow) => {
+      for (const guest of __privateGet(this, _guests).values()) {
+        if (guest.window === guestWindow)
+          return guest;
+      }
+      return null;
+    });
+    /**
+     * get the reference to the guest application by its window
+     *
+     * @param url url of the guest application
+     * @returns reference to the guest
+     */
+    __privateAdd(this, _getGuestForUrl, (url) => {
+      for (const guest of __privateGet(this, _guests).values()) {
+        if (guest.url === url)
+          return guest;
+      }
+      return null;
+    });
+    /**
+     * check if a object is a scripting object
+     *
+     * @param value javascript object
+     * @returns true if the object is a scripting object
+     */
+    __privateAdd(this, _isScriptingObject, (value) => (
+      // eslint-disable-next-line no-underscore-dangle, @typescript-eslint/no-unsafe-member-access
+      typeof value?._toJSON === "function"
+    ));
+    __privateAdd(this, _encodeResponse, (val) => {
+      if (__privateGet(this, _isScriptingObject).call(this, val)) {
+        this.addScriptingObject(val);
+        return { type: "object", object: val._toJSON() };
+      }
+      return { type: "value", value: val };
+    });
+    __privateAdd(this, _encodeException, (ex) => {
+      if (typeof ex === "string") {
+        return ex;
+      }
+      if (ex instanceof Error) {
+        return ex.message;
+      }
+      return "An unexpected error occurred in the host application";
+    });
+    __privateAdd(this, _dispatchConfigEvent, (guest) => {
+      if (guest.ready) {
+        __privateGet(this, _remoting).send({
+          targetWin: guest.window,
+          targetOrigin: guest.origin,
+          messageType: import_ssf_common.MessageType.HostConfig,
+          messageBody: {
+            logLevel: __privateGet(this, _logger).getLogLevel(),
+            ...guest.getInfo()
+          }
+        });
+      }
+    });
+    __privateAdd(this, _invoke, ({
+      guest,
+      obj,
+      functionName,
+      functionParams
+    }) => {
+      const func = obj[functionName];
+      if (!(0, import_utils.isFunction)(func)) {
+        __privateGet(this, _logger).warn(
+          `Attempt to call invalid function on object type ${obj.objectType}: ${String(functionName)}`
+        );
+        return Promise.reject(
+          new Error(
+            `Method '${functionName}' not found in Scripting Object '${obj.id}'`
+          )
+        );
+      }
+      __privateGet(this, _logger).debug(
+        `Invoking host implementation of ${obj.id}.${String(functionName)}()`
+      );
+      return new Promise((resolve) => {
+        if (!Object.prototype.hasOwnProperty.call(func, "callContext")) {
+          Object.defineProperty(func, "callContext", {
+            value: { guest },
+            enumerable: true
+          });
+        }
+        resolve(func(...functionParams));
+      });
+    });
+    __privateAdd(this, _handleGuestReadyComplete, ({
+      sourceWin,
+      sourceOrigin,
+      requestId
+    }) => {
+      var _a;
+      const guest = __privateGet(this, _getGuestForWindow).call(this, sourceWin);
+      if (!guest) {
+        __privateGet(this, _logger).warn(
+          `Received ready event for unknown guest. requestId: ${requestId}`
+        );
+        return;
+      }
+      if (!guest.initialized) {
+        __privateGet(this, _logger).warn(
+          "Guest must be initialized before it is marked as ready"
+        );
+        __privateGet(this, _remoting).raiseException({
+          targetWin: sourceWin,
+          targetOrigin: sourceOrigin,
+          requestId,
+          ex: "Guest must be initialized before it is marked as ready"
+        });
+        return;
+      }
+      if (!guest.ready) {
+        guest.ready = true;
+        __privateGet(this, _dispatchConfigEvent).call(this, guest);
+        (_a = __privateGet(this, _readyStateCallback)) == null ? void 0 : _a.call(this, guest);
+        __privateGet(this, _logger).audit({
+          message: `Guest is ready`,
+          ...guest.getInfo()
+        });
+      }
+    });
+    // Initializes a guest when the guest is full loaded
+    __privateAdd(this, _handleGuestReady, ({
+      sourceWin,
+      sourceOrigin,
+      requestId,
+      body
+    }) => {
+      const guest = __privateGet(this, _getGuestForWindow).call(this, sourceWin);
+      if (!guest) {
+        __privateGet(this, _logger).warn(
+          `Received ready event for unknown guest. requestid = ${requestId}`
+        );
+        return;
+      }
+      if (!guest.initialized) {
+        guest.initialized = true;
+        guest.capabilities = body || {};
+        __privateGet(this, _logger).audit({
+          message: `Guest is initialized`,
+          ...guest.getInfo()
+        });
+      }
+      if (!body || !body.onReady) {
+        __privateGet(this, _handleGuestReadyComplete).call(this, {
+          sourceWin,
+          sourceOrigin,
+          requestId,
+          type: "",
+          body: null
+        });
+      }
+    });
+    __privateAdd(this, _handleGuestClose, ({ sourceWin }) => {
+      if (sourceWin?.window)
+        this.unloadGuest(sourceWin);
+    });
+    // Handles object get requests from the remote automation framework
+    __privateAdd(this, _handleObjectGet, ({
+      sourceWin,
+      sourceOrigin,
+      requestId,
+      body
+    }) => {
+      const { objectId } = body;
+      __privateGet(this, _logger).debug(
+        `Processing getObject request for object ${objectId}. requestId = ${requestId}`
+      );
+      const guest = __privateGet(this, _getGuestForWindow).call(this, sourceWin);
+      if (!guest) {
+        __privateGet(this, _logger).warn("Rejected object request from unknown guest window");
+        __privateGet(this, _remoting).raiseException({
+          targetWin: sourceWin,
+          targetOrigin: sourceOrigin,
+          requestId,
+          ex: "Specified window is not a known guest"
+        });
+        return false;
+      }
+      const obj = this.getScriptingObject(objectId);
+      if (!obj) {
+        __privateGet(this, _logger).warn(
+          `unknown or unauthorized object ${objectId} from guest ${guest.id}`
+        );
+        __privateGet(this, _remoting).raiseException({
+          targetWin: sourceWin,
+          targetOrigin: sourceOrigin,
+          requestId,
+          ex: `The requested object (${objectId}) is not available`
+        });
+        return false;
+      }
+      __privateGet(this, _remoting).respond({
+        targetWin: sourceWin,
+        targetOrigin: sourceOrigin,
+        requestId,
+        response: __privateGet(this, _encodeResponse).call(this, obj)
+      });
+      __privateGet(this, _logger).audit({
+        message: `Scripting Object returned`,
+        requestId,
+        scriptingObject: objectId,
+        ...guest.getInfo()
+      });
+      return true;
+    });
+    // handles guest resize event
+    __privateAdd(this, _handleGuestResize, ({
+      sourceWin,
+      requestId,
+      body
+    }) => {
+      const guest = __privateGet(this, _getGuestForWindow).call(this, sourceWin);
+      if (!guest) {
+        __privateGet(this, _logger).warn(
+          `Received resize event from unknown guest. requestid = ${requestId}`
+        );
+        return;
+      }
+      if (guest.domElement) {
+        guest.domElement.style.height = `${body.height}px`;
+      }
+      __privateGet(this, _logger).debug(
+        `Guest ${guest.id} resized to ${body.width}x${body.height}`
+      );
+    });
+    // Handles object invoke requests from the remote automation framework
+    __privateAdd(this, _handleObjectInvoke, ({
+      sourceWin,
+      sourceOrigin,
+      requestId,
+      body
+    }) => {
+      const { objectId } = body;
+      const guest = __privateGet(this, _getGuestForWindow).call(this, sourceWin);
+      if (!guest) {
+        __privateGet(this, _logger).warn(
+          "Rejected method invocation request from unknown guest window"
+        );
+        __privateGet(this, _remoting).raiseException({
+          targetWin: sourceWin,
+          targetOrigin: sourceOrigin,
+          requestId,
+          ex: "Specified window is not a known guest"
+        });
+        return false;
+      }
+      __privateGet(this, _logger).debug(
+        `Function ${objectId}.${String(body.functionName)}() called from guest "${guest.id}" (requestId = ${requestId})`
+      );
+      const obj = this.getScriptingObject(objectId);
+      if (!obj) {
+        __privateGet(this, _logger).warn(
+          `Invocation of unknown or unauthorized object ${objectId} from guest ${guest.id}`
+        );
+        __privateGet(this, _remoting).raiseException({
+          targetWin: sourceWin,
+          targetOrigin: sourceOrigin,
+          requestId,
+          ex: `The requested object (${objectId}) is not available`
+        });
+        return false;
+      }
+      __privateGet(this, _invoke).call(this, {
+        guest,
+        obj,
+        functionName: body.functionName,
+        functionParams: body.functionParams
+      }).then((val) => {
+        __privateGet(this, _remoting).respond({
+          targetWin: sourceWin,
+          targetOrigin: sourceOrigin,
+          requestId,
+          response: __privateGet(this, _encodeResponse).call(this, val)
+        });
+        __privateGet(this, _logger).audit({
+          message: `Value returned for Scripting Object method call`,
+          requestId,
+          scriptingObject: objectId,
+          scriptingMethod: body.functionName,
+          ...guest.getInfo()
+        });
+      }).catch((ex) => {
+        __privateGet(this, _remoting).raiseException({
+          targetWin: sourceWin,
+          targetOrigin: guest.origin,
+          requestId,
+          ex: __privateGet(this, _encodeException).call(this, ex)
+        });
+        __privateGet(this, _logger).audit({
+          message: `Exception thrown for Scripting Object method call`,
+          requestId,
+          scriptingObject: objectId,
+          scriptingMethod: body.functionName,
+          ...guest.getInfo()
+        });
+      });
+      return true;
+    });
+    __privateAdd(this, _subscribeToGuestResizeEvent, () => {
+      __privateGet(this, _remoting).listen({
+        messageType: import_ssf_common.MessageType.GuestResize,
+        callback: __privateGet(this, _handleGuestResize)
+      });
+    });
+    __privateAdd(this, _connect, () => {
+      __privateGet(this, _remoting).listen({
+        messageType: import_ssf_common.MessageType.GuestReady,
+        callback: __privateGet(this, _handleGuestReady)
+      });
+      __privateGet(this, _remoting).listen({
+        messageType: import_ssf_common.MessageType.GuestReadyComplete,
+        callback: __privateGet(this, _handleGuestReadyComplete)
+      });
+      __privateGet(this, _remoting).listen({
+        messageType: import_ssf_common.MessageType.GuestClose,
+        callback: __privateGet(this, _handleGuestClose)
+      });
+      __privateGet(this, _remoting).listen({
+        messageType: import_ssf_common.MessageType.ObjectGet,
+        callback: __privateGet(this, _handleObjectGet)
+      });
+      __privateGet(this, _remoting).listen({
+        messageType: import_ssf_common.MessageType.ObjectInvoke,
+        callback: __privateGet(this, _handleObjectInvoke)
+      });
+      window.addEventListener("visibilitychange", __privateGet(this, _closeAllPopupGuests));
+    });
+    __privateAdd(this, _isProxyEvent, (value) => (
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      value?.constructor?.name === "ProxyEvent"
+    ));
+    /**
+     * Register pre-rendered guest application to host
+     *
+     * @param {AttachParam} param - parameters for attaching the guest
+     * @returns reference to the guest object
+     */
+    __privateAdd(this, _attachGuest, (param) => {
+      const guest = new import_guest.Guest({ ...param, remoting: __privateGet(this, _remoting) });
+      guest.init();
+      __privateGet(this, _guests).set(param.guestId, guest);
+      return guest;
+    });
+    __privateAdd(this, _monitorPopupGuests, () => {
+      __privateSet(this, _popupGuestMonitor, setInterval(() => {
+        const guestsToRemove = [];
+        __privateGet(this, _guests).forEach((guest) => {
+          if (guest.openMode === import_types.OpenMode.Popup && guest.window.closed) {
+            guestsToRemove.push(guest);
+          }
+        });
+        guestsToRemove.forEach((guest) => {
+          this.unloadGuest(guest.id);
+        });
+      }, 1e3));
+    });
+    __privateAdd(this, _openPopupGuest, (param) => {
+      const { url, title, windowFeatures = {}, params, guestId } = param;
+      const { width = 800, height = 600, top = 100, left = 100 } = windowFeatures;
+      let guest = __privateGet(this, _getGuestForUrl).call(this, url);
+      if (guest) {
+        if (!guest.window.closed) {
+          guest.send({
+            messageType: import_ssf_common.MessageType.GuestFocus,
+            messageBody: {}
+          });
+        }
+      } else {
+        const popupWindowFeatures = [
+          { key: "width", value: width },
+          { key: "height", value: height },
+          { key: "top", value: top },
+          { key: "left", value: left }
+        ].reduce((acc, cur, curIndex) => {
+          if (curIndex > 0 && cur.value)
+            acc += ",";
+          return cur.value ? `${acc}${cur.key}=${cur.value}` : acc;
+        }, "");
+        const guestWindow = window.open(
+          url,
+          title,
+          `popup, ${popupWindowFeatures}`
+        );
+        if (!guestWindow)
+          throw new Error("Failed to open guest application in popup window");
+        guestWindow.opener = null;
+        guest = __privateGet(this, _attachGuest).call(this, {
+          guestId,
+          window: guestWindow,
+          title,
+          url,
+          params,
+          openMode: import_types.OpenMode.Popup
+        });
+      }
+      return guest;
+    });
+    __privateAdd(this, _openEmbedGuest, (param) => {
+      const {
+        url,
+        title,
+        targetElement,
+        params,
+        guestId,
+        options = {}
+      } = param;
+      const targetElementDocument = targetElement.ownerDocument ?? document;
+      const {
+        fitToContent = false,
+        disableSandbox = false,
+        sandboxValues = []
+      } = options;
+      if (!title)
+        throw new Error("title is required");
+      if (fitToContent)
+        __privateGet(this, _subscribeToGuestResizeEvent).call(this);
+      const frame = targetElementDocument.createElement("iframe");
+      frame.setAttribute("id", guestId);
+      frame.addEventListener("load", () => {
+        __privateGet(this, _logger).debug(`frame loaded for guest with id '${guestId}'`);
+      });
+      frame.setAttribute("style", "min-width: 100%; height: 100%; border: 0px;");
+      if (!disableSandbox) {
+        frame.setAttribute(
+          "sandbox",
+          `${SANDBOX_DEFAULT} ${sandboxValues.join(" ")}`
+        );
+      }
+      frame.setAttribute("title", title);
+      frame.setAttribute("src", url);
+      targetElement.appendChild(frame);
+      const guestFrameEle = targetElementDocument.getElementById(
+        guestId
+      );
+      return __privateGet(this, _attachGuest).call(this, {
+        guestId,
+        domElement: guestFrameEle,
+        window: guestFrameEle.contentWindow,
+        title,
+        url,
+        params,
+        openMode: import_types.OpenMode.Embed
+      });
+    });
+    __privateAdd(this, _getGuestUrl, (url, params) => {
+      let querystring = "";
+      Object.keys(params).forEach((queryParam) => {
+        querystring += `${(querystring.length ? "&" : "") + encodeURIComponent(queryParam)}=${encodeURIComponent(params[queryParam])}`;
+      });
+      return url + (!querystring ? "" : (url.indexOf("?") >= 0 ? "&" : "?") + querystring);
+    });
+    /**
+     * adds scripting object to host
+     *
+     * @param so scripting object
+     * @throws Error if the scripting object is invalid
+     */
+    __publicField(this, "addScriptingObject", (so) => {
+      if (!so?.id || !so?._toJSON) {
+        throw new Error("Object is not derived from ScriptingObject");
+      }
+      if (so.id.toLowerCase() === "module")
+        throw new Error(
+          "Do not publish the module object. Create a concrete object derived from it."
+        );
+      __privateGet(this, _publishedObjects).set(so.id, so);
+    });
+    /**
+     * Clone parent host's scripting object for exposing to grand children
+     *
+     * @param proxy - reference to the scripting object obtained through getObject method
+     * @param guest - reference to the ssf guest
+     * @returns cloned version of the scripting object
+     */
+    __publicField(this, "cloneScriptingObject", (proxy, guest) => {
+      if (!proxy)
+        throw new Error("proxy is required");
+      if (!guest)
+        throw new Error("guest is required");
+      const so = new import_ssf_common.ScriptingObject(proxy.id, proxy.objectType);
+      let unsubscribers = [];
+      Object.keys(proxy).forEach((propName) => {
+        const propValue = proxy[propName];
+        if (__privateGet(this, _isProxyEvent).call(this, propValue)) {
+          const event = new import_ssf_common.Event({
+            name: propValue.name,
+            requiresFeedback: false,
+            so
+          });
+          Object.defineProperty(so, propName, {
+            value: event,
+            enumerable: true
+          });
+          const listener = ({
+            eventParams,
+            eventOptions
+          }) => this.dispatchEvent({
+            event,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            eventParams,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            eventOptions
+          });
+          const token = guest.subscribe({
+            eventId: propValue.id,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            callback: listener
+          });
+          unsubscribers.push(() => {
+            guest.unsubscribe({ eventId: propValue.id, token });
+          });
+        } else if ((0, import_utils.isFunction)(propValue)) {
+          Object.defineProperty(so, propName, {
+            value: async (...args) => {
+              const retVal = await propValue(...args);
+              return (0, import_utils.isProxy)(retVal) ? this.cloneScriptingObject(retVal, guest) : retVal;
+            },
+            enumerable: true
+          });
+          if (propName === "dispose") {
+            const defaultImpl = so.dispose;
+            Object.defineProperty(so, propName, {
+              value: () => {
+                so._dispose();
+                return defaultImpl.apply(so);
+              },
+              enumerable: true
+            });
+          }
+        }
+      });
+      so._dispose = () => {
+        unsubscribers.forEach((unsub) => {
+          unsub?.();
+        });
+        unsubscribers = [];
+      };
+      return so;
+    });
+    /**
+     * dispose the resources used by the host application
+     */
+    __publicField(this, "close", () => {
+      clearInterval(__privateGet(this, _popupGuestMonitor));
+      __privateGet(this, _remoting).close();
+      window.removeEventListener("visibilitychange", __privateGet(this, _closeAllPopupGuests));
+      __privateGet(this, _logger).debug(
+        `host is closed. hostId: ${this.hostId}, correlationId: ${__privateGet(this, _correlationId)}`
+      );
+    });
+    /**
+     * dispatch event to guest application(s)
+     *
+     * @param {EventDetail} details details of the event to be dispatched
+     * @returns promise that resolves to an array with result from each guest application
+     */
+    __publicField(this, "dispatchEvent", async (details) => {
+      const {
+        event: { id, name, scriptingObject },
+        eventParams,
+        eventOptions = {}
+      } = details;
+      const {
+        eventHandler = null,
+        timeout = null,
+        window: targetWindow = null
+      } = eventOptions;
+      const eventObj = {
+        // eslint-disable-next-line no-underscore-dangle
+        object: scriptingObject._toJSON(),
+        eventName: name,
+        eventParams,
+        eventHandler,
+        eventOptions: {
+          allowsFeedback: false
+        }
+      };
+      if (timeout && !Number.isNaN(timeout)) {
+        eventObj.eventOptions = {
+          allowsFeedback: true,
+          timeout: Number(timeout)
+        };
+      }
+      const guestPromises = [];
+      __privateGet(this, _guests).forEach((guest) => {
+        if (!targetWindow || targetWindow === guest.window) {
+          if (timeout && guest?.capabilities?.eventFeedback) {
+            guestPromises.push(guest.dispatchEvent(eventObj, timeout));
+            __privateGet(this, _logger).audit({
+              message: "Event dispatched and awaiting feedback",
+              scriptingEventId: id,
+              ...guest.getInfo()
+            });
+          } else {
+            guest.send({
+              messageType: import_ssf_common.MessageType.ObjectEvent,
+              messageBody: eventObj
+            });
+            __privateGet(this, _logger).audit({
+              message: "Event dispatched",
+              scriptingEventId: id,
+              ...guest.getInfo()
+            });
+          }
+        }
+      });
+      const retValue = await Promise.all(guestPromises).then((values) => {
+        __privateGet(this, _logger).audit({
+          message: "Event feedback received",
+          scriptingEventId: id
+        });
+        return (0, import_utils.flatten)(values);
+      }).catch((ex) => {
+        __privateGet(this, _logger).error({
+          message: "Error processing event",
+          eventId: id,
+          exception: ex
+        });
+        throw ex;
+      });
+      return retValue;
+    });
+    /**
+     * get reference to all guest applications
+     *
+     * @returns list of guest application references
+     */
+    __publicField(this, "getGuests", () => {
+      const guestList = [];
+      __privateGet(this, _guests).forEach((guest) => {
+        guestList.push(guest);
+      });
+      return guestList;
+    });
+    /**
+     * get the scripting object by id
+     *
+     * @param objectId - id of the scripting object
+     * @returns scripting object
+     */
+    __publicField(this, "getScriptingObject", (objectId) => {
+      if (!__privateGet(this, _publishedObjects).has(objectId))
+        return null;
+      return __privateGet(this, _publishedObjects).get(objectId);
+    });
+    /**
+     * loads guest application inside sandboxed iframe
+     *
+     * @param {LoadGuestParam} param - parameters for loading the guest application
+     * @returns reference to the guest object
+     */
+    __publicField(this, "loadGuest", (param) => {
+      const {
+        url,
+        targetElement,
+        title,
+        params = {},
+        options = {}
+      } = param;
+      const { openMode = import_types.OpenMode.Embed, windowFeatures = {} } = options;
+      const guestId = `guest-${this.hostId}-sandbox-${__privateGet(this, _nextGuestId)}`;
+      __privateSet(this, _nextGuestId, __privateGet(this, _nextGuestId) + 1);
+      const srcUrl = __privateGet(this, _getGuestUrl).call(this, url, params);
+      let guest = null;
+      if (openMode === import_types.OpenMode.Popup) {
+        guest = __privateGet(this, _openPopupGuest).call(this, {
+          guestId,
+          url: srcUrl,
+          title,
+          params,
+          windowFeatures
+        });
+      } else if (openMode === import_types.OpenMode.Embed) {
+        guest = __privateGet(this, _openEmbedGuest).call(this, {
+          guestId,
+          url: srcUrl,
+          title,
+          targetElement,
+          params,
+          options
+        });
+      } else {
+        throw new Error(`Invalid openMode: ${openMode}`);
+      }
+      __privateGet(this, _logger).audit({
+        message: "Guest loaded",
+        ...guest.getInfo()
+      });
+      return guest;
+    });
+    /**
+     * loads guest application inside sandboxed iframe with different params
+     *
+     * @param {LoadGuestsParam} param - parameters for loading the guest application
+     */
+    __publicField(this, "loadGuests", (param) => {
+      const {
+        url,
+        targetElement,
+        title,
+        paramsList = [],
+        options = {}
+      } = param;
+      paramsList.forEach((params) => {
+        this.loadGuest({ url, title, targetElement, params, options });
+      }, this);
+    });
+    /**
+     * removes all scripting objects from host
+     *
+     */
+    __publicField(this, "removeAllScriptingObjects", () => {
+      const objectIds = Array.from(__privateGet(this, _publishedObjects).keys());
+      objectIds.forEach((objectId) => {
+        this.removeScriptingObject(objectId);
+      });
+    });
+    /**
+     * removes scripting object from host
+     *
+     * @param objectId unique id of the scripting object
+     */
+    __publicField(this, "removeScriptingObject", (objectId) => {
+      const obj = this.getScriptingObject(objectId);
+      if (obj) {
+        if (obj._dispose && typeof obj._dispose === "function") {
+          obj._dispose();
+        }
+        __privateGet(this, _publishedObjects).delete(objectId);
+      }
+    });
+    /**
+     * set the log level for the host application
+     *
+     * @param level - log level
+     */
+    __publicField(this, "setLogLevel", (level) => {
+      __privateGet(this, _logger).setLogLevel(level);
+      __privateGet(this, _guests).forEach(__privateGet(this, _dispatchConfigEvent));
+      __privateGet(this, _logger).debug("Dispatched config events to all guests");
+    });
+    /**
+     * unloads guest application from host
+     *
+     * @param guestIdOrWindowOrEle unique id of the guest application or window object or dom element of the guest application
+     * @throws Error if guestId or Window reference is invalid
+     */
+    __publicField(this, "unloadGuest", (guestIdOrWindowOrEle) => {
+      let guest = typeof guestIdOrWindowOrEle === "string" ? __privateGet(this, _guests).get(guestIdOrWindowOrEle) : null;
+      if (!guest) {
+        guest = Array.from(__privateGet(this, _guests).values()).find(
+          (value) => value.window === guestIdOrWindowOrEle || value.domElement === guestIdOrWindowOrEle
+        );
+        if (!guest) {
+          throw new Error("Invalid guestId or guestWindow reference");
+        }
+      }
+      guest.dispose();
+      __privateGet(this, _guests).delete(guest.id);
+      __privateGet(this, _logger).audit({
+        message: `Guest is removed from host`,
+        ...guest.getInfo()
+      });
+    });
+    this.hostId = hostId;
+    if (!option?.logger)
+      throw new Error("Logger is required");
+    __privateSet(this, _logger, option.logger);
+    __privateSet(this, _correlationId, (0, import_uuid.v4)());
+    __privateSet(this, _remoting, new import_ssf_common.Remoting(__privateGet(this, _logger), __privateGet(this, _correlationId)));
+    if (option?.readyStateCallback && typeof option?.readyStateCallback !== "function")
+      throw new Error("readyStateCallback must be a function");
+    __privateSet(this, _readyStateCallback, option?.readyStateCallback || null);
+    __privateGet(this, _remoting).initialize(window);
+    __privateGet(this, _connect).call(this);
+    __privateGet(this, _monitorPopupGuests).call(this);
+    __privateGet(this, _logger).debug(
+      `host is initialized. hostId: ${this.hostId}, correlationId: ${__privateGet(this, _correlationId)}`
+    );
+  }
+}
+_remoting = new WeakMap();
+_correlationId = new WeakMap();
+_logger = new WeakMap();
+_nextGuestId = new WeakMap();
+_guests = new WeakMap();
+_publishedObjects = new WeakMap();
+_readyStateCallback = new WeakMap();
+_popupGuestMonitor = new WeakMap();
+_closeAllPopupGuests = new WeakMap();
+_getGuestForWindow = new WeakMap();
+_getGuestForUrl = new WeakMap();
+_isScriptingObject = new WeakMap();
+_encodeResponse = new WeakMap();
+_encodeException = new WeakMap();
+_dispatchConfigEvent = new WeakMap();
+_invoke = new WeakMap();
+_handleGuestReadyComplete = new WeakMap();
+_handleGuestReady = new WeakMap();
+_handleGuestClose = new WeakMap();
+_handleObjectGet = new WeakMap();
+_handleGuestResize = new WeakMap();
+_handleObjectInvoke = new WeakMap();
+_subscribeToGuestResizeEvent = new WeakMap();
+_connect = new WeakMap();
+_isProxyEvent = new WeakMap();
+_attachGuest = new WeakMap();
+_monitorPopupGuests = new WeakMap();
+_openPopupGuest = new WeakMap();
+_openEmbedGuest = new WeakMap();
+_getGuestUrl = new WeakMap();