@y/y 14.0.0-20 → 14.0.0-22

package/src/utils/meta.js

@@ -5,6 +5,8 @@
 import * as idmap from './IdMap.js'
 import * as idset from './IdSet.js'
 import { IdSetEncoderV2 } from './UpdateEncoder.js'
+import { IdSetDecoderV2 } from './UpdateDecoder.js'
+import * as decoding from 'lib0/decoding'
 
 /**
  * @typedef {{ inserts: import('./IdSet.js').IdSet, deletes: import('./IdSet.js').IdSet }} ContentIds
@@ -18,7 +20,7 @@ import { IdSetEncoderV2 } from './UpdateEncoder.js'
  * @param {import('./IdSet.js').IdSet} inserts
  * @param {import('./IdSet.js').IdSet} deletes
  */
-export const createContentIds = (inserts, deletes) => ({ inserts, deletes })
+export const createContentIds = (inserts = idset.createIdSet(), deletes = idset.createIdSet()) => ({ inserts, deletes })
 
 /**
  * @param {ContentMap} contentMap
@@ -50,6 +52,31 @@ export const createContentIdsFromDocDiff = (ydocPrev, ydocNext) =>
 export const excludeContentIds = (content, excludeContent) =>
   createContentIds(idset.diffIdSet(content.inserts, excludeContent.inserts), idset.diffIdSet(content.deletes, excludeContent.deletes))
 
+/**
+ * @param {ContentMap} content
+ * @param {ContentIds | ContentMap} excludeContent
+ */
+export const excludeContentMaps = (content, excludeContent) => createContentMap(
+  idmap.diffIdMap(content.inserts, excludeContent.inserts),
+  idmap.diffIdMap(content.deletes, excludeContent.deletes)
+)
+
+/**
+ * @param {Array<ContentMap>} contents
+ */
+export const mergeContentMaps = contents => createContentMap(
+  idmap.mergeIdMaps(contents.map(c => c.inserts)),
+  idmap.mergeIdMaps(contents.map(c => c.deletes))
+)
+
+/**
+ * @param {Array<ContentIds>} contents
+ */
+export const mergeContentIds = contents => createContentIds(
+  idset.mergeIdSets(contents.map(c => c.inserts)),
+  idset.mergeIdSets(contents.map(c => c.deletes))
+)
+
 /**
  * @param {import('./IdMap.js').IdMap<any>} inserts
  * @param {import('./IdMap.js').IdMap<any>} deletes
@@ -78,7 +105,27 @@ export const writeContentIds = (encoder, contentIds) => {
 /**
  * @param {ContentIds} contentIds
  */
