prosemirror-view 1.23.13 → 1.24.0-beta.3

package/src/{selection.js → selection.ts}

@@ -1,25 +1,29 @@
-import {TextSelection, NodeSelection} from "prosemirror-state"
+import {TextSelection, NodeSelection, Selection} from "prosemirror-state"
+import {ResolvedPos} from "prosemirror-model"
 
-import browser from "./browser"
+import * as browser from "./browser"
 import {selectionCollapsed, isEquivalentPosition, domIndex, isOnEdge} from "./dom"
+import {EditorView} from "./index"
+import {NodeViewDesc} from "./viewdesc"
 
-export function selectionFromDOM(view, origin) {
-  let domSel = view.root.getSelection(), doc = view.state.doc
+export function selectionFromDOM(view: EditorView, origin: string | null = null) {
+  let domSel = view.domSelection(), doc = view.state.doc
   if (!domSel.focusNode) return null
   let nearestDesc = view.docView.nearestDesc(domSel.focusNode), inWidget = nearestDesc && nearestDesc.size == 0
-  let head = view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset)
+  let head = view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset, 1)
   if (head < 0) return null
   let $head = doc.resolve(head), $anchor, selection
   if (selectionCollapsed(domSel)) {
     $anchor = $head
     while (nearestDesc && !nearestDesc.node) nearestDesc = nearestDesc.parent
-    if (nearestDesc && nearestDesc.node.isAtom && NodeSelection.isSelectable(nearestDesc.node) && nearestDesc.parent
-        && !(nearestDesc.node.isInline && isOnEdge(domSel.focusNode, domSel.focusOffset, nearestDesc.dom))) {
+    let nearestDescNode = (nearestDesc as NodeViewDesc).node
+    if (nearestDesc && nearestDescNode.isAtom && NodeSelection.isSelectable(nearestDescNode) && nearestDesc.parent
+        && !(nearestDescNode.isInline && isOnEdge(domSel.focusNode, domSel.focusOffset, nearestDesc.dom))) {
       let pos = nearestDesc.posBefore
       selection = new NodeSelection(head == pos ? $head : doc.resolve(pos))
     }
   } else {
-    let anchor = view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset)
+    let anchor = view.docView.posFromDOM(domSel.anchorNode!, domSel.anchorOffset, 1)
     if (anchor < 0) return null
     $anchor = doc.resolve(anchor)
   }
@@ -31,12 +35,12 @@ export function selectionFromDOM(view, origin) {
   return selection
 }
 
