@muze-nl/simplystore 0.3.6 → 0.4.0

package/www/codemirror/src/input/TextareaInput.js

@@ -1,380 +0,0 @@
-import { operation, runInOp } from "../display/operations.js"
-import { prepareSelection } from "../display/selection.js"
-import { applyTextInput, copyableRanges, handlePaste, hiddenTextarea, disableBrowserMagic, setLastCopied } from "./input.js"
-import { cursorCoords, posFromMouse } from "../measurement/position_measurement.js"
-import { eventInWidget } from "../measurement/widgets.js"
-import { simpleSelection } from "../model/selection.js"
-import { selectAll, setSelection } from "../model/selection_updates.js"
-import { captureRightClick, ie, ie_version, ios, mac, mobile, presto, webkit } from "../util/browser.js"
-import { activeElt, removeChildrenAndAdd, selectInput } from "../util/dom.js"
-import { e_preventDefault, e_stop, off, on, signalDOMEvent } from "../util/event.js"
-import { hasSelection } from "../util/feature_detection.js"
-import { Delayed, sel_dontScroll } from "../util/misc.js"
-
-// TEXTAREA INPUT STYLE
-
-export default class TextareaInput {
-  constructor(cm) {
-    this.cm = cm
-    // See input.poll and input.reset
-    this.prevInput = ""
-
-    // Flag that indicates whether we expect input to appear real soon
-    // now (after some event like 'keypress' or 'input') and are
-    // polling intensively.
-    this.pollingFast = false
-    // Self-resetting timeout for the poller
-    this.polling = new Delayed()
-    // Used to work around IE issue with selection being forgotten when focus moves away from textarea
-    this.hasSelection = false
-    this.composing = null
-    this.resetting = false
-  }
-
-  init(display) {
-    let input = this, cm = this.cm
-    this.createField(display)
-    const te = this.textarea
-
-    display.wrapper.insertBefore(this.wrapper, display.wrapper.firstChild)
-
-    // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
-    if (ios) te.style.width = "0px"
-
-    on(te, "input", () => {
-      if (ie && ie_version >= 9 && this.hasSelection) this.hasSelection = null
-      input.poll()
-    })
-
-    on(te, "paste", e => {
-      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) return
-
-      cm.state.pasteIncoming = +new Date
-      input.fastPoll()
-    })
-
-    function prepareCopyCut(e) {
-      if (signalDOMEvent(cm, e)) return
-      if (cm.somethingSelected()) {
-        setLastCopied({lineWise: false, text: cm.getSelections()})
-      } else if (!cm.options.lineWiseCopyCut) {
-        return
-      } else {
-        let ranges = copyableRanges(cm)
-        setLastCopied({lineWise: true, text: ranges.text})
-        if (e.type == "cut") {
-          cm.setSelections(ranges.ranges, null, sel_dontScroll)
-        } else {
-          input.prevInput = ""
-          te.value = ranges.text.join("\n")
-          selectInput(te)
-        }
-      }
-      if (e.type == "cut") cm.state.cutIncoming = +new Date
-    }
-    on(te, "cut", prepareCopyCut)
-    on(te, "copy", prepareCopyCut)
-
-    on(display.scroller, "paste", e => {
-      if (eventInWidget(display, e) || signalDOMEvent(cm, e)) return
-      if (!te.dispatchEvent) {
-        cm.state.pasteIncoming = +new Date
-        input.focus()
-        return
-      }
-
-      // Pass the `paste` event to the textarea so it's handled by its event listener.
-      const event = new Event("paste")
-      event.clipboardData = e.clipboardData
-      te.dispatchEvent(event)
-    })
-
-    // Prevent normal selection in the editor (we handle our own)
-    on(display.lineSpace, "selectstart", e => {
-      if (!eventInWidget(display, e)) e_preventDefault(e)
-    })
-
-    on(te, "compositionstart", () => {
-      let start = cm.getCursor("from")
-      if (input.composing) input.composing.range.clear()
-      input.composing = {
-        start: start,
-        range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"})
-      }
-    })
-    on(te, "compositionend", () => {
-      if (input.composing) {
-        input.poll()
-        input.composing.range.clear()
-        input.composing = null
-      }
-    })
-  }
-
-  createField(_display) {
-    // Wraps and hides input textarea
-    this.wrapper = hiddenTextarea()
-    // The semihidden textarea that is focused when the editor is
-    // focused, and receives input.
-    this.textarea = this.wrapper.firstChild
-    let opts = this.cm.options
-    disableBrowserMagic(this.textarea, opts.spellcheck, opts.autocorrect, opts.autocapitalize)
-  }
-
-  screenReaderLabelChanged(label) {
-    // Label for screenreaders, accessibility
-    if(label) {
-      this.textarea.setAttribute('aria-label', label)
-    } else {
-      this.textarea.removeAttribute('aria-label')
-    }
-  }
-
-  prepareSelection() {
-    // Redraw the selection and/or cursor
-    let cm = this.cm, display = cm.display, doc = cm.doc
-    let result = prepareSelection(cm)
-
-    // Move the hidden textarea near the cursor to prevent scrolling artifacts
-    if (cm.options.moveInputWithCursor) {
-      let headPos = cursorCoords(cm, doc.sel.primary().head, "div")
-      let wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect()
-      result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
-                                          headPos.top + lineOff.top - wrapOff.top))
-      result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
-                                           headPos.left + lineOff.left - wrapOff.left))
-    }
-
-    return result
-  }
-
-  showSelection(drawn) {
-    let cm = this.cm, display = cm.display
-    removeChildrenAndAdd(display.cursorDiv, drawn.cursors)
-    removeChildrenAndAdd(display.selectionDiv, drawn.selection)
-    if (drawn.teTop != null) {
-      this.wrapper.style.top = drawn.teTop + "px"
-      this.wrapper.style.left = drawn.teLeft + "px"
-    }
-  }
-
-  // Reset the input to correspond to the selection (or to be empty,
-  // when not typing and nothing is selected)
-  reset(typing) {
-    if (this.contextMenuPending || this.composing && typing) return
-    let cm = this.cm
-    this.resetting = true
-    if (cm.somethingSelected()) {
-      this.prevInput = ""
-      let content = cm.getSelection()
-      this.textarea.value = content
-      if (cm.state.focused) selectInput(this.textarea)
-      if (ie && ie_version >= 9) this.hasSelection = content
-    } else if (!typing) {
-      this.prevInput = this.textarea.value = ""
-      if (ie && ie_version >= 9) this.hasSelection = null
-    }
-    this.resetting = false
-  }
-
-  getField() { return this.textarea }
-
-  supportsTouch() { return false }
-
-  focus() {
-    if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt(this.textarea.ownerDocument) != this.textarea)) {
-      try { this.textarea.focus() }
-      catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
-    }
-  }
-
-  blur() { this.textarea.blur() }
-
-  resetPosition() {
-    this.wrapper.style.top = this.wrapper.style.left = 0
-  }
-
-  receivedFocus() { this.slowPoll() }
-
-  // Poll for input changes, using the normal rate of polling. This
-  // runs as long as the editor is focused.
-  slowPoll() {
-    if (this.pollingFast) return
-    this.polling.set(this.cm.options.pollInterval, () => {
-      this.poll()
-      if (this.cm.state.focused) this.slowPoll()
-    })
-  }
-
-  // When an event has just come in that is likely to add or change
-  // something in the input textarea, we poll faster, to ensure that
-  // the change appears on the screen quickly.
-  fastPoll() {
-    let missed = false, input = this
-    input.pollingFast = true
-    function p() {
-      let changed = input.poll()
-      if (!changed && !missed) {missed = true; input.polling.set(60, p)}
-      else {input.pollingFast = false; input.slowPoll()}
-    }
-    input.polling.set(20, p)
-  }
-
-  // Read input from the textarea, and update the document to match.
-  // When something is selected, it is present in the textarea, and
-  // selected (unless it is huge, in which case a placeholder is
-  // used). When nothing is selected, the cursor sits after previously
-  // seen text (can be empty), which is stored in prevInput (we must
-  // not reset the textarea when typing, because that breaks IME).
-  poll() {
-    let cm = this.cm, input = this.textarea, prevInput = this.prevInput
-    // Since this is called a *lot*, try to bail out as cheaply as
-    // possible when it is clear that nothing happened. hasSelection
-    // will be the case when there is a lot of text in the textarea,
-    // in which case reading its value would be expensive.
-    if (this.contextMenuPending || this.resetting || !cm.state.focused ||
-        (hasSelection(input) && !prevInput && !this.composing) ||
-        cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)
-      return false
-
-    let text = input.value
-    // If nothing changed, bail.
-    if (text == prevInput && !cm.somethingSelected()) return false
-    // Work around nonsensical selection resetting in IE9/10, and
-    // inexplicable appearance of private area unicode characters on
-    // some key combos in Mac (#2689).
-    if (ie && ie_version >= 9 && this.hasSelection === text ||
-        mac && /[\uf700-\uf7ff]/.test(text)) {
-      cm.display.input.reset()
-      return false
-    }
-
-    if (cm.doc.sel == cm.display.selForContextMenu) {
-      let first = text.charCodeAt(0)
-      if (first == 0x200b && !prevInput) prevInput = "\u200b"
-      if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo") }
-    }
-    // Find the part of the input that is actually new
-    let same = 0, l = Math.min(prevInput.length, text.length)
-    while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) ++same
-
-    runInOp(cm, () => {
-      applyTextInput(cm, text.slice(same), prevInput.length - same,
-                     null, this.composing ? "*compose" : null)
-
-      // Don't leave long text in the textarea, since it makes further polling slow
-      if (text.length > 1000 || text.indexOf("\n") > -1) input.value = this.prevInput = ""
-      else this.prevInput = text
-
-      if (this.composing) {
-        this.composing.range.clear()
-        this.composing.range = cm.markText(this.composing.start, cm.getCursor("to"),
-                                           {className: "CodeMirror-composing"})
-      }
-    })
-    return true
-  }
-
-  ensurePolled() {
-    if (this.pollingFast && this.poll()) this.pollingFast = false
-  }
-
-  onKeyPress() {
-    if (ie && ie_version >= 9) this.hasSelection = null
-    this.fastPoll()
-  }
-
-  onContextMenu(e) {
-    let input = this, cm = input.cm, display = cm.display, te = input.textarea
-    if (input.contextMenuPending) input.contextMenuPending()
-    let pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop
-    if (!pos || presto) return // Opera is difficult.
-
-    // Reset the current text selection only if the click is done outside of the selection
-    // and 'resetSelectionOnContextMenu' option is true.
-    let reset = cm.options.resetSelectionOnContextMenu
-    if (reset && cm.doc.sel.contains(pos) == -1)
-      operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll)
-
-    let oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText
-    let wrapperBox = input.wrapper.offsetParent.getBoundingClientRect()
-    input.wrapper.style.cssText = "position: static"
-    te.style.cssText = `position: absolute; width: 30px; height: 30px;
-      top: ${e.clientY - wrapperBox.top - 5}px; left: ${e.clientX - wrapperBox.left - 5}px;
-      z-index: 1000; background: ${ie ? "rgba(255, 255, 255, .05)" : "transparent"};
-      outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);`
-    let oldScrollY
-    if (webkit) oldScrollY = te.ownerDocument.defaultView.scrollY // Work around Chrome issue (#2712)
-    display.input.focus()
-    if (webkit) te.ownerDocument.defaultView.scrollTo(null, oldScrollY)
-    display.input.reset()
-    // Adds "Select all" to context menu in FF
-    if (!cm.somethingSelected()) te.value = input.prevInput = " "
-    input.contextMenuPending = rehide
-    display.selForContextMenu = cm.doc.sel
-    clearTimeout(display.detectingSelectAll)
-
-    // Select-all will be greyed out if there's nothing to select, so
-    // this adds a zero-width space so that we can later check whether
-    // it got selected.
-    function prepareSelectAllHack() {
-      if (te.selectionStart != null) {
-        let selected = cm.somethingSelected()
-        let extval = "\u200b" + (selected ? te.value : "")
-        te.value = "\u21da" // Used to catch context-menu undo
-        te.value = extval
-        input.prevInput = selected ? "" : "\u200b"
-        te.selectionStart = 1; te.selectionEnd = extval.length
-        // Re-set this, in case some other handler touched the
-        // selection in the meantime.
-        display.selForContextMenu = cm.doc.sel
-      }
-    }
-    function rehide() {
-      if (input.contextMenuPending != rehide) return
-      input.contextMenuPending = false
-      input.wrapper.style.cssText = oldWrapperCSS
-      te.style.cssText = oldCSS
-      if (ie && ie_version < 9) display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos)
-
-      // Try to detect the user choosing select-all
-      if (te.selectionStart != null) {
-        if (!ie || (ie && ie_version < 9)) prepareSelectAllHack()
-        let i = 0, poll = () => {
-          if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&
-              te.selectionEnd > 0 && input.prevInput == "\u200b") {
-            operation(cm, selectAll)(cm)
-          } else if (i++ < 10) {
-            display.detectingSelectAll = setTimeout(poll, 500)
-          } else {
-            display.selForContextMenu = null
-            display.input.reset()
-          }
-        }
-        display.detectingSelectAll = setTimeout(poll, 200)
-      }
-    }
-
-    if (ie && ie_version >= 9) prepareSelectAllHack()
-    if (captureRightClick) {
-      e_stop(e)
-      let mouseup = () => {
-        off(window, "mouseup", mouseup)
-        setTimeout(rehide, 20)
-      }
-      on(window, "mouseup", mouseup)
-    } else {
-      setTimeout(rehide, 50)
-    }
-  }
-
-  readOnlyChanged(val) {
-    if (!val) this.reset()
-    this.textarea.disabled = val == "nocursor"
-    this.textarea.readOnly = !!val
-  }
-
-  setUneditable() {}
-}
-
-TextareaInput.prototype.needsContentAttribute = false

