@elliemae/pui-app-sdk 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/esm/utils/constants.js

@@ -14,9 +14,11 @@ const Themes = {
 };
 const HOST_WINDOW_RESIZED = "HOST_WINDOW_RESIZED";
 const HOST_WINDOW_BREAKPOINT_CHANGED = "HOST_WINDOW_BREAKPOINT_CHANGED";
+const SESSION_RENEWAL_INTERVAL = 6e4;
 export {
   HOST_WINDOW_BREAKPOINT_CHANGED,
   HOST_WINDOW_RESIZED,
+  SESSION_RENEWAL_INTERVAL,
   SESSION_TIMEOUT_INTERVAL,
   Themes,
   constants_default as default

package/dist/esm/utils/decorators/classDecorators.js

@@ -20,7 +20,7 @@ function Mixins(...constructors) {
     });
   };
 }
-const SINGLETON_KEY = Symbol("singleton");
+const SINGLETON_KEY = /* @__PURE__ */ Symbol("singleton");
 function Singleton(type) {
   return new Proxy(type, {
     construct(target, argsList, newTarget) {

package/dist/esm/utils/decorators/functionDecorators.js

@@ -127,12 +127,110 @@ function Throttle(delay = 300) {
     return descriptor;
   };
 }
+function AsyncSingleExecution(_target, _propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  const instanceMap = /* @__PURE__ */ new WeakMap();
+  descriptor.value = function(...args) {
+    const instance = this;
+    if (!instanceMap.has(instance)) {
+      instanceMap.set(instance, /* @__PURE__ */ new Map());
+    }
+    const promiseMap = instanceMap.get(instance);
+    const key = JSON.stringify(args);
+    if (promiseMap.has(key)) {
+      return promiseMap.get(key);
+    }
+    const promise = originalMethod.apply(this, args);
+    if (promise && typeof promise.then === "function") {
+      promiseMap.set(key, promise);
+      promise.catch((e) => e).finally(() => {
+        promiseMap.delete(key);
+      });
+    }
+    return promise;
+  };
+  return descriptor;
+}
+function RetryAsync(retries = 3, interval = 2e3, reThrowException = true) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      let attempts = 0;
+      while (attempts < retries) {
+        try {
+          const result = originalMethod.apply(this, args);
+          if (result && typeof result.then === "function") {
+            return await result;
+          }
+          return result;
+        } catch (error) {
+          attempts += 1;
+          if (attempts >= retries) {
+            if (reThrowException) {
+              throw error;
+            }
+            return void 0;
+          }
+          await new Promise((resolve) => {
+            setTimeout(() => {
+              resolve(true);
+            }, interval);
+          });
+        }
+      }
+      return void 0;
+    };
+    return descriptor;
+  };
+}
+function MemoizeSingleArgPrimitive(_target, _propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  const cache = {};
+  function isPrimitiveArg(arg) {
+    const type = typeof arg;
+    return arg === null || type === "string" || type === "number" || type === "boolean" || type === "symbol" || type === "undefined";
+  }
+  function getCachedResult(params) {
+    const { context, cacheObj, key, original, arg } = params;
+    if (Object.prototype.hasOwnProperty.call(cacheObj, key)) {
+      return cacheObj[key];
+    }
+    const result = arg !== void 0 ? original.call(context, arg) : original.call(context);
+    cacheObj[key] = result;
+    return result;
+  }
+  descriptor.value = function MemoizeSingleArgPrimitiveWrapper(...args) {
+    if (args.length === 0) {
+      return getCachedResult({
+        context: this,
+        cacheObj: cache,
+        key: "__NO_ARGS__",
+        original: originalMethod
+      });
+    }
+    if (args.length === 1 && isPrimitiveArg(args[0])) {
+      const key = String(args[0]);
+      return getCachedResult({
+        context: this,
+        cacheObj: cache,
+        key,
+        original: originalMethod,
+        arg: args[0]
+      });
+    }
+    return originalMethod.apply(this, args);
+  };
+  return descriptor;
+}
 export {
+  AsyncSingleExecution,
   CacheUntilResolved,
   Debounce,
   ImmutableArgs,
   Memoize,
   MemoizeAsync,
+  MemoizeSingleArgPrimitive,
   QueueTask,
+  RetryAsync,
   Throttle
 };

