Use generic Item with typed content to reduce cache misses

src/structs/AbstractStruct.js

@@ -12,14 +12,16 @@ import * as error from 'lib0/error.js'
 export class AbstractStruct {
   /**
    * @param {ID} id
+   * @param {number} length
    */
-  constructor (id) {
+  constructor (id, length) {
     /**
      * The uniqe identifier of this struct.
      * @type {ID}
      * @readonly
      */
     this.id = id
+    this.length = length
     this.deleted = false
   }
   /**
@@ -32,12 +34,6 @@ export class AbstractStruct {
   mergeWith (right) {
     return false
   }
-  /**
-   * @type {number}
-   */
-  get length () {
-    throw error.methodUnimplemented()
-  }
   /**
    * @param {encoding.Encoder} encoder The encoder to write data to.
    * @param {number} offset
@@ -89,10 +85,4 @@ export class AbstractStructRef {
   toStruct (transaction, store, offset) {
     throw error.methodUnimplemented()
   }
-  /**
-   * @type {number}
-   */
-  get length () {
-    return 1
-  }
 }

src/structs/ContentBinary.js

@@ -0,0 +1,92 @@
+import {
+  StructStore, Item, Transaction // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as buffer from 'lib0/buffer.js'
+import * as error from 'lib0/error.js'
+
+/**
+ * @private
+ */
+export class ContentBinary {
+  /**
+   * @param {Uint8Array} content
+   */
+  constructor (content) {
+    this.content = content
+  }
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return [this.content]
+  }
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+  /**
+   * @return {ContentBinary}
+   */
+  copy () {
+    return new ContentBinary(this.content)
+  }
+  /**
+   * @param {number} offset
+   * @return {ContentBinary}
+   */
+  splice (offset) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {ContentBinary} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    return false
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {}
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {}
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {}
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    encoding.writeVarUint8Array(encoder, this.content)
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 3
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentBinary}
+ */
+export const readContentBinary = decoder => new ContentBinary(buffer.copyUint8Array(decoding.readVarUint8Array(decoder)))

src/structs/ContentDeleted.js

@@ -0,0 +1,98 @@
+
+import {
+  addToDeleteSet,
+  StructStore, Item, Transaction // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export class ContentDeleted {
+  /**
+   * @param {number} len
+   */
+  constructor (len) {
+    this.len = len
+  }
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return this.len
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return []
+  }
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return false
+  }
+  /**
+   * @return {ContentDeleted}
+   */
+  copy () {
+    return new ContentDeleted(this.len)
+  }
+  /**
+   * @param {number} offset
+   * @return {ContentDeleted}
+   */
+  splice (offset) {
+    const right = new ContentDeleted(this.len - offset)
+    this.len = offset
+    return right
+  }
+  /**
+   * @param {ContentDeleted} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this.len += right.len
+    return true
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {
+    addToDeleteSet(transaction.deleteSet, item.id, this.len)
+    item.deleted = true
+  }
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {}
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {}
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    encoding.writeVarUint(encoder, this.len - offset)
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 1
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentDeleted}
+ */
+export const readContentDeleted = decoder => new ContentDeleted(decoding.readVarUint(decoder))

src/structs/ContentEmbed.js

@@ -0,0 +1,92 @@
+
+import {
+  StructStore, Item, Transaction // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as error from 'lib0/error.js'
+
+/**
+ * @private
+ */
+export class ContentEmbed {
+  /**
+   * @param {Object} embed
+   */
+  constructor (embed) {
+    this.embed = embed
+  }
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return [this.embed]
+  }
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+  /**
+   * @return {ContentEmbed}
+   */
+  copy () {
+    return new ContentEmbed(this.embed)
+  }
+  /**
+   * @param {number} offset
+   * @return {ContentEmbed}
+   */
+  splice (offset) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {ContentEmbed} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    return false
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {}
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {}
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {}
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    encoding.writeVarString(encoder, JSON.stringify(this.embed))
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 5
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentEmbed}
+ */
+export const readContentEmbed = decoder => new ContentEmbed(JSON.parse(decoding.readVarString(decoder)))

src/structs/ContentFormat.js

@@ -0,0 +1,95 @@
+
+import {
+  Item, StructStore, Transaction // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as error from 'lib0/error.js'
+
+/**
+ * @private
+ */
+export class ContentFormat {
+  /**
+   * @param {string} key
+   * @param {Object} value
+   */
+  constructor (key, value) {
+    this.key = key
+    this.value = value
+  }
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return []
+  }
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return false
+  }
+  /**
+   * @return {ContentFormat}
+   */
+  copy () {
+    return new ContentFormat(this.key, this.value)
+  }
+  /**
+   * @param {number} offset
+   * @return {ContentFormat}
+   */
+  splice (offset) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {ContentFormat} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    return false
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {}
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {}
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {}
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    encoding.writeVarString(encoder, this.key)
+    encoding.writeVarString(encoder, JSON.stringify(this.value))
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 6
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentFormat}
+ */
+export const readContentFormat = decoder => new ContentFormat(decoding.readVarString(decoder), JSON.parse(decoding.readVarString(decoder)))

src/structs/ContentJSON.js

@@ -0,0 +1,113 @@
+import {
+  Transaction, Item, StructStore // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export class ContentJSON {
+  /**
+   * @param {Array<any>} arr
+   */
+  constructor (arr) {
+    /**
+     * @type {Array<any>}
+     */
+    this.arr = arr
+  }
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return this.arr.length
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return this.arr
+  }
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+  /**
+   * @return {ContentJSON}
+   */
+  copy () {
+    return new ContentJSON(this.arr)
+  }
+  /**
+   * @param {number} offset
+   * @return {ContentJSON}
+   */
+  splice (offset) {
+    const right = new ContentJSON(this.arr.slice(offset))
+    this.arr = this.arr.slice(0, offset)
+    return right
+  }
+  /**
+   * @param {ContentJSON} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this.arr = this.arr.concat(right.arr)
+    return true
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {}
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {}
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {}
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    const len = this.arr.length
+    encoding.writeVarUint(encoder, len - offset)
+    for (let i = offset; i < len; i++) {
+      const c = this.arr[i]
+      encoding.writeVarString(encoder, c === undefined ? 'undefined' : JSON.stringify(c))
+    }
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 2
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentJSON}
+ */
+export const readContentJSON = decoder => {
+  const len = decoding.readVarUint(decoder)
+  const cs = []
+  for (let i = 0; i < len; i++) {
+    const c = decoding.readVarString(decoder)
+    if (c === 'undefined') {
+      cs.push(undefined)
+    } else {
+      cs.push(JSON.parse(c))
+    }
+  }
+  return new ContentJSON(cs)
+}