package/www/codemirror/src/input/indent.js

@@ -1,71 +0,0 @@
-import { getContextBefore } from "../line/highlight.js"
-import { Pos } from "../line/pos.js"
-import { getLine } from "../line/utils_line.js"
-import { replaceRange } from "../model/changes.js"
-import { Range } from "../model/selection.js"
-import { replaceOneSelection } from "../model/selection_updates.js"
-import { countColumn, Pass, spaceStr } from "../util/misc.js"
-
-// Indent the given line. The how parameter can be "smart",
-// "add"/null, "subtract", or "prev". When aggressive is false
-// (typically set to true for forced single-line indents), empty
-// lines are not indented, and places where the mode returns Pass
-// are left alone.
-export function indentLine(cm, n, how, aggressive) {
-  let doc = cm.doc, state
-  if (how == null) how = "add"
-  if (how == "smart") {
-    // Fall back to "prev" when the mode doesn't have an indentation
-    // method.
-    if (!doc.mode.indent) how = "prev"
-    else state = getContextBefore(cm, n).state
-  }
-
-  let tabSize = cm.options.tabSize
-  let line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize)
-  if (line.stateAfter) line.stateAfter = null
-  let curSpaceString = line.text.match(/^\s*/)[0], indentation
-  if (!aggressive && !/\S/.test(line.text)) {
-    indentation = 0
-    how = "not"
-  } else if (how == "smart") {
-    indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text)
-    if (indentation == Pass || indentation > 150) {
-      if (!aggressive) return
-      how = "prev"
-    }
-  }
-  if (how == "prev") {
-    if (n > doc.first) indentation = countColumn(getLine(doc, n-1).text, null, tabSize)
-    else indentation = 0
-  } else if (how == "add") {
-    indentation = curSpace + cm.options.indentUnit
-  } else if (how == "subtract") {
-    indentation = curSpace - cm.options.indentUnit
-  } else if (typeof how == "number") {
-    indentation = curSpace + how
-  }
-  indentation = Math.max(0, indentation)
-
-  let indentString = "", pos = 0
-  if (cm.options.indentWithTabs)
-    for (let i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t"}
-  if (pos < indentation) indentString += spaceStr(indentation - pos)
-
-  if (indentString != curSpaceString) {
-    replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input")
-    line.stateAfter = null
-    return true
-  } else {
-    // Ensure that, if the cursor was in the whitespace at the start
-    // of the line, it is moved to the end of that space.
-    for (let i = 0; i < doc.sel.ranges.length; i++) {
-      let range = doc.sel.ranges[i]
-      if (range.head.line == n && range.head.ch < curSpaceString.length) {
-        let pos = Pos(n, curSpaceString.length)
-        replaceOneSelection(doc, i, new Range(pos, pos))
-        break
-      }
-    }
-  }
-}

