@zohodesk/platform-middleware/src/sigmafiles/ZFramework.js

Generalized Contract for the events from Marketplace App, In-App widgets, CRM-Plus and EFC

/*$Id$*/
let ZAppUtil = (function (ZAppUtil) { // eslint-disable-line no-unused-vars, no-shadow

  // Global Logger instance which will be acquired and shared by other modules.
  let GlobalLogger;

  // minimal Logging utility.
  function ZLogger() { }
  ZLogger.prototype.Info = function () {
    //    if (ZAppUtil.isDevMode()) {
    //      // eslint-disable-next-line no-console
    //      console.info.apply(console, arguments);
    //    }
  };
  ZLogger.prototype.Error = function () {
    console.log(...arguments); // eslint-disable-line no-console
    console.error(new Error()); // eslint-disable-line no-console
  };
  function getLogger() {
    if (!GlobalLogger || !(GlobalLogger instanceof ZLogger)) {
      GlobalLogger = new ZLogger(); // Logging instance for Core Framework
    }

    return GlobalLogger;
  }

  function constructQueryParamsString(qpMap) {
    let qpPairs = [];
    for (let k in qpMap) {
      if (k && qpMap[k]) {
        qpPairs.push(`${k}=${qpMap[k]}`);
      }
    }
    return qpPairs.join('&');
  }

  function getURLOrigin(URL) {
    let currentLocation = URL || document.location.href;
    let aEle = document.createElement('a');
    aEle.setAttribute('href', currentLocation);

    return `${aEle.protocol}//${aEle.host}`;
  }

  function isURL(URL) {
    return URL.indexOf('http') !== -1;
  }

  // Custom Error function.
  function AuthenticationError(message) {
    this.name = 'AuthenticationError';
    this.message = message;
    this.stack = (new Error()).stack;
  }
  AuthenticationError.prototype = Object.create(Error.prototype);
  AuthenticationError.prototype.constructor = AuthenticationError;

  ZAppUtil.getURLOrigin = getURLOrigin;
  ZAppUtil.isURL = isURL;
  ZAppUtil.getLogger = getLogger;
  ZAppUtil.constructQueryParamsString = constructQueryParamsString;
  ZAppUtil.AuthenticationError = AuthenticationError;

  return ZAppUtil;
}(window.ZAppUtil || {}));

