@pie-element/ebsr 6.6.3-next.1075 → 6.6.3-next.1082

package/configure/node_modules/@pie-lib/editable-html/lib/editor.js

@@ -0,0 +1,837 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ALL_PLUGINS", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.ALL_PLUGINS;
+  }
+});
+Object.defineProperty(exports, "DEFAULT_PLUGINS", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.DEFAULT_PLUGINS;
+  }
+});
+exports.serialization = exports["default"] = exports.Editor = 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 _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _slateReact = require("slate-react");
+
+var _slatePropTypes = _interopRequireDefault(require("slate-prop-types"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var serialization = _interopRequireWildcard(require("./serialization"));
+
+exports.serialization = serialization;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _slate = require("slate");
+
+var _plugins = require("./plugins");
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _styles = require("@material-ui/core/styles");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _renderUi = require("@pie-lib/render-ui");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var log = (0, _debug["default"])('editable-html:editor');
+var defaultToolbarOpts = {
+  position: 'bottom',
+  alignment: 'left',
+  alwaysVisible: false,
+  showDone: true,
+  doneOn: 'blur'
+};
+var defaultResponseAreaProps = {
+  options: {},
+  respAreaToolbar: function respAreaToolbar() {},
+  onHandleAreaChange: function onHandleAreaChange() {}
+};
+var defaultLanguageCharactersProps = [];
+
+var createToolbarOpts = function createToolbarOpts(toolbarOpts) {
+  return _objectSpread(_objectSpread({}, defaultToolbarOpts), toolbarOpts);
+};
+
+var Editor = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(Editor, _React$Component);
+
+  var _super = _createSuper(Editor);
+
+  function Editor(_props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, Editor);
+    _this = _super.call(this, _props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handlePlugins", function (props) {
+      var normalizedResponseAreaProps = _objectSpread(_objectSpread({}, defaultResponseAreaProps), props.responseAreaProps);
+
+      _this.plugins = (0, _plugins.buildPlugins)(props.activePlugins, {
+        math: {
+          onClick: _this.onMathClick,
+          onFocus: _this.onPluginFocus,
+          onBlur: _this.onPluginBlur
+        },
+        image: {
+          onDelete: props.imageSupport && props.imageSupport["delete"] && function (src, done) {
+            props.imageSupport["delete"](src, function (e) {
+              done(e, _this.state.value);
+            });
+          },
+          insertImageRequested: props.imageSupport && function (getHandler) {
+            /**
+             * The handler is the object through which the outer context
+             * communicates file upload events like: fileChosen, cancel, progress
+             */
+            var handler = getHandler(function () {
+              return _this.state.value;
+            });
+            props.imageSupport.add(handler);
+          },
+          onFocus: _this.onPluginFocus,
+          onBlur: _this.onPluginBlur,
+          maxImageWidth: _this.props.maxImageWidth,
+          maxImageHeight: _this.props.maxImageHeight
+        },
+        toolbar: {
+          /**
+           * To minimize converting html -> state -> html
+           * We only emit markup once 'done' is clicked.
+           */
+          disableUnderline: props.disableUnderline,
+          autoWidth: props.autoWidthToolbar,
+          onDone: function onDone() {
+            var nonEmpty = props.nonEmpty;
+            log('[onDone]');
+
+            _this.setState({
+              toolbarInFocus: false,
+              focusedNode: null
+            });
+
+            _this.editor.blur();
+
+            if (nonEmpty && _this.state.value.startText.text.length === 0) {
+              _this.resetValue(true).then(function () {
+                _this.onEditingDone();
+              });
+            } else {
+              _this.onEditingDone();
+            }
+          }
+        },
+        table: {
+          onFocus: function onFocus() {
+            log('[table:onFocus]...');
+
+            _this.onPluginFocus();
+          },
+          onBlur: function onBlur() {
+            log('[table:onBlur]...');
+
+            _this.onPluginBlur();
+          }
+        },
+        responseArea: {
+          type: normalizedResponseAreaProps.type,
+          options: normalizedResponseAreaProps.options,
+          maxResponseAreas: normalizedResponseAreaProps.maxResponseAreas,
+          respAreaToolbar: normalizedResponseAreaProps.respAreaToolbar,
+          onHandleAreaChange: normalizedResponseAreaProps.onHandleAreaChange,
+          error: normalizedResponseAreaProps.error,
+          onFocus: function onFocus() {
+            log('[table:onFocus]...');
+
+            _this.onPluginFocus();
+          },
+          onBlur: function onBlur() {
+            log('[table:onBlur]...');
+
+            _this.onPluginBlur();
+          }
+        },
+        languageCharacters: props.languageCharactersProps,
+        media: {
+          focus: _this.focus,
+          createChange: function createChange() {
+            return _this.state.value.change();
+          },
+          onChange: _this.onChange
+        }
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onPluginBlur", function (e) {
+      log('[onPluginBlur]', e && e.relatedTarget);
+      var target = e && e.relatedTarget;
+      var node = target ? (0, _slateReact.findNode)(target, _this.state.value) : null;
+      log('[onPluginBlur] node: ', node);
+
+      _this.setState({
+        focusedNode: node
+      }, function () {
+        _this.resetValue();
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onPluginFocus", function (e) {
+      log('[onPluginFocus]', e && e.target);
+      var target = e && e.target;
+
+      if (target) {
+        var node = (0, _slateReact.findNode)(target, _this.state.value);
+        log('[onPluginFocus] node: ', node);
+        var stashedValue = _this.state.stashedValue || _this.state.value;
+
+        _this.setState({
+          focusedNode: node,
+          stashedValue: stashedValue
+        });
+      } else {
+        _this.setState({
+          focusedNode: null
+        });
+      }
+
+      _this.stashValue();
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onMathClick", function (node) {
+      _this.editor.change(function (c) {
+        return c.collapseToStartOf(node);
+      });
+
+      _this.setState({
+        selectedNode: node
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onEditingDone", function () {
+      log('[onEditingDone]');
+
+      _this.setState({
+        stashedValue: null,
+        focusedNode: null
+      });
+
+      log('[onEditingDone] value: ', _this.state.value);
+
+      _this.props.onChange(_this.state.value, true);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleBlur", function (resolve) {
+      var nonEmpty = _this.props.nonEmpty;
+      var doneOn = _this.state.toolbarOpts.doneOn;
+
+      _this.setState({
+        toolbarInFocus: false,
+        focusedNode: null
+      });
+
+      if (_this.editor) {
+        _this.editor.blur();
+      }
+
+      if (doneOn === 'blur') {
+        if (nonEmpty && _this.state.value.startText.text.length === 0) {
+          _this.resetValue(true).then(function () {
+            _this.onEditingDone();
+
+            resolve();
+          });
+        } else {
+          _this.onEditingDone();
+
+          resolve();
+        }
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onBlur", function (event) {
+      log('[onBlur]');
+      var target = event.relatedTarget;
+      var node = target ? (0, _slateReact.findNode)(target, _this.state.value) : null;
+      log('[onBlur] node: ', node);
+      return new Promise(function (resolve) {
+        _this.setState({
+          focusedNode: node
+        }, _this.handleBlur.bind((0, _assertThisInitialized2["default"])(_this), resolve));
+
+        _this.props.onBlur(event);
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleDomBlur", function (e) {
+      var editorDOM = document.querySelector("[data-key=\"".concat(_this.state.value.document.key, "\"]"));
+      setTimeout(function () {
+        if (!_this.wrapperRef) {
+          return;
+        }
+
+        var editorElement = !editorDOM || document.activeElement.closest("[class*=\"".concat(editorDOM.className, "\"]"));
+        var toolbarElement = !_this.toolbarRef || document.activeElement.closest("[class*=\"".concat(_this.toolbarRef.className, "\"]"));
+
+        var isInCurrentComponent = _this.wrapperRef.contains(editorElement) || _this.wrapperRef.contains(toolbarElement);
+
+        if (!isInCurrentComponent) {
+          editorDOM.removeEventListener('blur', _this.handleDomBlur);
+
+          _this.onBlur(e);
+        }
+      }, 50);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onFocus", function () {
+      return new Promise(function (resolve) {
+        var editorDOM = document.querySelector("[data-key=\"".concat(_this.state.value.document.key, "\"]"));
+        log('[onFocus]', document.activeElement);
+        /**
+         * This is a temporary hack - @see changeData below for some more information.
+         */
+
+        if (_this.__TEMPORARY_CHANGE_DATA) {
+          var _this$__TEMPORARY_CHA = _this.__TEMPORARY_CHANGE_DATA,
+              key = _this$__TEMPORARY_CHA.key,
+              data = _this$__TEMPORARY_CHA.data;
+          var domEl = document.querySelector("[data-key=\"".concat(key, "\"]"));
+
+          if (domEl) {
+            var change = _this.state.value.change().setNodeByKey(key, {
+              data: data
+            });
+
+            _this.setState({
+              value: change.value
+            }, function () {
+              _this.__TEMPORARY_CHANGE_DATA = null;
+            });
+          }
+        }
+        /**
+         * This is needed just in case the browser decides to make the editor
+         * lose focus without triggering the onBlur event (can happen in a few cases).
+         * This will also trigger onBlur if the user clicks outside of the page when the editor
+         * is focused.
+         */
+
+
+        if (editorDOM === document.activeElement) {
+          editorDOM.removeEventListener('blur', _this.handleDomBlur);
+          editorDOM.addEventListener('blur', _this.handleDomBlur);
+        }
+
+        _this.stashValue();
+
+        _this.props.onFocus();
+
+        resolve();
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "stashValue", function () {
+      log('[stashValue]');
+
+      if (!_this.state.stashedValue) {
+        _this.setState({
+          stashedValue: _this.state.value
+        });
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "resetValue", function (force) {
+      var _this$state = _this.state,
+          value = _this$state.value,
+          focusedNode = _this$state.focusedNode;
+
+      var stopReset = _this.plugins.reduce(function (s, p) {
+        return s || p.stopReset && p.stopReset(_this.state.value);
+      }, false);
+
+      log('[resetValue]', value.isFocused, focusedNode, 'stopReset: ', stopReset);
+
+      if (_this.state.stashedValue && !value.isFocused && !focusedNode && !stopReset || force) {
+        log('[resetValue] resetting...');
+        log('stashed', _this.state.stashedValue.document.toObject());
+        log('current', _this.state.value.document.toObject());
+
+        var newValue = _slate.Value.fromJSON(_this.state.stashedValue.toJSON());
+
+        log('newValue: ', newValue.document);
+        return new Promise(function (resolve) {
+          setTimeout(function () {
+            _this.setState({
+              value: newValue,
+              stashedValue: null
+            }, function () {
+              log('value now: ', _this.state.value.document.toJSON());
+              resolve();
+            });
+          }, 50);
+        });
+      } else {
+        return Promise.resolve({});
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onChange", function (change, done) {
+      log('[onChange]');
+      var value = change.value;
+      var charactersLimit = _this.props.charactersLimit;
+
+      if (value && value.document && value.document.text && value.document.text.length > charactersLimit) {
+        return;
+      }
+
+      _this.setState({
+        value: value
+      }, function () {
+        log('[onChange], call done()');
+
+        if (done) {
+          done();
+        }
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "valueToSize", function (v) {
+      if (!v) {
+        return;
+      }
+
+      if (typeof v === 'string') {
+        if (v.endsWith('%')) {
+          return undefined;
+        } else if (v.endsWith('px') || v.endsWith('vh') || v.endsWith('vw')) {
+          return v;
+        } else {
+          var value = parseInt(v, 10);
+          return isNaN(value) ? value : "".concat(value, "px");
+        }
+      }
+
+      if (typeof v === 'number') {
+        return "".concat(v, "px");
+      }
+
+      return;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "validateNode", function (node) {
+      if (node.object !== 'block') return;
+      var last = node.nodes.last();
+      if (!last) return;
+      if (last.type !== 'image') return;
+      log('[validateNode] last is image..');
+      var parent = last.getParent(last.key);
+
+      var p = _slate.Block.getParent(last.key);
+
+      log('[validateNode] parent:', parent, p);
+      return undefined;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "changeData", function (key, data) {
+      log('[changeData]. .. ', key, data);
+      /**
+       * HACK ALERT: We should be calling setState here and storing the change data:
+       *
+       * <code>this.setState({changeData: { key, data}})</code>
+       * However this is causing issues with the Mathquill instance. The 'input' event stops firing on the element and no
+       * more changes get through. The issues seem to be related to the promises in onBlur/onFocus. But removing these
+       * brings it's own problems. A major clean up is planned for this component so I've decided to temporarily settle
+       * on this hack rather than spend more time on this.
+       */
+      // Uncomment this line to see the bug described above.
+      // this.setState({changeData: {key, data}})
+
+      _this.__TEMPORARY_CHANGE_DATA = {
+        key: key,
+        data: data
+      };
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "focus", function (pos, node) {
+      var position = pos || 'end';
+
+      _this.props.focus(position, node);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onDropPaste", /*#__PURE__*/function () {
+      var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(event, change, dropContext) {
+        var editor, transfer, file, src, inline, range, ch;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (_this.props.imageSupport) {
+                  _context.next = 2;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 2:
+                editor = change.editor;
+                transfer = (0, _slateReact.getEventTransfer)(event);
+                file = transfer.files[0];
+
+                if (!(file.type === 'image/jpeg' || file.type === 'image/jpg' || file.type === 'image/png')) {
+                  _context.next = 20;
+                  break;
+                }
+
+                _context.prev = 6;
+                log('[onDropPaste]');
+                _context.next = 10;
+                return (0, serialization.getBase64)(file);
+
+              case 10:
+                src = _context.sent;
+                inline = _slate.Inline.create({
+                  type: 'image',
+                  isVoid: true,
+                  data: {
+                    loading: false,
+                    src: src
+                  }
+                });
+
+                if (dropContext) {
+                  _this.focus();
+                } else {
+                  range = (0, _slateReact.getEventRange)(event, editor);
+
+                  if (range) {
+                    change.select(range);
+                  }
+                }
+
+                ch = change.insertInline(inline);
+
+                _this.onChange(ch);
+
+                _context.next = 20;
+                break;
+
+              case 17:
+                _context.prev = 17;
+                _context.t0 = _context["catch"](6);
+                log('[onDropPaste] error: ', _context.t0);
+
+              case 20:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[6, 17]]);
+      }));
+
+      return function (_x, _x2, _x3) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    _this.state = {
+      value: _props.value,
+      toolbarOpts: createToolbarOpts(_props.toolbarOpts)
+    };
+
+    _this.onResize = function () {
+      _props.onChange(_this.state.value, true);
+    };
+
+    _this.handlePlugins(_this.props);
+
+    return _this;
+  }
+
+  (0, _createClass2["default"])(Editor, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+
+      // onRef is needed to get the ref of the component because we export it using withStyles
+      this.props.onRef(this);
+      window.addEventListener('resize', this.onResize);
+
+      if (this.editor && this.props.autoFocus) {
+        Promise.resolve().then(function () {
+          if (_this2.editor) {
+            var editorDOM = document.querySelector("[data-key=\"".concat(_this2.editor.value.document.key, "\"]"));
+
+            _this2.editor.focus();
+
+            if (editorDOM) {
+              editorDOM.focus();
+            }
+          }
+        });
+      }
+    }
+  }, {
+    key: "componentWillReceiveProps",
+    value: function componentWillReceiveProps(nextProps) {
+      var toolbarOpts = this.state.toolbarOpts;
+      var newToolbarOpts = createToolbarOpts(nextProps.toolbarOpts);
+
+      if (!(0, _isEqual["default"])(newToolbarOpts, toolbarOpts)) {
+        this.setState({
+          toolbarOpts: newToolbarOpts
+        });
+      }
+
+      if (!(0, _isEqual["default"])(nextProps.languageCharactersProps, this.props.languageCharactersProps)) {
+        this.handlePlugins(nextProps);
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      // The cursor is on a zero width element and when that is placed near void elements, it is not visible
+      // so we increase the width to at least 2px in order for the user to see it
+      var zeroWidthEls = document.querySelectorAll('[data-slate-zero-width="z"]');
+      Array.from(zeroWidthEls).forEach(function (el) {
+        el.style.minWidth = '2px';
+        el.style.display = 'inline-block';
+      });
+    }
+  }, {
+    key: "componentWillUnmount",
+    value:
+    /**
+     * Remove onResize event listener
+     */
+    function componentWillUnmount() {
+      window.removeEventListener('resize', this.onResize);
+    } // Allowing time for onChange to take effect if it is called
+
+  }, {
+    key: "UNSAFE_componentWillReceiveProps",
+    value: function UNSAFE_componentWillReceiveProps(props) {
+      if (!props.value.document.equals(this.props.value.document)) {
+        this.setState({
+          focus: false,
+          value: props.value
+        });
+      }
+    }
+  }, {
+    key: "buildSizeStyle",
+    value: function buildSizeStyle() {
+      var _this$props = this.props,
+          width = _this$props.width,
+          minHeight = _this$props.minHeight,
+          height = _this$props.height,
+          maxHeight = _this$props.maxHeight;
+      return {
+        width: this.valueToSize(width),
+        height: this.valueToSize(height),
+        minHeight: this.valueToSize(minHeight),
+        maxHeight: this.valueToSize(maxHeight)
+      };
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _classNames,
+          _this3 = this;
+
+      var _this$props2 = this.props,
+          disabled = _this$props2.disabled,
+          spellCheck = _this$props2.spellCheck,
+          highlightShape = _this$props2.highlightShape,
+          classes = _this$props2.classes,
+          className = _this$props2.className,
+          placeholder = _this$props2.placeholder,
+          pluginProps = _this$props2.pluginProps,
+          onKeyDown = _this$props2.onKeyDown;
+      var _this$state2 = this.state,
+          value = _this$state2.value,
+          focusedNode = _this$state2.focusedNode,
+          toolbarOpts = _this$state2.toolbarOpts;
+      log('[render] value: ', value);
+      var sizeStyle = this.buildSizeStyle();
+      var names = (0, _classnames["default"])((_classNames = {}, (0, _defineProperty2["default"])(_classNames, classes.withBg, highlightShape), (0, _defineProperty2["default"])(_classNames, classes.toolbarOnTop, toolbarOpts.alwaysVisible && toolbarOpts.position === 'top'), _classNames), className);
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        ref: function ref(_ref2) {
+          return _this3.wrapperRef = _ref2;
+        },
+        style: {
+          width: sizeStyle.width
+        },
+        className: names
+      }, /*#__PURE__*/_react["default"].createElement(_slateReact.Editor, {
+        plugins: this.plugins,
+        innerRef: function innerRef(r) {
+          if (r) {
+            _this3.slateEditor = r;
+          }
+        },
+        ref: function ref(r) {
+          return _this3.editor = r && _this3.props.editorRef(r);
+        },
+        toolbarRef: function toolbarRef(r) {
+          if (r) {
+            _this3.toolbarRef = r;
+          }
+        },
+        value: value,
+        focus: this.focus,
+        onKeyDown: onKeyDown,
+        onChange: this.onChange,
+        onBlur: this.onBlur,
+        onDrop: function onDrop(event, editor) {
+          return _this3.onDropPaste(event, editor, true);
+        },
+        onPaste: function onPaste(event, editor) {
+          return _this3.onDropPaste(event, editor);
+        },
+        onFocus: this.onFocus,
+        onEditingDone: this.onEditingDone,
+        focusedNode: focusedNode,
+        normalize: this.normalize,
+        readOnly: disabled,
+        spellCheck: spellCheck,
+        className: classes.slateEditor,
+        style: {
+          minHeight: sizeStyle.minHeight,
+          height: sizeStyle.height,
+          maxHeight: sizeStyle.maxHeight
+        },
+        pluginProps: pluginProps,
+        toolbarOpts: toolbarOpts,
+        placeholder: placeholder,
+        onDataChange: this.changeData
+      }));
+    }
+  }]);
+  return Editor;
+}(_react["default"].Component); // TODO color - hardcoded gray background and keypad colors will need to change too
+
+
+exports.Editor = Editor;
+(0, _defineProperty2["default"])(Editor, "propTypes", {
+  autoFocus: _propTypes["default"].bool,
+  editorRef: _propTypes["default"].func.isRequired,
+  onRef: _propTypes["default"].func.isRequired,
+  onChange: _propTypes["default"].func.isRequired,
+  onFocus: _propTypes["default"].func,
+  onBlur: _propTypes["default"].func,
+  onKeyDown: _propTypes["default"].func,
+  focus: _propTypes["default"].func.isRequired,
+  value: _slatePropTypes["default"].value.isRequired,
+  imageSupport: _propTypes["default"].object,
+  charactersLimit: _propTypes["default"].number,
+  width: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]),
+  height: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]),
+  minHeight: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]),
+  maxHeight: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]),
+  classes: _propTypes["default"].object.isRequired,
+  highlightShape: _propTypes["default"].bool,
+  disabled: _propTypes["default"].bool,
+  spellCheck: _propTypes["default"].bool,
+  nonEmpty: _propTypes["default"].bool,
+  disableUnderline: _propTypes["default"].bool,
+  autoWidthToolbar: _propTypes["default"].bool,
+  pluginProps: _propTypes["default"].any,
+  placeholder: _propTypes["default"].string,
+  responseAreaProps: _propTypes["default"].shape({
+    type: _propTypes["default"].oneOf(['explicit-constructed-response', 'inline-dropdown', 'drag-in-the-blank']),
+    options: _propTypes["default"].object,
+    respAreaToolbar: _propTypes["default"].func,
+    onHandleAreaChange: _propTypes["default"].func
+  }),
+  languageCharactersProps: _propTypes["default"].arrayOf(_propTypes["default"].shape({
+    language: _propTypes["default"].string,
+    characterIcon: _propTypes["default"].string,
+    characters: _propTypes["default"].arrayOf(_propTypes["default"].arrayOf(_propTypes["default"].string))
+  })),
+  toolbarOpts: _propTypes["default"].shape({
+    position: _propTypes["default"].oneOf(['bottom', 'top']),
+    alignment: _propTypes["default"].oneOf(['left', 'right']),
+    alwaysVisible: _propTypes["default"].bool,
+    showDone: _propTypes["default"].bool,
+    doneOn: _propTypes["default"].string
+  }),
+  activePlugins: _propTypes["default"].arrayOf(function (values) {
+    var allValid = values.every(function (v) {
+      return _plugins.ALL_PLUGINS.includes(v);
+    });
+    return !allValid && new Error("Invalid values: ".concat(values, ", values must be one of [").concat(_plugins.ALL_PLUGINS.join(','), "]"));
+  }),
+  className: _propTypes["default"].string,
+  maxImageWidth: _propTypes["default"].number,
+  maxImageHeight: _propTypes["default"].number
+});
+(0, _defineProperty2["default"])(Editor, "defaultProps", {
+  disableUnderline: true,
+  onFocus: function onFocus() {},
+  onBlur: function onBlur() {},
+  onKeyDown: function onKeyDown() {},
+  toolbarOpts: defaultToolbarOpts,
+  responseAreaProps: defaultResponseAreaProps,
+  languageCharactersProps: defaultLanguageCharactersProps
+});
+var styles = {
+  withBg: {
+    backgroundColor: 'rgba(0,0,0,0.06)'
+  },
+  slateEditor: {
+    fontFamily: 'Roboto, sans-serif',
+    '& table': {
+      tableLayout: 'fixed',
+      width: '100%',
+      borderCollapse: 'collapse',
+      color: _renderUi.color.text(),
+      backgroundColor: _renderUi.color.background()
+    },
+    '& table:not([border="1"]) tr': {
+      borderTop: '1px solid #dfe2e5' // TODO perhaps secondary color for background, for now disable
+      // '&:nth-child(2n)': {
+      //   backgroundColor: '#f6f8fa'
+      // }
+
+    },
+    '& td, th': {
+      padding: '.6em 1em',
+      textAlign: 'center'
+    },
+    '& table:not([border="1"]) td, th': {
+      border: '1px solid #dfe2e5'
+    }
+  },
+  toolbarOnTop: {
+    marginTop: '45px'
+  }
+};
+
+var _default = (0, _styles.withStyles)(styles)(Editor);
+
+exports["default"] = _default;
+//# sourceMappingURL=editor.js.map