@zohodesk/platform-middleware/lib/index.js

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

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.platformMiddleware = void 0;

var _utils = require("./utils");

var _loadAssets = require("./loadAssets");

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) {
      appEventListeners[listenerKey] = function (event) {
        listenerFunc = listeners[listenerKey];

        if (listenerFunc && typeof listenerFunc == 'function') {
          listenerFunc((0, _utils.handleEvent)({
            event: event,
            getState: getState,
            dispatch: dispatch,
            dataList: dataList
          }));
        }
      };
    });

    if (typeof platformConfig !== 'undefined') {
      var existingListeners = platformConfig.eventHandlers || {};
      appEventListeners = Object.assign({}, existingListeners, appEventListeners);
    }

    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 = (0, _utils.validateConfig)(config),
        isConfigValid = _validateConfig.isConfigValid,
        errorMsg = _validateConfig.errorMsg;

    if (!isConfigValid) {
      throw errorMsg;
    }

    config.store = {
      dispatch: dispatch,
      getState: getState
    };
    configObj = config;
    window.platformConfig = {
      overrideInvokeMethodToCommonPattern: config.overrideInvokeMethodToCommonPattern,
      eventListenerName: config.eventListenerName || 'DESK_EVENT',
      eventHandlers: bindEventListeners({
        listeners: config.eventListeners,
        dispatch: dispatch,
        getState: getState,
        dataList: config.dataList
      })
    };

    if (config.featureFlags.isMarketplaceNeeded) {
      (0, _loadAssets.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((0, _utils.handleEvent)({
                event: event,
                getState: getState,
                dispatch: dispatch,
                promise: promise
              }));
            }
          });
        }
      });
    }

    (0, _loadAssets.loadInProductSDKAssets)({
      globalNameSpace: config.globalNameSpace,
      cb: function cb() {
        config.postProductSDKAssetsFetch();
      }
    });
    return function (next) {
      return function (action) {
        if (action.type === config.renderWidgetActionConstant) {
          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' && (0, _utils.isEventNeededToBroadCast)(event)) {
          var prevState = getState();

          var getPrevState = function getPrevState() {
            return prevState;
          };

          var nextAction = next(action);

          if (config.isPromiseBasedAction) {
            nextAction.then(function () {
              (0, _utils.zAppBroadcastEvent)({
                event: event,
                getState: getState,
                dispatch: dispatch,
                action: action,
                getPrevState: getPrevState
              });
            })["catch"](function (err) {
              //Console.log -> Tarcking Error for future purpose.
              console.log(err);
            });
          } else {
            (0, _utils.zAppBroadcastEvent)({
              event: event,
              getState: getState,
              dispatch: dispatch,
              action: action,
              getPrevState: getPrevState
            });
          }

          return nextAction;
        } else if (hook && hook.type === 'hook' && (0, _utils.isEventNeededToBroadCast)(hook)) {
          return (0, _utils.zAppHookEvent)({
            hook: hook,
            getState: getState,
            dispatch: dispatch,
            action: action,
            notifyHandler: function notifyHandler(data) {
              data = Object.assign(data, {
                dispatch: dispatch,
                getState: getState
              });
              config.marketplace.notifyHandler(data);
            }
          }).then(function (res) {
            return next(action);
          });
        } else {
          return next(action);
        }
      };
    };
  };
};

exports.platformMiddleware = platformMiddleware;