@fluidframework/sequence 2.32.0 → 2.33.0

package/dist/intervalCollection.js

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.opsMap = exports.LocalIntervalCollection = exports.computeStickinessFromSide = exports.toOptionalSequencePlace = exports.toSequencePlace = exports.sidesFromStickiness = void 0;
+exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.LocalIntervalCollection = exports.computeStickinessFromSide = exports.toOptionalSequencePlace = exports.toSequencePlace = exports.sidesFromStickiness = void 0;
 /* eslint-disable no-bitwise */
 const client_utils_1 = require("@fluid-internal/client-utils");
 const internal_1 = require("@fluidframework/core-utils/internal");
@@ -116,7 +116,7 @@ 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
@@ -124,7 +124,7 @@ class LocalIntervalCollection {
             props[internal_2.reservedRangeLabelsKey][0] !== this.label) {
             throw new internal_3.LoggingError("Adding an interval that belongs to another interval collection is not permitted");
         }
-        const interval = (0, index_js_2.createSequenceInterval)(this.label, id, start, end, this.client, index_js_2.IntervalType.SlideOnRemove, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint, props);
+        const interval = (0, index_js_2.createSequenceInterval)(this.label, id, start, end, this.client, index_js_2.IntervalType.SlideOnRemove, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint, props, rollback);
         this.add(interval);
         return interval;
     }
@@ -197,51 +197,6 @@ class LocalIntervalCollection {
     }
 }
 exports.LocalIntervalCollection = LocalIntervalCollection;
-const rebase = (collection, op, localOpMetadata) => {
-    const { localSeq } = localOpMetadata;
-    const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
-    if (rebasedValue === undefined) {
-        return undefined;
-    }
-    const rebasedOp = { ...op, value: rebasedValue };
-    return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
-};
-exports.opsMap = {
-    [index_js_2.IntervalDeltaOpType.ADD]: {
-        process: (collection, params, local, op, localOpMetadata) => {
-            // if params is undefined, the interval was deleted during
-            // rebasing
-            if (!params) {
-                return;
-            }
-            (0, internal_1.assert)(op !== undefined, 0x3fb /* op should exist here */);
-            collection.ackAdd(params, local, op, localOpMetadata);
-        },
-        rebase,
-    },
-    [index_js_2.IntervalDeltaOpType.DELETE]: {
-        process: (collection, params, local, op) => {
-            (0, internal_1.assert)(op !== undefined, 0x3fc /* op should exist here */);
-            collection.ackDelete(params, local, op);
-        },
-        rebase: (collection, op, localOpMetadata) => {
-            // Deletion of intervals is based on id, so requires no rebasing.
-            return { rebasedOp: op, rebasedLocalOpMetadata: localOpMetadata };
-        },
-    },
-    [index_js_2.IntervalDeltaOpType.CHANGE]: {
-        process: (collection, params, local, op, localOpMetadata) => {
-            // if params is undefined, the interval was deleted during
-            // rebasing
-            if (!params) {
-                return;
-            }
-            (0, internal_1.assert)(op !== undefined, 0x3fd /* op should exist here */);
-            collection.ackChange(params, local, op, localOpMetadata);
-        },
-        rebase,
-    },
-};
 class IntervalCollectionIterator {
     constructor(collection, iteratesForward = true, start, end) {
         this.results = [];
@@ -308,6 +263,112 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         }
         return true;
     }
+    rollback(op, localOpMetadata) {
+        const { opName, value } = op;
+        const { id, properties } = (0, index_js_2.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": {
+                (0, internal_1.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": {
+                (0, internal_1.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:
+                (0, internal_1.unreachableCase)(opName);
+        }
+    }
+    process(op, local, message, localOpMetadata) {
+        const { opName, value } = op;
+        switch (opName) {
+            case "add": {
+                this.ackAdd(value, local, message, localOpMetadata);
+                break;
+            }
+            case "delete": {
+                this.ackDelete(value, local, message);
+                break;
+            }
+            case "change": {
+                this.ackChange(value, local, message, localOpMetadata);
+                break;
+            }
+            default:
+                (0, internal_1.unreachableCase)(opName);
+        }
+    }
+    resubmitMessage(op, localOpMetadata) {
+        const { opName, value } = op;
+        const { localSeq } = localOpMetadata;
+        const rebasedValue = opName === "delete" ? value : this.rebaseLocalInterval(opName, value, localSeq);
+        if (rebasedValue === undefined) {
+            return undefined;
+        }
+        this.submitDelta({ opName, value: rebasedValue }, localOpMetadata);
+    }
+    applyStashedOp(op) {
+        const { opName, value } = op;
+        const { id, properties } = (0, index_js_2.getSerializedProperties)(value);
+        switch (opName) {
+            case "add": {
+                this.add({
+                    id,
+                    // Todo: we should improve typing so we know add ops always have start and end
+                    start: toSequencePlace(value.start, value.startSide),
+                    end: toSequencePlace(value.end, value.endSide),
+                    props: properties,
+                });
+                break;
+            }
+            case "change": {
+                this.change(id, {
+                    start: toOptionalSequencePlace(value.start, value.startSide),
+                    end: toOptionalSequencePlace(value.end, value.endSide),
+                    props: properties,
+                });
+                break;
+            }
+            case "delete": {
+                this.removeIntervalById(id);
+                break;
+            }
+            default:
+                throw new Error("unknown ops should not be stashed");
+        }
+    }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
         if (!this.client) {
             throw new internal_3.LoggingError("mergeTree client must exist");
@@ -417,7 +478,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
     /**
      * {@inheritdoc IIntervalCollection.add}
      */
-    add({ id, start, end, props, }) {
+    add({ id, start, end, props, rollback, }) {
         if (!this.localCollection) {
             throw new internal_3.LoggingError("attach must be called prior to adding intervals");
         }
@@ -427,7 +488,7 @@ class IntervalCollection extends client_utils_1.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 ?? (0, uuid_1.v4)(), toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), props);
+        const interval = this.localCollection.addInterval(id ?? (0, uuid_1.v4)(), toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), props, undefined, rollback);
         if (interval) {
             if (!this.isCollaborating) {
                 setSlideOnRemove(interval.start);
@@ -435,20 +496,20 @@ class IntervalCollection extends client_utils_1.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 internal_3.LoggingError("Attach must be called before accessing intervals");
         }
@@ -456,12 +517,13 @@ class IntervalCollection extends client_utils_1.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 {
@@ -481,14 +543,14 @@ class IntervalCollection extends client_utils_1.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 internal_3.LoggingError("Attach must be called before accessing intervals");
         }
@@ -510,7 +572,7 @@ class IntervalCollection extends client_utils_1.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) {
@@ -520,27 +582,25 @@ class IntervalCollection extends client_utils_1.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);
@@ -836,7 +896,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         const { id } = (0, index_js_2.getSerializedProperties)(serializedInterval);
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
         if (interval) {
-            this.deleteExistingInterval(interval, local, op);
+            this.deleteExistingInterval({ interval, local, op });
         }
     }
     serializeInternal(version) {