@elliemae/microfe-common 2.0.0-next.30

package/dist/types/event.d.ts

@@ -0,0 +1,82 @@
+import type { IScriptingObject, IEvent, Events } from '@elliemae/pui-scripting-object';
+import { EventListeners } from './common.js';
+/**
+ * Interface for scripting object proxy events
+ */
+export interface IScriptingObjectProxyEvent<EventsList extends EventListeners = Events> {
+    /**
+     * unique id of the event
+     */
+    readonly id: Extract<keyof EventsList, string>;
+    /**
+     * name of the event
+     */
+    readonly name: string;
+    /**
+     * scripting object id that owns this event
+     */
+    readonly objectId: string;
+}
+/**
+ * parameters for creating an event
+ */
+export type EventParam = {
+    /**
+     * name of the event
+     */
+    name: string;
+    /**
+     * flag indicating this event requires feedback from all of the listeners
+     */
+    requiresFeedback: boolean;
+    /**
+     * scripting object that owns this event
+     */
+    so: IScriptingObject;
+};
+/**
+ * Base class for all events
+ */
+export declare class Event<EventsList extends EventListeners = Events> implements IEvent {
+    /**
+     * scripting object that owns this event
+     */
+    readonly scriptingObject: IScriptingObject;
+    /**
+     * name of the event
+     */
+    readonly name: string;
+    /**
+     * scripting object id that owns this event
+     */
+    readonly objectId: string;
+    /**
+     * flag indicating this event requires feedback from all of the listeners
+     */
+    readonly requiresFeedback: boolean;
+    /**
+     * unique id of the event
+     */
+    readonly id: Extract<keyof EventsList, string>;
+    /**
+     * Create an event object
+     *
+     * @param {EventParam} param - parameters for creating an event
+     */
+    constructor(param: EventParam);
+}
+/**
+ * Check given object is an event
+ *
+ * @param value object to check
+ * @returns true if given object is an event
+ */
+export declare const isEvent: (value: any) => value is Event<Events>;
+/**
+ * Get normalized event ID for an object and event
+ *
+ * @param objectId scripting object id
+ * @param eventName  event name
+ * @returns normalized event ID
+ */
+export declare const getEventId: (objectId: string, eventName: string) => string;

package/dist/types/eventManager.d.ts

