evmux-app-framework 0.0.1

package/README.md

@@ -0,0 +1 @@
+# evmuxAppFramework

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "evmux-app-framework",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "webpack",
+    "build:prod": "webpack --mode production",
+    "dev": "webpack serve --mode development",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "html-webpack-plugin": "^5.5.0",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.0",
+    "webpack-dev-server": "^4.11.1"
+  }
+}

package/src/AppsDataManager/AppsDataManager.js

@@ -0,0 +1,52 @@
+
+
+import { createPromise, generateGuid, pubSub } from '../EvmuxAppsApi/HelpersFromCore'
+
+
+ export class AppsDataManager {
+    /*    
+    _requests: {} */
+
+    constructor(){
+        this._userApps = {}
+        this._userAppInstances = {}
+    }
+
+
+    updateUserAppData(appId, appData, merge = false) {
+        if (!merge || !this._userApps[appId]) {
+            this._userApps[appId] = appData;
+        }
+        else {
+            this._userApps[appId] = { ...this._userApps[appId], ...appData };
+        }
+    }
+
+    updateUserAppInstance(instanceId, instanceData, merge = false) {
+        if (!merge || !this._userAppInstances[instanceId]) {
+            this._userAppInstances[instanceId] = instanceData;
+        }
+        else {
+            this._userAppInstances[instanceId] = { ...this._userAppInstances[instanceId], ...instanceData };
+        }
+    }
+
+    async getUserAppDataByAppId(userAppId) {
+        return this._userApps[userAppId];
+    }
+
+    async getUserAppInstanceById(userInstanceId, includeAppData = false) {
+        
+        let appInstance = this._userAppInstances[userInstanceId];
+
+        if (appInstance && includeAppData)
+        {
+            appInstance.appData = await this.getUserAppDataByAppId(appInstance.userAppId)
+        }
+
+        return appInstance;
+    }
+ }
+
+let appsDataManager = new AppsDataManager();
+export default appsDataManager;

package/src/AppsObserver/AppsObserver.js

@@ -0,0 +1,131 @@
+
+
+import { createPromise, generateGuid, pubSub } from '../EvmuxAppsApi/HelpersFromCore'
+
+import PostMessageManager from '../PostMessageManager/PostMessageManager';
+import appsDataManager from '../AppsDataManager/AppsDataManager';
+
+let createEventResultObject = (eventName, result) => {
+
+    let eventObj = {
+      requestName: "EvEvent",
+      eventName,
+      data: {...result}
+    }
+    return eventObj;
+}
+  
+
+ class AppsObserver {
+    /*    
+    _requests: {} */
+
+    constructor(){
+        this._userAppInstances = {}
+        this._messagesEventHandlers = new pubSub()
+        this._eventHandler = new pubSub()
+        window.onmessage = this.onPostMessage.bind(this);
+    }
+
+    raiseEvent(eventName, data) {
+        
+    }
+
+    getAppSettingsForAppInstanceId(appInstanceId)
+    {
+        return {}
+    }
+  
+    _makeSureAppInstanceExist(userAppInstanceId)
+    {
+        this._userAppInstances[userAppInstanceId] = this._userAppInstances[userAppInstanceId]  || {  }
+        this._userAppInstances[userAppInstanceId].instances = this._userAppInstances[userAppInstanceId].instances || {};
+        this._userAppInstances[userAppInstanceId].events = this._userAppInstances[userAppInstanceId].events || {};
+    }
+      
+     async onPostMessage(evt) {
+        
+        let requestObj = {};
+        try {
+            requestObj = JSON.parse(evt.data);
+        } catch (error) {
+            console.log("xxxx", error)
+        }
+        
+        let result = null
+
+        if (requestObj.request == "updateSettings")
+        {
+            
+            if (this._userAppInstances[requestObj.userAppInstanceId]) {
+
+                
+                this._eventHandler.publish("updateSettings", requestObj)
+                
+                if (this._userAppInstances[requestObj.userAppInstanceId].events['settingsUpdated'])
+                {
+                    let eventObj = createEventResultObject("settingsUpdated", requestObj.data)
+                    let stringObjToSend = JSON.stringify(eventObj)
+                    for (const [key, instanceWindow] of Object.entries(this._userAppInstances[requestObj.userAppInstanceId].instances)) {
+                        instanceWindow.window.postMessage(stringObjToSend, "*")
+                    }
+                }
+
+            }
+        }
+        else if (requestObj.request == "getSettings")
+        {
+      
+            if (this._userAppInstances[requestObj.userAppInstanceId]) {
+
+                let eventObj = createEventResultObject("settings", requestObj.data)
+                let stringObjToSend = JSON.stringify(eventObj)
+                result = (await appsDataManager.getUserAppInstanceById(requestObj.userAppInstanceId, false)).settings
+                //this._userAppInstances[requestObj.userAppInstanceId].window.postMessage(stringObjToSend, "*")
+
+            }
+        }
+        else if (requestObj.request == "startLoad")
+        {
+            this._makeSureAppInstanceExist(requestObj.userAppInstanceId);
+            this._userAppInstances[requestObj.userAppInstanceId].instances[requestObj.componentId] = { window: evt.source }
+            return;
+        }
+        else if (requestObj.request == "loaded")
+        {
+            this._makeSureAppInstanceExist(requestObj.userAppInstanceId);
+            
+            this._userAppInstances[requestObj.userAppInstanceId].instances[requestObj.componentId] = { window: evt.source }
+
+            result = this.getAppSettingsForAppInstanceId(requestObj.userAppInstanceId)
+        }
+        else if (requestObj.request == "registerEvent")
+        {
+            // verify that the app can register to this event
+            this._makeSureAppInstanceExist(requestObj.userAppInstanceId);
+            this._userAppInstances[requestObj.userAppInstanceId].events[requestObj.data.eventName] = true
+        }
+        else if (requestObj.request == "unregisterEvent")
+        {
+            this._makeSureAppInstanceExist(requestObj.userAppInstanceId);
+            delete this._userAppInstances[requestObj.userAppInstanceId].events[requestObj.data.eventName]
+        }
+        
+        PostMessageManager.respondForPromiseBasedRequest(requestObj, evt.source, evt.origin, result);
+
+    }
+     
+     onUserAppComponentUnload(userAppInstanceId, componentId)
+     {
+         if (this._userAppInstances[userAppInstanceId].instances[componentId]) {
+            delete this._userAppInstances[userAppInstanceId].instances[componentId]
+            if (Object.keys(this._userAppInstances[userAppInstanceId].instances).length == 0)
+            {
+                delete this._userAppInstances[userAppInstanceId]  
+            }
+         }
+     }
+ }
+
+
+export default new AppsObserver();

