@fluidframework/sequence 2.30.0 → 2.31.1

package/lib/intervalCollection.js

@@ -3,14 +3,13 @@
  * Licensed under the MIT License.
  */
 /* eslint-disable no-bitwise */
-/* eslint-disable import/no-deprecated */
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
-import { DetachedReferencePosition, ReferenceType, SlidingPreference, UnassignedSequenceNumber, UniversalSequenceNumber, addProperties, createMap, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, PropertiesManager, } from "@fluidframework/merge-tree/internal";
+import { DetachedReferencePosition, ReferenceType, SlidingPreference, UnassignedSequenceNumber, UniversalSequenceNumber, addProperties, getSlideToSegoff, refTypeIncludesFlag, reservedRangeLabelsKey, Side, endpointPosAndSide, PropertiesManager, createMap, } from "@fluidframework/merge-tree/internal";
 import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
-import { EndpointIndex, OverlappingIntervalsIndex, createIdIntervalIndex, } from "./intervalIndex/index.js";
-import { IntervalOpType, IntervalStickiness, IntervalType, SequenceIntervalClass, createInterval, createPositionReferenceFromSegoff, endReferenceSlidingPreference, sequenceIntervalHelpers, startReferenceSlidingPreference, } from "./intervals/index.js";
+import { createIdIntervalIndex, EndpointIndex, OverlappingIntervalsIndex, } from "./intervalIndex/index.js";
+import { IntervalDeltaOpType, IntervalStickiness, IntervalType, createPositionReferenceFromSegoff, createSequenceInterval, endReferenceSlidingPreference, startReferenceSlidingPreference, } from "./intervals/index.js";
 export const reservedIntervalIdKey = "intervalId";
 export function sidesFromStickiness(stickiness) {
     const startSide = (stickiness & IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
@@ -72,25 +71,17 @@ export function computeStickinessFromSide(startPos = -1, startSide = Side.Before
     }
     return stickiness;
 }
-export function createIntervalIndex() {
-    const helpers = {
-        create: createInterval,
-    };
-    const lc = new LocalIntervalCollection(undefined, "", helpers, {});
-    return lc;
-}
 export class LocalIntervalCollection {
-    constructor(client, label, helpers, options, 
+    constructor(client, label, options, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
     onPositionChange) {
         this.client = client;
         this.label = label;
-        this.helpers = helpers;
         this.options = options;
         this.onPositionChange = onPositionChange;
-        this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
+        this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client);
         this.idIntervalIndex = createIdIntervalIndex();
-        this.endIntervalIndex = new EndpointIndex(client, helpers);
+        this.endIntervalIndex = new EndpointIndex(client);
         this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
@@ -145,7 +136,7 @@ export class LocalIntervalCollection {
         this.removeIntervalListeners(interval);
     }
     createInterval(start, end, intervalType, op) {
-        return this.helpers.create(this.label, start, end, this.client, intervalType, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
+        return createSequenceInterval(this.label, start, end, this.client, intervalType, op, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
     }
     addInterval(start, end, intervalType, props, op) {
         const interval = this.createInterval(start, end, intervalType, op);
@@ -169,10 +160,8 @@ export class LocalIntervalCollection {
         return interval;
     }
     linkEndpointsToInterval(interval) {
-        if (interval instanceof SequenceIntervalClass) {
-            interval.start.addProperties({ interval });
-            interval.end.addProperties({ interval });
-        }
+        interval.start.addProperties({ interval });
+        interval.end.addProperties({ interval });
     }
     addIntervalToIndexes(interval) {
         for (const index of this.indexes) {
@@ -192,7 +181,10 @@ export class LocalIntervalCollection {
         }
         return newInterval;
     }
-    serialize() {
+    serialize(version) {
+        if (version === "1") {
+            return Array.from(this.idIntervalIndex, (interval) => interval.serialize());
+        }
         return {
             label: this.label,
             intervals: Array.from(this.idIntervalIndex, (interval) => compressInterval(interval.serialize())),
@@ -210,141 +202,77 @@ export class LocalIntervalCollection {
             }
             return this.client.createLocalReferencePosition(segment, ref.getOffset(), ReferenceType.Transient, ref.properties, ref.slidingPreference, ref.canSlideToEndpoint);
         };
-        if (interval instanceof SequenceIntervalClass) {
-            let previousInterval;
-            let pendingChanges = 0;
-            interval.addPositionChangeListeners(() => {
-                pendingChanges++;
-                // Note: both start and end can change and invoke beforeSlide on each endpoint before afterSlide.
-                if (!previousInterval) {
-                    previousInterval = interval.clone();
-                    previousInterval.start = cloneRef(previousInterval.start);
-                    previousInterval.end = cloneRef(previousInterval.end);
-                    this.removeIntervalFromIndexes(interval);
-                }
-            }, () => {
-                assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
-                pendingChanges--;
-                if (pendingChanges === 0) {
-                    this.addIntervalToIndexes(interval);
-                    this.onPositionChange?.(interval, previousInterval);
-                    previousInterval = undefined;
-                }
-            });
-        }
+        let previousInterval;
+        let pendingChanges = 0;
+        interval.addPositionChangeListeners(() => {
+            pendingChanges++;
+            // Note: both start and end can change and invoke beforeSlide on each endpoint before afterSlide.
+            if (!previousInterval) {
+                previousInterval = interval.clone();
+                previousInterval.start = cloneRef(previousInterval.start);
+                previousInterval.end = cloneRef(previousInterval.end);
+                this.removeIntervalFromIndexes(interval);
+            }
+        }, () => {
+            assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
+            pendingChanges--;
+            if (pendingChanges === 0) {
+                this.addIntervalToIndexes(interval);
+                this.onPositionChange?.(interval, previousInterval);
+                previousInterval = undefined;
+            }
+        });
     }
     removeIntervalListeners(interval) {
-        if (interval instanceof SequenceIntervalClass) {
-            interval.removePositionChangeListeners();
-        }
+        interval.removePositionChangeListeners();
     }
 }
 LocalIntervalCollection.legacyIdPrefix = "legacy";
-class SequenceIntervalCollectionFactory {
-    load(emitter, raw = [], options) {
-        return new IntervalCollection(sequenceIntervalHelpers, true, emitter, raw, options);
-    }
-    store(value) {
-        return value.serializeInternal();
-    }
-}
-export class SequenceIntervalCollectionValueType {
-    get name() {
-        return SequenceIntervalCollectionValueType.Name;
-    }
-    get factory() {
-        return SequenceIntervalCollectionValueType._factory;
-    }
-    get ops() {
-        return SequenceIntervalCollectionValueType._ops;
-    }
-}
-SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
-SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
-SequenceIntervalCollectionValueType._ops = makeOpsMap();
-class IntervalCollectionFactory {
-    load(emitter, raw = [], options) {
-        const helpers = {
-            create: createInterval,
-        };
-        const collection = new IntervalCollection(helpers, false, emitter, raw, options);
-        collection.attachGraph(undefined, "");
-        return collection;
-    }
-    store(value) {
-        return value.serializeInternal();
-    }
-}
-export class IntervalCollectionValueType {
-    get name() {
-        return IntervalCollectionValueType.Name;
-    }
-    get factory() {
-        return IntervalCollectionValueType._factory;
-    }
-    get ops() {
-        return IntervalCollectionValueType._ops;
+const rebase = (collection, op, localOpMetadata) => {
+    const { localSeq } = localOpMetadata;
+    const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
+    if (rebasedValue === undefined) {
+        return undefined;
     }
-}
-IntervalCollectionValueType.Name = "sharedIntervalCollection";
-IntervalCollectionValueType._factory = new IntervalCollectionFactory();
-IntervalCollectionValueType._ops = makeOpsMap();
-export function makeOpsMap() {
-    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 };
-    };
-    return new Map([
-        [
-            IntervalOpType.ADD,
-            {
-                process: (collection, params, local, op, localOpMetadata) => {
-                    // if params is undefined, the interval was deleted during
-                    // rebasing
-                    if (!params) {
-                        return;
-                    }
-                    assert(op !== undefined, 0x3fb /* op should exist here */);
-                    collection.ackAdd(params, local, op, localOpMetadata);
-                },
-                rebase,
-            },
-        ],
-        [
-            IntervalOpType.DELETE,
-            {
-                process: (collection, params, local, op) => {
-                    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 };
-                },
-            },
-        ],
-        [
-            IntervalOpType.CHANGE,
-            {
-                process: (collection, params, local, op, localOpMetadata) => {
-                    // if params is undefined, the interval was deleted during
-                    // rebasing
-                    if (!params) {
-                        return;
-                    }
-                    assert(op !== undefined, 0x3fd /* op should exist here */);
-                    collection.ackChange(params, local, op, localOpMetadata);
-                },
-                rebase,
-            },
-        ],
-    ]);
-}
+    const rebasedOp = { ...op, value: rebasedValue };
+    return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
+};
+export const opsMap = {
+    [IntervalDeltaOpType.ADD]: {
+        process: (collection, params, local, op, localOpMetadata) => {
+            // if params is undefined, the interval was deleted during
+            // rebasing
+            if (!params) {
+                return;
+            }
+            assert(op !== undefined, 0x3fb /* op should exist here */);
+            collection.ackAdd(params, local, op, localOpMetadata);
+        },
+        rebase,
+    },
+    [IntervalDeltaOpType.DELETE]: {
+        process: (collection, params, local, op) => {
+            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 };
+        },
+    },
+    [IntervalDeltaOpType.CHANGE]: {
+        process: (collection, params, local, op, localOpMetadata) => {
+            // if params is undefined, the interval was deleted during
+            // rebasing
+            if (!params) {
+                return;
+            }
+            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 = [];
@@ -371,11 +299,9 @@ export class IntervalCollection extends TypedEventEmitter {
     get attached() {
         return !!this.localCollection;
     }
-    constructor(helpers, requiresClient, emitter, serializedIntervals, options = {}) {
+    constructor(submitDelta, serializedIntervals, options = {}) {
         super();
-        this.helpers = helpers;
-        this.requiresClient = requiresClient;
-        this.emitter = emitter;
+        this.submitDelta = submitDelta;
         this.options = options;
         this.localSeqToSerializedInterval = new Map();
         this.localSeqToRebasedInterval = new Map();
@@ -453,7 +379,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (this.attached) {
             throw new LoggingError("Only supports one Sequence attach");
         }
-        if (client === undefined && this.requiresClient) {
+        if (client === undefined) {
             throw new LoggingError("Client required for this collection");
         }
         // Instantiate the local interval collection based on the saved intervals
@@ -465,7 +391,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 }
             });
         }
-        this.localCollection = new LocalIntervalCollection(client, label, this.helpers, this.options, (interval, previousInterval) => this.emitChange(interval, previousInterval, true, true));
+        this.localCollection = new LocalIntervalCollection(client, label, this.options, (interval, previousInterval) => this.emitChange(interval, previousInterval, true, true));
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
                 this.localCollection.ensureSerializedId(serializedInterval);
@@ -476,7 +402,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 const end = typeof endPos === "number" && endSide !== undefined
                     ? { pos: endPos, side: endSide }
                     : endPos;
-                const interval = this.helpers.create(label, start, end, client, intervalType, undefined, true, this.options.mergeTreeReferencesCanSlideToEndpoint);
+                const interval = createSequenceInterval(label, start, end, client, intervalType, undefined, true, this.options.mergeTreeReferencesCanSlideToEndpoint);
                 if (properties) {
                     interval.properties = addProperties(interval.properties, properties);
                 }
@@ -498,22 +424,14 @@ export class IntervalCollection extends TypedEventEmitter {
         // Temporarily make references transient so that positional queries work (non-transient refs
         // on resolve to DetachedPosition on any segments that don't contain them). The original refType
         // is restored as single-endpoint changes re-use previous references.
-        let startRefType;
-        let endRefType;
-        if (previousInterval instanceof SequenceIntervalClass) {
-            startRefType = previousInterval.start.refType;
-            endRefType = previousInterval.end.refType;
-            previousInterval.start.refType = ReferenceType.Transient;
-            previousInterval.end.refType = ReferenceType.Transient;
-            this.emit("changeInterval", interval, previousInterval, local, op, slide);
-            this.emit("changed", interval, undefined, previousInterval ?? undefined, local, slide);
-            previousInterval.start.refType = startRefType;
-            previousInterval.end.refType = endRefType;
-        }
-        else {
-            this.emit("changeInterval", interval, previousInterval, local, op, slide);
-            this.emit("changed", interval, undefined, previousInterval ?? undefined, local, slide);
-        }
+        const startRefType = previousInterval.start.refType;
+        const endRefType = previousInterval.end.refType;
+        previousInterval.start.refType = ReferenceType.Transient;
+        previousInterval.end.refType = ReferenceType.Transient;
+        this.emit("changeInterval", interval, previousInterval, local, op, slide);
+        this.emit("changed", interval, undefined, previousInterval ?? undefined, local, slide);
+        previousInterval.start.refType = startRefType;
+        previousInterval.end.refType = endRefType;
     }
     /**
      * {@inheritdoc IIntervalCollection.getIntervalById}
@@ -546,7 +464,7 @@ export class IntervalCollection extends TypedEventEmitter {
         this.assertStickinessEnabled(start, end);
         const interval = this.localCollection.addInterval(toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), IntervalType.SlideOnRemove, props);
         if (interval) {
-            if (!this.isCollaborating && interval instanceof SequenceIntervalClass) {
+            if (!this.isCollaborating) {
                 setSlideOnRemove(interval.start);
                 setSlideOnRemove(interval.end);
             }
@@ -564,8 +482,12 @@ export class IntervalCollection extends TypedEventEmitter {
             if (this.isCollaborating) {
                 this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
             }
-            // Local ops get submitted to the server. Remote ops have the deserializer run.
-            this.emitter.emit("add", undefined, serializedInterval, { localSeq });
+            this.submitDelta({
+                opName: "add",
+                value: serializedInterval,
+            }, {
+                localSeq,
+            });
         }
         this.emit("addInterval", interval, true, undefined);
         return interval;
@@ -579,7 +501,10 @@ export class IntervalCollection extends TypedEventEmitter {
         if (interval) {
             // Local ops get submitted to the server. Remote ops have the deserializer run.
             if (local) {
-                this.emitter.emit("delete", undefined, interval.serialize(), {
+                this.submitDelta({
+                    opName: "delete",
+                    value: interval.serialize(),
+                }, {
                     localSeq: this.getNextLocalSeq(),
                 });
             }
@@ -634,7 +559,7 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             if (start !== undefined && end !== undefined) {
                 newInterval = this.localCollection.changeInterval(interval, start, end);
-                if (!this.isCollaborating && newInterval instanceof SequenceIntervalClass) {
+                if (!this.isCollaborating && newInterval !== undefined) {
                     setSlideOnRemove(newInterval.start);
                     setSlideOnRemove(newInterval.end);
                 }
@@ -656,7 +581,12 @@ export class IntervalCollection extends TypedEventEmitter {
             if (this.isCollaborating) {
                 this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
             }
-            this.emitter.emit("change", undefined, serializedInterval, { localSeq });
+            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);
@@ -664,10 +594,8 @@ export class IntervalCollection extends TypedEventEmitter {
             if (newInterval) {
                 this.addPendingChange(id, serializedInterval);
                 this.emitChange(newInterval, interval, true, false);
-                if (interval instanceof SequenceIntervalClass) {
-                    this.client?.removeLocalReferencePosition(interval.start);
-                    this.client?.removeLocalReferencePosition(interval.end);
-                }
+                this.client?.removeLocalReferencePosition(interval.start);
+                this.client?.removeLocalReferencePosition(interval.end);
             }
             return newInterval;
         }
@@ -847,8 +775,6 @@ export class IntervalCollection extends TypedEventEmitter {
             return undefined;
         }
         if (localInterval !== undefined) {
-            // we know we must be using `SequenceInterval` because `this.client` exists
-            assert(localInterval instanceof SequenceIntervalClass, 0x3a0 /* localInterval must be `SequenceInterval` when used with client */);
             // The rebased op may place this interval's endpoints on different segments. Calling `changeInterval` here
             // updates the local client's state to be consistent with the emitted op.
             this.localCollection?.changeInterval(localInterval, toOptionalSequencePlace(startRebased, startSide ?? Side.Before), toOptionalSequencePlace(endRebased, endSide ?? Side.Before), undefined, localSeq);
@@ -873,10 +799,6 @@ export class IntervalCollection extends TypedEventEmitter {
         return value;
     }
     ackInterval(interval, op) {
-        // Only SequenceIntervals need potential sliding
-        if (!(interval instanceof SequenceIntervalClass)) {
-            return;
-        }
         if (!refTypeIncludesFlag(interval.start, ReferenceType.StayOnRemove) &&
             !refTypeIncludesFlag(interval.end, ReferenceType.StayOnRemove)) {
             return;
@@ -975,11 +897,11 @@ export class IntervalCollection extends TypedEventEmitter {
             this.deleteExistingInterval(interval, local, op);
         }
     }
-    serializeInternal() {
+    serializeInternal(version) {
         if (!this.localCollection) {
             throw new LoggingError("attachSequence must be called");
         }
-        return this.localCollection.serialize();
+        return this.localCollection.serialize(version);
     }
     /**
      * @returns an iterator over all intervals in this collection.