@yorkie-js/sdk 0.6.26 → 0.6.27

package/dist/yorkie-js-sdk.d.ts

@@ -115,16 +115,13 @@ declare interface AuthErrorEvent_2 extends BaseDocEvent_2 {
     };
 }
 
-/**
- * `BaseArray` is a base type of JSONArray.
- */
 declare type BaseArray<T> = JSONArray<T> | Array<T>;
 
 /* Excluded from this release type: BaseDocEvent */
 
 /* Excluded from this release type: BaseDocEvent_2 */
 
-declare type BaseObject<T> = JSONObject<T> | Record<string, T>;
+declare type BaseObject<T> = JSONObject<T> | T;
 
 declare interface BroadcastEvent extends BaseDocEvent {
     type: DocEventType_2.Broadcast;
@@ -2902,6 +2899,17 @@ declare class History_2<P extends Indexable> {
      * `getRedoStackForTest` returns the redo stack for test.
      */
     getRedoStackForTest(): Array<Array<HistoryOperation<P>>>;
+    /**
+     * `reconcileCreatedAt` updates the createdAt and prevCreatedAt fields.
+     *
+     * When an element is replaced(e.g., UndoRemove as Add, or Set),
+     * it receives a new createdAt(executedAt). However, existing history
+     * operations may still reference the old createdAt or prevCreatedAt.
+     *
+     * This method scans both undo/redo stacks and replaces any matching
+     * createdAt/prevCreatedAt with the new one, ensuring consistency.
+     */
+    reconcileCreatedAt(prevCreatedAt: TimeTicket, currCreatedAt: TimeTicket): void;
 }
 
 /**
@@ -3202,68 +3210,68 @@ export declare type JSONArray<T> = {
     /**
      * `getID` returns the ID, `TimeTicket` of this Object.
      */
-    getID?(): TimeTicket;
+    getID(): TimeTicket;
     /**
      * `getElementByID` returns the element for the given ID.
      */
-    getElementByID?(createdAt: TimeTicket): WrappedElement<T>;
+    getElementByID(createdAt: TimeTicket): WrappedElement<T>;
     /**
      * `getElementByIndex` returns the element for the given index.
      */
-    getElementByIndex?(index: number): WrappedElement<T>;
+    getElementByIndex(index: number): WrappedElement<T>;
     /**
      * `getLast` returns the last element of this array.
      */
-    getLast?(): WrappedElement<T>;
+    getLast(): WrappedElement<T>;
     /**
      * `setValue` sets the given value at the given index.
      */
-    setValue?(index: number, value: unknown): WrappedElement<T>;
+    setValue(index: number, value: unknown): WrappedElement<T>;
     /**
      * `delete` deletes the element of the given index.
      */
-    delete?(index: number): WrappedElement<T>;
+    delete(index: number): WrappedElement<T>;
     /**
      * `deleteByID` deletes the element of the given ID.
      */
-    deleteByID?(createdAt: TimeTicket): WrappedElement<T>;
+    deleteByID(createdAt: TimeTicket): WrappedElement<T>;
     /**
      * `insertBefore` inserts a value before the given next element.
      */
-    insertBefore?(nextID: TimeTicket, value: any): WrappedElement<T>;
+    insertBefore(nextID: TimeTicket, value: any): WrappedElement<T>;
     /**
      * `insertAfter` inserts a value after the given previous element.
      */
-    insertAfter?(prevID: TimeTicket, value: any): WrappedElement<T>;
+    insertAfter(prevID: TimeTicket, value: any): WrappedElement<T>;
     /**
      * `insertIntegerAfter` inserts a value after the given index.
      */
-    insertIntegerAfter?(index: number, value: number): WrappedElement<T>;
+    insertIntegerAfter(index: number, value: number): WrappedElement<T>;
     /**
      * `moveBefore` moves the element before the given next element.
      */
-    moveBefore?(nextID: TimeTicket, id: TimeTicket): void;
+    moveBefore(nextID: TimeTicket, id: TimeTicket): void;
     /**
      * `moveAfter` moves the element after the given previous element.
      */
-    moveAfter?(prevID: TimeTicket, id: TimeTicket): void;
+    moveAfter(prevID: TimeTicket, id: TimeTicket): void;
     /**
      * `moveAfterByIndex` moves the element after the given index.
      */
-    moveAfterByIndex?(prevIndex: number, targetIndex: number): void;
+    moveAfterByIndex(prevIndex: number, targetIndex: number): void;
     /**
      * `moveFront` moves the element before the first element.
      */
-    moveFront?(id: TimeTicket): void;
+    moveFront(id: TimeTicket): void;
     /**
      * `moveLast` moves the element after the last element.
      */
-    moveLast?(id: TimeTicket): void;
+    moveLast(id: TimeTicket): void;
     /**
      * `toTestString` returns a String containing the meta data of the node
      * for debugging purpose.
      */
-    toTestString?(): string;
+    toTestString(): string;
     /* Excluded from this release type: toJSForTest */
 } & Array<T>;
 