/* eslint-disable */
function ZWidgetRuntime(widgetProps) {
  this.__WIDGET__ = widgetProps;
  this._hasLoaded = false;
  this._isActive = false;
  this._bindedEvents = {};
  this._hasRegistered = false;
  this._origin;
  this._type;
}
ZWidgetRuntime.prototype.getWidgetInfo = function () {
  var info = {
    'url': this.getURL(),
    'location': this.getLocation(),
    'widgetID': this.getUniqueID(),
    'name': this.getProp('name')
  };
  return info;
}
ZWidgetRuntime.prototype.hasLoaded = function () {
  return !!this._hasLoaded;
};
ZWidgetRuntime.prototype.isActive = function () {
  return this._isActive;
};
ZWidgetRuntime.prototype.getOrigin = function () {
  return this._origin;
};
ZWidgetRuntime.prototype.activate = function (shouldSendEvent) {
  this._isActive = true;
  // TODO: Send Event to the App if shouldSendEvent is set

  return this._isActive;
};
ZWidgetRuntime.prototype.deActivate = function (shouldSendEvent) {
  this._isActive = false;
  // TODO: Send Event to the App if shouldSendEvent is set

  return this._isActive;
};
ZWidgetRuntime.prototype.getConfig = function () {
  return this.__WIDGET__ && this.__WIDGET__.config;
};
ZWidgetRuntime.prototype.getFrameOrigin = function () {
  return this.__WIDGET__.frameOrigin;
}
ZWidgetRuntime.prototype.getURL = function () {
  return this.__WIDGET__.url;
}
ZWidgetRuntime.prototype.getLocation = function () {
  return this.__WIDGET__.location;
}
ZWidgetRuntime.prototype.getExtensionID = function () {
  return this.__WIDGET__ && this.__WIDGET__.extension_id;
}
ZWidgetRuntime.prototype.getExtensionVersion = function () {
  return this.__WIDGET__ && this.__WIDGET__.extension_version;
}
ZWidgetRuntime.prototype.getZAppID = function () {
  return this.__WIDGET__ && this.__WIDGET__.zappid;
}
ZWidgetRuntime.prototype.getResolvedURL = function () {
  return this._resolvedURL;
}
ZWidgetRuntime.prototype.getUniqueID = function () {
  return this._uniqueID;
}
ZWidgetRuntime.prototype.getProp = function (propName) {
  return this.__WIDGET__ && this.__WIDGET__[propName];
}
ZWidgetRuntime.prototype.getIFrame = function () { return document.getElementById(this._uniqueID); };
ZWidgetRuntime.prototype.getWindow = function () {
  var _iframe = document.getElementById(this._uniqueID);
  return _iframe && _iframe.contentWindow;
};
ZWidgetRuntime.prototype.SendEvent = function (eventName, data, isPromise) {
  var eventObj = {
    type: '__EVENT__',
    data: data,
    uniqueID: this.getUniqueID(),
    widgetID: this.getUniqueID(),
    eventName: eventName,
    isPromise: isPromise
  };
  var bindedEvents = this._bindedEvents[eventName];
  var widgetInstance, returnVal = [];
  if (typeof bindedEvents !== 'undefined') {
    for (var k in bindedEvents) {
      if (bindedEvents.hasOwnProperty(k)) {

        widgetInstance = ZApp.GetWidgetInstance(k);
        if (widgetInstance && widgetInstance.isActive()) {
          if (isPromise) {
            returnVal.push(MessageManager.SendMessage(widgetInstance, eventObj));
          } else {
            MessageManager.SendMessage(widgetInstance, eventObj);
          }
        }
      }
    }
  }
  if (isPromise) {
    return returnVal;
  }
};
ZWidgetRuntime.prototype.addEventInfo = function () { }
ZWidgetRuntime.prototype.removeEventInfo = function () { }
ZWidgetRuntime.prototype.getEvents = function () {
  return Object.keys(this._bindedEvents);
}
var MessageManager = (function (MessageManager) { // eslint-disable-line no-unused-vars, no-shadow

  var Context;
  var Logger = ZAppUtil.getLogger();
  var promiseIDCtr = 100;
  var PromiseQueue = {};

  function Init(ctx, config) { // config for any future use
    if (!ctx || typeof ctx !== 'object') {
      throw Error('Invalid Context object passed');
    }
    if (config && typeof config !== 'object') {
      throw Error('Invalid Configuration Passed to MessageHandler');
    }

    Context = ctx;

    return MessageHandler.bind(MessageManager);
  }

  function SendMessage(widgetInstance, message) {
    var isPromiseEvent = message.isPromise;
    var PromiseID;
    if (isPromiseEvent) {
      PromiseID = getNextPromiseID();
      message.promiseID = PromiseID; // eslint-disable-line
    }

    var frameURL = getURLWithPath(widgetInstance.getResolvedURL());
    var ctxWindow = widgetInstance.getWindow();

    if (!ctxWindow || !frameURL) {
      Logger.Error('Invalid IFrame object. Can\'t send Message to Widget');
      return;
    }
    message.__time__ = new Date().getTime();

    ctxWindow.postMessage(message, frameURL);

    if (isPromiseEvent) {
      return AddToPromiseQueue(PromiseID);
    }
  }

  function getNextPromiseID() {
    return 'Promise' + promiseIDCtr++;
  }
  function AddToPromiseQueue(promiseID) {

    var promise = new Promise(function (resolve, reject) {

      // Adding the promise to queue.
      PromiseQueue[promiseID] = {
        resolve: resolve,
        reject: reject,
        time: new Date().getTime()
      };
    });

    return promise;
  }

  function BroadcastEvent(eventName, data, isPromise) {
    var widgetInstances = Context.GetAllWidgetInstance(), widgetInstance;
    var returnArr = [];

    for (var k in widgetInstances) {
      if (widgetInstances.hasOwnProperty(k)) {
        widgetInstance = widgetInstances[k];
        if (widgetInstance && widgetInstance.isActive()) {
          var eventPromise = widgetInstance.SendEvent(eventName, data, isPromise);
          if (isPromise && eventPromise) {
            for (var i = 0; i < eventPromise.length; i++) {
              returnArr.push(eventPromise[i]);
            }
          }
        }
      }
    }
    return isPromise ? returnArr : Promise.resolve();
  }


  // Event Handlers
  function MessageHandler(MessageEvent) {
    /* Added for backward compatibility support */
    var data;
    try {
      data = typeof MessageEvent.data === 'string' ? JSON.parse(MessageEvent.data) : MessageEvent.data;
    } catch (e) {
      data = MessageEvent.data;
    }
    var messageType = data.type;
    try {

      if (['__REGISTER__', '__DEREGISTER__'].indexOf(messageType) !== -1 || isAuthorizedMessage(MessageEvent, data)) {

        switch (messageType) {

          case '__REGISTER__':
            HandleRegister(MessageEvent, data); break;
          case '__DEREGISTER__':
            HandleDeRegister(MessageEvent, data); break;
          case '__EVENT_BIND__':
            HandleEventBind(MessageEvent, data); break;
          case '__EMIT__':
            HandleEmitEvent(MessageEvent, data); break;
          case '__EVENT_RESPONSE__':
            HandleEventResponse(MessageEvent, data); break;
          default:
            HandleInternalEvent(MessageEvent, data); break;

        }
      }

    } catch (e) {
      if (!(e instanceof ZAppUtil.AuthenticationError)) {
        Logger.Error('[MessageHandler] => ', e.stack);
      }
    }
  }

  function isAuthorizedMessage(MessageEvent, data) {

    var widgetInstance = Context.GetWidgetInstance(data.uniqueID);
    var WindowRef = widgetInstance && widgetInstance.getWindow();

    if (typeof data.uniqueID !== 'string' && !WindowRef) {
      throw new ZAppUtil.AuthenticationError('Message from Invalid window from received');
    }
    var Origin = getURLWithPath(widgetInstance.getResolvedURL());
    var widgetUniqueID = widgetInstance.getUniqueID();

    var MessageWindowRef = MessageEvent.source;
    var MessageUniqueID = data.uniqueID;
    var MessageOrigin = getURLWithPath(decodeURIComponent(data.widgetOrigin));

    if (WindowRef !== MessageWindowRef || Origin !== MessageOrigin || widgetUniqueID !== MessageUniqueID) {
      throw new Error('Message from UnAuthorized Source');
    }

    return true;
  }

  // Register SDK
  function HandleRegister(MessageEvent, data) {

    var sourceWindow = MessageEvent.source;
    var origin = MessageEvent.origin;
    var uniqueID = data.uniqueID;
    var widgetInstance = Context.GetWidgetInstance(uniqueID);
    if (!widgetInstance || (widgetInstance && sourceWindow !== widgetInstance.getWindow())) {
      Logger.Error('Message from Invalid IFrame arrived.');
      return;
    }

    widgetInstance._origin = origin;
    widgetInstance._isActive = true;
    widgetInstance._hasRegistered = true;

  }
  function WidgetLoadHandler(widgetInstance) {
    var widgetLocation = widgetInstance.getIFrame() && widgetInstance.getIFrame().getAttribute('data-location');
    var metaData = widgetInstance.getProp('meta') //Context.GetMeta(widgetLocation);
    var extensionID = widgetInstance.getExtensionID();
    var localeResourceURL = widgetInstance.getProp("localeResourceUrl");
    var defaultLocaleResourceUrl = widgetInstance.getProp("defaultLocaleResourceUrl");
    var locale = widgetInstance.getProp("locale");

    var PluginContext = {
      type: '__REGISTER__',
      uniqueID: widgetInstance.getUniqueID(),
      data: {
        meta: metaData, // NO I18N
        uniqueID: widgetInstance.getUniqueID(),
        extensionID: extensionID,
        location: widgetInstance.getLocation()
      }
    };

    Context
      .FetchLocaleResource(localeResourceURL, locale, defaultLocaleResourceUrl)
      .then(function (localeResponse) {
        if (typeof localeResponse !== 'undefined') {
          PluginContext.data.locale = localeResponse.locale;
          PluginContext.data.localeResource = localeResponse.content;
        }
        SendRegisterEvent(widgetInstance, PluginContext);
      })
      .catch(function (error) {
        Logger.Info('Error occured while fetching I18NResource ', error);
        SendRegisterEvent(widgetInstance, PluginContext);
      });
  }
  function SendRegisterEvent(widgetInstance, contextObject) {
    if (!widgetInstance) {
      Logger.Info('Invalid WidgetInstance passed');
    }
    widgetInstance._hasLoaded = true;
    widgetInstance.activate();
    SendMessage(widgetInstance, contextObject);

    // In case Modal box
    if (widgetInstance.getLocation() === '__MODAL__') {
      setTimeout(function () { widgetInstance.SendEvent('modal.opened'); }, 0);
    }
    // Invoking the App Lifecycle event : Onload
    if (typeof widgetInstance.getProp('onload') === 'function') {
      setTimeout(widgetInstance.getProp('onload').bind(null, [widgetInstance.getConfig()]), widgetInstance.AppOnLoadDelay || 0);
    }

  }

  function HandleDeRegister(MessageEvent, data) {
    Context.DeleteWidgetInstance(data.uniqueID);
  }

  function HandleEventBind(MessageEvent, data) {
    var sourceWidgetID = data.uniqueID;
    var targetWidgetID = data.widgetID;
    var eventName = data.eventName;

    var targetWidget = ZApp.GetWidgetInstance(targetWidgetID);
    var eventObj;
    if (targetWidget && !targetWidget._bindedEvents[eventName]) {
      targetWidget._bindedEvents[eventName] = {};
    }
    eventObj = targetWidget._bindedEvents[eventName];
    eventObj[sourceWidgetID] = data.count;
  }
  function HandleCreateInstance(MessageEvent, data) {
    var uniqueID = data.uniqueID;
    var widgetInstance = ZApp.GetWidgetInstance(uniqueID);

    var modalProps = {
      extension_id: widgetInstance.getExtensionID(),
      extension_version: widgetInstance.getExtensionVersion()
    };

    for (var k in data.options) {
      if (data.options.hasOwnProperty(k)) {
        modalProps[k] = data.options[k];
      }
    }

    var eventObj = {
      type: '__EVENT_RESPONSE__',
      eventName: '__INVOKE_MODAL__',
      promiseID: data.promiseID,
      time: new Date().getTime()
    };
    try {
      var ModalRuntime = new ZWidgetRuntime(modalProps); // eslint-disable-line
      Context.RenderWidget(modalProps.location, ModalRuntime);
      eventObj.isSuccess = true;
      eventObj.data = ModalRuntime.getWidgetInfo();
    } catch (e) {
      eventObj.isSuccess = false;
      eventObj.data = e.message;
    }

    SendMessage(widgetInstance, eventObj);
  }
  function HandleWidgetInfo(MessageEvent, data) {
    var uniqueID = data.uniqueID;
    var widgetInstance = ZApp.GetWidgetInstance(uniqueID);
    var extensionID = widgetInstance.getExtensionID();
    var instanceList = [];
    var eventObj = {
      type: '__EVENT_RESPONSE__',
      eventName: '__WIDGETS_INFO__',
      promiseID: data.promiseID,
      time: new Date().getTime()
    };

    try {
      var allWidgets = ZApp.GetAllWidgetInstance();
      for (var k in allWidgets) {
        if (allWidgets.hasOwnProperty(k)) {
          var instance = allWidgets[k];
          if (
            instance &&
            instance.getUniqueID() !== uniqueID &&
            instance.getExtensionID() === extensionID &&
            instance.isActive()
          ) {
            instanceList.push(instance.getWidgetInfo());
          }
        }
      }
      eventObj.isSuccess = true;
      eventObj.data = instanceList;

    } catch (e) {
      Logger.Error(e.message);
      eventObj.isSuccess = false;
    }
    SendMessage(widgetInstance, eventObj);
  }
  function HandleEmitEvent(MessageEvent, data) {
    var targetWidgetID = data.widgetID;
    var eventName = data.eventName;

    var eventObj = {
      widgetID: targetWidgetID,
      data: data.data,
      eventName: eventName,
      type: '__EMIT__'
    };
    var targetWidget = ZApp.GetWidgetInstance(targetWidgetID);
    var bindedEvents = targetWidget._bindedEvents[eventName];
    var targetWidgetKeys = bindedEvents && Object.keys(targetWidget._bindedEvents[eventName]);
    if (Array.isArray(targetWidgetKeys)) {
      targetWidgetKeys.forEach(function (widgetID) {
        var widgetInstance = ZApp.GetWidgetInstance(widgetID);
        if (widgetInstance && widgetInstance.isActive()) {
          SendMessage(widgetInstance, eventObj);
        }
      });
    }
  }
  function HandleInternalEvent(MessageEvent, data) {
    var eventHandlerMap = {
      '__HTTP__': HandleHTTPRequest,
      '__WIDGETS_INFO__': HandleWidgetInfo,
      '__CREATE_INSTANCE__': HandleCreateInstance
    };
    var handleFn = eventHandlerMap[data.eventName];
    if (handleFn) {
      handleFn(MessageEvent, data);
      return;
    }

    // In case if its custome Event
    HandleCustomEvent(MessageEvent, data);
  }
  function HandleCustomEvent(MessageEvent, data) {
    var eventName = data.eventName;
    var promiseID = data.promiseID;
    var eventPayload = data.data;
    var uniqueID = data.uniqueID;
    var widgetInstance = Context.GetWidgetInstance(uniqueID);
    var appConfig = widgetInstance.getConfig();
    var extensionID = widgetInstance.getExtensionID();

    Logger.Info('Event from SDK => Eventname : ', eventName, ', Time : ', data.time, ', Eventpayload : ', eventPayload);

    var eventObj = {
      'data': eventPayload,
      'config': appConfig,
      'iframe': widgetInstance.getIFrame()
    };

    if (promiseID) {
      var promiseObject = {
        'resolve': PromiseCallback.bind(null, widgetInstance, promiseID, eventName, true),
        'reject': PromiseCallback.bind(null, widgetInstance, promiseID, eventName, false)
      };
      eventObj.promise = promiseObject;
    }
    if (typeof extensionID !== 'undefined') {
      eventObj.extension_id = extensionID; // TODO: Will be removed in future. Added for backward compatibility.
      eventObj.widgetID = uniqueID;
    }

    Context.TriggerEventListeners(eventName, eventObj);
  }

  function HandleEventResponse(MessageEvent, data) {
    var promiseID = data.promiseID;
    var eventPayload = data.data;
    if (PromiseQueue.hasOwnProperty(promiseID)) {
      PromiseQueue[promiseID].resolve(eventPayload);
      PromiseQueue[promiseID] = undefined; // eslint-disable-line
      delete PromiseQueue[promiseID];
    }
  }

  // TODO: Experiemental Currently. need to refactor.
  function PromiseCallback(widgetInstance, promiseID, eventName, isSuccess, response) {
    var eventObj = {
      type: '__EVENT_RESPONSE__',
      eventName: 'eventName',
      promiseID: promiseID,
      time: new Date().getTime(),
      data: response,
      isSuccess: isSuccess
    };

    SendMessage(widgetInstance, eventObj);
  }
  function HandleHTTPRequest(MessageEvent, data) {
    var options = data.options;
    var promiseID = data.promiseID;
    var uniqueID = data.uniqueID;

    var promiseObj = {
      'resolve': NotifyRequestProcessedResult.bind(null, uniqueID, MessageEvent.origin, promiseID, true),
      'reject': NotifyRequestProcessedResult.bind(null, uniqueID, MessageEvent.origin, promiseID, false)
    };
    Context.ProcessGetRequest(promiseID, uniqueID, options, promiseObj);
  }
  function NotifyRequestProcessedResult(uniqueID, windowOrigin, promiseID, isSuccess, response) {

    var sourceWindow = ZApp.GetWidgetInstance(uniqueID).getWindow();
    var eventObj = {
      type: '__EVENT_RESPONSE__', // NO I18N
      eventName: '__HTTP__',
      data: response,
      time: new Date().getTime(),
      promiseID: promiseID,
      isSuccess: isSuccess
    };
    setTimeout(function () { sourceWindow.postMessage(eventObj, windowOrigin) }, 0); // eslint-disable-line semi
  }

  // Util
  function getURLWithPath(url) {
    var a = document.createElement('a');
    a.setAttribute('href', url);
    return a.protocol + '//' + a.host + a.pathname;
  }

  MessageManager.Init = Init;
  MessageManager.SendMessage = SendMessage;
  MessageManager.BroadcastEvent = BroadcastEvent;
  MessageManager.WidgetLoadHandler = WidgetLoadHandler;

  return MessageManager;

})(window.MessageManager || {});

