@elliemae/microfe-common 2.0.0-next.40 → 2.0.0-next.41

package/dist/cjs/index.js

@@ -22,6 +22,7 @@ __export(lib_exports, {
   MessageType: () => import_messageType.MessageType,
   Remoting: () => import_remoting.Remoting,
   ScriptingObject: () => import_scriptingObject.ScriptingObject,
+  ScriptingObjectManager: () => import_scriptingObjectManager.ScriptingObjectManager,
   getEventId: () => import_event.getEventId,
   sendMessage: () => import_remoting.sendMessage
 });
@@ -31,3 +32,4 @@ var import_event = require("./event.js");
 var import_event2 = require("./event.js");
 var import_scriptingObject = require("./scriptingObject.js");
 var import_messageType = require("./messageType.js");
+var import_scriptingObjectManager = require("./scriptingObjectManager.js");

package/dist/cjs/scriptingObjectManager.js

@@ -0,0 +1,239 @@
+"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 scriptingObjectManager_exports = {};
+__export(scriptingObjectManager_exports, {
+  ScriptingObjectManager: () => ScriptingObjectManager,
+  SecurityContext: () => SecurityContext
+});
+module.exports = __toCommonJS(scriptingObjectManager_exports);
+var _scriptingObjects, _guestScriptingObjects, _addGuestScriptingObject, _disposeSO, _getGuestScriptingObject, _removeGuestScriptingObject, _attachCallContext;
+var SecurityContext = /* @__PURE__ */ ((SecurityContext2) => {
+  SecurityContext2["USER"] = "USER";
+  SecurityContext2["PARTNER"] = "PARTNER";
+  return SecurityContext2;
+})(SecurityContext || {});
+class ScriptingObjectManager {
+  constructor() {
+    /**
+     * collection of registered scripting objects
+     */
+    __privateAdd(this, _scriptingObjects, /* @__PURE__ */ new Map());
+    /**
+     * collection of proxied scripting objects for each guest
+     */
+    __privateAdd(this, _guestScriptingObjects, /* @__PURE__ */ new Map());
+    __privateAdd(this, _addGuestScriptingObject, (params) => {
+      const { so, guestId } = params;
+      const objectId = so.id.toLowerCase();
+      const guestSOs = __privateGet(this, _guestScriptingObjects).get(guestId);
+      if (!guestSOs) {
+        __privateGet(this, _guestScriptingObjects).set(guestId, /* @__PURE__ */ new Map([[objectId, params]]));
+      } else {
+        if (guestSOs.has(objectId))
+          throw new Error(
+            `Scripting Object ${so.id} already exists for guest ${guestId}`
+          );
+        guestSOs.set(objectId, params);
+      }
+    });
+    __privateAdd(this, _disposeSO, ({ so }) => {
+      if (so._dispose && typeof so._dispose === "function") {
+        so._dispose();
+      }
+    });
+    __privateAdd(this, _getGuestScriptingObject, ({
+      objectId,
+      guestId
+    }) => {
+      const moduleSOs = __privateGet(this, _guestScriptingObjects).get(guestId);
+      if (moduleSOs) {
+        return moduleSOs.get(objectId) ?? null;
+      }
+      return null;
+    });
+    __privateAdd(this, _removeGuestScriptingObject, ({
+      objectId,
+      guestId
+    } = {}) => {
+      if (guestId) {
+        if (!objectId) {
+          const sosInfo = __privateGet(this, _guestScriptingObjects).get(guestId);
+          if (sosInfo) {
+            sosInfo.forEach(__privateGet(this, _disposeSO));
+          }
+          __privateGet(this, _guestScriptingObjects).delete(guestId);
+          return;
+        }
+        const moduleSOs = __privateGet(this, _guestScriptingObjects).get(guestId);
+        if (moduleSOs) {
+          const soInfo = moduleSOs.get(objectId);
+          if (soInfo)
+            __privateGet(this, _disposeSO).call(this, soInfo);
+          moduleSOs.delete(objectId);
+        }
+      } else if (objectId) {
+        __privateGet(this, _guestScriptingObjects).forEach((moduleSOs) => {
+          const soInfo = moduleSOs.get(objectId);
+          if (soInfo)
+            __privateGet(this, _disposeSO).call(this, soInfo);
+          moduleSOs.delete(objectId);
+        });
+      }
+    });
+    /**
+     * attach guest context to the scripting object methods
+     *
+     * @param root0
+     * @param root0.so
+     * @param root0.guest
+     * @returns proxies scripting object that has call context set to the guest
+     */
+    __privateAdd(this, _attachCallContext, ({
+      so,
+      guest
+    }) => new Proxy(so, {
+      get(target, prop, receiver) {
+        const value = target[prop];
+        if (value instanceof Function && prop !== "constructor") {
+          return function(...args) {
+            const proxyRef = this;
+            Object.defineProperty(value, "callContext", {
+              value: guest,
+              enumerable: false,
+              writable: true
+            });
+            return value.apply(proxyRef === receiver ? target : proxyRef, args);
+          };
+        }
+        return value;
+      }
+    }));
+    /**
+     * registers scripting object to the host
+     *
+     * @param so scripting object to register
+     * @param {AddScriptingObjectParams<ValueOf<AppObjects>>}
+     * @param params
+     */
+    __publicField(this, "addScriptingObject", (so, params) => {
+      const { guestId } = params || {};
+      if (!so?.id || !so?._toJSON) {
+        throw new Error("Object is not derived from ScriptingObject");
+      }
+      const objectId = so.id.toLowerCase();
+      if (objectId === "module" && !guestId) {
+        throw new Error(`Guest id is required to add Module scripting object`);
+      }
+      if (guestId) {
+        __privateGet(this, _addGuestScriptingObject).call(this, { so, ...params, guestId });
+        return;
+      }
+      if (__privateGet(this, _scriptingObjects).has(objectId))
+        throw new Error(`Scripting Object ${so.id} already exists`);
+      __privateGet(this, _scriptingObjects).set(objectId, { so, ...params });
+    });
+    /**
+     * Get reference to the scripting object proxy for a guest
+     *
+     * @param {string} objectId scripting object id
+     * @param {GuestContext} guest that is requesting the scripting object
+     * @returns proxied scripting object reference
+     */
+    __publicField(this, "getObject", (objectId, guest) => {
+      const id = objectId.toLowerCase();
+      let soInfo = null;
+      if (guest?.id) {
+        soInfo = __privateGet(this, _getGuestScriptingObject).call(this, {
+          objectId: id,
+          guestId: guest.id
+        });
+      }
+      soInfo = soInfo ?? __privateGet(this, _scriptingObjects).get(id);
+      const { so } = soInfo || {};
+      if (!so)
+        return null;
+      if (!guest)
+        return so;
+      const guestSO = __privateGet(this, _attachCallContext).call(this, { so, guest });
+      Object.defineProperty(guestSO, "target", {
+        value: so,
+        enumerable: false,
+        configurable: false,
+        writable: true
+      });
+      return guestSO;
+    });
+    /**
+     * removes scripting object
+     *
+     * @param objectId unique id of the scripting object
+     * @param guestId unique id of the guest
+     */
+    __publicField(this, "removeScriptingObject", (objectId, guestId) => {
+      const id = objectId.toLowerCase();
+      if (guestId) {
+        __privateGet(this, _removeGuestScriptingObject).call(this, { objectId: id, guestId });
+      } else {
+        __privateGet(this, _removeGuestScriptingObject).call(this, { objectId: id });
+        const soInfo = __privateGet(this, _scriptingObjects).get(id);
+        if (soInfo)
+          __privateGet(this, _disposeSO).call(this, soInfo);
+        __privateGet(this, _scriptingObjects).delete(id);
+      }
+    });
+    /**
+     * removes all scripting objects
+     *
+     * @param guestId unique id of the guest
+     */
+    __publicField(this, "removeAllScriptingObjects", (guestId) => {
+      if (!guestId) {
+        __privateGet(this, _scriptingObjects).forEach(__privateGet(this, _disposeSO));
+        __privateGet(this, _scriptingObjects).clear();
+      } else {
+        __privateGet(this, _removeGuestScriptingObject).call(this, { guestId });
+      }
+    });
+  }
+}
+_scriptingObjects = new WeakMap();
+_guestScriptingObjects = new WeakMap();
+_addGuestScriptingObject = new WeakMap();
+_disposeSO = new WeakMap();
+_getGuestScriptingObject = new WeakMap();
+_removeGuestScriptingObject = new WeakMap();
+_attachCallContext = new WeakMap();