@@ -0,0 +1,125 @@
+import { IScriptingObject, Listener, Events } from '@elliemae/pui-scripting-object';
+import { EventListeners } from './common.js';
+/**
+ * details of an event listener
+ */
+type EventListenerDetails = {
+    /**
+     * event listener
+     */
+    callback: Listener<any, any, any, any>;
+    /**
+     * subscription id
+     */
+    subscriptionId: string;
+};
+/**
+ * parameters for subscribing to an event
+ */
+export type SubscribeParam<EventId, EventListener> = {
+    /**
+     * unique id of the event
+     */
+    eventId: EventId;
+    /**
+     * event listener
+     */
+    listener: EventListener;
+};
+/**
+ * parameters for unsubscribing from an event
+ */
+export type UnsubscribeParam<EventId> = {
+    /**
+     * unique id of the event
+     */
+    eventId: EventId;
+    /**
+     * subscription id
+     */
+    subscriptionId?: string;
+};
+/**
+ * parameters for emitting an event
+ */
+export type EmitEventParam = {
+    /**
+     * name of the event
+     */
+    eventName: string;
+    /**
+     * scripting object that owns this event
+     */
+    scriptingObject: IScriptingObject;
+    /**
+     * event parameters
+     */
+    eventParams: Record<string, unknown>;
+    /**
+     * event listeners
+     */
+    listeners: EventListenerDetails[];
+};
+/**
+ * parameters for dispatching an event
+ */
+export type DispatchEventParam<EventId, Params> = {
+    /**
+     * event details
+     */
+    event: {
+        /**
+         * unique id of the event
+         */
+        id: EventId;
+        /**
+         * name of the event
+         */
+        name: string;
+        /**
+         * flag indicating this event requires feedback from all of the listeners
+         */
+        requiresFeedback: boolean;
+        /**
+         * scripting object that owns this event
+         */
+        scriptingObject: IScriptingObject;
+    };
+    /**
+     * event parameters
+     */
+    eventParams: Params;
+    /**
+     * time to wait for feedback from listeners. milliseconds
+     */
+    feedbackWaitTime?: number;
+};
+/**
+ * Event Manager
+ */
+export declare class EventManager<AppEvents extends EventListeners = Events> {
+    #private;
+    /**
+     * dispatch an event
+     *
+     * @param {DispatchEventParam<EventId, Params>} param - parameters for dispatching an event
+     */
+    dispatchEvent: <EventId extends Extract<keyof AppEvents, string>, Params extends Parameters<AppEvents[EventId]>[0]["eventParams"]>(param: DispatchEventParam<EventId, Params>) => Promise<void | any[]>;
+    /**
+     * Subscribe to an event
+     *
+     * @param {SubscribeParam<EventId, AppEvents[EventId]>} param - parameters for subscribing to an event
+     */
+    subscribe: <EventId extends Extract<keyof AppEvents, string>>(param: SubscribeParam<EventId, AppEvents[EventId]>) => string;
+    /**
+     * Unsubscribe from an event
+     *
+     * @param {UnsubscribeParam<EventId>} param - parameters for unsubscribing from an event
+     */
+    unsubscribe: <EventId extends Extract<keyof AppEvents, string>>(param: UnsubscribeParam<EventId>) => void;
+    /**
+     * Unsubscribe from all events
+     */
+    unsubscribeAll: () => void;
+}
+export {};

package/dist/types/guest.d.ts

