@elliemae/microfe-common 2.0.0-next.41 → 2.0.0-next.43

package/dist/cjs/remoting.js

@@ -3,7 +3,6 @@ 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 });
@@ -17,28 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   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 remoting_exports = {};
 __export(remoting_exports, {
   Remoting: () => Remoting,
@@ -46,7 +23,6 @@ __export(remoting_exports, {
 });
 module.exports = __toCommonJS(remoting_exports);
 var import_uuid = require("uuid");
-var _correlationId, _logger, _listeners, _invocations, _timeoutMonitorHandle, _allowedSenders, _evaluateTimeouts, _startResponseMonitor, _stopResponseMonitor, _popInvocation, _processResponse, _processException, _receive, _processMessage;
 const MESSAGE_SOURCE = "elli:remoting";
 const RESPONSE_MESSAGE_TYPE = "elli:remoting:response";
 const EXCEPTION_MESSAGE_TYPE = "elli:remoting:exception";
@@ -67,6 +43,24 @@ const sendMessage = (param) => {
   targetWin.postMessage(msg, targetOrigin);
 };
 class Remoting {
+  #correlationId;
+  #logger;
+  /**
+   * set of listeners that are registered
+   */
+  #listeners = /* @__PURE__ */ new Map();
+  /**
+   * Represents the set of invocations that are waiting for a response
+   */
+  #invocations = /* @__PURE__ */ new Map();
+  /**
+   * The handle to the timeout monitor
+   */
+  #timeoutMonitorHandle = null;
+  /**
+   * The set of windows that are allowed to send messages to this window
+   */
+  #allowedSenders = /* @__PURE__ */ new Map();
   /**
    * Create a new instance of the Remoting class
    *
@@ -74,313 +68,281 @@ class Remoting {
    * @param correlationId unique id for the current session
    */
   constructor(logger, correlationId) {
-    __privateAdd(this, _correlationId, void 0);
-    __privateAdd(this, _logger, void 0);
-    /**
-     * set of listeners that are registered
-     */
-    __privateAdd(this, _listeners, /* @__PURE__ */ new Map());
-    /**
-     * Represents the set of invocations that are waiting for a response
-     */
-    __privateAdd(this, _invocations, /* @__PURE__ */ new Map());
-    /**
-     * The handle to the timeout monitor
-     */
-    __privateAdd(this, _timeoutMonitorHandle, null);
-    /**
-     * The set of windows that are allowed to send messages to this window
-     */
-    __privateAdd(this, _allowedSenders, /* @__PURE__ */ new Map());
-    // Evaluates the timeouts on any waiting invocations
-    __privateAdd(this, _evaluateTimeouts, () => {
-      const ts = Date.now();
-      const canceledItems = [];
-      __privateGet(this, _invocations).forEach((eventData, key) => {
-        const { requestId, cancelTime } = eventData;
-        __privateGet(this, _logger).debug(
-          `Checking response timeout for requestId: ${requestId}) @ ${cancelTime ?? ""}`
+    if (!logger)
+      throw new Error("logger is required");
+    if (!correlationId)
+      throw new Error("correlationId is required");
+    this.#correlationId = correlationId;
+    this.#logger = logger;
+  }
+  // Evaluates the timeouts on any waiting invocations
+  #evaluateTimeouts = () => {
+    const ts = Date.now();
+    const canceledItems = [];
+    this.#invocations.forEach((eventData, key) => {
+      const { requestId, cancelTime } = eventData;
+      this.#logger.debug(
+        `Checking response timeout for requestId: ${requestId}) @ ${cancelTime ?? ""}`
+      );
+      if (eventData.cancelTime && eventData.cancelTime < ts) {
+        this.#logger.debug(
+          `Detected response timeout for requestId: ${requestId}...`
         );
-        if (eventData.cancelTime && eventData.cancelTime < ts) {
-          __privateGet(this, _logger).debug(
-            `Detected response timeout for requestId: ${requestId}...`
-          );
-          canceledItems.push(key);
-          eventData.resolve();
-          __privateGet(this, _logger).debug(
-            `Aborted waiting for response to requestid: ${requestId})`
-          );
-        }
-      });
-      canceledItems.forEach((key) => {
-        __privateGet(this, _logger).debug(
-          `removing invocations with requestId ${key} from cache since response time has expired`
+        canceledItems.push(key);
+        eventData.resolve();
+        this.#logger.debug(
+          `Aborted waiting for response to requestid: ${requestId})`
         );
-        __privateGet(this, _invocations).delete(key);
-      });
-      if (__privateGet(this, _invocations).size === 0) {
-        __privateGet(this, _logger).debug(`stopping response monitor`);
-        __privateGet(this, _stopResponseMonitor).call(this);
       }
     });
-    // Set a timer interval to catch any invocations that didn't respond in a timely manner
-    __privateAdd(this, _startResponseMonitor, () => {
-      if (__privateGet(this, _timeoutMonitorHandle) === null) {
-        __privateGet(this, _logger).debug("Staring response timeout evaluator");
-        __privateSet(this, _timeoutMonitorHandle, window.setInterval(
-          __privateGet(this, _evaluateTimeouts),
-          200
-        ));
-      }
-    });
-    // Stops the timeout monitor interval
-    __privateAdd(this, _stopResponseMonitor, () => {
-      if (__privateGet(this, _timeoutMonitorHandle) !== null) {
-        window.clearInterval(__privateGet(this, _timeoutMonitorHandle));
-        __privateSet(this, _timeoutMonitorHandle, null);
-        __privateGet(this, _logger).debug("Stopped response timeout evaluator");
-      }
-    });
-    // Pops an invocation from the incovation list
-    __privateAdd(this, _popInvocation, (requestId) => {
-      const e = __privateGet(this, _invocations).get(requestId);
-      __privateGet(this, _logger).debug(`serving requestId: ${requestId}`);
-      __privateGet(this, _invocations).delete(requestId);
-      return e;
-    });
-    // Handles a response to a prior cross-frame invocation
-    __privateAdd(this, _processResponse, (message) => {
-      const { requestId } = message;
-      __privateGet(this, _logger).debug(
-        `Response received for invocation requestId: ${requestId}`
+    canceledItems.forEach((key) => {
+      this.#logger.debug(
+        `removing invocations with requestId ${key} from cache since response time has expired`
       );
-      const eventData = __privateGet(this, _popInvocation).call(this, requestId);
-      if (!eventData) {
-        __privateGet(this, _logger).warn(
-          `Received response to stale/invalid request with requestId: ${requestId}`
-        );
-        return false;
-      }
-      eventData.resolve(message.body);
-      return true;
+      this.#invocations.delete(key);
     });
-    // Handles a response to a prior cross-frame invocation
-    __privateAdd(this, _processException, (message) => {
-      __privateGet(this, _logger).debug(
-        `Exception received for invocation (requestId = ${message.requestId})`
+    if (this.#invocations.size === 0) {
+      this.#logger.debug(`stopping response monitor`);
+      this.#stopResponseMonitor();
+    }
+  };
+  // Set a timer interval to catch any invocations that didn't respond in a timely manner
+  #startResponseMonitor = () => {
+    if (this.#timeoutMonitorHandle === null) {
+      this.#logger.debug("Staring response timeout evaluator");
+      this.#timeoutMonitorHandle = window.setInterval(
+        this.#evaluateTimeouts,
+        200
       );
-      const eventData = __privateGet(this, _popInvocation).call(this, message.requestId);
-      if (!eventData) {
-        __privateGet(this, _logger).warn(
-          `Received exception for stale/invalid request (requestId = ${message.requestId})`
-        );
-        return false;
-      }
-      eventData.reject(new Error(message.body));
-      return true;
-    });
-    // Receives a message from another window and invokes any event handlers
-    __privateAdd(this, _receive, ({
-      sourceWin,
-      sourceOrigin,
-      message
-    }) => {
-      __privateGet(this, _logger).debug(`Received message of type "${message.type}"`);
-      const callbacks = __privateGet(this, _listeners).get(message.type);
-      if (!callbacks)
-        return false;
-      callbacks.forEach((callback) => {
-        __privateGet(this, _logger).debug(`Invoking message handler ${callback.name}`);
-        callback({
-          sourceWin,
-          sourceOrigin,
-          requestId: message.requestId,
-          type: message.type,
-          body: message.body
-        });
-      });
-      return true;
-    });
-    // Processes a message received thru the window's message event
-    __privateAdd(this, _processMessage, (message) => {
-      __privateGet(this, _logger).debug(
-        `Remoting: Received message ${JSON.stringify(message.data)}`
+    }
+  };
+  // Stops the timeout monitor interval
+  #stopResponseMonitor = () => {
+    if (this.#timeoutMonitorHandle !== null) {
+      window.clearInterval(this.#timeoutMonitorHandle);
+      this.#timeoutMonitorHandle = null;
+      this.#logger.debug("Stopped response timeout evaluator");
+    }
+  };
+  // Pops an invocation from the incovation list
+  #popInvocation = (requestId) => {
+    const e = this.#invocations.get(requestId);
+    this.#logger.debug(`serving requestId: ${requestId}`);
+    this.#invocations.delete(requestId);
+    return e;
+  };
+  // Handles a response to a prior cross-frame invocation
+  #processResponse = (message) => {
+    const { requestId } = message;
+    this.#logger.debug(
+      `Response received for invocation requestId: ${requestId}`
+    );
+    const eventData = this.#popInvocation(requestId);
+    if (!eventData) {
+      this.#logger.warn(
+        `Received response to stale/invalid request with requestId: ${requestId}`
       );
-      if (__privateGet(this, _allowedSenders).size === 0)
-        return false;
-      if (!message.source)
-        return false;
-      const senderOrigin = __privateGet(this, _allowedSenders).get(message.source);
-      if (!senderOrigin)
-        return false;
-      if (message?.data?.source !== MESSAGE_SOURCE)
-        return false;
-      if (message.data.type === RESPONSE_MESSAGE_TYPE)
-        __privateGet(this, _processResponse).call(this, message.data);
-      else if (message.data.type === EXCEPTION_MESSAGE_TYPE)
-        __privateGet(this, _processException).call(this, message.data);
-      else
-        __privateGet(this, _receive).call(this, {
-          sourceWin: message.source,
-          sourceOrigin: senderOrigin,
-          message: message.data
-        });
-      return true;
-    });
-    /**
-     * Adds window and its origin list of allowed senders
-     *
-     * @param {AddSenderParam} param - The sender to add
-     */
-    __publicField(this, "addSender", (param) => {
-      const { origin, window: window2 } = param;
-      if (!origin)
-        throw new Error("origin is required");
-      if (!window2)
-        throw new Error("window is required");
-      __privateGet(this, _allowedSenders).set(window2, origin);
-    });
-    /**
-     * Initializes the remoting service for a window
-     *
-     * @param win The window to initialize remoting for
-     */
-    __publicField(this, "initialize", (win) => {
-      win.removeEventListener("message", __privateGet(this, _processMessage));
-      win.addEventListener("message", __privateGet(this, _processMessage));
-      __privateGet(this, _logger).debug(`initialized remoting id: ${__privateGet(this, _correlationId)}`);
-    });
-    /**
-     * Closes the remoting service for a window
-     */
-    __publicField(this, "close", () => {
-      window.removeEventListener("message", __privateGet(this, _processMessage));
-      __privateGet(this, _logger).debug(`closed remoting id: ${__privateGet(this, _correlationId)}`);
-    });
-    /**
-     * Sends an invocation which generates a Promise to be used to get a response
-     *
-     * @param {InvokeParam} param The parameters for the invocation
-     * @returns promisifyed response
-     */
-    __publicField(this, "invoke", (param) => {
-      const {
-        targetWin,
-        targetOrigin,
-        messageType,
-        messageBody,
-        responseTimeoutMs
-      } = param;
-      return new Promise((resolve, reject) => {
-        const msg = createMessage({ messageType, messageBody });
-        __privateGet(this, _invocations).set(msg.requestId, {
-          requestId: msg.requestId,
-          resolve,
-          reject,
-          cancelTime: responseTimeoutMs ? Date.now() + Number.parseInt(responseTimeoutMs, 10) : null
-        });
-        targetWin.postMessage(msg, targetOrigin);
-        const { requestId } = msg;
-        __privateGet(this, _logger).debug(
-          `Posted invocation message of type ${messageType} requestId: ${requestId || ""}`
-        );
-        if (responseTimeoutMs) {
-          __privateGet(this, _logger).debug(
-            `starting response monitor for requestId: ${requestId || ""} for ${responseTimeoutMs} ms`
-          );
-          __privateGet(this, _startResponseMonitor).call(this);
-        }
+      return false;
+    }
+    eventData.resolve(message.body);
+    return true;
+  };
+  // Handles a response to a prior cross-frame invocation
+  #processException = (message) => {
+    this.#logger.debug(
+      `Exception received for invocation (requestId = ${message.requestId})`
+    );
+    const eventData = this.#popInvocation(message.requestId);
+    if (!eventData) {
+      this.#logger.warn(
+        `Received exception for stale/invalid request (requestId = ${message.requestId})`
+      );
+      return false;
+    }
+    eventData.reject(new Error(message.body));
+    return true;
+  };
+  // Receives a message from another window and invokes any event handlers
+  #receive = ({
+    sourceWin,
+    sourceOrigin,
+    message
+  }) => {
+    this.#logger.debug(`Received message of type "${message.type}"`);
+    const callbacks = this.#listeners.get(message.type);
+    if (!callbacks)
+      return false;
+    callbacks.forEach((callback) => {
+      this.#logger.debug(`Invoking message handler ${callback.name}`);
+      callback({
+        sourceWin,
+        sourceOrigin,
+        requestId: message.requestId,
+        type: message.type,
+        body: message.body
       });
     });
-    /**
-     * Setup callback for a specific message type
-     *
-     * @param {ListenParam<T>} param The parameters for the listener
-     */
-    __publicField(this, "listen", (param) => {
-      const { messageType, callback } = param;
-      const items = __privateGet(this, _listeners).get(messageType) || [];
-      items.push(callback);
-      __privateGet(this, _listeners).set(messageType, items);
-    });
-    /**
-     * Send a message without any form of response. Fire and forget
-     *
-     * @param {SendParam} param The parameters for the send
-     */
-    __publicField(this, "send", (param) => {
-      const { targetWin, targetOrigin, messageType, messageBody } = param;
-      const msg = createMessage({
-        messageType,
-        messageBody,
-        onewayMsg: true
+    return true;
+  };
+  // Processes a message received thru the window's message event
+  #processMessage = (message) => {
+    this.#logger.debug(
+      `Remoting: Received message ${JSON.stringify(message.data)}`
+    );
+    if (this.#allowedSenders.size === 0)
+      return false;
+    if (!message.source)
+      return false;
+    const senderOrigin = this.#allowedSenders.get(message.source);
+    if (!senderOrigin)
+      return false;
+    if (message?.data?.source !== MESSAGE_SOURCE)
+      return false;
+    if (message.data.type === RESPONSE_MESSAGE_TYPE)
+      this.#processResponse(message.data);
+    else if (message.data.type === EXCEPTION_MESSAGE_TYPE)
+      this.#processException(message.data);
+    else
+      this.#receive({
+        sourceWin: message.source,
+        sourceOrigin: senderOrigin,
+        message: message.data
       });
-      targetWin.postMessage(msg, targetOrigin);
-      __privateGet(this, _logger).debug(`Posted one-way message of type "${messageType}"`);
-    });
-    /**
-     * Removes a window from the list of allowed senders
-     *
-     * @param {AddSenderParam} param - The sender to remove
-     */
-    __publicField(this, "removeSender", (param) => {
-      const { window: window2 } = param;
-      if (window2)
-        __privateGet(this, _allowedSenders).delete(window2);
-    });
-    /**
-     * Send a response message to a window
-     *
-     * @param {RespondParam} param The parameters for the response
-     */
-    __publicField(this, "respond", (param) => {
-      const { targetWin, targetOrigin, requestId, response } = param;
-      const msg = createMessage({
-        messageType: RESPONSE_MESSAGE_TYPE,
-        messageBody: response
+    return true;
+  };
+  /**
+   * Adds window and its origin list of allowed senders
+   *
+   * @param {AddSenderParam} param - The sender to add
+   */
+  addSender = (param) => {
+    const { origin, window: window2 } = param;
+    if (!origin)
+      throw new Error("origin is required");
+    if (!window2)
+      throw new Error("window is required");
+    this.#allowedSenders.set(window2, origin);
+  };
+  /**
+   * Initializes the remoting service for a window
+   *
+   * @param win The window to initialize remoting for
+   */
+  initialize = (win) => {
+    win.removeEventListener("message", this.#processMessage);
+    win.addEventListener("message", this.#processMessage);
+    this.#logger.debug(`initialized remoting id: ${this.#correlationId}`);
+  };
+  /**
+   * Closes the remoting service for a window
+   */
+  close = () => {
+    window.removeEventListener("message", this.#processMessage);
+    this.#logger.debug(`closed remoting id: ${this.#correlationId}`);
+  };
+  /**
+   * Sends an invocation which generates a Promise to be used to get a response
+   *
+   * @param {InvokeParam} param The parameters for the invocation
+   * @returns promisifyed response
+   */
+  invoke = (param) => {
+    const {
+      targetWin,
+      targetOrigin,
+      messageType,
+      messageBody,
+      responseTimeoutMs
+    } = param;
+    return new Promise((resolve, reject) => {
+      const msg = createMessage({ messageType, messageBody });
+      this.#invocations.set(msg.requestId, {
+        requestId: msg.requestId,
+        resolve,
+        reject,
+        cancelTime: responseTimeoutMs ? Date.now() + Number.parseInt(responseTimeoutMs, 10) : null
       });
-      msg.requestId = requestId;
       targetWin.postMessage(msg, targetOrigin);
-      __privateGet(this, _logger).debug(
-        `Response sent to caller for invocation requestId: ${requestId}`
+      const { requestId } = msg;
+      this.#logger.debug(
+        `Posted invocation message of type ${messageType} requestId: ${requestId || ""}`
       );
+      if (responseTimeoutMs) {
+        this.#logger.debug(
+          `starting response monitor for requestId: ${requestId || ""} for ${responseTimeoutMs} ms`
+        );
+        this.#startResponseMonitor();
+      }
     });
-    /**
-     * Send an exception message to a window
-     *
-     * @param {RaiseExceptionParam} param The parameters for the exception
-     */
-    __publicField(this, "raiseException", (param) => {
-      const { targetWin, targetOrigin, requestId, ex } = param;
-      const msg = createMessage({
-        messageType: EXCEPTION_MESSAGE_TYPE,
-        messageBody: ex
-      });
-      msg.requestId = requestId;
-      targetWin.postMessage(msg, targetOrigin);
-      __privateGet(this, _logger).debug(
-        `Exception sent to caller for invocation. requestId: ${requestId}`
-      );
+  };
+  /**
+   * Setup callback for a specific message type
+   *
+   * @param {ListenParam<T>} param The parameters for the listener
+   */
+  listen = (param) => {
+    const { messageType, callback } = param;
+    const items = this.#listeners.get(messageType) || [];
+    items.push(callback);
+    this.#listeners.set(messageType, items);
+  };
+  /**
+   * Send a message without any form of response. Fire and forget
+   *
+   * @param {SendParam} param The parameters for the send
+   */
+  send = (param) => {
+    const { targetWin, targetOrigin, messageType, messageBody } = param;
+    const msg = createMessage({
+      messageType,
+      messageBody,
+      onewayMsg: true
     });
-    if (!logger)
-      throw new Error("logger is required");
-    if (!correlationId)
-      throw new Error("correlationId is required");
-    __privateSet(this, _correlationId, correlationId);
-    __privateSet(this, _logger, logger);
-  }
+    targetWin.postMessage(msg, targetOrigin);
+    this.#logger.debug(`Posted one-way message of type "${messageType}"`);
+  };
+  /**
+   * Removes a window from the list of allowed senders
+   *
+   * @param {AddSenderParam} param - The sender to remove
+   */
+  removeSender = (param) => {
+    const { window: window2 } = param;
+    if (window2)
+      this.#allowedSenders.delete(window2);
+  };
+  /**
+   * Send a response message to a window
+   *
+   * @param {RespondParam} param The parameters for the response
+   */
+  respond = (param) => {
+    const { targetWin, targetOrigin, requestId, response } = param;
+    const msg = createMessage({
+      messageType: RESPONSE_MESSAGE_TYPE,
+      messageBody: response
+    });
+    msg.requestId = requestId;
+    targetWin.postMessage(msg, targetOrigin);
+    this.#logger.debug(
+      `Response sent to caller for invocation requestId: ${requestId}`
+    );
+  };
+  /**
+   * Send an exception message to a window
+   *
+   * @param {RaiseExceptionParam} param The parameters for the exception
+   */
+  raiseException = (param) => {
+    const { targetWin, targetOrigin, requestId, ex } = param;
+    const msg = createMessage({
+      messageType: EXCEPTION_MESSAGE_TYPE,
+      messageBody: ex
+    });
+    msg.requestId = requestId;
+    targetWin.postMessage(msg, targetOrigin);
+    this.#logger.debug(
+      `Exception sent to caller for invocation. requestId: ${requestId}`
+    );
+  };
 }
-_correlationId = new WeakMap();
-_logger = new WeakMap();
-_listeners = new WeakMap();
-_invocations = new WeakMap();
-_timeoutMonitorHandle = new WeakMap();
-_allowedSenders = new WeakMap();
-_evaluateTimeouts = new WeakMap();
-_startResponseMonitor = new WeakMap();
-_stopResponseMonitor = new WeakMap();
-_popInvocation = new WeakMap();
-_processResponse = new WeakMap();
-_processException = new WeakMap();
-_receive = new WeakMap();
-_processMessage = new WeakMap();