@elliemae/microfe-common 2.24.0 → 2.26.0-alpha.0

package/dist/esm/tests/loan/latest/manifest.json

@@ -0,0 +1,3 @@
+{
+  "index.js": "latest/index.js"
+}

package/dist/esm/tests/server.js

@@ -0,0 +1,9 @@
+import { setupServer } from "msw/node";
+import { serverHandlers } from "./serverHandlers";
+const initServer = () => {
+  const server = setupServer(...serverHandlers);
+  return server;
+};
+export {
+  initServer
+};

package/dist/esm/tests/serverHandlers.js

@@ -0,0 +1,51 @@
+import { rest } from "msw";
+import { readFile } from "fs/promises";
+import path from "node:path";
+import appConfig from "../app.config.json";
+import loanAppManifest from "./loan/latest/manifest.json";
+const sendJS = async (res, ctx, filePath) => {
+  const fileContent = await readFile(path.join(__dirname, filePath), "utf-8");
+  return res(
+    ctx.status(200),
+    ctx.set("Content-Type", "application/javascript"),
+    ctx.body(fileContent)
+  );
+};
+const serverHandlers = [
+  rest.get(
+    "https://www.google-analytics.com/analytics.js",
+    (req, res, ctx) => res(
+      ctx.status(200),
+      ctx.set("Content-Type", "application/javascript"),
+      ctx.body("")
+    )
+  ),
+  rest.get(
+    "/latest/app.config.json",
+    (req, res, ctx) => res(ctx.json(appConfig))
+  ),
+  // frame html
+  rest.get("/frame.html", async (req, res, ctx) => {
+    const fileContent = await readFile(
+      path.join(__dirname, "../frame.html"),
+      "utf-8"
+    );
+    return res(
+      ctx.status(200),
+      ctx.set("Content-Type", "text/html"),
+      ctx.body(fileContent)
+    );
+  }),
+  rest.get("/loan/latest/index.js", async (req, res, ctx) => {
+    const newRes = await sendJS(res, ctx, "./loan/latest/index.js");
+    return newRes;
+  }),
+  // loan microapp handler
+  rest.get(
+    "/loan/latest/manifest.json",
+    (req, res, ctx) => res(ctx.json(loanAppManifest))
+  )
+];
+export {
+  serverHandlers
+};

package/dist/esm/tests/task/latest/index.js

@@ -0,0 +1,57 @@
+(function() {
+  const appId = "taskapp";
+  const appName = "Task App";
+  const appElementId = `pui-app-container-${appId}`;
+  const pipelinePath = "/pipeline";
+  const pipelineLinkText = "Pipeline";
+  const getWindow = () => {
+    try {
+      window.parent.document;
+      return window.parent;
+    } catch (err) {
+      return window;
+    }
+  };
+  let host = null;
+  let parentHistory = null;
+  let logger = null;
+  const browserWindow = getWindow();
+  browserWindow.emui = browserWindow.emui || {};
+  browserWindow.emui[appId] = browserWindow.emui[appId] || {};
+  browserWindow.emui[appId].init = async (options) => {
+    host = options.host;
+    parentHistory = options.history;
+    logger = options.logger;
+  };
+  browserWindow.emui[appId].mount = async () => {
+    const appContainer = document.getElementById(appElementId);
+    if (appContainer) {
+      const mainElement = document.createElement("main");
+      appContainer.appendChild(mainElement);
+      const pageHeaderEle = document.createElement("h1");
+      pageHeaderEle.textContent = appName;
+      mainElement.appendChild(pageHeaderEle);
+      const contentEle = document.createElement("p");
+      contentEle.textContent = "Go to ";
+      mainElement.appendChild(contentEle);
+      const linkEle = document.createElement("a");
+      linkEle.href = "#";
+      linkEle.onclick = () => {
+        parentHistory?.push?.(pipelinePath);
+      };
+      linkEle.textContent = pipelineLinkText;
+      contentEle.appendChild(linkEle);
+    } else {
+      throw new Error(
+        `App container element with id ${appElementId} not found`
+      );
+    }
+  };
+  browserWindow.emui[appId].unmount = () => {
+    const appContainer = document.getElementById(appElementId);
+    if (appContainer) {
+      appContainer.removeChild(appContainer.getElementsByTagName("main")[0]);
+    }
+    return Promise.resolve();
+  };
+})();

