edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/vendor/yjs/src/utils/positions.js

@@ -0,0 +1,115 @@
+// YP19: a position as an item id and back — what upstream's relative
+// positions resolve, without the `RelativePosition`/`AbsolutePosition`
+// objects, their JSON form, root-key types or the redone-chain option
+// (edytor follows no undone deletion: every replica resolves an id alike).
+
+import { Item } from '../structs/Item.js'
+import { findMarker } from '../ynode.js'
+import { createID } from './ID.js'
+import { liveLength } from './transaction-helpers.js'
+
+/**
+ * The id at live index `index` of `type`: with `assoc >= 0` the unit at
+ * `index` (`null` at the end), with `assoc < 0` the unit before it (`null`
+ * at the start).
+ *
+ * @param {YNode} type
+ * @param {number} index
+ * @param {number} [assoc]
+ * @return {ID|null}
+ */
+export const idAtIndex = (type, index, assoc = 0) => {
+  let t = type._start
+  if (assoc < 0) {
+    // associated to the left character or the beginning of a type, increment index if possible.
+    if (index === 0) {
+      return null
+    }
+    index--
+  }
+  // Seed the walk from a search marker — the loop below counts
+  // countable/non-deleted length, exactly the space `marker.index` records,
+  // so `findMarker`'s (item, left-edge-index) result is a valid cursor. With
+  // no markers this falls back to the `_start` walk.
+  if (index > 0 && type._searchMarker !== null && type._searchMarker.length > 0) {
+    const m = findMarker(type, index)
+    if (m !== null && m.index <= index) {
+      t = m.p
+      index -= m.index
+    }
+  }
+  while (t !== null) {
+    const len = liveLength(t)
+    if (len > index) {
+      return createID(t.id.client, t.id.clock + index)
+    }
+    index -= len
+    if (t.right === null && assoc < 0) {
+      // left-associated position, return last available id
+      return t.lastId
+    }
+    t = t.right
+  }
+  return null
+}
+
+/**
+ * The live index of the position bound to unit `id` (`assoc >= 0`: before
+ * it, `assoc < 0`: after it) and the node holding it; `null` when `id` is
+ * not integrated here or was collected. A position in a deleted node is
+ * index `0`.
+ *
+ * @param {Doc} doc
+ * @param {ID} id
+ * @param {number} [assoc]
+ * @return {{ type: YNode, index: number }|null}
+ */
+export const indexOfId = (doc, id, assoc = 0) => {
+  const store = doc.store
+  if (store.getClock(id.client) <= id.clock) {
+    return null
+  }
+  const right = store.getItem(id)
+  if (!(right instanceof Item)) {
+    return null
+  }
+  const type = /** @type {YNode} */ (right.parent)
+  let index = 0
+  // an index into a deleted type is meaningless
+  if (type._item === null || !type._item.deleted) {
+    index = liveLength(right) === 0 ? 0 : (id.clock - right.id.clock + (assoc >= 0 ? 0 : 1)) // adjust position based on left association if necessary
+    let n = right.left
+    if (type._searchMarker !== null && type._searchMarker.length > 0) {
+      // Marker-assisted left walk: this loop
+      // accumulates countable/non-deleted length — the same space
+      // `marker.index` records — so the first marked item reached supplies
+      // the sum of everything left of it and the walk can stop early.
+      // Items whose flag outlived their record (wholesale marker clears
+      // leave the flag set) are simply walked past.
+      const markers = type._searchMarker
+      while (n !== null) {
+        if (n.marker) {
+          let m = null
+          for (let i = 0; i < markers.length; i++) {
+            if (markers[i].p === n) { m = markers[i]; break }
+          }
+          if (m !== null) {
+            // m.index is the left edge of n — the count of rendered units
+            // strictly before it — so n's own contribution is added too.
+            index += m.index + liveLength(n)
+            n = null
+            break
+          }
+        }
+        index += liveLength(n)
+        n = n.left
+      }
+    } else {
+      while (n !== null) {
+        index += liveLength(n)
+        n = n.left
+      }
+    }
+  }
+  return { type, index }
+}

