@y/y 14.0.0-rc.2 → 14.0.0-rc.21

package/src/utils/UndoManager.js

@@ -1,22 +1,18 @@
-import {
-  mergeIdSets,
-  iterateStructsByIdSet,
-  keepItem,
-  transact,
-  createID,
-  redoItem,
-  isParentOf,
-  followRedone,
-  getItemCleanStart,
-  YEvent, Transaction, Doc, Item, GC, IdSet, YType, // eslint-disable-line
-  diffIdSet
-} from '../internals.js'
-
 import * as time from 'lib0/time'
 import * as array from 'lib0/array'
 import * as logging from 'lib0/logging'
 import { ObservableV2 } from 'lib0/observable'
 
+import { mergeIdSets, iterateStructsByIdSet, diffIdSet } from './ids.js'
+import { Item, followRedone } from '../structs/Item.js'
+
+import { transact } from './Transaction.js'
+import { createID } from './ID.js'
+import { isParentOf } from './isParentOf.js'
+import { getItemCleanStart } from './transaction-helpers.js'
+import { Doc } from './Doc.js'
+import { YType } from '../ytype.js'
+
 export class StackItem {
   /**
    * @param {IdSet} insertions
@@ -96,7 +92,7 @@ const popStackItem = (undoManager, stack, eventType) => {
         }
       })
       itemsToRedo.forEach(struct => {
-        performedChange = redoItem(transaction, struct, itemsToRedo, stackItem.inserts, undoManager.ignoreRemoteMapChanges, undoManager) !== null || performedChange
+        performedChange = redoItem(transaction, struct, itemsToRedo, stackItem.inserts, undoManager.ignoreRemoteAttributeChanges, undoManager) !== null || performedChange
       })
       // We want to delete in reverse order so that children are deleted before
       // parents, so we have more information available when items are filtered.
@@ -135,7 +131,7 @@ const popStackItem = (undoManager, stack, eventType) => {
  * filter returns false, the type/item won't be deleted even it is in the
  * undo/redo scope.
  * @property {Set<any>} [UndoManagerOptions.trackedOrigins=new Set([null])]
- * @property {boolean} [ignoreRemoteMapChanges] Experimental. By default, the UndoManager will never overwrite remote changes. Enable this property to enable overwriting remote changes on key-value changes (Y.Map, properties on Y.Xml, etc..).
+ * @property {boolean} [ignoreRemoteAttributeChanges] By default, the UndoManager will never overwrite remote changes. In some cases this might be the expected behavior. This property enables overwriting remote changes on attribute changes. (previously named `ignoreRemoteMapChanges`)
  * @property {Doc} [doc] The document that this UndoManager operates on. Only needed if typeScope is empty.
  */
 
@@ -166,7 +162,7 @@ export class UndoManager extends ObservableV2 {
     captureTransaction = _tr => true,
     deleteFilter = () => true,
     trackedOrigins = new Set([null]),
-    ignoreRemoteMapChanges = false,
+    ignoreRemoteAttributeChanges = false,
     doc = /** @type {Doc} */ (array.isArray(typeScope) ? typeScope[0].doc : typeScope instanceof Doc ? typeScope : typeScope.doc)
   } = {}) {
     super()
@@ -202,7 +198,7 @@ export class UndoManager extends ObservableV2 {
      */
     this.currStackItem = null
     this.lastChange = 0
-    this.ignoreRemoteMapChanges = ignoreRemoteMapChanges
+    this.ignoreRemoteAttributeChanges = ignoreRemoteAttributeChanges
     this.captureTimeout = captureTimeout
     /**
      * @param {Transaction} transaction
@@ -397,7 +393,7 @@ export class UndoManager extends ObservableV2 {
  * This is not guaranteed to work on documents with gc enabled!
  *
  * @param {Doc} ydoc
- * @param {import('./meta.js').ContentIds} contentIds
+ * @param {ContentIds} contentIds
  * @param {UndoManagerOptions} opts
  */
 export const undoContentIds = (ydoc, contentIds, opts = {}) => {
@@ -405,3 +401,145 @@ export const undoContentIds = (ydoc, contentIds, opts = {}) => {
   um.undoStack.push(new StackItem(diffIdSet(contentIds.inserts, contentIds.deletes), diffIdSet(contentIds.deletes, contentIds.inserts)))
   um.undo()
 }
+
+/**
+ * @param {Array<StackItem>} stack
+ * @param {ID} id
+ */
+const isDeletedByUndoStack = (stack, id) => array.some(stack, /** @param {StackItem} s */ s => s.deletes.hasId(id))
+
+/**
+ * Redoes the effect of this operation.
+ *
+ * @param {Transaction} transaction The Yjs instance.
+ * @param {Item} item
+ * @param {Set<Item>} redoitems
+ * @param {IdSet} itemsToDelete
+ * @param {boolean} ignoreRemoteAttributeChanges
+ * @param {import('../utils/UndoManager.js').UndoManager} um
+ *
+ * @return {Item|null}
+ *
+ * @private
+ */
+export const redoItem = (transaction, item, redoitems, itemsToDelete, ignoreRemoteAttributeChanges, um) => {
+  const doc = transaction.doc
+  const store = doc.store
+  const ownClientID = doc.clientID
+  const redone = item.redone
+  if (redone !== null) {
+    return getItemCleanStart(transaction, redone)
+  }
+  let parentItem = /** @type {YType} */ (item.parent)._item
+  /**
+   * @type {Item|null}
+   */
+  let left = null
+  /**
+   * @type {Item|null}
+   */
+  let right
+  // make sure that parent is redone
+  if (parentItem !== null && parentItem.deleted === true) {
+    // try to undo parent if it will be undone anyway
+    if (parentItem.redone === null && (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems, itemsToDelete, ignoreRemoteAttributeChanges, um) === null)) {
+      return null
+    }
+    while (parentItem.redone !== null) {
+      parentItem = getItemCleanStart(transaction, parentItem.redone)
+    }
+  }
+  /**
+   * @type {YType}
+   */
+  const parentType = /** @type {YType} */ (parentItem === null ? item.parent : /** @type {ContentType} */ (parentItem.content).type)
+
+  if (item.parentSub === null) {
+    // Is an array item. Insert at the old position
+    left = item.left
+    right = item
+    // find next cloned_redo items
+    while (left !== null) {
+      /**
+       * @type {Item|null}
+       */
+      let leftTrace = left
+      // trace redone until parent matches
+      while (leftTrace !== null && /** @type {YType} */ (leftTrace.parent)._item !== parentItem) {
+        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone)
+      }
+      if (leftTrace !== null && /** @type {YType} */ (leftTrace.parent)._item === parentItem) {
+        left = leftTrace
+        break
+      }
+      left = left.left
+    }
+    while (right !== null) {
+      /**
+       * @type {Item|null}
+       */
+      let rightTrace = right
+      // trace redone until parent matches
+      while (rightTrace !== null && /** @type {YType} */ (rightTrace.parent)._item !== parentItem) {
+        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone)
+      }
+      if (rightTrace !== null && /** @type {YType} */ (rightTrace.parent)._item === parentItem) {
+        right = rightTrace
+        break
+      }
+      right = right.right
+    }
+  } else {
+    right = null
+    if (item.right && !ignoreRemoteAttributeChanges) {
+      left = item
+      // Iterate right while right is in itemsToDelete
+      // If it is intended to delete right while item is redone, we can expect that item should replace right.
+      while (left !== null && left.right !== null && (left.right.redone || itemsToDelete.hasId(left.right.id) || isDeletedByUndoStack(um.undoStack, left.right.id) || isDeletedByUndoStack(um.redoStack, left.right.id))) {
+        left = left.right
+        // follow redone
+        while (left.redone) left = getItemCleanStart(transaction, left.redone)
+      }
+      if (left && left.right !== null) {
+        // It is not possible to redo this item because it conflicts with a
+        // change from another client
+        return null
+      }
+    } else {
+      left = parentType._map.get(item.parentSub) || null
+    }
+    if (left !== null && /** @type {YType} */ (left.parent)._item !== parentItem) {
+      left = parentType._map.get(item.parentSub) || null
+    }
+  }
+  const nextClock = store.getClock(ownClientID)
+  const nextId = createID(ownClientID, nextClock)
+  const redoneItem = new Item(
+    nextId,
+    left, left && left.lastId,
+    right, right && right.id,
+    parentType,
+    item.parentSub,
+    item.content.copy()
+  )
+  item.redone = nextId
+  keepItem(redoneItem, true)
+  redoneItem.integrate(transaction, 0)
+  return redoneItem
+}
+
+/**
+ * Make sure that neither item nor any of its parents is ever deleted.
+ *
+ * This property does not persist when storing it into a database or when
+ * sending it to other peers
+ *
+ * @param {Item|null} item
+ * @param {boolean} keep
+ */
+export const keepItem = (item, keep) => {
+  while (item !== null && item.keep !== keep) {
+    item.keep = keep
+    item = /** @type {YType} */ (item.parent)._item
+  }
+}

