@fluidframework/sequence 0.59.2000-61729 → 0.59.2001

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "0.59.2000-61729";
+export const pkgVersion = "0.59.2001";

package/src/sequence.ts

@@ -579,7 +579,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
             const handled = this.intervalMapKernel.tryProcessMessage(message.contents, local, message, localOpMetadata);
 
             if (!handled) {
-                this.processMergeTreeMsg(message);
+                this.processMergeTreeMsg(message, local);
             }
         }
     }
@@ -597,6 +597,10 @@ export abstract class SharedSegmentSequence<T extends ISegment>
         this.loadFinished();
     }
 
+    protected applyStashedOp(content: any) {
+        return this.client.applyStashedOp(content);
+    }
+
     private summarizeMergeTree(serializer: IFluidSerializer): ISummaryTreeWithStats {
         // Are we fully loaded? If not, things will go south
         assert(this.loadedDeferred.isCompleted, 0x074 /* "Snapshot called when not fully loaded" */);
@@ -609,8 +613,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
         return this.client.summarize(this.runtime, this.handle, serializer, this.messagesSinceMSNChange);
     }
 
-    private processMergeTreeMsg(
-        rawMessage: ISequencedDocumentMessage) {
+    private processMergeTreeMsg(rawMessage: ISequencedDocumentMessage, local?: boolean) {
         const message = parseHandles(rawMessage, this.serializer);
 
         const ops: IMergeTreeDeltaOp[] = [];
@@ -625,7 +628,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
             }
         }
 
-        this.client.applyMsg(message);
+        this.client.applyMsg(message, local);
 
         if (this.runtime.options?.newMergeTreeSnapshotFormat !== true) {
             if (needsTransformation) {
@@ -709,8 +712,4 @@ export abstract class SharedSegmentSequence<T extends ISegment>
             intervalCollection.attachGraph(this.client, key);
         }
     }
-
-    protected applyStashedOp() {
-        throw new Error("not implemented");
-    }
 }

package/src/sequenceDeltaEvent.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { assert } from "@fluidframework/common-utils";
 import {
     Client,
     IMergeTreeDeltaCallbackArgs,
@@ -19,22 +20,28 @@ import {
 /**
  * Base class for SequenceDeltaEvent and SequenceMaintenanceEvent.
  *
- * The properties of this object and its sub-objects represent a point in time state
- * at the time the operation was applied. They will not take into any future modifications
- * performed to the underlying sequence and merge tree.
+ * The properties of this object and its sub-objects represent the state of the sequence at the
+ * point in time at which the operation was applied.
+ * They will not take into any future modifications performed to the underlying sequence and merge tree.
  */
 export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
+    /**
+     * @deprecated - Events no longer fire when the change they correspond to had no impact (e.g. a remote delete
+     * event for a range that had already been deleted locally).
+     * Clients can therefore assume this property is false.
+     */
     public readonly isEmpty: boolean;
     public readonly deltaOperation: TOperation;
     private readonly sortedRanges: Lazy<SortedSegmentSet<ISequenceDeltaRange<TOperation>>>;
-    private readonly pFirst: Lazy<ISequenceDeltaRange<TOperation> | undefined>;
-    private readonly pLast: Lazy<ISequenceDeltaRange<TOperation> | undefined>;
+    private readonly pFirst: Lazy<ISequenceDeltaRange<TOperation>>;
+    private readonly pLast: Lazy<ISequenceDeltaRange<TOperation>>;
 
     constructor(
         public readonly deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>,
         private readonly mergeTreeClient: Client,
     ) {
-        this.isEmpty = deltaArgs.deltaSegments.length === 0;
+        assert(deltaArgs.deltaSegments.length > 0, 0x2d8 /* "Empty change event should not be emitted." */);
+        this.isEmpty = false;
         this.deltaOperation = deltaArgs.operation;
 
         this.sortedRanges = new Lazy<SortedSegmentSet<ISequenceDeltaRange<TOperation>>>(
@@ -53,25 +60,17 @@ export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTy
             });
 
         this.pFirst = new Lazy<ISequenceDeltaRange<TOperation>>(
-            () => {
-                if (this.isEmpty) {
-                    return undefined;
-                }
-                return this.sortedRanges.value.items[0];
-            });
+            () => this.sortedRanges.value.items[0],
+        );
 
         this.pLast = new Lazy<ISequenceDeltaRange<TOperation>>(
-            () => {
-                if (this.isEmpty) {
-                    return undefined;
-                }
-                return this.sortedRanges.value.items[this.sortedRanges.value.size - 1];
-            });
+            () => this.sortedRanges.value.items[this.sortedRanges.value.size - 1],
+        );
     }
 
     /**
      * The in-order ranges affected by this delta.
-     * These may not be continuos.
+     * These may not be continuous.
      */
     public get ranges(): readonly Readonly<ISequenceDeltaRange<TOperation>>[] {
         return this.sortedRanges.value.items;
@@ -85,18 +84,16 @@ export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTy
     }
 
     /**
-     * The first of the modified ranges. Undefined if delta is empty,
-     * like in the case where a delete comes in for a previously deleted range
+     * The first of the modified ranges.
      */
-    public get first(): Readonly<ISequenceDeltaRange<TOperation>> | undefined {
+    public get first(): Readonly<ISequenceDeltaRange<TOperation>> {
         return this.pFirst.value;
     }
 
     /**
-     * The last of the modified ranges. Undefined if delta is empty,
-     * like in the case where a delete comes in for a previously deleted range
+     * The last of the modified ranges.
      */
-    public get last(): Readonly<ISequenceDeltaRange<TOperation>> | undefined {
+    public get last(): Readonly<ISequenceDeltaRange<TOperation>> {
         return this.pLast.value;
     }
 }
@@ -104,11 +101,11 @@ export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTy
 /**
  * The event object returned on sequenceDelta events.
  *
- * The properties of this object and its sub-objects represent a point in time state
- * at the time the operation was applied. They will not take into consideration any future modifications
- * performed to the underlying sequence and merge tree.
+ * The properties of this object and its sub-objects represent the state of the sequence at the
+ * point in time at which the operation was applied.
+ * They will not take into consideration any future modifications performed to the underlying sequence and merge tree.
  *
- * For group ops, each op will get it's own event, and the group op property will be set on the op args.
+ * For group ops, each op will get its own event, and the group op property will be set on the op args.
  *
  * Ops may get multiple events. For instance, an insert-replace will get a remove then an insert event.
  */
@@ -131,9 +128,9 @@ export class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationTyp
 /**
  * The event object returned on maintenance events.
  *
- * The properties of this object and its sub-objects represent a point in time state
- * at the time the operation was applied. They will not take into any future modifications
- * performed to the underlying sequence and merge tree.
+ * The properties of this object and its sub-objects represent the state of the sequence at the
+ * point in time at which the operation was applied.
+ * They will not take into consideration any future modifications performed to the underlying sequence and merge tree.
  */
 export class SequenceMaintenanceEvent extends SequenceEvent<MergeTreeMaintenanceType> {
     constructor(