-export const encodeContentIds = contentIds => writeContentIds(new IdSetEncoderV2(), contentIds)
+export const encodeContentIds = contentIds => {
+  const encoder = new IdSetEncoderV2()
+  writeContentIds(encoder, contentIds)
+  return encoder.toUint8Array()
+}
+
+/**
+ * @todo this encoding needs to be heavily optimized for production
+ *
+ * @param {import('./UpdateDecoder.js').IdSetDecoder} decoder
+ * @return {ContentIds}
+ */
+export const readContentIds = decoder => createContentIds(
+  idset.readIdSet(decoder),
+  idset.readIdSet(decoder)
+)
+
+/**
+ * @param {Uint8Array<any>} buf
+ */
+export const decodeContentIds = buf => readContentIds(new IdSetDecoderV2(decoding.createDecoder(buf)))
 
 /**
  * @todo this encoding needs to be heavily optimized for production
@@ -92,6 +139,52 @@ export const writeContentMap = (encoder, contentMap) => {
 }
 
 /**
+ * @todo this encoding needs to be heavily optimized for production
+ *
+ * @param {import('./UpdateDecoder.js').IdSetDecoder} decoder
+ * @return {ContentMap} contentMap
+ */
+export const readContentMap = (decoder) => createContentMap(
+  idmap.readIdMap(decoder),
+  idmap.readIdMap(decoder)
+)
+
+/**
+ * @param {ContentMap} contentMap
+ */
+export const encodeContentMap = contentMap => {
+  const encoder = new IdSetEncoderV2()
+  writeContentMap(encoder, contentMap)
+  return encoder.toUint8Array()
+}
+
+/**
+ * @param {ContentMap} mapA
+ * @param {ContentMap|ContentIds} mapB
+ */
+export const intersectContentMap = (mapA, mapB) => createContentMap(
+  idmap.intersectMaps(mapA.inserts, mapB.inserts),
+  idmap.intersectMaps(mapA.deletes, mapB.deletes)
+)
+
+/**
+ * @param {ContentIds} setA
+ * @param {ContentIds|ContentMap} setB
+ */
+export const intersectContentIds = (setA, setB) => createContentIds(
+  idset.intersectSets(setA.inserts, setB.inserts),
+  idset.intersectSets(setA.deletes, setB.deletes)
+)
+
+/**
+ * @param {Uint8Array<any>} buf
+ */
+export const decodeContentMap = buf => readContentMap(new IdSetDecoderV2(decoding.createDecoder(buf)))
+
+/**
+ * @todo filter by array of content instead
  * @param {ContentMap} contentMap
+ * @param {(c:Array<idmap.ContentAttribute<any>>)=>boolean} insertPredicate
+ * @param {(c:Array<idmap.ContentAttribute<any>>)=>boolean} deletePredicate
  */
-export const encodeContentMap = contentMap => writeContentMap(new IdSetEncoderV2(), contentMap)
+export const filterContentMap = (contentMap, insertPredicate, deletePredicate) => createContentMap(idmap.filterIdMap(contentMap.inserts, insertPredicate), idmap.filterIdMap(contentMap.deletes, deletePredicate))

package/src/utils/updates.js

@@ -33,9 +33,14 @@ import {
   UpdateEncoderV1,
   UpdateEncoderV2,
   writeIdSet,
-  createIdSet
+  createIdSet,
+  Doc,
+  applyUpdate,
+  applyUpdateV2
 } from '../internals.js'
 
+import * as idset from './IdSet.js'
+
 /**
  * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
  */
@@ -248,7 +253,7 @@ export const encodeStateVectorFromUpdate = update => encodeStateVectorFromUpdate
  * @param {typeof UpdateDecoderV2 | typeof UpdateDecoderV1} [YDecoder]
  * @return {import('./meta.js').ContentIds}
  */
-export const readUpdateToContentIdsV2 = (update, YDecoder = UpdateDecoderV2) => {
+export const createContentIdsFromUpdateV2 = (update, YDecoder = UpdateDecoderV2) => {
   const updateDecoder = new YDecoder(decoding.createDecoder(update))
   const lazyDecoder = new LazyStructReader(updateDecoder, true)
   const inserts = createIdSet()
@@ -280,7 +285,7 @@ export const readUpdateToContentIdsV2 = (update, YDecoder = UpdateDecoderV2) =>
  * @param {Uint8Array} update
  * @return {import('./meta.js').ContentIds}
  */
-export const readUpdateToContentIds = update => readUpdateToContentIdsV2(update, UpdateDecoderV1)
+export const createContentIdsFromUpdate = update => createContentIdsFromUpdateV2(update, UpdateDecoderV1)
 
 /**
  * This method is intended to slice any kind of struct and retrieve the right part.
@@ -390,7 +395,7 @@ export const mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = U
       }
 
       if (firstClient !== currWrite.struct.id.client) {
-        writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset)
+        writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset, 0)
         currWrite = { struct: curr, offset: 0 }
         currDecoder.next()
       } else {
@@ -400,7 +405,7 @@ export const mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = U
             // extend existing skip
             currWrite.struct.length = curr.id.clock + curr.length - currWrite.struct.id.clock
           } else {
-            writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset)
+            writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset, 0)
             const diff = curr.id.clock - currWrite.struct.id.clock - currWrite.struct.length
             /**
              * @type {Skip}
@@ -419,7 +424,7 @@ export const mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = U
             }
           }
           if (!currWrite.struct.mergeWith(/** @type {any} */ (curr))) {
-            writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset)
+            writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset, 0)
             currWrite = { struct: curr, offset: 0 }
             currDecoder.next()
           }