// $Id$
var DefaultRenderHandlers = (function (DefaultRenderHandlers) { // eslint-disable-line 

  function WidgetHandler(appConfig) {

    var appLocation = appConfig.location;
    var appURL = appConfig.resolvedURL;
    var IFrameComponent;

    if (appLocation && typeof appLocation === 'string') {
      appLocation = IFrameComponent = document.getElementById(appLocation); // No I18N
    }

    if (appLocation instanceof HTMLIFrameElement) {
      IFrameComponent = appLocation;
      IFrameComponent.setAttribute('src', appURL);
    }

    return IFrameComponent;
  }

  DefaultRenderHandlers.WidgetHandler = WidgetHandler;

  return DefaultRenderHandlers;

})(window.DefaultRenderHandlers || {});


// $Id$
var ZApp = (function (Framework) {
  Framework.isDevMode = () => {
    return localStorage && !!localStorage.getItem('isDevMode');
  }

  var Logger = ZAppUtil.getLogger(); // Logging instance for Core Framework
  try {

    var REGISTER_CHECK_TIMEOUT = 15 * 1000; // Seconds to schedule for check
    // var CLEAN_RUNTIME_TIMEOUT = 2 * 1000; // Seconds to schedule for invalid runtime clearance
    var TLD = window.location.origin.split(".").pop().toLowerCase(); // Top Level Domain
    
    var origin = window.location.origin.toLowerCase();
    var dCType = "US";
    if (TLD === "cn") {
      dCType = "CN";
      TLD = 'com.cn';
    } else if (TLD === "au") {
      dCType = "AU";
      TLD = 'com.au';
    } else if (TLD === "eu") {
      dCType = "EU";
    } else if (origin.endsWith("hq.in")) {
      dCType = "INEC";
      TLD = 'hq.in';
    } else if (TLD === "in") {
      dCType = "IN";
    } else if (TLD === "jp") {
      dCType = "JP";
    } else if (TLD === "ca") {
      dCType = "CA";
    } else if (TLD === "sa") {
      dCType = "SA";
    } else if (TLD === "ae") {
      dCType = "AE";
    } else if (TLD === "sg") {
      dCType = "SG";
    }

    var
      isInit = false,
      _isDevMode = false,
      MetaStore = {},
      serverConfig = {
        devHost: {
          host: '127.0.0.1',
          port: '5000',
          path: ''
        },
        zappsHost: {
          host: dCType === "INEC" ? '{{zappid}}.zappsusercontent' + TLD : '{{zappid}}.zappsusercontent.' + TLD,
          port: '',
          path: '/appfiles/{{zappid}}/{{version}}/{{hashkey}}'
        }
      },
      preRenderApp, postRenderApp,

      defaultLocale,
      ExtensionData = {}, // Extension Modules config data - Widgets, Buttons, Webtabs
      WidgetRuntimes = {}, // All the individual widget runtimes

      RenderHandlers, // Function which handles the render of the Widgets
      RequestHandler, // Function which handles API Request handling of the app.

      FrameworkContext = {}; // Context Object which is passed around Individual modules

    function isInitialized() {
      return isInit;
    }

    function GetDCType() {
      return dCType;
    }

    function GetWidgetInstance(uniqueID) {
      return WidgetRuntimes[uniqueID];
    }

    function GetAllWidgetInstance() {
      return WidgetRuntimes;
    }

    function DeleteWidgetInstance(uniqueID, forceDelete) {
      var IFrameEle = document.getElementById(uniqueID);

      if (forceDelete) {
        WidgetRuntimes[uniqueID] = undefined; // eslint-disable-line no-undefined
        delete WidgetRuntimes[uniqueID];
        if (IFrameEle) {
          IFrameEle.parentElement.removeChild(IFrameEle);
        }
      } else if (!IFrameEle) {
        WidgetRuntimes[uniqueID] = undefined; // eslint-disable-line no-undefined
        delete WidgetRuntimes[uniqueID];
      }
    }

    function RenderWidgets(data, metaData) {
      if (Array.isArray(data)) {
        for (var i = 0; i < data.length; i++) {

          var widgetProps = data[i];
          var locationID = widgetProps.location;
          Logger.Info('Render Apps with LocationID => ', locationID);
          MetaStore[locationID] = metaData;
          try {
            var widgetInstance = new ZWidgetRuntime(widgetProps); // eslint-disable-line no-undef

            // TODO: have to handle forceRender, which in case will render the app forcefully.
            RenderWidget(locationID, widgetInstance);
          } catch (e) {
            Logger.Error('Exception while Rendering Widget ==> ', e);
          }
        }
      } else {
        Logger.Error('Expected array of widgets ==> ');
      }
    }

    // Private API to render passed in Widget configuration
    function RenderWidget(renderLocation, widgetInstance) {

      try {
        var uniqueID = generateSecretKey();
        widgetInstance._uniqueID = uniqueID;
        widgetInstance._resolvedURL = getResolvedAppURL(widgetInstance);

        executeCallback(preRenderApp, widgetInstance);
        let widgetLoadFunc = MessageManager.WidgetLoadHandler.bind(null, widgetInstance)
        widgetInstance.handleLoad = widgetLoadFunc;
        var windowRef = RenderHandlers.WidgetHandler(renderLocation, widgetInstance);

        if (windowRef instanceof HTMLIFrameElement) {
          windowRef.setAttribute('data-location', renderLocation);
          windowRef.setAttribute('id', uniqueID);
          WidgetRuntimes[uniqueID] = widgetInstance;

          // Listening for OnUnload event on the IFrame
          var iframeElement = document.getElementById(uniqueID);
          if (iframeElement !== null) {
            iframeElement.addEventListener('DOMNodeRemovedFromDocument', function () {
              WidgetRuntimes[uniqueID] = undefined; // eslint-disable-line no-undefined
              delete WidgetRuntimes[uniqueID];
            });
          }

          // Listening for OnLoad event on the IFrame
          windowRef.onload = widgetLoadFunc;
          ScheduleRegisterCheck(uniqueID);

          executeCallback(postRenderApp, widgetInstance);
        } else {
          Logger.Info('[windowRef] is not an IFrameElement.' + renderLocation + ' , ' + widgetInstance.getURL());
        }
      } catch (e) {
        throw e;
      }

      return widgetInstance;
    }

    function ScheduleRegisterCheck(widgetID) {
      setTimeout(function () {
        var widgetInstance = WidgetRuntimes[widgetID];
        if (widgetInstance && widgetInstance._hasLoaded && !widgetInstance._hasRegistered) {
          WidgetRuntimes[widgetID] = undefined;
          delete WidgetRuntimes[widgetID];
        }
      }, REGISTER_CHECK_TIMEOUT);
    }
    function isDevMode() {
      return _isDevMode;
    }

    function executeCallback(fn, appInstance) {
      if (fn && typeof fn === 'function') {
        return fn(appInstance);
      }
    }
    function getResolvedAppURL(widgetConfig) {
      var widgetURL = widgetConfig.getURL();

      var resolvedURL = '';

      var serviceOrigin = ZAppUtil.getURLOrigin();
      var frameOrigin = widgetConfig.getFrameOrigin() || serviceOrigin; 
      var resolvedURL = "";
      var qpMap = {
        'serviceOrigin': encodeURIComponent(serviceOrigin),
        'isDevMode': isDevMode(),
        'frameorigin' : encodeURIComponent(frameOrigin)
      };
      var QPString = ZAppUtil.constructQueryParamsString(qpMap);

      if (ZAppUtil.isURL(widgetURL)) { // If the URL is external (absolute) URL.
        resolvedURL = widgetURL;
      }

      var index = resolvedURL.indexOf("?");
      if (index === -1) {
        var hashIndex = resolvedURL.indexOf("#");
        if (hashIndex === -1) {
          resolvedURL += '?' + QPString;
        } else {
          resolvedURL = resolvedURL.slice(0, hashIndex) + '?' + QPString + resolvedURL.slice(hashIndex);
        }
      } else {
        index += 1;
        resolvedURL = resolvedURL.slice(0, index) + QPString + '&' + resolvedURL.slice(index);
      }
      return resolvedURL;
    }

    // Event Operations
    var _EventListeners = {};
    function AttachEventListener(eventName, fn) {

      if (!_EventListeners.hasOwnProperty(eventName)) {
        _EventListeners[eventName] = [];
      }
      _EventListeners[eventName].push(fn);
    }

    function GetWidgetsByEvent(eventName) {
      var widgetInstances = GetAllWidgetInstance();
      var eventWidget = [];
      for (var key in widgetInstances) {
        if (widgetInstances.hasOwnProperty(key)) {
          var events = widgetInstances[key]._bindedEvents;
          if (events[eventName] !== undefined) {
            eventWidget.push(key);
          }
        }
      }
      return eventWidget;
    }

    // Meta operations
    function GetMeta(location) {
      return MetaStore[location];
    }
    // Event operations
    function BroadcastEvent(eventName, payload, isPromise) {
      return MessageManager.BroadcastEvent(eventName, payload, isPromise);
    }

    function ProcessGetRequest(promiseId, uniqueID, options, promiseObj) {
      var uniqueID = uniqueID;
      var widgetInstance = GetWidgetInstance(uniqueID);
      var extensionID = widgetInstance.getExtensionID();

      var eventObj = {
        'data': {
          'value': options
        },
        'iframe': widgetInstance.getIFrame(),
        'promise': promiseObj
      };

      if (typeof extensionID !== 'undefined') {
        eventObj.extension_id = extensionID;
        eventObj.widgetID = uniqueID;
      }

      try {

        Logger.Info('ProcessGetRequest : PromiseID: ', promiseId, ', Options: ', options);

        options.contentType = options && options.contentType ? options.contentType : 'application/text';
        options.dataType = options && options.dataType ? options.dataType : 'text';
        // options.widgetID = uniqueID;

        if (typeof RequestHandler !== 'function') { throw new Error('Provide Request handler implementation in the Bootstrap.'); }

        RequestHandler(eventObj);

      } catch (e) {
        Logger.Error('ProcessGetRequest : Error => ', e); // NO I18N
      }
    }

    function TriggerEventListeners(eventName, evt) {
      var eventListeners = _EventListeners[eventName];
      if (Array.isArray(eventListeners)) {
        for (var i = 0; i < eventListeners.length; i++) {
          eventListeners[i](evt);
        }
      }
    }

    function FetchLocaleResource(localeResourceURL, locale, defaultLocaleResourceUrl) {
      return new Promise(function (resolve, reject) {
        FetchResource(localeResourceURL, locale).then(function (localeResponse) {
          resolve(localeResponse);
        }).catch(function () {
          if (locale !== defaultLocale) {
            FetchResource(defaultLocaleResourceUrl, defaultLocale).then(function (localeResponse) {
              resolve(localeResponse);
            }).catch(function (e) {
              reject(e);
            });
          } else {
            reject();
          }
        });
      });
    }

    function FetchResource(url, locale) {
      return new Promise(function (resolve, reject) {
        try {
          var XHR = new XMLHttpRequest();
          XHR.onreadystatechange = function () {
            if (XHR.readyState === XMLHttpRequest.DONE && XHR.status === 200) {
              var responseJSON;
              try {
                responseJSON = JSON.parse(XHR.responseText);
              } catch (e) { reject(e); }
              resolve({ locale: locale, content: responseJSON });
            } else if (XHR.readyState === XMLHttpRequest.DONE) {
              reject(XHR.status);
            }
          };
          XHR.open('GET', url);
          XHR.send();
        } catch (e) {
          reject();
        }
      });
    }

    // Framework Initializer
    function Bootstrap(config) {

      return new Promise(function (resolve, reject) {

        var MessageHandler;
        try {
          if (!config || typeof config !== 'object') {
            throw new Error('Invalid configurations passed to Bootstrap.'); // NO I18N
          }

          RenderHandlers = config.RenderHandlers || DefaultRenderHandlers;
          RequestHandler = config.RequestHandler;

          preRenderApp = config.preRenderApp;
          postRenderApp = config.postRenderApp;

          _isDevMode = Boolean(config.isDevMode);

          // Pre filling defaults
          for (var k in config.serverConfig) {
            if (serverConfig.hasOwnProperty(k)) {
              serverConfig[k] = config.serverConfig[k];
            }
          }

          defaultLocale = config.defaultLocale || 'en';

          FrameworkContext.defaultLocale = defaultLocale;
          FrameworkContext.ProcessGetRequest = ProcessGetRequest;
          FrameworkContext.Logger = Logger;
          FrameworkContext.RenderWidget = RenderWidget;
          FrameworkContext.GetWidgetInstance = GetWidgetInstance;
          FrameworkContext.GetAllWidgetInstance = GetAllWidgetInstance;
          FrameworkContext.DeleteWidgetInstance = DeleteWidgetInstance;
          FrameworkContext.dcType = dCType;
          FrameworkContext.GetMeta = GetMeta;

          FrameworkContext.TriggerEventListeners = TriggerEventListeners;

          FrameworkContext.FetchLocaleResource = FetchLocaleResource;

          // Attaching event handlers
          var EventListeners = config.EventListeners || {};
          for (k in EventListeners) {
            if (EventListeners.hasOwnProperty(k)) {
              AttachEventListener(k, EventListeners[k]);
            }
          }

          MessageHandler = MessageManager.Init(FrameworkContext);
          window.addEventListener('message', MessageHandler);
          isInit = true;

          // CleanRuntimeScheduler();

          Logger.Info('Running in Dev Mode : ', isDevMode()); // No I18N

          resolve(Framework);
        } catch (e) {
          reject(e.message);
        }
      });
    }

    // Utils
    function generateSecretKey() {
      var d = new Date().getTime();
      var secretKey = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
        var r = (d + Math.random() * 16) % 16 | 0;
        d = Math.floor(d / 16);
        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
      });
      return secretKey;
    }

    // Public API's
    Framework.Bootstrap = Bootstrap;
    Framework.isInitialized = isInitialized;

    // Rendering widgets and other types
    Framework.RenderWidgets = RenderWidgets;

    // Getting widgets reference
    Framework.GetWidgetInstance = GetWidgetInstance;
    Framework.GetWidgetsByEvent = GetWidgetsByEvent;
    Framework.GetAllWidgetInstance = GetAllWidgetInstance;
    Framework.DeleteWidgetInstance = DeleteWidgetInstance;

    Framework.BroadcastEvent = BroadcastEvent;
    Framework.GetDCType = GetDCType;

    // Returning public API
    return Framework;

  } catch (e) {
    Logger.Error('Error Occured ', e.message);
  }

})(window.ZApp || {});