@elliemae/ssf-host 2.0.0-next.29

package/dist/cjs/tests/utils.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 utils_exports = {};
+__export(utils_exports, {
+  createHost: () => createHost,
+  initGuest: () => initGuest,
+  postMessage: () => postMessage,
+  releaseJSThread: () => releaseJSThread
+});
+module.exports = __toCommonJS(utils_exports);
+var import_ssf_common = require("@elliemae/ssf-common");
+var import__ = require("../index.js");
+var import_logger = require("./logger.js");
+var import_utils = require("../utils.js");
+const createHost = (name = "IMTProduct") => {
+  let host = null;
+  const guestReady = new Promise((resolve) => {
+    const hostOptions = {
+      logger: import_logger.logger,
+      readyStateCallback: (guest) => {
+        resolve(guest);
+      }
+    };
+    host = new import__.SSFHost(name, hostOptions);
+  });
+  return { host, guestReady, guestName: `guest-${name}-sandbox` };
+};
+const postMessage = ({
+  srcWindow,
+  targetWindow,
+  message
+}) => {
+  targetWindow.dispatchEvent(
+    new MessageEvent("message", {
+      source: srcWindow,
+      origin: (0, import_utils.getOrigin)(srcWindow.location.href),
+      data: {
+        source: "elli:remoting",
+        ...message
+      }
+    })
+  );
+};
+const initGuest = (guestId) => {
+  const { contentWindow: guestWindow } = document.getElementById(guestId) || {};
+  if (!guestWindow)
+    throw new Error("Could not find guest window");
+  postMessage({
+    srcWindow: guestWindow,
+    targetWindow: guestWindow.parent,
+    message: {
+      body: { eventFeedback: true },
+      type: import_ssf_common.MessageType.GuestReady
+    }
+  });
+  return guestWindow;
+};
+const releaseJSThread = () => new Promise((resolve) => {
+  setTimeout(resolve, 0);
+});

package/dist/cjs/types.js

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+__export(types_exports, {
+  IFrameSandboxValues: () => IFrameSandboxValues,
+  OpenMode: () => OpenMode
+});
+module.exports = __toCommonJS(types_exports);
+var OpenMode = /* @__PURE__ */ ((OpenMode2) => {
+  OpenMode2["Popup"] = "popup";
+  OpenMode2["Embed"] = "embed";
+  return OpenMode2;
+})(OpenMode || {});
+var IFrameSandboxValues = /* @__PURE__ */ ((IFrameSandboxValues2) => {
+  IFrameSandboxValues2["AllowDownloadsWithoutUserActivation"] = "allow-downloads-without-user-activation";
+  IFrameSandboxValues2["AllowDownloads"] = "allow-downloads";
+  IFrameSandboxValues2["AllowForms"] = "allow-forms";
+  IFrameSandboxValues2["AllowModals"] = "allow-modals";
+  IFrameSandboxValues2["AllowOrientationLock"] = "allow-orientation-lock";
+  IFrameSandboxValues2["AllowPointerLock"] = "allow-pointer-lock";
+  IFrameSandboxValues2["AllowPopups"] = "allow-popups";
+  IFrameSandboxValues2["AllowPopupsToEscapeSandbox"] = "allow-popups-to-escape-sandbox";
+  IFrameSandboxValues2["AllowPresentation"] = "allow-presentation";
+  IFrameSandboxValues2["AllowSameOrigin"] = "allow-same-origin";
+  IFrameSandboxValues2["AllowScripts"] = "allow-scripts";
+  IFrameSandboxValues2["AllowStorageAccessByUserActivation"] = "allow-storage-access-by-user-activation";
+  IFrameSandboxValues2["AllowTopNavigation"] = "allow-top-navigation";
+  IFrameSandboxValues2["AllowTopNavigationByUserActivation"] = "allow-top-navigation-by-user-activation";
+  return IFrameSandboxValues2;
+})(IFrameSandboxValues || {});

package/dist/cjs/utils.js

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 utils_exports = {};
+__export(utils_exports, {
+  flatten: () => flatten,
+  getObjectId: () => getObjectId,
+  getOrigin: () => getOrigin,
+  isFunction: () => isFunction,
+  isProxy: () => isProxy,
+  isScriptingObject: () => isScriptingObject
+});
+module.exports = __toCommonJS(utils_exports);
+const getOrigin = (url) => {
+  if (url === "about:blank")
+    return "*";
+  const { origin } = new URL(url);
+  return origin === "null" || !origin ? url : origin;
+};
+const flatten = (source, target = []) => {
+  const retVal = target || [];
+  if (source && source.forEach) {
+    source.forEach((item) => {
+      flatten(item, retVal);
+    });
+  } else if (typeof source !== "undefined") {
+    retVal.push(source);
+  }
+  return retVal;
+};
+const isScriptingObject = (value) => (
+  // eslint-disable-next-line no-underscore-dangle, @typescript-eslint/no-unsafe-member-access
+  typeof value?._toJSON === "function"
+);
+function isFunction(value) {
+  return typeof value === "function";
+}
+const isProxy = (value) => (
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  value?.constructor?.name === "Proxy"
+);
+const getObjectId = (elementOrId) => elementOrId?.id ?? elementOrId;

