@fluidframework/sequence 0.56.9 → 0.56.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/sequence",
-  "version": "0.56.9",
+  "version": "0.56.10",
   "description": "Distributed sequence",
   "homepage": "https://fluidframework.com",
   "repository": "https://github.com/microsoft/FluidFramework",
@@ -60,23 +60,23 @@
     "@fluidframework/common-definitions": "^0.20.1",
     "@fluidframework/common-utils": "^0.32.1",
     "@fluidframework/core-interfaces": "^0.42.0",
-    "@fluidframework/datastore-definitions": "^0.56.9",
-    "@fluidframework/merge-tree": "^0.56.9",
+    "@fluidframework/datastore-definitions": "^0.56.10",
+    "@fluidframework/merge-tree": "^0.56.10",
     "@fluidframework/protocol-definitions": "^0.1026.0",
-    "@fluidframework/runtime-definitions": "^0.56.9",
-    "@fluidframework/runtime-utils": "^0.56.9",
-    "@fluidframework/shared-object-base": "^0.56.9",
-    "@fluidframework/telemetry-utils": "^0.56.9",
+    "@fluidframework/runtime-definitions": "^0.56.10",
+    "@fluidframework/runtime-utils": "^0.56.10",
+    "@fluidframework/shared-object-base": "^0.56.10",
+    "@fluidframework/telemetry-utils": "^0.56.10",
     "uuid": "^8.3.1"
   },
   "devDependencies": {
-    "@fluid-internal/test-dds-utils": "^0.56.9",
+    "@fluid-internal/test-dds-utils": "^0.56.10",
     "@fluidframework/build-common": "^0.23.0",
     "@fluidframework/eslint-config-fluid": "^0.25.0",
     "@fluidframework/gitresources": "^0.1034.0",
-    "@fluidframework/mocha-test-setup": "^0.56.9",
+    "@fluidframework/mocha-test-setup": "^0.56.10",
     "@fluidframework/server-services-client": "^0.1034.0",
-    "@fluidframework/test-runtime-utils": "^0.56.9",
+    "@fluidframework/test-runtime-utils": "^0.56.10",
     "@microsoft/api-extractor": "^7.16.1",
     "@rushstack/eslint-config": "^2.5.1",
     "@types/diff": "^3.5.1",

package/src/intervalCollection.ts

@@ -55,7 +55,7 @@ export interface ISerializableInterval extends IInterval {
 export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
     compareEnds(a: TInterval, b: TInterval): number;
     create(label: string, start: number, end: number,
-        client: Client, intervalType?: IntervalType): TInterval;
+        client: Client, intervalType?: IntervalType, op?: ISequencedDocumentMessage): TInterval;
 }
 
 export class Interval implements ISerializableInterval {
@@ -175,7 +175,7 @@ export class Interval implements ISerializableInterval {
         }
     }
 