@@ -434,12 +439,12 @@ export const mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = U
       next !== null && next.id.client === firstClient && next.id.clock === currWrite.struct.id.clock + currWrite.struct.length && next.constructor !== Skip;
       next = currDecoder.next()
     ) {
-      writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset)
+      writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset, 0)
       currWrite = { struct: next, offset: 0 }
     }
   }
   if (currWrite !== null) {
-    writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset)
+    writeStructToLazyStructWriter(lazyStructEncoder, currWrite.struct, currWrite.offset, 0)
     currWrite = null
   }
   finishLazyStructWriting(lazyStructEncoder)
@@ -451,6 +456,7 @@ export const mergeUpdatesV2 = (updates, YDecoder = UpdateDecoderV2, YEncoder = U
 }
 
 /**
+ * @deprecated
  * @param {Uint8Array} update
  * @param {Uint8Array} sv
  * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]
@@ -472,10 +478,10 @@ export const diffUpdateV2 = (update, sv, YDecoder = UpdateDecoderV2, YEncoder =
       continue
     }
     if (curr.id.clock + curr.length > svClock) {
-      writeStructToLazyStructWriter(lazyStructWriter, curr, math.max(svClock - curr.id.clock, 0))
+      writeStructToLazyStructWriter(lazyStructWriter, curr, math.max(svClock - curr.id.clock, 0), 0)
       reader.next()
       while (reader.curr && reader.curr.id.client === currClient) {
-        writeStructToLazyStructWriter(lazyStructWriter, reader.curr, 0)
+        writeStructToLazyStructWriter(lazyStructWriter, reader.curr, 0, 0)
         reader.next()
       }
     } else {
@@ -493,6 +499,9 @@ export const diffUpdateV2 = (update, sv, YDecoder = UpdateDecoderV2, YEncoder =
 }
 
 /**
+ * @deprecated
+ * @todo remove this in favor of intersectupdate
+ *
  * @param {Uint8Array} update
  * @param {Uint8Array} sv
  */
