v13.0.0-61 -- distribution files

examples/quill-cursors/index.js

@@ -20,7 +20,7 @@ let quill = new Quill('#quill-container', {
       [{ header: [1, 2, false] }],
       ['bold', 'italic', 'underline'],
       ['image', 'code-block'],
-      [{ color: [] }, { background: [] }], // Snow theme fills in values
+      [{ color: [] }, { background: [] }],    // Snow theme fills in values
       [{ script: 'sub' }, { script: 'super' }],
       ['link', 'image'],
       ['link', 'code-block'],
@@ -31,7 +31,7 @@ let quill = new Quill('#quill-container', {
     }
   },
   placeholder: 'Compose an epic...',
-  theme: 'snow' // or 'bubble'
+  theme: 'snow'  // or 'bubble'
 })
 
 let cursors = quill.getModule('cursors')

examples/quill/index.js

@@ -13,7 +13,7 @@ let quill = new Quill('#quill-container', {
       [{ header: [1, 2, false] }],
       ['bold', 'italic', 'underline'],
       ['image', 'code-block'],
-      [{ color: [] }, { background: [] }], // Snow theme fills in values
+      [{ color: [] }, { background: [] }],    // Snow theme fills in values
       [{ script: 'sub' }, { script: 'super' }],
       ['link', 'image'],
       ['link', 'code-block'],
@@ -21,7 +21,7 @@ let quill = new Quill('#quill-container', {
     ]
   },
   placeholder: 'Compose an epic...',
-  theme: 'snow' // or 'bubble'
+  theme: 'snow'  // or 'bubble'
 })
 
 let yText = y.define('quill', Y.Text)

examples/serviceworker/index.js

