13.0.0-94

README.v13.md

@@ -25,9 +25,10 @@ suited for even large documents.
 * [Getting Started](#Getting-Started)
 * [API](#API)
   * [Shared Types](#Shared-Types)
-  * [Y.Doc](#Y.Doc)
+  * [Y.Doc](#YDoc)
   * [Document Updates](#Document-Updates)
   * [Relative Positions](#Relative-Positions)
+  * [Y.UndoManager](#YUndoManager)
 * [Miscellaneous](#Miscellaneous)
   * [Typescript Declarations](#Typescript-Declarations)
 * [Yjs CRDT Algorithm](#Yjs-CRDT-Algorithm)
@@ -185,6 +186,8 @@ position 0.
     <dd></dd>
     <b><code>length:number</code></b>
     <dd></dd>
+    <b><code>forEach(function(index:number,value:object|boolean|Array|string|number|Uint8Array|Y.Type))</code></b>
+    <dd></dd>
     <b><code>map(function(T, number, YArray):M):Array&lt;M&gt;</code></b>
     <dd></dd>
     <b><code>toArray():Array&lt;object|boolean|Array|string|number|Uint8Array|Y.Type&gt;</code></b>
@@ -241,11 +244,15 @@ or any of its children.
     <dd></dd>
     <b><code>get(index:number)</code></b>
     <dd></dd>
-    <b><code>toJSON():Object&lt;string, Object|boolean|Array|string|number&gt;</code></b>
+    <b><code>toJSON():Object&lt;string, Object|boolean|Array|string|number|Uint8Array&gt;</code></b>
     <dd>
 Copies the <code>[key,value]</code> pairs of this YMap to a new Object.It
 transforms all child types to JSON using their <code>toJSON</code> method.
     </dd>
+    <b><code>forEach(function(key:string,value:object|boolean|Array|string|number|Uint8Array|Y.Type))</code></b>
+    <dd>
+      Execute the provided function once for every key-value pair.
+    </dd>
     <b><code>[Symbol.Iterator]</code></b>
     <dd>
       Returns an Iterator of <code>[key, value]</code> pairs.
@@ -637,6 +644,136 @@ pos.index === 2 // => true
   <dd></dd>
 </dl>
 
+### Y.UndoManager
+
+Yjs ships with an Undo/Redo manager for selective undo/redo of of changes on a
+Yjs type. The changes can be optionally scoped to transaction origins.
+
+```js
+const ytext = doc.getArray('array')
+const undoManager = new Y.UndoManager(ytext)
+
+ytext.insert(0, 'abc')
+undoManager.undo()
+ytext.toString() // => ''
+undoManager.redo()
+ytext.toString() // => 'abc'
+```
+
+<dl>
+  <b><code>constructor(scope:Y.AbstractType|Array&lt;Y.AbstractType&gt;,
+  [trackedTransactionOrigins:Set&lt;any&gt;, [{captureTimeout: number}]])</code></b>
+  <dd>Accepts either single type as scope or an array of types.</dd>
+  <b><code>undo()</code></b>
+  <dd></dd>
+  <b><code>redo()</code></b>
+  <dd></dd>
+  <b><code>stopCapturing()</code></b>
+  <dd></dd>
+  <b>
+    <code>
+on('stack-item-added', { stackItem: { meta: Map&lt;any,any&gt; }, type: 'undo'
+| 'redo' })
+    </code>
+  </b>
+  <dd>
+Register an event that is called when a <code>StackItem</code> is added to the
+undo- or the redo-stack.
+  </dd>
+  <b>
+    <code>
+on('stack-item-popped', { stackItem: { meta: Map&lt;any,any&gt; }, type: 'undo'
+| 'redo' })
+    </code>  
+  </b>
+  <dd>
+Register an event that is called when a <code>StackItem</code> is popped from
+the undo- or the redo-stack.
+  </dd>
+</dl>
+
+#### Example: Stop Capturing
+
+UndoManager merges Undo-StackItems if they are created within time-gap
+smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next
+StackItem won't be merged.
+
+```js
+// without stopCapturing
+ytext.insert(0, 'a')
+ytext.insert(1, 'b')
+um.undo()
+ytext.toString() // => '' (note that 'ab' was removed)
+// with stopCapturing
+ytext.insert(0, 'a')
+um.stopCapturing()
+ytext.insert(0, 'b')
+um.undo()
+ytext.toString() // => 'a' (note that only 'b' was removed)
+```
+
+#### Example: Specify tracked origins
+
+Every change on the shared document has an origin. If no origin was specified,
+it defaults to `null`. By specifying `trackedTransactionOrigins` you can
+selectively specify which changes should be tracked by `UndoManager`. The
+UndoManager instance is always added to `trackedTransactionOrigins`.
+
+```js
+class CustomBinding {}
+
+const ytext = doc.getArray('array')
+const undoManager = new Y.UndoManager(ytext, new Set([42, CustomBinding]))
+
+ytext.insert(0, 'abc')
+undoManager.undo()
+ytext.toString() // => 'abc' (does not track because origin `null` and not part
+                 //           of `trackedTransactionOrigins`)
+ytext.delete(0, 3) // revert change
+
+doc.transact(() => {
+  ytext.insert(0, 'abc')
+}, 42)
+undoManager.undo()
+ytext.toString() // => '' (tracked because origin is an instance of `trackedTransactionorigins`)
+
+doc.transact(() => {
+  ytext.insert(0, 'abc')
+}, 41)
+undoManager.undo()
+ytext.toString() // => '' (not tracked because 41 is not an instance of
+                 //        `trackedTransactionorigins`)
+ytext.delete(0, 3) // revert change
+
+doc.transact(() => {
+  ytext.insert(0, 'abc')
+}, new CustomBinding())
+undoManager.undo()
+ytext.toString() // => '' (tracked because origin is a `CustomBinding` and
+                 //        `CustomBinding` is in `trackedTransactionorigins`)
+```
+
+#### Example: Add additional information to the StackItems
+
+When undoing or redoing a previous action, it is often expected to restore
+additional meta information like the cursor location or the view on the
+document. You can assign meta-information to Undo-/Redo-StackItems.
+
+```js
+const ytext = doc.getArray('array')
+const undoManager = new Y.UndoManager(ytext, new Set([42, CustomBinding]))
+
+undoManager.on('stack-item-added', event => {
+  // save the current cursor location on the stack-item
+  event.stackItem.meta.set('cursor-location', getRelativeCursorLocation())
+})
+
+undoManager.on('stack-item-popped', event => {
+  // restore the current cursor location on the stack-item
+  restoreCursorLocation(event.stackItem.meta.get('cursor-location'))
+})
+```
+
 ## Miscellaneous
 
 ### Typescript Declarations

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "yjs",
-  "version": "13.0.0-90",
+  "version": "13.0.0-94",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -1490,8 +1490,7 @@
         "ansi-regex": {
           "version": "2.1.1",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "aproba": {
           "version": "1.2.0",
@@ -1512,14 +1511,12 @@
         "balanced-match": {
           "version": "1.0.0",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "brace-expansion": {
           "version": "1.1.11",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "balanced-match": "^1.0.0",
             "concat-map": "0.0.1"
@@ -1534,20 +1531,17 @@
         "code-point-at": {
           "version": "1.1.0",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "concat-map": {
           "version": "0.0.1",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "console-control-strings": {
           "version": "1.1.0",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "core-util-is": {
           "version": "1.0.2",
@@ -1664,8 +1658,7 @@
         "inherits": {
           "version": "2.0.3",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "ini": {
           "version": "1.3.5",
@@ -1677,7 +1670,6 @@
           "version": "1.0.0",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "number-is-nan": "^1.0.0"
           }
@@ -1692,7 +1684,6 @@
           "version": "3.0.4",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "brace-expansion": "^1.1.7"
           }
@@ -1700,14 +1691,12 @@
         "minimist": {
           "version": "0.0.8",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "minipass": {
           "version": "2.3.5",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "safe-buffer": "^5.1.2",
             "yallist": "^3.0.0"
@@ -1726,7 +1715,6 @@
           "version": "0.5.1",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "minimist": "0.0.8"
           }
@@ -1807,8 +1795,7 @@
         "number-is-nan": {
           "version": "1.0.1",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "object-assign": {
           "version": "4.1.1",
@@ -1820,7 +1807,6 @@
           "version": "1.4.0",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "wrappy": "1"
           }
@@ -1906,8 +1892,7 @@
         "safe-buffer": {
           "version": "5.1.2",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "safer-buffer": {
           "version": "2.1.2",
@@ -1943,7 +1928,6 @@
           "version": "1.0.2",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "code-point-at": "^1.0.0",
             "is-fullwidth-code-point": "^1.0.0",
@@ -1963,7 +1947,6 @@
           "version": "3.0.1",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "ansi-regex": "^2.0.0"
           }
@@ -2007,14 +1990,12 @@
         "wrappy": {
           "version": "1.0.2",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "yallist": {
           "version": "3.0.3",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         }
       }
     },

package.json

@@ -1,6 +1,6 @@
 {
   "name": "yjs",
-  "version": "13.0.0-90",
+  "version": "13.0.0-94",
   "description": "Shared Editing Library",
   "main": "./dist/yjs.js",
   "module": "./dist/yjs.mjs",

src/index.js

@@ -42,5 +42,6 @@ export {
   iterateDeletedStructs,
   applyUpdate,
   encodeStateAsUpdate,
-  encodeStateVector
+  encodeStateVector,
+  UndoManager
 } from './internals.js'

src/internals.js

@@ -6,7 +6,7 @@ export * from './utils/RelativePosition.js'
 export * from './utils/Snapshot.js'
 export * from './utils/StructStore.js'
 export * from './utils/Transaction.js'
-// export * from './utils/UndoManager.js'
+export * from './utils/UndoManager.js'
 export * from './utils/Doc.js'
 export * from './utils/YEvent.js'
 

src/structs/ContentType.js

@@ -120,7 +120,6 @@ export class ContentType {
       }
     })
     transaction.changed.delete(this.type)
-    transaction.changedParentTypes.delete(this.type)
   }
   /**
    * @param {StructStore} store

src/structs/Item.js

@@ -22,6 +22,7 @@ import {
   readContentEmbed,
   readContentFormat,
   readContentType,
+  addChangedTypeToTransaction,
   ContentType, ContentDeleted, StructStore, ID, AbstractType, Transaction // eslint-disable-line
 } from '../internals.js'
 
@@ -32,6 +33,46 @@ import * as maplib from 'lib0/map.js'
 import * as set from 'lib0/set.js'
 import * as binary from 'lib0/binary.js'
 
+/**
+ * @param {StructStore} store
+ * @param {ID} id
+ * @return {{item:Item, diff:number}}
+ */
+export const followRedone = (store, id) => {
+  /**
+   * @type {ID|null}
+   */
+  let nextID = id
+  let diff = 0
+  let item
+  do {
+    if (diff > 0) {
+      nextID = createID(nextID.client, nextID.clock + diff)
+    }
+    item = getItem(store, nextID)
+    diff = nextID.clock - item.id.clock
+    nextID = item.redone
+  } while (nextID !== null)
+  return {
+    item, diff
+  }
+}
+
+/**
+ * Make sure that neither item nor any of its parents is ever deleted.
+ *
+ * This property does not persist when storing it into a database or when
+ * sending it to other peers
+ *
+ * @param {Item|null} item
+ */
+export const keepItem = item => {
+  while (item !== null && !item.keep) {
+    item.keep = true
+    item = item.parent._item
+  }
+}
+
 /**
  * Split leftItem into two items
  * @param {Transaction} transaction
@@ -58,6 +99,12 @@ export const splitItem = (transaction, leftItem, diff) => {
   if (leftItem.deleted) {
     rightItem.deleted = true
   }
+  if (leftItem.keep) {
+    rightItem.keep = true
+  }
+  if (leftItem.redone !== null) {
+    rightItem.redone = createID(leftItem.redone.client, leftItem.redone.clock + diff)
+  }
   // update left (do not set leftItem.rightOrigin as it will lead to problems when syncing)
   leftItem.right = rightItem
   // update right
@@ -74,6 +121,107 @@ export const splitItem = (transaction, leftItem, diff) => {
   return rightItem
 }
 
+/**
+ * Redoes the effect of this operation.
+ *
+ * @param {Transaction} transaction The Yjs instance.
+ * @param {Item} item
+ * @param {Set<Item>} redoitems
+ *
+ * @return {Item|null}
+ *
+ * @private
+ */
+export const redoItem = (transaction, item, redoitems) => {
+  if (item.redone !== null) {
+    return getItemCleanStart(transaction, transaction.doc.store, item.redone)
+  }
+  let parentItem = item.parent._item
+  /**
+   * @type {Item|null}
+   */
+  let left
+  /**
+   * @type {Item|null}
+   */
+  let right
+  if (item.parentSub === null) {
+    // Is an array item. Insert at the old position
+    left = item.left
+    right = item
+  } else {
+    // Is a map item. Insert as current value
+    left = item
+    while (left.right !== null) {
+      left = left.right
+      if (left.id.client !== transaction.doc.clientID) {
+        // It is not possible to redo this item because it conflicts with a
+        // change from another client
+        return null
+      }
+    }
+    if (left.right !== null) {
+      left = /** @type {Item} */ (item.parent._map.get(item.parentSub))
+    }
+    right = null
+  }
+  // make sure that parent is redone
+  if (parentItem !== null && parentItem.deleted === true && parentItem.redone === null) {
+    // try to undo parent if it will be undone anyway
+    if (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems) === null) {
+      return null
+    }
+  }
+  if (parentItem !== null && parentItem.redone !== null) {
+    while (parentItem.redone !== null) {
+      parentItem = getItemCleanStart(transaction, transaction.doc.store, parentItem.redone)
+    }
+    // find next cloned_redo items
+    while (left !== null) {
+      /**
+       * @type {Item|null}
+       */
+      let leftTrace = left
+      // trace redone until parent matches
+      while (leftTrace !== null && leftTrace.parent._item !== parentItem) {
+        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, transaction.doc.store, leftTrace.redone)
+      }
+      if (leftTrace !== null && leftTrace.parent._item === parentItem) {
+        left = leftTrace
+        break
+      }
+      left = left.left
+    }
+    while (right !== null) {
+      /**
+       * @type {Item|null}
+       */
+      let rightTrace = right
+      // trace redone until parent matches
+      while (rightTrace !== null && rightTrace.parent._item !== parentItem) {
+        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, transaction.doc.store, rightTrace.redone)
+      }
+      if (rightTrace !== null && rightTrace.parent._item === parentItem) {
+        right = rightTrace
+        break
+      }
+      right = right.right
+    }
+  }
+  const redoneItem = new Item(
+    nextID(transaction),
+    left, left === null ? null : left.lastId,
+    right, right === null ? null : right.id,
+    parentItem === null ? item.parent : /** @type {ContentType} */ (parentItem.content).type,
+    item.parentSub,
+    item.content.copy()
+  )
+  item.redone = redoneItem.id
+  keepItem(redoneItem)
+  redoneItem.integrate(transaction)
+  return redoneItem
+}
+
 /**
  * Abstract class that represents any content.
  */
@@ -135,7 +283,7 @@ export class Item extends AbstractStruct {
     /**
      * If this type's effect is reundone this type refers to the type that undid
      * this operation.
-     * @type {Item | null}
+     * @type {ID | null}
      */
     this.redone = null
     /**
@@ -144,6 +292,10 @@ export class Item extends AbstractStruct {
     this.content = content
     this.length = content.getLength()
     this.countable = content.isCountable()
+    /**
+     * If true, do not garbage collect this Item.
+     */
+    this.keep = false
   }
 
   /**
@@ -237,7 +389,8 @@ export class Item extends AbstractStruct {
     }
     addStruct(store, this)
     this.content.integrate(transaction, this)
-    maplib.setIfUndefined(transaction.changed, parent, set.create).add(parentSub)
+    // add parent to transaction.changed
+    addChangedTypeToTransaction(transaction, parent, parentSub)
     if ((parent._item !== null && parent._item.deleted) || (this.right !== null && parentSub !== null)) {
       // delete if parent is deleted or if this is not the current attribute value of parent
       this.delete(transaction)
@@ -268,66 +421,6 @@ export class Item extends AbstractStruct {
     return n
   }
 
-  /**
-   * Redoes the effect of this operation.
-   *
-   * @param {Transaction} transaction The Yjs instance.
-   * @param {Set<Item>} redoitems
-   *
-   * @private
-   */
-  redo (transaction, redoitems) {
-    if (this.redone !== null) {
-      return this.redone
-    }
-    /**
-     * @type {any}
-     */
-    let parent = this.parent
-    if (parent === null) {
-      return
-    }
-    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 as current value
-      left = parent.type._map.get(this.parentSub)
-      right = null
-    }
-    // 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(transaction, redoitems)) {
-        return false
-      }
-    }
-    if (parent.redone !== null) {
-      while (parent.redone !== null) {
-        parent = parent.redone
-      }
-      // find next cloned_redo items
-      while (left !== null) {
-        if (left.redone !== null && left.redone.parent === parent) {
-          left = left.redone
-          break
-        }
-        left = left.left
-      }
-      while (right !== null) {
-        if (right.redone !== null && right.redone.parent === parent) {
-          right = right.redone
-        }
-        right = right.right
-      }
-    }
-    this.redone = new Item(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, this.parentSub, this.content.copy())
-    this.redone.integrate(transaction)
-    return true
-  }
-
   /**
    * Computes the last content address of this Item.
    */
@@ -348,9 +441,14 @@ export class Item extends AbstractStruct {
       this.id.client === right.id.client &&
       this.id.clock + this.length === right.id.clock &&
       this.deleted === right.deleted &&
+      this.redone === null &&
+      right.redone === null &&
       this.content.constructor === right.content.constructor &&
       this.content.mergeWith(right.content)
     ) {
+      if (right.keep) {
+        this.keep = true
+      }
       this.right = right.right
       if (this.right !== null) {
         this.right.left = this
@@ -622,6 +720,7 @@ export class ItemRef extends AbstractStructRef {
       this.id = createID(id.client, id.clock + offset)
       this.left = createID(this.id.client, this.id.clock - 1)
       this.content = this.content.splice(offset)
+      this.length -= offset
     }
 
     const left = this.left === null ? null : getItemCleanEnd(transaction, store, this.left)

src/types/YArray.js

@@ -68,6 +68,11 @@ export class YArray extends AbstractType {
     this.insert(0, /** @type {Array} */ (this._prelimContent))
     this._prelimContent = null
   }
+
+  _copy () {
+    return new YArray()
+  }
+
   get length () {
     return this._prelimContent === null ? this._length : this._prelimContent.length
   }

src/types/YMap.js

@@ -72,6 +72,11 @@ export class YMap extends AbstractType {
     }
     this._prelimContent = null
   }
+
+  _copy () {
+    return new YMap()
+  }
+
   /**
    * Creates YMapEvent and calls observers.
    *
@@ -106,7 +111,7 @@ export class YMap extends AbstractType {
   /**
    * Returns the keys for each element in the YMap Type.
    *
-   * @return {Iterator<string>}
+   * @return {IterableIterator<string>}
    */
   keys () {
     return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[0])
@@ -115,7 +120,7 @@ export class YMap extends AbstractType {
   /**
    * Returns the keys for each element in the YMap Type.
    *
-   * @return {Iterator<string>}
+   * @return {IterableIterator<string>}
    */
   values () {
     return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[1].content.getContent()[v[1].length - 1])
@@ -130,6 +135,24 @@ export class YMap extends AbstractType {
     return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => [v[0], v[1].content.getContent()[v[1].length - 1]])
   }
 
+  /**
+   * Executes a provided function on once on overy key-value pair.
+   *
+   * @param {function(T,string,YMap<T>):void} f A function to execute on every element of this YArray.
+   */
+  forEach (f) {
+    /**
+     * @type {Object<string,T>}
+     */
+    const map = {}
+    for (let [key, item] of this._map) {
+      if (!item.deleted) {
+        f(item.content.getContent()[item.length - 1], key, this)
+      }
+    }
+    return map
+  }
+
   /**
    * @return {IterableIterator<T>}
    */

src/types/YText.js

@@ -625,6 +625,10 @@ export class YText extends AbstractType {
     this._pending = null
   }
 
+  _copy () {
+    return new YText()
+  }
+
   /**
    * Creates YTextEvent and calls observers.
    *

src/types/YXmlElement.js

@@ -45,12 +45,10 @@ export class YXmlElement extends YXmlFragment {
    */
   _integrate (y, item) {
     super._integrate(y, item)
-    this.insert(0, /** @type {Array} */ (this._prelimContent))
-    this._prelimContent = null
     ;(/** @type {Map<string, any>} */ (this._prelimAttrs)).forEach((value, key) => {
       this.setAttribute(key, value)
     })
-    this._prelimContent = null
+    this._prelimAttrs = null
   }
 
   /**

src/types/YXmlFragment.js

@@ -14,7 +14,7 @@ import {
   YXmlFragmentRefID,
   callTypeObservers,
   transact,
-  ContentType, Transaction, Item, YXmlText, YXmlHook, Snapshot // eslint-disable-line
+  Doc, ContentType, Transaction, Item, YXmlText, YXmlHook, Snapshot // eslint-disable-line
 } from '../internals.js'
 
 import * as encoding from 'lib0/encoding.js'
@@ -130,6 +130,27 @@ export class YXmlFragment extends AbstractType {
      */
     this._prelimContent = []
   }
+  /**
+   * Integrate this type into the Yjs instance.
+   *
+   * * Save this struct in the os
+   * * This type is sent to other client
+   * * Observer functions are fired
+   *
+   * @param {Doc} y The Yjs instance
+   * @param {Item} item
+   * @private
+   */
+  _integrate (y, item) {
+    super._integrate(y, item)
+    this.insert(0, /** @type {Array} */ (this._prelimContent))
+    this._prelimContent = null
+  }
+
+  _copy () {
+    return new YXmlFragment()
+  }
+
   /**
    * Create a subtree of childNodes.
    *

src/types/YXmlText.js

@@ -9,6 +9,9 @@ import * as decoding from 'lib0/decoding.js' // eslint-disable-line
  * simple formatting information like bold and italic.
  */
 export class YXmlText extends YText {
+  _copy () {
+    return new YXmlText()
+  }
   /**
    * Creates a Dom Element that mirrors this YXmlText.
    *

src/utils/DeleteSet.js

@@ -4,7 +4,8 @@ import {
   createID,
   getState,
   splitItem,
-  Item, AbstractStruct, StructStore, Transaction, ID // eslint-disable-line
+  iterateStructs,
+  Item, GC, StructStore, Transaction, ID // eslint-disable-line
 } from '../internals.js'
 
 import * as math from 'lib0/math.js'
@@ -47,29 +48,21 @@ export class DeleteSet {
 }
 
 /**
- * Iterate over all structs that were deleted.
- *
- * This function expects that the deletes structs are not merged. Hence, you can
- * probably only use it in type observes and `afterTransaction` events. But not
- * in `afterTransactionCleanup`.
+ * Iterate over all structs that the DeleteSet gc's.
  *
+ * @param {Transaction} transaction
  * @param {DeleteSet} ds
  * @param {StructStore} store
- * @param {function(AbstractStruct):void} f
+ * @param {function(GC|Item):void} f
  *
  * @function
  */
-export const iterateDeletedStructs = (ds, store, f) =>
+export const iterateDeletedStructs = (transaction, ds, store, f) =>
   ds.clients.forEach((deletes, clientid) => {
-    const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(clientid))
+    const structs = /** @type {Array<GC|Item>} */ (store.clients.get(clientid))
     for (let i = 0; i < deletes.length; i++) {
       const del = deletes[i]
-      let index = findIndexSS(structs, del.clock)
-      let struct
-      do {
-        struct = structs[index++]
-        f(struct)
-      } while (index < structs.length && structs[index].id.clock < del.clock + del.len)
+      iterateStructs(transaction, structs, del.clock, del.len, f)
     }
   })
 
@@ -143,6 +136,27 @@ export const sortAndMergeDeleteSet = ds => {
   })
 }
 
+/**
+ * @param {DeleteSet} ds1
+ * @param {DeleteSet} ds2
+ * @return {DeleteSet} A fresh DeleteSet
+ */
+export const mergeDeleteSets = (ds1, ds2) => {
+  const merged = new DeleteSet()
+  // Write all keys from ds1 to merged. If ds2 has the same key, combine the sets.
+  ds1.clients.forEach((dels1, client) =>
+    merged.clients.set(client, dels1.concat(ds2.clients.get(client) || []))
+  )
+  // Write all missing keys from ds2 to merged.
+  ds2.clients.forEach((dels2, client) => {
+    if (!merged.clients.has(client)) {
+      merged.clients.set(client, dels2)
+    }
+  })
+  sortAndMergeDeleteSet(merged)
+  return merged
+}
+
 /**
  * @param {DeleteSet} ds
  * @param {ID} id

src/utils/Doc.js

@@ -27,6 +27,7 @@ export class Doc extends Observable {
    */
   constructor (conf = {}) {
     super()
+    this.gc = conf.gc || true
     this.clientID = random.uint32()
     /**
      * @type {Map<string, AbstractType<YEvent>>}

src/utils/RelativePosition.js

@@ -1,6 +1,5 @@
 
 import {
-  getItem,
   createID,
   writeID,
   readID,
@@ -9,6 +8,7 @@ import {
   findRootTypeKey,
   Item,
   ContentType,
+  followRedone,
   ID, Doc, AbstractType // eslint-disable-line
 } from '../internals.js'
 
@@ -222,19 +222,22 @@ export const createAbsolutePositionFromRelativePosition = (rpos, doc) => {
     if (getState(store, rightID.client) <= rightID.clock) {
       return null
     }
-    const right = getItem(store, rightID)
+    const res = followRedone(store, rightID)
+    const right = res.item
     if (!(right instanceof Item)) {
       return null
     }
-    index = right.deleted || !right.countable ? 0 : rightID.clock - right.id.clock
-    let n = right.left
-    while (n !== null) {
-      if (!n.deleted && n.countable) {
-        index += n.length
-      }
-      n = n.left
-    }
     type = right.parent
+    if (type._item !== null && !type._item.deleted) {
+      index = right.deleted || !right.countable ? 0 : res.diff
+      let n = right.left
+      while (n !== null) {
+        if (!n.deleted && n.countable) {
+          index += n.length
+        }
+        n = n.left
+      }
+    }
   } else {
     if (tname !== null) {
       type = doc.get(tname)
@@ -243,9 +246,9 @@ export const createAbsolutePositionFromRelativePosition = (rpos, doc) => {
         // type does not exist yet
         return null
       }
-      const struct = getItem(store, typeID)
-      if (struct instanceof Item && struct.content instanceof ContentType) {
-        type = struct.content.type
+      const { item } = followRedone(store, typeID)
+      if (item instanceof Item && item.content instanceof ContentType) {
+        type = item.content.type
       } else {
         // struct is garbage collected
         return null
@@ -255,9 +258,6 @@ export const createAbsolutePositionFromRelativePosition = (rpos, doc) => {
     }
     index = type._length
   }
-  if (type._item !== null && type._item.deleted) {
-    return null
-  }
   return createAbsolutePosition(type, index)
 }
 

src/utils/StructStore.js

@@ -2,7 +2,7 @@
 import {
   GC,
   splitItem,
-  GCRef, ItemRef, Transaction, ID, Item, AbstractStruct // eslint-disable-line
+  GCRef, ItemRef, Transaction, ID, Item // eslint-disable-line
 } from '../internals.js'
 
 import * as math from 'lib0/math.js'
@@ -12,7 +12,7 @@ import * as decoding from 'lib0/decoding.js' // eslint-disable-line
 export class StructStore {
   constructor () {
     /**
-     * @type {Map<number,Array<AbstractStruct>>}
+     * @type {Map<number,Array<GC|Item>>}
      * @private
      */
     this.clients = new Map()
@@ -97,7 +97,7 @@ export const integretyCheck = store => {
 
 /**
  * @param {StructStore} store
- * @param {AbstractStruct} struct
+ * @param {GC|Item} struct
  *
  * @private
  * @function
@@ -151,14 +151,14 @@ export const findIndexSS = (structs, clock) => {
  *
  * @param {StructStore} store
  * @param {ID} id
- * @return {AbstractStruct}
+ * @return {GC|Item}
  *
  * @private
  * @function
  */
 export const find = (store, id) => {
   /**
-   * @type {Array<AbstractStruct>}
+   * @type {Array<GC|Item>}
    */
   // @ts-ignore
   const structs = store.clients.get(id.client)
@@ -178,6 +178,21 @@ export const find = (store, id) => {
 // @ts-ignore
 export const getItem = (store, id) => find(store, id)
 
+/**
+ * @param {Transaction} transaction
+ * @param {Array<Item|GC>} structs
+ * @param {number} clock
+ */
+export const findIndexCleanStart = (transaction, structs, clock) => {
+  const index = findIndexSS(structs, clock)
+  let struct = structs[index]
+  if (struct.id.clock < clock && struct instanceof Item) {
+    structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock))
+    return index + 1
+  }
+  return index
+}
+
 /**
  * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
  *
@@ -190,14 +205,8 @@ export const getItem = (store, id) => find(store, id)
  * @function
  */
 export const getItemCleanStart = (transaction, store, id) => {
-  const structs = /** @type {Array<Item>} */ (store.clients.get(id.client))
-  const index = findIndexSS(structs, id.clock)
-  let struct = structs[index]
-  if (struct.id.clock < id.clock && struct.constructor !== GC) {
-    struct = splitItem(transaction, struct, id.clock - struct.id.clock)
-    structs.splice(index + 1, 0, struct)
-  }
-  return struct
+  const structs = /** @type {Array<GC|Item>} */ (store.clients.get(id.client))
+  return /** @type {Item} */ (structs[findIndexCleanStart(transaction, structs, id.clock)])
 }
 
 /**
@@ -228,13 +237,40 @@ export const getItemCleanEnd = (transaction, store, id) => {
 /**
  * Replace `item` with `newitem` in store
  * @param {StructStore} store
- * @param {AbstractStruct} struct
- * @param {AbstractStruct} newStruct
+ * @param {GC|Item} struct
+ * @param {GC|Item} newStruct
  *
  * @private
  * @function
  */
 export const replaceStruct = (store, struct, newStruct) => {
-  const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(struct.id.client))
+  const structs = /** @type {Array<GC|Item>} */ (store.clients.get(struct.id.client))
   structs[findIndexSS(structs, struct.id.clock)] = newStruct
 }
+
+/**
+ * Iterate over a range of structs
+ *
+ * @param {Transaction} transaction
+ * @param {Array<Item|GC>} structs
+ * @param {number} clockStart Inclusive start
+ * @param {number} len
+ * @param {function(GC|Item):void} f
+ *
+ * @function
+ */
+export const iterateStructs = (transaction, structs, clockStart, len, f) => {
+  if (len === 0) {
+    return
+  }
+  const clockEnd = clockStart + len
+  let index = findIndexCleanStart(transaction, structs, clockStart)
+  let struct
+  do {
+    struct = structs[index++]
+    if (clockEnd < struct.id.clock + struct.length) {
+      findIndexCleanStart(transaction, structs, clockEnd)
+    }
+    f(struct)
+  } while (index < structs.length && structs[index].id.clock < clockEnd)
+}

src/utils/Transaction.js

@@ -16,6 +16,7 @@ import {
 import * as encoding from 'lib0/encoding.js'
 import * as map from 'lib0/map.js'
 import * as math from 'lib0/math.js'
+import * as set from 'lib0/set.js'
 
 /**
  * A transaction is created for every change on the Yjs model. It is possible
@@ -117,6 +118,21 @@ export const nextID = transaction => {
   return createID(y.clientID, getState(y.store, y.clientID))
 }
 
+/**
+ * If `type.parent` was added in current transaction, `type` technically
+ * did not change, it was just added and we should not fire events for `type`.
+ *
+ * @param {Transaction} transaction
+ * @param {AbstractType<YEvent>} type
+ * @param {string|null} parentSub
+ */
+export const addChangedTypeToTransaction = (transaction, type, parentSub) => {
+  const item = type._item
+  if (item === null || (item.id.clock < (transaction.beforeState.get(item.id.client) || 0) && !item.deleted)) {
+    map.setIfUndefined(transaction.changed, type, set.create).add(parentSub)
+  }
+}
+
 /**
  * Implements the functionality of `y.transact(()=>{..})`
  *
@@ -153,20 +169,26 @@ export const transact = (doc, f, origin = null) => {
         doc.emit('beforeObserverCalls', [transaction, doc])
         // emit change events on changed types
         transaction.changed.forEach((subs, itemtype) => {
-          itemtype._callObserver(transaction, subs)
+          if (itemtype._item === null || !itemtype._item.deleted) {
+            itemtype._callObserver(transaction, subs)
+          }
         })
         transaction.changedParentTypes.forEach((events, type) => {
-          events = events
-            .filter(event =>
-              event.target._item === null || !event.target._item.deleted
-            )
-          events
-            .forEach(event => {
-              event.currentTarget = type
-            })
-          // we don't need to check for events.length
-          // because we know it has at least one element
-          callEventHandlerListeners(type._dEH, events, transaction)
+          // We need to think about the possibility that the user transforms the
+          // Y.Doc in the event.
+          if (type._item === null || !type._item.deleted) {
+            events = events
+              .filter(event =>
+                event.target._item === null || !event.target._item.deleted
+              )
+            events
+              .forEach(event => {
+                event.currentTarget = type
+              })
+            // We don't need to check for events.length
+            // because we know it has at least one element
+            callEventHandlerListeners(type._dEH, events, transaction)
+          }
         })
         doc.emit('afterTransaction', [transaction, doc])
         /**
@@ -185,23 +207,26 @@ export const transact = (doc, f, origin = null) => {
             }
           }
         }
-        // replace deleted items with ItemDeleted / GC
-        for (const [client, deleteItems] of ds.clients) {
-          const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
-          for (let di = deleteItems.length - 1; di >= 0; di--) {
-            const deleteItem = deleteItems[di]
-            const endDeleteItemClock = deleteItem.clock + deleteItem.len
-            for (
-              let si = findIndexSS(structs, deleteItem.clock), struct = structs[si];
-              si < structs.length && struct.id.clock < endDeleteItemClock;
-              struct = structs[++si]
-            ) {
-              const struct = structs[si]
-              if (deleteItem.clock + deleteItem.len <= struct.id.clock) {
-                break
-              }
-              if (struct.deleted && struct instanceof Item) {
-                struct.gc(store, false)
+        // Replace deleted items with ItemDeleted / GC.
+        // This is where content is actually remove from the Yjs Doc.
+        if (doc.gc) {
+          for (const [client, deleteItems] of ds.clients) {
+            const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(client))
+            for (let di = deleteItems.length - 1; di >= 0; di--) {
+              const deleteItem = deleteItems[di]
+              const endDeleteItemClock = deleteItem.clock + deleteItem.len
+              for (
+                let si = findIndexSS(structs, deleteItem.clock), struct = structs[si];
+                si < structs.length && struct.id.clock < endDeleteItemClock;
+                struct = structs[++si]
+              ) {
+                const struct = structs[si]
+                if (deleteItem.clock + deleteItem.len <= struct.id.clock) {
+                  break
+                }
+                if (struct instanceof Item && struct.deleted && !struct.keep) {
+                  struct.gc(store, false)
+                }
               }
             }
           }

src/utils/UndoManager.js

@@ -1,202 +1,221 @@
-// @ts-nocheck
-
 import {
+  mergeDeleteSets,
+  iterateDeletedStructs,
+  keepItem,
+  transact,
+  redoItem,
+  iterateStructs,
   isParentOf,
   createID,
-  transact
+  followRedone,
+  getItemCleanStart,
+  Transaction, Doc, Item, GC, DeleteSet, AbstractType // eslint-disable-line
 } from '../internals.js'
 
-/**
- * @private
- */
-class ReverseOperation {
-  constructor (y, transaction, bindingInfos) {
-    this.created = new Date()
-    const beforeState = transaction.beforeState
-    if (beforeState.has(y.userID)) {
-      this.toState = createID(y.userID, y.ss.getState(y.userID) - 1)
-      this.fromState = createID(y.userID, beforeState.get(y.userID))
-    } else {
-      this.toState = null
-      this.fromState = null
-    }
-    this.deletedStructs = new Set()
-    transaction.deletedStructs.forEach(struct => {
-      this.deletedStructs.add({
-        from: struct._id,
-        len: struct._length
-      })
-    })
+import * as time from 'lib0/time.js'
+import { Observable } from 'lib0/observable.js'
+
+class StackItem {
+  /**
+   * @param {DeleteSet} ds
+   * @param {number} start clock start of the local client
+   * @param {number} len
+   */
+  constructor (ds, start, len) {
+    this.ds = ds
+    this.start = start
+    this.len = len
     /**
-     * Maps from binding to binding information (e.g. cursor information)
+     * Use this to save and restore metadata like selection range
      */
-    this.bindingInfos = bindingInfos
+    this.meta = new Map()
   }
 }
 
 /**
- * @private
- * @function
+ * @param {UndoManager} undoManager
+ * @param {Array<StackItem>} stack
+ * @param {string} eventType
+ * @return {StackItem?}
  */
-function applyReverseOperation (y, scope, reverseBuffer) {
-  let performedUndo = false
-  let undoOp = null
-  transact(y, () => {
-    while (!performedUndo && reverseBuffer.length > 0) {
-      undoOp = reverseBuffer.pop()
-      // make sure that it is possible to iterate {from}-{to}
-      if (undoOp.fromState !== null) {
-        y.os.getItemCleanStart(undoOp.fromState)
-        y.os.getItemCleanEnd(undoOp.toState)
-        y.os.iterate(undoOp.fromState, undoOp.toState, op => {
-          while (op._deleted && op._redone !== null) {
-            op = op._redone
-          }
-          if (op._deleted === false && isParentOf(scope, op)) {
-            performedUndo = true
-            op._delete(y)
-          }
-        })
-      }
-      const redoitems = new Set()
-      for (let del of undoOp.deletedStructs) {
-        const fromState = del.from
-        const toState = createID(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)
-          }
-        })
-      }
-      redoitems.forEach(op => {
-        const opUndone = op._redo(y, redoitems)
-        performedUndo = performedUndo || opUndone
-      })
-    }
-  })
-  if (performedUndo && undoOp !== null) {
-    // should be performed after the undo transaction
-    undoOp.bindingInfos.forEach((info, binding) => {
-      binding._restoreUndoStackInfo(info)
-    })
-  }
-  return performedUndo
-}
-
-/**
- * Saves a history of locally applied operations. The UndoManager handles the
- * undoing and redoing of locally created changes.
- *
- * @private
- * @function
- */
-export class UndoManager {
+const popStackItem = (undoManager, stack, eventType) => {
   /**
-   * @param {YType} scope The scope on which to listen for changes.
-   * @param {Object} options Optionally provided configuration.
+   * Whether a change happened
+   * @type {StackItem?}
    */
-  constructor (scope, options = {}) {
-    this.options = options
-    this._bindings = new Set(options.bindings)
-    options.captureTimeout = options.captureTimeout == null ? 500 : options.captureTimeout
-    this._undoBuffer = []
-    this._redoBuffer = []
-    this._scope = scope
-    this._undoing = false
-    this._redoing = false
-    this._lastTransactionWasUndo = false
-    const doc = scope.doc
-    this.y = doc
-    let bindingInfos
-    doc.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())
-        })
-      }
-    })
-    doc.on('afterTransaction', (y, transaction, remote) => {
-      if (!remote && transaction.changedParentTypes.has(scope)) {
-        let reverseOperation = new ReverseOperation(y, transaction, bindingInfos)
-        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.getTime() - lastUndoOp.created.getTime()) <= options.captureTimeout)
-          ) {
-            lastUndoOp.created = reverseOperation.created
-            if (reverseOperation.toState !== null) {
-              lastUndoOp.toState = reverseOperation.toState
-              if (lastUndoOp.fromState === null) {
-                lastUndoOp.fromState = reverseOperation.fromState
-              }
-            }
-            reverseOperation.deletedStructs.forEach(lastUndoOp.deletedStructs.add, lastUndoOp.deletedStructs)
-          } else {
-            this._lastTransactionWasUndo = false
-            this._undoBuffer.push(reverseOperation)
-          }
-          if (!this._redoing) {
-            this._redoBuffer = []
-          }
-        } else {
-          this._lastTransactionWasUndo = true
-          this._redoBuffer.push(reverseOperation)
+  let result = null
+  const doc = undoManager.doc
+  const scope = undoManager.scope
+  transact(doc, transaction => {
+    while (stack.length > 0 && result === null) {
+      const store = doc.store
+      const stackItem = /** @type {StackItem} */ (stack.pop())
+      const itemsToRedo = new Set()
+      let performedChange = false
+      iterateDeletedStructs(transaction, stackItem.ds, store, struct => {
+        if (struct instanceof Item && scope.some(type => isParentOf(type, struct))) {
+          itemsToRedo.add(struct)
         }
+      })
+      itemsToRedo.forEach(item => {
+        performedChange = redoItem(transaction, item, itemsToRedo) !== null || performedChange
+      })
+      const structs = /** @type {Array<GC|Item>} */ (store.clients.get(doc.clientID))
+      iterateStructs(transaction, structs, stackItem.start, stackItem.len, struct => {
+        if (struct instanceof Item && !struct.deleted && scope.some(type => isParentOf(type, /** @type {Item} */ (struct)))) {
+          if (struct.redone !== null) {
+            let { item, diff } = followRedone(store, struct.id)
+            if (diff > 0) {
+              item = getItemCleanStart(transaction, store, createID(item.id.client, item.id.clock + diff))
+            }
+            if (item.length > stackItem.len) {
+              getItemCleanStart(transaction, store, createID(item.id.client, item.id.clock + stackItem.len))
+            }
+            struct = item
+          }
+          keepItem(struct)
+          struct.delete(transaction)
+          performedChange = true
+        }
+      })
+      result = stackItem
+      if (result != null) {
+        undoManager.emit('stack-item-popped', [{ stackItem: result, type: eventType }, undoManager])
       }
+    }
+  }, undoManager)
+  return result
+}
+
+/**
+ * Fires 'stack-item-added' event when a stack item was added to either the undo- or
+ * the redo-stack. You may store additional stack information via the
+ * metadata property on `event.stackItem.metadata` (it is a `Map` of metadata properties).
+ * Fires 'stack-item-popped' event when a stack item was popped from either the
+ * undo- or the redo-stack. You may restore the saved stack information from `event.stackItem.metadata`.
+ *
+ * @extends {Observable<'stack-item-added'|'stack-item-popped'>}
+ */
+export class UndoManager extends Observable {
+  /**
+   * @param {AbstractType<any>|Array<AbstractType<any>>} typeScope Accepts either a single type, or an array of types
+   * @param {Set<any>} [trackedTransactionOrigins=new Set([null])]
+   * @param {object} [options={captureTimeout=500}]
+   */
+  constructor (typeScope, trackedTransactionOrigins = new Set([null]), { captureTimeout = 500 } = {}) {
+    super()
+    this.scope = typeScope instanceof Array ? typeScope : [typeScope]
+    trackedTransactionOrigins.add(this)
+    this.trackedTransactionOrigins = trackedTransactionOrigins
+    /**
+     * @type {Array<StackItem>}
+     */
+    this.undoStack = []
+    /**
+     * @type {Array<StackItem>}
+     */
+    this.redoStack = []
+    /**
+     * Whether the client is currently undoing (calling UndoManager.undo)
+     *
+     * @type {boolean}
+     */
+    this.undoing = false
+    this.redoing = false
+    this.doc = /** @type {Doc} */ (this.scope[0].doc)
+    this.lastChange = 0
+    this.doc.on('afterTransaction', /** @param {Transaction} transaction */ transaction => {
+      // Only track certain transactions
+      if (!this.scope.some(type => transaction.changedParentTypes.has(type)) || (!this.trackedTransactionOrigins.has(transaction.origin) && (!transaction.origin || !this.trackedTransactionOrigins.has(transaction.origin.constructor)))) {
+        return
+      }
+      const undoing = this.undoing
+      const redoing = this.redoing
+      const stack = undoing ? this.redoStack : this.undoStack
+      if (undoing) {
+        this.stopCapturing() // next undo should not be appended to last stack item
+      } else if (!redoing) {
+        // neither undoing nor redoing: delete redoStack
+        this.redoStack = []
+      }
+      const beforeState = transaction.beforeState.get(this.doc.clientID) || 0
+      const afterState = transaction.afterState.get(this.doc.clientID) || 0
+      const now = time.getUnixTime()
+      if (now - this.lastChange < captureTimeout && stack.length > 0 && !undoing && !redoing) {
+        // append change to last stack op
+        const lastOp = stack[stack.length - 1]
+        lastOp.ds = mergeDeleteSets(lastOp.ds, transaction.deleteSet)
+        lastOp.len = afterState - lastOp.start
+      } else {
+        // create a new stack op
+        stack.push(new StackItem(transaction.deleteSet, beforeState, afterState - beforeState))
+      }
+      if (!undoing && !redoing) {
+        this.lastChange = now
+      }
+      // make sure that deleted structs are not gc'd
+      iterateDeletedStructs(transaction, transaction.deleteSet, transaction.doc.store, /** @param {Item|GC} item */ item => {
+        if (item instanceof Item && this.scope.some(type => isParentOf(type, item))) {
+          keepItem(item)
+        }
+      })
+      this.emit('stack-item-added', [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? 'redo' : 'undo' }, this])
     })
   }
 
   /**
-   * Enforce that the next change is created as a separate item in the undo stack
+   * UndoManager merges Undo-StackItem if they are created within time-gap
+   * smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next
+   * StackItem won't be merged.
+   *
+   *
+   * @example
+   *     // without stopCapturing
+   *     ytext.insert(0, 'a')
+   *     ytext.insert(1, 'b')
+   *     um.undo()
+   *     ytext.toString() // => '' (note that 'ab' was removed)
+   *     // with stopCapturing
+   *     ytext.insert(0, 'a')
+   *     um.stopCapturing()
+   *     ytext.insert(0, 'b')
+   *     um.undo()
+   *     ytext.toString() // => 'a' (note that only 'b' was removed)
    *
-   * @private
-   * @function
    */
-  flushChanges () {
-    this._lastTransactionWasUndo = true
+  stopCapturing () {
+    this.lastChange = 0
   }
 
   /**
-   * Undo the last locally created change.
+   * Undo last changes on type.
    *
-   * @private
-   * @function
+   * @return {StackItem?} Returns StackItem if a change was applied
    */
   undo () {
-    this._undoing = true
-    const performedUndo = applyReverseOperation(this.y, this._scope, this._undoBuffer)
-    this._undoing = false
-    return performedUndo
+    this.undoing = true
+    let res
+    try {
+      res = popStackItem(this, this.undoStack, 'undo')
+    } finally {
+      this.undoing = false
+    }
+    return res
   }
 
   /**
-   * Redo the last locally created change.
+   * Redo last undo operation.
    *
-   * @private
-   * @function
+   * @return {StackItem?} Returns StackItem if a change was applied
    */
   redo () {
-    this._redoing = true
-    const performedRedo = applyReverseOperation(this.y, this._scope, this._redoBuffer)
-    this._redoing = false
-    return performedRedo
+    this.redoing = true
+    let res
+    try {
+      res = popStackItem(this, this.redoStack, 'redo')
+    } finally {
+      this.redoing = false
+    }
+    return res
   }
 }

src/utils/isParentOf.js

@@ -1,22 +1,22 @@
 
-import { AbstractType } from '../internals.js' // eslint-disable-line
+import { AbstractType, Item } from '../internals.js' // eslint-disable-line
 
 /**
  * Check if `parent` is a parent of `child`.
  *
  * @param {AbstractType<any>} parent
- * @param {AbstractType<any>} child
+ * @param {Item|null} child
  * @return {Boolean} Whether `parent` is a parent of `child`.
  *
  * @private
  * @function
  */
 export const isParentOf = (parent, child) => {
-  while (child._item !== null) {
-    if (child === parent) {
+  while (child !== null) {
+    if (child.parent === parent) {
       return true
     }
-    child = child._item.parent
+    child = child.parent._item
   }
   return false
 }

tests/index.js

@@ -4,6 +4,7 @@ import * as map from './y-map.tests.js'
 import * as text from './y-text.tests.js'
 import * as xml from './y-xml.tests.js'
 import * as encoding from './encoding.tests.js'
+import * as undoredo from './undo-redo.tests.js'
 
 import { runTests } from 'lib0/testing.js'
 import { isBrowser, isNode } from 'lib0/environment.js'
@@ -13,7 +14,7 @@ if (isBrowser) {
   log.createVConsole(document.body)
 }
 runTests({
-  map, array, text, xml, encoding
+  map, array, text, xml, encoding, undoredo
 }).then(success => {
   /* istanbul ignore next */
   if (isNode) {

tests/testHelper.js

@@ -266,8 +266,11 @@ export const compare = users => {
     t.assert(u.store.pendingClientsStructRefs.size === 0)
   }
   // Test Array iterator
-  t.compare(userArrayValues[0], Array.from(users[0].getArray('array').toJSON()))
+  t.compare(users[0].getArray('array').toArray(), Array.from(users[0].getArray('array')))
   // Test Map iterator
+  const ymapkeys = Array.from(users[0].getMap('map').keys())
+  t.assert(ymapkeys.length === Object.keys(userMapValues[0]).length)
+  ymapkeys.forEach(key => t.assert(userMapValues[0].hasOwnProperty(key)))
   /**
    * @type {Object<string,any>}
    */

tests/undo-redo.tests.js

@@ -0,0 +1,203 @@
+import { init, compare, applyRandomTests, Doc } from './testHelper.js' // eslint-disable-line
+
+import {
+  UndoManager
+} from '../src/internals.js'
+
+import * as Y from '../src/index.js'
+import * as t from 'lib0/testing.js'
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoText = tc => {
+  const { testConnector, text0, text1 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(text0)
+  text0.insert(0, 'abc')
+  text1.insert(0, 'xyz')
+  testConnector.syncAll()
+  undoManager.undo()
+  t.assert(text0.toString() === 'xyz')
+  undoManager.redo()
+  t.assert(text0.toString() === 'abcxyz')
+  testConnector.syncAll()
+  text1.delete(0, 1)
+  testConnector.syncAll()
+  undoManager.undo()
+  t.assert(text0.toString() === 'xyz')
+  undoManager.redo()
+  t.assert(text0.toString() === 'bcxyz')
+  // test marks
+  text0.format(1, 3, { bold: true })
+  t.compare(text0.toDelta(), [{ insert: 'b' }, { insert: 'cxy', attributes: { bold: true } }, { insert: 'z' }])
+  undoManager.undo()
+  t.compare(text0.toDelta(), [{ insert: 'bcxyz' }])
+  undoManager.redo()
+  t.compare(text0.toDelta(), [{ insert: 'b' }, { insert: 'cxy', attributes: { bold: true } }, { insert: 'z' }])
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoMap = tc => {
+  const { testConnector, map0, map1 } = init(tc, { users: 2 })
+  map0.set('a', 0)
+  const undoManager = new UndoManager(map0)
+  map0.set('a', 1)
+  undoManager.undo()
+  t.assert(map0.get('a') === 0)
+  undoManager.redo()
+  t.assert(map0.get('a') === 1)
+  // testing sub-types and if it can restore a whole type
+  const subType = new Y.Map()
+  map0.set('a', subType)
+  subType.set('x', 42)
+  t.compare(map0.toJSON(), /** @type {any} */ ({ 'a': { x: 42 } }))
+  undoManager.undo()
+  t.assert(map0.get('a') === 1)
+  undoManager.redo()
+  t.compare(map0.toJSON(), /** @type {any} */ ({ 'a': { x: 42 } }))
+  testConnector.syncAll()
+  // if content is overwritten by another user, undo operations should be skipped
+  map1.set('a', 44)
+  testConnector.syncAll()
+  undoManager.undo()
+  t.assert(map0.get('a') === 44)
+  undoManager.redo()
+  t.assert(map0.get('a') === 44)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoArray = tc => {
+  const { testConnector, array0, array1 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(array0)
+  array0.insert(0, [1, 2, 3])
+  array1.insert(0, [4, 5, 6])
+  testConnector.syncAll()
+  t.compare(array0.toArray(), [1, 2, 3, 4, 5, 6])
+  undoManager.undo()
+  t.compare(array0.toArray(), [4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toArray(), [1, 2, 3, 4, 5, 6])
+  testConnector.syncAll()
+  array1.delete(0, 1) // user1 deletes [1]
+  testConnector.syncAll()
+  undoManager.undo()
+  t.compare(array0.toArray(), [4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toArray(), [2, 3, 4, 5, 6])
+  array0.delete(0, 5)
+  // test nested structure
+  const ymap = new Y.Map()
+  array0.insert(0, [ymap])
+  t.compare(array0.toJSON(), [{}])
+  undoManager.stopCapturing()
+  ymap.set('a', 1)
+  t.compare(array0.toJSON(), [{ a: 1 }])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [{}])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [2, 3, 4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{}])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{ a: 1 }])
+  testConnector.syncAll()
+  array1.get(0).set('b', 2)
+  testConnector.syncAll()
+  t.compare(array0.toJSON(), [{ a: 1, b: 2 }])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [{ b: 2 }])
+  undoManager.undo()
+  t.compare(array0.toJSON(), [2, 3, 4, 5, 6])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{ b: 2 }])
+  undoManager.redo()
+  t.compare(array0.toJSON(), [{ a: 1, b: 2 }])
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoXml = tc => {
+  const { xml0 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(xml0)
+  const child = new Y.XmlElement('p')
+  xml0.insert(0, [child])
+  const textchild = new Y.XmlText('content')
+  child.insert(0, [textchild])
+  t.assert(xml0.toString() === '<undefined><p>content</p></undefined>')
+  // format textchild and revert that change
+  undoManager.stopCapturing()
+  textchild.format(3, 4, { bold: {} })
+  t.assert(xml0.toString() === '<undefined><p>con<bold>tent</bold></p></undefined>')
+  undoManager.undo()
+  t.assert(xml0.toString() === '<undefined><p>content</p></undefined>')
+  undoManager.redo()
+  t.assert(xml0.toString() === '<undefined><p>con<bold>tent</bold></p></undefined>')
+  xml0.delete(0, 1)
+  t.assert(xml0.toString() === '<undefined></undefined>')
+  undoManager.undo()
+  t.assert(xml0.toString() === '<undefined><p>con<bold>tent</bold></p></undefined>')
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testUndoEvents = tc => {
+  const { text0 } = init(tc, { users: 3 })
+  const undoManager = new UndoManager(text0)
+  let counter = 0
+  let receivedMetadata = -1
+  undoManager.on('stack-item-added', /** @param {any} event */ event => {
+    t.assert(event.type != null)
+    event.stackItem.meta.set('test', counter++)
+  })
+  undoManager.on('stack-item-popped', /** @param {any} event */ event => {
+    t.assert(event.type != null)
+    receivedMetadata = event.stackItem.meta.get('test')
+  })
+  text0.insert(0, 'abc')
+  undoManager.undo()
+  t.assert(receivedMetadata === 0)
+  undoManager.redo()
+  t.assert(receivedMetadata === 1)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testTrackClass = tc => {
+  const { users, text0 } = init(tc, { users: 3 })
+  // only track origins that are numbers
+  const undoManager = new UndoManager(text0, new Set([Number]))
+  users[0].transact(() => {
+    text0.insert(0, 'abc')
+  }, 42)
+  t.assert(text0.toString() === 'abc')
+  undoManager.undo()
+  t.assert(text0.toString() === '')
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testTypeScope = tc => {
+  const { array0 } = init(tc, { users: 3 })
+  // only track origins that are numbers
+  const text0 = new Y.Text()
+  const text1 = new Y.Text()
+  array0.insert(0, [text0, text1])
+  const undoManager = new UndoManager(text0)
+  const undoManagerBoth = new UndoManager([text0, text1])
+  text1.insert(0, 'abc')
+  t.assert(undoManager.undoStack.length === 0)
+  t.assert(undoManagerBoth.undoStack.length === 1)
+  t.assert(text1.toString() === 'abc')
+  undoManager.undo()
+  t.assert(text1.toString() === 'abc')
+  undoManagerBoth.undo()
+  t.assert(text1.toString() === '')
+}

tests/y-array.tests.js

@@ -210,6 +210,24 @@ export const testInsertAndDeleteEventsForTypes2 = tc => {
   compare(users)
 }
 
+/**
+ * This issue has been reported here https://github.com/y-js/yjs/issues/155
+ * @param {t.TestCase} tc
+ */
+export const testNewChildDoesNotEmitEventInTransaction = tc => {
+  const { array0, users } = init(tc, { users: 2 })
+  let fired = false
+  users[0].transact(() => {
+    const newMap = new Y.Map()
+    newMap.observe(() => {
+      fired = true
+    })
+    array0.insert(0, [newMap])
+    newMap.set('tst', 42)
+  })
+  t.assert(!fired, 'Event does not trigger')
+}
+
 /**
  * @param {t.TestCase} tc
  */