package/www/codemirror/src/input/input.js

@@ -1,134 +0,0 @@
-import { runInOp } from "../display/operations.js"
-import { ensureCursorVisible } from "../display/scrolling.js"
-import { Pos } from "../line/pos.js"
-import { getLine } from "../line/utils_line.js"
-import { makeChange } from "../model/changes.js"
-import { ios, webkit } from "../util/browser.js"
-import { elt } from "../util/dom.js"
-import { lst, map } from "../util/misc.js"
-import { signalLater } from "../util/operation_group.js"
-import { splitLinesAuto } from "../util/feature_detection.js"
-
-import { indentLine } from "./indent.js"
-
-// This will be set to a {lineWise: bool, text: [string]} object, so
-// that, when pasting, we know what kind of selections the copied
-// text was made out of.
-export let lastCopied = null
-
-export function setLastCopied(newLastCopied) {
-  lastCopied = newLastCopied
-}
-
-export function applyTextInput(cm, inserted, deleted, sel, origin) {
-  let doc = cm.doc
-  cm.display.shift = false
-  if (!sel) sel = doc.sel
-
-  let recent = +new Date - 200
-  let paste = origin == "paste" || cm.state.pasteIncoming > recent
-  let textLines = splitLinesAuto(inserted), multiPaste = null
-  // When pasting N lines into N selections, insert one line per selection
-  if (paste && sel.ranges.length > 1) {
-    if (lastCopied && lastCopied.text.join("\n") == inserted) {
-      if (sel.ranges.length % lastCopied.text.length == 0) {
-        multiPaste = []
-        for (let i = 0; i < lastCopied.text.length; i++)
-          multiPaste.push(doc.splitLines(lastCopied.text[i]))
-      }
-    } else if (textLines.length == sel.ranges.length && cm.options.pasteLinesPerSelection) {
-      multiPaste = map(textLines, l => [l])
-    }
-  }
-
-  let updateInput = cm.curOp.updateInput
-  // Normal behavior is to insert the new text into every selection
-  for (let i = sel.ranges.length - 1; i >= 0; i--) {
-    let range = sel.ranges[i]
-    let from = range.from(), to = range.to()
-    if (range.empty()) {
-      if (deleted && deleted > 0) // Handle deletion
-        from = Pos(from.line, from.ch - deleted)
-      else if (cm.state.overwrite && !paste) // Handle overwrite
-        to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length))
-      else if (paste && lastCopied && lastCopied.lineWise && lastCopied.text.join("\n") == textLines.join("\n"))
-        from = to = Pos(from.line, 0)
-    }
-    let changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i % multiPaste.length] : textLines,
-                       origin: origin || (paste ? "paste" : cm.state.cutIncoming > recent ? "cut" : "+input")}
-    makeChange(cm.doc, changeEvent)
-    signalLater(cm, "inputRead", cm, changeEvent)
-  }
-  if (inserted && !paste)
-    triggerElectric(cm, inserted)
-
-  ensureCursorVisible(cm)
-  if (cm.curOp.updateInput < 2) cm.curOp.updateInput = updateInput
-  cm.curOp.typing = true
-  cm.state.pasteIncoming = cm.state.cutIncoming = -1
-}
-
-export function handlePaste(e, cm) {
-  let pasted = e.clipboardData && e.clipboardData.getData("Text")
-  if (pasted) {
-    e.preventDefault()
-    if (!cm.isReadOnly() && !cm.options.disableInput && cm.hasFocus())
-      runInOp(cm, () => applyTextInput(cm, pasted, 0, null, "paste"))
-    return true
-  }
-}
-
-export function triggerElectric(cm, inserted) {
-  // When an 'electric' character is inserted, immediately trigger a reindent
-  if (!cm.options.electricChars || !cm.options.smartIndent) return
-  let sel = cm.doc.sel
-
-  for (let i = sel.ranges.length - 1; i >= 0; i--) {
-    let range = sel.ranges[i]
-    if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) continue
-    let mode = cm.getModeAt(range.head)
-    let indented = false
-    if (mode.electricChars) {
-      for (let j = 0; j < mode.electricChars.length; j++)
-        if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
-          indented = indentLine(cm, range.head.line, "smart")
-          break
-        }
-    } else if (mode.electricInput) {
-      if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))
-        indented = indentLine(cm, range.head.line, "smart")
-    }
-    if (indented) signalLater(cm, "electricInput", cm, range.head.line)
-  }
-}
-
-export function copyableRanges(cm) {
-  let text = [], ranges = []
-  for (let i = 0; i < cm.doc.sel.ranges.length; i++) {
-    let line = cm.doc.sel.ranges[i].head.line
-    let lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}
-    ranges.push(lineRange)
-    text.push(cm.getRange(lineRange.anchor, lineRange.head))
-  }
-  return {text: text, ranges: ranges}
-}
-
-export function disableBrowserMagic(field, spellcheck, autocorrect, autocapitalize) {
-  field.setAttribute("autocorrect", autocorrect ? "on" : "off")
-  field.setAttribute("autocapitalize", autocapitalize ? "on" : "off")
-  field.setAttribute("spellcheck", !!spellcheck)
-}
-
-export function hiddenTextarea() {
-  let te = elt("textarea", null, null, "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; min-height: 1em; outline: none")
-  let div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;")
-  // The textarea is kept positioned near the cursor to prevent the
-  // fact that it'll be scrolled into view on input from scrolling
-  // our fake cursor out of view. On webkit, when wrap=off, paste is
-  // very slow. So make the area wide instead.
-  if (webkit) te.style.width = "1000px"
-  else te.setAttribute("wrap", "off")
-  // If border: 0; -- iOS fails to open keyboard (issue #1287)
-  if (ios) te.style.border = "1px solid black"
-  return div
-}