@@ -513,8 +522,9 @@ const flushLazyStructWriter = lazyWriter => {
  * @param {LazyStructWriter} lazyWriter
  * @param {Item | GC} struct
  * @param {number} offset
+ * @param {number} offsetEnd
  */
-const writeStructToLazyStructWriter = (lazyWriter, struct, offset) => {
+const writeStructToLazyStructWriter = (lazyWriter, struct, offset, offsetEnd) => {
   // flush curr if we start another client
   if (lazyWriter.written > 0 && lazyWriter.currClient !== struct.id.client) {
     flushLazyStructWriter(lazyWriter)
@@ -526,7 +536,7 @@ const writeStructToLazyStructWriter = (lazyWriter, struct, offset) => {
     // write startClock
     encoding.writeVarUint(lazyWriter.encoder.restEncoder, struct.id.clock + offset)
   }
-  struct.write(lazyWriter.encoder, offset, 0)
+  struct.write(lazyWriter.encoder, offset, offsetEnd)
   lazyWriter.written++
 }
 /**
@@ -574,7 +584,7 @@ export const convertUpdateFormat = (update, blockTransformer, YDecoder, YEncoder
   const updateEncoder = new YEncoder()
   const lazyWriter = new LazyStructWriter(updateEncoder)
   for (let curr = lazyDecoder.curr; curr !== null; curr = lazyDecoder.next()) {
-    writeStructToLazyStructWriter(lazyWriter, blockTransformer(curr), 0)
+    writeStructToLazyStructWriter(lazyWriter, blockTransformer(curr), 0, 0)
   }
   finishLazyStructWriting(lazyWriter)
   const ds = readIdSet(updateDecoder)
@@ -709,3 +719,84 @@ export const convertUpdateFormatV1ToV2 = update => convertUpdateFormat(update, f
  * @param {Uint8Array} update
  */
 export const convertUpdateFormatV2ToV1 = update => convertUpdateFormat(update, f.id, UpdateDecoderV2, UpdateEncoderV1)
+
+/**
+ * Filter an update to only include content specified by a ContentIds pattern.
+ *
+ * This function extracts a subset of an update, keeping only the structs whose IDs
+ * are present in `contentIds.inserts` and only the delete set entries that are
+ * present in `contentIds.deletes`.
+ *
+ * Note: If a struct partially overlaps with the contentIds pattern, only the
+ * overlapping portion is included in the result.
+ *
+ * @param {Uint8Array} update
+ * @param {import('./meta.js').ContentIds} contentIds - Pattern specifying which content to include
+ * @param {typeof UpdateDecoderV1 | typeof UpdateDecoderV2} [YDecoder]
+ * @param {typeof UpdateEncoderV1 | typeof UpdateEncoderV2} [YEncoder]
+ * @return {Uint8Array}
+ */
+export const intersectUpdateWithContentIdsV2 = (update, contentIds, YDecoder = UpdateDecoderV2, YEncoder = UpdateEncoderV2) => {
+  const { inserts, deletes } = contentIds
+  const encoder = new YEncoder()
+  const lazyStructWriter = new LazyStructWriter(encoder)
+  const decoder = new YDecoder(decoding.createDecoder(update))
+  const reader = new LazyStructReader(decoder, true)
+
+  while (reader.curr) {
+    const currClientId = reader.curr.id.client
+    let nextClock = reader.curr.id.clock
+    let firstWrite = false
+    while (reader.curr != null && reader.curr.id.client === currClientId) {
+      const curr = reader.curr
+      for (const slice of inserts.slice(currClientId, nextClock, curr.length)) {
+        if (slice.exists) {
+          const skipLen = slice.clock - nextClock
+          if (skipLen > 0 && firstWrite) {
+            // write missing skip
+            writeStructToLazyStructWriter(lazyStructWriter, new Skip(createID(currClientId, nextClock), skipLen), 0, 0)
+          }
+          // write sliced content
+          writeStructToLazyStructWriter(lazyStructWriter, curr, slice.clock - curr.id.clock, (curr.id.clock + curr.length) - (slice.clock + slice.len))
+          nextClock = slice.clock + slice.len
+          firstWrite = true
+        }
+      }
+      reader.next()
+    }
+  }
+  finishLazyStructWriting(lazyStructWriter)
+  // Filter the delete set to only include entries in contentIds.deletes
+  const ds = readIdSet(decoder)
+  const filteredDs = idset.intersectSets(ds, deletes)
+  writeIdSet(encoder, filteredDs)
+  return encoder.toUint8Array()
+}
+
+/**
+ * Filter an update (V1 format) to only include content specified by a ContentIds pattern.
+ *
+ * @param {Uint8Array} update
+ * @param {import('./meta.js').ContentIds} contentIds - Pattern specifying which content to include
+ * @return {Uint8Array}
+ */
+export const intersectUpdateWithContentIds = (update, contentIds) =>
+  intersectUpdateWithContentIdsV2(update, contentIds, UpdateDecoderV1, UpdateEncoderV1)
+
+/**
+ * @param {Uint8Array} update
+ */
+export const createDocFromUpdate = update => {
+  const ydoc = new Doc()
+  applyUpdate(ydoc, update)
+  return ydoc
+}
+
+/**
+ * @param {Uint8Array} update
+ */
+export const createDocFromUpdateV2 = update => {
+  const ydoc = new Doc()
+  applyUpdateV2(ydoc, update)
+  return ydoc
+}