src/structs/ContentString.js

@@ -0,0 +1,96 @@
+import {
+  Transaction, Item, StructStore // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export class ContentString {
+  /**
+   * @param {string} str
+   */
+  constructor (str) {
+    /**
+     * @type {string}
+     */
+    this.str = str
+  }
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return this.str.length
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return this.str.split('')
+  }
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+  /**
+   * @return {ContentString}
+   */
+  copy () {
+    return new ContentString(this.str)
+  }
+  /**
+   * @param {number} offset
+   * @return {ContentString}
+   */
+  splice (offset) {
+    const right = new ContentString(this.str.slice(offset))
+    this.str = this.str.slice(0, offset)
+    return right
+  }
+  /**
+   * @param {ContentString} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this.str += right.str
+    return true
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {}
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {}
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {}
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    encoding.writeVarString(encoder, offset === 0 ? this.str : this.str.slice(offset))
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 4
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentString}
+ */
+export const readContentString = decoder => new ContentString(decoding.readVarString(decoder))

src/structs/ContentType.js

@@ -0,0 +1,161 @@
+
+import {
+  readYArray,
+  readYMap,
+  readYText,
+  readYXmlElement,
+  readYXmlFragment,
+  readYXmlHook,
+  readYXmlText,
+  StructStore, Transaction, Item, YEvent, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js' // eslint-disable-line
+import * as decoding from 'lib0/decoding.js'
+import * as error from 'lib0/error.js'
+
+/**
+ * @type {Array<function(decoding.Decoder):AbstractType<any>>}
+ * @private
+ */
+export const typeRefs = [
+  readYArray,
+  readYMap,
+  readYText,
+  readYXmlElement,
+  readYXmlFragment,
+  readYXmlHook,
+  readYXmlText
+]
+
+export const YArrayRefID = 0
+export const YMapRefID = 1
+export const YTextRefID = 2
+export const YXmlElementRefID = 3
+export const YXmlFragmentRefID = 4
+export const YXmlHookRefID = 5
+export const YXmlTextRefID = 6
+
+/**
+ * @private
+ */
+export class ContentType {
+  /**
+   * @param {AbstractType<YEvent>} type
+   */
+  constructor (type) {
+    this.type = type
+  }
+  /**
+   * @return {number}
+   */
+  getLength () {
+    return 1
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    return [this.type]
+  }
+  /**
+   * @return {boolean}
+   */
+  isCountable () {
+    return true
+  }
+  /**
+   * @return {ContentType}
+   */
+  copy () {
+    return new ContentType(this.type._copy())
+  }
+  /**
+   * @param {number} offset
+   * @return {ContentType}
+   */
+  splice (offset) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {ContentType} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    return false
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {
+    this.type._integrate(transaction.doc, item)
+  }
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {
+    let item = this.type._start
+    while (item !== null) {
+      if (!item.deleted) {
+        item.delete(transaction)
+      } else {
+        // Whis will be gc'd later and we want to merge it if possible
+        // We try to merge all deleted items after each transaction,
+        // but we have no knowledge about that this needs to be merged
+        // since it is not in transaction.ds. Hence we add it to transaction._mergeStructs
+        transaction._mergeStructs.add(item.id)
+      }
+      item = item.right
+    }
+    this.type._map.forEach(item => {
+      if (!item.deleted) {
+        item.delete(transaction)
+      } else {
+        // same as above
+        transaction._mergeStructs.add(item.id)
+      }
+    })
+    transaction.changed.delete(this.type)
+    transaction.changedParentTypes.delete(this.type)
+  }
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {
+    let item = this.type._start
+    while (item !== null) {
+      item.gc(store, true)
+      item = item.right
+    }
+    this.type._start = null
+    this.type._map.forEach(/** @param {Item | null} item */ (item) => {
+      while (item !== null) {
+        item.gc(store, true)
+        item = item.left
+      }
+    })
+    this.type._map = new Map()
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    this.type._write(encoder)
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 7
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ContentType}
+ */
+export const readContentType = decoder => new ContentType(typeRefs[decoding.readVarUint(decoder)](decoder))

src/structs/GC.js

@@ -21,26 +21,18 @@ export class GC extends AbstractStruct {
    * @param {number} length
    */
   constructor (id, length) {
-    super(id)
-    /**
-     * @type {number}
-     */
-    this._len = length
+    super(id, length)
     this.deleted = true
   }
 
-  get length () {
-    return this._len
-  }
-
   delete () {}
 
   /**
-   * @param {AbstractStruct} right
+   * @param {GC} right
    * @return {boolean}
    */
   mergeWith (right) {
-    this._len += right.length
+    this.length += right.length
     return true
   }
 
@@ -57,7 +49,7 @@ export class GC extends AbstractStruct {
    */
   write (encoder, offset) {
     encoding.writeUint8(encoder, structGCRefNumber)
-    encoding.writeVarUint(encoder, this._len - offset)
+    encoding.writeVarUint(encoder, this.length - offset)
   }
 }
 
@@ -75,15 +67,7 @@ export class GCRef extends AbstractStructRef {
     /**
      * @type {number}
      */
-    this._len = decoding.readVarUint(decoder)
-  }
-  get length () {
-    return this._len
-  }
-  missing () {
-    return [
-      createID(this.id.client, this.id.clock - 1)
-    ]
+    this.length = decoding.readVarUint(decoder)
   }
   /**
    * @param {Transaction} transaction
@@ -95,11 +79,11 @@ export class GCRef extends AbstractStructRef {
     if (offset > 0) {
       // @ts-ignore
       this.id = createID(this.id.client, this.id.clock + offset)
-      this._len = this._len - offset
+      this.length -= offset
     }
     return new GC(
       this.id,
-      this._len
+      this.length
     )
   }
 }

src/structs/Item.js

@@ -10,14 +10,19 @@ import {
   replaceStruct,
   addStruct,
   addToDeleteSet,
-  ItemDeleted,
   findRootTypeKey,
   compareIDs,
   getItem,
-  getItemType,
   getItemCleanEnd,
   getItemCleanStart,
-  YEvent, StructStore, ID, AbstractType, Transaction // eslint-disable-line
+  readContentDeleted,
+  readContentBinary,
+  readContentJSON,
+  readContentString,
+  readContentEmbed,
+  readContentFormat,
+  readContentType,
+  ContentType, ContentDeleted, StructStore, ID, AbstractType, Transaction // eslint-disable-line
 } from '../internals.js'
 
 import * as error from 'lib0/error.js'
@@ -27,28 +32,12 @@ import * as maplib from 'lib0/map.js'
 import * as set from 'lib0/set.js'
 import * as binary from 'lib0/binary.js'
 
-/**
- * @param {AbstractItem} left
- * @param {AbstractItem} right
- * @return {boolean} If true, right is removed from the linked list and should be discarded
- */
-export const mergeItemWith = (left, right) => {
-  if (compareIDs(right.origin, left.lastId) && left.right === right && compareIDs(left.rightOrigin, right.rightOrigin)) {
-    left.right = right.right
-    if (left.right !== null) {
-      left.right.left = left
-    }
-    return true
-  }
-  return false
-}
-
 /**
  * Split leftItem into two items
  * @param {Transaction} transaction
- * @param {AbstractItem} leftItem
+ * @param {Item} leftItem
  * @param {number} diff
- * @return {AbstractItem}
+ * @return {Item}
  *
  * @function
  * @private
@@ -56,14 +45,15 @@ export const mergeItemWith = (left, right) => {
 export const splitItem = (transaction, leftItem, diff) => {
   const id = leftItem.id
   // create rightItem
-  const rightItem = leftItem.copy(
+  const rightItem = new Item(
     createID(id.client, id.clock + diff),
     leftItem,
     createID(id.client, id.clock + diff - 1),
     leftItem.right,
     leftItem.rightOrigin,
     leftItem.parent,
-    leftItem.parentSub
+    leftItem.parentSub,
+    leftItem.content.splice(diff)
   )
   if (leftItem.deleted) {
     rightItem.deleted = true
@@ -80,24 +70,26 @@ export const splitItem = (transaction, leftItem, diff) => {
   if (rightItem.parentSub !== null && rightItem.right === null) {
     rightItem.parent._map.set(rightItem.parentSub, rightItem)
   }
+  leftItem.length = diff
   return rightItem
 }
 
 /**
  * Abstract class that represents any content.
  */
-export class AbstractItem extends AbstractStruct {
+export class Item extends AbstractStruct {
   /**
    * @param {ID} id
-   * @param {AbstractItem | null} left
+   * @param {Item | null} left
    * @param {ID | null} origin
-   * @param {AbstractItem | null} right
+   * @param {Item | null} right
    * @param {ID | null} rightOrigin
    * @param {AbstractType<any>} parent
    * @param {string | null} parentSub
+   * @param {AbstractContent} content
    */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub) {
-    super(id)
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, content) {
+    super(id, content.getLength())
     /**
      * The item that was originally to the left of this item.
      * @type {ID | null}
@@ -106,12 +98,12 @@ export class AbstractItem extends AbstractStruct {
     this.origin = origin
     /**
      * The item that is currently to the left of this item.
-     * @type {AbstractItem | null}
+     * @type {Item | null}
      */
     this.left = left
     /**
      * The item that is currently to the right of this item.
-     * @type {AbstractItem | null}
+     * @type {Item | null}
      */
     this.right = right
     /**
@@ -143,9 +135,12 @@ export class AbstractItem extends AbstractStruct {
     /**
      * If this type's effect is reundone this type refers to the type that undid
      * this operation.
-     * @type {AbstractItem | null}
+     * @type {Item | null}
      */
     this.redone = null
+    this.content = content
+    this.length = content.getLength()
+    this.countable = content.isCountable()
   }
 
   /**
@@ -159,7 +154,7 @@ export class AbstractItem extends AbstractStruct {
     const parentSub = this.parentSub
     const length = this.length
     /**
-     * @type {AbstractItem|null}
+     * @type {Item|null}
      */
     let o
     // set o to the first conflicting item
@@ -175,11 +170,11 @@ export class AbstractItem extends AbstractStruct {
     }
     // TODO: use something like DeleteSet here (a tree implementation would be best)
     /**
-     * @type {Set<AbstractItem>}
+     * @type {Set<Item>}
      */
     const conflictingItems = new Set()
     /**
-     * @type {Set<AbstractItem>}
+     * @type {Set<Item>}
      */
     const itemsBeforeOrigin = new Set()
     // Let c in conflictingItems, b in itemsBeforeOrigin
@@ -238,8 +233,8 @@ export class AbstractItem extends AbstractStruct {
       parent._length += length
     }
     addStruct(store, this)
+    this.content.integrate(transaction, this)
     maplib.setIfUndefined(transaction.changed, parent, set.create).add(parentSub)
-    // @ts-ignore
     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)
@@ -270,29 +265,11 @@ export class AbstractItem extends AbstractStruct {
     return n
   }
 
-  /**
-   * Creates an Item with the same effect as this Item (without position effect)
-   *
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @return {AbstractItem}
-   *
-   * @private
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    throw error.methodUnimplemented()
-  }
-
   /**
    * Redoes the effect of this operation.
    *
    * @param {Transaction} transaction The Yjs instance.
-   * @param {Set<AbstractItem>} redoitems
+   * @param {Set<Item>} redoitems
    *
    * @private
    */
@@ -343,7 +320,7 @@ export class AbstractItem extends AbstractStruct {
         right = right.right
       }
     }
-    this.redone = this.copy(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, this.parentSub)
+    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
   }
@@ -354,46 +331,31 @@ export class AbstractItem extends AbstractStruct {
   get lastId () {
     return createID(this.id.client, this.id.clock + this.length - 1)
   }
-
   /**
-   * Computes the length of this Item.
+   * Try to merge two items
+   *
+   * @param {Item} right
+   * @return {boolean}
    */
-  get length () {
-    return 1
-  }
-
-  /**
-   * Should return false if this Item is some kind of meta information
-   * (e.g. format information).
-   *
-   * * Whether this Item should be addressable via `yarray.get(i)`
-   * * Whether this Item should be counted when computing yarray.length
-   */
-  get countable () {
-    return true
-  }
-
-  /**
-   * Do not call directly. Always split via StructStore!
-   *
-   * Splits this Item so that another Item can be inserted in-between.
-   * This must be overwritten if _length > 1
-   * Returns right part after split
-   *
-   * (see {@link ItemJSON}/{@link ItemString} for implementation)
-   *
-   * Does not integrate the struct, nor store it in struct store.
-   *
-   * This method should only be cally by StructStore.
-   *
-   * @param {Transaction} transaction
-   * @param {number} diff
-   * @return {AbstractItem}
-   *
-   * @private
-   */
-  splitAt (transaction, diff) {
-    throw error.methodUnimplemented()
+  mergeWith (right) {
+    if (
+      compareIDs(right.origin, this.lastId) &&
+      this.right === right &&
+      compareIDs(this.rightOrigin, right.rightOrigin) &&
+      this.id.client === right.id.client &&
+      this.id.clock + this.length === right.id.clock &&
+      this.deleted === right.deleted &&
+      this.content.constructor === right.content.constructor &&
+      this.content.mergeWith(right.content)
+    ) {
+      this.right = right.right
+      if (this.right !== null) {
+        this.right.left = this
+      }
+      this.length += right.length
+      return true
+    }
+    return false
   }
 
   /**
@@ -411,16 +373,10 @@ export class AbstractItem extends AbstractStruct {
       this.deleted = true
       addToDeleteSet(transaction.deleteSet, this.id, this.length)
       maplib.setIfUndefined(transaction.changed, parent, set.create).add(this.parentSub)
+      this.content.delete(transaction)
     }
   }
 
-  /**
-   * @param {StructStore} store
-   *
-   * @private
-   */
-  gcChildren (store) { }
-
   /**
    * @param {StructStore} store
    * @param {boolean} parentGCd
@@ -431,30 +387,12 @@ export class AbstractItem extends AbstractStruct {
     if (!this.deleted) {
       throw error.unexpectedCase()
     }
-    let r
+    this.content.gc(store)
     if (parentGCd) {
-      r = new GC(this.id, this.length)
+      replaceStruct(store, this, new GC(this.id, this.length))
     } else {
-      r = new ItemDeleted(this.id, this.left, this.origin, this.right, this.rightOrigin, this.parent, this.parentSub, this.length)
-      if (r.right !== null) {
-        r.right.left = r
-      } else if (r.parentSub !== null) {
-        r.parent._map.set(r.parentSub, r)
-      }
-      if (r.left !== null) {
-        r.left.right = r
-      } else if (r.parentSub === null) {
-        r.parent._start = r
-      }
+      this.content = new ContentDeleted(this.length)
     }
-    replaceStruct(store, this, r)
-  }
-
-  /**
-   * @return {Array<any>}
-   */
-  getContent () {
-    throw error.methodUnimplemented()
   }
 
   /**
@@ -465,15 +403,14 @@ export class AbstractItem extends AbstractStruct {
    *
    * @param {encoding.Encoder} encoder The encoder to write data to.
    * @param {number} offset
-   * @param {number} encodingRef
    *
    * @private
    */
-  write (encoder, offset, encodingRef) {
+  write (encoder, offset) {
     const origin = offset > 0 ? createID(this.id.client, this.id.clock + offset - 1) : this.origin
     const rightOrigin = this.rightOrigin
     const parentSub = this.parentSub
-    const info = (encodingRef & binary.BITS5) |
+    const info = (this.content.getRef() & binary.BITS5) |
       (origin === null ? 0 : binary.BIT8) | // origin is defined
       (rightOrigin === null ? 0 : binary.BIT7) | // right origin is defined
       (parentSub === null ? 0 : binary.BIT6) // parentSub is non-null
@@ -489,26 +426,129 @@ export class AbstractItem extends AbstractStruct {
       if (parent._item === null) {
         // parent type on y._map
         // find the correct key
-        // @ts-ignore we know that y exists
         const ykey = findRootTypeKey(parent)
         encoding.writeVarUint(encoder, 1) // write parentYKey
         encoding.writeVarString(encoder, ykey)
       } else {
         encoding.writeVarUint(encoder, 0) // write parent id
-        // @ts-ignore _item is defined because parent is integrated
         writeID(encoder, parent._item.id)
       }
       if (parentSub !== null) {
         encoding.writeVarString(encoder, parentSub)
       }
     }
+    this.content.write(encoder, offset)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @param {number} info
+ */
+const readItemContent = (decoder, info) => contentRefs[info & binary.BITS5](decoder)
+
+/**
+ * A lookup map for reading Item content.
+ *
+ * @type {Array<function(decoding.Decoder):AbstractContent>}
+ */
+export const contentRefs = [
+  () => { throw error.unexpectedCase() }, // GC is not ItemContent
+  readContentDeleted,
+  readContentJSON,
+  readContentBinary,
+  readContentString,
+  readContentEmbed,
+  readContentFormat,
+  readContentType
+]
+
+/**
+ * Do not implement this class!
+ */
+export class AbstractContent {
+  /**
+   * @return {number}
+   */
+  getLength () {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * Should return false if this Item is some kind of meta information
+   * (e.g. format information).
+   *
+   * * Whether this Item should be addressable via `yarray.get(i)`
+   * * Whether this Item should be counted when computing yarray.length
+   *
+   * @return {boolean}
+   */
+  isCountable () {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @return {AbstractContent}
+   */
+  copy () {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {number} offset
+   * @return {AbstractContent}
+   */
+  splice (offset) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {AbstractContent} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {Item} item
+   */
+  integrate (transaction, item) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {StructStore} store
+   */
+  gc (store) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @return {number}
+   */
+  getRef () {
+    throw error.methodUnimplemented()
   }
 }
 
 /**
  * @private
  */
-export class AbstractItemRef extends AbstractStructRef {
+export class ItemRef extends AbstractStructRef {
   /**
    * @param {decoding.Decoder} decoder
    * @param {ID} id
@@ -558,85 +598,69 @@ export class AbstractItemRef extends AbstractStructRef {
     if (this.parent !== null) {
       missing.push(this.parent)
     }
+    /**
+     * @type {AbstractContent}
+     */
+    this.content = readItemContent(decoder, info)
+    this.length = this.content.getLength()
   }
-}
-
-/**
- * @param {AbstractItemRef} item
- * @param {number} offset
- *
- * @function
- * @private
- */
-export const changeItemRefOffset = (item, offset) => {
-  item.id = createID(item.id.client, item.id.clock + offset)
-  item.left = createID(item.id.client, item.id.clock - 1)
-}
-
-export class ItemParams {
   /**
-   * @param {AbstractItem?} left
-   * @param {AbstractItem?} right
-   * @param {AbstractType<YEvent>?} parent
-   * @param {string|null} parentSub
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {Item|GC}
    */
-  constructor (left, right, parent, parentSub) {
-    this.left = left
-    this.right = right
-    this.parent = parent
-    this.parentSub = parentSub
-  }
-}
+  toStruct (transaction, store, offset) {
+    if (offset > 0) {
+      /**
+       * @type {ID}
+       */
+      const id = this.id
+      this.id = createID(id.client, id.clock + offset)
+      this.left = createID(this.id.client, this.id.clock - 1)
+      this.content = this.content.splice(offset)
+    }
 
-/**
- * Outsourcing some of the logic of computing the item params from a received struct.
- * If parent === null, it is expected to gc the read struct. Otherwise apply it.
- *
- * @param {Transaction} transaction
- * @param {StructStore} store
- * @param {ID|null} leftid
- * @param {ID|null} rightid
- * @param {ID|null} parentid
- * @param {string|null} parentSub
- * @param {string|null} parentYKey
- * @return {ItemParams}
- *
- * @private
- * @function
- */
-export const computeItemParams = (transaction, store, leftid, rightid, parentid, parentSub, parentYKey) => {
-  const left = leftid === null ? null : getItemCleanEnd(transaction, store, leftid)
-  const right = rightid === null ? null : getItemCleanStart(transaction, store, rightid)
-  let parent = null
-  if (parentid !== null) {
-    const parentItem = getItemType(store, parentid)
-    switch (parentItem.constructor) {
-      case ItemDeleted:
-      case GC:
-        break
-      default:
-        // Edge case: toStruct is called with an offset > 0. In this case left is defined.
-        // Depending in which order structs arrive, left may be GC'd and the parent not
-        // deleted. This is why we check if left is GC'd. Strictly we probably don't have
-        // to check if right is GC'd, but we will in case we run into future issues
-        if (!parentItem.deleted && (left === null || left.constructor !== GC) && (right === null || right.constructor !== GC)) {
-          parent = parentItem.type
-        }
+    const left = this.left === null ? null : getItemCleanEnd(transaction, store, this.left)
+    const right = this.right === null ? null : getItemCleanStart(transaction, store, this.right)
+    let parent = null
+    let parentSub = this.parentSub
+    if (this.parent !== null) {
+      const parentItem = getItem(store, this.parent)
+      // Edge case: toStruct is called with an offset > 0. In this case left is defined.
+      // Depending in which order structs arrive, left may be GC'd and the parent not
+      // deleted. This is why we check if left is GC'd. Strictly we don't have
+      // to check if right is GC'd, but we will in case we run into future issues
+      if (!parentItem.deleted && (left === null || left.constructor !== GC) && (right === null || right.constructor !== GC)) {
+        parent = /** @type {ContentType} */ (parentItem.content).type
+      }
+    } else if (this.parentYKey !== null) {
+      parent = transaction.doc.get(this.parentYKey)
+    } else if (left !== null) {
+      if (left.constructor !== GC) {
+        parent = left.parent
+        parentSub = left.parentSub
+      }
+    } else if (right !== null) {
+      if (right.constructor !== GC) {
+        parent = right.parent
+        parentSub = right.parentSub
+      }
+    } else {
+      throw error.unexpectedCase()
     }
-  } else if (parentYKey !== null) {
-    parent = transaction.doc.get(parentYKey)
-  } else if (left !== null) {
-    if (left.constructor !== GC) {
-      parent = left.parent
-      parentSub = left.parentSub
-    }
-  } else if (right !== null) {
-    if (right.constructor !== GC) {
-      parent = right.parent
-      parentSub = right.parentSub
-    }
-  } else {
-    throw error.unexpectedCase()
+
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new Item(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.content
+      )
   }
-  return new ItemParams(left, right, parent, parentSub)
 }

src/structs/ItemBinary.js

@@ -1,99 +0,0 @@
-
-import {
-  AbstractItem,
-  AbstractItemRef,
-  computeItemParams,
-  GC,
-  StructStore, Transaction, AbstractType, ID // eslint-disable-line
-} from '../internals.js'
-
-import * as encoding from 'lib0/encoding.js'
-import * as decoding from 'lib0/decoding.js'
-import * as buffer from 'lib0/buffer.js'
-
-/**
- * @private
- */
-export const structBinaryRefNumber = 1
-
-/**
- * @private
- */
-export class ItemBinary extends AbstractItem {
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @param {Uint8Array} content
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, content) {
-    super(id, left, origin, right, rightOrigin, parent, parentSub)
-    this.content = content
-  }
-  getContent () {
-    return [this.content]
-  }
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    return new ItemBinary(id, left, origin, right, rightOrigin, parent, parentSub, this.content)
-  }
-  /**
-   * @param {encoding.Encoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    super.write(encoder, offset, structBinaryRefNumber)
-    encoding.writeVarUint8Array(encoder, this.content)
-  }
-}
-
-/**
- * @private
- */
-export class ItemBinaryRef extends AbstractItemRef {
-  /**
-   * @param {decoding.Decoder} decoder
-   * @param {ID} id
-   * @param {number} info
-   */
-  constructor (decoder, id, info) {
-    super(decoder, id, info)
-    /**
-     * @type {Uint8Array}
-     */
-    this.content = buffer.copyUint8Array(decoding.readVarUint8Array(decoder))
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @param {number} offset
-   * @return {ItemBinary|GC}
-   */
-  toStruct (transaction, store, offset) {
-    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
-    return parent === null
-      ? new GC(this.id, this.length)
-      : new ItemBinary(
-        this.id,
-        left,
-        this.left,
-        right,
-        this.right,
-        parent,
-        parentSub,
-        this.content
-      )
-  }
-}

src/structs/ItemDeleted.js

@@ -1,155 +0,0 @@
-
-import {
-  AbstractItem,
-  AbstractItemRef,
-  computeItemParams,
-  changeItemRefOffset,
-  GC,
-  splitItem,
-  addToDeleteSet,
-  mergeItemWith,
-  StructStore, Transaction, ID, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as encoding from 'lib0/encoding.js'
-import * as decoding from 'lib0/decoding.js'
-
-/**
- * @private
- */
-export const structDeletedRefNumber = 2
-
-/**
- * @private
- */
-export class ItemDeleted extends AbstractItem {
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @param {number} length
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, length) {
-    super(id, left, origin, right, rightOrigin, parent, parentSub)
-    this._len = length
-    this.deleted = true
-  }
-  get length () {
-    return this._len
-  }
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    return new ItemDeleted(id, left, origin, right, rightOrigin, parent, parentSub, this.length)
-  }
-  /**
-   * @param {Transaction} transaction
-   */
-  integrate (transaction) {
-    super.integrate(transaction)
-    addToDeleteSet(transaction.deleteSet, this.id, this.length)
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {number} diff
-   */
-  splitAt (transaction, diff) {
-    /**
-     * @type {ItemDeleted}
-     */
-    // @ts-ignore
-    const right = splitItem(transaction, this, diff)
-    right._len -= diff
-    this._len = diff
-    return right
-  }
-  /**
-   * @param {ItemDeleted} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    if (mergeItemWith(this, right)) {
-      this._len += right._len
-      return true
-    }
-    return false
-  }
-
-  /**
-   * @param {StructStore} store
-   * @param {boolean} parentGCd
-   *
-   * @private
-   */
-  gc (store, parentGCd) {
-    if (parentGCd) {
-      super.gc(store, parentGCd)
-    }
-  }
-  /**
-   * @param {encoding.Encoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    super.write(encoder, offset, structDeletedRefNumber)
-    encoding.writeVarUint(encoder, this.length - offset)
-  }
-}
-
-/**
- * @private
- */
-export class ItemDeletedRef extends AbstractItemRef {
-  /**
-   * @param {decoding.Decoder} decoder
-   * @param {ID} id
-   * @param {number} info
-   */
-  constructor (decoder, id, info) {
-    super(decoder, id, info)
-    /**
-     * @type {number}
-     */
-    this.len = decoding.readVarUint(decoder)
-  }
-  get length () {
-    return this.len
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @param {number} offset
-   * @return {ItemDeleted|GC}
-   */
-  toStruct (transaction, store, offset) {
-    if (offset > 0) {
-      changeItemRefOffset(this, offset)
-      this.len = this.len - offset
-    }
-
-    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
-    return parent === null
-      ? new GC(this.id, this.length)
-      : new ItemDeleted(
-        this.id,
-        left,
-        this.left,
-        right,
-        this.right,
-        parent,
-        parentSub,
-        this.len
-      )
-  }
-}

src/structs/ItemEmbed.js

@@ -1,95 +0,0 @@
-
-import {
-  AbstractItem,
-  AbstractItemRef,
-  computeItemParams,
-  GC,
-  Transaction, StructStore, ID, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as encoding from 'lib0/encoding.js'
-import * as decoding from 'lib0/decoding.js'
-
-/**
- * @private
- */
-export const structEmbedRefNumber = 3
-
-/**
- * @private
- */
-export class ItemEmbed extends AbstractItem {
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @param {Object} embed
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, embed) {
-    super(id, left, origin, right, rightOrigin, parent, parentSub)
-    this.embed = embed
-  }
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    return new ItemEmbed(id, left, origin, right, rightOrigin, parent, parentSub, this.embed)
-  }
-  /**
-   * @param {encoding.Encoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    super.write(encoder, offset, structEmbedRefNumber)
-    encoding.writeVarString(encoder, JSON.stringify(this.embed))
-  }
-}
-
-/**
- * @private
- */
-export class ItemEmbedRef extends AbstractItemRef {
-  /**
-   * @param {decoding.Decoder} decoder
-   * @param {ID} id
-   * @param {number} info
-   */
-  constructor (decoder, id, info) {
-    super(decoder, id, info)
-    /**
-     * @type {Object}
-     */
-    this.embed = JSON.parse(decoding.readVarString(decoder))
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @param {number} offset
-   * @return {ItemEmbed|GC}
-   */
-  toStruct (transaction, store, offset) {
-    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
-    return parent === null
-      ? new GC(this.id, this.length)
-      : new ItemEmbed(
-        this.id,
-        left,
-        this.left,
-        right,
-        this.right,
-        parent,
-        parentSub,
-        this.embed
-      )
-  }
-}

src/structs/ItemFormat.js

@@ -1,103 +0,0 @@
-
-import {
-  AbstractItem,
-  AbstractItemRef,
-  computeItemParams,
-  GC,
-  Transaction, StructStore, ID, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as encoding from 'lib0/encoding.js'
-import * as decoding from 'lib0/decoding.js'
-
-/**
- * @private
- */
-export const structFormatRefNumber = 4
-
-/**
- * @private
- */
-export class ItemFormat extends AbstractItem {
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @param {string} key
-   * @param {any} value
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, key, value) {
-    super(id, left, origin, right, rightOrigin, parent, parentSub)
-    this.key = key
-    this.value = value
-  }
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    return new ItemFormat(id, left, origin, right, rightOrigin, parent, parentSub, this.key, this.value)
-  }
-  get countable () {
-    return false
-  }
-  /**
-   * @param {encoding.Encoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    super.write(encoder, offset, structFormatRefNumber)
-    encoding.writeVarString(encoder, this.key)
-    encoding.writeVarString(encoder, JSON.stringify(this.value))
-  }
-}
-
-/**
- * @private
- */
-export class ItemFormatRef extends AbstractItemRef {
-  /**
-   * @param {decoding.Decoder} decoder
-   * @param {ID} id
-   * @param {number} info
-   */
-  constructor (decoder, id, info) {
-    super(decoder, id, info)
-    /**
-     * @type {string}
-     */
-    this.key = decoding.readVarString(decoder)
-    this.value = JSON.parse(decoding.readVarString(decoder))
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @param {number} offset
-   * @return {ItemFormat|GC}
-   */
-  toStruct (transaction, store, offset) {
-    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
-    return parent === null
-      ? new GC(this.id, this.length)
-      : new ItemFormat(
-        this.id,
-        left,
-        this.left,
-        right,
-        this.right,
-        parent,
-        parentSub,
-        this.key,
-        this.value
-      )
-  }
-}

src/structs/ItemJSON.js

@@ -1,153 +0,0 @@
-
-import {
-  AbstractItem,
-  AbstractItemRef,
-  computeItemParams,
-  splitItem,
-  changeItemRefOffset,
-  GC,
-  mergeItemWith,
-  Transaction, StructStore, ID, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as encoding from 'lib0/encoding.js'
-import * as decoding from 'lib0/decoding.js'
-
-/**
- * @private
- */
-export const structJSONRefNumber = 5
-
-/**
- * @private
- */
-export class ItemJSON extends AbstractItem {
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @param {Array<any>} content
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, content) {
-    super(id, left, origin, right, rightOrigin, parent, parentSub)
-    /**
-     * @type {Array<any>}
-     */
-    this.content = content
-  }
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    return new ItemJSON(id, left, origin, right, rightOrigin, parent, parentSub, this.content)
-  }
-  get length () {
-    return this.content.length
-  }
-  getContent () {
-    return this.content
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {number} diff
-   */
-  splitAt (transaction, diff) {
-    /**
-     * @type {ItemJSON}
-     */
-    // @ts-ignore
-    const right = splitItem(transaction, this, diff)
-    right.content = this.content.splice(diff)
-    return right
-  }
-  /**
-   * @param {ItemJSON} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    if (mergeItemWith(this, right)) {
-      this.content = this.content.concat(right.content)
-      return true
-    }
-    return false
-  }
-  /**
-   * @param {encoding.Encoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    super.write(encoder, offset, structJSONRefNumber)
-    const len = this.content.length
-    encoding.writeVarUint(encoder, len - offset)
-    for (let i = offset; i < len; i++) {
-      const c = this.content[i]
-      encoding.writeVarString(encoder, c === undefined ? 'undefined' : JSON.stringify(c))
-    }
-  }
-}
-
-/**
- * @private
- */
-export class ItemJSONRef extends AbstractItemRef {
-  /**
-   * @param {decoding.Decoder} decoder
-   * @param {ID} id
-   * @param {number} info
-   */
-  constructor (decoder, id, info) {
-    super(decoder, id, info)
-    const len = decoding.readVarUint(decoder)
-    const cs = []
-    for (let i = 0; i < len; i++) {
-      const c = decoding.readVarString(decoder)
-      if (c === 'undefined') {
-        cs.push(undefined)
-      } else {
-        cs.push(JSON.parse(c))
-      }
-    }
-    /**
-     * @type {Array<any>}
-     */
-    this.content = cs
-  }
-  get length () {
-    return this.content.length
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @param {number} offset
-   * @return {ItemJSON|GC}
-   */
-  toStruct (transaction, store, offset) {
-    if (offset > 0) {
-      changeItemRefOffset(this, offset)
-      this.content = this.content.slice(offset)
-    }
-    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
-    return parent === null
-      ? new GC(this.id, this.length)
-      : new ItemJSON(
-        this.id,
-        left,
-        this.left,
-        right,
-        this.right,
-        parent,
-        parentSub,
-        this.content
-      )
-  }
-}

src/structs/ItemString.js

@@ -1,138 +0,0 @@
-
-import {
-  AbstractItem,
-  AbstractItemRef,
-  computeItemParams,
-  splitItem,
-  changeItemRefOffset,
-  GC,
-  mergeItemWith,
-  Transaction, StructStore, ID, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as encoding from 'lib0/encoding.js'
-import * as decoding from 'lib0/decoding.js'
-
-export const structStringRefNumber = 6
-
-/**
- * @private
- */
-export class ItemString extends AbstractItem {
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @param {string} string
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, string) {
-    super(id, left, origin, right, rightOrigin, parent, parentSub)
-    /**
-     * @type {string}
-     */
-    this.string = string
-  }
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    return new ItemString(id, left, origin, right, rightOrigin, parent, parentSub, this.string)
-  }
-  getContent () {
-    return this.string.split('')
-  }
-  get length () {
-    return this.string.length
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {number} diff
-   * @return {ItemString}
-   */
-  splitAt (transaction, diff) {
-    /**
-     * @type {ItemString}
-     */
-    // @ts-ignore
-    const right = splitItem(transaction, this, diff)
-    right.string = this.string.slice(diff)
-    this.string = this.string.slice(0, diff)
-    return right
-  }
-  /**
-   * @param {ItemString} right
-   * @return {boolean}
-   */
-  mergeWith (right) {
-    if (mergeItemWith(this, right)) {
-      this.string += right.string
-      return true
-    }
-    return false
-  }
-  /**
-   * @param {encoding.Encoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    super.write(encoder, offset, structStringRefNumber)
-    encoding.writeVarString(encoder, offset === 0 ? this.string : this.string.slice(offset))
-  }
-}
-
-/**
- * @private
- */
-export class ItemStringRef extends AbstractItemRef {
-  /**
-   * @param {decoding.Decoder} decoder
-   * @param {ID} id
-   * @param {number} info
-   */
-  constructor (decoder, id, info) {
-    super(decoder, id, info)
-    /**
-     * @type {string}
-     */
-    this.string = decoding.readVarString(decoder)
-  }
-  get length () {
-    return this.string.length
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @param {number} offset
-   * @return {ItemString|GC}
-   */
-  toStruct (transaction, store, offset) {
-    if (offset > 0) {
-      changeItemRefOffset(this, offset)
-      this.string = this.string.slice(offset)
-    }
-
-    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
-    return parent === null
-      ? new GC(this.id, this.length)
-      : new ItemString(
-        this.id,
-        left,
-        this.left,
-        right,
-        this.right,
-        parent,
-        parentSub,
-        this.string
-      )
-  }
-}

src/structs/ItemType.js

@@ -1,199 +0,0 @@
-
-import {
-  AbstractItem,
-  AbstractItemRef,
-  computeItemParams,
-  readYArray,
-  readYMap,
-  readYText,
-  readYXmlElement,
-  readYXmlFragment,
-  readYXmlHook,
-  readYXmlText,
-  StructStore, GC, Transaction, ID, AbstractType // eslint-disable-line
-} from '../internals.js'
-
-import * as encoding from 'lib0/encoding.js' // eslint-disable-line
-import * as decoding from 'lib0/decoding.js'
-
-/**
- * @private
- */
-export const structTypeRefNumber = 7
-
-/**
- * @type {Array<function(decoding.Decoder):AbstractType<any>>}
- * @private
- */
-export const typeRefs = [
-  readYArray,
-  readYMap,
-  readYText,
-  readYXmlElement,
-  readYXmlFragment,
-  readYXmlHook,
-  readYXmlText
-]
-
-export const YArrayRefID = 0
-export const YMapRefID = 1
-export const YTextRefID = 2
-export const YXmlElementRefID = 3
-export const YXmlFragmentRefID = 4
-export const YXmlHookRefID = 5
-export const YXmlTextRefID = 6
-
-/**
- * @private
- */
-export class ItemType extends AbstractItem {
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @param {AbstractType<any>} type
-   */
-  constructor (id, left, origin, right, rightOrigin, parent, parentSub, type) {
-    super(id, left, origin, right, rightOrigin, parent, parentSub)
-    this.type = type
-  }
-
-  getContent () {
-    return [this.type]
-  }
-  /**
-   * @param {ID} id
-   * @param {AbstractItem | null} left
-   * @param {ID | null} origin
-   * @param {AbstractItem | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>} parent
-   * @param {string | null} parentSub
-   * @return {ItemType}
-   */
-  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
-    return new ItemType(id, left, origin, right, rightOrigin, parent, parentSub, this.type._copy())
-  }
-  /**
-   * @param {Transaction} transaction
-   */
-  integrate (transaction) {
-    super.integrate(transaction)
-    this.type._integrate(transaction.doc, this)
-  }
-  /**
-   * @param {encoding.Encoder} encoder
-   * @param {number} offset
-   */
-  write (encoder, offset) {
-    super.write(encoder, offset, structTypeRefNumber)
-    this.type._write(encoder)
-  }
-  /**
-   * Mark this Item as deleted.
-   *
-   * @param {Transaction} transaction The Yjs instance
-   * @private
-   */
-  delete (transaction) {
-    if (!this.deleted) {
-      super.delete(transaction)
-      let item = this.type._start
-      while (item !== null) {
-        if (!item.deleted) {
-          item.delete(transaction)
-        } else {
-          // Whis will be gc'd later and we want to merge it if possible
-          // We try to merge all deleted items after each transaction,
-          // but we have no knowledge about that this needs to be merged
-          // since it is not in transaction.ds. Hence we add it to transaction._mergeStructs
-          transaction._mergeStructs.add(item.id)
-        }
-        item = item.right
-      }
-      this.type._map.forEach(item => {
-        if (!item.deleted) {
-          item.delete(transaction)
-        } else {
-          // same as above
-          transaction._mergeStructs.add(item.id)
-        }
-      })
-      transaction.changed.delete(this.type)
-      transaction.changedParentTypes.delete(this.type)
-    }
-  }
-
-  /**
-   * @param {StructStore} store
-   */
-  gcChildren (store) {
-    let item = this.type._start
-    while (item !== null) {
-      item.gc(store, true)
-      item = item.right
-    }
-    this.type._start = null
-    this.type._map.forEach(item => {
-      while (item !== null) {
-        item.gc(store, true)
-        // @ts-ignore
-        item = item.left
-      }
-    })
-    this._map = new Map()
-  }
-
-  /**
-   * @param {StructStore} store
-   * @param {boolean} parentGCd
-   */
-  gc (store, parentGCd) {
-    this.gcChildren(store)
-    super.gc(store, parentGCd)
-  }
-}
-
-/**
- * @private
- */
-export class ItemTypeRef extends AbstractItemRef {
-  /**
-   * @param {decoding.Decoder} decoder
-   * @param {ID} id
-   * @param {number} info
-   */
-  constructor (decoder, id, info) {
-    super(decoder, id, info)
-    const typeRef = decoding.readVarUint(decoder)
-    /**
-     * @type {AbstractType<any>}
-     */
-    this.type = typeRefs[typeRef](decoder)
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @param {number} offset
-   * @return {ItemType|GC}
-   */
-  toStruct (transaction, store, offset) {
-    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
-    return parent === null
-      ? new GC(this.id, this.length)
-      : new ItemType(
-        this.id,
-        left,
-        this.left,
-        right,
-        this.right,
-        parent,
-        parentSub,
-        this.type
-      )
-  }
-}