package/dist/esm/tests/task/latest/manifest.json

@@ -0,0 +1,3 @@
+{
+  "index.js": "latest/index.js"
+}

package/dist/esm/utils.js

@@ -0,0 +1,13 @@
+import { CMicroAppHost } from "./host.js";
+const isHost = () => CMicroAppHost.isInitialized();
+const removeDoubleSlash = (url) => url.replace(/([^:]\/)\/+/g, "$1");
+const getAbsoluteUrl = (url) => {
+  const a = document.createElement("a");
+  a.href = url;
+  return a.href;
+};
+export {
+  getAbsoluteUrl,
+  isHost,
+  removeDoubleSlash
+};

package/dist/esm/window.js

@@ -0,0 +1,43 @@
+import { getDefaultTheme } from "@elliemae/pui-theme";
+const getWindow = () => {
+  try {
+    window.parent.document;
+    return window.parent;
+  } catch (err) {
+    return window;
+  }
+};
+const getViewportSize = () => ({
+  width: Math.max(
+    document.documentElement.clientWidth || 0,
+    window.innerWidth || 0
+  ),
+  height: Math.max(
+    document.documentElement.clientHeight || 0,
+    window.innerHeight || 0
+  )
+});
+const convertBreakpointToNumber = (breakpoint) => Number(breakpoint.replace("px", ""));
+const getCurrentBreakpoint = () => {
+  const { width } = getViewportSize();
+  const { breakpoints } = getDefaultTheme();
+  if (width <= convertBreakpointToNumber(breakpoints.small)) return "small";
+  if (width <= convertBreakpointToNumber(breakpoints.medium)) return "medium";
+  return "large";
+};
+const getAssetPath = () => window?.emui?._ASSET_PATH || "latest/";
+const isCrossDomain = () => {
+  try {
+    window.parent.document;
+    return false;
+  } catch (ex) {
+    return true;
+  }
+};
+export {
+  getAssetPath,
+  getCurrentBreakpoint,
+  getViewportSize,
+  getWindow,
+  isCrossDomain
+};

package/dist/types/lib/app.d.ts

@@ -0,0 +1,2 @@
+import { MicroAppConfig } from './typings/microapp.js';
+export declare const launchMicroApp: (appConfig: MicroAppConfig) => Promise<void>;

package/dist/types/lib/auditThrottler.d.ts

@@ -0,0 +1,29 @@
+import type { Logger, LogRecord } from '@elliemae/pui-diagnostics';
+export type AuditThrottlerOptions = {
+    logger: Logger;
+    /** When `true`, high-frequency operations are logged at `audit` level. @default true */
+    enabled?: boolean;
+    /** Throttle window (ms). Same operation key is audited at most once per window. @default 10000 */
+    throttleMs?: number;
+};
+/**
+ * Controls whether high-frequency operations are logged at `audit` level
+ * (sent to Splunk) or `debug` level (local only).
+ *
+ * When enabled, a per-key throttle window prevents the same operation from
+ * flooding Splunk. Operations outside the window or with throttling disabled
+ * (`throttleMs === 0`) go straight to `audit`.
+ */
+export declare class AuditThrottler {
+    #private;
+    static readonly DEFAULT_THROTTLE_MS = 10000;
+    constructor(options: AuditThrottlerOptions);
+    get enabled(): boolean;
+    /**
+     * Log a high-frequency operation. When audit is enabled and the throttle
+     * window allows it the payload is sent at `audit` level; otherwise `debug`.
+     * @param {string} key - dedup key for throttling (e.g. `invoke:loan.getField`)
+     * @param {LogRecord} payload - structured log payload
+     */
+    log(key: string, payload: LogRecord): void;
+}

package/dist/types/lib/config.d.ts

@@ -0,0 +1,25 @@
+interface ServiceEndpoints {
+    api?: string;
+    idp?: string;
+    logger?: string;
+}
+interface Env {
+    serviceEndpoints?: ServiceEndpoints;
+}
+export interface AppConfig {
+    appId: string;
+    brand?: string;
+    activeEnv: string;
+    sessionTimeoutWarnInterval?: string;
+    sessionTimeoutInterval?: string;
+    serviceEndpoints: ServiceEndpoints;
+    env: {
+        [key: string]: Env;
+    };
+}
+export declare const setAppConfig: (config: AppConfig) => void;
+export declare const getAppConfigValue: <Type>(key?: string, defaultValue?: unknown) => Type;
+export declare const setAppConfigValue: <Type>(key: string, value: Type) => AppConfig;
+export declare const hasItem: (key?: string) => boolean;
+export declare const loadAppConfig: (assetPath?: string) => Promise<void>;
+export {};