package/dist/esm/index.js

@@ -3,11 +3,13 @@ import { getEventId } from "./event.js";
 import { Event } from "./event.js";
 import { ScriptingObject } from "./scriptingObject.js";
 import { MessageType } from "./messageType.js";
+import { ScriptingObjectManager } from "./scriptingObjectManager.js";
 export {
   Event,
   MessageType,
   Remoting,
   ScriptingObject,
+  ScriptingObjectManager,
   getEventId,
   sendMessage
 };

package/dist/esm/scriptingObjectManager.js

@@ -0,0 +1,220 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 _scriptingObjects, _guestScriptingObjects, _addGuestScriptingObject, _disposeSO, _getGuestScriptingObject, _removeGuestScriptingObject, _attachCallContext;
+var SecurityContext = /* @__PURE__ */ ((SecurityContext2) => {
+  SecurityContext2["USER"] = "USER";
+  SecurityContext2["PARTNER"] = "PARTNER";
+  return SecurityContext2;
+})(SecurityContext || {});
+class ScriptingObjectManager {
+  constructor() {
+    /**
+     * collection of registered scripting objects
+     */
+    __privateAdd(this, _scriptingObjects, /* @__PURE__ */ new Map());
+    /**
+     * collection of proxied scripting objects for each guest
+     */
+    __privateAdd(this, _guestScriptingObjects, /* @__PURE__ */ new Map());
+    __privateAdd(this, _addGuestScriptingObject, (params) => {
+      const { so, guestId } = params;
+      const objectId = so.id.toLowerCase();
+      const guestSOs = __privateGet(this, _guestScriptingObjects).get(guestId);
+      if (!guestSOs) {
+        __privateGet(this, _guestScriptingObjects).set(guestId, /* @__PURE__ */ new Map([[objectId, params]]));
+      } else {
+        if (guestSOs.has(objectId))
+          throw new Error(
+            `Scripting Object ${so.id} already exists for guest ${guestId}`
+          );
+        guestSOs.set(objectId, params);
+      }
+    });
+    __privateAdd(this, _disposeSO, ({ so }) => {
+      if (so._dispose && typeof so._dispose === "function") {
+        so._dispose();
+      }
+    });
+    __privateAdd(this, _getGuestScriptingObject, ({
+      objectId,
+      guestId
+    }) => {
+      const moduleSOs = __privateGet(this, _guestScriptingObjects).get(guestId);
+      if (moduleSOs) {
+        return moduleSOs.get(objectId) ?? null;
+      }
+      return null;
+    });
+    __privateAdd(this, _removeGuestScriptingObject, ({
+      objectId,
+      guestId
+    } = {}) => {
+      if (guestId) {
+        if (!objectId) {
+          const sosInfo = __privateGet(this, _guestScriptingObjects).get(guestId);
+          if (sosInfo) {
+            sosInfo.forEach(__privateGet(this, _disposeSO));
+          }
+          __privateGet(this, _guestScriptingObjects).delete(guestId);
+          return;
+        }
+        const moduleSOs = __privateGet(this, _guestScriptingObjects).get(guestId);
+        if (moduleSOs) {
+          const soInfo = moduleSOs.get(objectId);
+          if (soInfo)
+            __privateGet(this, _disposeSO).call(this, soInfo);
+          moduleSOs.delete(objectId);
+        }
+      } else if (objectId) {
+        __privateGet(this, _guestScriptingObjects).forEach((moduleSOs) => {
+          const soInfo = moduleSOs.get(objectId);
+          if (soInfo)
+            __privateGet(this, _disposeSO).call(this, soInfo);
+          moduleSOs.delete(objectId);
+        });
+      }
+    });
+    /**
+     * attach guest context to the scripting object methods
+     *
+     * @param root0
+     * @param root0.so
+     * @param root0.guest
+     * @returns proxies scripting object that has call context set to the guest
+     */
+    __privateAdd(this, _attachCallContext, ({
+      so,
+      guest
+    }) => new Proxy(so, {
+      get(target, prop, receiver) {
+        const value = target[prop];
+        if (value instanceof Function && prop !== "constructor") {
+          return function(...args) {
+            const proxyRef = this;
+            Object.defineProperty(value, "callContext", {
+              value: guest,
+              enumerable: false,
+              writable: true
+            });
+            return value.apply(proxyRef === receiver ? target : proxyRef, args);
+          };
+        }
+        return value;
+      }
+    }));
+    /**
+     * registers scripting object to the host
+     *
+     * @param so scripting object to register
+     * @param {AddScriptingObjectParams<ValueOf<AppObjects>>}
+     * @param params
+     */
+    __publicField(this, "addScriptingObject", (so, params) => {
+      const { guestId } = params || {};
+      if (!so?.id || !so?._toJSON) {
+        throw new Error("Object is not derived from ScriptingObject");
+      }
+      const objectId = so.id.toLowerCase();
+      if (objectId === "module" && !guestId) {
+        throw new Error(`Guest id is required to add Module scripting object`);
+      }
+      if (guestId) {
+        __privateGet(this, _addGuestScriptingObject).call(this, { so, ...params, guestId });
+        return;
+      }
+      if (__privateGet(this, _scriptingObjects).has(objectId))
+        throw new Error(`Scripting Object ${so.id} already exists`);
+      __privateGet(this, _scriptingObjects).set(objectId, { so, ...params });
+    });
+    /**
+     * Get reference to the scripting object proxy for a guest
+     *
+     * @param {string} objectId scripting object id
+     * @param {GuestContext} guest that is requesting the scripting object
+     * @returns proxied scripting object reference
+     */
+    __publicField(this, "getObject", (objectId, guest) => {
+      const id = objectId.toLowerCase();
+      let soInfo = null;
+      if (guest?.id) {
+        soInfo = __privateGet(this, _getGuestScriptingObject).call(this, {
+          objectId: id,
+          guestId: guest.id
+        });
+      }
+      soInfo = soInfo ?? __privateGet(this, _scriptingObjects).get(id);
+      const { so } = soInfo || {};
+      if (!so)
+        return null;
+      if (!guest)
+        return so;
+      const guestSO = __privateGet(this, _attachCallContext).call(this, { so, guest });
+      Object.defineProperty(guestSO, "target", {
+        value: so,
+        enumerable: false,
+        configurable: false,
+        writable: true
+      });
+      return guestSO;
+    });
+    /**
+     * removes scripting object
+     *
+     * @param objectId unique id of the scripting object
+     * @param guestId unique id of the guest
+     */
+    __publicField(this, "removeScriptingObject", (objectId, guestId) => {
+      const id = objectId.toLowerCase();
+      if (guestId) {
+        __privateGet(this, _removeGuestScriptingObject).call(this, { objectId: id, guestId });
+      } else {
+        __privateGet(this, _removeGuestScriptingObject).call(this, { objectId: id });
+        const soInfo = __privateGet(this, _scriptingObjects).get(id);
+        if (soInfo)
+          __privateGet(this, _disposeSO).call(this, soInfo);
+        __privateGet(this, _scriptingObjects).delete(id);
+      }
+    });
+    /**
+     * removes all scripting objects
+     *
+     * @param guestId unique id of the guest
+     */
+    __publicField(this, "removeAllScriptingObjects", (guestId) => {
+      if (!guestId) {
+        __privateGet(this, _scriptingObjects).forEach(__privateGet(this, _disposeSO));
+        __privateGet(this, _scriptingObjects).clear();
+      } else {
+        __privateGet(this, _removeGuestScriptingObject).call(this, { guestId });
+      }
+    });
+  }
+}
+_scriptingObjects = new WeakMap();
+_guestScriptingObjects = new WeakMap();
+_addGuestScriptingObject = new WeakMap();
+_disposeSO = new WeakMap();
+_getGuestScriptingObject = new WeakMap();
+_removeGuestScriptingObject = new WeakMap();
+_attachCallContext = new WeakMap();
+export {
+  ScriptingObjectManager,
+  SecurityContext
+};