package/src/utils/UpdateDecoder.js

@@ -1,8 +1,7 @@
 import * as buffer from 'lib0/buffer'
 import * as decoding from 'lib0/decoding'
-import {
-  ID, createID
-} from '../internals.js'
+
+import { ID, createID } from './ID.js'
 
 /**
  * @typedef {IdSetDecoderV1 | IdSetDecoderV2} IdSetDecoder

package/src/utils/UpdateEncoder.js

@@ -1,10 +1,6 @@
 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()

package/src/utils/YEvent.js

@@ -1,30 +1,24 @@
-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'
 
+import { diffIdSet, mergeIdSets } from './ids.js'
+import { baseRenderer } from './renderer-helpers.js'
+import { createAbsolutePositionFromRelativePosition, createRelativePosition } from './RelativePosition.js'
+
 /**
- * @template {delta.DeltaConf} DConf
+ * @template {DeltaConf} DConf
  * YEvent describes the changes on a YType.
  */
 export class YEvent {
   /**
    * @param {YType<DConf>} target The changed type.
-   * @param {Transaction} transaction
+   * @param {import('./Transaction.js').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>}
+     * @type {import('../ytype.js').YType<DConf>}
      */
     this.target = target
     /**
@@ -34,15 +28,15 @@ export class YEvent {
     this.currentTarget = target
     /**
      * The transaction that triggered this event.
-     * @type {Transaction}
+     * @type {import('./Transaction.js').Transaction}
      */
     this.transaction = transaction
     /**
-     * @type {delta.Delta<import('../ytype.js').DeltaConfDeltaToYType<DConf>>|null}
+     * @type {Delta<import('../ytype.js').DeltaConfDeltaToYType<DConf>>|null}
      */
     this._delta = null
     /**
-     * @type {delta.Delta<DConf>|null}
+     * @type {Delta<DConf>|null}
      */
     this._deltaDeep = null
     /**
@@ -91,14 +85,14 @@ export class YEvent {
 
   /**
    * @template {boolean} [Deep=false]
-   * @param {AbstractAttributionManager} am
    * @param {object} [opts]
+   * @param {AbstractRenderer} [opts.renderer] - renders the content (with attributions); defaults to the target type's active renderer (see {@link YType#useRenderer}), i.e. `baseRenderer` unless changed
    * @param {Deep} [opts.deep]
-   * @return {Deep extends true ? delta.Delta<DConf> : delta.Delta<import('../internals.js').DeltaConfDeltaToYType<DConf>>} The Delta representation of this type.
+   * @return {Deep extends true ? Delta<DConf> : Delta<import('../ytype.js').DeltaConfDeltaToYType<DConf>>} The Delta representation of this type.
    *
    * @public
    */
-  getDelta (am = noAttributionsManager, { deep } = {}) {
+  getDelta ({ renderer = this.target._renderer, 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
@@ -126,14 +120,14 @@ export class YEvent {
       }
       modified = dchanged
     }
-    return /** @type {any} */ (this.target.toDelta(am, { itemsToRender, retainDeletes: true, deletedItems: this.transaction.deleteSet, deep: !!deep, modified }))
+    return /** @type {any} */ (this.target.toDelta({ renderer, 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.
+   * @type {Delta<import('../ytype.js').DeltaConfDeltaToYType<DConf>>} The Delta representation of this type.
    * @public
    */
   get delta () {
@@ -144,11 +138,11 @@ export class YEvent {
    * 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.
+   * @type {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 }))))
+    return /** @type {any} */ (this._deltaDeep ?? (this._deltaDeep = /** @type {any} */ (this.getDelta({ deep: true }))))
   }
 }
 
@@ -164,13 +158,13 @@ export class YEvent {
  *
  * @param {YType} parent
  * @param {YType} child target
- * @param {AbstractAttributionManager} am
+ * @param {AbstractRenderer} renderer
  * @return {Array<string|number>} Path to the target
  *
  * @private
  * @function
  */
-export const getPathTo = (parent, child, am = noAttributionsManager) => {
+export const getPathTo = (parent, child, renderer = baseRenderer) => {
   const path = []
   const doc = /** @type {Doc} */ (parent.doc)
   while (child._item !== null && child !== parent) {
@@ -180,7 +174,7 @@ export const getPathTo = (parent, child, am = noAttributionsManager) => {
     } 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))
+      const apos = /** @type {import('../utils/RelativePosition.js').AbsolutePosition} */ (createAbsolutePositionFromRelativePosition(createRelativePosition(parent, child._item.id), doc, false, renderer))
       path.unshift(apos.index)
     }
     child = /** @type {YType} */ (child._item.parent)

package/src/utils/delta-helpers.js

@@ -1,54 +1,33 @@
-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'
+import { createInsertSetFromStructStore, createDeleteSetFromStructStore, diffIdSet, mergeIdSets } from './ids.js'
+import { createDiffRenderer } from './Renderer.js'
+import { computeModifiedFromItems } from '../ytype.js'
 
 /**
  * @param {Doc} v1
  * @param {Doc} v2
  * @return {delta.DeltaBuilderAny}
  */
-export const diffDocsToDelta = (v1, v2, { am = createAttributionManagerFromDiff(v1, v2) } = {}) => {
+export const diffDocsToDelta = (v1, v2, { renderer = createDiffRenderer(v1, v2) } = {}) => {
+  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 = computeModifiedFromItems(v2.store, itemsToRender)
   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
-        }
+  v2.share.forEach((type, typename) => {
+    const typeConf = changedTypes.get(type)
+    if (typeConf) {
+      const shareDelta = type.toDelta({
+        renderer, itemsToRender, retainDeletes: true, deletedItems: deletesOnly, modified: changedTypes, deep: true
       })
-      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)
-      }
-    })
+      d.modifyAttr(typename, shareDelta)
+    }
   })
   return d
 }

