@fluidframework/merge-tree 0.59.4001 → 1.1.0-75972

package/lib/client.js

@@ -10,11 +10,11 @@ import { UnassignedSequenceNumber, UniversalSequenceNumber } from "./constants";
 import { LocalReference } from "./localReference";
 import { compareStrings, MergeTree, } from "./mergeTree";
 import { createAnnotateMarkerOp, createAnnotateRangeOp, createGroupOp, createInsertSegmentOp, createRemoveRangeOp, } from "./opBuilder";
+import { MergeTreeDeltaType, } from "./ops";
 import { SnapshotLegacy } from "./snapshotlegacy";
 import { SnapshotLoader } from "./snapshotLoader";
 import { MergeTreeTextHelper } from "./textSegment";
 import { SnapshotV1 } from "./snapshotV1";
-import { DetachedReferencePosition } from "./referencePositions";
 function elapsedMicroseconds(trace) {
     return trace.trace().duration * 1000;
 }
@@ -221,11 +221,7 @@ export class Client {
         return this.mergeTree.removeLocalReferencePosition(lref);
     }
     localReferencePositionToPosition(lref) {
-        const segment = lref.getSegment();
-        if (segment === undefined) {
-            return DetachedReferencePosition;
-        }
-        return this.getPosition(segment) + lref.getOffset();
+        return this.mergeTree.referencePositionToLocalPosition(lref);
     }
     /**
      * Given a position specified relative to a marker id, lookup the marker
@@ -244,7 +240,7 @@ export class Client {
      * @returns True if the remove was applied. False if it could not be.
      */
     applyRemoveRangeOp(opArgs) {
-        assert(opArgs.op.type === 1 /* REMOVE */, 0x02d /* "Unexpected op type on range remove!" */);
+        assert(opArgs.op.type === MergeTreeDeltaType.REMOVE, 0x02d /* "Unexpected op type on range remove!" */);
         const op = opArgs.op;
         const clientArgs = this.getClientSequenceArgs(opArgs);
         const range = this.getValidOpRange(op, clientArgs);
@@ -265,7 +261,7 @@ export class Client {
      * @returns True if the annotate was applied. False if it could not be.
      */
     applyAnnotateRangeOp(opArgs) {
-        assert(opArgs.op.type === 2 /* ANNOTATE */, 0x02e /* "Unexpected op type on range annotate!" */);
+        assert(opArgs.op.type === MergeTreeDeltaType.ANNOTATE, 0x02e /* "Unexpected op type on range annotate!" */);
         const op = opArgs.op;
         const clientArgs = this.getClientSequenceArgs(opArgs);
         const range = this.getValidOpRange(op, clientArgs);
@@ -286,7 +282,7 @@ export class Client {
      * @returns True if the insert was applied. False if it could not be.
      */
     applyInsertOp(opArgs) {
-        assert(opArgs.op.type === 0 /* INSERT */, 0x02f /* "Unexpected op type on range insert!" */);
+        assert(opArgs.op.type === MergeTreeDeltaType.INSERT, 0x02f /* "Unexpected op type on range insert!" */);
         const op = opArgs.op;
         const clientArgs = this.getClientSequenceArgs(opArgs);
         const range = this.getValidOpRange(op, clientArgs);
@@ -355,12 +351,12 @@ export class Client {
             if (start === undefined
                 || start < 0
                 || start > length
-                || start === length && op.type !== 0 /* INSERT */) {
+                || start === length && op.type !== MergeTreeDeltaType.INSERT) {
                 invalidPositions.push("start");
             }
             // Validate end if not insert, or insert has end
             //
-            if (op.type !== 0 /* INSERT */ || end !== undefined) {
+            if (op.type !== MergeTreeDeltaType.INSERT || end !== undefined) {
                 if (end === undefined || end <= start) {
                     invalidPositions.push("end");
                 }
@@ -386,13 +382,13 @@ export class Client {
     }
     /**
      * Gets the client args from the op if remote, otherwise uses the local clients info
-     * @param opArgs - The op arg to get the client sequence args for
+     * @param sequencedMessage - The sequencedMessage to get the client sequence args for
      */
-    getClientSequenceArgs(opArgs) {
+    getClientSequenceArgsForMessage(sequencedMessage) {
         // If there this no sequenced message, then the op is local
         // and unacked, so use this clients sequenced args
         //
-        if (!opArgs.sequencedMessage) {
+        if (!sequencedMessage) {
             const segWindow = this.getCollabWindow();
             return {
                 clientId: segWindow.clientId,
@@ -402,12 +398,19 @@ export class Client {
         }
         else {
             return {
-                clientId: this.getShortClientId(opArgs.sequencedMessage.clientId),
-                referenceSequenceNumber: opArgs.sequencedMessage.referenceSequenceNumber,
-                sequenceNumber: opArgs.sequencedMessage.sequenceNumber,
+                clientId: this.getOrAddShortClientId(sequencedMessage.clientId),
+                referenceSequenceNumber: sequencedMessage.referenceSequenceNumber,
+                sequenceNumber: sequencedMessage.sequenceNumber,
             };
         }
     }
+    /**
+     * Gets the client args from the op if remote, otherwise uses the local clients info
+     * @param opArgs - The op arg to get the client sequence args for
+     */
+    getClientSequenceArgs(opArgs) {
+        return this.getClientSequenceArgsForMessage(opArgs.sequencedMessage);
+    }
     ackPendingSegment(opArgs) {
         const ackOp = (deltaOpArgs) => {
             let trace;
@@ -415,7 +418,7 @@ export class Client {
                 trace = Trace.start();
             }
             this.mergeTree.ackPendingSegment(deltaOpArgs);
-            if (deltaOpArgs.op.type === 2 /* ANNOTATE */) {
+            if (deltaOpArgs.op.type === MergeTreeDeltaType.ANNOTATE) {
                 if (deltaOpArgs.op.combiningOp && (deltaOpArgs.op.combiningOp.name === "consensus")) {
                     this.updateConsensusProperty(deltaOpArgs.op, deltaOpArgs.sequencedMessage);
                 }
@@ -426,7 +429,7 @@ export class Client {
                 this.accumWindow += (this.getCurrentSeq() - this.getCollabWindow().minSeq);
             }
         };
-        if (opArgs.op.type === 3 /* GROUP */) {
+        if (opArgs.op.type === MergeTreeDeltaType.GROUP) {
             for (const memberOp of opArgs.op.ops) {
                 ackOp({
                     groupOp: opArgs.op,
@@ -507,6 +510,47 @@ export class Client {
         });
         return segmentPosition;
     }
+    /**
+     * Rebases a (local) position from the perspective `{ seq: seqNumberFrom, localSeq }` to the perspective
+     * of the current sequence number. This is desirable when rebasing operations for reconnection.
+     *
+     * If the position refers to a segment/offset that was removed by some operation between `seqNumberFrom` and
+     * the current sequence number, the returned position will align with the position of a reference given
+     * `SlideOnRemove` semantics.
+     */
+    rebasePosition(pos, seqNumberFrom, localSeq) {
+        assert(localSeq <= this.mergeTree.collabWindow.localSeq, 0x300 /* localSeq greater than collab window */);
+        let segment;
+        let posAccumulated = 0;
+        let offset = pos;
+        const isInsertedInView = (seg) => (seg.seq !== undefined && seg.seq !== UnassignedSequenceNumber && seg.seq <= seqNumberFrom)
+            || (seg.localSeq !== undefined && seg.localSeq <= localSeq);
+        const isRemovedFromView = ({ removedSeq, localRemovedSeq }) => (removedSeq !== undefined && removedSeq !== UnassignedSequenceNumber && removedSeq <= seqNumberFrom)
+            || (localRemovedSeq !== undefined && localRemovedSeq <= localSeq);
+        this.mergeTree.walkAllSegments(this.mergeTree.root, (seg) => {
+            assert(seg.seq !== undefined || seg.localSeq !== undefined, 0x301 /* Either seq or localSeq should be defined */);
+            segment = seg;
+            if (isInsertedInView(seg) && !isRemovedFromView(seg)) {
+                posAccumulated += seg.cachedLength;
+                if (offset >= seg.cachedLength) {
+                    offset -= seg.cachedLength;
+                }
+            }
+            // Keep going while we've yet to reach the segment at the desired position
+            return posAccumulated <= pos;
+        });
+        assert(segment !== undefined, 0x302 /* No segment found */);
+        const seqNumberTo = this.getCollabWindow().currentSeq;
+        if ((segment.removedSeq !== undefined &&
+            segment.removedSeq !== UnassignedSequenceNumber &&
+            segment.removedSeq <= seqNumberTo)
+            || (segment.localRemovedSeq !== undefined && segment.localRemovedSeq <= localSeq)) {
+            // Segment that the position was in has been removed: null out offset.
+            offset = 0;
+        }
+        assert(0 <= offset && offset < segment.cachedLength, 0x303 /* Invalid offset */);
+        return this.findReconnectionPosition(segment, localSeq) + offset;
+    }
     resetPendingDeltaToOps(resetOp, segmentGroup) {
         var _a, _b;
         assert(!!segmentGroup, 0x033 /* "Segment group undefined" */);
@@ -524,7 +568,7 @@ export class Client {
             const segmentPosition = this.findReconnectionPosition(segment, segmentGroup.localSeq);
             let newOp;
             switch (resetOp.type) {
-                case 2 /* ANNOTATE */:
+                case MergeTreeDeltaType.ANNOTATE:
                     assert(((_b = segment.propertyManager) === null || _b === void 0 ? void 0 : _b.hasPendingProperties()) === true, 0x036 /* "Segment has no pending properties" */);
                     // if the segment has been removed, there's no need to send the annotate op
                     // unless the remove was local, in which case the annotate must have come
@@ -533,11 +577,11 @@ export class Client {
                         newOp = createAnnotateRangeOp(segmentPosition, segmentPosition + segment.cachedLength, resetOp.props, resetOp.combiningOp);
                     }
                     break;
-                case 0 /* INSERT */:
+                case MergeTreeDeltaType.INSERT:
                     assert(segment.seq === UnassignedSequenceNumber, 0x037 /* "Segment already has assigned sequence number" */);
                     newOp = createInsertSegmentOp(segmentPosition, segment);
                     break;
-                case 1 /* REMOVE */:
+                case MergeTreeDeltaType.REMOVE:
                     if (segment.localRemovedSeq !== undefined) {
                         newOp = createRemoveRangeOp(segmentPosition, segmentPosition + segment.cachedLength);
                     }
@@ -559,16 +603,16 @@ export class Client {
         const msg = opArgs.sequencedMessage;
         this.getOrAddShortClientId(msg.clientId);
         switch (op.type) {
-            case 0 /* INSERT */:
+            case MergeTreeDeltaType.INSERT:
                 this.applyInsertOp(opArgs);
                 break;
-            case 1 /* REMOVE */:
+            case MergeTreeDeltaType.REMOVE:
                 this.applyRemoveRangeOp(opArgs);
                 break;
-            case 2 /* ANNOTATE */:
+            case MergeTreeDeltaType.ANNOTATE:
                 this.applyAnnotateRangeOp(opArgs);
                 break;
-            case 3 /* GROUP */: {
+            case MergeTreeDeltaType.GROUP: {
                 for (const memberOp of op.ops) {
                     this.applyRemoteOp({
                         op: memberOp,
@@ -585,19 +629,19 @@ export class Client {
     applyStashedOp(op) {
         let metadata;
         switch (op.type) {
-            case 0 /* INSERT */:
+            case MergeTreeDeltaType.INSERT:
                 this.applyInsertOp({ op });
                 metadata = this.peekPendingSegmentGroups();
                 break;
-            case 1 /* REMOVE */:
+            case MergeTreeDeltaType.REMOVE:
                 this.applyRemoveRangeOp({ op });
                 metadata = this.peekPendingSegmentGroups();
                 break;
-            case 2 /* ANNOTATE */:
+            case MergeTreeDeltaType.ANNOTATE:
                 this.applyAnnotateRangeOp({ op });
                 metadata = this.peekPendingSegmentGroups();
                 break;
-            case 3 /* GROUP */:
+            case MergeTreeDeltaType.GROUP:
                 return op.ops.map((o) => this.applyStashedOp(o));
             default:
                 unreachableCase(op, "unrecognized op type");
@@ -652,7 +696,7 @@ export class Client {
      */
     regeneratePendingOp(resetOp, segmentGroup) {
         const opList = [];
-        if (resetOp.type === 3 /* GROUP */) {
+        if (resetOp.type === MergeTreeDeltaType.GROUP) {
             if (Array.isArray(segmentGroup)) {
                 assert(resetOp.ops.length === segmentGroup.length, 0x03a /* "Number of ops in 'resetOp' must match the number of segment groups provided." */);
                 for (let i = 0; i < resetOp.ops.length; i++) {
@@ -667,7 +711,7 @@ export class Client {
             }
         }
         else {
-            assert(resetOp.type !== 3 /* GROUP */, 0x03c /* "Reset op has 'group' delta type!" */);
+            assert(resetOp.type !== MergeTreeDeltaType.GROUP, 0x03c /* "Reset op has 'group' delta type!" */);
             assert(!Array.isArray(segmentGroup), 0x03d /* "segmentGroup is array rather than singleton!" */);
             opList.push(...this.resetPendingDeltaToOps(resetOp, segmentGroup));
         }
@@ -724,13 +768,13 @@ export class Client {
                 groupOp,
             };
             switch (op.type) {
-                case 0 /* INSERT */:
+                case MergeTreeDeltaType.INSERT:
                     this.applyInsertOp(opArgs);
                     break;
-                case 2 /* ANNOTATE */:
+                case MergeTreeDeltaType.ANNOTATE:
                     this.applyAnnotateRangeOp(opArgs);
                     break;
-                case 1 /* REMOVE */:
+                case MergeTreeDeltaType.REMOVE:
                     this.applyRemoveRangeOp(opArgs);
                     break;
                 default:
@@ -761,18 +805,16 @@ export class Client {
         }
     }
     getContainingSegment(pos, op) {
-        let seq;
-        let clientId;
-        if (op) {
-            clientId = this.getOrAddShortClientId(op.clientId);
-            seq = op.referenceSequenceNumber;
-        }
-        else {
-            const segWindow = this.mergeTree.getCollabWindow();
-            seq = segWindow.currentSeq;
-            clientId = segWindow.clientId;
-        }
-        return this.mergeTree.getContainingSegment(pos, seq, clientId);
+        const args = this.getClientSequenceArgsForMessage(op);
+        return this.mergeTree.getContainingSegment(pos, args.referenceSequenceNumber, args.clientId);
+    }
+    /**
+     * Returns the position to slide a reference to if a slide is required.
+     * @param segoff - The segment and offset to slide from
+     * @returns - segment and offset to slide the reference to
+     */
+    getSlideToSegment(segoff) {
+        return this.mergeTree._getSlideToSegment(segoff);
     }
     getPropertiesAtPosition(pos) {
         let propertiesAtPosition;