package/dist/types/index.d.ts

@@ -8,3 +8,5 @@ export { ScriptingObject } from './scriptingObject.js';
 export { MessageType } from './messageType.js';
 export type { EventListeners, Listener } from './common.js';
 export type { ISSFGuest, ConnectParam, SubscribeParam as GuestSubscribeParam, UnsubscribeParam as GuestUnsubscribeParam, } from './guest.js';
+export { ScriptingObjectManager } from './scriptingObjectManager.js';
+export type { AddScriptingObjectParams, GetObjectParams, GuestContext, } from './scriptingObjectManager.js';

package/dist/types/scriptingObjectManager.d.ts

@@ -0,0 +1,97 @@
+import { ScriptingObjectTypes, IScriptingObject } from '@elliemae/pui-scripting-object';
+type ValueOf<T> = T[keyof T];
+/**
+ * collection of scripting objects
+ */
+export type ScriptingObjects = Record<string, IScriptingObject>;
+/**
+ * information about the guest
+ */
+export type GuestContext = {
+    /**
+     * unique id of the guest application
+     */
+    id: string;
+};
+/**
+ * security context under which the guest application is running
+ */
+export declare enum SecurityContext {
+    /**
+     * application is using the same security context as the host
+     */
+    USER = "USER",
+    /**
+     * application is using the partner security context
+     */
+    PARTNER = "PARTNER"
+}
+/**
+ * parameters to add scripting object
+ */
+export type AddScriptingObjectParams = {
+    /**
+     * limit scripting object only to the specified guest
+     */
+    guestId?: string;
+    /**
+     * security context under which the scripting object is available
+     */
+    securityContext?: SecurityContext;
+};
+/**
+ * parameters to get scripting object
+ */
+export type GetObjectParams = {
+    guest: GuestContext;
+};
+/**
+ * scripting object details
+ */
+export type SOInfo<Objects extends ScriptingObjects> = {
+    /**
+     * scripting object to add
+     */
+    so: ValueOf<Objects>;
+    /**
+     * limit scripting object only to the specified guest
+     */
+    guestId?: string;
+    /**
+     * security context under which the scripting object is available
+     */
+    securityContext?: SecurityContext;
+};
+export declare class ScriptingObjectManager<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>> {
+    #private;
+    /**
+     * registers scripting object to the host
+     *
+     * @param so scripting object to register
+     * @param {AddScriptingObjectParams<ValueOf<AppObjects>>}
+     * @param params
+     */
+    addScriptingObject: <SO extends ValueOf<AppObjects>>(so: SO, params?: AddScriptingObjectParams) => void;
+    /**
+     * Get reference to the scripting object proxy for a guest
+     *
+     * @param {string} objectId scripting object id
+     * @param {GuestContext} guest that is requesting the scripting object
+     * @returns proxied scripting object reference
+     */
+    getObject: <ObjectId extends Extract<keyof AppObjects, string>>(objectId: ObjectId, guest?: GuestContext) => AppObjects[ObjectId] | null;
+    /**
+     * removes scripting object
+     *
+     * @param objectId unique id of the scripting object
+     * @param guestId unique id of the guest
+     */
+    removeScriptingObject: (objectId: Extract<keyof AppObjects, string>, guestId?: string) => void;
+    /**
+     * removes all scripting objects
+     *
+     * @param guestId unique id of the guest
+     */
+    removeAllScriptingObjects: (guestId?: string) => void;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/microfe-common",
-  "version": "2.0.0-next.40",
+  "version": "2.0.0-next.41",
   "description": "common micro frontend functional modules",
   "repository": {
     "type": "git",