@y/y 14.0.0-18 → 14.0.0-20

package/src/utils/UpdateEncoder.js

@@ -0,0 +1,327 @@
+import * as error from 'lib0/error'
+import * as encoding from 'lib0/encoding'
+
+import {
+  ID // eslint-disable-line
+} from '../internals.js'
+
+export class IdSetEncoderV1 {
+  constructor () {
+    this.restEncoder = encoding.createEncoder()
+  }
+
+  toUint8Array () {
+    return encoding.toUint8Array(this.restEncoder)
+  }
+
+  resetIdSetCurVal () {
+    // nop
+  }
+
+  /**
+   * @param {number} clock
+   */
+  writeIdSetClock (clock) {
+    encoding.writeVarUint(this.restEncoder, clock)
+  }
+
+  /**
+   * @param {number} len
+   */
+  writeIdSetLen (len) {
+    encoding.writeVarUint(this.restEncoder, len)
+  }
+}
+
+export class UpdateEncoderV1 extends IdSetEncoderV1 {
+  /**
+   * @param {ID} id
+   */
+  writeLeftID (id) {
+    encoding.writeVarUint(this.restEncoder, id.client)
+    encoding.writeVarUint(this.restEncoder, id.clock)
+  }
+
+  /**
+   * @param {ID} id
+   */
+  writeRightID (id) {
+    encoding.writeVarUint(this.restEncoder, id.client)
+    encoding.writeVarUint(this.restEncoder, id.clock)
+  }
+
+  /**
+   * Use writeClient and writeClock instead of writeID if possible.
+   * @param {number} client
+   */
+  writeClient (client) {
+    encoding.writeVarUint(this.restEncoder, client)
+  }
+
+  /**
+   * @param {number} info An unsigned 8-bit integer
+   */
+  writeInfo (info) {
+    encoding.writeUint8(this.restEncoder, info)
+  }
+
+  /**
+   * @param {string} s
+   */
+  writeString (s) {
+    encoding.writeVarString(this.restEncoder, s)
+  }
+
+  /**
+   * @param {boolean} isYKey
+   */
+  writeParentInfo (isYKey) {
+    encoding.writeVarUint(this.restEncoder, isYKey ? 1 : 0)
+  }
+
+  /**
+   * @param {number} info An unsigned 8-bit integer
+   */
+  writeTypeRef (info) {
+    encoding.writeVarUint(this.restEncoder, info)
+  }
+
+  /**
+   * Write len of a struct - well suited for Opt RLE encoder.
+   *
+   * @param {number} len
+   */
+  writeLen (len) {
+    encoding.writeVarUint(this.restEncoder, len)
+  }
+
+  /**
+   * @param {any} any
+   */
+  writeAny (any) {
+    encoding.writeAny(this.restEncoder, any)
+  }
+
+  /**
+   * @param {Uint8Array} buf
+   */
+  writeBuf (buf) {
+    encoding.writeVarUint8Array(this.restEncoder, buf)
+  }
+
+  /**
+   * @param {any} embed
+   */
+  writeJSON (embed) {
+    encoding.writeVarString(this.restEncoder, JSON.stringify(embed))
+  }
+
+  /**
+   * @param {string} key
+   */
+  writeKey (key) {
+    encoding.writeVarString(this.restEncoder, key)
+  }
+}
+
+export class IdSetEncoderV2 {
+  constructor () {
+    this.restEncoder = encoding.createEncoder() // encodes all the rest / non-optimized
+    this.dsCurrVal = 0
+  }
+
+  toUint8Array () {
+    return encoding.toUint8Array(this.restEncoder)
+  }
+
+  resetIdSetCurVal () {
+    this.dsCurrVal = 0
+  }
+
+  /**
+   * @param {number} clock
+   */
+  writeIdSetClock (clock) {
+    const diff = clock - this.dsCurrVal
+    this.dsCurrVal = clock
+    encoding.writeVarUint(this.restEncoder, diff)
+  }
+
+  /**
+   * @param {number} len
+   */
+  writeIdSetLen (len) {
+    if (len === 0) {
+      error.unexpectedCase()
+    }
+    encoding.writeVarUint(this.restEncoder, len - 1)
+    this.dsCurrVal += len
+  }
+}
+
+export class UpdateEncoderV2 extends IdSetEncoderV2 {
+  constructor () {
+    super()
+    /**
+     * @type {Map<string,number>}
+     */
+    this.keyMap = new Map()
+    /**
+     * Refers to the next unique key-identifier to me used.
+     * See writeKey method for more information.
+     *
+     * @type {number}
+     */
+    this.keyClock = 0
+    this.keyClockEncoder = new encoding.IntDiffOptRleEncoder()
+    this.clientEncoder = new encoding.UintOptRleEncoder()
+    this.leftClockEncoder = new encoding.IntDiffOptRleEncoder()
+    this.rightClockEncoder = new encoding.IntDiffOptRleEncoder()
+    this.infoEncoder = new encoding.RleEncoder(encoding.writeUint8)
+    this.stringEncoder = new encoding.StringEncoder()
+    this.parentInfoEncoder = new encoding.RleEncoder(encoding.writeUint8)
+    this.typeRefEncoder = new encoding.UintOptRleEncoder()
+    this.lenEncoder = new encoding.UintOptRleEncoder()
+  }
+
+  toUint8Array () {
+    const encoder = encoding.createEncoder()
+    encoding.writeVarUint(encoder, 0) // this is a feature flag that we might use in the future
+    encoding.writeVarUint8Array(encoder, this.keyClockEncoder.toUint8Array())
+    encoding.writeVarUint8Array(encoder, this.clientEncoder.toUint8Array())
+    encoding.writeVarUint8Array(encoder, this.leftClockEncoder.toUint8Array())
+    encoding.writeVarUint8Array(encoder, this.rightClockEncoder.toUint8Array())
+    encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.infoEncoder))
+    encoding.writeVarUint8Array(encoder, this.stringEncoder.toUint8Array())
+    encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.parentInfoEncoder))
+    encoding.writeVarUint8Array(encoder, this.typeRefEncoder.toUint8Array())
+    encoding.writeVarUint8Array(encoder, this.lenEncoder.toUint8Array())
+    // @note The rest encoder is appended! (note the missing var)
+    encoding.writeUint8Array(encoder, encoding.toUint8Array(this.restEncoder))
+    return encoding.toUint8Array(encoder)
+  }
+
+  /**
+   * @param {ID} id
+   */
+  writeLeftID (id) {
+    this.clientEncoder.write(id.client)
+    this.leftClockEncoder.write(id.clock)
+  }
+
+  /**
+   * @param {ID} id
+   */
+  writeRightID (id) {
+    this.clientEncoder.write(id.client)
+    this.rightClockEncoder.write(id.clock)
+  }
+
+  /**
+   * @param {number} client
+   */
+  writeClient (client) {
+    this.clientEncoder.write(client)
+  }
+
+  /**
+   * @param {number} info An unsigned 8-bit integer
+   */
+  writeInfo (info) {
+    this.infoEncoder.write(info)
+  }
+
+  /**
+   * @param {string} s
+   */
+  writeString (s) {
+    this.stringEncoder.write(s)
+  }
+
+  /**
+   * @param {boolean} isYKey
+   */
+  writeParentInfo (isYKey) {
+    this.parentInfoEncoder.write(isYKey ? 1 : 0)
+  }
+
+  /**
+   * @param {number} info An unsigned 8-bit integer
+   */
+  writeTypeRef (info) {
+    this.typeRefEncoder.write(info)
+  }
+
+  /**
+   * Write len of a struct - well suited for Opt RLE encoder.
+   *
+   * @param {number} len
+   */
+  writeLen (len) {
+    this.lenEncoder.write(len)
+  }
+
+  /**
+   * @param {any} any
+   */
+  writeAny (any) {
+    encoding.writeAny(this.restEncoder, any)
+  }
+
+  /**
+   * @param {Uint8Array} buf
+   */
+  writeBuf (buf) {
+    encoding.writeVarUint8Array(this.restEncoder, buf)
+  }
+
+  /**
+   * This is mainly here for legacy purposes.
+   *
+   * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
+   *
+   * @param {any} embed
+   */
+  writeJSON (embed) {
+    encoding.writeAny(this.restEncoder, embed)
+  }
+
+  /**
+   * Property keys are often reused. For example, in y-prosemirror the key `bold` might
+   * occur very often. For a 3d application, the key `position` might occur very often.
+   *
+   * We cache these keys in a Map and refer to them via a unique number.
+   *
+   * @param {string} key
+   */
+  writeKey (key) {
+    const clock = this.keyMap.get(key)
+    if (clock === undefined) {
+      /**
+       * @todo uncomment to introduce this feature finally
+       *
+       * Background. The ContentFormat object was always encoded using writeKey, but the decoder used to use readString.
+       * Furthermore, I forgot to set the keyclock. So everything was working fine.
+       *
+       * However, this feature here is basically useless as it is not being used (it actually only consumes extra memory).
+       *
+       * I don't know yet how to reintroduce this feature..
+       *
+       * Older clients won't be able to read updates when we reintroduce this feature. So this should probably be done using a flag.
+       *
+       */
+      // this.keyMap.set(key, this.keyClock)
+      this.keyClockEncoder.write(this.keyClock++)
+      this.stringEncoder.write(key)
+    } else {
+      this.keyClockEncoder.write(clock)
+    }
+  }
+}
+
+/**
+ * @typedef {IdSetEncoderV1 | IdSetEncoderV2} IdSetEncoder
+ */
+/**
+ * @typedef {UpdateEncoderV1 | UpdateEncoderV2} UpdateEncoder
+ */