-    public modify(label: string, start: number, end: number) {
+    public modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage) {
         const startPos = start ?? this.start;
         const endPos = end ?? this.end;
         if (this.start === startPos && this.end === endPos) {
@@ -312,16 +312,17 @@ export class SequenceInterval implements ISerializableInterval {
         }
     }
 
-    public modify(label: string, start: number, end: number) {
-        const startPos = start ?? this.start.getOffset();
-        const endPos = end ?? this.end.getOffset();
+    public modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage) {
+        const startPos = start ?? this.start.toPosition();
+        const endPos = end ?? this.end.toPosition();
 
-        if (this.start.getOffset() === startPos && this.end.getOffset() === endPos) {
+        if (this.start.toPosition() === startPos && this.end.toPosition() === endPos) {
             // Return undefined to indicate that no change is necessary.
             return;
         }
 
-        const newInterval = createSequenceInterval(label, startPos, endPos, this.start.getClient(), this.intervalType);
+        const newInterval =
+            createSequenceInterval(label, startPos, endPos, this.start.getClient(), this.intervalType, op);
         if (this.properties) {
             newInterval.addProperties(this.properties);
         }
@@ -332,8 +333,9 @@ export class SequenceInterval implements ISerializableInterval {
 function createPositionReference(
     client: Client,
     pos: number,
-    refType: ReferenceType): LocalReference {
-    const segoff = client.getContainingSegment(pos);
+    refType: ReferenceType,
+    op?: ISequencedDocumentMessage): LocalReference {
+    const segoff = client.getContainingSegment(pos, op);
     if (segoff && segoff.segment) {
         const lref = new LocalReference(client, segoff.segment, segoff.offset, refType);
         if (refType !== ReferenceType.Transient) {
@@ -349,7 +351,8 @@ function createSequenceInterval(
     start: number,
     end: number,
     client: Client,
-    intervalType: IntervalType): SequenceInterval {
+    intervalType: IntervalType,
+    op?: ISequencedDocumentMessage): SequenceInterval {
     let beginRefType = ReferenceType.RangeBegin;
     let endRefType = ReferenceType.RangeEnd;
     if (intervalType === IntervalType.Nest) {
@@ -366,8 +369,8 @@ function createSequenceInterval(
         endRefType |= ReferenceType.SlideOnRemove;
     }
 
-    const startLref = createPositionReference(client, start, beginRefType);
-    const endLref = createPositionReference(client, end, endRefType);
+    const startLref = createPositionReference(client, start, beginRefType, op);
+    const endLref = createPositionReference(client, end, endRefType, op);
     if (startLref && endLref) {
         startLref.pairedRef = endLref;
         endLref.pairedRef = startLref;
@@ -589,16 +592,21 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
         this.endIntervalTree.remove(interval);
     }
 
-    public createInterval(start: number, end: number, intervalType: IntervalType): TInterval {
-        return this.helpers.create(this.label, start, end, this.client, intervalType);
+    public createInterval(
+        start: number,
+        end: number,
+        intervalType: IntervalType,
+        op?: ISequencedDocumentMessage): TInterval {
+        return this.helpers.create(this.label, start, end, this.client, intervalType, op);
     }
 
     public addInterval(
         start: number,
         end: number,
         intervalType: IntervalType,
-        props?: PropertySet) {
-        const interval: TInterval = this.createInterval(start, end, intervalType);
+        props?: PropertySet,
+        op?: ISequencedDocumentMessage) {
+        const interval: TInterval = this.createInterval(start, end, intervalType, op);
         if (interval) {
             if (!interval.properties) {
                 interval.properties = createMap<any>();
@@ -638,8 +646,8 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
         return result;
     }
 
-    public changeInterval(interval: TInterval, start: number, end: number) {
-        const newInterval = interval.modify(this.label, start, end) as TInterval | undefined;
+    public changeInterval(interval: TInterval, start: number, end: number, op?: ISequencedDocumentMessage) {
+        const newInterval = interval.modify(this.label, start, end, op) as TInterval | undefined;
         if (newInterval) {
             this.removeExistingInterval(interval);
             this.add(newInterval);
@@ -1115,7 +1123,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
                 if (start !== undefined || end !== undefined) {
                     // If changeInterval gives us a new interval, work with that one. Otherwise keep working with
                     // the one we originally found in the tree.
-                    interval = this.localCollection.changeInterval(interval, start, end) ?? interval;
+                    interval = this.localCollection.changeInterval(interval, start, end, op) ?? interval;
                 }
                 const deltaProps = interval.addProperties(serializedInterval.properties, true, op.sequenceNumber);
                 if (this.onDeserialize) {
@@ -1163,7 +1171,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             serializedInterval.start,
             serializedInterval.end,
             serializedInterval.intervalType,
-            serializedInterval.properties);
+            serializedInterval.properties,
+            op);
 
         if (interval) {
             // Local ops get submitted to the server. Remote ops have the deserializer run.

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "0.56.9";
+export const pkgVersion = "0.56.10";