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

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/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/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/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;