@@ -3349,15 +3357,15 @@ export declare type JSONObject<T> = {
     /**
      * `getID` returns the ID(time ticket) of this Object.
      */
-    getID?(): TimeTicket;
+    getID(): TimeTicket;
     /**
      * `toJSON` returns the JSON encoding of this object.
      */
-    toJSON?(): string;
+    toJSON(): string;
     /**
      * `toJS` returns the JSON object of this object.
      */
-    toJS?(): T;
+    toJS(): T;
     /* Excluded from this release type: toJSForTest */
 } & T;
 
@@ -3371,9 +3379,6 @@ declare type JsonPrimitive = string | number | boolean | null;
 
 declare type JsonPrimitive_2 = string | number | boolean | null;
 
-/**
- * `LeafElement` is a leaf element of JSONElement.
- */
 declare type LeafElement = PrimitiveValue | Primitive | Text_2 | Counter | Tree;
 
 /**

package/dist/yorkie-js-sdk.es.js

@@ -8232,6 +8232,12 @@ class CRDTElement {
     }
     return this.movedAt;
   }
+  /**
+   * `setCreatedAt` sets the creation time of this element manually.
+   */
+  setCreatedAt(createdAt) {
+    this.createdAt = createdAt;
+  }
   /**
    * `setMovedAt` sets the move time of this element.
    */