package/dist/crdt/vendor/yjs/src/utils/redo.js

@@ -0,0 +1,143 @@
+/**
+ * YP18: what remains of the engine's UndoManager — the struct primitives an
+ * undo is made of. The history itself (stacks, capture, the undo and redo
+ * transactions) is edytor's (`src/lib/crdt/doc/history.ts`).
+ */
+import { Item } from '../structs/Item.js'
+import { createID } from './ID.js'
+import { getItemCleanStart } from './transaction-helpers.js'
+
+/**
+ * Redoes the effect of this operation.
+ *
+ * @param {Transaction} transaction The Yjs instance.
+ * @param {Item} item
+ * @param {Set<Item>} redoitems
+ * @param {IdSet} itemsToDelete
+ * @param {function(ID):boolean} [deletedByHistory] Whether a step of the history deletes the item `id` names (YP18)
+ *
+ * @return {Item|null}
+ *
+ * @private
+ */
+export const redoItem = (transaction, item, redoitems, itemsToDelete, deletedByHistory = () => false) => {
+  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 {YNode} */ (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, deletedByHistory) === null)) {
+      return null
+    }
+    while (parentItem.redone !== null) {
+      parentItem = getItemCleanStart(transaction, parentItem.redone)
+    }
+  }
+  /**
+   * @type {YNode}
+   */
+  const parentType = /** @type {YNode} */ (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 {YNode} */ (leftTrace.parent)._item !== parentItem) {
+        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone)
+      }
+      if (leftTrace !== null && /** @type {YNode} */ (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 {YNode} */ (rightTrace.parent)._item !== parentItem) {
+        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone)
+      }
+      if (rightTrace !== null && /** @type {YNode} */ (rightTrace.parent)._item === parentItem) {
+        right = rightTrace
+        break
+      }
+      right = right.right
+    }
+  } else {
+    right = null
+    if (item.right) {
+      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) || deletedByHistory(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 {YNode} */ (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 {YNode} */ (item.parent)._item
+  }
+}

package/dist/crdt/vendor/yjs/src/utils/transaction-helpers.js

@@ -2,7 +2,7 @@ import * as math from 'lib0-v14/math'
 import * as error from 'lib0-v14/error'
 import * as map from 'lib0-v14/map'
 import * as set from 'lib0-v14/set'
-import { foldPaired, pairedRole } from './marks.js' // YP13
+import { foldPaired } from './marks.js' // YP13
 import { compareIDs } from './ID.js' // YP14
 
 
@@ -161,33 +161,6 @@ export const iterateStructs = (transaction, structs, clockStart, len, f) => {
   } while (index < structs.length && structs[index].id.clock < clockEnd)
 }
 
-/**
- * Iterate over a range of structs without splitting the structs. You will get content that you did
- * not expect.
- *
- * @param {Array<Item|GC>} structs
- * @param {number} clockStart Inclusive start
- * @param {number} len
- * @param {(struct: GC|Item|Skip, offset:number, len:number)=>void} f
- *
- * @function
- */
-export const iterateStructsWithoutSplits = (structs, clockStart, len, f) => {
-  if (len === 0) {
-    return
-  }
-  const clockEnd = clockStart + len
-  for (
-    let index = findIndexSS(structs, clockStart), struct = structs[index], clock = struct.id.clock;
-    clock < clockEnd;
-    struct = structs[++index], clock = struct.id.clock
-  ) {
-    const offset = clock < clockStart ? clockStart - clock : 0
-    f(struct, offset, math.min(clock + struct.length, clockEnd) - clock)
-    if (index + 1 === structs.length) break
-  }
-}
-
 /**
  * More generalized version of splitItem. Split leftStruct into two structs
  * @param {Transaction?} transaction
@@ -306,111 +279,21 @@ export const tryMerge = (ds, store) => {
 }
 
 /**
- * @param {Transaction} transaction
- * @param {Item | null} item
+ * The live length of `item`: alive countable content counts its length, everything else `0`.
+ *
+ * @param {Item} item
+ * @return {number}
  */