-function editorOwnsSelection(view) {
+function editorOwnsSelection(view: EditorView) {
   return view.editable ? view.hasFocus() :
     hasSelection(view) && document.activeElement && document.activeElement.contains(view.dom)
 }
 
-export function selectionToDOM(view, force) {
+export function selectionToDOM(view: EditorView, force = false) {
   let sel = view.state.selection
   syncNodeSelection(view, sel)
 
@@ -45,11 +49,12 @@ export function selectionToDOM(view, force) {
   // The delayed drag selection causes issues with Cell Selections
   // in Safari. And the drag selection delay is to workarond issues
   // which only present in Chrome.
-  if (!force && view.mouseDown && view.mouseDown.allowDefault && browser.chrome) {
-    let domSel = view.root.getSelection(), curSel = view.domObserver.currentSelection
-    if (domSel.anchorNode && isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset,
-                                                  curSel.anchorNode, curSel.anchorOffset)) {
-      view.mouseDown.delayedSelectionSync = true
+  if (!force && view.input.mouseDown && view.input.mouseDown.allowDefault && browser.chrome) {
+    let domSel = view.domSelection(), curSel = view.domObserver.currentSelection
+    if (domSel.anchorNode && curSel.anchorNode &&
+        isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset,
+                             curSel.anchorNode, curSel.anchorOffset)) {
+      view.input.mouseDown.delayedSelectionSync = true
       view.domObserver.setCurSelection()
       return
     }
@@ -90,36 +95,37 @@ export function selectionToDOM(view, force) {
 
 const brokenSelectBetweenUneditable = browser.safari || browser.chrome && browser.chrome_version < 63
 
-function temporarilyEditableNear(view, pos) {
+function temporarilyEditableNear(view: EditorView, pos: number) {
   let {node, offset} = view.docView.domFromPos(pos, 0)
   let after = offset < node.childNodes.length ? node.childNodes[offset] : null
   let before = offset ? node.childNodes[offset - 1] : null
-  if (browser.safari && after && after.contentEditable == "false") return setEditable(after)
-  if ((!after || after.contentEditable == "false") && (!before || before.contentEditable == "false")) {
-    if (after) return setEditable(after)
-    else if (before) return setEditable(before)
+  if (browser.safari && after && (after as HTMLElement).contentEditable == "false") return setEditable(after as HTMLElement)
+  if ((!after || (after as HTMLElement).contentEditable == "false") &&
+      (!before || (before as HTMLElement).contentEditable == "false")) {
+    if (after) return setEditable(after as HTMLElement)
+    else if (before) return setEditable(before as HTMLElement)
   }
 }
 
-function setEditable(element) {
+function setEditable(element: HTMLElement) {
   element.contentEditable = "true"
-  if (browser.safari && element.draggable) { element.draggable = false; element.wasDraggable = true }
+  if (browser.safari && element.draggable) { element.draggable = false; (element as any).wasDraggable = true }
   return element
 }
 
-function resetEditable(element) {
+function resetEditable(element: HTMLElement) {
   element.contentEditable = "false"
-  if (element.wasDraggable) { element.draggable = true; element.wasDraggable = null }
+  if ((element as any).wasDraggable) { element.draggable = true; (element as any).wasDraggable = null }
 }
 
-function removeClassOnSelectionChange(view) {
+function removeClassOnSelectionChange(view: EditorView) {
   let doc = view.dom.ownerDocument
-  doc.removeEventListener("selectionchange", view.hideSelectionGuard)
-  let domSel = view.root.getSelection()
+  doc.removeEventListener("selectionchange", view.input.hideSelectionGuard!)
+  let domSel = view.domSelection()
   let node = domSel.anchorNode, offset = domSel.anchorOffset
-  doc.addEventListener("selectionchange", view.hideSelectionGuard = () => {
+  doc.addEventListener("selectionchange", view.input.hideSelectionGuard = () => {
     if (domSel.anchorNode != node || domSel.anchorOffset != offset) {
-      doc.removeEventListener("selectionchange", view.hideSelectionGuard)
+      doc.removeEventListener("selectionchange", view.input.hideSelectionGuard!)
       setTimeout(() => {
         if (!editorOwnsSelection(view) || view.state.selection.visible)
           view.dom.classList.remove("ProseMirror-hideselection")
@@ -128,10 +134,10 @@ function removeClassOnSelectionChange(view) {
   })
 }
 
-function selectCursorWrapper(view) {
-  let domSel = view.root.getSelection(), range = document.createRange()
-  let node = view.cursorWrapper.dom, img = node.nodeName == "IMG"
-  if (img) range.setEnd(node.parentNode, domIndex(node) + 1)
+function selectCursorWrapper(view: EditorView) {
+  let domSel = view.domSelection(), range = document.createRange()
+  let node = view.cursorWrapper!.dom, img = node.nodeName == "IMG"
+  if (img) range.setEnd(node.parentNode!, domIndex(node) + 1)
   else range.setEnd(node, 0)
   range.collapse(false)
   domSel.removeAllRanges()
@@ -142,17 +148,17 @@ function selectCursorWrapper(view) {
   // positioned wrapper, rather than the root editable node, the
   // focused element.
   if (!img && !view.state.selection.visible && browser.ie && browser.ie_version <= 11) {
-    node.disabled = true
-    node.disabled = false
+    ;(node as any).disabled = true
+    ;(node as any).disabled = false
   }
 }
 
-export function syncNodeSelection(view, sel) {
+export function syncNodeSelection(view: EditorView, sel: Selection) {
   if (sel instanceof NodeSelection) {
     let desc = view.docView.descAt(sel.from)
     if (desc != view.lastSelectedViewDesc) {
       clearNodeSelection(view)
-      if (desc) desc.selectNode()
+      if (desc) (desc as NodeViewDesc).selectNode()
       view.lastSelectedViewDesc = desc
     }
   } else {
@@ -161,40 +167,40 @@ export function syncNodeSelection(view, sel) {
 }
 
 // Clear all DOM statefulness of the last node selection.
-function clearNodeSelection(view) {
+function clearNodeSelection(view: EditorView) {
   if (view.lastSelectedViewDesc) {
     if (view.lastSelectedViewDesc.parent)
-      view.lastSelectedViewDesc.deselectNode()
-    view.lastSelectedViewDesc = null
+      (view.lastSelectedViewDesc as NodeViewDesc).deselectNode()
+    view.lastSelectedViewDesc = undefined
   }
 }
 
-export function selectionBetween(view, $anchor, $head, bias) {
+export function selectionBetween(view: EditorView, $anchor: ResolvedPos, $head: ResolvedPos, bias?: number) {
   return view.someProp("createSelectionBetween", f => f(view, $anchor, $head))
     || TextSelection.between($anchor, $head, bias)
 }
 
-export function hasFocusAndSelection(view) {
+export function hasFocusAndSelection(view: EditorView) {
   if (view.editable && view.root.activeElement != view.dom) return false
   return hasSelection(view)
 }
 
-export function hasSelection(view) {
-  let sel = view.root.getSelection()
+export function hasSelection(view: EditorView) {
+  let sel = view.domSelection()
   if (!sel.anchorNode) return false
   try {
     // Firefox will raise 'permission denied' errors when accessing
     // properties of `sel.anchorNode` when it's in a generated CSS
     // element.
     return view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode) &&
-      (view.editable || view.dom.contains(sel.focusNode.nodeType == 3 ? sel.focusNode.parentNode : sel.focusNode))
+      (view.editable || view.dom.contains(sel.focusNode!.nodeType == 3 ? sel.focusNode!.parentNode : sel.focusNode))
   } catch(_) {
     return false
   }
 }
 
-export function anchorInRightPlace(view) {
+export function anchorInRightPlace(view: EditorView) {
   let anchorDOM = view.docView.domFromPos(view.state.selection.anchor, 0)
-  let domSel = view.root.getSelection()
-  return isEquivalentPosition(anchorDOM.node, anchorDOM.offset, domSel.anchorNode, domSel.anchorOffset)
+  let domSel = view.domSelection()
+  return isEquivalentPosition(anchorDOM.node, anchorDOM.offset, domSel.anchorNode!, domSel.anchorOffset)
 }