@fluidframework/sequence 2.23.0 → 2.31.0

package/dist/intervalCollection.js

@@ -4,9 +4,8 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.makeOpsMap = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.computeStickinessFromSide = exports.toOptionalSequencePlace = exports.toSequencePlace = exports.sidesFromStickiness = exports.reservedIntervalIdKey = void 0;
+exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.opsMap = exports.LocalIntervalCollection = exports.computeStickinessFromSide = exports.toOptionalSequencePlace = exports.toSequencePlace = exports.sidesFromStickiness = exports.reservedIntervalIdKey = void 0;
 /* eslint-disable no-bitwise */
-/* eslint-disable import/no-deprecated */
 const client_utils_1 = require("@fluid-internal/client-utils");
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/merge-tree/internal");
@@ -79,26 +78,17 @@ function computeStickinessFromSide(startPos = -1, startSide = internal_2.Side.Be
     return stickiness;
 }
 exports.computeStickinessFromSide = computeStickinessFromSide;
-function createIntervalIndex() {
-    const helpers = {
-        create: index_js_2.createInterval,
-    };
-    const lc = new LocalIntervalCollection(undefined, "", helpers, {});
-    return lc;
-}
-exports.createIntervalIndex = createIntervalIndex;
 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 index_js_1.OverlappingIntervalsIndex(client, helpers);
+        this.overlappingIntervalsIndex = new index_js_1.OverlappingIntervalsIndex(client);
         this.idIntervalIndex = (0, index_js_1.createIdIntervalIndex)();
-        this.endIntervalIndex = new index_js_1.EndpointIndex(client, helpers);
+        this.endIntervalIndex = new index_js_1.EndpointIndex(client);
         this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
@@ -153,7 +143,7 @@ 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 (0, index_js_2.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);
@@ -177,10 +167,8 @@ class LocalIntervalCollection {
         return interval;
     }
     linkEndpointsToInterval(interval) {
-        if (interval instanceof index_js_2.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) {
@@ -200,7 +188,10 @@ 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())),
@@ -218,145 +209,78 @@ class LocalIntervalCollection {
             }
             return this.client.createLocalReferencePosition(segment, ref.getOffset(), internal_2.ReferenceType.Transient, ref.properties, ref.slidingPreference, ref.canSlideToEndpoint);
         };
-        if (interval instanceof index_js_2.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);
-                }
-            }, () => {
-                (0, internal_1.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);
+            }
+        }, () => {
+            (0, internal_1.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 index_js_2.SequenceIntervalClass) {
-            interval.removePositionChangeListeners();
-        }
+        interval.removePositionChangeListeners();
     }
 }
 exports.LocalIntervalCollection = LocalIntervalCollection;
 LocalIntervalCollection.legacyIdPrefix = "legacy";
-class SequenceIntervalCollectionFactory {
-    load(emitter, raw = [], options) {
-        return new IntervalCollection(index_js_2.sequenceIntervalHelpers, true, emitter, raw, options);
-    }
-    store(value) {
-        return value.serializeInternal();
-    }
-}
-class SequenceIntervalCollectionValueType {
-    get name() {
-        return SequenceIntervalCollectionValueType.Name;
-    }
-    get factory() {
-        return SequenceIntervalCollectionValueType._factory;
-    }
-    get ops() {
-        return SequenceIntervalCollectionValueType._ops;
-    }
-}
-exports.SequenceIntervalCollectionValueType = SequenceIntervalCollectionValueType;
-SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
-SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
-SequenceIntervalCollectionValueType._ops = makeOpsMap();
-class IntervalCollectionFactory {
-    load(emitter, raw = [], options) {
-        const helpers = {
-            create: index_js_2.createInterval,
-        };
-        const collection = new IntervalCollection(helpers, false, emitter, raw, options);
-        collection.attachGraph(undefined, "");
-        return collection;
-    }
-    store(value) {
-        return value.serializeInternal();
-    }
-}
-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;
     }
-}
-exports.IntervalCollectionValueType = IntervalCollectionValueType;
-IntervalCollectionValueType.Name = "sharedIntervalCollection";
-IntervalCollectionValueType._factory = new IntervalCollectionFactory();
-IntervalCollectionValueType._ops = makeOpsMap();
-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([
-        [
-            index_js_2.IntervalOpType.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.IntervalOpType.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.IntervalOpType.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,
-            },
-        ],
-    ]);
-}
-exports.makeOpsMap = makeOpsMap;
+    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 = [];
@@ -383,11 +307,9 @@ class IntervalCollection extends client_utils_1.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();
@@ -465,7 +387,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         if (this.attached) {
             throw new internal_3.LoggingError("Only supports one Sequence attach");
         }
