@instructure/quiz-core 20.17.3-rc.7 → 20.17.3-rc.8

package/es/common/kinesis/QuizEventsLogger.js

@@ -1,26 +1,30 @@
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _construct from "@babel/runtime/helpers/esm/construct";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
-import StreamQueue from './StreamQueue';
-import getKinesisConfig from './client';
+import StreamQueue from "./StreamQueue.js";
+import getKinesisConfig from "./client.js";
 var KINESIS_REFRESH_THRESHOLD = 600000; // 10 minutes
+
 var PAGE_FOCUSED_EVENT = 'PAGE_FOCUSED_EVENT';
 var PAGE_BLURRED_EVENT = 'PAGE_BLURRED_EVENT';
 export var QuizEventsLogger = /*#__PURE__*/function () {
   function QuizEventsLogger() {
     _classCallCheck(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();
     this.hasSentPageBlurredEventPreviously = false;
   }
-  return _createClass(QuizEventsLogger, [{
+
+  _createClass(QuizEventsLogger, [{
     key: "needsRefresh",
     value: function needsRefresh() {
       var threshold = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KINESIS_REFRESH_THRESHOLD;
@@ -34,9 +38,11 @@ export var QuizEventsLogger = /*#__PURE__*/function () {
       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;
     }
@@ -44,6 +50,7 @@ export var QuizEventsLogger = /*#__PURE__*/function () {
     key: "enqueueEvent",
     value: function enqueueEvent(data) {
       var _this = this;
+
       var eventType = data.eventType;
       var queues = this.queuesForEventType(eventType);
       queues.forEach(function (queue) {
@@ -51,8 +58,10 @@ export var QuizEventsLogger = /*#__PURE__*/function () {
         if (eventType === PAGE_FOCUSED_EVENT && !_this.hasSentPageBlurredEventPreviously) {
           return;
         }
+
         queue.push(eventType, data);
       });
+
       if (eventType === PAGE_BLURRED_EVENT) {
         this.hasSentPageBlurredEventPreviously = true;
       } else if (eventType === PAGE_FOCUSED_EVENT) {
@@ -60,70 +69,83 @@ export var QuizEventsLogger = /*#__PURE__*/function () {
       }
     }
   }]);
+
+  return QuizEventsLogger;
 }();
 var loggers = {};
 var loggerHandlers = {};
+
 var getLogger = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(quizSessionId) {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(quizSessionId) {
     var kinesisConfigGetter,
-      logger,
-      handler,
-      kinesisConfig,
-      kinesisClient,
-      streamQueues,
-      _args = arguments;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          kinesisConfigGetter = _args.length > 1 && _args[1] !== void 0 ? _args[1] : getKinesisConfig;
-          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({
-              config: config,
-              kinesis: kinesisClient
+        logger,
+        handler,
+        kinesisConfig,
+        kinesisClient,
+        streamQueues,
+        _args = arguments;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            kinesisConfigGetter = _args.length > 1 && _args[1] !== void 0 ? _args[1] : getKinesisConfig;
+            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({
+                config: config,
+                kinesis: kinesisClient
+              });
             });
-          });
-          logger = _construct(QuizEventsLogger, _toConsumableArray(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();
+            logger = _construct(QuizEventsLogger, _toConsumableArray(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
+}(); // 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
+
+
 export var fetchLogger = function fetchLogger(quizSessionId) {
   var kinesisConfigGetter = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getKinesisConfig;
-  var logger = loggers[quizSessionId];
+  var logger = loggers[quizSessionId]; // expires 1 second earlier to protect processing edge case
 
-  // 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;
 };
 export default getLogger;

package/es/common/kinesis/StreamQueue.js

@@ -4,36 +4,46 @@ 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;
+        kinesis = _ref.kinesis;
+
     _classCallCheck(this, StreamQueue);
+
     this.config = config;
     this.kinesis = kinesis;
     this.timeout = null;
     this.pageQueue = [];
+
     this._addPage();
+
     this._scheduleSendRecords();
   }
-  return _createClass(StreamQueue, [{
+
+  _createClass(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;
-    }
 
-    // =============
+      return true;
+    } // =============
     // PRIVATE
     // =============
+
   }, {
     key: "_scheduleSendRecords",
     value: function _scheduleSendRecords() {
@@ -45,6 +55,7 @@ var StreamQueue = /*#__PURE__*/function () {
     value: function _sendIfLastPageFull() {
       if (this._lastPage().data.length === this.config.maxPageSize) {
         this._sendRecords();
+
         this._addPage();
       }
     }
@@ -70,9 +81,11 @@ var StreamQueue = /*#__PURE__*/function () {
     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) {
@@ -88,6 +101,7 @@ var StreamQueue = /*#__PURE__*/function () {
     key: "_sendRecords",
     value: function _sendRecords() {
       var _this = this;
+
       this.pageQueue.forEach(function (page, i) {
         if (!_this._canSendPage(page)) return;
         var params = {
@@ -95,20 +109,25 @@ var StreamQueue = /*#__PURE__*/function () {
           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
+            _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
+            _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;
 }();
+
 export { StreamQueue as default };

package/es/common/kinesis/client.js

@@ -1,10 +1,10 @@
 import { Credentials, config } from 'aws-sdk/global';
 import Kinesis from 'aws-sdk/clients/kinesis';
-import { assembleKinesisConfig, assembleStreamConfigs } from './config';
-import Fetcher from '../util/Fetcher';
+import { assembleKinesisConfig, assembleStreamConfigs } from "./config.js";
+import Fetcher from "../util/Fetcher.js";
 export var buildKinesisConfiguration = function buildKinesisConfiguration(_ref) {
   var configuration = _ref.configuration,
-    credentials = _ref.credentials;
+      credentials = _ref.credentials;
   var serverTime = configuration.server_time;
   if (serverTime) config.systemClockOffset = Date.parse(serverTime) - Date.now();
   return {
@@ -24,6 +24,7 @@ export var buildCredentials = function buildCredentials(credentialParams) {
   creds.expireTime = Date.parse(credentialParams.expiration);
   return creds;
 };
+
 var getKinesisConfig = function getKinesisConfig(quizSessionId) {
   var fetcher = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : new Fetcher();
   return new Promise(function (resolve, reject) {
@@ -39,4 +40,5 @@ var getKinesisConfig = function getKinesisConfig(quizSessionId) {
     });
   });
 };
+
 export default getKinesisConfig;

package/es/common/kinesis/config.js

@@ -1,11 +1,10 @@
-import { EVENT_RESPONSE, QUIZ_SUBMISSION_EVENT, RESPONSE, SESSION_STARTED_OR_RESUMED_EVENT, RCE_EVENT, PAGE_BLURRED_EVENT, PAGE_FOCUSED_EVENT } from './eventTypes';
+import { EVENT_RESPONSE, QUIZ_SUBMISSION_EVENT, RESPONSE, SESSION_STARTED_OR_RESUMED_EVENT, RCE_EVENT, PAGE_BLURRED_EVENT, PAGE_FOCUSED_EVENT } from "./eventTypes.js";
 export 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.
 
-// We don't really want to delay sending events for this queue.
 export var responseStreamConfig = function responseStreamConfig(defaultStreamConfig, stream) {
   return Object.assign({}, defaultStreamConfig, {
     eventTypes: {
@@ -33,6 +32,7 @@ export var assembleStreamConfigs = function assembleStreamConfigs(config) {
     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)];
 };

package/es/common/kinesis/eventTypes.js

@@ -1,28 +1,28 @@
 import { decamelizeKeys } from '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;
+        accountUuid = data.accountUuid;
     var createdAt = "".concat(new Date().toISOString(), "|").concat(window.performance.now());
     var quizSessionKey = "".concat(quizSessionId, "|").concat(accountUuid);
     var serializedData = JSON.stringify(decamelizeKeys(Object.assign(eventTransform(data), {
       createdAt: createdAt
-    })));
+    }))); // AWS-SDK uses capitalized properties :\
 
-    // AWS-SDK uses capitalized properties :\
     return {
       Data: serializedData,
       PartitionKey: quizSessionKey
     };
   };
 }
+
 export 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);

package/es/common/middleware/alertTimerMiddleware.js

@@ -1,19 +1,23 @@
 import { ADD_ALERT } from '@instructure/quiz-common';
-import { removeAlert } from '../actions/alerts';
+import { removeAlert } from "../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 === ADD_ALERT && action.payload.removeIn && action.payload.variant != 'stickyerror') {
         var remove = function remove() {
           store.dispatch(removeAlert(action.payload.uuid));
-        };
+        }; // injected for testing
+
 
-        // injected for testing
         delay(remove, action.payload.removeIn);
       }
+
       return next(action);
     };
   };
 };
+
 export default alertTimerMiddleware;

package/es/common/middleware/crossDomainMessagingMiddleware.js

@@ -1,13 +1,16 @@
 import { POST_TO_PARENT } from '@instructure/quiz-common';
-import { postToParent } from '../util/crossDomainMessaging';
+import { postToParent } from "../util/crossDomainMessaging.js";
+
 var crossDomainMessagingMiddleware = function crossDomainMessagingMiddleware(store) {
   return function (next) {
     return function (action) {
       if (action.type === POST_TO_PARENT) {
         postToParent(action.payload);
       }
+
       return next(action);
     };
   };
 };
+
 export default crossDomainMessagingMiddleware;

package/es/common/middleware/eventLoggerMiddleware.js

@@ -1,11 +1,10 @@
-import serializeEvent from '../util/serializeEvent';
-
-// ==============================================================
+import serializeEvent from "../util/serializeEvent.js"; // ==============================================================
 // this middleware queues payloads to the logger for handling
 // ==============================================================
 
-import getLogger from '../kinesis/QuizEventsLogger';
-import { getActiveQuizSessionId } from '../selectors/quizSessions';
+import getLogger from "../kinesis/QuizEventsLogger.js";
+import { getActiveQuizSessionId } from "../selectors/quizSessions.js";
+
 var eventLoggerMiddlewareCreator = function eventLoggerMiddlewareCreator() {
   var loggerFetch = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getLogger;
   var serializer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : serializeEvent;
@@ -14,15 +13,18 @@ var eventLoggerMiddlewareCreator = function eventLoggerMiddlewareCreator() {
       return function (action) {
         var result = next(action);
         var eventJSON = serializer(action, store);
+
         if (eventJSON) {
           var quizSessionId = getActiveQuizSessionId(store.getState());
           loggerFetch(quizSessionId).then(function (logger) {
             logger.enqueueEvent(eventJSON);
           });
         }
+
         return result;
       };
     };
   };
 };
+
 export default eventLoggerMiddlewareCreator;

package/es/common/middleware/persistedStorageMiddleware.js

@@ -1,7 +1,6 @@
 import store from 'store';
 import { ACTIVE_QUESTION, ACTIVE_QUIZ_SESSION_CHANGE, BACKTRACKING_NEXT_QUESTION, CACHED_SESSION_ID, PREVIOUS_QUESTION, SET_CURRENT_SESSION_ITEM_POSITION, PERSIST_PRINT_FONT_SIZE_PREFERENCE, QUIZ_PRINT_FONT_SIZE_PREFERENCE } from '@instructure/quiz-common';
-import { sessionStore } from '../util/sessionStore';
-
+import { sessionStore } from "../util/sessionStore.js";
 /**
  * Some of our redux store values are stored in browser client-side storage
  * for easy recall in the event of a page refresh, etc. This provides a single
@@ -17,10 +16,12 @@ var persistTakingInfo = function persistTakingInfo(store, persistedLocalStore) {
   persistedLocalStore.set(ACTIVE_QUESTION, position);
   persistedLocalStore.set(CACHED_SESSION_ID, sessionId);
 };
+
 var persistPrintFontSizePreference = function persistPrintFontSizePreference(store, persistedLocalStore) {
   var fontSize = store.getState().getIn(['printing', 'fontSizePreference']);
   persistedLocalStore.set(QUIZ_PRINT_FONT_SIZE_PREFERENCE, fontSize);
 };
+
 var persistedStorageMiddleware = function persistedStorageMiddleware() {
   var persistedSessionStore = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : sessionStore;
   var persistedLocalStore = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : store;
@@ -28,6 +29,7 @@ var persistedStorageMiddleware = function persistedStorageMiddleware() {
     return function (next) {
       return function (action) {
         var nextState = next(action);
+
         if (persistedLocalStore.enabled) {
           switch (action.type) {
             case ACTIVE_QUIZ_SESSION_CHANGE:
@@ -36,14 +38,17 @@ var persistedStorageMiddleware = function persistedStorageMiddleware() {
             case SET_CURRENT_SESSION_ITEM_POSITION:
               persistTakingInfo(store, persistedLocalStore);
               break;
+
             case PERSIST_PRINT_FONT_SIZE_PREFERENCE:
               persistPrintFontSizePreference(store, persistedLocalStore);
               break;
           }
         }
+
         return nextState;
       };
     };
   };
 };
+
 export default persistedStorageMiddleware;

package/es/common/react-redux.js

@@ -1,10 +1,12 @@
 /* eslint "no-param-reassign": "warn" */
 import { connect, createProvider } from 'react-redux';
 var STORE_KEY = 'SDKStore';
+
 function connectToSDKStore(mapStateToProps, mapDispatchToProps, mergeProps) {
   var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
   options.storeKey = options.storeKey || STORE_KEY;
   return connect(mapStateToProps, mapDispatchToProps, mergeProps, options);
 }
+
 export { connectToSDKStore as connect };
 export var Provider = createProvider(STORE_KEY);

package/es/common/records/Alert.js

@@ -1,15 +1,19 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _callSuper from "@babel/runtime/helpers/esm/callSuper";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import { Record } from 'immutable';
 export var Alert = /*#__PURE__*/function (_Record) {
+  _inherits(Alert, _Record);
+
+  var _super = _createSuper(Alert);
+
   function Alert() {
     _classCallCheck(this, Alert);
-    return _callSuper(this, Alert, arguments);
+
+    return _super.apply(this, arguments);
   }
-  _inherits(Alert, _Record);
-  return _createClass(Alert);
+
+  return Alert;
 }(Record({
   message: null,
   uuid: null,

package/es/common/records/Bank.js

@@ -1,22 +1,26 @@
-import _readOnlyError from "@babel/runtime/helpers/esm/readOnlyError";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _callSuper from "@babel/runtime/helpers/esm/callSuper";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import { Set } from 'immutable';
-import ReduxRecord from './reduxRecord';
+import ReduxRecord from "./reduxRecord.js";
 import t from '@instructure/quiz-i18n/es/format-message';
 import { TEMPORARY_BANK_ID, CAN_EDIT } from '@instructure/quiz-common';
 import { rule } from 'instructure-validations';
 import { presenceMessage } from '@instructure/quiz-interactions';
-import { getLatestQtiImportForParentWithType } from '../selectors/qtiImports';
+import { getLatestQtiImportForParentWithType } from "../selectors/qtiImports.js";
 export var Bank = /*#__PURE__*/function (_ReduxRecord) {
+  _inherits(Bank, _ReduxRecord);
+
+  var _super = _createSuper(Bank);
+
   function Bank() {
     _classCallCheck(this, Bank);
-    return _callSuper(this, Bank, arguments);
+
+    return _super.apply(this, arguments);
   }
-  _inherits(Bank, _ReduxRecord);
-  return _createClass(Bank, [{
+
+  _createClass(Bank, [{
     key: "createdAt",
     value: function createdAt() {
       return new Date(this.get('createdAt'));
@@ -78,6 +82,8 @@ export var Bank = /*#__PURE__*/function (_ReduxRecord) {
       };
     }
   }]);
+
+  return Bank;
 }(ReduxRecord({
   accountPermission: null,
   archived: false,

package/es/common/records/BankEntry.js

@@ -1,28 +1,36 @@
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _callSuper from "@babel/runtime/helpers/esm/callSuper";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import { Map } from 'immutable';
-import ReduxRecord from './reduxRecord';
-import _Item from './Item';
-import _Stimulus from './Stimulus';
+import ReduxRecord from "./reduxRecord.js";
+import _Item from "./Item.js";
+import _Stimulus from "./Stimulus.js";
 import { TEMPORARY_ITEM_ID, TEMPORARY_STIMULUS_ID } from '@instructure/quiz-common';
 export var BankEntry = /*#__PURE__*/function (_ReduxRecord) {
+  _inherits(BankEntry, _ReduxRecord);
+
+  var _super = _createSuper(BankEntry);
+
   function BankEntry() {
     _classCallCheck(this, BankEntry);
-    return _callSuper(this, BankEntry, arguments);
+
+    return _super.apply(this, arguments);
   }
-  _inherits(BankEntry, _ReduxRecord);
-  return _createClass(BankEntry, [{
+
+  _createClass(BankEntry, [{
     key: "getEntry",
     value: function getEntry() {
       var _this = this;
+
       if (this.entry === TEMPORARY_ITEM_ID) {
         return _Item.create(this.getState().getIn(['modifications', 'items', TEMPORARY_ITEM_ID]));
       }
+
       if (this.entry === TEMPORARY_STIMULUS_ID) {
         return _Stimulus.create(this.getState().getIn(['modifications', 'stimuli', TEMPORARY_STIMULUS_ID]));
       }
+
       var entryCreator = {
         Item: function Item() {
           return _Item.create(_this.getState().getIn(['items', _this.entry.get('id')]));
@@ -55,6 +63,8 @@ export var BankEntry = /*#__PURE__*/function (_ReduxRecord) {
       return this.entryType === 'Stimulus';
     }
   }]);
+
+  return BankEntry;
 }(ReduxRecord({
   id: '0',
   entry: Map(),