package/src/utils/YEvent.js

@@ -0,0 +1,189 @@
+import {
+  diffIdSet,
+  mergeIdSets,
+  noAttributionsManager,
+  YType, Doc, AbstractAttributionManager, Item, Transaction, AbstractStruct, // eslint-disable-line
+  createAbsolutePositionFromRelativePosition,
+  createRelativePosition
+} from '../internals.js'
+
+import * as map from 'lib0/map'
+import * as delta from 'lib0/delta' // eslint-disable-line
+import * as set from 'lib0/set'
+
+/**
+ * @template {delta.DeltaConf} DConf
+ * YEvent describes the changes on a YType.
+ */
+export class YEvent {
+  /**
+   * @param {YType<DConf>} target The changed type.
+   * @param {Transaction} transaction
+   * @param {Set<any>?} subs The keys that changed
+   */
+  constructor (target, transaction, subs) {
+    /**
+     * The type on which this event was created on.
+     * @type {YType<DConf>}
+     */
+    this.target = target
+    /**
+     * The current target on which the observe callback is called.
+     * @type {YType<any>}
+     */
+    this.currentTarget = target
+    /**
+     * The transaction that triggered this event.
+     * @type {Transaction}
+     */
+    this.transaction = transaction
+    /**
+     * @type {delta.Delta<import('../ytype.js').DeltaConfDeltaToYType<DConf>>|null}
+     */
+    this._delta = null
+    /**
+     * @type {delta.Delta<DConf>|null}
+     */
+    this._deltaDeep = null
+    /**
+     * Whether the children changed.
+     * @type {Boolean}
+     * @private
+     */
+    this.childListChanged = false
+    /**
+     * Set of all changed attributes.
+     * @type {Set<string>}
+     */
+    this.keysChanged = new Set()
+    subs?.forEach((sub) => {
+      if (sub === null) {
+        this.childListChanged = true
+      } else {
+        this.keysChanged.add(sub)
+      }
+    })
+  }
+
+  /**
+   * Check if a struct is deleted by this event.
+   *
+   * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
+   *
+   * @param {AbstractStruct} struct
+   * @return {boolean}
+   */
+  deletes (struct) {
+    return this.transaction.deleteSet.hasId(struct.id)
+  }
+
+  /**
+   * Check if a struct is added by this event.
+   *
+   * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
+   *
+   * @param {AbstractStruct} struct
+   * @return {boolean}
+   */
+  adds (struct) {
+    return this.transaction.insertSet.hasId(struct.id)
+  }
+
+  /**
+   * @template {boolean} [Deep=false]
+   * @param {AbstractAttributionManager} am
+   * @param {object} [opts]
+   * @param {Deep} [opts.deep]
+   * @return {Deep extends true ? delta.Delta<DConf> : delta.Delta<import('../internals.js').DeltaConfDeltaToYType<DConf>>} The Delta representation of this type.
+   *
+   * @public
+   */
+  getDelta (am = noAttributionsManager, { deep } = {}) {
+    const itemsToRender = mergeIdSets([diffIdSet(this.transaction.insertSet, this.transaction.deleteSet), diffIdSet(this.transaction.deleteSet, this.transaction.insertSet)])
+    /**
+     * @todo this should be done only one in the transaction step
+     *
+     * @type {Map<YType,Set<string|null>>|null}
+     */
+    let modified = this.transaction.changed
+    if (deep) {
+      // need to add deep changes to copy of modified
+      const dchanged = new Map()
+      modified.forEach((attrs, type) => {
+        dchanged.set(type, new Set(attrs))
+      })
+      for (let m of modified.keys()) {
+        while (m._item != null) {
+          const item = m._item
+          const ms = map.setIfUndefined(dchanged, item?.parent, set.create)
+          if (item && !ms.has(item.parentSub)) {
+            ms.add(item.parentSub)
+            m = /** @type {any} */ (item.parent)
+          } else {
+            break
+          }
+        }
+      }
+      modified = dchanged
+    }
+    return /** @type {any} */ (this.target.toDelta(am, { itemsToRender, retainDeletes: true, deletedItems: this.transaction.deleteSet, deep: !!deep, modified }))
+  }
+
+  /**
+   * Compute the changes in the delta format.
+   * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.
+   *
+   * @type {delta.Delta<import('../internals.js').DeltaConfDeltaToYType<DConf>>} The Delta representation of this type.
+   * @public
+   */
+  get delta () {
+    return /** @type {any} */ (this._delta ?? (this._delta = this.getDelta().done()))
+  }
+
+  /**
+   * Compute the changes in the delta format.
+   * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.
+   *
+   * @type {delta.Delta<DConf>} The Delta representation of this type.
+   * @public
+   */
+  get deltaDeep () {
+    return /** @type {any} */ (this._deltaDeep ?? (this._deltaDeep = /** @type {any} */ (this.getDelta(noAttributionsManager, { deep: true }))))
+  }
+}
+
+/**
+ * Compute the path from this type to the specified target.
+ *
+ * @example
+ *   // `child` should be accessible via `type.get(path[0]).get(path[1])..`
+ *   const path = type.getPathTo(child)
+ *   // assuming `type instanceof YArray`
+ *   console.log(path) // might look like => [2, 'key1']
+ *   child === type.get(path[0]).get(path[1])
+ *
+ * @param {YType} parent
+ * @param {YType} child target
+ * @param {AbstractAttributionManager} am
+ * @return {Array<string|number>} Path to the target
+ *
+ * @private
+ * @function
+ */
+export const getPathTo = (parent, child, am = noAttributionsManager) => {
+  const path = []
+  const doc = /** @type {Doc} */ (parent.doc)
+  while (child._item !== null && child !== parent) {
+    if (child._item.parentSub !== null) {
+      // parent is map-ish
+      path.unshift(child._item.parentSub)
+    } else {
+      const parent = /** @type {import('../ytype.js').YType} */ (child._item.parent)
+      // parent is array-ish
+      const apos = /** @type {import('../utils/RelativePosition.js').AbsolutePosition} */ (createAbsolutePositionFromRelativePosition(createRelativePosition(parent, child._item.id), doc, false, am))
+      path.unshift(apos.index)
+    }
+    child = /** @type {YType} */ (child._item.parent)
+  }
+  return path
+}

