13.6.6

fix equalDeleteSets

README.md

@@ -91,6 +91,7 @@ are implemented in separate modules.
 | [CodeMirror](https://codemirror.net/) | ✔ | [y-codemirror](https://github.com/yjs/y-codemirror) | [demo](https://demos.yjs.dev/codemirror/codemirror.html) |
 | [Monaco](https://microsoft.github.io/monaco-editor/) | ✔ | [y-monaco](https://github.com/yjs/y-monaco) | [demo](https://demos.yjs.dev/monaco/monaco.html) |
 | [Slate](https://github.com/ianstormtaylor/slate) | ✔ | [slate-yjs](https://github.com/bitphinix/slate-yjs) | [demo](https://bitphinix.github.io/slate-yjs-example) |
+| [BlockSuite](https://github.com/toeverything/blocksuite) | ✔ | (native) | [demo](https://blocksuite-toeverything.vercel.app/?init) |
 | [valtio](https://github.com/pmndrs/valtio) |  | [valtio-yjs](https://github.com/dai-shi/valtio-yjs) | [demo](https://codesandbox.io/s/valtio-yjs-demo-ox3iy) |
 | [immer](https://github.com/immerjs/immer) |  | [immer-yjs](https://github.com/sep2/immer-yjs) | [demo](https://codesandbox.io/s/immer-yjs-demo-6e0znb) |
 | React / Vue / Svelte / MobX | | [SyncedStore](https://syncedstore.org) | [demo](https://syncedstore.org/docs/react) |

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "yjs",
-  "version": "13.6.4",
+  "version": "13.6.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "yjs",
-      "version": "13.6.4",
+      "version": "13.6.6",
       "license": "MIT",
       "dependencies": {
         "lib0": "^0.2.74"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "yjs",
-  "version": "13.6.4",
+  "version": "13.6.6",
   "description": "Shared Editing Library",
   "main": "./dist/yjs.cjs",
   "module": "./dist/yjs.mjs",

src/structs/ContentFormat.js

@@ -1,6 +1,6 @@
 
 import {
-  AbstractType, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Item, StructStore, Transaction // eslint-disable-line
+  YText, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Item, StructStore, Transaction // eslint-disable-line
 } from '../internals.js'
 
 import * as error from 'lib0/error'
@@ -47,28 +47,30 @@ export class ContentFormat {
   }
 
   /**
-   * @param {number} offset
+   * @param {number} _offset
    * @return {ContentFormat}
    */
-  splice (offset) {
+  splice (_offset) {
     throw error.methodUnimplemented()
   }
 
   /**
-   * @param {ContentFormat} right
+   * @param {ContentFormat} _right
    * @return {boolean}
    */
-  mergeWith (right) {
+  mergeWith (_right) {
     return false
   }
 
   /**
-   * @param {Transaction} transaction
+   * @param {Transaction} _transaction
    * @param {Item} item
    */
-  integrate (transaction, item) {
+  integrate (_transaction, item) {
     // @todo searchmarker are currently unsupported for rich text documents
-    /** @type {AbstractType<any>} */ (item.parent)._searchMarker = null
+    const p = /** @type {YText} */ (item.parent)
+    p._searchMarker = null
+    p._hasFormatting = true
   }
 
   /**

src/types/YText.js

@@ -505,7 +505,7 @@ export const cleanupYTextAfterTransaction = transaction => {
   // cleanup in a new transaction
   transact(doc, (t) => {
     iterateDeletedStructs(transaction, transaction.deleteSet, item => {
-      if (item instanceof GC || needFullCleanup.has(/** @type {YText} */ (item.parent))) {
+      if (item instanceof GC || !(/** @type {YText} */ (item.parent)._hasFormatting) || needFullCleanup.has(/** @type {YText} */ (item.parent))) {
         return
       }
       const parent = /** @type {YText} */ (item.parent)
@@ -859,9 +859,14 @@ export class YText extends AbstractType {
      */
     this._pending = string !== undefined ? [() => this.insert(0, string)] : []
     /**
-     * @type {Array<ArraySearchMarker>}
+     * @type {Array<ArraySearchMarker>|null}
      */
     this._searchMarker = []
+    /**
+     * Whether this YText contains formatting attributes.
+     * This flag is updated when a formatting item is integrated (see ContentFormat.integrate)
+     */
+    this._hasFormatting = false
   }
 
   /**
@@ -911,7 +916,7 @@ export class YText extends AbstractType {
     const event = new YTextEvent(this, transaction, parentSubs)
     callTypeObservers(this, transaction, event)
     // If a remote change happened, we try to cleanup potential formatting duplicates.
-    if (!transaction.local) {
+    if (!transaction.local && this._hasFormatting) {
       transaction._needFormattingCleanup = true
     }
   }

src/utils/DeleteSet.js

@@ -335,7 +335,7 @@ export const readAndApplyDeleteSet = (decoder, transaction, store) => {
  */
 export const equalDeleteSets = (ds1, ds2) => {
   if (ds1.clients.size !== ds2.clients.size) return false
-  ds1.clients.forEach((deleteItems1, client) => {
+  for (const [client, deleteItems1] of ds1.clients.entries()) {
     const deleteItems2 = /** @type {Array<import('../internals.js').DeleteItem>} */ (ds2.clients.get(client))
     if (deleteItems2 === undefined || deleteItems1.length !== deleteItems2.length) return false
     for (let i = 0; i < deleteItems1.length; i++) {
@@ -345,6 +345,6 @@ export const equalDeleteSets = (ds1, ds2) => {
         return false
       }
     }
-  })
+  }
   return true
 }

src/utils/Transaction.js

@@ -275,30 +275,30 @@ const cleanupTransactions = (transactionCleanups, i) => {
       )
       fs.push(() => {
         // deep observe events
-        transaction.changedParentTypes.forEach((events, type) =>
+        transaction.changedParentTypes.forEach((events, type) => {
-          fs.push(() => {
+          // We need to think about the possibility that the user transforms the
-            // We need to think about the possibility that the user transforms the
+          // Y.Doc in the event.
-            // Y.Doc in the event.
+          if (type._dEH.l.length > 0 && (type._item === null || !type._item.deleted)) {
-            if (type._item === null || !type._item.deleted) {
+            events = events
-              events = events
+              .filter(event =>
-                .filter(event =>
+                event.target._item === null || !event.target._item.deleted
-                  event.target._item === null || !event.target._item.deleted
+              )
-                )
+            events
-              events
+              .forEach(event => {
-                .forEach(event => {
+                event.currentTarget = type
-                  event.currentTarget = type
+                // path is relative to the current target
-                })
+                event._path = null
-              // sort events by path length so that top-level events are fired first.
+              })
-              events
+            // sort events by path length so that top-level events are fired first.
-                .sort((event1, event2) => event1.path.length - event2.path.length)
+            events
-              // We don't need to check for events.length
+              .sort((event1, event2) => event1.path.length - event2.path.length)
-              // because we know it has at least one element
+            // We don't need to check for events.length
-              callEventHandlerListeners(type._dEH, events, transaction)
+            // because we know it has at least one element
-            }
+            callEventHandlerListeners(type._dEH, events, transaction)
-          })
+          }
-        )
+        })
-        fs.push(() => doc.emit('afterTransaction', [transaction, doc]))
       })
+      fs.push(() => doc.emit('afterTransaction', [transaction, doc]))
       callAll(fs, [])
       if (transaction._needFormattingCleanup) {
         cleanupYTextAfterTransaction(transaction)

tests/y-map.tests.js

@@ -337,6 +337,34 @@ export const testObserversUsingObservedeep = tc => {
   compare(users)
 }
 
+/**
+ * @param {t.TestCase} tc
+ */
+export const testPathsOfSiblingEvents = tc => {
+  const { users, map0 } = init(tc, { users: 2 })
+  /**
+   * @type {Array<Array<string|number>>}
+   */
+  const pathes = []
+  let calls = 0
+  const doc = users[0]
+  map0.set('map', new Y.Map())
+  map0.get('map').set('text1', new Y.Text('initial'))
+  map0.observeDeep(events => {
+    events.forEach(event => {
+      pathes.push(event.path)
+    })
+    calls++
+  })
+  doc.transact(() => {
+    map0.get('map').get('text1').insert(0, 'post-')
+    map0.get('map').set('text2', new Y.Text('new'))
+  })
+  t.assert(calls === 1)
+  t.compare(pathes, [['map'], ['map', 'text1']])
+  compare(users)
+}
+
 // TODO: Test events in Y.Map
 /**
  * @param {Object<string,any>} is