imp(): tests improved, lint fix

Author: Егор Коновалов

packages/collaboration-manager/src/BatchedOperation.spec.ts

@@ -159,5 +159,14 @@ describe('Batch', () => {
 
       expect(batch.canAdd(op2)).toBe(false);
     });
+
+    it('should return false when payload is a multi-character string', () => {
+      const op1 = new Operation(OperationType.Insert, templateIndex, { payload: 'a' }, userId);
+      const op2 = new Operation(OperationType.Insert, createIndexByRange([1, 1]), { payload: 'bc' }, userId);
+
+      const batch = new BatchedOperation(op1);
+
+      expect(batch.canAdd(op2)).toBe(false);
+    });
   });
 });

packages/collaboration-manager/src/BatchedOperation.ts

@@ -56,7 +56,7 @@ export class BatchedOperation<T extends OperationType = OperationType> extends O
         batch.add(Operation.from(op));
       });
 
-      return batch as BatchedOperation<T>;
+      return batch;
     } else {
       const batch = new BatchedOperation<T>(Operation.from(opBatchOrJSON));
 
@@ -90,7 +90,7 @@ export class BatchedOperation<T extends OperationType = OperationType> extends O
     this.operations.toReversed().slice(1)
       .map(op => newBatchedOperation.add(op.inverse()));
 
-    return newBatchedOperation as BatchedOperation<InvertedOperationType<T>>;
+    return newBatchedOperation;
   }
 
   /**
@@ -130,6 +130,9 @@ export class BatchedOperation<T extends OperationType = OperationType> extends O
       return true;
     }
 
+    /**
+     * @todo - implement other index types
+     */
     if (!op.index.isTextIndex || !lastOp.index.isTextIndex) {
       return false;
     }

packages/collaboration-manager/src/CollaborationManager.spec.ts

@@ -3,8 +3,10 @@ import { createDataKey, IndexBuilder } from '@editorjs/model';
 import { EditorJSModel } from '@editorjs/model';
 import type { CoreConfig } from '@editorjs/sdk';
 import { beforeAll, jest } from '@jest/globals';
+import { BatchedOperation } from './BatchedOperation.js';
 import { CollaborationManager } from './CollaborationManager.js';
 import { Operation, OperationType } from './Operation.js';
+import { UndoRedoManager } from './UndoRedoManager.js';
 
 const userId = 'user';
 const documentId = 'document';
@@ -228,6 +230,82 @@ describe('CollaborationManager', () => {
       });
     });
 
+    it('should not change the model when applying Neutral operation', () => {
+      const model = new EditorJSModel(userId, { identifier: documentId });
+
+      model.initializeDocument({
+        blocks: [ {
+          name: 'paragraph',
+          data: {
+            text: {
+              value: 'hello',
+              $t: 't',
+            },
+          },
+        } ],
+      });
+      const collaborationManager = new CollaborationManager(config as Required<CoreConfig>, model);
+      const index = new IndexBuilder().addBlockIndex(0)
+        .addDataKey(createDataKey('text'))
+        .addTextRange([0, 5])
+        .build();
+      const operation = new Operation(OperationType.Neutral, index, {
+        payload: [],
+      }, userId);
+
+      const before = model.serialized;
+
+      collaborationManager.applyOperation(operation);
+
+      expect(model.serialized).toStrictEqual(before);
+    });
+
+    it('should apply every operation when applying BatchedOperation', () => {
+      const model = new EditorJSModel(userId, { identifier: documentId });
+
+      model.initializeDocument({
+        blocks: [ {
+          name: 'paragraph',
+          data: {
+            text: {
+              value: '',
+              $t: 't',
+            },
+          },
+        } ],
+      });
+      const collaborationManager = new CollaborationManager(config as Required<CoreConfig>, model);
+      const op1 = new Operation(OperationType.Insert, new IndexBuilder().addBlockIndex(0)
+        .addDataKey(createDataKey('text'))
+        .addTextRange([0, 0])
+        .build(), { payload: 'a' }, userId);
+      const op2 = new Operation(OperationType.Insert, new IndexBuilder().addBlockIndex(0)
+        .addDataKey(createDataKey('text'))
+        .addTextRange([1, 1])
+        .build(), { payload: 'b' }, userId);
+      const batch = new BatchedOperation(op1);
+
+      batch.add(op2);
+
+      collaborationManager.applyOperation(batch);
+
+      expect(model.serialized).toStrictEqual({
+        identifier: documentId,
+        blocks: [ {
+          name: 'paragraph',
+          tunes: {},
+          data: {
+            text: {
+              $t: 't',
+              value: 'ab',
+              fragments: [],
+            },
+          },
+        } ],
+        properties: {},
+      });
+    });
+
     it('should unformat text on apply Modify Operation', () => {
       const model = new EditorJSModel(userId, { identifier: documentId });
 
@@ -946,6 +1024,38 @@ describe('CollaborationManager', () => {
     });
   });
 