package/src/utils/encoding-helpers.js

@@ -0,0 +1,110 @@
+import * as encoding from 'lib0/encoding'
+import * as math from 'lib0/math'
+import * as array from 'lib0/array'
+
+import { findIndexSS } from './transaction-helpers.js'
+import { Skip } from '../structs/Skip.js'
+import { createID } from './ID.js'
+import { writeIdSet } from './ids.js'
+
+/**
+ * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+ * @param {Array<GC|Item|Skip>} structs All structs by `client`
+ * @param {number} client
+ * @param {Array<IdRange>} idranges
+ *
+ * @function
+ */
+export const writeStructs = (encoder, structs, client, idranges) => {
+  let structsToWrite = 0 // this accounts for the skips
+  /**
+   * @type {Array<{ start: number, end: number, startClock: number, endClock: number }>}
+   */
+  const indexRanges = []
+  const firstPossibleClock = structs[0].id.clock
+  const lastStruct = array.last(structs)
+  const lastPossibleClock = lastStruct.id.clock + lastStruct.length
+  idranges.forEach(idrange => {
+    const startClock = math.max(idrange.clock, firstPossibleClock)
+    const endClock = math.min(idrange.clock + idrange.len, lastPossibleClock)
+    if (startClock >= endClock) return // structs for this range do not exist
+    // inclusive start
+    const start = findIndexSS(structs, startClock)
+    // exclusive end
+    const end = findIndexSS(structs, endClock - 1) + 1
+    structsToWrite += end - start
+    indexRanges.push({
+      start,
+      end,
+      startClock,
+      endClock
+    })
+  })
+  structsToWrite += idranges.length - 1
+  // start writing with this clock. this is updated to the next clock that we expect to write
+  let clock = indexRanges[0].startClock
+  // write # encoded structs
+  encoding.writeVarUint(encoder.restEncoder, structsToWrite)
+  encoder.writeClient(client)
+  // write clock
+  encoding.writeVarUint(encoder.restEncoder, clock)
+  indexRanges.forEach(indexRange => {
+    const skipLen = indexRange.startClock - clock
+    if (skipLen > 0) {
+      new Skip(createID(client, clock), skipLen).write(encoder, 0)
+      clock += skipLen
+    }
+    for (let i = indexRange.start; i < indexRange.end; i++) {
+      const struct = structs[i]
+      const structEnd = struct.id.clock + struct.length
+      const offsetEnd = math.max(structEnd - indexRange.endClock, 0)
+      struct.write(encoder, clock - struct.id.clock, offsetEnd)
+      clock = structEnd - offsetEnd
+    }
+  })
+}
+
+/**
+ * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+ * @param {StructStore} store
+ * @param {IdSet} idset
+ *
+ * @todo at the moment this writes the full deleteset range
+ *
+ * @private
+ * @function
+ */
+export const writeStructsFromIdSet = (encoder, store, idset) => {
+  // write # states that were updated
+  encoding.writeVarUint(encoder.restEncoder, idset.clients.size)
+  // Write items with higher client ids first
+  // This heavily improves the conflict algorithm.
+  array.from(idset.clients.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, ids]) => {
+    const idRanges = ids.getIds()
+    const structs = /** @type {Array<GC|Item>} */ (store.clients.get(client))
+    writeStructs(encoder, structs, client, idRanges)
+  })
+}
+
+/**
+ * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+ * @param {Transaction} transaction
+ *
+ * @private
+ * @function
+ */
+export const writeStructsFromTransaction = (encoder, transaction) => writeStructsFromIdSet(encoder, transaction.doc.store, transaction.insertSet)
+
+/**
+ * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+ * @param {Transaction} transaction
+ * @return {boolean} Whether data was written.
+ */
+export const writeUpdateMessageFromTransaction = (encoder, transaction) => {
+  if (transaction.deleteSet.clients.size === 0 && transaction.insertSet.clients.size === 0) {
+    return false
+  }
+  writeStructsFromTransaction(encoder, transaction)
+  writeIdSet(encoder, transaction.deleteSet)
+  return true
+}