-export const cleanupContextlessFormattingGap = (transaction, item) => {
-  if (!transaction.doc.cleanupFormatting) return 0
-  // iterate until item.right is null or content
-  while (item && item.right && (item.right.deleted || !item.right.countable)) {
-    item = item.right
-  }
-  const attrs = new Set()
-  // iterate back until a content item is found
-  while (item && (item.deleted || !item.countable)) {
-    if (!item.deleted && item.content.getRef() === 6 && pairedRole(/** @type {ContentFormat} */ (item.content)) < 0) { // is a ContentFormat (YP13: never a paired mark)
-      const key = /** @type {ContentFormat} */ (item.content).key
-      if (attrs.has(key)) {
-        item.delete(transaction)
-        transaction.cleanUps.add(item.id.client, item.id.clock, item.length)
-      } else {
-        attrs.add(key)
-      }
-    }
-    item = item.left
-  }
-}
+export const liveLength = item => (item.deleted || !item.content.isCountable()) ? 0 : item.length
 
 /**
+ * Fold mark item `format` into `currentFormats` (YP13, YP19: a mark is a
+ * paired operation; a plain format item is inert).
+ *
  * @param {Map<string,any>} currentFormats
  * @param {ContentFormat} format
  *
  * @private
  * @function
  */
-export const updateCurrentFormats = (currentFormats, format) => {
-  if (foldPaired(currentFormats, format)) return // YP13
-  const { key, value } = format
-  if (value === null) {
-    currentFormats.delete(key)
-  } else {
-    currentFormats.set(key, value)
-  }
-}
-
-/**
- * Call this function after string content has been deleted in order to
- * clean up formatting Items.
- *
- * @param {Transaction} transaction
- * @param {Item} start
- * @param {Item|null} curr exclusive end, automatically iterates to the next Content Item
- * @param {Map<string,any>} startFormats
- * @param {Map<string,any>} currFormats
- * @return {number} The amount of formatting Items deleted.
- *
- * @function
- */
-export const cleanupFormattingGap = (transaction, start, curr, startFormats, currFormats) => {
-  if (!transaction.doc.cleanupFormatting) return 0
-  /**
-   * @type {Item|null}
-   */
-  let end = start
-  /**
-   * @type {Map<string,ContentFormat>}
-   */
-  const endFormats = map.create()
-  while (end && (!end.countable || end.deleted)) {
-    if (!end.deleted && end.content.getRef() === 6 && pairedRole(/** @type {ContentFormat} */ (end.content)) < 0) {
-      const cf = /** @type {ContentFormat} */ (end.content)
-      endFormats.set(cf.key, cf)
-    }
-    end = end.right
-  }
-  let cleanups = 0
-  let reachedCurr = false
-  while (start !== end) {
-    if (curr === start) {
-      reachedCurr = true
-    }
-    if (!start.deleted) {
-      const content = start.content
-      if (content.getRef() === 6 && pairedRole(/** @type {ContentFormat} */ (content)) >= 0) {
-        // YP13: a paired mark is never redundant — an end closes only its own start
-        if (!reachedCurr) updateCurrentFormats(currFormats, /** @type {ContentFormat} */ (content))
-      } else if (content.getRef() === 6) { // is ContentFormat
-        const { key, value } = /** @type {ContentFormat} */ (content)
-        const startFormatValue = startFormats.get(key) ?? null
-        if (endFormats.get(key) !== content || startFormatValue === value) {
-          // Either this format is overwritten or it is not necessary because the format already existed.
-          start.delete(transaction)
-          transaction.cleanUps.add(start.id.client, start.id.clock, start.length)
-          cleanups++
-          if (!reachedCurr && (currFormats.get(key) ?? null) === value && startFormatValue !== value) {
-            if (startFormatValue === null) {
-              currFormats.delete(key)
-            } else {
-              currFormats.set(key, startFormatValue)
-            }
-          }
-        }
-        if (!reachedCurr && !start.deleted) {
-          updateCurrentFormats(currFormats, /** @type {ContentFormat} */ (content))
-        }
-      }
-    }
-    start = /** @type {Item} */ (start.right)
-  }
-  return cleanups
-}
+export const updateCurrentFormats = (currentFormats, format) => { foldPaired(currentFormats, format) }

