@y/y 14.0.0-16

package/src/structs/ContentJSON.js

@@ -0,0 +1,119 @@
+import {
+  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Transaction, Item, StructStore // eslint-disable-line
+} from '../internals.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 {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} offset
+   * @param {number} offsetEnd
+   */
+  write (encoder, offset, offsetEnd) {
+    const end = this.arr.length - offsetEnd
+    encoder.writeLen(end - offset)
+    for (let i = offset; i < end; i++) {
+      const c = this.arr[i]
+      encoder.writeString(c === undefined ? 'undefined' : JSON.stringify(c))
+    }
+  }
+
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 2
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @return {ContentJSON}
+ */
+export const readContentJSON = decoder => {
+  const len = decoder.readLen()
+  const cs = []
+  for (let i = 0; i < len; i++) {
+    const c = decoder.readString()
+    if (c === 'undefined') {
+      cs.push(undefined)
+    } else {
+      cs.push(JSON.parse(c))
+    }
+  }
+  return new ContentJSON(cs)
+}

package/src/structs/ContentString.js

@@ -0,0 +1,113 @@
+import {
+  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Transaction, Item, StructStore // eslint-disable-line
+} from '../internals.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)
+
+    // Prevent encoding invalid documents because of splitting of surrogate pairs: https://github.com/yjs/yjs/issues/248
+    const firstCharCode = this.str.charCodeAt(offset - 1)
+    if (firstCharCode >= 0xD800 && firstCharCode <= 0xDBFF) {
+      // Last character of the left split is the start of a surrogate utf16/ucs2 pair.
+      // We don't support splitting of surrogate pairs because this may lead to invalid documents.
+      // Replace the invalid character with a unicode replacement character (� / U+FFFD)
+      this.str = this.str.slice(0, offset - 1) + '�'
+      // replace right as well
+      right.str = '�' + right.str.slice(1)
+    }
+    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 {Transaction} _tr
+   */
+  gc (_tr) {}
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} offset
+   * @param {number} offsetEnd
+   */
+  write (encoder, offset, offsetEnd) {
+    encoder.writeString((offset === 0 && offsetEnd === 0) ? this.str : this.str.slice(offset, this.str.length - offsetEnd))
+  }
+
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 4
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @return {ContentString}
+ */
+export const readContentString = decoder => new ContentString(decoder.readString())

package/src/structs/ContentType.js

@@ -0,0 +1,176 @@
+import {
+  readYArray,
+  readYMap,
+  readYText,
+  readYXmlElement,
+  readYXmlFragment,
+  readYXmlHook,
+  readYXmlText,
+  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Transaction, Item // eslint-disable-line
+} from '../internals.js'
+
+/**
+ * @typedef {import('../utils/types.js').YType} YType_CT
+ */
+
+import * as error from 'lib0/error'
+
+/**
+ * @type {Array<(decoder: UpdateDecoderV1 | UpdateDecoderV2)=>(import('../utils/types.js').YType)>}
+ * @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 {YType_CT} type
+   */
+  constructor (type) {
+    /**
+     * @type {YType_CT}
+     */
+    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 if (!transaction.insertSet.hasId(item.id)) {
+        // This 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.push(item)
+      }
+      item = item.right
+    }
+    this.type._map.forEach(item => {
+      if (!item.deleted) {
+        item.delete(transaction)
+      } else if (!transaction.insertSet.hasId(item.id)) {
+        // same as above
+        transaction._mergeStructs.push(item)
+      }
+    })
+    transaction.changed.delete(this.type)
+  }
+
+  /**
+   * @param {Transaction} tr
+   */
+  gc (tr) {
+    let item = this.type._start
+    while (item !== null) {
+      item.gc(tr, true)
+      item = item.right
+    }
+    this.type._start = null
+    this.type._map.forEach(/** @param {Item | null} item */ (item) => {
+      while (item !== null) {
+        item.gc(tr, true)
+        item = item.left
+      }
+    })
+    this.type._map = new Map()
+  }
+
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} _offset
+   * @param {number} _offsetEnd
+   */
+  write (encoder, _offset, _offsetEnd) {
+    this.type._write(encoder)
+  }
+
+  /**
+   * @return {number}
+   */
+  getRef () {
+    return 7
+  }
+}
+
+/**
+ * @private
+ *
+ * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @return {ContentType}
+ */
+export const readContentType = decoder => new ContentType(typeRefs[decoder.readTypeRef()](decoder))

package/src/structs/GC.js

@@ -0,0 +1,80 @@
+import {
+  AbstractStruct,
+  addStruct,
+  addStructToIdSet,
+  addToIdSet,
+  createID,
+  UpdateEncoderV1, UpdateEncoderV2, StructStore, Transaction // eslint-disable-line
+} from '../internals.js'
+
+export const structGCRefNumber = 0
+
+/**
+ * @private
+ */
+export class GC extends AbstractStruct {
+  get deleted () {
+    return true
+  }
+
+  delete () {}
+
+  /**
+   * @param {GC} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    if (this.constructor !== right.constructor) {
+      return false
+    }
+    this.length += right.length
+    return true
+  }
+
+  /**
+   * @param {Transaction} transaction
+   * @param {number} offset - @todo remove offset parameter
+   */
+  integrate (transaction, offset) {
+    if (offset > 0) {
+      this.id.clock += offset
+      this.length -= offset
+    }
+    addToIdSet(transaction.deleteSet, this.id.client, this.id.clock, this.length)
+    addStructToIdSet(transaction.insertSet, this)
+    addStruct(transaction.doc.store, this)
+  }
+
+  /**
+   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {number} offset
+   * @param {number} offsetEnd
+   */
+  write (encoder, offset, offsetEnd) {
+    encoder.writeInfo(structGCRefNumber)
+    encoder.writeLen(this.length - offset - offsetEnd)
+  }
+
+  /**
+   * @param {Transaction} _transaction
+   * @param {StructStore} _store
+   * @return {null | number}
+   */
+  getMissing (_transaction, _store) {
+    return null
+  }
+
+  /**
+   * gc structs can't be spliced.
+   *
+   * If this feature is required in the future, then need to try to merge this struct after
+   * transaction.
+   *
+   * @param {number} diff
+   */
+  splice (diff) {
+    const other = new GC(createID(this.id.client, this.id.clock + diff), this.length - diff)
+    this.length = diff
+    return other
+  }
+}