@instructure/quiz-core 17.19.2 → 17.20.0

package/lib/building/components/resources/quizEntry/QuizEntryEdit/Header/theme.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generator;
+
+function generator(_ref) {
+  var spacing = _ref.spacing,
+      colors = _ref.colors,
+      typography = _ref.typography;
+  return {
+    headerBackgroundColor: colors.porcelain,
+    headerColor: colors.oxford,
+    headerPadding: "".concat(spacing.xSmall, " ").concat(spacing.small),
+    interactionTypeFontSize: typography.fontSizeSmall,
+    interactionTypeLeftMargin: spacing.xSmall,
+    interactionTypeRightMargin: spacing.xSmall,
+    titleInputFontSize: typography.fontSizeMedium
+  };
+}

package/lib/building/components/resources/quizEntry/QuizEntryEdit/index.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _immutable = require("immutable");
+
+var _redux = require("redux");
+
+var _reactRedux = require("../../../../../common/react-redux.js");
+
+var _makeEditable = _interopRequireDefault(require("../../../../../common/components/shared/functionality/makeEditable.js"));
+
+var alertActions = _interopRequireWildcard(require("../../../../../common/actions/alerts.js"));
+
+var errorsShowingActions = _interopRequireWildcard(require("../../../../../common/actions/errorsShowing.js"));
+
+var itemApiActions = _interopRequireWildcard(require("../../../../api/items.js"));
+
+var modalActions = _interopRequireWildcard(require("../../../../../common/actions/modal.js"));
+
+var _ui = require("../../../../../common/actions/ui.js");
+
+var modificationActions = _interopRequireWildcard(require("../../../../../common/actions/modifications.js"));
+
+var quizEntryApiActions = _interopRequireWildcard(require("../../../../api/quizEntries.js"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _presenter = _interopRequireDefault(require("./presenter.js"));
+
+function mapStateToProps(state, props) {
+  // Error Related:
+  var workingEntry = props.entry.getWorkingInstance();
+  var errorsShowing = state.get('errorsShowing', (0, _immutable.Map)());
+  var errorsAreShowing = errorsShowing.get(props.guid);
+  var addContentPopoverOpen = state.get('editing', (0, _immutable.Map)()).find(function (isEditing, key) {
+    return isEditing && key.includes(_quizCommon.ADD_CONTENT_POPOVER_KEY);
+  });
+  var dndPosition = state.getIn(['dragAndDrop', 'position']);
+  var draggingAboveHalf = state.getIn(['dragAndDrop', 'aboveHalf'], false);
+  var draggingOver = props.draggingOnBuild && dndPosition === props.quizEntry.position;
+  return {
+    addContentPopoverOpen: Boolean(addContentPopoverOpen),
+    draggingAboveHalf: draggingOver && draggingAboveHalf,
+    draggingOver: draggingOver,
+    editable: true,
+    errors: workingEntry.getErrors().toJS(),
+    errorsAreShowing: errorsAreShowing,
+    isEditing: true,
+    isOccluded: state.getIn(['ui', 'quizEntriesOccluded'], false),
+    nextQuizEntry: state.getIn(['modifications', 'nextQuizEntry'], null),
+    notifyScreenReader: true,
+    stemErrors: workingEntry.errorsFor('itemBody').toJS(),
+    workingEntry: workingEntry,
+    workingQuizEntry: props.quizEntry.getWorkingInstance(),
+    appContainer: state.getIn(['ui', 'appContainer'])
+  };
+}
+
+function mapDispatchToProps(dispatch) {
+  var boundErrorActions = (0, _redux.bindActionCreators)(errorsShowingActions, dispatch);
+  var boundItemApiActions = (0, _redux.bindActionCreators)(itemApiActions, dispatch);
+  var boundModalActions = (0, _redux.bindActionCreators)(modalActions, dispatch);
+  var boundModificationActions = (0, _redux.bindActionCreators)(modificationActions, dispatch);
+  var boundQuizEntryApiActions = (0, _redux.bindActionCreators)(quizEntryApiActions, dispatch);
+  return {
+    screenreaderNotification: (0, _redux.bindActionCreators)(alertActions, dispatch).screenreaderNotification,
+    setUI: (0, _redux.bindActionCreators)(_ui.set, dispatch),
+    changeItemTitle: boundModificationActions.changeItemTitle,
+    changeQuizEntryPoints: boundModificationActions.changeQuizEntryPoints,
+    clearModifications: boundModificationActions.clearModifications,
+    clearTemporaryItem: boundModificationActions.clearTemporaryItem,
+    clearNextQuizEntry: boundModificationActions.clearNextQuizEntry,
+    hideError: boundErrorActions.hideError,
+    showError: boundErrorActions.showError,
+    createTempItem: boundModificationActions.createItem,
+    createTempStimulus: boundModificationActions.createStimulus,
+    createItem: boundItemApiActions.createItem,
+    updateItem: boundItemApiActions.updateItem,
+    cloneQuizEntry: boundQuizEntryApiActions.cloneQuizEntry,
+    createQuizEntry: boundQuizEntryApiActions.createQuizEntry,
+    removeQuizEntry: boundQuizEntryApiActions.removeQuizEntry,
+    updateQuizEntry: boundQuizEntryApiActions.updateQuizEntry,
+    openModal: boundModalActions.openModal,
+    withConfirm: boundModalActions.withConfirm
+  };
+}
+
+var _default = (0, _makeEditable.default)((0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_presenter.default));
+
+exports.default = _default;

package/lib/building/components/resources/quizEntry/QuizEntryEdit/presenter.js

@@ -0,0 +1,545 @@
+"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.QuizEntryEditRaw = exports.UndecoratedQuizEntryEdit = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+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 _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 _reactImmutableProptypes = _interopRequireDefault(require("react-immutable-proptypes"));
+
+var _reactDnd = require("react-dnd");
+
+var _pick = _interopRequireDefault(require("lodash/pick"));
+
+var _first = _interopRequireDefault(require("lodash/first"));
+
+var _uiThemeable = require("@instructure/ui-themeable");
+
+var _formatMessage = _interopRequireDefault(require("@instructure/quiz-i18n/es/format-message"));
+
+var _CustomPropTypes = _interopRequireDefault(require("../../../../../common/util/CustomPropTypes.js"));
+
+var _ElementsForSelectors = _interopRequireDefault(require("../../../../../common/util/ElementsForSelectors.js"));
+
+var _index = _interopRequireDefault(require("../../../../../banks/components/AddToBankModal/index.js"));
+
+var _index2 = _interopRequireDefault(require("../../../../../common/components/shared/drag_and_drop/DragAndDropZone/index.js"));
+
+var _componentWithOutsideClick = _interopRequireDefault(require("../../../../../common/components/shared/functionality/componentWithOutsideClick.js"));
+
+var _index3 = _interopRequireDefault(require("./Header/index.js"));
+
+var _index4 = _interopRequireDefault(require("./Footer/index.js"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _dragAndDropUtils = require("../../../../../common/components/shared/drag_and_drop/dragAndDropUtils.js");
+
+var _theme = _interopRequireDefault(require("./theme.js"));
+
+var _dec, _class, _class2, _temp;
+
+var styles = {
+  componentId: 'elceN',
+  template: function template(theme) {
+    return "\n\n.elceN_qRLg{font-size:".concat(theme.quizEntryEditFontSize || 'inherit', ";margin:").concat(theme.quizEntryEditMargin || 'inherit', " 0;position:relative;transform:translateZ(0);z-index:3333}");
+  },
+  'quizEntryEdit': 'elceN_qRLg'
+};
+var QuizEntryEdit = (_dec = (0, _uiThemeable.themeable)(_theme.default, styles), _dec(_class = (_temp = _class2 = /*#__PURE__*/function (_Component) {
+  (0, _inherits2.default)(QuizEntryEdit, _Component);
+
+  var _super = (0, _createSuper2.default)(QuizEntryEdit);
+
+  function QuizEntryEdit() {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, QuizEntryEdit);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.state = {
+      canSubmit: true
+    };
+
+    _this.onSubmit = function (e) {
+      var displayPosition = _this.props.displayPosition;
+      e && e.preventDefault();
+
+      if (_this.isValid() && _this.state.canSubmit) {
+        _this.successfulSubmit();
+      } else {
+        var msg = (0, _formatMessage.default)('Item {displayPosition, number} cannot be saved due to invalid input data.', {
+          displayPosition: displayPosition
+        });
+
+        _this.props.screenreaderNotification(msg);
+
+        _this.props.showError(_this.props.guid);
+
+        _this.props.clearNextQuizEntry();
+      }
+    };
+
+    _this.createOrUpdateItem = function () {
+      var workingEntry = _this.props.workingEntry;
+
+      if (_this.props.entry.isTemporary()) {
+        return _this.props.createItem(workingEntry, _this.props.quizId, 'quiz');
+      } else if (_this.props.shouldClone) {
+        return _this.props.createItem(workingEntry, _this.props.quizId, 'quiz', workingEntry.id);
+      } else if (_this.props.entry.hasModifications()) {
+        return _this.props.updateItem(workingEntry, _this.props.quizId, 'quiz');
+      }
+
+      return Promise.resolve(_this.props.entry.toJS());
+    };
+
+    _this.createNextQuizEntry = function () {
+      var _this$props$nextQuizE = _this.props.nextQuizEntry,
+          interactionTypeData = _this$props$nextQuizE.interactionTypeData,
+          quizId = _this$props$nextQuizE.quizId,
+          position = _this$props$nextQuizE.position,
+          stimulusId = _this$props$nextQuizE.stimulusId,
+          parentEntryId = _this$props$nextQuizE.parentEntryId;
+
+      if (!interactionTypeData) {
+        _this.props.createTempStimulus(quizId, position);
+      } else {
+        var defaultInteractionData = interactionTypeData.getDefaultInteractionData();
+        var scoringData = interactionTypeData.getDefaultScoringData(defaultInteractionData);
+
+        _this.props.createTempItem(quizId, position, {
+          id: interactionTypeData.id,
+          interactionData: defaultInteractionData,
+          itemBody: interactionTypeData.itemBody,
+          properties: interactionTypeData.defaultProperties,
+          scoringAlgorithm: (0, _first.default)(interactionTypeData.scoringAlgorithmOptions),
+          scoringData: scoringData,
+          userResponseType: (0, _first.default)(interactionTypeData.userResponseTypeOptions)
+        }, parentEntryId, stimulusId);
+      }
+
+      _this.props.clearNextQuizEntry();
+    };
+
+    _this.createOrUpdateQuizEntry = function (itemData) {
+      var _this$props = _this.props,
+          workingEntry = _this$props.workingEntry,
+          workingQuizEntry = _this$props.workingQuizEntry,
+          quizEntry = _this$props.quizEntry,
+          shouldClone = _this$props.shouldClone;
+
+      if (workingQuizEntry.isTemporary) {
+        return _this.props.createQuizEntry(_this.props.quizId, workingEntry.id === _quizCommon.TEMPORARY_ITEM_ID ? itemData.id : workingEntry.id, workingQuizEntry.entryType, workingQuizEntry.getProperties(), !_this.props.addContentPopoverOpen);
+      } else if (shouldClone && (!quizEntry.isBankEntry || quizEntry.isArchivedBankEntry)) {
+        return _this.props.cloneQuizEntry(_this.props.quizId, workingQuizEntry.id, Object.assign({}, workingQuizEntry.toJS(), {
+          entryId: itemData.id,
+          entryType: quizEntry.isArchivedBankEntry ? quizEntry.getEntry().entryType : quizEntry.entryType
+        }));
+      } else if (_this.props.quizEntry.hasModifications()) {
+        // if a quiz entry is a bank entry, item.id is not bank entry id
+        // if a quiz entry is not a bank entry, item.id is entry id
+        var entryId = quizEntry.isBankEntry ? workingQuizEntry.entry.get('id') : itemData.id;
+        return _this.props.updateQuizEntry(_this.props.quizId, workingQuizEntry.id, Object.assign({}, workingQuizEntry.toJS(), {
+          entryId: entryId
+        }));
+      }
+
+      return Promise.resolve(_this.props.quizEntry);
+    };
+
+    _this.handleApiErrors = /*#__PURE__*/function () {
+      var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(fetcherError) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!fetcherError.validationErrorsFromApi) {
+                  _context.next = 4;
+                  break;
+                }
+
+                _this.props.handleValidationErrorsFromApi(fetcherError.validationErrorsFromApi);
+
+                _context.next = 5;
+                break;
+
+              case 4:
+                throw fetcherError;
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    _this.successfulSubmit = /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var itemData;
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _this.setState({
+                canSubmit: false
+              });
+
+              _context2.prev = 1;
+              _context2.next = 4;
+              return _this.createOrUpdateItem();
+
+            case 4:
+              itemData = _context2.sent;
+              _context2.next = 7;
+              return _this.createOrUpdateQuizEntry(itemData);
+
+            case 7:
+              _context2.next = 14;
+              break;
+
+            case 9:
+              _context2.prev = 9;
+              _context2.t0 = _context2["catch"](1);
+
+              _this.setState({
+                canSubmit: true
+              });
+
+              _this.handleApiErrors(_context2.t0); // When reached, this is always a validation error
+
+
+              return _context2.abrupt("return", _quizCommon.API_INPUT_VALIDATION_ERROR);
+
+            case 14:
+              _this.props.hideError(_this.props.guid);
+
+              if (_this.props.shouldClone) {
+                _this.props.openRegradeModal();
+              }
+
+              _this.clearModifications();
+
+              if (_this.props.nextQuizEntry) {
+                _this.createNextQuizEntry();
+              }
+
+              _this.props.switchOffEditing();
+
+            case 19:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[1, 9]]);
+    }));
+
+    _this.clearChanges = function () {
+      var fromCancel = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+
+      _this.props.clearValidationErrorsFromApi(_quizCommon.CLEAR_ALL_INPUT_VALIDATION_ERRORS);
+
+      _this.clearModifications();
+
+      if (_this.props.quizEntry.isTemporary) {
+        _this.props.clearTemporaryItem(_this.props.quizId);
+
+        if (fromCancel) {
+          _this.props.setUi(_quizCommon.DELETED_QUIZ_ENTRY, {
+            position: Math.ceil(_this.props.quizEntry.position),
+            inStimulus: _this.props.quizEntry.hasStimulus
+          });
+        }
+      }
+    };
+
+    _this.handleAddToBankContinue = function () {
+      if (_this.props.workingQuizEntry.isTemporary) {
+        _this.setState({
+          canSubmit: false
+        });
+      }
+    };
+
+    _this.handleAddToBank = function (bankEntry) {
+      var workingQuizEntry = _this.props.workingQuizEntry;
+
+      if (workingQuizEntry.isTemporary) {
+        _this.props.createQuizEntry(_this.props.quizId, bankEntry.id, 'BankEntry', workingQuizEntry.getProperties());
+
+        _this.props.clearTemporaryItem(_this.props.quizId);
+
+        _this.clearModifications();
+
+        _this.props.switchOffEditing();
+      } else if (_this.props.shouldClone) {
+        _this.props.cloneQuizEntry(_this.props.quizId, workingQuizEntry.id, Object.assign({}, workingQuizEntry.toJS(), {
+          entryId: bankEntry.id,
+          entryType: 'BankEntry'
+        }));
+      } else {
+        _this.props.updateQuizEntry(_this.props.quizId, workingQuizEntry.id, {
+          entryId: bankEntry.id,
+          entryType: 'BankEntry'
+        });
+      }
+    };
+
+    _this.getEntryForBank = function () {
+      var _this$props2 = _this.props,
+          entry = _this$props2.entry,
+          workingEntry = _this$props2.workingEntry,
+          quizId = _this$props2.quizId,
+          shouldClone = _this$props2.shouldClone;
+
+      if (entry.isTemporary()) {
+        return _this.props.createItem(workingEntry, quizId, _quizCommon.PARENT_TYPE_ADDING_TO_BANK);
+      } else if (entry.hasModifications()) {
+        if (shouldClone) {
+          return _this.props.createItem(workingEntry, quizId);
+        } else {
+          return _this.props.updateItem(workingEntry, quizId);
+        }
+      } else {
+        return Promise.resolve(entry);
+      }
+    };
+
+    _this.connectDragSource = function (dragHandle) {
+      return _this.props.connectDragSource(dragHandle);
+    };
+
+    _this.clearModifications = function () {
+      _this.props.clearModifications('items', _this.props.entry.id);
+
+      _this.props.clearModifications('quizEntries', _this.props.quizEntry.id);
+    };
+
+    _this.shouldDisableSubmit = function () {
+      return Boolean(!_this.state.canSubmit || _this.props.haveValidationErrorsFromApi);
+    };
+
+    _this.renderDraggable = function () {
+      var _this$props3 = _this.props,
+          connectDragPreview = _this$props3.connectDragPreview,
+          draggingOver = _this$props3.draggingOver,
+          draggingAboveHalf = _this$props3.draggingAboveHalf;
+      var propsForDnDZone = {
+        draggingOver: draggingOver,
+        draggingAboveHalf: draggingAboveHalf
+      };
+      return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement(_index2.default, Object.assign({}, propsForDnDZone, {
+        location: "above"
+      })), connectDragPreview(_this.renderForm()), /*#__PURE__*/_react.default.createElement(_index2.default, Object.assign({}, propsForDnDZone, {
+        location: "below"
+      })));
+    };
+
+    return _this;
+  }
+
+  (0, _createClass2.default)(QuizEntryEdit, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.props.onEditQuizEntryToggle(this.props.quizEntry.id);
+    }
+  }, {
+    key: "componentWillMount",
+    value: function componentWillMount() {
+      this.props.setUi(_quizCommon.SHOULD_CLONE_ITEM, false);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.props.setUi(_quizCommon.SHOULD_CLONE_ITEM, false);
+    }
+  }, {
+    key: "clickedOutside",
+    value: function clickedOutside() {
+      this.onSubmit();
+    }
+  }, {
+    key: "ignoreClickOutsideIf",
+    value: function ignoreClickOutsideIf(e) {
+      // Need to iterate over the appNodes since Gauge and lti have a different index for the sdk node
+      var appNodes = (0, _ElementsForSelectors.default)(this.props.appContainer);
+      var outsideApp = appNodes.every(function (node) {
+        return node && !node.contains(e.target);
+      });
+      return this.props.isOccluded || outsideApp;
+    }
+  }, {
+    key: "isValid",
+    value: function isValid() {
+      return this.props.workingEntry.isValid() && this.props.workingQuizEntry.isValid();
+    }
+  }, {
+    key: "renderFooter",
+    value: function renderFooter() {
+      var isItemOrBankEntry = this.props.quizEntry.isItem || this.props.quizEntry.isBankEntry;
+      if (!(isItemOrBankEntry || this.props.disabledForRegrade)) return;
+      var footerProps = (0, _pick.default)(this.props, ['alternativeRightFooter', 'changeQuizEntryPoints', 'clearTemporaryItem', 'displayPosition', 'entry', 'guid', 'initialFocusId', 'openModal', 'quizEntry', 'setUi', 'shouldClone', 'workingQuizEntry']);
+      return /*#__PURE__*/_react.default.createElement(_index4.default, Object.assign({
+        clearChanges: this.clearChanges,
+        isValid: this.isValid(),
+        successfulSubmit: this.successfulSubmit,
+        disableSubmit: this.shouldDisableSubmit()
+      }, footerProps));
+    }
+  }, {
+    key: "renderAddToBankModal",
+    value: function renderAddToBankModal() {
+      if (!this.props.quizEntry.isItem) return;
+      return /*#__PURE__*/_react.default.createElement(_index.default, {
+        label: (0, _formatMessage.default)('Add to an Item Bank'),
+        onContinue: this.handleAddToBankContinue,
+        onAdd: this.handleAddToBank,
+        getEntry: this.getEntryForBank,
+        entryId: this.props.guid,
+        entryType: this.props.quizEntry.entryType,
+        handleValidationErrorsFromApi: this.props.handleValidationErrorsFromApi
+      });
+    }
+  }, {
+    key: "renderHeader",
+    value: function renderHeader() {
+      var headerProps = (0, _pick.default)(this.props, ['changeItemTitle', 'clearModifications', 'clearTemporaryItem', 'connectDragSource', 'createTempItem', 'disabledForRegrade', 'displayPosition', 'entry', 'guid', 'hideError', 'initialFocusId', 'name', 'quizEntries', 'quizEntry', 'quizId', 'removeQuizEntry', 'screenreaderNotification', 'setUi', 'shouldClone', 'showError', 'withConfirm', 'workingEntry', 'workingQuizEntry']);
+      return /*#__PURE__*/_react.default.createElement(_index3.default, Object.assign({
+        isValid: this.isValid(),
+        successfulSubmit: this.successfulSubmit,
+        disableSubmit: this.shouldDisableSubmit()
+      }, headerProps));
+    }
+  }, {
+    key: "renderForm",
+    value: function renderForm() {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: styles.quizEntryEdit,
+        "data-automation": "sdk-quiz-entry-edit-div"
+      }, /*#__PURE__*/_react.default.createElement("div", {
+        role: "form"
+      }, this.renderHeader(), this.props.children, this.renderFooter()), this.renderAddToBankModal());
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return this.props.disabledForRegrade ? this.renderForm() : this.renderDraggable();
+    }
+  }]);
+  QuizEntryEdit.displayName = "QuizEntryEdit";
+  return QuizEntryEdit;
+}(_react.Component), _class2.propTypes = {
+  children: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.node), _propTypes.default.node]),
+  clearModifications: _propTypes.default.func.isRequired,
+  // from connected component
+  clearNextQuizEntry: _propTypes.default.func.isRequired,
+  // from connected component
+  clearTemporaryItem: _propTypes.default.func.isRequired,
+  // from connected component
+  cloneQuizEntry: _propTypes.default.func.isRequired,
+  // from connected component
+  connectDragPreview: _propTypes.default.func.isRequired,
+  // inserted from React DnD
+  connectDragSource: _propTypes.default.func.isRequired,
+  // inserted from React DnD
+  createItem: _propTypes.default.func.isRequired,
+  // from connected component
+  createTempItem: _propTypes.default.func.isRequired,
+  // from connected component
+  createTempStimulus: _propTypes.default.func.isRequired,
+  // from connected component
+  createQuizEntry: _propTypes.default.func.isRequired,
+  // from connected component
+  disabledForRegrade: _propTypes.default.bool,
+  draggingAboveHalf: _propTypes.default.bool.isRequired,
+  draggingOver: _propTypes.default.bool.isRequired,
+  entry: _reactImmutableProptypes.default.record.isRequired,
+  guid: _propTypes.default.string.isRequired,
+  addContentPopoverOpen: _propTypes.default.bool.isRequired,
+  isOccluded: _propTypes.default.bool,
+  nextQuizEntry: _reactImmutableProptypes.default.map,
+  openRegradeModal: _propTypes.default.func.isRequired,
+  quizEntries: _reactImmutableProptypes.default.listOf(_reactImmutableProptypes.default.record).isRequired,
+  quizEntry: _reactImmutableProptypes.default.record.isRequired,
+  quizId: _propTypes.default.string.isRequired,
+  screenreaderNotification: _propTypes.default.func.isRequired,
+  // from connected component
+  setUi: _propTypes.default.func.isRequired,
+  shouldClone: _propTypes.default.bool,
+  showError: _propTypes.default.func.isRequired,
+  // from connected component
+  switchOffEditing: _propTypes.default.func.isRequired,
+  updateQuizEntry: _propTypes.default.func.isRequired,
+  // from connected component
+  updateItem: _propTypes.default.func.isRequired,
+  // from connected component
+  workingEntry: _reactImmutableProptypes.default.record.isRequired,
+  workingQuizEntry: _reactImmutableProptypes.default.record.isRequired,
+  appContainer: _CustomPropTypes.default.selectors.isRequired,
+  alternativeRightFooter: _propTypes.default.func,
+  changeItemTitle: _propTypes.default.func.isRequired,
+  // from connected component
+  changeQuizEntryPoints: _propTypes.default.func.isRequired,
+  // from connected component
+  displayPosition: _propTypes.default.number.isRequired,
+  hideError: _propTypes.default.func.isRequired,
+  // from connected component
+  name: _propTypes.default.string,
+  openModal: _propTypes.default.func.isRequired,
+  removeQuizEntry: _propTypes.default.func.isRequired,
+  // from connected component
+  withConfirm: _propTypes.default.func.isRequired,
+  initialFocusId: _propTypes.default.string,
+  onEditQuizEntryToggle: _propTypes.default.func,
+  clearValidationErrorsFromApi: _propTypes.default.func.isRequired,
+  handleValidationErrorsFromApi: _propTypes.default.func.isRequired,
+  haveValidationErrorsFromApi: _propTypes.default.bool
+}, _class2.defaultProps = {
+  alternativeRightFooter: null,
+  children: null,
+  disabledForRegrade: false,
+  initialFocusId: null,
+  isOccluded: false,
+  name: null,
+  nextQuizEntry: null,
+  onEditQuizEntryToggle: Function.prototype,
+  shouldClone: false,
+  haveValidationErrorsFromApi: false
+}, _temp)) || _class);
+var UndecoratedQuizEntryEdit = QuizEntryEdit;
+exports.UndecoratedQuizEntryEdit = UndecoratedQuizEntryEdit;
+var QuizEntryEditRaw = (0, _componentWithOutsideClick.default)(QuizEntryEdit);
+exports.QuizEntryEditRaw = QuizEntryEditRaw;
+
+var _default = (0, _reactDnd.DragSource)(_dragAndDropUtils.ItemTypes.QUIZ_ENTRY, _dragAndDropUtils.dragSource, _dragAndDropUtils.collectDrag)(QuizEntryEditRaw);
+
+exports.default = _default;

package/lib/building/components/resources/quizEntry/QuizEntryEdit/theme.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generator;
+
+function generator(_ref) {
+  var spacing = _ref.spacing,
+      colors = _ref.colors,
+      typography = _ref.typography,
+      borders = _ref.borders;
+  return {
+    quizEntryEditFontSize: typography.fontSizeMedium,
+    quizEntryEditMargin: spacing.medium
+  };
+}