Introduce basic architecture to support undo and redo

src/document/change/change.ts

@@ -22,10 +22,12 @@ import {
 import { CRDTRoot } from '@yorkie-js-sdk/src/document/crdt/root';
 import { ChangeID } from '@yorkie-js-sdk/src/document/change/change_id';
 import { Indexable } from '@yorkie-js-sdk/src/document/document';
+import { HistoryOperation } from '@yorkie-js-sdk/src/document/history';
 import {
   PresenceChange,
   PresenceChangeType,
 } from '@yorkie-js-sdk/src/document/presence/presence';
+import { deepcopy } from '@yorkie-js-sdk/src/util/object';
 
 /**
  * `Change` represents a unit of modification in the document.
@@ -135,21 +137,31 @@ export class Change<P extends Indexable> {
   public execute(
     root: CRDTRoot,
     presences: Map<ActorID, P>,
-  ): Array<OperationInfo> {
-    const opInfos: Array<OperationInfo> = [];
+  ): {
+    opInfos: Array<OperationInfo>;
+    reverseOps: Array<HistoryOperation<P>>;
+  } {
+    const changeOpInfos: Array<OperationInfo> = [];
+    const reverseOps: Array<HistoryOperation<P>> = [];
     for (const operation of this.operations) {
-      const infos = operation.execute(root);
-      opInfos.push(...infos);
+      const { opInfos, reverseOp } = operation.execute(root);
+      changeOpInfos.push(...opInfos);
+      if (reverseOp) {
+        reverseOps.unshift(reverseOp);
+      }
     }
 
     if (this.presenceChange) {
       if (this.presenceChange.type === PresenceChangeType.Put) {
-        presences.set(this.id.getActorID()!, this.presenceChange.presence);
+        presences.set(
+          this.id.getActorID()!,
+          deepcopy(this.presenceChange.presence),
+        );
       } else {
         presences.delete(this.id.getActorID()!);
       }
     }
-    return opInfos;
+    return { opInfos: changeOpInfos, reverseOps };
   }
 
   /**

src/document/change/context.ts

@@ -29,6 +29,7 @@ import { ChangeID } from '@yorkie-js-sdk/src/document/change/change_id';
 import { Change } from '@yorkie-js-sdk/src/document/change/change';
 import { PresenceChange } from '@yorkie-js-sdk/src/document/presence/presence';
 import { Indexable } from '@yorkie-js-sdk/src/document/document';
+import { deepcopy } from '@yorkie-js-sdk/src/util/object';
 
 /**
  * `ChangeContext` is used to record the context of modification when editing
@@ -37,19 +38,35 @@ import { Indexable } from '@yorkie-js-sdk/src/document/document';
  */
 export class ChangeContext<P extends Indexable = Indexable> {
   private id: ChangeID;
+  private delimiter: number;
+  private message?: string;
+
   private root: CRDTRoot;
   private operations: Array<Operation>;
   private presenceChange?: PresenceChange<P>;
-  private message?: string;
-  private delimiter: number;
 
-  constructor(id: ChangeID, root: CRDTRoot, message?: string) {
+  /**
+   * `previousPresence` stores the previous presence to be used for undoing
+   * presence changes.
+   */
+  private previousPresence: P;
+
+  /**
+   * `reversePresenceKeys` stores the keys of the presence to be used for undoing
+   * presence changes.
+   */
+  private reversePresenceKeys: Set<string>;
+
+  constructor(id: ChangeID, root: CRDTRoot, presence: P, message?: string) {
     this.id = id;
+    this.delimiter = InitialDelimiter;
+
     this.root = root;
     this.operations = [];
+    this.previousPresence = deepcopy(presence);
     this.presenceChange = undefined;
+    this.reversePresenceKeys = new Set();
     this.message = message;
-    this.delimiter = InitialDelimiter;
   }
 
   /**
@@ -58,9 +75,10 @@ export class ChangeContext<P extends Indexable = Indexable> {
   public static create<P extends Indexable>(
     id: ChangeID,
     root: CRDTRoot,
+    presence: P,
     message?: string,
   ): ChangeContext<P> {
-    return new ChangeContext(id, root, message);
+    return new ChangeContext(id, root, presence, message);
   }
 
   /**
@@ -118,6 +136,35 @@ export class ChangeContext<P extends Indexable = Indexable> {
     this.presenceChange = presenceChange;
   }
 
+  /**
+   * `setReversePresence` registers the previous presence to undo presence updates.
+   */
+  public setReversePresence(
+    presence: Partial<P>,
+    option?: { addToHistory: boolean },
+  ) {
+    for (const key of Object.keys(presence)) {
+      if (option?.addToHistory) {
+        this.reversePresenceKeys.add(key);
+      } else {
+        this.reversePresenceKeys.delete(key);
+      }
+    }
+  }
+
+  /**
+   * `getReversePresence` returns the reverse presence of this context.
+   */
+  public getReversePresence() {
+    if (this.reversePresenceKeys.size === 0) return undefined;
+
+    const reversePresence: Partial<P> = {};
+    for (const key of this.reversePresenceKeys) {
+      reversePresence[key as keyof P] = this.previousPresence[key];
+    }
+    return reversePresence;
+  }
+
   /**
    * `issueTimeTicket` creates a time ticket to be used to create a new operation.
    */