package/dist/types/lib/frame.d.ts

@@ -0,0 +1,10 @@
+type FrameOptions = {
+    id: string;
+    sandbox?: string;
+    src?: string;
+    style?: string;
+};
+export declare const FRAME_CONTAINER_ID_PREFIX = "pui-iframe-container-";
+export declare const FRAME_APP_CONTAINER_ID_PREFIX = "pui-app-container-";
+export declare const createFrame: (options: FrameOptions) => Promise<HTMLIFrameElement>;
+export {};

package/dist/types/lib/history.d.ts

@@ -0,0 +1,2 @@
+export declare const browserHistory: import("history").BrowserHistory;
+export declare const memoryHistory: import("history").MemoryHistory;

package/dist/types/lib/host.d.ts

@@ -0,0 +1,42 @@
+import { History } from 'history';
+import { DefaultTheme } from 'styled-components';
+import { Logger } from '@elliemae/pui-diagnostics';
+import { IMicroAppHost, SubscriptionListener, AppWindowSize } from './typings/host.js';
+type HostOptions = {
+    systemVersion: string;
+    history: History;
+    theme: DefaultTheme;
+};
+export type OnInitCallback = (options: HostOptions) => void;
+type ConstructorParams = {
+    logger?: Logger;
+    history?: History;
+    version?: string;
+    theme?: DefaultTheme;
+    scriptingObjects?: Record<string, any>;
+    onRenewSessionTimer?: () => void;
+    onInit?: OnInitCallback;
+};
+export declare class CMicroAppHost implements IMicroAppHost {
+    private static instance;
+    private readonly logger;
+    private readonly appId;
+    private props;
+    activeGuests: Record<string, unknown>;
+    private readonly onInit?;
+    private readonly onRenewSessionTimer?;
+    scriptingObjects: Record<string, any>;
+    private constructor();
+    static getInstance(params?: ConstructorParams): CMicroAppHost;
+    static isInitialized(): boolean;
+    getProps(this: CMicroAppHost): HostOptions;
+    getLogger(this: CMicroAppHost): Logger;
+    getObject<T>(name: string): Promise<T>;
+    getGuests(this: CMicroAppHost): Record<string, unknown>;
+    getGuest<T>(id: string): T | null;
+    setAppWindowSize(appSize: AppWindowSize): void;
+    publish<Type>(eventId: string | symbol, data?: Type): boolean;
+    subscribe<T>(eventId: string | symbol, listener: SubscriptionListener<T>): string;
+    unsubscribe(token: string): void;
+}
+export {};

package/dist/types/lib/index.d.ts

@@ -12,3 +12,5 @@ export type { ISSFGuest, ConnectParam } from './guest.js';
 export { ScriptingObjectManager, SecurityContext, } from './scriptingObjectManager.js';
 export type { AddScriptingObjectParams, CallContext, CallerInfo, GetObjectParams, GuestContext, } from './scriptingObjectManager.js';
 export { ScriptingObjectProxy, isScriptingObjectProxy } from './proxy.js';
+export { AuditThrottler } from './auditThrottler.js';
+export type { AuditThrottlerOptions } from './auditThrottler.js';

package/dist/types/lib/loader.d.ts

@@ -0,0 +1,9 @@
+import { MicroAppConfig } from './typings/microapp.js';
+export declare const mountApp: ({ id, name }: MicroAppConfig) => Promise<void>;
+export declare const unmountApp: ({ id, name }: MicroAppConfig) => Promise<void | null>;
+export declare const loadApp: (appConfig: MicroAppConfig) => Promise<void>;
+export declare const unloadApp: ({ id, hostUrl, documentEle, }: {
+    id: string;
+    hostUrl?: string;
+    documentEle: Document;
+}) => void;

package/dist/types/lib/logRecords.d.ts