-        if (client === undefined && this.requiresClient) {
+        if (client === undefined) {
             throw new internal_3.LoggingError("Client required for this collection");
         }
         // Instantiate the local interval collection based on the saved intervals
@@ -477,7 +399,7 @@ class IntervalCollection extends client_utils_1.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);
@@ -488,7 +410,7 @@ class IntervalCollection extends client_utils_1.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 = (0, index_js_2.createSequenceInterval)(label, start, end, client, intervalType, undefined, true, this.options.mergeTreeReferencesCanSlideToEndpoint);
                 if (properties) {
                     interval.properties = (0, internal_2.addProperties)(interval.properties, properties);
                 }
@@ -510,22 +432,14 @@ class IntervalCollection extends client_utils_1.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 index_js_2.SequenceIntervalClass) {
-            startRefType = previousInterval.start.refType;
-            endRefType = previousInterval.end.refType;
-            previousInterval.start.refType = internal_2.ReferenceType.Transient;
-            previousInterval.end.refType = internal_2.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 = internal_2.ReferenceType.Transient;
+        previousInterval.end.refType = internal_2.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}
@@ -558,7 +472,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         this.assertStickinessEnabled(start, end);
         const interval = this.localCollection.addInterval(toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), index_js_2.IntervalType.SlideOnRemove, props);
         if (interval) {
-            if (!this.isCollaborating && interval instanceof index_js_2.SequenceIntervalClass) {
+            if (!this.isCollaborating) {
                 setSlideOnRemove(interval.start);
                 setSlideOnRemove(interval.end);
             }
@@ -576,8 +490,12 @@ class IntervalCollection extends client_utils_1.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;
@@ -591,7 +509,10 @@ class IntervalCollection extends client_utils_1.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(),
                 });
             }
@@ -646,7 +567,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             }
             if (start !== undefined && end !== undefined) {
                 newInterval = this.localCollection.changeInterval(interval, start, end);
-                if (!this.isCollaborating && newInterval instanceof index_js_2.SequenceIntervalClass) {
+                if (!this.isCollaborating && newInterval !== undefined) {
                     setSlideOnRemove(newInterval.start);
                     setSlideOnRemove(newInterval.end);
                 }
@@ -668,7 +589,12 @@ class IntervalCollection extends client_utils_1.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);
@@ -676,10 +602,8 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             if (newInterval) {
                 this.addPendingChange(id, serializedInterval);
                 this.emitChange(newInterval, interval, true, false);
-                if (interval instanceof index_js_2.SequenceIntervalClass) {
-                    this.client?.removeLocalReferencePosition(interval.start);
-                    this.client?.removeLocalReferencePosition(interval.end);
-                }
+                this.client?.removeLocalReferencePosition(interval.start);
+                this.client?.removeLocalReferencePosition(interval.end);
             }
             return newInterval;
         }
@@ -859,8 +783,6 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             return undefined;
         }
         if (localInterval !== undefined) {
-            // we know we must be using `SequenceInterval` because `this.client` exists
-            (0, internal_1.assert)(localInterval instanceof index_js_2.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 ?? internal_2.Side.Before), toOptionalSequencePlace(endRebased, endSide ?? internal_2.Side.Before), undefined, localSeq);
@@ -885,10 +807,6 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         return value;
     }
     ackInterval(interval, op) {
-        // Only SequenceIntervals need potential sliding
-        if (!(interval instanceof index_js_2.SequenceIntervalClass)) {
-            return;
-        }
         if (!(0, internal_2.refTypeIncludesFlag)(interval.start, internal_2.ReferenceType.StayOnRemove) &&
             !(0, internal_2.refTypeIncludesFlag)(interval.end, internal_2.ReferenceType.StayOnRemove)) {
             return;
@@ -987,11 +905,11 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             this.deleteExistingInterval(interval, local, op);
         }
     }
-    serializeInternal() {
+    serializeInternal(version) {
         if (!this.localCollection) {
             throw new internal_3.LoggingError("attachSequence must be called");
         }
-        return this.localCollection.serialize();
+        return this.localCollection.serialize(version);
     }
     /**
      * @returns an iterator over all intervals in this collection.