@chaoswise/ui 3.0.6 → 3.0.8

package/lib/Ace/ace.js

@@ -0,0 +1,600 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+import PropTypes from 'prop-types';
+import React from 'react';
+import { isEqual } from 'lodash-es';
+import { Range } from '@chaoswise/ace';
+import { getAceInstance, editorEvents, debounce, editorOptions } from './editorOptions';
+var ace = getAceInstance();
+var ReactAce = /*#__PURE__*/function (_React$Component) {
+  function ReactAce(props) {
+    var _this;
+    _classCallCheck(this, ReactAce);
+    _this = _callSuper(this, ReactAce, [props]);
+    editorEvents.forEach(function (method) {
+      _this[method] = _this[method].bind(_this);
+    });
+    _this.debounce = debounce;
+    return _this;
+  }
+  _inherits(ReactAce, _React$Component);
+  return _createClass(ReactAce, [{
+    key: "isInShadow",
+    value: function isInShadow(node) {
+      var parent = node && node.parentNode;
+      while (parent) {
+        if (parent.toString() === '[object ShadowRoot]') {
+          return true;
+        }
+        parent = parent.parentNode;
+      }
+      return false;
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+      var _this$props = this.props,
+        className = _this$props.className,
+        onBeforeLoad = _this$props.onBeforeLoad,
+        onValidate = _this$props.onValidate,
+        mode = _this$props.mode,
+        focus = _this$props.focus,
+        theme = _this$props.theme,
+        fontSize = _this$props.fontSize,
+        value = _this$props.value,
+        defaultValue = _this$props.defaultValue,
+        showGutter = _this$props.showGutter,
+        wrapEnabled = _this$props.wrapEnabled,
+        showPrintMargin = _this$props.showPrintMargin,
+        _this$props$scrollMar = _this$props.scrollMargin,
+        scrollMargin = _this$props$scrollMar === void 0 ? [0, 0, 0, 0] : _this$props$scrollMar,
+        keyboardHandler = _this$props.keyboardHandler,
+        onLoad = _this$props.onLoad,
+        commands = _this$props.commands,
+        annotations = _this$props.annotations,
+        markers = _this$props.markers,
+        placeholder = _this$props.placeholder;
+      this.editor = ace.edit(this.refEditor);
+      if (onBeforeLoad) {
+        onBeforeLoad(ace);
+      }
+      var editorProps = Object.keys(this.props.editorProps);
+      for (var i = 0; i < editorProps.length; i++) {
+        this.editor[editorProps[i]] = this.props.editorProps[editorProps[i]];
+      }
+      if (this.props.debounceChangePeriod) {
+        this.onChange = this.debounce(this.onChange, this.props.debounceChangePeriod);
+      }
+      this.editor.renderer.setScrollMargin(scrollMargin[0], scrollMargin[1], scrollMargin[2], scrollMargin[3]);
+      if (this.isInShadow(this.refEditor)) {
+        this.editor.renderer.attachToShadowRoot();
+      }
+      this.editor.getSession().setMode(typeof mode === 'string' ? "ace/mode/".concat(mode) : mode);
+      if (theme && theme !== '') this.editor.setTheme("ace/theme/".concat(theme));
+      this.editor.setFontSize(typeof fontSize === 'number' ? "".concat(fontSize, "px") : fontSize);
+      this.editor.getSession().setValue(!defaultValue ? value || '' : defaultValue);
+      if (this.props.navigateToFileEnd) {
+        this.editor.navigateFileEnd();
+      }
+      this.editor.renderer.setShowGutter(showGutter);
+      this.editor.getSession().setUseWrapMode(wrapEnabled);
+      this.editor.setShowPrintMargin(showPrintMargin);
+      this.editor.on('focus', this.onFocus);
+      this.editor.on('blur', this.onBlur);
+      this.editor.on('copy', this.onCopy);
+      this.editor.on('paste', this.onPaste);
+      this.editor.on('change', this.onChange);
+      this.editor.on('input', this.onInput);
+      if (placeholder) {
+        this.updatePlaceholder();
+      }
+      this.editor.getSession().selection.on('changeSelection', this.onSelectionChange);
+      this.editor.getSession().selection.on('changeCursor', this.onCursorChange);
+      if (onValidate) {
+        // @ts-ignore types don't include
+        this.editor.getSession().on('changeAnnotation', function () {
+          // tslint:disable-next-line:no-shadowed-variable
+          var annotations = _this2.editor.getSession().getAnnotations();
+          _this2.props.onValidate(annotations);
+        });
+      }
+      this.editor.session.on('changeScrollTop', this.onScroll);
+      this.editor.getSession().setAnnotations(annotations || []);
+      if (markers && markers.length > 0) {
+        this.handleMarkers(markers);
+      }
+      // get a list of possible options to avoid 'misspelled option errors'
+      var availableOptions = this.editor.$options;
+      editorOptions.forEach(function (option) {
+        if (availableOptions.hasOwnProperty(option)) {
+          // @ts-ignore
+          _this2.editor.setOption(option, _this2.props[option]);
+        } else if (_this2.props[option]) {
+          console.warn("ReactAce: editor option ".concat(option, " was activated but not found. Did you need to import a related tool or did you possibly mispell the option?"));
+        }
+      });
+      this.handleOptions(this.props);
+      if (Array.isArray(commands)) {
+        commands.forEach(function (command) {
+          if (typeof command.exec === 'string') {
+            _this2.editor.commands.bindKey(command.bindKey, command.exec);
+          } else {
+            _this2.editor.commands.addCommand(command);
+          }
+        });
+      }
+      if (keyboardHandler) {
+        this.editor.setKeyboardHandler('ace/keyboard/' + keyboardHandler);
+      }
+      if (className) {
+        this.refEditor.className += ' ' + className;
+      }
+      if (onLoad) {
+        onLoad(this.editor);
+      }
+      this.editor.resize();
+      if (focus) {
+        this.editor.focus();
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var oldProps = prevProps;
+      var nextProps = this.props;
+      for (var i = 0; i < editorOptions.length; i++) {
+        var option = editorOptions[i];
+        if (nextProps[option] !== oldProps[option]) {
+          // @ts-ignore
+          this.editor.setOption(option, nextProps[option]);
+        }
+      }
+      if (nextProps.className !== oldProps.className) {
+        var appliedClasses = this.refEditor.className;
+        var appliedClassesArray = appliedClasses.trim().split(' ');
+        var oldClassesArray = oldProps.className.trim().split(' ');
+        oldClassesArray.forEach(function (oldClass) {
+          var index = appliedClassesArray.indexOf(oldClass);
+          appliedClassesArray.splice(index, 1);
+        });
+        this.refEditor.className = ' ' + nextProps.className + ' ' + appliedClassesArray.join(' ');
+      }
+      // First process editor value, as it may create a new session (see issue #300)
+      var valueChanged = this.editor && nextProps.value != null && this.editor.getValue() !== nextProps.value;
+      if (valueChanged) {
+        // editor.setValue is a synchronous function call, change event is emitted before setValue return.
+        this.silent = true;
+        var pos = this.editor.session.selection.toJSON();
+        this.editor.setValue(nextProps.value, nextProps.cursorStart);
+        this.editor.session.selection.fromJSON(pos);
+        this.silent = false;
+      }
+      if (nextProps.placeholder !== oldProps.placeholder) {
+        this.updatePlaceholder();
+      }
+      if (nextProps.mode !== oldProps.mode) {
+        this.editor.getSession().setMode(typeof nextProps.mode === 'string' ? "ace/mode/".concat(nextProps.mode) : nextProps.mode);
+      }
+      if (nextProps.theme !== oldProps.theme) {
+        this.editor.setTheme('ace/theme/' + nextProps.theme);
+      }
+      if (nextProps.keyboardHandler !== oldProps.keyboardHandler) {
+        if (nextProps.keyboardHandler) {
+          this.editor.setKeyboardHandler('ace/keyboard/' + nextProps.keyboardHandler);
+        } else {
+          this.editor.setKeyboardHandler(null);
+        }
+      }
+      if (nextProps.fontSize !== oldProps.fontSize) {
+        this.editor.setFontSize(typeof nextProps.fontSize === 'number' ? "".concat(nextProps.fontSize, "px") : nextProps.fontSize);
+      }
+      if (nextProps.wrapEnabled !== oldProps.wrapEnabled) {
+        this.editor.getSession().setUseWrapMode(nextProps.wrapEnabled);
+      }
+      if (nextProps.showPrintMargin !== oldProps.showPrintMargin) {
+        this.editor.setShowPrintMargin(nextProps.showPrintMargin);
+      }
+      if (nextProps.showGutter !== oldProps.showGutter) {
+        this.editor.renderer.setShowGutter(nextProps.showGutter);
+      }
+      if (!isEqual(nextProps.setOptions, oldProps.setOptions)) {
+        this.handleOptions(nextProps);
+      }
+      // if the value or annotations changed, set the annotations
+      // changing the value may create a new session which will require annotations to be re-set
+      if (valueChanged || !isEqual(nextProps.annotations, oldProps.annotations)) {
+        this.editor.getSession().setAnnotations(nextProps.annotations || []);
+      }
+      if (!isEqual(nextProps.markers, oldProps.markers) && Array.isArray(nextProps.markers)) {
+        this.handleMarkers(nextProps.markers);
+      }
+      // this doesn't look like it works at all....
+      if (!isEqual(nextProps.scrollMargin, oldProps.scrollMargin)) {
+        this.handleScrollMargins(nextProps.scrollMargin);
+      }
+      if (prevProps.height !== this.props.height || prevProps.width !== this.props.width) {
+        this.editor.resize();
+      }
+      if (this.props.focus && !prevProps.focus) {
+        this.editor.focus();
+      }
+    }
+  }, {
+    key: "handleScrollMargins",
+    value: function handleScrollMargins() {
+      var margins = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [0, 0, 0, 0];
+      this.editor.renderer.setScrollMargin(margins[0], margins[1], margins[2], margins[3]);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.editor) {
+        this.editor.destroy();
+        this.editor = null;
+      }
+    }
+  }, {
+    key: "onChange",
+    value: function onChange(event) {
+      if (this.props.onChange && !this.silent) {
+        var value = this.editor.getValue();
+        this.props.onChange(value, event);
+      }
+    }
+  }, {
+    key: "onSelectionChange",
+    value: function onSelectionChange(event) {
+      if (this.props.onSelectionChange) {
+        var value = this.editor.getSelection();
+        this.props.onSelectionChange(value, event);
+      }
+    }
+  }, {
+    key: "onCursorChange",
+    value: function onCursorChange(event) {
+      if (this.props.onCursorChange) {
+        var value = this.editor.getSelection();
+        this.props.onCursorChange(value, event);
+      }
+    }
+  }, {
+    key: "onInput",
+    value: function onInput(event) {
+      if (this.props.onInput) {
+        this.props.onInput(event);
+      }
+      if (this.props.placeholder) {
+        this.updatePlaceholder();
+      }
+    }
+  }, {
+    key: "onFocus",
+    value: function onFocus(event) {
+      if (this.props.onFocus) {
+        this.props.onFocus(event, this.editor);
+      }
+    }
+  }, {
+    key: "onBlur",
+    value: function onBlur(event) {
+      if (this.props.onBlur) {
+        this.props.onBlur(event, this.editor);
+      }
+    }
+  }, {
+    key: "onCopy",
+    value: function onCopy(_ref) {
+      var text = _ref.text;
+      if (this.props.onCopy) {
+        this.props.onCopy(text);
+      }
+    }
+  }, {
+    key: "onPaste",
+    value: function onPaste(_ref2) {
+      var text = _ref2.text;
+      if (this.props.onPaste) {
+        this.props.onPaste(text);
+      }
+    }
+  }, {
+    key: "onScroll",
+    value: function onScroll() {
+      if (this.props.onScroll) {
+        this.props.onScroll(this.editor);
+      }
+    }
+  }, {
+    key: "handleOptions",
+    value: function handleOptions(props) {
+      var setOptions = Object.keys(props.setOptions);
+      for (var y = 0; y < setOptions.length; y++) {
+        // @ts-ignore
+        this.editor.setOption(setOptions[y], props.setOptions[setOptions[y]]);
+      }
+    }
+  }, {
+    key: "handleMarkers",
+    value: function handleMarkers(markers) {
+      var _this3 = this;
+      // remove foreground markers
+      var currentMarkers = this.editor.getSession().getMarkers(true);
+      for (var i in currentMarkers) {
+        if (currentMarkers.hasOwnProperty(i)) {
+          this.editor.getSession().removeMarker(currentMarkers[i].id);
+        }
+      }
+      // remove background markers except active line marker and selected word marker
+      currentMarkers = this.editor.getSession().getMarkers(false);
+      for (var _i in currentMarkers) {
+        if (currentMarkers.hasOwnProperty(_i) && currentMarkers[_i].clazz !== 'ace_active-line' && currentMarkers[_i].clazz !== 'ace_selected-word') {
+          this.editor.getSession().removeMarker(currentMarkers[_i].id);
+        }
+      }
+      // add new markers
+      markers.forEach(function (_ref3) {
+        var startRow = _ref3.startRow,
+          startCol = _ref3.startCol,
+          endRow = _ref3.endRow,
+          endCol = _ref3.endCol,
+          className = _ref3.className,
+          type = _ref3.type,
+          _ref3$inFront = _ref3.inFront,
+          inFront = _ref3$inFront === void 0 ? false : _ref3$inFront;
+        var range = new Range(startRow, startCol, endRow, endCol);
+        _this3.editor.getSession().addMarker(range, className, type, inFront);
+      });
+    }
+  }, {
+    key: "updatePlaceholder",
+    value: function updatePlaceholder() {
+      // Adapted from https://stackoverflow.com/questions/26695708/how-can-i-add-placeholder-text-when-the-editor-is-empty
+      var editor = this.editor;
+      var placeholder = this.props.placeholder;
+      var showPlaceholder = !editor.session.getValue().length;
+      var node = editor.renderer.placeholderNode;
+      if (!showPlaceholder && node) {
+        editor.renderer.scroller.removeChild(editor.renderer.placeholderNode);
+        editor.renderer.placeholderNode = null;
+      } else if (showPlaceholder && !node) {
+        node = editor.renderer.placeholderNode = document.createElement('div');
+        node.textContent = placeholder || '';
+        node.className = 'ace_comment ace_placeholder';
+        node.style.padding = '0 9px';
+        node.style.position = 'absolute';
+        node.style.zIndex = '3';
+        editor.renderer.scroller.appendChild(node);
+      } else if (showPlaceholder && node) {
+        node.textContent = placeholder;
+      }
+    }
+  }, {
+    key: "updateRef",
+    value: function updateRef(item) {
+      this.refEditor = item;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+        name = _this$props2.name,
+        width = _this$props2.width,
+        height = _this$props2.height,
+        style = _this$props2.style;
+      var divStyle = Object.assign({
+        width: width,
+        height: height
+      }, style);
+      return /*#__PURE__*/React.createElement('div', {
+        ref: this.updateRef,
+        id: name,
+        style: divStyle
+      });
+    }
+  }]);
+}(React.Component);
+ReactAce.propTypes = {
+  /**
+   * 编辑器语言模型，可选：
+   * abap| abc| actionscript| ada| alda| apache_conf| apex| aql| asciidoc| asl| assembly_x86| autohotkey
+   * | batchfile| c_cpp| c9search| cirru| clojure| cobol| coffee| coldfusion| crystal| csharp| csound_document
+   * | csound_orchestra| csound_score| css| curly| d| dart| diff| dockerfile| dot| drools| edifact| eiffel| ejs
+   * | elixir| elm| erlang| forth| fortran| fsharp| fsl| ftl| gcode| gherkin| gitignore| glsl| gobstones| golang
+   * | graphqlschema| groovy| haml| handlebars| haskell| haskell_cabal| haxe| hjson| html| html_elixir| html_ruby
+   * | ini| io| jack| jade| java| javascript| json| json5| jsoniq| jsp| jssm| jsx| julia| kotlin| latex| less| liquid| lisp
+   * | livescript| logiql| lsl| lua| luapage| lucene| makefile| markdown| mask| matlab| maze| mediawiki| mel| mips| mixal
+   * | mushcode| mysql| nginx| nim| nix| nsis| nunjucks| objectivec| ocaml| pascal| perl| perl6| pgsql| php| php_laravel_blade
+   * | pig| powershell| praat| prisma| prolog| properties| protobuf| puppet| python| qml| r| razor| rdoc| red| rhtml| rst
+   * | ruby| rust| sass| scad| scala| scheme| scss| sh| sjs| slim| smarty| smithy| snippets| soy_template| space| sql
+   * | sqlserver| stylus| svg| swift| tcl| terraform| tex| text| textile| toml| tsx| twig| typescript| vala| vbscript
+   * | velocity| verilog| vhdl| visualforce| wollok| xml| xquery| yaml| zeek| django| flink
+   */
+  mode: PropTypes.string,
+  /**
+   * 是否获取焦点
+   */
+  focus: PropTypes.bool,
+  /**
+   * 主题
+   * 亮色可选：chrome | clouds | crimson_editor | dawn | dreamweaver | eclipse | github | iplastic | solarized_light | textmate | tomorrow | xcode | kuroir | katzenmilch | sqlserver
+   * <br>暗色可选：ambiance | chaos | clouds_midnight | dracula | cobalt | gruvbox | gob | idle_fingers | kr_theme | merbivore
+   * | merbivore_soft | mono_industrial | monokai | nord_dark | pastel_on_dark | solarized_dark | terminal | tomorrow_night | tomorrow_night_blue | tomorrow_night_bright | tomorrow_night_eighties | twilight | vibrant_ink
+   */
+  theme: PropTypes.string,
+  /**
+   * 编辑器的唯一ID
+   */
+  name: PropTypes.string,
+  /**
+   * 自定义类
+   */
+  className: PropTypes.string,
+  height: PropTypes.string,
+  width: PropTypes.string,
+  fontSize: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  /**
+   * 是否展示左侧栏
+   */
+  showGutter: PropTypes.bool,
+  /**
+   * 文档改变触发，onChange(value, event)
+   */
+  onChange: PropTypes.func,
+  /**
+   * copy事件，onCopy(text)
+   */
+  onCopy: PropTypes.func,
+  /**
+   * 粘贴事件，onPaste(text)
+   */
+  onPaste: PropTypes.func,
+  /**
+   * 获取焦点事件
+   */
+  onFocus: PropTypes.func,
+  /**
+   * 输入事件
+   */
+  onInput: PropTypes.func,
+  /**
+   * 失去焦点事件
+   */
+  onBlur: PropTypes.func,
+  /**
+   * 滚动事件
+   */
+  onScroll: PropTypes.func,
+  /**
+   * 编辑器的值
+   */
+  value: PropTypes.string,
+  /**
+   * 编辑器默认值
+   */
+  defaultValue: PropTypes.string,
+  /**
+   * 编辑器加载事件
+   */
+  onLoad: PropTypes.func,
+  /**
+   * 选择内容更改事件
+   */
+  onSelectionChange: PropTypes.func,
+  /**
+   * 光标改变事件
+   */
+  onCursorChange: PropTypes.func,
+  /**
+   * 编辑器加载前
+   */
+  onBeforeLoad: PropTypes.func,
+  /**
+   * 注释更改事件
+   */
+  onValidate: PropTypes.func,
+  /**
+   * 最小行数
+   */
+  minLines: PropTypes.number,
+  /**
+   * 最大行数
+   */
+  maxLines: PropTypes.number,
+  /**
+   * 只读
+   */
+  readOnly: PropTypes.bool,
+  /**
+   * 高亮行数
+   */
+  highlightActiveLine: PropTypes.bool,
+  tabSize: PropTypes.number,
+  /**
+   * 显示打印边距
+   */
+  showPrintMargin: PropTypes.bool,
+  /**
+   * 光标位置
+   */
+  cursorStart: PropTypes.number,
+  /**
+   * onChange事件的抖动延迟时间
+   */
+  debounceChangePeriod: PropTypes.number,
+  /**
+   * 直接应用于Ace编辑器实例的props
+   */
+  editorProps: PropTypes.object,
+  /**
+   * 直接应用于Ace编辑器实例的选项
+   */
+  setOptions: PropTypes.object,
+  style: PropTypes.object,
+  scrollMargin: PropTypes.array,
+  /**
+   * 注释设置
+   */
+  annotations: PropTypes.array,
+  /**
+   * 标记设置
+   */
+  markers: PropTypes.array,
+  /**
+   * 键盘模式
+   */
+  keyboardHandler: PropTypes.string,
+  wrapEnabled: PropTypes.bool,
+  enableSnippets: PropTypes.bool,
+  enableBasicAutocompletion: PropTypes.oneOfType([PropTypes.bool, PropTypes.array]),
+  enableLiveAutocompletion: PropTypes.oneOfType([PropTypes.bool, PropTypes.array]),
+  navigateToFileEnd: PropTypes.bool,
+  commands: PropTypes.array,
+  /**
+   * 编辑器为空时要显示的占位符文本
+   */
+  placeholder: PropTypes.string
+};
+ReactAce.defaultProps = {
+  name: 'ace-editor',
+  focus: false,
+  mode: '',
+  theme: '',
+  height: '500px',
+  width: '500px',
+  fontSize: 12,
+  enableSnippets: false,
+  showGutter: true,
+  onChange: null,
+  onPaste: null,
+  onLoad: null,
+  onScroll: null,
+  minLines: null,
+  maxLines: null,
+  readOnly: false,
+  highlightActiveLine: true,
+  showPrintMargin: true,
+  tabSize: 4,
+  cursorStart: 1,
+  editorProps: {},
+  style: {},
+  scrollMargin: [0, 0, 0, 0],
+  setOptions: {},
+  wrapEnabled: false,
+  enableBasicAutocompletion: false,
+  enableLiveAutocompletion: false,
+  placeholder: null,
+  navigateToFileEnd: true
+};
+export default ReactAce;