@@ -0,0 +1,14 @@
+import type { LogRecord } from '@elliemae/pui-diagnostics';
+export declare const logRecords: {
+    APP_CONFIG_LOAD_FAILED: {
+        code: string;
+        message: string;
+    };
+    ASSET_NOT_FOUND_IN_MANIFEST: (assetName: string) => LogRecord;
+    APP_INIT_FAILED: (appId: string, errMsg: string) => LogRecord;
+    APP_LOADING: (appId: string) => LogRecord;
+    APP_LOADING_COMPLETE: (appId: string) => LogRecord;
+    APP_UNLOADING: (appId: string) => LogRecord;
+    APP_UNLOADING_COMPLETE: (appId: string) => LogRecord;
+    SSF_HOST_OBJECT_NOT_FOUND: (name: string) => LogRecord;
+};

package/dist/types/lib/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: import("@elliemae/pui-diagnostics").Logger;

package/dist/types/lib/manifestLoader.d.ts

@@ -0,0 +1,7 @@
+type Manifest = Record<string, string>;
+export declare const getAppManifest: ({ hostUrl, manifestPath, }: {
+    hostUrl?: string;
+    manifestPath?: string;
+}) => Promise<Manifest>;
+export declare const getFullFileNameofAssetsFromManifest: (manifest: Record<string, string>, assetNames?: Array<string>) => Array<string>;
+export {};

package/dist/types/lib/scriptLoader.d.ts

@@ -0,0 +1,6 @@
+import { MicroAppConfig } from './typings/microapp.js';
+export declare const APP_SCRIPT_ID_PREFIX = "emui-script-";
+export declare const addScriptToDOM: ({ name, hostUrl, documentEle }: MicroAppConfig, fileName: string, index: number) => Promise<string>;
+export declare const removeScriptFromDOM: (elementId?: string, documentEle?: Document) => Promise<void>;
+export declare const removeDynamicImportedScripts: (hostUrl: string, documentEle: HTMLDocument) => void;
+export declare const removePrefetchLinks: (hostUrl: string, documentEle: HTMLDocument) => void;

package/dist/types/lib/styleLoader.d.ts

@@ -0,0 +1,5 @@
+import { MicroAppConfig } from './typings/microapp.js';
+export declare const APP_STYLE_ID_PREFIX = "emui-style-";
+export declare const addStylesToDOM: ({ name, hostUrl, documentEle }: MicroAppConfig, fileName: string, index: number) => Promise<string>;
+export declare const removeStyleFromDOM: (elementId?: string, documentEle?: Document) => Promise<void>;
+export declare const removeDynamicImportedStyles: (hostUrl: string, documentEle: Document) => void;

package/dist/types/lib/tests/auditThrottler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/tests/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/tests/server.d.ts

@@ -0,0 +1 @@
+export declare const initServer: () => import("msw/lib/glossary-2792c6da").K;

package/dist/types/lib/tests/serverHandlers.d.ts

@@ -0,0 +1 @@
+export declare const serverHandlers: import("msw").RestHandler<import("msw").MockedRequest<import("msw").DefaultBodyType>>[];

package/dist/types/lib/typings/guest.d.ts

@@ -0,0 +1,67 @@
+import { History, To } from 'history';
+import { DefaultTheme } from 'styled-components';
+import { Logger } from '@elliemae/pui-diagnostics';
+import { BreakPoint } from '@elliemae/pui-theme';
+import { IMicroAppHost } from './host.js';
+import { JSONValue } from './index.js';
+type ViewportSize = {
+    width: number;
+    height: number;
+};
+/**
+ * options to initialize the guest app
+ */
+export type InitOptions = {
+    host?: IMicroAppHost;
+    hostName?: string;
+    hostUrl?: string;
+    manifestPath?: string;
+    homeRoute?: string;
+    prevState?: JSONValue;
+    history?: History;
+    theme?: DefaultTheme;
+    hostBreakpoint?: BreakPoint;
+    hostViewportSize?: ViewportSize;
+    logger?: Logger;
+};
+/**
+ * options to mount the guest app
+ */
+export type MountOptions = {
+    containerId: string;
+    hostBreakpoint?: BreakPoint;
+    hostViewportSize?: ViewportSize;
+};
+/**
+ * Interface to connect and communicate with microfrontend guest application
+ */
+export interface IMicroAppGuest {
+    /**
+     * initialize the guest application
+     * @param options guest initailization options
+     */
+    init(options: InitOptions): Promise<void>;
+    /**
+     * mount application to the window DOM
+     * @param options application dom mount options
+     */
+    mount(options: MountOptions): Promise<void>;
+    /**
+     * unmount application from the window DOM
+     * @param options DOM unmount options
+     * @returns application state serialized as JSON
+     */
+    unmount(options: MountOptions): Promise<JSONValue>;
+    /**
+     * Get scripting object exposed from guest application
+     * @returns scripting object
+     */
+    getObject<T>(): T | null;
+    /**
+     * navigate to a route
+     * @param url url to navigate the guest application to
+     * @param state state to pass to the guest application
+     */
+    navigate(url: To, state?: any): void;
+}
+export {};

