@zohodesk/platform-middleware_poc/es/index.js

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

import _Object$keys from 'babel-runtime/core-js/object/keys';
import { validateConfig, zAppBroadcastEvent, zAppHookEvent, handleEvent, isEventNeededToBroadCast } from './utils';
import { loadSigmaAssests, loadInProductSDKAssets } from './loadAssets';

import WidgetProvider, { WidgetContext } from './providers/WidgetProvider';
import { WidgetsReducer } from './reducers/widgetsReducer';
import { fetchWidgetsSuccess, renderWidgetsAction } from './actions/widgetsActions';

var configObj = {};

// let sampleConfig = {
//   "marketplace": {
//     "renderHandler": "<rednerHandler>",
//     "postAssetsFetch": "<postAssetsFetchHandler>",
//     "isDevMode": "<isDevModeHandler>",
//     "requestHandler": "<requestHandler>"
//   },
//   "locale": "<locale>",
//   "eventListeners": "<eventListenersHandlerObj> {DESK_EVENT: 'desk_event Handler', DESK_EVENT_V2: 'desk_event_v2 handler'}"
// }

function bindEventListeners(listnerObj) {
  var listeners = listnerObj.listeners,
      dataList = listnerObj.dataList,
      getState = listnerObj.getState,
      dispatch = listnerObj.dispatch;

  try {
    var listenerFunc = null,
        appEventListeners = {};
    _Object$keys(listeners).forEach(function (listenerKey) {
      listenerFunc = listeners[listenerKey];
      if (listenerFunc && typeof listenerFunc == 'function') {
        appEventListeners[listenerKey] = function (event) {
          listenerFunc(handleEvent({ event: event, getState: getState, dispatch: dispatch, dataList: dataList }));
        };
      }
    });
    return appEventListeners;
  } catch (error) {
    throw 'Listeners expect an JSON Object...';
  }
}

var platformMiddleware = function platformMiddleware(config) {
  return function (_ref) {
    var dispatch = _ref.dispatch,
        getState = _ref.getState;

    var _validateConfig = validateConfig(config),
        isConfigValid = _validateConfig.isConfigValid,
        errorMsg = _validateConfig.errorMsg;

    if (!isConfigValid) {
      throw errorMsg;
    }

    config.store = { dispatch: dispatch, getState: getState };
    configObj = config;

    window.platformConfig = {
      eventHandlers: bindEventListeners({ listeners: config.eventListeners, dispatch: dispatch, getState: getState, dataList: config.dataList })
    };

    if (config.featureFlags.isMarketplaceNeeded) {
      loadSigmaAssests(function () {
        if (typeof ZApp !== 'undefined') {
          config.marketplace.postAssestsFetch({ dispatch: dispatch, getState: getState });

          /* Bootstraping the ZApp Framework */
          ZApp.Bootstrap({
            RenderHandlers: config.marketplace.renderHandler(dispatch, getState),
            isDevMode: config.marketplace.isDevMode(),
            EventListeners: bindEventListeners({ listeners: config.eventListeners, dispatch: dispatch, getState: getState, dataList: config.dataList }),
            defaultLocale: config.locale || 'en',
            RequestHandler: function RequestHandler(event, promise) {
              return config.marketplace.requestHandler(handleEvent({ event: event, getState: getState, dispatch: dispatch, promise: promise }));
            }
          });
        }
      });
    }

    loadInProductSDKAssets({ globalNameSpace: config.globalNameSpace, cb: function cb() {} });

    return function (next) {
      return function (action) {

        if (action.type === 'RENDER_WIDGETS_NEW') {
          var widgets = Array.isArray(action.data) ? action.data : [action.data];
          ZApp.RenderWidgets(widgets);
        }

        var eventList = config.events || {};
        var event = eventList[action.type];
        var hook = action.types && eventList[action.types[0]];
        /* Added for the URL CHANGE action gets dispatched twice */
        var isValidEvent = true;
        if (event && event.filter) {
          isValidEvent = event.filter(action);
        }
        if (isValidEvent && event && event.type === 'event' && isEventNeededToBroadCast(event)) {
          var nextAction = next(action);
          zAppBroadcastEvent({ event: event, getState: getState, dispatch: dispatch, action: action });
          return nextAction;
        } else if (hook && hook.type === 'hook' && isEventNeededToBroadCast(hook)) {
          return zAppHookEvent({
            hook: hook, getState: getState, dispatch: dispatch, action: action, notifyHandler: function notifyHandler(data) {
              config.marketplace.notifyHandler(data);
            }
          }).then(function (res) {
            return next(action);
          }).catch(function (err) {
            return next(action);
          });
        } else {
          return next(action);
        }
      };
    };
  };
};

export { platformMiddleware, WidgetProvider, WidgetContext, WidgetsReducer, fetchWidgetsSuccess, renderWidgetsAction };