@instructure/quiz-core 17.19.2 → 17.19.3-rc.0

package/lib/common/components/shared/spinner/Spinner.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.QuizzesSpinner = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _uiSpinner = require("@instructure/ui-spinner");
+
+var _uiHeading = require("@instructure/ui-heading");
+
+var _uiA11yContent = require("@instructure/ui-a11y-content");
+
+var _uiThemeable = require("@instructure/ui-themeable");
+
+var _formatMessage = _interopRequireDefault(require("@instructure/quiz-i18n/es/format-message"));
+
+var _theme = _interopRequireDefault(require("./theme.js"));
+
+var _dec, _class, _class2, _temp;
+
+var styles = {
+  componentId: 'ebGcj',
+  template: function template(theme) {
+    return "\n\n.ebGcj_gasz{align-items:center;display:inline-flex;flex:1 1 auto;height:100%;justify-content:center;min-height:500px;width:100%}\n\n:root .ebGcj_gasz,_:-ms-fullscreen{height:10rem}\n\n.ebGcj_bZBM .ebGcj_qrQc{flex:1 1 auto}\n\n.ebGcj_fBqo{font-size:".concat(theme.mainTextFontSize || 'inherit', "}");
+  },
+  'wrapper': 'ebGcj_gasz',
+  'left': 'ebGcj_bZBM',
+  'right': 'ebGcj_qrQc',
+  'mainText': 'ebGcj_fBqo'
+};
+var QuizzesSpinner = (_dec = (0, _uiThemeable.themeable)(_theme.default, styles), _dec(_class = (_temp = _class2 = /*#__PURE__*/function (_Component) {
+  (0, _inherits2.default)(QuizzesSpinner, _Component);
+
+  var _super = (0, _createSuper2.default)(QuizzesSpinner);
+
+  function QuizzesSpinner() {
+    (0, _classCallCheck2.default)(this, QuizzesSpinner);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(QuizzesSpinner, [{
+    key: "mainText",
+    value: function mainText() {
+      return this.props.mainText || (0, _formatMessage.default)('Loading...');
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: styles.wrapper
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: styles.left
+      }, /*#__PURE__*/_react.default.createElement(_uiSpinner.Spinner, {
+        renderTitle: this.mainText(),
+        size: "large"
+      })), /*#__PURE__*/_react.default.createElement("div", {
+        className: styles.right
+      }, /*#__PURE__*/_react.default.createElement(_uiA11yContent.PresentationContent, null, /*#__PURE__*/_react.default.createElement(_uiHeading.Heading, {
+        level: "h2",
+        as: "h1"
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        className: styles.mainText
+      }, this.mainText())))));
+    }
+  }]);
+  QuizzesSpinner.displayName = "QuizzesSpinner";
+  return QuizzesSpinner;
+}(_react.Component), _class2.propTypes = {
+  mainText: _propTypes.default.string
+}, _class2.defaultProps = {
+  mainText: null
+}, _temp)) || _class);
+exports.QuizzesSpinner = QuizzesSpinner;
+var _default = QuizzesSpinner;
+exports.default = _default;

package/lib/common/components/shared/spinner/theme.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generator;
+
+function generator(_ref) {
+  var typography = _ref.typography;
+  return {
+    mainTextFontSize: typography.fontSizeXXLarge
+  };
+}