+  describe('debounce', () => {
+    it('should move the open batch to the undo stack after the debounce delay', () => {
+      const putSpy = jest.spyOn(UndoRedoManager.prototype, 'put');
+
+      const model = new EditorJSModel(userId, { identifier: documentId });
+
+      model.initializeDocument({
+        blocks: [ {
+          name: 'paragraph',
+          data: {
+            text: {
+              value: '',
+              $t: 't',
+            },
+          },
+        } ],
+      });
+      void new CollaborationManager(config as Required<CoreConfig>, model);
+
+      model.insertText(userId, 0, createDataKey('text'), 'a', 0);
+
+      expect(putSpy).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(500);
+
+      expect(putSpy).toHaveBeenCalledTimes(1);
+      expect(putSpy.mock.calls[0][0]).toBeInstanceOf(BatchedOperation);
+
+      putSpy.mockRestore();
+    });
+  });
+
   describe('remote operations', () => {
     it('should transform current batch when remote operation arrives', () => {
       const model = new EditorJSModel(userId, { identifier: documentId });
@@ -1006,6 +1116,47 @@ describe('CollaborationManager', () => {
       });
     });
 
+    it('should transform undo stack when remote user edits arrive through model events', () => {
+      const model = new EditorJSModel(userId, { identifier: documentId });
+
+      model.initializeDocument({
+        blocks: [ {
+          name: 'paragraph',
+          data: {
+            text: {
+              value: '',
+              $t: 't',
+            },
+          },
+        } ],
+      });
+
+      const collaborationManager = new CollaborationManager(config as Required<CoreConfig>, model);
+
+      model.insertText(userId, 0, createDataKey('text'), 'world', 0);
+      jest.advanceTimersByTime(500);
+
+      model.insertText('remote-user', 0, createDataKey('text'), 'hello', 0);
+
+      collaborationManager.undo();
+
+      expect(model.serialized).toStrictEqual({
+        identifier: documentId,
+        blocks: [ {
+          name: 'paragraph',
+          tunes: {},
+          data: {
+            text: {
+              $t: 't',
+              value: 'hello',
+              fragments: [],
+            },
+          },
+        } ],
+        properties: {},
+      });
+    });
+
     it('should clear current batch if not transformable with remote operation', () => {
       const model = new EditorJSModel(userId, { identifier: documentId });
 

packages/collaboration-manager/src/CollaborationManager.ts

@@ -31,7 +31,8 @@ export class CollaborationManager {
   #undoRedoManager: UndoRedoManager;
 
   /**
-   * Flag to control whether events should be handled to avoid putting operations to the stack on undo/redo. Used for preventing operations infinity loop on undo/redo
+   * Flag to control whether events should be handled to avoid putting operations to the stack on undo/redo.
+   * Used for preventing operations infinity loop on undo/redo
    */
   #shouldHandleEvents = true;
 
@@ -98,7 +99,7 @@ export class CollaborationManager {
    * Undo last operation in the local stack
    */
   public undo(): void {
-    this.#moveBatchToUndo();
+    this.#putBatchToUndo();
 
     const operation = this.#undoRedoManager.undo();
 
@@ -119,7 +120,7 @@ export class CollaborationManager {
    * Redo last undone operation in the local stack
    */
   public redo(): void {
-    this.#moveBatchToUndo();
+    this.#putBatchToUndo();
 
     const operation = this.#undoRedoManager.redo();
 
@@ -265,7 +266,7 @@ export class CollaborationManager {
      * If current operation could not be added to the batch, then terminate current batch and create a new one with current operation
      */
     if (!this.#currentBatch.canAdd(operation)) {
-      this.#moveBatchToUndo();
+      this.#putBatchToUndo();
 
       this.#currentBatch = new BatchedOperation(operation);
       this.#debounce();
@@ -280,7 +281,7 @@ export class CollaborationManager {
   /**
    * Puts current batch to the undo stack and clears the batch
    */
-  #moveBatchToUndo(): void {
+  #putBatchToUndo(): void {
     if (this.#currentBatch !== null) {
       this.#undoRedoManager.put(this.#currentBatch);
 
@@ -289,13 +290,13 @@ export class CollaborationManager {
   }
 
   /**
-   * Debouneces timer of #moveBatchToUndo method
+   * Debouneces timer of #putBatchToUndo method
    */
   #debounce(): void {
     clearTimeout(this.#debounceTimer);
 
     this.#debounceTimer = setTimeout(() => {
-      this.#moveBatchToUndo();
+      this.#putBatchToUndo();
     }, DEBOUCE_TIMEOUT);
   }
 }