@@ -35,7 +35,7 @@ Y({
       toolbar: [
         [{ size: ['small', false, 'large', 'huge'] }],
         ['bold', 'italic', 'underline'],
-        [{ color: [] }, { background: [] }], // Snow theme fills in values
+        [{ color: [] }, { background: [] }],    // Snow theme fills in values
         [{ script: 'sub' }, { script: 'super' }],
         ['link', 'image'],
         ['link', 'code-block'],

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "yjs",
-  "version": "13.0.0-64",
+  "version": "13.0.0-61",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "yjs",
-  "version": "13.0.0-64",
+  "version": "13.0.0-61",
   "description": "A framework for real-time p2p shared editing on any data",
   "main": "./y.node.js",
   "browser": "./y.js",

src/Bindings/DomBinding/DomBinding.js

@@ -1,9 +1,8 @@
-/* global MutationObserver, getSelection */
+/* global MutationObserver */
 
-import { fromRelativePosition } from '../../Util/relativePosition.js'
 import Binding from '../Binding.js'
 import { createAssociation, removeAssociation } from './util.js'
-import { beforeTransactionSelectionFixer, afterTransactionSelectionFixer, getCurrentRelativeSelection } from './selection.js'
+import { beforeTransactionSelectionFixer, afterTransactionSelectionFixer } from './selection.js'
 import { defaultFilter, applyFilterOnType } from './filter.js'
 import typeObserver from './typeObserver.js'
 import domObserver from './domObserver.js'
@@ -68,25 +67,16 @@ export default class DomBinding extends Binding {
       characterData: true,
       subtree: true
     })
-    this._currentSel = null
-    document.addEventListener('selectionchange', () => {
-      this._currentSel = getCurrentRelativeSelection(this)
-    })
     const y = type._y
-    this.y = y
     // Force flush dom changes before Type changes are applied (they might
     // modify the dom)
     this._beforeTransactionHandler = (y, transaction, remote) => {
       this._domObserver(this._mutationObserver.takeRecords())
-      this._mutualExclude(() => {
-        beforeTransactionSelectionFixer(this, remote)
-      })
+      beforeTransactionSelectionFixer(y, this, transaction, remote)
     }
     y.on('beforeTransaction', this._beforeTransactionHandler)
     this._afterTransactionHandler = (y, transaction, remote) => {
-      this._mutualExclude(() => {
-        afterTransactionSelectionFixer(this, remote)
-      })
+      afterTransactionSelectionFixer(y, this, transaction, remote)
       // remove associations
       // TODO: this could be done more efficiently
       // e.g. Always delete using the following approach, or removeAssociation
@@ -125,62 +115,6 @@ export default class DomBinding extends Binding {
     // TODO: apply filter to all elements
   }
 
-  _getUndoStackInfo () {
-    return this.getSelection()
-  }
-
-  _restoreUndoStackInfo (info) {
-    this.restoreSelection(info)
-  }
-
-  getSelection () {
-    return this._currentSel
-  }
-
-  restoreSelection (selection) {
-    if (selection !== null) {
-      const { to, from } = selection
-      /**
-       * There is little information on the difference between anchor/focus and base/extent.
-       * MDN doesn't even mention base/extent anymore.. though you still have to call
-       * setBaseAndExtent to change the selection..
-       * I can observe that base/extend refer to notes higher up in the xml hierachy.
-       * Espesially for undo/redo this is preferred. If this becomes a problem in the future,
-       * we should probably go back to anchor/focus.
-       */
-      const browserSelection = getSelection()
-      let { baseNode, baseOffset, extentNode, extentOffset } = browserSelection
-      if (from !== null) {
-        let sel = fromRelativePosition(this.y, from)
-        if (sel !== null) {
-          let node = this.typeToDom.get(sel.type)
-          let offset = sel.offset
-          if (node !== baseNode || offset !== baseOffset) {
-            baseNode = node
-            baseOffset = offset
-          }
-        }
-      }
-      if (to !== null) {
-        let sel = fromRelativePosition(this.y, to)
-        if (sel !== null) {
-          let node = this.typeToDom.get(sel.type)
-          let offset = sel.offset
-          if (node !== extentNode || offset !== extentOffset) {
-            extentNode = node
-            extentOffset = offset
-          }
-        }
-      }
-      browserSelection.setBaseAndExtent(
-        baseNode,
-        baseOffset,
-        extentNode,
-        extentOffset
-      )
-    }
-  }
-
   /**
    * Remove all properties that are handled by this class.
    */
@@ -196,10 +130,11 @@ export default class DomBinding extends Binding {
     super.destroy()
   }
 }
-/**
- * A filter defines which elements and attributes to share.
- * Return null if the node should be filtered. Otherwise return the Map of
- * accepted attributes.
- *
- * @typedef {function(nodeName: String, attrs: Map): Map|null} FilterFunction
- */
+
+  /**
+   * A filter defines which elements and attributes to share.
+   * Return null if the node should be filtered. Otherwise return the Map of
+   * accepted attributes.
+   *
+   * @typedef {function(nodeName: String, attrs: Map): Map|null} FilterFunction
+   */

src/Bindings/DomBinding/selection.js

@@ -1,35 +1,84 @@
 /* globals getSelection */
 
-import { getRelativePosition } from '../../Util/relativePosition.js'
+import { getRelativePosition, fromRelativePosition } from '../../Util/relativePosition.js'
 
+let browserSelection = null
 let relativeSelection = null
 
-function _getCurrentRelativeSelection (domBinding) {
-  const { baseNode, baseOffset, extentNode, extentOffset } = getSelection()
-  const baseNodeType = domBinding.domToType.get(baseNode)
-  const extentNodeType = domBinding.domToType.get(extentNode)
-  if (baseNodeType !== undefined && extentNodeType !== undefined) {
-    return {
-      from: getRelativePosition(baseNodeType, baseOffset),
-      to: getRelativePosition(extentNodeType, extentOffset)
+/**
+ * @private
+ */
+export let beforeTransactionSelectionFixer
+if (typeof getSelection !== 'undefined') {
+  beforeTransactionSelectionFixer = function _beforeTransactionSelectionFixer (y, domBinding, transaction, remote) {
+    if (!remote) {
+      return
+    }
+    relativeSelection = { from: null, to: null, fromY: null, toY: null }
+    browserSelection = getSelection()
+    const anchorNode = browserSelection.anchorNode
+    const anchorNodeType = domBinding.domToType.get(anchorNode)
+    if (anchorNode !== null && anchorNodeType !== undefined) {
+      relativeSelection.from = getRelativePosition(anchorNodeType, browserSelection.anchorOffset)
+      relativeSelection.fromY = anchorNodeType._y
+    }
+    const focusNode = browserSelection.focusNode
+    const focusNodeType = domBinding.domToType.get(focusNode)
+    if (focusNode !== null && focusNodeType !== undefined) {
+      relativeSelection.to = getRelativePosition(focusNodeType, browserSelection.focusOffset)
+      relativeSelection.toY = focusNodeType._y
     }
   }
-  return null
-}
-
-export const getCurrentRelativeSelection = typeof getSelection !== 'undefined' ? _getCurrentRelativeSelection : () => null
-
-export function beforeTransactionSelectionFixer (domBinding, remote) {
-  if (remote) {
-    relativeSelection = getCurrentRelativeSelection(domBinding)
-  }
+} else {
+  beforeTransactionSelectionFixer = function _fakeBeforeTransactionSelectionFixer () {}
 }
 
 /**
  * @private
  */
-export function afterTransactionSelectionFixer (domBinding, remote) {
-  if (relativeSelection !== null && remote) {
-    domBinding.restoreSelection(relativeSelection)
+export function afterTransactionSelectionFixer (y, domBinding, transaction, remote) {
+  if (relativeSelection === null || !remote) {
+    return
+  }
+  const to = relativeSelection.to
+  const from = relativeSelection.from
+  const fromY = relativeSelection.fromY
+  const toY = relativeSelection.toY
+  let shouldUpdate = false
+  let anchorNode = browserSelection.anchorNode
+  let anchorOffset = browserSelection.anchorOffset
+  let focusNode = browserSelection.focusNode
+  let focusOffset = browserSelection.focusOffset
+  if (from !== null) {
+    let sel = fromRelativePosition(fromY, from)
+    if (sel !== null) {
+      let node = domBinding.typeToDom.get(sel.type)
+      let offset = sel.offset
+      if (node !== anchorNode || offset !== anchorOffset) {
+        anchorNode = node
+        anchorOffset = offset
+        shouldUpdate = true
+      }
+    }
+  }
+  if (to !== null) {
+    let sel = fromRelativePosition(toY, to)
+    if (sel !== null) {
+      let node = domBinding.typeToDom.get(sel.type)
+      let offset = sel.offset
+      if (node !== focusNode || offset !== focusOffset) {
+        focusNode = node
+        focusOffset = offset
+        shouldUpdate = true
+      }
+    }
+  }
+  if (shouldUpdate) {
+    browserSelection.setBaseAndExtent(
+      anchorNode,
+      anchorOffset,
+      focusNode,
+      focusOffset
+    )
   }
 }

src/Struct/Item.js

@@ -87,7 +87,7 @@ export default class Item {
      * If the parent refers to this item with some kind of key (e.g. YMap, the
      * key is specified here. The key is then used to refer to the list in which
      * to insert this item. If `parentSub = null` type._start is the list in
-     * which to insert to. Otherwise it is `parent._map`.
+     * which to insert to. Otherwise it is `parent._start`.
      * @type {String}
      */
     this._parentSub = null
@@ -120,29 +120,17 @@ export default class Item {
    *
    * @private
    */
-  _redo (y, redoitems) {
+  _redo (y) {
     if (this._redone !== null) {
       return this._redone
     }
     let struct = this._copy()
-    let left, right
-    if (this._parentSub === null) {
-      // Is an array item. Insert at the old position
-      left = this._left
-      right = this
-    } else {
-      // Is a map item. Insert at the start
-      left = null
-      right = this._parent._map.get(this._parentSub)
-      right._delete(y)
-    }
+    let left = this._left
+    let right = this
     let parent = this._parent
     // make sure that parent is redone
     if (parent._deleted === true && parent._redone === null) {
-      // try to undo parent if it will be undone anyway
-      if (!redoitems.has(parent) || !parent._redo(y, redoitems)) {
-        return false
-      }
+      parent._redo(y)
     }
     if (parent._redone !== null) {
       parent = parent._redone
@@ -169,7 +157,7 @@ export default class Item {
     struct._parentSub = this._parentSub
     struct._integrate(y)
     this._redone = struct
-    return true
+    return struct
   }
 
   /**

src/Types/YText/YText.js

@@ -254,7 +254,7 @@ function deleteText (y, length, parent, left, right, currentAttributes) {
  * @typedef {Array<Object>} Delta
  */
 
-/**
+ /**
   * Attributes that can be assigned to a selection of text.
   *
   * @example

src/Util/UndoManager.js

@@ -2,7 +2,7 @@ import ID from './ID/ID.js'
 import isParentOf from './isParentOf.js'
 
 class ReverseOperation {
-  constructor (y, transaction, bindingInfos) {
+  constructor (y, transaction) {
     this.created = new Date()
     const beforeState = transaction.beforeState
     if (beforeState.has(y.userID)) {
@@ -12,26 +12,15 @@ class ReverseOperation {
       this.toState = null
       this.fromState = null
     }
-    this.deletedStructs = new Set()
-    transaction.deletedStructs.forEach(struct => {
-      this.deletedStructs.add({
-        from: struct._id,
-        len: struct._length
-      })
-    })
-    /**
-     * Maps from binding to binding information (e.g. cursor information)
-     */
-    this.bindingInfos = bindingInfos
+    this.deletedStructs = transaction.deletedStructs
   }
 }
 
 function applyReverseOperation (y, scope, reverseBuffer) {
   let performedUndo = false
-  let undoOp
   y.transact(() => {
     while (!performedUndo && reverseBuffer.length > 0) {
-      undoOp = reverseBuffer.pop()
+      let undoOp = reverseBuffer.pop()
       // make sure that it is possible to iterate {from}-{to}
       if (undoOp.fromState !== null) {
         y.os.getItemCleanStart(undoOp.fromState)
@@ -46,39 +35,23 @@ function applyReverseOperation (y, scope, reverseBuffer) {
           }
         })
       }
-      const redoitems = new Set()
-      for (let del of undoOp.deletedStructs) {
-        const fromState = del.from
-        const toState = new ID(fromState.user, fromState.clock + del.len - 1)
-        y.os.getItemCleanStart(fromState)
-        y.os.getItemCleanEnd(toState)
-        y.os.iterate(fromState, toState, op => {
-          if (
-            isParentOf(scope, op) &&
-            op._parent !== y &&
-            (
-              op._id.user !== y.userID ||
-              undoOp.fromState === null ||
-              op._id.clock < undoOp.fromState.clock ||
-              op._id.clock > undoOp.toState.clock
-            )
-          ) {
-            redoitems.add(op)
-          }
-        })
+      for (let op of undoOp.deletedStructs) {
+        if (
+          isParentOf(scope, op) &&
+          op._parent !== y &&
+          (
+            op._id.user !== y.userID ||
+            undoOp.fromState === null ||
+            op._id.clock < undoOp.fromState.clock ||
+            op._id.clock > undoOp.toState.clock
+          )
+        ) {
+          performedUndo = true
+          op._redo(y)
+        }
       }
-      redoitems.forEach(op => {
-        const opUndone = op._redo(y, redoitems)
-        performedUndo = performedUndo || opUndone
-      })
     }
   })
-  if (performedUndo) {
-    // should be performed after the undo transaction
-    undoOp.bindingInfos.forEach((info, binding) => {
-      binding._restoreUndoStackInfo(info)
-    })
-  }
   return performedUndo
 }
 
@@ -93,7 +66,6 @@ export default class UndoManager {
    */
   constructor (scope, options = {}) {
     this.options = options
-    this._bindings = new Set(options.bindings)
     options.captureTimeout = options.captureTimeout == null ? 500 : options.captureTimeout
     this._undoBuffer = []
     this._redoBuffer = []
@@ -104,28 +76,16 @@ export default class UndoManager {
     const y = scope._y
     this.y = y
     y._hasUndoManager = true
-    let bindingInfos
-    y.on('beforeTransaction', (y, transaction, remote) => {
-      if (!remote) {
-        // Store binding information before transaction is executed
-        // By restoring the binding information, we can make sure that the state
-        // before the transaction can be recovered
-        bindingInfos = new Map()
-        this._bindings.forEach(binding => {
-          bindingInfos.set(binding, binding._getUndoStackInfo())
-        })
-      }
-    })
     y.on('afterTransaction', (y, transaction, remote) => {
       if (!remote && transaction.changedParentTypes.has(scope)) {
-        let reverseOperation = new ReverseOperation(y, transaction, bindingInfos)
+        let reverseOperation = new ReverseOperation(y, transaction)
         if (!this._undoing) {
           let lastUndoOp = this._undoBuffer.length > 0 ? this._undoBuffer[this._undoBuffer.length - 1] : null
           if (
             this._redoing === false &&
             this._lastTransactionWasUndo === false &&
             lastUndoOp !== null &&
-            (options.captureTimeout < 0 || reverseOperation.created - lastUndoOp.created <= options.captureTimeout)
+            reverseOperation.created - lastUndoOp.created <= options.captureTimeout
           ) {
             lastUndoOp.created = reverseOperation.created
             if (reverseOperation.toState !== null) {
@@ -150,13 +110,6 @@ export default class UndoManager {
     })
   }
 
-  /**
-   * Enforce that the next change is created as a separate item in the undo stack
-   */
-  flushChanges () {
-    this._lastTransactionWasUndo = true
-  }
-
   /**
    * Undo the last locally created change.
    */

src/Util/relativePosition.js

@@ -76,10 +76,7 @@ export function fromRelativePosition (y, rpos) {
     } else {
       id = new RootID(rpos[3], rpos[4])
     }
-    let type = y.os.get(id)
-    while (type._redone !== null) {
-      type = type._redone
-    }
+    const type = y.os.get(id)
     if (type === null || type.constructor === GC) {
       return null
     }
@@ -90,16 +87,12 @@ export function fromRelativePosition (y, rpos) {
   } else {
     let offset = 0
     let struct = y.os.findNodeWithUpperBound(new ID(rpos[0], rpos[1])).val
-    const diff = rpos[1] - struct._id.clock
-    while (struct._redone !== null) {
-      struct = struct._redone
-    }
     const parent = struct._parent
     if (struct.constructor === GC || parent._deleted) {
       return null
     }
     if (!struct._deleted) {
-      offset = diff
+      offset = rpos[1] - struct._id.clock
     }
     struct = struct._left
     while (struct !== null) {

test/y-array.tests.js

@@ -111,7 +111,7 @@ function compareEvent (t, is, should) {
     t.assert(
       should[key] === is[key] ||
       JSON.stringify(should[key]) === JSON.stringify(is[key])
-      , 'event works as expected'
+    , 'event works as expected'
     )
   }
 }