package/src/utils/delta-helpers.js

@@ -0,0 +1,54 @@
+import {
+  createInsertSetFromStructStore,
+  createDeleteSetFromStructStore,
+  createAttributionManagerFromDiff,
+  diffIdSet,
+  mergeIdSets,
+  Item,
+  YType, Doc, // eslint-disable-line
+  iterateStructsByIdSet
+} from '../internals.js'
+import * as delta from 'lib0/delta'
+import * as map from 'lib0/map'
+import * as set from 'lib0/set'
+
+/**
+ * @param {Doc} v1
+ * @param {Doc} v2
+ * @return {delta.DeltaBuilderAny}
+ */
+export const diffDocsToDelta = (v1, v2, { am = createAttributionManagerFromDiff(v1, v2) } = {}) => {
+  const d = delta.create()
+  v2.transact(tr => {
+    v2.share.forEach((type, typename) => {
+      const insertDiff = diffIdSet(createInsertSetFromStructStore(v2.store, false), createInsertSetFromStructStore(v1.store, false))
+      const deleteDiff = diffIdSet(createDeleteSetFromStructStore(v2.store), createDeleteSetFromStructStore(v1.store))
+      // don't render items that have been inserted and then deleted
+      const insertsOnly = diffIdSet(insertDiff, deleteDiff)
+      const deletesOnly = diffIdSet(deleteDiff, insertDiff)
+      const itemsToRender = mergeIdSets([insertsOnly, deleteDiff])
+      /**
+       * @type {Map<YType, Set<string|null>>}
+       */
+      const changedTypes = new Map()
+      iterateStructsByIdSet(tr, itemsToRender, /** @param {any} item */ item => {
+        while (item instanceof Item) {
+          const parent = /** @type {YType} */ (item.parent)
+          const conf = map.setIfUndefined(changedTypes, parent, set.create)
+          if (conf.has(item.parentSub)) break // has already been marked as modified
+          conf.add(item.parentSub)
+          item = parent._item
+        }
+      })
+      const typeConf = changedTypes.get(type)
+      if (typeConf) {
+        // @ts-ignore
+        const shareDelta = type.toDelta(am, {
+          itemsToRender, retainDeletes: true, deletedItems: deletesOnly, modified: changedTypes, deep: true
+        })
+        d.modifyAttr(typename, shareDelta)
+      }
+    })
+  })
+  return d
+}