@@ -0,0 +1,90 @@
+import { LogLevels } from '@elliemae/pui-diagnostics';
+import type { IScriptingObjectProxy } from '@elliemae/pui-scripting-object';
+import { EventListeners } from './common.js';
+/**
+ * parameters for connecting to the host
+ */
+export type ConnectParam = {
+    /**
+     * reference to the guest window
+     */
+    window?: Window;
+} & Record<string, any>;
+/**
+ * parameters for subscribing to an event
+ */
+export type SubscribeParam<EventId, EventListener> = {
+    /**
+     * unique id of the event
+     */
+    eventId: EventId;
+    /**
+     * event listener
+     */
+    callback: EventListener;
+};
+/**
+ * parameters for unsubscribing from an event
+ */
+export type UnsubscribeParam<EventId> = {
+    /**
+     * unique id of the event
+     */
+    eventId: EventId;
+    /**
+     * subscription token
+     */
+    token: string;
+};
+/**
+ * Interface for SSF guest
+ */
+export interface ISSFGuest<AppEvents extends EventListeners> {
+    /**
+     * Initialize guest using script
+     *
+     * @param scriptUri uri of the script
+     * @param containerElement dom element to inject the script at
+     */
+    addScript: (scriptUri: string, containerElement: HTMLElement) => Promise<void>;
+    /**
+     * Close the connection to the host
+     */
+    close: () => void;
+    /**
+     * Connect to the host
+     *
+     * @param {ConnectParam} param - reference to the guest window or parameters
+     */
+    connect: (param?: ConnectParam) => Promise<void>;
+    /**
+     * Get scripting object proxy by id
+     *
+     * @param objectId unique id of the scripting object
+     * @returns scripting object proxy
+     */
+    getObject: (objectId: string) => Promise<IScriptingObjectProxy>;
+    /**
+     * remove the guest from the host
+     */
+    removeScript: () => void;
+    /**
+     * set the log level
+     *
+     * @param {LogLevels} logLevel - log level
+     */
+    setLogLevel: (logLevel: LogLevels) => void;
+    /**
+     * subscribe to an scripting object event
+     *
+     * @param {SubscribeParam<EventId, AppEvents[EventId]>} param - parameters for subscribing to an event
+     * @returns subscription token
+     */
+    subscribe: <EventId extends Extract<keyof AppEvents, string>>(param: SubscribeParam<EventId, AppEvents[EventId]>) => string;
+    /**
+     * unsubscribe from an scripting object event
+     *
+     * @param {UnsubscribeParam<EventId>} param - parameters for unsubscribing from an event
+     */
+    unsubscribe: <EventId extends Extract<keyof AppEvents, string>>(param: UnsubscribeParam<EventId>) => void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export { Remoting, sendMessage } from './remoting.js';
+export type { ListenerCallback, ListenerCallbackParams, ListenParam, InvokeParam, RaiseExceptionParam, RespondParam, SendParam, AddSenderParam, } from './remoting.js';
+export type { RemotingEventMessage } from './remotingEventMessage.js';
+export { EventManager } from './eventManager.js';
+export type { EmitEventParam, SubscribeParam, UnsubscribeParam, DispatchEventParam, } from './eventManager.js';
+export { getEventId } from './event.js';
+export type { IScriptingObjectProxyEvent, EventParam } from './event.js';
+export { Event } from './event.js';
+export { ScriptingObject } from './scriptingObject.js';
+export { MessageType } from './messageType.js';
+export type { EventListeners } from './common.js';
+export type { ISSFGuest, ConnectParam, SubscribeParam as GuestSubscribeParam, UnsubscribeParam as GuestUnsubscribeParam, } from './guest.js';

package/dist/types/messageType.d.ts

@@ -0,0 +1,13 @@
+export declare enum MessageType {
+    GuestReady = "guest:ready",
+    GuestClose = "guest:close",
+    GuestReadyComplete = "guest:readyComplete",
+    GuestResize = "guest:resize",
+    GuestFocus = "guest:focus",
+    HandShake = "handshake",
+    HandShakeAck = "handshake:ack",
+    ObjectInvoke = "object:invoke",
+    ObjectGet = "object:get",
+    ObjectEvent = "object:event",
+    HostConfig = "host:config"
+}

package/dist/types/remoting.d.ts

@@ -0,0 +1,237 @@
+import { Logger } from '@elliemae/pui-diagnostics';
+/**
+ * Represents a callback parameters when a message is received
+ */
+export type ListenerCallbackParams<T> = {
+    /**
+     * The window that sent the message
+     */
+    sourceWin: Window;
+    /**
+     * source origin
+     */
+    sourceOrigin: string;
+    /**
+     * The unique ID of the message
+     */
+    requestId: string;
+    /**
+     * The message type
+     */
+    type: string;
+    /**
+     * The message body
+     */
+    body: T;
+};
+/**
+ * Represents a callback to invoke when a message is received
+ */
+export type ListenerCallback<T> = ({ sourceWin, requestId, type, body, }: ListenerCallbackParams<T>) => void;
+/**
+ * Represents a message received from another window
+ */
+export type RemotingMessage = {
+    /**
+     * The unique ID of the message
+     */
+    requestId: string | null;
+    /**
+     * The source of the message
+     */
+    source: string;
+    /**
+     * The message type
+     */
+    type: string;
+    /**
+     * The message body
+     */
+    body: any;
+};
+/**
+ * Represents a message to be sent to another window
+ */
+export type InvokeParam = {
+    /**
+     * The window to send the message to
+     */
+    targetWin: Window;
+    /**
+     * The origin of the target window
+     */
+    targetOrigin: string;
+    /**
+     * The message type to send
+     */
+    messageType: string;
+    /**
+     * The message body to send
+     */
+    messageBody: unknown;
+    /**
+     * The timeout in milliseconds to wait for a response
+     */
+    responseTimeoutMs?: number;
+};
+/**
+ * Represents a listener registration
+ */
+export type ListenParam<T> = {
+    /**
+     * The message type to listen for
+     */
+    messageType: string;
+    /**
+     * The callback to invoke when the message is received
+     */
+    callback: ListenerCallback<T>;
+};
+/**
+ * Parameters for sending a message to another window
+ */
+export type SendParam = {
+    /**
+     * The window to send the message to
+     */
+    targetWin: Window;
+    /**
+     * The origin of the target window
+     */
+    targetOrigin: string;
+    /**
+     * The message type to send
+     */
+    messageType: string;
+    /**
+     * The message body to send
+     */
+    messageBody: unknown;
+};
+/**
+ * Parameters for responding to a message
+ */
+export type RespondParam = {
+    /**
+     * The window to send the response message to
+     */
+    targetWin: Window;
+    /**
+     * The origin of the target window
+     */
+    targetOrigin: string;
+    /**
+     * The unique ID of the message to respond to
+     */
+    requestId: string;
+    /**
+     * The response message body
+     */
+    response: unknown;
+};
+/**
+ * Parameters for raising an exception
+ */
+export type RaiseExceptionParam = {
+    /**
+     * The window to send the exception message to
+     */
+    targetWin: Window;
+    /**
+     * The origin of the target window
+     */
+    targetOrigin: string;
+    /**
+     * The unique ID of the message to respond to
+     */
+    requestId: string;
+    /**
+     * The exception / error message
+     */
+    ex: string;
+};
+/**
+ * Sends a message to another window
+ *
+ * @param {SendParam} param - parameters for sending the message
+ */
+export declare const sendMessage: (param: SendParam) => void;
+/**
+ * Description of a window that is allowed to send messages to this window
+ */
+export type AddSenderParam = {
+    /**
+     * origin of the window
+     */
+    origin: string;
+    /**
+     * window object
+     */
+    window: Window;
+};
+/**
+ * Provides core messaging capabilities for cross-frame interactions in a sandboxed environment.
+ */
+export declare class Remoting {
+    #private;
+    /**
+     * Create a new instance of the Remoting class
+     *
+     * @param logger pui-diagnostic logger
+     * @param correlationId unique id for the current session
+     */
+    constructor(logger: Logger, correlationId: string);
+    /**
+     * Adds window and its origin list of allowed senders
+     *
+     * @param {AddSenderParam} param - The sender to add
+     */
+    addSender: (param: AddSenderParam) => void;
+    /**
+     * Initializes the remoting service for a window
+     *
+     * @param win The window to initialize remoting for
+     */
+    initialize: (win: Window) => void;
+    /**
+     * Closes the remoting service for a window
+     */
+    close: () => void;
+    /**
+     * Sends an invocation which generates a Promise to be used to get a response
+     *
+     * @param {InvokeParam} param The parameters for the invocation
+     * @returns promisifyed response
+     */
+    invoke: <T>(param: InvokeParam) => Promise<T>;
+    /**
+     * Setup callback for a specific message type
+     *
+     * @param {ListenParam<T>} param The parameters for the listener
+     */
+    listen: <T>(param: ListenParam<T>) => void;
+    /**
+     * Send a message without any form of response. Fire and forget
+     *
+     * @param {SendParam} param The parameters for the send
+     */
+    send: (param: SendParam) => void;
+    /**
+     * Removes a window from the list of allowed senders
+     *
+     * @param {AddSenderParam} param - The sender to remove
+     */
+    removeSender: (param: AddSenderParam) => void;
+    /**
+     * Send a response message to a window
+     *
+     * @param {RespondParam} param The parameters for the response
+     */
+    respond: (param: RespondParam) => void;
+    /**
+     * Send an exception message to a window
+     *
+     * @param {RaiseExceptionParam} param The parameters for the exception
+     */
+    raiseException: (param: RaiseExceptionParam) => void;
+}

package/dist/types/remotingEventMessage.d.ts

@@ -0,0 +1,26 @@
+import { RemotingScriptingObject } from '@elliemae/pui-scripting-object';
+/**
+ * Event message for remoting
+ */
+export type RemotingEventMessage = {
+    /**
+     * Marshalled scripting object
+     */
+    readonly object: RemotingScriptingObject;
+    /**
+     * Event name
+     */
+    readonly eventName: string;
+    /**
+     * Event handler
+     */
+    readonly eventHandler?: string;
+    /**
+     * Event parameters
+     */
+    readonly eventParams?: Array<any>;
+    /**
+     * Event options
+     */
+    readonly eventOptions?: Record<string, any>;
+};

package/dist/types/scriptingObject.d.ts

@@ -0,0 +1,37 @@
+import type { RemotingScriptingObject, IScriptingObject } from '@elliemae/pui-scripting-object';
+export type GenericFunction = (...args: unknown[]) => unknown;
+/**
+ * Base class for all scripting objects
+ */
+export declare class ScriptingObject implements IScriptingObject {
+    #private;
+    /**
+     * Creates an instance of ScriptingObject.
+     *
+     * @param objectId unique id of the scripting object
+     * @param objectType type of the scripting object
+     */
+    constructor(objectId: string, objectType?: string);
+    /**
+     * get unique id of the scripting object
+     */
+    get id(): string;
+    /**
+     * get type of the scripting object
+     */
+    get objectType(): string;
+    /**
+     * transform the scripting object to a format suitable for transmitting over window.postMessage
+     *
+     * @returns marshalled scripting object
+     */
+    _toJSON: () => RemotingScriptingObject;
+    /**
+     * dispose the scripting object
+     */
+    _dispose: () => void;
+    /**
+     * dispose the scripting object
+     */
+    dispose: () => void;
+}

package/dist/types/tests/eventManager.test.d.ts

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

package/dist/types/tests/scriptingObjects/appraisalServiceModule.d.ts

@@ -0,0 +1,33 @@
+import { IModule, Listener, Events } from '@elliemae/pui-scripting-object';
+import { ScriptingObject, Event } from '../../index.js';
+export type AppraisalServiceEvents = {
+    'appraisalservice.onprecommit': Listener<AppraisalService, {
+        loanId: string;
+    }, Record<string, unknown>, boolean>;
+    'appraisalservice.onsaved': Listener<AppraisalService, {
+        loanId: string;
+    }, Record<string, unknown>, void>;
+};
+export declare class AppraisalService extends ScriptingObject implements IModule {
+    #private;
+    Unloading: Event<Events>;
+    onPreCommit: Event<AppraisalServiceEvents>;
+    onSaved: Event<AppraisalServiceEvents>;
+    constructor({ loanId, creditScore, }: {
+        loanId: string;
+        creditScore: number;
+    });
+    getCapabilities: () => Promise<{
+        isAdmin: boolean;
+        los: string;
+    }>;
+    getParameters: () => Promise<{
+        loanId: string;
+        creditScore: number;
+    }>;
+    setCreditScore: (creditScore: number) => Promise<void>;
+    saveLoan: () => Promise<void>;
+    commit: () => Promise<unknown>;
+    delete: () => never;
+    unload: () => Promise<void>;
+}

package/dist/types/tests/scriptingObjects/constant.d.ts

@@ -0,0 +1,2 @@
+export declare const OBJECT_NAME = "AppraisalService";
+export declare const UNLOADING_EVENT_NAME = "Unloading";

package/dist/types/tests/scriptingObjects/global.d.ts

@@ -0,0 +1,10 @@
+import { Events, IGlobal } from '@elliemae/pui-scripting-object';
+import { Event } from '../../event.js';
+import { ScriptingObject } from '../../index.js';
+export declare class Global extends ScriptingObject implements IGlobal {
+    #private;
+    constructor();
+    readonly Change: Event<Events>;
+    set: (key: string, value: any) => Promise<void>;
+    get: (key: string) => Promise<unknown>;
+}