@elliemae/microfe-common 2.0.0-next.30

package/dist/esm/remoting.js

@@ -0,0 +1,367 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 _correlationId, _logger, _listeners, _invocations, _timeoutMonitorHandle, _allowedSenders, _evaluateTimeouts, _startResponseMonitor, _stopResponseMonitor, _popInvocation, _processResponse, _processException, _receive, _processMessage;
+import { v4 as uuidv4 } from "uuid";
+const MESSAGE_SOURCE = "elli:remoting";
+const RESPONSE_MESSAGE_TYPE = "elli:remoting:response";
+const EXCEPTION_MESSAGE_TYPE = "elli:remoting:exception";
+const createMessage = ({
+  messageType,
+  messageBody,
+  onewayMsg = false
+}) => ({
+  requestId: !onewayMsg ? uuidv4() : null,
+  source: MESSAGE_SOURCE,
+  type: messageType,
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  body: messageBody
+});
+const sendMessage = (param) => {
+  const { targetWin, targetOrigin, messageType, messageBody } = param;
+  const msg = createMessage({ messageType, messageBody });
+  targetWin.postMessage(msg, targetOrigin);
+};
+class Remoting {
+  /**
+   * Create a new instance of the Remoting class
+   *
+   * @param logger pui-diagnostic logger
+   * @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 (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`
+        );
+        __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}`
+      );
+      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;
+    });
+    // Handles a response to a prior cross-frame invocation
+    __privateAdd(this, _processException, (message) => {
+      __privateGet(this, _logger).debug(
+        `Exception received for invocation (requestId = ${message.requestId})`
+      );
+      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)}`
+      );
+      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);
+        }
+      });
+    });
+    /**
+     * 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
+      });
+      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
+      });
+      msg.requestId = requestId;
+      targetWin.postMessage(msg, targetOrigin);
+      __privateGet(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
+     */
+    __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}`
+      );
+    });
+    if (!logger)
+      throw new Error("logger is required");
+    if (!correlationId)
+      throw new Error("correlationId is required");
+    __privateSet(this, _correlationId, correlationId);
+    __privateSet(this, _logger, logger);
+  }
+}
+_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();
+export {
+  Remoting,
+  sendMessage
+};

package/dist/esm/scriptingObject.js

@@ -0,0 +1,100 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 _id, _objectType;
+import { isEvent } from "./event.js";
+const FUNCTION = "function";
+const isPublicFunction = (value, fnName) => typeof value === FUNCTION && !!fnName && !fnName.startsWith("_");
+class ScriptingObject {
+  /**
+   * Creates an instance of ScriptingObject.
+   *
+   * @param objectId unique id of the scripting object
+   * @param objectType type of the scripting object
+   */
+  constructor(objectId, objectType) {
+    /**
+     * unique id of the scripting object
+     */
+    __privateAdd(this, _id, void 0);
+    /**
+     * type of the scripting object
+     */
+    __privateAdd(this, _objectType, "Object");
+    /**
+     * transform the scripting object to a format suitable for transmitting over window.postMessage
+     *
+     * @returns marshalled scripting object
+     */
+    // eslint-disable-next-line no-underscore-dangle
+    __publicField(this, "_toJSON", () => {
+      const functions = [];
+      const events = [];
+      Object.keys(this).forEach((property) => {
+        const value = this[property];
+        if (isEvent(value)) {
+          events.push(property);
+        } else if (isPublicFunction(value, property)) {
+          functions.push(property);
+        }
+      });
+      return {
+        objectId: __privateGet(this, _id),
+        objectType: __privateGet(this, _objectType),
+        functions,
+        events
+      };
+    });
+    /**
+     * dispose the scripting object
+     */
+    // eslint-disable-next-line no-underscore-dangle
+    __publicField(this, "_dispose", () => {
+    });
+    /**
+     * dispose the scripting object
+     */
+    __publicField(this, "dispose", () => {
+    });
+    __privateSet(this, _id, objectId);
+    __privateSet(this, _objectType, objectType || __privateGet(this, _objectType));
+  }
+  /**
+   * get unique id of the scripting object
+   */
+  get id() {
+    return __privateGet(this, _id);
+  }
+  /**
+   * get type of the scripting object
+   */
+  get objectType() {
+    return __privateGet(this, _objectType);
+  }
+}
+_id = new WeakMap();
+_objectType = new WeakMap();
+export {
+  ScriptingObject
+};

package/dist/esm/tests/scriptingObjects/appraisalServiceModule.js

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 _loanId, _creditScore;
+import { ScriptingObject, Event } from "../../index.js";
+import { OBJECT_NAME } from "./constant.js";
+class AppraisalService extends ScriptingObject {
+  constructor({
+    loanId,
+    creditScore
+  }) {
+    super(OBJECT_NAME);
+    __privateAdd(this, _loanId, void 0);
+    __privateAdd(this, _creditScore, void 0);
+    __publicField(this, "Unloading", new Event({
+      name: "Unloading",
+      requiresFeedback: false,
+      so: this
+    }));
+    __publicField(this, "onPreCommit", new Event({
+      name: "onPreCommit",
+      requiresFeedback: true,
+      so: this
+    }));
+    __publicField(this, "onSaved", new Event({
+      name: "onSaved",
+      requiresFeedback: false,
+      so: this
+    }));
+    __publicField(this, "getCapabilities", () => Promise.resolve({
+      isAdmin: true,
+      los: "Encompass"
+    }));
+    __publicField(this, "getParameters", () => Promise.resolve({
+      loanId: __privateGet(this, _loanId),
+      creditScore: __privateGet(this, _creditScore)
+    }));
+    __publicField(this, "setCreditScore", (creditScore) => {
+      __privateSet(this, _creditScore, creditScore);
+      return Promise.resolve();
+    });
+    __publicField(this, "saveLoan", () => Promise.resolve());
+    __publicField(this, "commit", () => new Promise((resolve) => {
+      setTimeout(() => {
+        resolve({ loanId: __privateGet(this, _loanId) });
+      }, 1e3);
+    }));
+    __publicField(this, "delete", () => {
+      throw new Error("Not implemented");
+    });
+    __publicField(this, "unload", async () => {
+    });
+    __privateSet(this, _loanId, loanId);
+    __privateSet(this, _creditScore, creditScore);
+  }
+}
+_loanId = new WeakMap();
+_creditScore = new WeakMap();
+export {
+  AppraisalService
+};

package/dist/esm/tests/scriptingObjects/constant.js

@@ -0,0 +1,6 @@
+const OBJECT_NAME = "AppraisalService";
+const UNLOADING_EVENT_NAME = "Unloading";
+export {
+  OBJECT_NAME,
+  UNLOADING_EVENT_NAME
+};

package/dist/esm/tests/scriptingObjects/global.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 _data;
+import { Event } from "../../event.js";
+import { ScriptingObject } from "../../index.js";
+class Global extends ScriptingObject {
+  constructor() {
+    super("Global");
+    __privateAdd(this, _data, /* @__PURE__ */ new Map());
+    __publicField(this, "Change", new Event({
+      name: "Change",
+      requiresFeedback: false,
+      so: this
+    }));
+    __publicField(this, "set", (key, value) => {
+      __privateGet(this, _data).set(key, value);
+      return Promise.resolve();
+    });
+    __publicField(this, "get", (key) => Promise.resolve(__privateGet(this, _data).get(key)));
+  }
+}
+_data = new WeakMap();
+export {
+  Global
+};

package/dist/types/common.d.ts

@@ -0,0 +1,35 @@
+import { RemotingScriptingObject, Listener } from '@elliemae/pui-scripting-object';
+/**
+ * Interface for scripting object proxy
+ */
+export interface IScriptingObjectProxy {
+    /**
+     * unique id of the scripting object
+     */
+    readonly id: string;
+    /**
+     * type of the scripting object
+     */
+    readonly objectType: string;
+    /**
+     * dipose the scripting object proxy
+     */
+    dispose?(): any;
+}
+/**
+ * Interface for scripting object
+ */
+export interface IScriptingObject extends IScriptingObjectProxy {
+    /**
+     * convert the scripting object properties to a format suitable for transferring over window.postMessage
+     */
+    _toJSON(): RemotingScriptingObject;
+    /**
+     * dispose the scripting object proxy
+     */
+    _dispose(): void;
+}
+/**
+ * list of event listeners
+ */
+export type EventListeners = Record<string, Listener<any, any, any, any>>;