package/lib/common/kinesis/QuizEventsLogger.js

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.fetchLogger = exports.QuizEventsLogger = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _construct2 = _interopRequireDefault(require("@babel/runtime/helpers/construct"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _StreamQueue = _interopRequireDefault(require("./StreamQueue.js"));
+
+var _client = _interopRequireDefault(require("./client.js"));
+
+var KINESIS_REFRESH_THRESHOLD = 600000; // 10 minutes
+
+var QuizEventsLogger = /*#__PURE__*/function () {
+  function QuizEventsLogger() {
+    (0, _classCallCheck2.default)(this, QuizEventsLogger);
+
+    for (var _len = arguments.length, streamQueues = new Array(_len), _key = 0; _key < _len; _key++) {
+      streamQueues[_key] = arguments[_key];
+    }
+
+    this.streamQueues = streamQueues;
+    this.eventTypeDict = Object.create(null);
+    this.builtAt = Date.now();
+  }
+
+  (0, _createClass2.default)(QuizEventsLogger, [{
+    key: "needsRefresh",
+    value: function needsRefresh() {
+      var threshold = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KINESIS_REFRESH_THRESHOLD;
+      return Date.now() - this.builtAt > threshold;
+    }
+  }, {
+    key: "queuesForEventType",
+    value: function queuesForEventType(eventType) {
+      var queues = this.eventTypeDict[eventType];
+      if (queues !== void 0) return queues;
+      queues = this.streamQueues.filter(function (queue) {
+        return Object.keys(queue.config.eventTypes).includes(eventType);
+      });
+
+      if (!queues.length) {
+        throw new Error("Unable to locate a valid StreamQueue for event type ".concat(eventType));
+      }
+
+      this.eventTypeDict[eventType] = queues;
+      return queues;
+    }
+  }, {
+    key: "enqueueEvent",
+    value: function enqueueEvent(data) {
+      var eventType = data.eventType;
+      this.queuesForEventType(eventType).forEach(function (queue) {
+        queue.push(eventType, data);
+      });
+    }
+  }]);
+  return QuizEventsLogger;
+}();
+
+exports.QuizEventsLogger = QuizEventsLogger;
+var loggers = {};
+var loggerHandlers = {};
+
+var getLogger = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(quizSessionId) {
+    var kinesisConfigGetter,
+        logger,
+        handler,
+        kinesisConfig,
+        kinesisClient,
+        streamQueues,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            kinesisConfigGetter = _args.length > 1 && _args[1] !== void 0 ? _args[1] : _client.default;
+            logger = loggers[quizSessionId];
+            handler = loggerHandlers[quizSessionId];
+            loggerHandlers[quizSessionId] = null;
+
+            if (!(!logger || logger.needsRefresh())) {
+              _context.next = 12;
+              break;
+            }
+
+            _context.next = 7;
+            return handler || kinesisConfigGetter(quizSessionId);
+
+          case 7:
+            kinesisConfig = _context.sent;
+            kinesisClient = kinesisConfig.client; // Set up the StreamQueues for possible events
+
+            streamQueues = kinesisConfig.streamConfigs.map(function (config) {
+              return new _StreamQueue.default({
+                config: config,
+                kinesis: kinesisClient
+              });
+            });
+            logger = (0, _construct2.default)(QuizEventsLogger, (0, _toConsumableArray2.default)(streamQueues)); // TODO: This appears to work in production, but fixing this eslint violation causes tests to fail.
+            // We should probably figure out why.
+
+            /* eslint-disable-next-line require-atomic-updates */
+
+            loggers[quizSessionId] = logger;
+
+          case 12:
+            return _context.abrupt("return", logger);
+
+          case 13:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getLogger(_x) {
+    return _ref.apply(this, arguments);
+  };
+}(); // preliminary fetch kinesis credentials
+// This method is called before submission, to send kinesis refreshing requests
+// before scope is switched to quiz.results, with which kinesis refreshing is prohibited
+
+
+var fetchLogger = function fetchLogger(quizSessionId) {
+  var kinesisConfigGetter = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _client.default;
+  var logger = loggers[quizSessionId]; // expires 1 second earlier to protect processing edge case
+
+  if (!logger || logger.needsRefresh(KINESIS_REFRESH_THRESHOLD - 1000)) {
+    // send kinesis refreshing request before submission
+    loggerHandlers[quizSessionId] = kinesisConfigGetter(quizSessionId);
+  }
+
+  return loggerHandlers;
+};
+
+exports.fetchLogger = fetchLogger;
+var _default = getLogger;
+exports.default = _default;

package/lib/common/kinesis/StreamQueue.js

@@ -0,0 +1,141 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var ERROR_STATE = 'error';
+var WAITING_STATE = 'waiting';
+var SENDING_STATE = 'sending';
+var SENT_STATE = 'sent';
+
+var StreamQueue = /*#__PURE__*/function () {
+  function StreamQueue(_ref) {
+    var config = _ref.config,
+        kinesis = _ref.kinesis;
+    (0, _classCallCheck2.default)(this, StreamQueue);
+    this.config = config;
+    this.kinesis = kinesis;
+    this.timeout = null;
+    this.pageQueue = [];
+
+    this._addPage();
+
+    this._scheduleSendRecords();
+  }
+
+  (0, _createClass2.default)(StreamQueue, [{
+    key: "push",
+    value: function push(eventType, data) {
+      var event = this._buildRecord(eventType, data);
+
+      if (this._canEnqueueToPage(this._lastPage())) {
+        this._lastPage().data.push(event);
+
+        this._sendIfLastPageFull();
+      } else {
+        this._sendRecords();
+
+        this._addPage();
+
+        this._lastPage().data.push(event);
+      }
+
+      return true;
+    } // =============
+    // PRIVATE
+    // =============
+
+  }, {
+    key: "_scheduleSendRecords",
+    value: function _scheduleSendRecords() {
+      clearTimeout(this.timeout);
+      this.timeout = setTimeout(this._sendRecords.bind(this), this.config.sendRecordsTimeout);
+    }
+  }, {
+    key: "_sendIfLastPageFull",
+    value: function _sendIfLastPageFull() {
+      if (this._lastPage().data.length === this.config.maxPageSize) {
+        this._sendRecords();
+
+        this._addPage();
+      }
+    }
+  }, {
+    key: "_canEnqueueToPage",
+    value: function _canEnqueueToPage(page) {
+      return page.status === WAITING_STATE && page.data.length < this.config.maxPageSize;
+    }
+  }, {
+    key: "_lastPage",
+    value: function _lastPage() {
+      return this.pageQueue[this.pageQueue.length - 1];
+    }
+  }, {
+    key: "_addPage",
+    value: function _addPage() {
+      this.pageQueue.push({
+        status: WAITING_STATE,
+        data: []
+      });
+    }
+  }, {
+    key: "_buildRecord",
+    value: function _buildRecord(eventType, data) {
+      var builder = this.config.eventTypes[eventType];
+
+      if (typeof builder !== 'function') {
+        throw new Error("Unable to retrieve a builder function for event type: ".concat(eventType));
+      }
+
+      try {
+        return builder(data);
+      } catch (e) {
+        throw new Error("Unable to build a record for data: ".concat(JSON.stringify(data), "\n").concat(e));
+      }
+    }
+  }, {
+    key: "_canSendPage",
+    value: function _canSendPage(page) {
+      return (page.status === WAITING_STATE || page.status === ERROR_STATE) && page.data.length;
+    }
+  }, {
+    key: "_sendRecords",
+    value: function _sendRecords() {
+      var _this = this;
+
+      this.pageQueue.forEach(function (page, i) {
+        if (!_this._canSendPage(page)) return;
+        var params = {
+          Records: page.data,
+          StreamName: _this.config.stream
+        };
+        _this.pageQueue[i].status = SENDING_STATE;
+
+        _this.kinesis.putRecords(params, function (err, data) {
+          if (err) {
+            _this.pageQueue[i].status = ERROR_STATE; // eslint-disable-next-line no-console
+
+            console.error("KINESIS STREAM ".concat(_this.config.stream, " ERROR: "), err);
+          } else {
+            _this.pageQueue[i].status = SENT_STATE; // eslint-disable-next-line no-console
+
+            console.log("KINESIS STREAM ".concat(_this.config.stream, " STATUS: "), "".concat(page.data.length, " items sent successfully"));
+          }
+        });
+      });
+
+      this._scheduleSendRecords();
+    }
+  }]);
+  return StreamQueue;
+}();
+
+exports.default = StreamQueue;

package/lib/common/kinesis/client.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.buildCredentials = exports.buildKinesisClient = exports.buildKinesisConfiguration = void 0;
+
+var _global = require("aws-sdk/global");
+
+var _kinesis = _interopRequireDefault(require("aws-sdk/clients/kinesis"));
+
+var _config = require("./config.js");
+
+var _Fetcher = _interopRequireDefault(require("../util/Fetcher.js"));
+
+var buildKinesisConfiguration = function buildKinesisConfiguration(_ref) {
+  var configuration = _ref.configuration,
+      credentials = _ref.credentials;
+  var serverTime = configuration.server_time;
+  if (serverTime) _global.config.systemClockOffset = Date.parse(serverTime) - Date.now();
+  return {
+    client: buildKinesisClient(configuration, credentials),
+    streamConfigs: (0, _config.assembleStreamConfigs)(configuration)
+  };
+};
+
+exports.buildKinesisConfiguration = buildKinesisConfiguration;
+
+var buildKinesisClient = function buildKinesisClient(configuration, credentials) {
+  var kinesisConfig = Object.assign({}, (0, _config.assembleKinesisConfig)(configuration.client_configuration), {
+    credentials: credentials
+  });
+  return new _kinesis.default(kinesisConfig);
+};
+
+exports.buildKinesisClient = buildKinesisClient;
+
+var buildCredentials = function buildCredentials(credentialParams) {
+  var creds = new _global.Credentials(credentialParams.access_key_id, credentialParams.secret_access_key, credentialParams.session_token // credentialParams
+  );
+  creds.expireTime = Date.parse(credentialParams.expiration);
+  return creds;
+};
+
+exports.buildCredentials = buildCredentials;
+
+var getKinesisConfig = function getKinesisConfig(quizSessionId) {
+  var fetcher = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : new _Fetcher.default();
+  return new Promise(function (resolve, reject) {
+    var url = "/api/quiz_sessions/".concat(quizSessionId, "/kinesis_credentials");
+    fetcher.post(url).then(function (configuration) {
+      var config = buildKinesisConfiguration({
+        configuration: configuration,
+        credentials: buildCredentials(configuration.credentials)
+      });
+      resolve(config);
+    }).then(function (err) {
+      return reject(err);
+    });
+  });
+};
+
+var _default = getKinesisConfig;
+exports.default = _default;

package/lib/common/kinesis/config.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assembleStreamConfigs = exports.eventStreamConfig = exports.responseStreamConfig = exports.assembleKinesisConfig = void 0;
+
+var _eventTypes = require("./eventTypes.js");
+
+var assembleKinesisConfig = function assembleKinesisConfig(apiConfig) {
+  return Object.assign({
+    apiVersion: '2013-12-02'
+  }, apiConfig);
+}; // We don't really want to delay sending events for this queue.
+
+
+exports.assembleKinesisConfig = assembleKinesisConfig;
+
+var responseStreamConfig = function responseStreamConfig(defaultStreamConfig, stream) {
+  return Object.assign({}, defaultStreamConfig, {
+    eventTypes: {
+      RESPONSE: _eventTypes.RESPONSE
+    },
+    maxPageSize: 1,
+    stream: stream
+  });
+};
+
+exports.responseStreamConfig = responseStreamConfig;
+
+var eventStreamConfig = function eventStreamConfig(defaultStreamConfig, stream) {
+  return Object.assign({}, defaultStreamConfig, {
+    eventTypes: {
+      RESPONSE: _eventTypes.EVENT_RESPONSE,
+      SESSION_STARTED_OR_RESUMED_EVENT: _eventTypes.SESSION_STARTED_OR_RESUMED_EVENT,
+      QUIZ_SUBMISSION_EVENT: _eventTypes.QUIZ_SUBMISSION_EVENT
+    },
+    stream: stream
+  });
+};
+
+exports.eventStreamConfig = eventStreamConfig;
+
+var assembleStreamConfigs = function assembleStreamConfigs(config) {
+  var defaultStreamConfig = Object.assign({
+    maxPageSize: 25,
+    // max number events sent at once
+    sendRecordsTimeout: 5000 // in milliseconds
+
+  }, config.stream_configuration);
+  return [eventStreamConfig(defaultStreamConfig, config.stream_identifiers.events), responseStreamConfig(defaultStreamConfig, config.stream_identifiers.responses)];
+};
+
+exports.assembleStreamConfigs = assembleStreamConfigs;

package/lib/common/kinesis/eventTypes.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.QUIZ_SUBMISSION_EVENT = exports.SESSION_STARTED_OR_RESUMED_EVENT = exports.EVENT_RESPONSE = exports.RESPONSE = void 0;
+
+var _humps = require("humps");
+
+function eventType() {
+  var eventTransform = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function (data) {
+    return data;
+  };
+  return function (data) {
+    var quizSessionId = data.quizSessionId,
+        accountUuid = data.accountUuid;
+    var createdAt = "".concat(new Date().toISOString(), "|").concat(window.performance.now());
+    var quizSessionKey = "".concat(quizSessionId, "|").concat(accountUuid);
+    var serializedData = JSON.stringify((0, _humps.decamelizeKeys)(Object.assign(eventTransform(data), {
+      createdAt: createdAt
+    }))); // AWS-SDK uses capitalized properties :\
+
+    return {
+      Data: serializedData,
+      PartitionKey: quizSessionKey
+    };
+  };
+}
+
+var RESPONSE = eventType(function (data) {
+  // The resume (response_events) stream doesn't care about eventData contents
+  // Clean them up!
+  // Required to prevent modification of the source data
+  var adjustedData = Object.assign({}, data);
+  adjustedData.eventData = Object.assign({}, data.eventData);
+  'position userResponse itemId'.split(' ').forEach(function (prop) {
+    adjustedData[prop] = adjustedData.eventData[prop];
+    delete adjustedData.eventData[prop];
+  });
+  return adjustedData;
+});
+exports.RESPONSE = RESPONSE;
+var EVENT_RESPONSE = eventType();
+exports.EVENT_RESPONSE = EVENT_RESPONSE;
+var SESSION_STARTED_OR_RESUMED_EVENT = eventType();
+exports.SESSION_STARTED_OR_RESUMED_EVENT = SESSION_STARTED_OR_RESUMED_EVENT;
+var QUIZ_SUBMISSION_EVENT = eventType();
+exports.QUIZ_SUBMISSION_EVENT = QUIZ_SUBMISSION_EVENT;

package/lib/common/middleware/alertTimerMiddleware.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _alerts = require("../actions/alerts.js");
+
+var alertTimerMiddleware = function alertTimerMiddleware(store) {
+  return function (next) {
+    return function (action) {
+      var delay = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : setTimeout;
+
+      if (action && action.type === _quizCommon.ADD_ALERT && action.payload.removeIn) {
+        var remove = function remove() {
+          store.dispatch((0, _alerts.removeAlert)(action.payload.uuid));
+        }; // injected for testing
+
+
+        delay(remove, action.payload.removeIn);
+      }
+
+      return next(action);
+    };
+  };
+};
+
+var _default = alertTimerMiddleware;
+exports.default = _default;

package/lib/common/middleware/crossDomainMessagingMiddleware.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _crossDomainMessaging = require("../util/crossDomainMessaging.js");
+
+var crossDomainMessagingMiddleware = function crossDomainMessagingMiddleware(store) {
+  return function (next) {
+    return function (action) {
+      if (action.type === _quizCommon.POST_TO_PARENT) {
+        (0, _crossDomainMessaging.postToParent)(action.payload);
+      }
+
+      return next(action);
+    };
+  };
+};
+
+var _default = crossDomainMessagingMiddleware;
+exports.default = _default;

package/lib/common/middleware/eventLoggerMiddleware.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _serializeEvent = _interopRequireDefault(require("../util/serializeEvent.js"));
+
+var _QuizEventsLogger = _interopRequireDefault(require("../kinesis/QuizEventsLogger.js"));
+
+var _quizSessions = require("../selectors/quizSessions.js");
+
+// ==============================================================
+// this middleware queues payloads to the logger for handling
+// ==============================================================
+var eventLoggerMiddlewareCreator = function eventLoggerMiddlewareCreator() {
+  var loggerFetch = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : _QuizEventsLogger.default;
+  var serializer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _serializeEvent.default;
+  return function (store) {
+    return function (next) {
+      return function (action) {
+        var result = next(action);
+        var eventJSON = serializer(action, store);
+
+        if (eventJSON) {
+          var quizSessionId = (0, _quizSessions.getActiveQuizSessionId)(store.getState());
+          loggerFetch(quizSessionId).then(function (logger) {
+            logger.enqueueEvent(eventJSON);
+          });
+        }
+
+        return result;
+      };
+    };
+  };
+};
+
+var _default = eventLoggerMiddlewareCreator;
+exports.default = _default;