@y/y 14.0.0-16 → 14.0.0-18

package/src/utils/UpdateEncoder.js

@@ -1,320 +0,0 @@
-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)
-    }
-  }
-}

package/src/utils/YEvent.js

@@ -1,216 +0,0 @@
-import {
-  diffIdSet,
-  mergeIdSets,
-  noAttributionsManager,
-  AbstractAttributionManager, Item, AbstractType, Transaction, AbstractStruct // eslint-disable-line
-} from '../internals.js'
-
-import * as map from 'lib0/map'
-import * as delta from 'lib0/delta' // eslint-disable-line
-import * as set from 'lib0/set'
-
-/**
- * @typedef {import('./types.js').YType} _YType
- */
-
-/**
- * @template {AbstractType<any,any>} Target
- * YEvent describes the changes on a YType.
- */
-export class YEvent {
-  /**
-   * @param {Target} 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 {Target}
-     */
-    this.target = target
-    /**
-     * The current target on which the observe callback is called.
-     * @type {_YType}
-     */
-    this.currentTarget = target
-    /**
-     * The transaction that triggered this event.
-     * @type {Transaction}
-     */
-    this.transaction = transaction
-    /**
-     * @type {(Target extends AbstractType<infer D,any> ? D : delta.Delta<any,any,any,any,any>)|null}
-     */
-    this._delta = null
-    /**
-     * @type {(Target extends AbstractType<infer D,any> ? import('../internals.js').ToDeepEventDelta<D> : delta.Delta<any,any,any,any,any>)|null}
-     */
-    this._deltaDeep = null
-    /**
-     * @type {Array<string|number>|null}
-     */
-    this._path = 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)
-      }
-    })
-  }
-
-  /**
-   * Computes the path from `y` to the changed type.
-   *
-   * @todo v14 should standardize on path: Array<{parent, index}> because that is easier to work with.
-   *
-   * The following property holds:
-   * @example
-   *   let type = y
-   *   event.path.forEach(dir => {
-   *     type = type.get(dir)
-   *   })
-   *   type === event.target // => true
-   */
-  get path () {
-    return this._path || (this._path = getPathTo(this.currentTarget, this.target))
-  }
-
-  /**
-   * 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 {Target extends AbstractType<infer D,any> ? (Deep extends true ? import('../internals.js').ToDeepEventDelta<D> : D) : delta.Delta<any,any,any,any>} 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<import('./types.js').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.getContent(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 {Target extends AbstractType<infer D,any> ? D : delta.Delta<any,any,any,any,any>} 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 {Target extends AbstractType<infer D,any> ? D : delta.Delta<any,any,any,any,any>} The Delta representation of this type.
-   * @public
-   */
-  get deltaDeep () {
-    return /** @type {any} */ (this._deltaDeep ?? (this._deltaDeep = 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
- * @return {Array<string|number>} Path to the target
- *
- * @private
- * @function
- */
-const getPathTo = (parent, child) => {
-  const path = []
-  while (child._item !== null && child !== parent) {
-    if (child._item.parentSub !== null) {
-      // parent is map-ish
-      path.unshift(child._item.parentSub)
-    } else {
-      // parent is array-ish
-      let i = 0
-      let c = /** @type {import('../utils/types.js').YType} */ (child._item.parent)._start
-      while (c !== child._item && c !== null) {
-        if (!c.deleted && c.countable) {
-          i += c.length
-        }
-        c = c.right
-      }
-      path.unshift(i)
-    }
-    child = /** @type {_YType} */ (child._item.parent)
-  }
-  return path
-}

package/src/utils/delta-helpers.js

@@ -1,54 +0,0 @@
-import {
-  createInsertSetFromStructStore,
-  createDeleteSetFromStructStore,
-  createAttributionManagerFromDiff,
-  diffIdSet,
-  mergeIdSets,
-  Item,
-  AbstractType, 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<AbstractType, Set<string|null>>}
-       */
-      const changedTypes = new Map()
-      iterateStructsByIdSet(tr, itemsToRender, /** @param {any} item */ item => {
-        while (item instanceof Item) {
-          const parent = /** @type {AbstractType} */ (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.getContent(am, {
-          itemsToRender, retainDeletes: true, deletedItems: deletesOnly, modified: changedTypes, deep: true
-        })
-        d.update(typename, shareDelta)
-      }
-    })
-  })
-  return d
-}