package/dist/crdt/vendor/yjs/src/utils/updates.js

@@ -1,14 +1,11 @@
 import * as binary from 'lib0-v14/binary'
 import * as decoding from 'lib0-v14/decoding'
 import * as encoding from 'lib0-v14/encoding'
-import * as f from 'lib0-v14/function'
-import * as string from 'lib0-v14/string'
 
-import { readIdSet, writeIdSet } from './ids.js'
+import { readIdSet } from './ids.js'
 
 import { createID } from './ID.js'
-import { UpdateEncoderV1, UpdateEncoderV2 } from './UpdateEncoder.js'
-import { UpdateDecoderV1, UpdateDecoderV2 } from './UpdateDecoder.js'
+import { UpdateDecoder } from './UpdateDecoder.js'
 import { GC } from '../structs/GC.js'
 import { Item } from '../structs/Item.js'
 import {
@@ -17,7 +14,7 @@ import {
 import { Skip } from '../structs/Skip.js'
 
 /**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+ * @param {UpdateDecoder} decoder
  */
 function * lazyStructReaderGenerator (decoder) {
   const numOfStateUpdates = decoding.readVarUint(decoder.restDecoder)
@@ -62,7 +59,7 @@ function * lazyStructReaderGenerator (decoder) {
 
 export class LazyStructReader {
   /**
-   * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+   * @param {UpdateDecoder} decoder
    * @param {boolean} filterSkips
    */
   constructor (decoder, filterSkips) {
@@ -91,16 +88,9 @@ export class LazyStructReader {
 /**
  * @param {Uint8Array} update
  */
-export const decodeUpdate = (update) => decodeUpdateV2(update, UpdateDecoderV1)
-
-/**
- * @param {Uint8Array} update
- * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]
- *
- */
-export const decodeUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
+export const decodeUpdate = (update) => {
   const structs = []
-  const updateDecoder = new YDecoder(decoding.createDecoder(update))
+  const updateDecoder = new UpdateDecoder(decoding.createDecoder(update))
   const lazyDecoder = new LazyStructReader(updateDecoder, false)
   for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
     structs.push(curr)
@@ -113,7 +103,7 @@ export const decodeUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
 
 export class LazyStructWriter {
   /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+   * @param {import('./UpdateEncoder.js').UpdateEncoder} encoder
    */
   constructor (encoder) {
     this.currClient = 0
@@ -229,36 +219,3 @@ export const finishLazyStructWriting = (lazyWriter) => {
     encoding.writeUint8Array(restEncoder, partStructs.restEncoder)
   }
 }
-
-/**
- * @param {Uint8Array} update
- * @param {function(Item|GC|Skip):Item|GC|Skip} blockTransformer
- * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} YDecoder
- * @param {typeof UpdateEncoderV2 | typeof UpdateEncoderV1 } YEncoder
- */
-export const convertUpdateFormat = (update, blockTransformer, YDecoder, YEncoder) => {
-  const updateDecoder = new YDecoder(decoding.createDecoder(update))
-  const lazyDecoder = new LazyStructReader(updateDecoder, false)
-  const updateEncoder = new YEncoder()
-  const lazyWriter = new LazyStructWriter(updateEncoder)
-  for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
-    writeStructToLazyStructWriter(lazyWriter, blockTransformer(curr), 0, 0)
-  }
-  finishLazyStructWriting(lazyWriter)
-  const ds = readIdSet(updateDecoder)
-  writeIdSet(updateEncoder, ds)
-  return updateEncoder.toUint8Array()
-}
-
-/**
- * @typedef {Object} ObfuscatorOptions
- * @property {boolean} [ObfuscatorOptions.formatting=true]
- * @property {boolean} [ObfuscatorOptions.subdocs=true]
- * @property {boolean} [ObfuscatorOptions.name=true] Whether to obfuscate nodeName / hookName
- */
-
-/**
- * @param {Uint8Array} update
- */
-export const convertUpdateFormatV2ToV1 = update => convertUpdateFormat(update, f.id, UpdateDecoderV2, UpdateEncoderV1)
-