package/src/EvmuxAppsApi/EvmuxAppsApi.js

@@ -0,0 +1,75 @@
+import PostMessageManager from '../PostMessageManager/PostMessageManager.js'
+
+const availableEvents = ["settingsUpdated", "viewerCountChanged", ""]
+
+export default class EvmuxAppsApi {
+  
+  constructor(userAppInstanceId, componentId) {
+        if (userAppInstanceId == null)
+        {
+          let appIdFromUrl = new URLSearchParams(window.location.search).get("appInstanceId");
+          
+          if (appIdFromUrl !== null)
+            userAppInstanceId = appIdFromUrl;
+        }
+    
+        if (componentId == undefined)
+        {
+          let componentIdFromUrl = new URLSearchParams(window.location.search).get("compId");
+          
+          if (componentIdFromUrl !== null)
+            componentId = componentIdFromUrl;
+        }
+      
+        this._postMessageManager = new PostMessageManager();
+        this._userAppInstanceId = userAppInstanceId;
+        this._componentId = componentId;
+
+        let reqObj = {request: "startLoad", userAppInstanceId: this._userAppInstanceId, componentId: this._componentId}
+        this._postMessageManager.sendRequest(reqObj);
+  
+      }
+
+      async registerEvent(eventName, callback)
+      {
+        this._postMessageManager._messagesEventHandlers.subscribe(eventName, callback)
+
+        let reqObj = { request: "registerEvent", userAppInstanceId: this._userAppInstanceId, componentId: this._componentId }
+        reqObj.data = {
+          eventName
+        }
+        return this._postMessageManager.sendRequestAsync(reqObj);
+      }
+  
+      async unregisterEvent(eventName, callback)
+      {
+        this._postMessageManager._messagesEventHandlers.unsubscribe(eventName, callback)
+        let reqObj = { request: "unregisterEvent", userAppInstanceId: this._userAppInstanceId, componentId: this._componentId }
+        reqObj.data = {
+          eventName
+        }
+        return this._postMessageManager.sendRequestAsync(reqObj);
+      }
+  
+      async reportLoaded() {
+        let reqObj = {request: "loaded", userAppInstanceId: this._userAppInstanceId, componentId: this._componentId}
+        return this._postMessageManager.sendRequestAsync(reqObj);
+      }
+  
+      async getSettings() {
+        
+        let reqObj = {request: "getSettings", userAppInstanceId: this._userAppInstanceId, componentId: this._componentId}
+        return this._postMessageManager.sendRequestAsync(reqObj);
+      }
+  
+      async updateSettings(settingsObj) {
+        
+        let requestObj = {
+          request: "updateSettings",
+          userAppInstanceId: this._userAppInstanceId,
+          componentId: this._componentId,
+          data: { ...settingsObj }
+        }  
+        return this._postMessageManager.sendRequestAsync(requestObj);
+      }
+  }

