@elliemae/pui-app-bridge 2.0.0-next.38 → 2.0.0-next.40

package/dist/cjs/{microfeFactory.js → appBridge.js}

@@ -39,61 +39,72 @@ var __privateSet = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var microfeFactory_exports = {};
-__export(microfeFactory_exports, {
-  CMicroAppFactory: () => CMicroAppFactory
+var appBridge_exports = {};
+__export(appBridge_exports, {
+  CAppBridge: () => CAppBridge
 });
-module.exports = __toCommonJS(microfeFactory_exports);
+module.exports = __toCommonJS(appBridge_exports);
+var import_pubsub_js = require("pubsub-js");
+var import_eventManager = require("./eventManager.js");
 var import_frame = require("./frame.js");
 var import_window = require("./typings/window.js");
 var import_app = require("./config/app.js");
 var import_microFE = require("./config/microFE.js");
 var import_loaders = require("./loaders/index.js");
+var import_scriptingObjectManager = require("./scriptingObjectManager.js");
 var import_microfeHost = require("./microfeHost.js");
-var _logger, _scriptLoader, _styleLoader, _appConfig, _microFEConfig, _host, _activeGuests, _activeApps, _removeAssetsFromDOM, _addAppToActiveAppList, _waitAndInitApplication, _initApplication, _loadApp, _unloadApp, _mountApp, _unmountApp;
+var _logger, _version, _scriptLoader, _styleLoader, _appConfig, _microFEConfig, _soManager, _eventManager, _activeApps, _removeAssetsFromDOM, _addAppToActiveAppList, _waitAndInitApplication, _initApplication, _loadApp, _unloadApp, _mountApp, _unmountApp;
 const APP_CONTAINER_ID_PREFIX = "pui-app-container-";
 const cssType = /\.css$/;
 const isCss = (fileName) => cssType.test(fileName);
-class CMicroAppFactory {
+class CAppBridge {
   /**
-   * Create a new instance of the MicroAppFactory
+   * Create a new instance of the AppBridge
    *
-   * @param {MicroAppFactoryParams} params - parameter for the constructor
+   * @param {AppBridgeParams} params - parameter for the constructor
    */
   constructor(params) {
     __privateAdd(this, _logger, void 0);
+    __privateAdd(this, _version, void 0);
     __privateAdd(this, _scriptLoader, void 0);
     __privateAdd(this, _styleLoader, void 0);
     __privateAdd(this, _appConfig, void 0);
     __privateAdd(this, _microFEConfig, new import_microFE.CMicroFEConfig());
-    __privateAdd(this, _host, void 0);
-    __privateAdd(this, _activeGuests, /* @__PURE__ */ new Map());
-    __privateAdd(this, _activeApps, {});
+    __privateAdd(this, _soManager, void 0);
+    __privateAdd(this, _eventManager, void 0);
+    __privateAdd(this, _activeApps, /* @__PURE__ */ new Map());
     __privateAdd(this, _removeAssetsFromDOM, (id, documentEle = document) => {
-      __privateGet(this, _activeGuests).delete(id);
-      const { elementIds } = __privateGet(this, _activeApps)[id] || {};
+      const { elementIds } = __privateGet(this, _activeApps).get(id) || {};
       if (elementIds) {
         elementIds.forEach((elementId) => {
           const ele = documentEle.getElementById(elementId);
           if (ele)
             ele.remove();
         });
-        delete __privateGet(this, _activeApps)[id];
       }
     });
     __privateAdd(this, _addAppToActiveAppList, (id, documentEle, elementIds) => {
       const app = window.emui?.[id] || {};
-      __privateGet(this, _activeApps)[id] = { elementIds };
-      __privateGet(this, _activeGuests).set(id, {
-        guestWindow: documentEle?.defaultView,
-        ...app
+      __privateGet(this, _activeApps).set(id, {
+        elementIds,
+        guest: {
+          guestWindow: documentEle?.defaultView,
+          ...app
+        }
       });
     });
     __privateAdd(this, _waitAndInitApplication, (options, requests) => {
-      const { id, name, hostUrl, manifestPath, homeRoute, history, theme } = options;
-      return Promise.all(requests).then(
-        __privateGet(this, _addAppToActiveAppList).bind(null, options.id, options.documentEle)
-      ).then(
+      const {
+        id,
+        name,
+        hostUrl,
+        manifestPath,
+        homeRoute,
+        history,
+        theme,
+        documentEle
+      } = options;
+      return Promise.all(requests).then(__privateGet(this, _addAppToActiveAppList).bind(null, id, documentEle)).then(
         __privateGet(this, _initApplication).bind(null, {
           id,
           name,
@@ -132,8 +143,17 @@ class CMicroAppFactory {
         throw new Error(
           `Application ${name} with id ${id} doesn't expose init method`
         );
+      const host = new import_microfeHost.CMicroFEHost({
+        guest: {
+          id
+        },
+        version: __privateGet(this, _version),
+        logger: __privateGet(this, _logger),
+        soManager: __privateGet(this, _soManager),
+        eventManager: __privateGet(this, _eventManager)
+      });
       return app.init({
-        host: __privateGet(this, _host),
+        host,
         hostUrl,
         manifestPath,
         homeRoute,
@@ -177,6 +197,7 @@ class CMicroAppFactory {
       __privateGet(this, _styleLoader).removeDynamicImportedStyles(hostUrl, documentEle);
       if (window.emui?.[id])
         delete window.emui[id];
+      __privateGet(this, _activeApps).delete(id);
       __privateGet(this, _logger).info({ message: "Application unloaded", appId: id });
     });
     __privateAdd(this, _mountApp, async ({ id, name }) => {
@@ -203,11 +224,19 @@ class CMicroAppFactory {
         containerId: `${APP_CONTAINER_ID_PREFIX}${id}`
       });
     });
+    /**
+     * registers scripting object to the host
+     *
+     * @param {AddScriptingObjectParams<AppObjects>} params params to add scripting object
+     */
+    __publicField(this, "addScriptingObject", (params) => {
+      __privateGet(this, _soManager).addScriptingObject(params);
+    });
     /**
      * Close all active guest micro frontend applications
      */
     __publicField(this, "closeAllApps", async () => {
-      await Promise.all(Object.keys(__privateGet(this, _activeApps)).map(this.closeApp));
+      await Promise.all([...__privateGet(this, _activeApps).keys()].map(this.closeApp));
     });
     /**
      * Close guest micro frontend application
@@ -230,29 +259,36 @@ class CMicroAppFactory {
           throw new Error(`Iframe for application with id ${id} is not found`);
         }
         __privateGet(this, _unloadApp).call(this, { id, hostUrl, documentEle: frameEle.contentDocument });
+        __privateGet(this, _soManager).clearGuestScriptingObjects(id);
         import_frame.Frame.remove(id);
       }
     });
+    /**
+     * dispatch event to guest microfrontend application
+     *
+     * @param {DispatchEventParams<EventId, Params>} params - event parameters
+     */
+    __publicField(this, "dispatchEvent", async (params) => __privateGet(this, _eventManager).dispatchEvent(params));
     /**
      * Get guest by id
      *
      * @param id unique id of guest
      * @returns guest instance
      */
-    __publicField(this, "getGuest", (id) => __privateGet(this, _activeGuests).get(id));
+    __publicField(this, "getGuest", (id) => __privateGet(this, _activeApps).get(id)?.guest);
     /**
      * Get list of active guests
      *
      * @returns list of active guests
      */
-    __publicField(this, "getGuests", () => Array.from(__privateGet(this, _activeGuests).values()));
+    __publicField(this, "getGuests", () => [...__privateGet(this, _activeApps).values()].map((app) => app.guest));
     /**
-     * Initialize factory
+     * Initialize appBridge
      */
     __publicField(this, "init", async () => {
       await __privateGet(this, _appConfig).load();
       __privateGet(this, _microFEConfig).init({
-        version: __privateGet(this, _host).version,
+        version: __privateGet(this, _version),
         appConfig: __privateGet(this, _appConfig)
       });
     });
@@ -298,6 +334,7 @@ class CMicroAppFactory {
           documentEle: frameEle.contentDocument
         });
         await __privateGet(this, _mountApp).call(this, appConfig);
+        return __privateGet(this, _activeApps).get(id)?.guest;
       } catch (err) {
         __privateGet(this, _unloadApp).call(this, {
           id,
@@ -308,6 +345,29 @@ class CMicroAppFactory {
         throw err;
       }
     });
+    /**
+     * emit event to all subscribers (deprecated)
+     *
+     * @deprecated use dispatchEvent instead
+     * @param eventId unique id of the event. The format is <scripting object name>.<event name>
+     * @param data data to be sent to the subscribers of the event
+     * @returns true if event is published successfully
+     */
+    __publicField(this, "publish", (eventId, data) => (0, import_pubsub_js.publish)(eventId, data));
+    /**
+     * remove all listeners
+     */
+    __publicField(this, "removeAllEventListeners", () => {
+      __privateGet(this, _eventManager).unsubscribeAll();
+    });
+    /**
+     * removes scripting object from the host
+     *
+     * @param objectId unique id of the scripting object
+     */
+    __publicField(this, "removeScriptingObject", (objectId) => {
+      __privateGet(this, _soManager).removeScriptingObject(objectId);
+    });
     /**
      * Unmount guest micro frontend application from DOM
      *
@@ -327,30 +387,25 @@ class CMicroAppFactory {
     if (!logger)
       throw new Error("logger is required");
     __privateSet(this, _logger, params.logger);
+    __privateSet(this, _version, params.version);
     __privateSet(this, _appConfig, new import_app.CAppConfig({
       version: params.version,
       baseUrl: params.appConfigBaseUrl
     }));
     __privateSet(this, _scriptLoader, new import_loaders.ScriptLoader(logger));
     __privateSet(this, _styleLoader, new import_loaders.StyleLoader(logger));
-    __privateSet(this, _host, new import_microfeHost.CMicroFEHost(params));
-  }
-  /**
-   * Get instance of host
-   *
-   * @returns instance of host
-   */
-  get host() {
-    return __privateGet(this, _host);
+    __privateSet(this, _soManager, new import_scriptingObjectManager.ScriptingObjectManager());
+    __privateSet(this, _eventManager, new import_eventManager.EventManager());
   }
 }
 _logger = new WeakMap();
+_version = new WeakMap();
 _scriptLoader = new WeakMap();
 _styleLoader = new WeakMap();
 _appConfig = new WeakMap();
 _microFEConfig = new WeakMap();
-_host = new WeakMap();
-_activeGuests = new WeakMap();
+_soManager = new WeakMap();
+_eventManager = new WeakMap();
 _activeApps = new WeakMap();
 _removeAssetsFromDOM = new WeakMap();
 _addAppToActiveAppList = new WeakMap();

package/dist/cjs/config/microFE.js

@@ -57,6 +57,7 @@ module.exports = __toCommonJS(microFE_exports);
 var import_merge = __toESM(require("lodash/merge"), 1);
 var import_utils = require("../utils.js");
 var import_constant = require("../constant.js");
+var import_common = require("../typings/common.js");
 var _microFrontendApps;
 const CONFIG_KEY = "microFrontendApps";
 const isCIBuild = () => process.env.CI === "true";
@@ -127,7 +128,8 @@ const getConfig = ({
     {
       name: id,
       mode: "production",
-      manifestPath: "./{SYSTEM_VERSION}/"
+      manifestPath: "./{SYSTEM_VERSION}/",
+      securityContext: import_common.SecurityContext.USER
     },
     config,
     envConfig

package/dist/cjs/eventManager.js

@@ -0,0 +1,201 @@
+"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 eventManager_exports = {};
+__export(eventManager_exports, {
+  EventManager: () => EventManager
+});
+module.exports = __toCommonJS(eventManager_exports);
+var import_uuid = require("uuid");
+var _listeners, _asyncCallwithTimeout, _emitEvent, _emitEventWithFeedback;
+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;
+};
+class EventManager {
+  constructor() {
+    /**
+     * event listeners
+     */
+    __privateAdd(this, _listeners, /* @__PURE__ */ new Map());
+    /**
+     * call an async function with a timeout
+     *
+     * @param promise async function to call
+     * @param feedbackWaitTime timeout in milliseconds
+     * @returns result of the async function or undefined if timeout
+     */
+    __privateAdd(this, _asyncCallwithTimeout, (promise, feedbackWaitTime) => {
+      const timeout = new Promise((resolve) => {
+        setTimeout(() => {
+          resolve();
+        }, feedbackWaitTime);
+      });
+      return Promise.race([promise, timeout]);
+    });
+    /**
+     * emit an event to set of listeners
+     *
+     * @param {EmitEventParam} param - parameters for emitting an event
+     */
+    __privateAdd(this, _emitEvent, (param) => {
+      const { eventName, scriptingObject, eventParams, listeners } = param;
+      listeners.map(async (listener) => {
+        try {
+          await listener.callback({
+            obj: scriptingObject,
+            eventName,
+            eventParams
+          });
+        } catch (e) {
+        }
+      });
+    });
+    __privateAdd(this, _emitEventWithFeedback, async ({
+      eventId,
+      eventName,
+      scriptingObject,
+      eventParams,
+      feedbackWaitTime
+    }) => {
+      const listeners = __privateGet(this, _listeners).get(eventId) || [];
+      const promises = listeners.map(
+        (listener) => __privateGet(this, _asyncCallwithTimeout).call(
+          this,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          listener.callback({
+            obj: scriptingObject,
+            eventName,
+            eventParams
+          }),
+          feedbackWaitTime
+        )
+      );
+      const retValues = await Promise.all(promises);
+      return flatten(retValues);
+    });
+    /**
+     * dispatch an event
+     *
+     * @param {DispatchEventParam<EventId, Params>} param - parameters for dispatching an event
+     */
+    __publicField(this, "dispatchEvent", async (param) => {
+      const {
+        event: { id, name, requiresFeedback, scriptingObject },
+        eventParams,
+        feedbackWaitTime = 1e3
+      } = param;
+      if (!id)
+        throw new Error("Event Id is required");
+      const listeners = __privateGet(this, _listeners).get(id) || [];
+      if (!requiresFeedback) {
+        __privateGet(this, _emitEvent).call(this, {
+          eventName: name,
+          scriptingObject,
+          eventParams,
+          listeners
+        });
+        return Promise.resolve();
+      }
+      return __privateGet(this, _emitEventWithFeedback).call(this, {
+        eventId: id,
+        eventName: name,
+        scriptingObject,
+        eventParams,
+        feedbackWaitTime
+      });
+    });
+    /**
+     * Subscribe to an event
+     *
+     * @param {SubscribeParam<EventId, AppEvents[EventId]>} param - parameters for subscribing to an event
+     */
+    __publicField(this, "subscribe", (param) => {
+      const { eventId, listener } = param;
+      if (!eventId)
+        throw new Error("eventId is required");
+      if (!listener)
+        throw new Error("Listener is required");
+      const listeners = __privateGet(this, _listeners).get(eventId) || [];
+      const subscriptionId = (0, import_uuid.v4)();
+      listeners.push({
+        subscriptionId,
+        callback: listener
+      });
+      __privateGet(this, _listeners).set(eventId, listeners);
+      return subscriptionId;
+    });
+    /**
+     * Unsubscribe from an event
+     *
+     * @param {UnsubscribeParam<EventId>} param - parameters for unsubscribing from an event
+     */
+    __publicField(this, "unsubscribe", (param) => {
+      const { eventId, subscriptionId } = param;
+      if (!eventId)
+        throw new Error("eventId id is required");
+      if (subscriptionId) {
+        const listeners = __privateGet(this, _listeners).get(eventId) || [];
+        const index = listeners.findIndex(
+          (listener) => listener.subscriptionId === subscriptionId
+        );
+        if (index > -1) {
+          listeners.splice(index, 1);
+          __privateGet(this, _listeners).set(eventId, listeners);
+        }
+      } else {
+        __privateGet(this, _listeners).delete(eventId);
+      }
+    });
+    /**
+     * Unsubscribe from all events
+     */
+    __publicField(this, "unsubscribeAll", () => {
+      __privateGet(this, _listeners).clear();
+    });
+  }
+}
+_listeners = new WeakMap();
+_asyncCallwithTimeout = new WeakMap();
+_emitEvent = new WeakMap();
+_emitEventWithFeedback = new WeakMap();

package/dist/cjs/index.js

@@ -18,10 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var lib_exports = {};
 __export(lib_exports, {
-  CMicroAppFactory: () => import_microfeFactory.CMicroAppFactory,
+  CAppBridge: () => import_appBridge.CAppBridge,
   Event: () => import_microfe_common.Event,
-  ScriptingObject: () => import_microfe_common.ScriptingObject
+  ScriptingObject: () => import_microfe_common.ScriptingObject,
+  SecurityContext: () => import_common.SecurityContext
 });
 module.exports = __toCommonJS(lib_exports);
+var import_common = require("./typings/common.js");
 var import_microfe_common = require("@elliemae/microfe-common");
-var import_microfeFactory = require("./microfeFactory.js");
+var import_appBridge = require("./appBridge.js");

package/dist/cjs/microfeHost.js

@@ -45,10 +45,9 @@ __export(microfeHost_exports, {
 });
 module.exports = __toCommonJS(microfeHost_exports);
 var import_pubsub_js = require("pubsub-js");
-var import_microfe_common = require("@elliemae/microfe-common");
 var import_frame = require("./frame.js");
 var import_constant = require("./constant.js");
-var _logger, _version, _eventManager, _scriptingObjects;
+var _logger, _guest, _version, _soManager, _eventManager;
 class CMicroFEHost {
   /**
    * Create new instance of the host frontend application
@@ -57,9 +56,10 @@ class CMicroFEHost {
    */
   constructor(params) {
     __privateAdd(this, _logger, void 0);
+    __privateAdd(this, _guest, void 0);
     __privateAdd(this, _version, void 0);
+    __privateAdd(this, _soManager, void 0);
     __privateAdd(this, _eventManager, void 0);
-    __privateAdd(this, _scriptingObjects, /* @__PURE__ */ new Map());
     /**
      * add listener to the scripting object event
      *
@@ -67,30 +67,6 @@ class CMicroFEHost {
      * @returns subscription id
      */
     __publicField(this, "addEventListener", (params) => __privateGet(this, _eventManager).subscribe(params));
-    /**
-     * registers scripting object to the host
-     *
-     * @param so scripting object to publish
-     */
-    __publicField(this, "addScriptingObject", (so) => {
-      if (!so?.id || !so?._toJSON) {
-        throw new Error("Object is not derived from ScriptingObject");
-      }
-      const objectId = so.id.toLowerCase();
-      if (objectId === "module")
-        throw new Error(
-          "Do not publish the module object. Create a concrete object derived from it."
-        );
-      if (__privateGet(this, _scriptingObjects).has(objectId))
-        throw new Error(`Scripting Object ${so.id} already exists`);
-      __privateGet(this, _scriptingObjects).set(objectId, so);
-    });
-    /**
-     * dispatch event to guest microfrontend application
-     *
-     * @param {DispatchEventParams<EventId, Params>} params - event parameters
-     */
-    __publicField(this, "dispatchEvent", async (params) => __privateGet(this, _eventManager).dispatchEvent(params));
     /**
      * Get reference to the scripting object (or proxy) by name
      *
@@ -98,11 +74,9 @@ class CMicroFEHost {
      * @param objectId
      * @returns scripting object reference
      */
-    __publicField(this, "getObject", (objectId) => {
-      const id = objectId.toLowerCase();
-      const data = __privateGet(this, _scriptingObjects).get(id);
-      return Promise.resolve(data || null);
-    });
+    __publicField(this, "getObject", (objectId) => Promise.resolve(
+      __privateGet(this, _soManager).getObject({ objectId, guest: __privateGet(this, _guest) })
+    ));
     /**
      * removes listener from the scripting object event
      *
@@ -111,22 +85,6 @@ class CMicroFEHost {
     __publicField(this, "removeEventListener", (params) => {
       __privateGet(this, _eventManager).unsubscribe(params);
     });
-    /**
-     * remove all listeners
-     */
-    __publicField(this, "removeAllEventListeners", () => {
-      __privateGet(this, _eventManager).unsubscribeAll();
-    });
-    /**
-     * removes scripting object from the host
-     *
-     * @param objectId unique id of the scripting object
-     */
-    __publicField(this, "removeScriptingObject", (objectId) => {
-      __privateGet(this, _scriptingObjects).delete(
-        objectId.toLowerCase()
-      );
-    });
     /**
      * set the size of the guest application iframe window
      *
@@ -142,14 +100,6 @@ class CMicroFEHost {
       }
     });
     // deprecated legacy eventing methods (to be removed)
-    /**
-     * emit event to all subscribers (deprecated)
-     *
-     * @param eventId unique id of the event. The format is <scripting object name>.<event name>
-     * @param data data to be sent to the subscribers of the event
-     * @returns true if event is published successfully
-     */
-    __publicField(this, "publish", (eventId, data) => (0, import_pubsub_js.publish)(eventId, data));
     /**
      * subscribe to an scripting object event (deprecated)
      *
@@ -168,9 +118,11 @@ class CMicroFEHost {
     __publicField(this, "unsubscribe", (token) => {
       (0, import_pubsub_js.unsubscribe)(token);
     });
+    __privateSet(this, _guest, params.guest);
     __privateSet(this, _logger, params.logger);
     __privateSet(this, _version, params?.version || import_constant.LATEST_VERSION);
-    __privateSet(this, _eventManager, new import_microfe_common.EventManager());
+    __privateSet(this, _soManager, params.soManager);
+    __privateSet(this, _eventManager, params.eventManager);
   }
   /**
    * application release version
@@ -182,6 +134,7 @@ class CMicroFEHost {
   }
 }
 _logger = new WeakMap();
+_guest = new WeakMap();
 _version = new WeakMap();
+_soManager = new WeakMap();
 _eventManager = new WeakMap();
-_scriptingObjects = new WeakMap();