Merge branch 'master' into export-yfm

browser/components/MarkdownEditor.js

@@ -1,3 +1,4 @@
+/* eslint-disable camelcase */
 import PropTypes from 'prop-types'
 import React from 'react'
 import CSSModules from 'browser/lib/CSSModules'
@@ -10,7 +11,7 @@ import ConfigManager from 'browser/main/lib/ConfigManager'
 import attachmentManagement from 'browser/main/lib/dataApi/attachmentManagement'
 
 class MarkdownEditor extends React.Component {
-  constructor (props) {
+  constructor(props) {
     super(props)
 
     // char codes for ctrl + w
@@ -20,194 +21,246 @@ class MarkdownEditor extends React.Component {
     this.supportMdSelectionBold = [16, 17, 186]
 
     this.state = {
-      status: props.config.editor.switchPreview === 'RIGHTCLICK' ? props.config.editor.delfaultStatus : 'PREVIEW',
+      status:
+        props.config.editor.switchPreview === 'RIGHTCLICK'
+          ? props.config.editor.delfaultStatus
+          : 'CODE',
       renderValue: props.value,
       keyPressed: new Set(),
-      isLocked: false
+      isLocked: props.isLocked
     }
 
-    this.lockEditorCode = () => this.handleLockEditor()
+    this.lockEditorCode = this.handleLockEditor.bind(this)
+    this.focusEditor = this.focusEditor.bind(this)
+
+    this.previewRef = React.createRef()
   }
 
-  componentDidMount () {
+  componentDidMount() {
     this.value = this.refs.code.value
     eventEmitter.on('editor:lock', this.lockEditorCode)
+    eventEmitter.on('editor:focus', this.focusEditor)
   }
 
-  componentDidUpdate () {
+  componentDidUpdate() {
     this.value = this.refs.code.value
   }
 
-  componentWillReceiveProps (props) {
+  UNSAFE_componentWillReceiveProps(props) {
     if (props.value !== this.props.value) {
       this.queueRendering(props.value)
     }
   }
 
-  componentWillUnmount () {
+  componentWillUnmount() {
     this.cancelQueue()
     eventEmitter.off('editor:lock', this.lockEditorCode)
+    eventEmitter.off('editor:focus', this.focusEditor)
   }
 
-  queueRendering (value) {
+  focusEditor() {
+    this.setState(
+      {
+        status: 'CODE'
+      },
+      () => {
+        if (this.refs.code == null) {
+          return
+        }
+        this.refs.code.focus()
+      }
+    )
+  }
+
+  queueRendering(value) {
     clearTimeout(this.renderTimer)
     this.renderTimer = setTimeout(() => {
       this.renderPreview(value)
     }, 500)
   }
 
-  cancelQueue () {
+  cancelQueue() {
     clearTimeout(this.renderTimer)
   }
 
-  renderPreview (value) {
+  renderPreview(value) {
     this.setState({
       renderValue: value
     })
   }
 
-  setValue (value) {
+  setValue(value) {
     this.refs.code.setValue(value)
   }
 
-  handleChange (e) {
+  handleChange(e) {
     this.value = this.refs.code.value
     this.props.onChange(e)
   }
 
-  handleContextMenu (e) {
+  handleContextMenu(e) {
+    if (this.state.isLocked) return
     const { config } = this.props
     if (config.editor.switchPreview === 'RIGHTCLICK') {
       const newStatus = this.state.status === 'PREVIEW' ? 'CODE' : 'PREVIEW'
-      this.setState({
-        status: newStatus
-      }, () => {
-        if (newStatus === 'CODE') {
-          this.refs.code.focus()
-        } else {
-          this.refs.preview.focus()
-        }
-        eventEmitter.emit('topbar:togglelockbutton', this.state.status)
+      this.setState(
+        {
+          status: newStatus
+        },
+        () => {
+          if (newStatus === 'CODE') {
+            this.refs.code.focus()
+          } else {
+            this.previewRef.current.focus()
+          }
+          eventEmitter.emit('topbar:togglelockbutton', this.state.status)
 
-        const newConfig = Object.assign({}, config)
-        newConfig.editor.delfaultStatus = newStatus
-        ConfigManager.set(newConfig)
-      })
+          const newConfig = Object.assign({}, config)
+          newConfig.editor.delfaultStatus = newStatus
+          ConfigManager.set(newConfig)
+        }
+      )
     }
   }
 
-  handleBlur (e) {
+  handleBlur(e) {
     if (this.state.isLocked) return
     this.setState({ keyPressed: new Set() })
     const { config } = this.props
-    if (config.editor.switchPreview === 'BLUR' ||
-        (config.editor.switchPreview === 'DBL_CLICK' && this.state.status === 'CODE')
+    if (
+      config.editor.switchPreview === 'BLUR' ||
+      (config.editor.switchPreview === 'DBL_CLICK' &&
+        this.state.status === 'CODE')
     ) {
       const cursorPosition = this.refs.code.editor.getCursor()
-      this.setState({
-        status: 'PREVIEW'
-      }, () => {
-        this.refs.preview.focus()
-        this.refs.preview.scrollTo(cursorPosition.line)
-      })
+      this.setState(
+        {
+          status: 'PREVIEW'
+        },
+        () => {
+          this.previewRef.current.focus()
+          this.previewRef.current.scrollToRow(cursorPosition.line)
+        }
+      )
       eventEmitter.emit('topbar:togglelockbutton', this.state.status)
     }
   }
 
-  handleDoubleClick (e) {
+  handleDoubleClick(e) {
     if (this.state.isLocked) return
-    this.setState({keyPressed: new Set()})
+    this.setState({ keyPressed: new Set() })
     const { config } = this.props
     if (config.editor.switchPreview === 'DBL_CLICK') {
-      this.setState({
-        status: 'CODE'
-      }, () => {
-        this.refs.code.focus()
-        eventEmitter.emit('topbar:togglelockbutton', this.state.status)
-      })
+      this.setState(
+        {
+          status: 'CODE'
+        },
+        () => {
+          this.refs.code.focus()
+          eventEmitter.emit('topbar:togglelockbutton', this.state.status)
+        }
+      )
     }
   }
 
-  handlePreviewMouseDown (e) {
+  handlePreviewMouseDown(e) {
     this.previewMouseDownedAt = new Date()
   }
 
-  handlePreviewMouseUp (e) {
+  handlePreviewMouseUp(e) {
     const { config } = this.props
-    if (config.editor.switchPreview === 'BLUR' && new Date() - this.previewMouseDownedAt < 200) {
-      this.setState({
-        status: 'CODE'
-      }, () => {
-        this.refs.code.focus()
-      })
+    if (
+      config.editor.switchPreview === 'BLUR' &&
+      new Date() - this.previewMouseDownedAt < 200
+    ) {
+      this.setState(
+        {
+          status: 'CODE'
+        },
+        () => {
+          this.refs.code.focus()
+        }
+      )
       eventEmitter.emit('topbar:togglelockbutton', this.state.status)
     }
   }
 
-  handleCheckboxClick (e) {
+  handleCheckboxClick(e) {
     e.preventDefault()
     e.stopPropagation()
     const idMatch = /checkbox-([0-9]+)/
-    const checkedMatch = /^\s*[\+\-\*] \[x\]/i
-    const uncheckedMatch = /^\s*[\+\-\*] \[ \]/
-    const checkReplace = /\[x\]/i
-    const uncheckReplace = /\[ \]/
+    const checkedMatch = /^(\s*>?)*\s*[+\-*] \[x]/i
+    const uncheckedMatch = /^(\s*>?)*\s*[+\-*] \[ ]/
+    const checkReplace = /\[x]/i
+    const uncheckReplace = /\[ ]/
     if (idMatch.test(e.target.getAttribute('id'))) {
-      const lineIndex = parseInt(e.target.getAttribute('id').match(idMatch)[1], 10) - 1
-      const lines = this.refs.code.value
-        .split('\n')
+      const lineIndex =
+        parseInt(e.target.getAttribute('id').match(idMatch)[1], 10) - 1
+      const lines = this.refs.code.value.split('\n')
 
       const targetLine = lines[lineIndex]
+      let newLine = targetLine
 
       if (targetLine.match(checkedMatch)) {
-        lines[lineIndex] = targetLine.replace(checkReplace, '[ ]')
+        newLine = targetLine.replace(checkReplace, '[ ]')
       }
       if (targetLine.match(uncheckedMatch)) {
-        lines[lineIndex] = targetLine.replace(uncheckReplace, '[x]')
+        newLine = targetLine.replace(uncheckReplace, '[x]')
       }
-      this.refs.code.setValue(lines.join('\n'))
+      this.refs.code.setLineContent(lineIndex, newLine)
     }
   }
 
-  focus () {
+  focus() {
     if (this.state.status === 'PREVIEW') {
-      this.setState({
-        status: 'CODE'
-      }, () => {
-        this.refs.code.focus()
-      })
+      this.setState(
+        {
+          status: 'CODE'
+        },
+        () => {
+          this.refs.code.focus()
+        }
+      )
     } else {
       this.refs.code.focus()
     }
     eventEmitter.emit('topbar:togglelockbutton', this.state.status)
   }
 
-  reload () {
+  reload() {
     this.refs.code.reload()
     this.cancelQueue()
     this.renderPreview(this.props.value)
   }
 
-  handleKeyDown (e) {
+  handleKeyDown(e) {
     const { config } = this.props
     if (this.state.status !== 'CODE') return false
     const keyPressed = this.state.keyPressed
     keyPressed.add(e.keyCode)
     this.setState({ keyPressed })
-    const isNoteHandlerKey = (el) => { return keyPressed.has(el) }
+    const isNoteHandlerKey = el => {
+      return keyPressed.has(el)
+    }
     // These conditions are for ctrl-e and ctrl-w
-    if (keyPressed.size === this.escapeFromEditor.length &&
-        !this.state.isLocked && this.state.status === 'CODE' &&
-        this.escapeFromEditor.every(isNoteHandlerKey)) {
+    if (
+      keyPressed.size === this.escapeFromEditor.length &&
+      !this.state.isLocked &&
+      this.state.status === 'CODE' &&
+      this.escapeFromEditor.every(isNoteHandlerKey)
+    ) {
       this.handleContextMenu()
       if (config.editor.switchPreview === 'BLUR') document.activeElement.blur()
     }
-    if (keyPressed.size === this.supportMdSelectionBold.length && this.supportMdSelectionBold.every(isNoteHandlerKey)) {
+    if (
+      keyPressed.size === this.supportMdSelectionBold.length &&
+      this.supportMdSelectionBold.every(isNoteHandlerKey)
+    ) {
       this.addMdAroundWord('**')
     }
   }
 
-  addMdAroundWord (mdElement) {
+  addMdAroundWord(mdElement) {
     if (this.refs.code.editor.getSelection()) {
       return this.addMdAroundSelection(mdElement)
     }
@@ -215,47 +268,64 @@ class MarkdownEditor extends React.Component {
     const word = this.refs.code.editor.findWordAt(currentCaret)
     const cmDoc = this.refs.code.editor.getDoc()
     cmDoc.replaceRange(mdElement, word.anchor)
-    cmDoc.replaceRange(mdElement, { line: word.head.line, ch: word.head.ch + mdElement.length })
-  }
-
-  addMdAroundSelection (mdElement) {
-    this.refs.code.editor.replaceSelection(`${mdElement}${this.refs.code.editor.getSelection()}${mdElement}`)
-  }
-
-  handleDropImage (dropEvent) {
-    dropEvent.preventDefault()
-    const { storageKey, noteKey } = this.props
-
-    this.setState({
-      status: 'CODE'
-    }, () => {
-      this.refs.code.focus()
-
-      this.refs.code.editor.execCommand('goDocEnd')
-      this.refs.code.editor.execCommand('goLineEnd')
-      this.refs.code.editor.execCommand('newlineAndIndent')
-
-      attachmentManagement.handleAttachmentDrop(
-        this.refs.code,
-        storageKey,
-        noteKey,
-        dropEvent
-      )
+    cmDoc.replaceRange(mdElement, {
+      line: word.head.line,
+      ch: word.head.ch + mdElement.length
     })
   }
 
-  handleKeyUp (e) {
+  addMdAroundSelection(mdElement) {
+    this.refs.code.editor.replaceSelection(
+      `${mdElement}${this.refs.code.editor.getSelection()}${mdElement}`
+    )
+  }
+
+  handleDropImage(dropEvent) {
+    dropEvent.preventDefault()
+    const { storageKey, noteKey } = this.props
+
+    this.setState(
+      {
+        status: 'CODE'
+      },
+      () => {
+        this.refs.code.focus()
+
+        this.refs.code.editor.execCommand('goDocEnd')
+        this.refs.code.editor.execCommand('goLineEnd')
+        this.refs.code.editor.execCommand('newlineAndIndent')
+
+        attachmentManagement.handleAttachmentDrop(
+          this.refs.code,
+          storageKey,
+          noteKey,
+          dropEvent
+        )
+      }
+    )
+  }
+
+  handleKeyUp(e) {
     const keyPressed = this.state.keyPressed
     keyPressed.delete(e.keyCode)
     this.setState({ keyPressed })
   }
 
-  handleLockEditor () {
+  handleLockEditor() {
     this.setState({ isLocked: !this.state.isLocked })
   }
 
-  render () {
-    const {className, value, config, storageKey, noteKey, linesHighlighted, getNote} = this.props
+  render() {
+    const {
+      className,
+      value,
+      config,
+      storageKey,
+      noteKey,
+      linesHighlighted,
+      getNote,
+      RTL
+    } = this.props
 
     let editorFontSize = parseInt(config.editor.fontSize, 10)
     if (!(editorFontSize > 0 && editorFontSize < 101)) editorFontSize = 14
@@ -263,23 +333,24 @@ class MarkdownEditor extends React.Component {
     if (!(editorFontSize > 0 && editorFontSize < 132)) editorIndentSize = 4
 
     const previewStyle = {}
-    if (this.props.ignorePreviewPointerEvents) previewStyle.pointerEvents = 'none'
+    if (this.props.ignorePreviewPointerEvents)
+      previewStyle.pointerEvents = 'none'
 
     const storage = findStorage(storageKey)
 
     return (
-      <div className={className == null
-          ? 'MarkdownEditor'
-          : `MarkdownEditor ${className}`
+      <div
+        className={
+          className == null ? 'MarkdownEditor' : `MarkdownEditor ${className}`
         }
-        onContextMenu={(e) => this.handleContextMenu(e)}
+        onContextMenu={e => this.handleContextMenu(e)}
         tabIndex='-1'
-        onKeyDown={(e) => this.handleKeyDown(e)}
-        onKeyUp={(e) => this.handleKeyUp(e)}
+        onKeyDown={e => this.handleKeyDown(e)}
+        onKeyUp={e => this.handleKeyUp(e)}
       >
-        <CodeEditor styleName={this.state.status === 'CODE'
-            ? 'codeEditor'
-            : 'codeEditor--hide'
+        <CodeEditor
+          styleName={
+            this.state.status === 'CODE' ? 'codeEditor' : 'codeEditor--hide'
           }
           ref='code'
           mode='Boost Flavored Markdown'
@@ -293,6 +364,7 @@ class MarkdownEditor extends React.Component {
           enableRulers={config.editor.enableRulers}
           rulers={config.editor.rulers}
           displayLineNumbers={config.editor.displayLineNumbers}
+          lineWrapping
           matchingPairs={config.editor.matchingPairs}
           matchingTriples={config.editor.matchingTriples}
           explodingPairs={config.editor.explodingPairs}
@@ -302,16 +374,22 @@ class MarkdownEditor extends React.Component {
           fetchUrlTitle={config.editor.fetchUrlTitle}
           enableTableEditor={config.editor.enableTableEditor}
           linesHighlighted={linesHighlighted}
-          onChange={(e) => this.handleChange(e)}
-          onBlur={(e) => this.handleBlur(e)}
+          onChange={e => this.handleChange(e)}
+          onBlur={e => this.handleBlur(e)}
           spellCheck={config.editor.spellcheck}
           enableSmartPaste={config.editor.enableSmartPaste}
           hotkey={config.hotkey}
           switchPreview={config.editor.switchPreview}
+          enableMarkdownLint={config.editor.enableMarkdownLint}
+          customMarkdownLintConfig={config.editor.customMarkdownLintConfig}
+          prettierConfig={config.editor.prettierConfig}
+          deleteUnusedAttachments={config.editor.deleteUnusedAttachments}
+          RTL={RTL}
         />
-        <MarkdownPreview styleName={this.state.status === 'PREVIEW'
-            ? 'preview'
-            : 'preview--hide'
+        <MarkdownPreview
+          ref={this.previewRef}
+          styleName={
+            this.state.status === 'PREVIEW' ? 'preview' : 'preview--hide'
           }
           style={previewStyle}
           theme={config.ui.theme}
@@ -327,14 +405,14 @@ class MarkdownEditor extends React.Component {
           smartArrows={config.preview.smartArrows}
           breaks={config.preview.breaks}
           sanitize={config.preview.sanitize}
-          ref='preview'
-          onContextMenu={(e) => this.handleContextMenu(e)}
-          onDoubleClick={(e) => this.handleDoubleClick(e)}
+          mermaidHTMLLabel={config.preview.mermaidHTMLLabel}
+          onContextMenu={e => this.handleContextMenu(e)}
+          onDoubleClick={e => this.handleDoubleClick(e)}
           tabIndex='0'
           value={this.state.renderValue}
-          onMouseUp={(e) => this.handlePreviewMouseUp(e)}
-          onMouseDown={(e) => this.handlePreviewMouseDown(e)}
-          onCheckboxClick={(e) => this.handleCheckboxClick(e)}
+          onMouseUp={e => this.handlePreviewMouseUp(e)}
+          onMouseDown={e => this.handlePreviewMouseDown(e)}
+          onCheckboxClick={e => this.handleCheckboxClick(e)}
           showCopyNotification={config.ui.showCopyNotification}
           storagePath={storage.path}
           noteKey={noteKey}
@@ -343,7 +421,8 @@ class MarkdownEditor extends React.Component {
           lineThroughCheckbox={config.preview.lineThroughCheckbox}
           getNote={getNote}
           export={config.export}
-          onDrop={(e) => this.handleDropImage(e)}
+          onDrop={e => this.handleDropImage(e)}
+          RTL={RTL}
         />
       </div>
     )