package/dist/esm/app.config.json

@@ -0,0 +1,20 @@
+{
+  "appId": "ssf-host",
+  "activeEnv": "localhost",
+  "options": {
+    "guestUrl": "http://localhost:4001"
+  },
+  "env": {
+    "localhost": {
+      "options": {
+        "guestUrl": "http://localhost:4001"
+      }
+    },
+    "dev2": {},
+    "qa2": {},
+    "qa3": {},
+    "int": {},
+    "stage": {},
+    "prod": {}
+  }
+}

package/dist/esm/guest.js

@@ -0,0 +1,177 @@
+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 _remoting;
+import { MessageType } from "@elliemae/ssf-common";
+import { OpenMode } from "./types.js";
+import { getOrigin } from "./utils.js";
+class Guest {
+  /**
+   * Create object representing guest application
+   *
+   * @param {GuestOption} option - options for creating a guest application
+   */
+  constructor(option) {
+    /**
+     * unique id of the guest application
+     */
+    __publicField(this, "id");
+    /**
+     * page title of the guest application
+     */
+    __publicField(this, "title");
+    /**
+     * url of the guest application
+     */
+    __publicField(this, "url");
+    /**
+     * properties of the guest application
+     */
+    __publicField(this, "params");
+    /**
+     * iframe element of the guest application
+     */
+    __publicField(this, "domElement");
+    /**
+     * window object of the guest application
+     */
+    __publicField(this, "window");
+    /**
+     * open mode of the guest application
+     */
+    __publicField(this, "openMode");
+    /**
+     * origin of the guest application
+     */
+    __publicField(this, "origin");
+    /**
+     * flag indicating if the guest application is initialized
+     */
+    __publicField(this, "initialized", false);
+    /**
+     * flag indicating if the guest application is ready
+     */
+    __publicField(this, "ready", false);
+    /**
+     * capabilities of the guest application
+     */
+    __publicField(this, "capabilities");
+    /**
+     * remoting object
+     */
+    __privateAdd(this, _remoting, void 0);
+    /**
+     * clean up resources
+     */
+    __publicField(this, "dispose", () => {
+      __privateGet(this, _remoting).removeSender({ origin: this.origin, window: this.window });
+      if (this.openMode === OpenMode.Popup) {
+        this.window.close();
+      } else {
+        this.domElement?.remove?.();
+      }
+    });
+    /**
+     * Get information about the guest application
+     *
+     * @returns guest properties
+     */
+    __publicField(this, "getInfo", () => ({
+      guestId: this.id,
+      guestTitle: this.title,
+      guestUrl: this.url
+    }));
+    /**
+     * initialize guest messaging
+     */
+    __publicField(this, "init", () => {
+      __privateGet(this, _remoting).addSender({ origin: this.origin, window: this.window });
+      if (this.openMode === OpenMode.Popup) {
+        const handShakeInterval = setInterval(() => {
+          __privateGet(this, _remoting).send({
+            targetWin: this.window,
+            targetOrigin: this.origin,
+            messageType: MessageType.HandShake,
+            messageBody: {}
+          });
+        }, 1e3);
+        __privateGet(this, _remoting).listen({
+          messageType: MessageType.HandShakeAck,
+          callback: () => {
+            clearInterval(handShakeInterval);
+          }
+        });
+      }
+    });
+    /**
+     * invokes event callback on the guest application
+     *
+     * @param {EventObject} event - event object
+     * @param {number} timeout - timeout in milliseconds
+     */
+    __publicField(this, "dispatchEvent", (event, timeout) => __privateGet(this, _remoting).invoke({
+      targetWin: this.window,
+      targetOrigin: this.origin,
+      messageType: MessageType.ObjectEvent,
+      messageBody: event,
+      responseTimeoutMs: timeout
+    }));
+    /**
+     * Send a message without any form of response. fire and forget
+     *
+     * @param {MessageParam} param - message to be sent
+     */
+    __publicField(this, "send", (param) => {
+      __privateGet(this, _remoting).send({
+        targetWin: this.window,
+        targetOrigin: this.origin,
+        ...param
+      });
+    });
+    const {
+      guestId,
+      domElement = null,
+      title,
+      url,
+      window,
+      params = {},
+      openMode = OpenMode.Embed,
+      remoting
+    } = option;
+    this.id = guestId;
+    this.title = title;
+    this.url = url;
+    this.origin = getOrigin(url);
+    this.params = params;
+    this.domElement = domElement;
+    this.window = window;
+    this.openMode = openMode;
+    this.capabilities = {};
+    __privateSet(this, _remoting, remoting);
+  }
+}
+_remoting = new WeakMap();
+export {
+  Guest
+};