@@ -10930,6 +10936,12 @@ class AddOperation extends Operation {
   getValue() {
     return this.value;
   }
+  /**
+   * `setPrevCreatedAt` sets the creation time of the previous element.
+   */
+  setPrevCreatedAt(createdAt) {
+    this.prevCreatedAt = createdAt;
+  }
 }
 class RemoveOperation extends Operation {
   constructor(parentCreatedAt, createdAt, executedAt) {
@@ -11040,6 +11052,12 @@ class RemoveOperation extends Operation {
   getCreatedAt() {
     return this.createdAt;
   }
+  /**
+   * `setCreatedAt` sets the creation time of the target element.
+   */
+  setCreatedAt(createdAt) {
+    this.createdAt = createdAt;
+  }
 }
 class SetOperation extends Operation {
   constructor(key, value, parentCreatedAt, executedAt) {
@@ -11231,6 +11249,18 @@ class MoveOperation extends Operation {
   getCreatedAt() {
     return this.createdAt;
   }
+  /**
+   * `setPrevCreatedAt` sets the creation time of the previous element.
+   */
+  setPrevCreatedAt(createdAt) {
+    this.prevCreatedAt = createdAt;
+  }
+  /**
+   * `setCreatedAt` sets the creation time of the target element.
+   */
+  setCreatedAt(createdAt) {
+    this.createdAt = createdAt;
+  }
 }
 class RHTNode {
   constructor(key, value, updatedAt, isRemoved) {
@@ -16195,11 +16225,12 @@ class ArraySetOperation extends Operation {
         `fail to execute, only array can execute set`
       );
     }
+    const previousValue = parentObject.getByID(this.createdAt).deepcopy();
+    const reverseOp = this.toReverseOperation(this.value, previousValue);
     const value = this.value.deepcopy();
     parentObject.insertAfter(this.createdAt, value, this.getExecutedAt());
     parentObject.delete(this.createdAt, this.getExecutedAt());
     root.registerElement(value);
-    const reverseOp = void 0;
     return {
       opInfos: [
         {
@@ -16210,6 +16241,17 @@ class ArraySetOperation extends Operation {
       reverseOp
     };
   }
+  /**
+   * `toReverseOperation` returns the reverse operation of this operation.
+   */
+  toReverseOperation(newValue, prevValue) {
+    const reverseOp = ArraySetOperation.create(
+      this.getParentCreatedAt(),
+      newValue.getCreatedAt(),
+      prevValue
+    );
+    return reverseOp;
+  }
   /**
    * `getEffectedCreatedAt` returns the creation time of the effected element.
    */
@@ -16234,6 +16276,12 @@ class ArraySetOperation extends Operation {
   getValue() {
     return this.value;
   }
+  /**
+   * `setCreatedAt` sets the creation time of the target element.
+   */
+  setCreatedAt(createdAt) {
+    this.createdAt = createdAt;
+  }
 }
 function toPresence(presence) {
   const pbPresence = new Presence$1();
@@ -17483,7 +17531,7 @@ function uuid() {
   });
 }
 class Attachment {
-  constructor(reconnectStreamDelay, doc, docID, syncMode, unsubscribeBroacastEvent) {
+  constructor(reconnectStreamDelay, doc, docID, syncMode, unsubscribeBroadcastEvent) {
     // TODO(hackerwins): Consider to changing the modifiers of the following properties to private.
     __publicField(this, "reconnectStreamDelay");
     __publicField(this, "doc");
@@ -17501,7 +17549,7 @@ class Attachment {
     this.syncMode = syncMode;
     this.remoteChangeEventReceived = false;
     this.cancelled = false;
-    this.unsubscribeBroadcastEvent = unsubscribeBroacastEvent;
+    this.unsubscribeBroadcastEvent = unsubscribeBroadcastEvent;
   }
   /**
    * `changeSyncMode` changes the sync mode of the document.
@@ -20157,6 +20205,32 @@ class History {
   getRedoStackForTest() {
     return this.redoStack;
   }
+  /**
+   * `reconcileCreatedAt` updates the createdAt and prevCreatedAt fields.
+   *
+   * When an element is replaced(e.g., UndoRemove as Add, or Set),
+   * it receives a new createdAt(executedAt). However, existing history
+   * operations may still reference the old createdAt or prevCreatedAt.
+   *
+   * This method scans both undo/redo stacks and replaces any matching
+   * createdAt/prevCreatedAt with the new one, ensuring consistency.
+   */
+  reconcileCreatedAt(prevCreatedAt, currCreatedAt) {
+    const replace = (stack) => {
+      for (const ops of stack) {
+        for (const op of ops) {
+          if ((op instanceof ArraySetOperation || op instanceof RemoveOperation || op instanceof MoveOperation) && op.getCreatedAt() === prevCreatedAt) {
+            op.setCreatedAt(currCreatedAt);
+          }
+          if ((op instanceof AddOperation || op instanceof MoveOperation) && op.getPrevCreatedAt() === prevCreatedAt) {
+            op.setPrevCreatedAt(currCreatedAt);
+          }
+        }
+      }
+    };
+    replace(this.undoStack);
+    replace(this.redoStack);
+  }
 }
 const EventSourceDevPanel = "yorkie-devtools-panel";
 const EventSourceSDK = "yorkie-devtools-sdk";
@@ -20419,6 +20493,14 @@ class Document {
         this.presences,
         OpSource.Local
       );
+      for (const op of change.getOperations()) {
+        if (op instanceof ArraySetOperation) {
+          this.internalHistory.reconcileCreatedAt(
+            op.getCreatedAt(),
+            op.getValue().getCreatedAt()
+          );
+        }
+      }
       const reversePresence = context.getReversePresence();
       if (reversePresence) {
         reverseOps.push({
@@ -21375,6 +21457,15 @@ class Document {
       }
       const ticket = context.issueTimeTicket();
       undoOp.setExecutedAt(ticket);
+      if (undoOp instanceof ArraySetOperation) {
+        const prev = undoOp.getCreatedAt();
+        undoOp.getValue().setCreatedAt(ticket);
+        this.internalHistory.reconcileCreatedAt(prev, ticket);
+      } else if (undoOp instanceof AddOperation) {
+        const prev = undoOp.getValue().getCreatedAt();
+        undoOp.getValue().setCreatedAt(ticket);
+        this.internalHistory.reconcileCreatedAt(prev, ticket);
+      }
       context.push(undoOp);
     }
     const change = context.toChange();
@@ -21462,6 +21553,15 @@ class Document {
       }
       const ticket = context.issueTimeTicket();
       redoOp.setExecutedAt(ticket);
+      if (redoOp instanceof ArraySetOperation) {
+        const prev = redoOp.getCreatedAt();
+        redoOp.getValue().setCreatedAt(ticket);
+        this.internalHistory.reconcileCreatedAt(prev, ticket);
+      } else if (redoOp instanceof AddOperation) {
+        const prev = redoOp.getValue().getCreatedAt();
+        redoOp.getValue().setCreatedAt(ticket);
+        this.internalHistory.reconcileCreatedAt(prev, ticket);
+      }
       context.push(redoOp);
     }
     const change = context.toChange();
@@ -21564,7 +21664,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name = "@yorkie-js/sdk";
-const version = "0.6.26";
+const version = "0.6.27";
 const pkg = {
   name,
   version