@y/y 14.0.0-18 → 14.0.0-20

package/src/structs/ContentType.js

@@ -0,0 +1,152 @@
+import {
+  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Transaction, Item // eslint-disable-line
+} from '../internals.js'
+
+import * as error from 'lib0/error'
+import { readYType } from '../ytype.js'
+
+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 {import('../ytype.js').YType} type
+   */
+  constructor (type) {
+    /**
+     * @type {import('../ytype.js').YType}
+     */
+    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(readYType(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
+  }
+}