package/dist/types/lib/typings/host.d.ts

@@ -0,0 +1,60 @@
+import { ScriptingObjectTypes } from '@elliemae/pui-scripting-object';
+/**
+ * event listner callback function
+ */
+export type SubscriptionListener<T> = (message: string, data?: T) => void;
+export type AppWindowSize = {
+    appId: string;
+    size: {
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Interface to connect and communicate with parent host
+ */
+export interface IMicroAppHost {
+    /**
+     * Get reference to the scripting object (or proxy) by name
+     * @param name unique name of the scripting object
+     * @returns scripting object (or its proxy) reference
+     */
+    getObject<T extends keyof ScriptingObjectTypes>(name: T): Promise<ScriptingObjectTypes[T]>;
+    /**
+     * Get lists of all guests attached to the host
+     * @returns list of guests
+     */
+    getGuests(): Record<string, unknown>;
+    /**
+     * Get reference to the guest by name
+     * @param id unique id of the guest
+     * @returns guest reference
+     */
+    getGuest<T>(id: string): T | null;
+    /**
+     * set the size of the guest application iframe window
+     * @param appSize window size of the application
+     */
+    setAppWindowSize(appSize: AppWindowSize): void;
+    /**
+     * emit event to all subscribers
+     * @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
+     */
+    publish<Type>(eventId: string | symbol, data?: Type): boolean;
+    /**
+     * subscribe to an scripting object event
+     * @param eventId unique id of the event. The format is <scripting object name>.<event name>
+     * @param listener callback function to be called when the event is fired
+     * @returns token to be used to unsubscribe
+     */
+    subscribe<T>(eventId: string | symbol, listener: SubscriptionListener<T>): string;
+    /**
+     *
+     * @param token unique token returned by subscribe
+     * @param objectId scripting object name
+     * @param eventName event name
+     */
+    unsubscribe(token: string, eventId?: string): void;
+}

package/dist/types/lib/typings/index.d.ts

@@ -0,0 +1,3 @@
+export type JSONValue = Partial<{
+    [key: string]: JSONValue;
+}> | JSONValue[] | string | number | boolean | null;

package/dist/types/lib/typings/microapp.d.ts

@@ -0,0 +1,17 @@
+import { InitOptions } from './guest.js';
+type EnvConfig = {
+    files: Array<string>;
+};
+export type MicroAppConfig = {
+    id: string;
+    name: string;
+    mode?: string;
+    hostUrl?: string;
+    manifestPath?: string;
+    homeRoute: string;
+    files?: Array<string>;
+    development?: EnvConfig;
+    production?: EnvConfig;
+    documentEle: Document;
+} & InitOptions;
+export {};

package/dist/types/lib/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const isHost: () => boolean;
+export declare const removeDoubleSlash: (url: string) => string;
+export declare const getAbsoluteUrl: (url: string) => string;

package/dist/types/lib/window.d.ts

@@ -0,0 +1,27 @@
+import { BreakPoint } from '@elliemae/pui-theme';
+import { Logger } from '@elliemae/pui-diagnostics';
+import { IMicroAppGuest } from './typings/guest.js';
+import { IMicroAppHost } from './typings/host.js';
+export type EMUI = {
+    [key: string]: IMicroAppGuest;
+} & {
+    _BASE_PATH: string;
+    _ASSET_PATH: string;
+    version: string;
+    MicroAppHost?: IMicroAppHost;
+    logger?: Logger;
+    appId?: string;
+};
+declare global {
+    interface Window {
+        emui: EMUI;
+    }
+}
+export declare const getWindow: () => Window;
+export declare const getViewportSize: () => {
+    width: number;
+    height: number;
+};
+export declare const getCurrentBreakpoint: () => BreakPoint;
+export declare const getAssetPath: () => string;
+export declare const isCrossDomain: () => boolean;