package/dist/esm/utils/decorators/index.js

@@ -1,12 +1,15 @@
 import { Mixins, Singleton } from "./classDecorators.js";
 import {
+  AsyncSingleExecution,
   CacheUntilResolved,
   Debounce,
   ImmutableArgs,
   Memoize,
   MemoizeAsync,
   QueueTask,
-  Throttle
+  Throttle,
+  RetryAsync,
+  MemoizeSingleArgPrimitive
 } from "./functionDecorators.js";
 const decorators = {
   class: {
@@ -19,8 +22,11 @@ const decorators = {
     ImmutableArgs,
     Memoize,
     MemoizeAsync,
+    MemoizeSingleArgPrimitive,
     QueueTask,
-    Throttle
+    Throttle,
+    AsyncSingleExecution,
+    RetryAsync
   }
 };
 export {

package/dist/esm/utils/helpers.js

@@ -29,7 +29,23 @@ const getProductAppDetails = () => {
     appPageTitle
   };
 };
+const abortPromise = ({
+  promise,
+  delay,
+  retValue = false,
+  throwError = false,
+  errMsg
+}) => Promise.race([
+  promise,
+  new Promise((resolve, reject) => {
+    setTimeout(() => {
+      if (throwError) reject(new Error(errMsg));
+      else resolve(retValue);
+    }, delay);
+  })
+]);
 export {
+  abortPromise,
   convertRelativeToAbsoluteUrl,
   getProductAppDetails,
   isCIBuild,

package/dist/esm/utils/logrocket.js

@@ -0,0 +1,29 @@
+import {
+  lrTrackGuarded,
+  markLrIdentified,
+  resetLrIdentity
+} from "@elliemae/pui-analytics-so";
+const getLogRocket = () => window.emui?.logRocket;
+const cleanupData = (data) => {
+  const cleanedData = {};
+  Object.entries(data).forEach(([key, value]) => {
+    cleanedData[key] = value === void 0 || value === null ? "" : value;
+  });
+  return cleanedData;
+};
+const lrIdentify = (userId, eventEx) => {
+  const logRocket = getLogRocket();
+  if (logRocket) {
+    logRocket.identify(userId, cleanupData(eventEx));
+    markLrIdentified(userId);
+  }
+};
+const lrTrack = (event, eventEx = {}) => {
+  lrTrackGuarded(event, eventEx);
+};
+export {
+  getLogRocket,
+  lrIdentify,
+  lrTrack,
+  resetLrIdentity
+};

package/dist/esm/utils/micro-frontend/app-bridge.js

@@ -0,0 +1,25 @@
+import { CAppBridge } from "@elliemae/pui-app-bridge";
+import { getLogger } from "../logger.js";
+import { getAppConfig, getAppConfigValue } from "../app-config/config.js";
+let appBridge = null;
+const getAppBridge = async () => {
+  if (!appBridge) {
+    const logger = getLogger();
+    const version = window.emui?.version || "latest";
+    appBridge = new CAppBridge({
+      logger,
+      version,
+      // eslint-disable-next-line no-underscore-dangle
+      appConfigBaseUrl: window?.emui?._ASSET_PATH
+    });
+    await appBridge.init(getAppConfig());
+    const microApps = getAppConfigValue("microFrontendApps");
+    if (microApps) {
+      Object.keys(microApps).forEach((id) => appBridge.warmUp(id));
+    }
+  }
+  return appBridge;
+};
+export {
+  getAppBridge
+};

package/dist/esm/utils/micro-frontend/guest.js

@@ -1,17 +1,18 @@
 import _ from "lodash";
 import { v4 as uuidv4 } from "uuid";
 import { getDefaultTheme } from "@elliemae/pui-theme";
+import { SSFGuest } from "@elliemae/ssf-guest";
+import { updateBAEventParameters } from "@elliemae/pui-analytics-so";
 import { getWindow } from "../window.js";
 import { loadAppConfig } from "../app-config/index.js";
 import { getAppConfigValue } from "../app-config/config.js";
-import { browserHistory } from "../history.js";
+import { browserHistory, memoryHistory } from "../history.js";
 import { consoleLogger } from "../console-logger.js";
 import { setLogger } from "../logger.js";
 import { removeStorageEvents } from "../web-storage.js";
-import { updateBAEventParameters } from "./scripting-objects/web-analytics.js";
-import { setAppDynamicsUserData } from "../../analytics/appdynamics.js";
-import { SSFGuestAdapter } from "./ssfguest-adapter.js";
-import { setHostApp } from "./host-app.js";
+import { getAppBridge } from "./app-bridge.js";
+import { abortPromise } from "../helpers.js";
+import { getSSFHost, setSSFHost } from "./ssf-host.js";
 const isCrossDomain = () => {
   try {
     window.parent.document;
@@ -20,6 +21,11 @@ const isCrossDomain = () => {
     return true;
   }
 };
+var CommunicationMethod = /* @__PURE__ */ ((CommunicationMethod2) => {
+  CommunicationMethod2["SSF"] = "ssf";
+  CommunicationMethod2["APPSDK"] = "app-sdk";
+  return CommunicationMethod2;
+})(CommunicationMethod || {});
 class CMicroAppGuest {
   /**
    * unique microapp id
@@ -30,6 +36,29 @@ class CMicroAppGuest {
   appId;
   props;
   containerId;
+  /**
+   * communication method used between microapps
+   */
+  #communicationMethod;
+  /**
+   * reference to SSFHost instance
+   */
+  #ssfHostRef;
+  /**
+   * true if the app prefers to use SSF V2 Guest from App SDK to communicate with host(optional, default: true)
+   */
+  #useV2Guest;
+  #selfInitialize;
+  /**
+   * AppBridge instance
+   */
+  #appBridge = null;
+  /**
+   * Stores the initial route provided by the host when useParentHistory is false.
+   * Applied in mount() before onMount to set the URL prior to the first React render,
+   * avoiding a flash of the default route.
+   */
+  #pendingInitialRoute = null;
   onInit;
   onMount;
   onUnmount;
@@ -40,6 +69,7 @@ class CMicroAppGuest {
     window.emui.uuid = window.emui.uuid || uuidv4();
     this.appId = window.emui?.appId || getAppConfigValue("appId");
     this.#uuid = window.emui.uuid;
+    this.#communicationMethod = "app-sdk" /* APPSDK */;
     this.props = {
       host: null,
       hostUrl: null,
@@ -50,6 +80,10 @@ class CMicroAppGuest {
     };
     this.logger = params?.logger || consoleLogger;
     setLogger(this.logger);
+    if (params?.ssfHostRef) setSSFHost(params.ssfHostRef);
+    this.#ssfHostRef = getSSFHost();
+    this.#useV2Guest = params?.useV2Guest !== false;
+    this.#selfInitialize = params?.selfInitialize ?? false;
     this.onInit = params?.onInit;
     this.onMount = params?.onMount;
     this.onUnmount = params?.onUnmount;
@@ -57,11 +91,15 @@ class CMicroAppGuest {
     this.getHost = this.getHost.bind(this);
     this.getLogger = this.getLogger.bind(this);
     this.getProps = this.getProps.bind(this);
-    this.#addAppToGlobalVariable();
+    if (this.#selfInitialize) {
+      window.addEventListener("beforeunload", this.#onWindowUnload.bind(this));
+    } else {
+      this.#addAppToGlobalVariable();
+    }
   }
   static getInstance(params) {
     if (!this.instance) {
-      this.instance = new this(params);
+      this.instance = new CMicroAppGuest(params);
     }
     return this.instance;
   }
@@ -77,6 +115,46 @@ class CMicroAppGuest {
   getLogger() {
     return this.logger;
   }
+  getObject(objectId) {
+    let host = null;
+    if (this.#communicationMethod === "ssf" /* SSF */) {
+      host = this.getHost();
+      return host.getObject(objectId);
+    }
+    host = this.getHost();
+    if (!host) return Promise.resolve(null);
+    return host.getObject(objectId);
+  }
+  /**
+   * subscribe to the scripting object event
+   * @param {SubscribeParam<EventId, AppEvents[EventId]>} params - the parameters for the subscription
+   * @param {string} params.soName - the name of the scripting object
+   * @param {string} params.eventName - the name of the event
+   * @param {Function} params.callback - the callback function to be called when the event is triggered
+   * @returns {void}
+   */
+  subscribe(params) {
+    let host = null;
+    if (this.#communicationMethod === "ssf" /* SSF */) {
+      host = this.getHost();
+      return host.subscribe(params);
+    }
+    host = this.getHost();
+    return host.subscribe(params);
+  }
+  /**
+   * unsubscribe from the scripting object event
+   * @param params - parameters for the unsubscription
+   */
+  unsubscribe(params) {
+    let host = null;
+    if (this.#communicationMethod === "ssf" /* SSF */) {
+      host = this.getHost();
+      host.unsubscribe(params);
+    }
+    host = this.getHost();
+    host.unsubscribe(params);
+  }
   getProps() {
     return this.props;
   }
@@ -124,65 +202,189 @@ class CMicroAppGuest {
    * remove the microapp from the global variable from the parent window and current window
    */
   #onWindowUnload() {
-    const browserWindow = getWindow();
-    if (Array.isArray(browserWindow.emui[this.appId])) {
-      const existingApps = browserWindow.emui[this.appId];
-      const index = existingApps.findIndex((app) => app.uuid === this.#uuid);
-      if (index > -1) existingApps.splice(index, 1);
-      if (existingApps.length === 0) {
+    if (!this.#selfInitialize) {
+      const browserWindow = getWindow();
+      if (Array.isArray(browserWindow.emui[this.appId])) {
+        const existingApps = browserWindow.emui[this.appId];
+        const index = existingApps.findIndex((app) => app.uuid === this.#uuid);
+        if (index > -1) existingApps.splice(index, 1);
+        if (existingApps.length === 0) {
+          delete browserWindow.emui[this.appId];
+        }
+      } else {
         delete browserWindow.emui[this.appId];
       }
-    } else {
-      delete browserWindow.emui[this.appId];
+      delete window.emui.app;
     }
-    delete window.emui.app;
     this.unmount({ containerId: this.containerId }).catch(() => {
     });
   }
   getSessionStorageItem(key) {
     let value = sessionStorage.getItem(key);
-    if (!value && this.props.host?.getItem) {
-      value = this.props.host.getItem(key);
+    const host = this.getHost();
+    if (!value && host?.getItem) {
+      value = host.getItem(key);
     }
     return value;
   }
-  async getSSFAdapter() {
+  async findHost() {
     let host = null;
-    if (window.parent !== window) {
-      if (!isCrossDomain()) {
-        host = window.parent?.emui?.MicroAppHost || null;
-      }
-      if (!host) {
-        const ssfAdapter = new SSFGuestAdapter();
-        if (!await ssfAdapter.init()) return null;
-        host = ssfAdapter;
-      }
+    if (!isCrossDomain()) {
+      host = window.parent?.emui?.MicroAppHost ?? null;
+    }
+    if (!host && this.#useV2Guest) {
+      host = new SSFGuest({ appLogger: this.logger });
+      if (await abortPromise({
+        promise: host.connect(),
+        delay: 1e3,
+        retValue: false
+      })) {
+        host = null;
+      } else this.#communicationMethod = "ssf" /* SSF */;
     }
     return host;
   }
   get uuid() {
     return this.#uuid;
   }
+  /**
+   * Resolves the history object based on the app config and host context.
+   * - SSF communication → always use browserHistory (guest owns its URL in a
+   *   cross-origin iframe)
+   * - useParentHistory: true → use the host-provided history
+   * - useParentHistory: false + inside iframe → use memoryHistory to avoid
+   *   pushState on the iframe which causes full reloads instead of SPA routing
+   * - otherwise → keep the current history (browserHistory or params.history)
+   * @param {History} hostHistory - The history object provided by the host app.
+   * @returns {boolean} The resolved value of useParentHistory.
+   */
+  #resolveHistory(hostHistory) {
+    if (this.#communicationMethod === "ssf" /* SSF */) {
+      this.props.history = browserHistory;
+      return false;
+    }
+    const useParentHistory = getAppConfigValue(
+      "useParentHistory",
+      true
+    );
+    if (useParentHistory && hostHistory) {
+      this.props.history = hostHistory;
+    } else if (!useParentHistory && window !== window.parent) {
+      this.props.history = memoryHistory;
+    }
+    return useParentHistory;
+  }
+  async #discoverHost() {
+    if (window.emui?.__host) {
+      return window.emui.__host;
+    }
+    if (this.#useV2Guest) {
+      const ssfGuest = new SSFGuest({ appLogger: this.logger });
+      const failed = await abortPromise({
+        promise: ssfGuest.connect(),
+        delay: 1e3,
+        retValue: true
+      });
+      if (!failed) {
+        this.#communicationMethod = "ssf" /* SSF */;
+        return ssfGuest;
+      }
+    }
+    return null;
+  }
+  #applyModuleParams(params) {
+    if (params.homeRoute) this.props.homeRoute = params.homeRoute;
+    if (params.theme) this.props.theme = params.theme;
+    if (params.hostUrl) this.props.hostUrl = params.hostUrl;
+    if (params.manifestPath)
+      this.props.manifestPath = params.manifestPath;
+    this.#applyHistoryFromParams(params);
+  }
+  #applyHistoryFromParams(params) {
+    if (this.#communicationMethod === "ssf" /* SSF */) {
+      this.props.history = browserHistory;
+      return;
+    }
+    const useParentHistory = getAppConfigValue(
+      "useParentHistory",
+      true
+    );
+    if (useParentHistory && params.history) {
+      this.props.history = params.history;
+    } else if (!useParentHistory && window !== window.parent) {
+      this.props.history = memoryHistory;
+    }
+    this.#applyInitialRoute(params, useParentHistory);
+  }
+  #applyInitialRoute(params, useParentHistory) {
+    if (!params.initialRoute || useParentHistory) return;
+    const route = typeof params.initialRoute === "string" ? params.initialRoute : params.initialRoute.pathname;
+    if (route) this.props.history.push(route);
+  }
+  /**
+   * Guest-initiated lifecycle: discovers the host, pulls module parameters,
+   * and applies them. After this resolves the guest is ready to render.
+   * Requires selfInitialize: true in the constructor so the bridge
+   * skips calling init() / mount() on this guest.
+   * @returns module parameters provided by the host
+   */
+  async initialize() {
+    const isStandalone = window.top === window.self && !window.opener;
+    if (isStandalone) {
+      await loadAppConfig();
+      this.logger.info("Running in standalone mode \u2014 skipping host discovery");
+      if (this.onInit) this.onInit(this.props);
+      return { moduleId: this.appId };
+    }
+    const [host] = await Promise.all([this.#discoverHost(), loadAppConfig()]);
+    if (!host) {
+      throw new Error(
+        "Unable to discover host. Ensure the host uses an updated pui-app-sdk and pui-microfe, or use the host-initiated model (onInit/onMount)."
+      );
+    }
+    this.props.host = host;
+    const module = await host.getObject("module");
+    if (!module) {
+      throw new Error(
+        `Host did not register a module scripting object for guest "${this.appId}". Ensure the host registers a module SO before rendering GuestMicroApp.`
+      );
+    }
+    const params = await module.getParameters();
+    this.#applyModuleParams(params);
+    if (this.onInit) this.onInit(this.props);
+    return params;
+  }
   async init(options) {
-    this.props = _.merge(this.props, options);
-    this.props.history = options?.history || this.props.history;
+    const { history, ...rest } = options ?? {};
+    this.props = _.merge(this.props, rest);
     if (!this.props.host) {
-      const host = await this.getSSFAdapter();
-      if (host) this.props.host = host;
+      const host = await this.findHost();
+      if (host) {
+        this.props.host = host;
+      } else this.logger.warn("unable to connect to host microapp");
     }
-    if (this.props.host) setHostApp(this.props.host);
     __webpack_public_path__ = __webpack_public_path__.replace(/\/?$/, "/");
     return loadAppConfig().then(() => {
       const instanceId = this.getSessionStorageItem("instanceId") || "";
       const userId = this.getSessionStorageItem("userId") || "";
       updateBAEventParameters({ appId: this.appId, instanceId, userId });
-      setAppDynamicsUserData({ appId: this.appId, instanceId, userId });
-      if (this.onInit) this.onInit(this.props);
+      const useParentHistory = this.#resolveHistory(history);
+      if (!useParentHistory && options?.initialRoute) {
+        this.#pendingInitialRoute = typeof options.initialRoute === "string" ? options.initialRoute : options.initialRoute.pathname || null;
+      }
+      return getAppBridge().then((appBridge) => {
+        this.#appBridge = appBridge;
+        if (this.onInit) this.onInit(this.props);
+      });
     });
   }
   mount(options = { containerId: "app-container" }) {
     this.containerId = options?.containerId;
     return Promise.resolve().then(() => {
+      if (this.#pendingInitialRoute) {
+        this.props.history.push(this.#pendingInitialRoute);
+        this.#pendingInitialRoute = null;
+      }
       if (this.onMount) this.onMount(options);
     });
   }
@@ -198,6 +400,45 @@ class CMicroAppGuest {
   navigate(url, state) {
     if (url) this.props.history.push(url, state);
   }
+  /**
+   * add scripting object for child microapp to use
+   * @param so - The scripting object to be added.
+   * @param params - Optional parameters for adding the scripting object.
+   */
+  addScriptingObject(so, params) {
+    if (this.#appBridge) {
+      this.#appBridge.addScriptingObject(so, params);
+    }
+    this.#ssfHostRef.addScriptingObject(so, params);
+  }
+  /**
+   * Dispatches an event to the child microapp.
+   * @param {DispatchEventParam<EventId, Params, Options>} params - Event parameters.
+   * @returns {Promise<any[]>} A promise that resolves with the combined results of dispatched events.
+   */
+  async dispatchEvent(params) {
+    if (this.#appBridge) {
+      const [appBridgeResult, ssfResult] = await Promise.all([
+        this.#appBridge.dispatchEvent(params),
+        this.#ssfHostRef.dispatchEvent(params)
+      ]);
+      if (Array.isArray(appBridgeResult) && Array.isArray(ssfResult)) {
+        return appBridgeResult.concat(ssfResult);
+      }
+      return Promise.resolve();
+    }
+    return this.#ssfHostRef.dispatchEvent(params);
+  }
+  /**
+   * removes scripting object from child microapp use
+   * @param objectId unique id of the scripting object
+   */
+  removeScriptingObject(objectId) {
+    if (this.#appBridge) {
+      this.#appBridge.removeScriptingObject(objectId);
+    }
+    this.#ssfHostRef.removeScriptingObject(objectId);
+  }
 }
 export {
   CMicroAppGuest