package/src/EvmuxAppsApi/HelpersFromCore.js

@@ -0,0 +1,85 @@
+export function createPromise(){
+  let resolve = null
+  let reject = null
+
+  let prom = new Promise((resolveF, rejectF) => {
+      resolve = resolveF
+      reject = rejectF
+  } )
+
+  return [prom, resolve, reject]
+}
+
+export function generateGuid() {
+  var result, i, j;
+  result = '';
+  for(j=0; j<32; j++) {
+    if( j == 8 || j == 12 || j == 16 || j == 20)
+      result = result + '-';
+    i = Math.floor(Math.random()*16).toString(16).toUpperCase();
+    result = result + i;
+  }
+  return result.toLowerCase();
+}
+
+
+
+export class pubSub
+{
+    // this.subscribers = {};
+
+    constructor() {
+        this.subscribers = {};
+    }
+    init() {
+    }
+
+    publish(eventName, data /* EventArgs */) {
+        if (!Array.isArray(this.subscribers[eventName]))
+            return;
+
+        this.subscribers[eventName].forEach(
+            (subscriberCallback) => {
+                try{
+                    subscriberCallback(eventName, data)
+                }catch (e) {
+                    console.error(e)
+                }
+            });
+    }
+
+
+    subscribe(eventName, callback) {
+        if (!Array.isArray(this.subscribers[eventName])) {
+            this.subscribers[eventName] = [];
+        }
+        if (this.subscribers[eventName].indexOf(callback) >= 0)
+          return () => this.unsubscribe(eventName, callback);
+        this.subscribers[eventName].push(callback);
+
+        return () => this.unsubscribe(eventName, callback);
+
+    }
+
+    unsubscribe(eventName, callback) {
+
+        if (!Array.isArray(this.subscribers[eventName])) {
+            return false;
+        }
+
+        if (this.subscribers[eventName].indexOf(callback) < 0)
+            return false;
+
+        this.subscribers[eventName] = this.subscribers[eventName].filter((cb) => {
+            // Does not include the callback in the new array
+            if (cb === callback) {
+                return false
+            }
+            return true
+        });
+
+    }
+
+
+}
+

package/src/PostMessageManager/PostMessageManager.js

@@ -0,0 +1,80 @@
+
+
+import {createPromise, generateGuid, pubSub} from '../EvmuxAppsApi/HelpersFromCore'
+
+
+export default class PostMessageManager {
+    /*    
+    _requests: {} */
+
+    constructor(){
+        this._requests = {};
+        this._messagesEventHandlers = new pubSub()
+        window.onmessage = this.onPostMessage.bind(this);
+    }
+
+    static respondForPromiseBasedRequest(requestObj, targetWindow, targetAdress = '*', result)
+    {
+        if (targetAdress == 'null')
+            targetAdress = '*'
+        if (requestObj.promisedBased)
+        {
+            let objectToAttach = {requestGuid: requestObj.requestGuid, response: result}
+            targetWindow.postMessage(JSON.stringify(objectToAttach), '*');    
+        }
+    }
+
+    async sendRequestAsync(requestObj, targetWindow = null) {
+        
+        let reqId = generateGuid();
+        let [prom, resolve, reject] = createPromise();
+
+        this._requests[reqId] = {
+            prom,
+            resolve,
+            reject,
+        }
+
+        requestObj.requestGuid = reqId;
+        requestObj.promisedBased = true;
+
+        targetWindow = targetWindow ? targetWindow : window.parent;
+        targetWindow.postMessage(JSON.stringify(requestObj), "*");
+
+        return prom;
+    }
+
+    sendRequest(requestObj, targetWindow = null) {
+        
+        let reqId = generateGuid();
+
+        requestObj.requestGuid = reqId;
+
+        targetWindow = targetWindow ? targetWindow : window.parent;
+        targetWindow.postMessage(JSON.stringify(requestObj), "*");
+    }
+  
+      
+    onPostMessage(evt) {
+        try {
+            let reqObj = evt && JSON.parse(evt.data)
+            if (reqObj.requestGuid && this._requests[reqObj.requestGuid])
+            {
+                let res = this._requests[reqObj.requestGuid];
+                delete this._requests[reqObj.requestGuid]
+                return res.resolve(reqObj)
+            }
+            else if (reqObj.requestName == "EvEvent")
+            {
+                this._messagesEventHandlers.publish(reqObj.eventName, reqObj.data)
+            }
+        } catch (error) {
+            
+        }
+
+    }
+
+    unregisterFromEvents(){
+
+    }
+  }