@fluidframework/sequence 2.33.0-333010 → 2.33.0

package/lib/intervalCollection.js

@@ -109,7 +109,7 @@ export class LocalIntervalCollection {
         this.removeIntervalFromIndexes(interval);
         this.removeIntervalListeners(interval);
     }
-    addInterval(id, start, end, props, op) {
+    addInterval(id, start, end, props, op, rollback) {
         // This check is intended to prevent scenarios where a random interval is created and then
         // inserted into a collection. The aim is to ensure that the collection is created first
         // then the user can create/add intervals based on the collection
@@ -117,7 +117,7 @@ export class LocalIntervalCollection {
             props[reservedRangeLabelsKey][0] !== this.label) {
             throw new LoggingError("Adding an interval that belongs to another interval collection is not permitted");
         }
-        const interval = createSequenceInterval(this.label, id, start, end, this.client, IntervalType.SlideOnRemove, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint, props);
+        const interval = createSequenceInterval(this.label, id, start, end, this.client, IntervalType.SlideOnRemove, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint, props, rollback);
         this.add(interval);
         return interval;
     }
@@ -255,6 +255,54 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         return true;
     }
+    rollback(op, localOpMetadata) {
+        const { opName, value } = op;
+        const { id, properties } = getSerializedProperties(value);
+        const { localSeq, previous } = localOpMetadata;
+        switch (opName) {
+            case "add": {
+                const interval = this.getIntervalById(id);
+                if (interval) {
+                    this.deleteExistingInterval({ interval, local: true, rollback: true });
+                }
+                break;
+            }
+            case "change": {
+                assert(previous !== undefined, 0xb7c /* must have previous for change */);
+                const endpointsChanged = value.start !== undefined && value.end !== undefined;
+                const start = endpointsChanged
+                    ? toOptionalSequencePlace(previous.start, previous.startSide)
+                    : undefined;
+                const end = endpointsChanged
+                    ? toOptionalSequencePlace(previous.end, previous.endSide)
+                    : undefined;
+                this.change(id, {
+                    start,
+                    end,
+                    props: Object.keys(properties).length > 0 ? properties : undefined,
+                    rollback: true,
+                });
+                this.localSeqToSerializedInterval.delete(localSeq);
+                if (endpointsChanged) {
+                    this.removePendingChange(value);
+                }
+                break;
+            }
+            case "delete": {
+                assert(previous !== undefined, 0xb7d /* must have previous for delete */);
+                this.add({
+                    id,
+                    start: toSequencePlace(previous.start, previous.startSide),
+                    end: toSequencePlace(previous.end, previous.endSide),
+                    props: Object.keys(properties).length > 0 ? properties : undefined,
+                    rollback: true,
+                });
+                break;
+            }
+            default:
+                unreachableCase(opName);
+        }
+    }
     process(op, local, message, localOpMetadata) {
         const { opName, value } = op;
         switch (opName) {
@@ -422,7 +470,7 @@ export class IntervalCollection extends TypedEventEmitter {
     /**
      * {@inheritdoc IIntervalCollection.add}
      */
-    add({ id, start, end, props, }) {
+    add({ id, start, end, props, rollback, }) {
         if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to adding intervals");
         }
@@ -432,7 +480,7 @@ export class IntervalCollection extends TypedEventEmitter {
             startSide !== undefined &&
             endSide !== undefined, 0x793 /* start and end cannot be undefined because they were not passed in as undefined */);
         this.assertStickinessEnabled(start, end);
-        const interval = this.localCollection.addInterval(id ?? uuid(), toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), props);
+        const interval = this.localCollection.addInterval(id ?? uuid(), toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), props, undefined, rollback);
         if (interval) {
             if (!this.isCollaborating) {
                 setSlideOnRemove(interval.start);
@@ -440,20 +488,20 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             const serializedInterval = interval.serialize();
             const localSeq = this.getNextLocalSeq();
-            if (this.isCollaborating) {
+            if (this.isCollaborating && rollback !== true) {
                 this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
+                this.submitDelta({
+                    opName: "add",
+                    value: serializedInterval,
+                }, {
+                    localSeq,
+                });
             }
-            this.submitDelta({
-                opName: "add",
-                value: serializedInterval,
-            }, {
-                localSeq,
-            });
         }
         this.emit("addInterval", interval, true, undefined);
         return interval;
     }
-    deleteExistingInterval(interval, local, op) {
+    deleteExistingInterval({ interval, local, op, rollback, }) {
         if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
@@ -461,12 +509,13 @@ export class IntervalCollection extends TypedEventEmitter {
         this.localCollection.removeExistingInterval(interval);
         if (interval) {
             // Local ops get submitted to the server. Remote ops have the deserializer run.
-            if (local) {
+            if (local && rollback !== true) {
                 this.submitDelta({
                     opName: "delete",
                     value: interval.serialize(),
                 }, {
                     localSeq: this.getNextLocalSeq(),
+                    previous: interval.serialize(),
                 });
             }
             else {
@@ -486,14 +535,14 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
         if (interval) {
-            this.deleteExistingInterval(interval, true, undefined);
+            this.deleteExistingInterval({ interval, local: true });
         }
         return interval;
     }
     /**
      * {@inheritdoc IIntervalCollection.change}
      */
-    change(id, { start, end, props }) {
+    change(id, { start, end, props, rollback, }) {
         if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
@@ -515,7 +564,7 @@ export class IntervalCollection extends TypedEventEmitter {
             let deltaProps;
             let newInterval;
             if (props !== undefined) {
-                deltaProps = interval.changeProperties(props);
+                deltaProps = interval.changeProperties(props, undefined, rollback);
             }
             const changeEndpoints = start !== undefined && end !== undefined;
             if (changeEndpoints) {
@@ -525,27 +574,25 @@ export class IntervalCollection extends TypedEventEmitter {
                     setSlideOnRemove(newInterval.end);
                 }
             }
-            // Emit a property bag containing the ID and the other (if any) properties changed
-            const serializedInterval = (newInterval ?? interval).serializeDelta({
-                props,
-                includeEndpoints: changeEndpoints,
-            });
-            const localSeq = this.getNextLocalSeq();
-            if (this.isCollaborating) {
+            if (this.isCollaborating && rollback !== true) {
+                // Emit a property bag containing the ID and the other (if any) properties changed
+                const serializedInterval = (newInterval ?? interval).serializeDelta({ props, includeEndpoints: changeEndpoints });
+                const localSeq = this.getNextLocalSeq();
                 this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
+                this.addPendingChange(id, serializedInterval);
+                this.submitDelta({
+                    opName: "change",
+                    value: serializedInterval,
+                }, {
+                    localSeq,
+                    previous: interval.serialize(),
+                });
             }
-            this.submitDelta({
-                opName: "change",
-                value: serializedInterval,
-            }, {
-                localSeq,
-            });
             if (deltaProps !== undefined) {
                 this.emit("propertyChanged", interval, deltaProps, true, undefined);
                 this.emit("changed", newInterval ?? interval, deltaProps, newInterval ? interval : undefined, true, false);
             }
             if (newInterval) {
-                this.addPendingChange(id, serializedInterval);
                 this.emitChange(newInterval, interval, true, false);
                 this.client?.removeLocalReferencePosition(interval.start);
                 this.client?.removeLocalReferencePosition(interval.end);
@@ -841,7 +888,7 @@ export class IntervalCollection extends TypedEventEmitter {
         const { id } = getSerializedProperties(serializedInterval);
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
         if (interval) {
-            this.deleteExistingInterval(interval, local, op);
+            this.deleteExistingInterval({ interval, local, op });
         }
     }
     serializeInternal(version) {