@fluidframework/sequence 2.0.0-internal.5.1.0 → 2.0.0-internal.5.2.0

package/lib/intervalCollection.js

@@ -19,7 +19,7 @@ import { UsageError } from "@fluidframework/container-utils";
 import { addProperties, compareReferencePositions, createMap, MergeTreeDeltaType, minReferencePosition, PropertiesManager, RedBlackTree, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, maxReferencePosition, createDetachedLocalReferencePosition, DetachedReferencePosition, SlidingPreference, } from "@fluidframework/merge-tree";
 import { LoggingError } from "@fluidframework/telemetry-utils";
 import { v4 as uuid } from "uuid";
-import { IntervalTree } from "./intervalTree";
+import { createOverlappingIntervalsIndex } from "./intervalIndex";
 const reservedIntervalIdKey = "intervalId";
 /**
  * Values are used in persisted formats (ops) and revertibles.
@@ -498,7 +498,7 @@ export class SequenceInterval {
         }
     }
 }
-function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference) {
+export function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference) {
     if (segoff.segment) {
         const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined, slidingPreference);
         return ref;
@@ -574,98 +574,6 @@ export function createIntervalIndex() {
     const lc = new LocalIntervalCollection(undefined, "", helpers);
     return lc;
 }
-class OverlappingIntervalsIndex {
-    constructor(client, helpers) {
-        this.client = client;
-        this.helpers = helpers;
-        this.intervalTree = new IntervalTree();
-    }
-    map(fn) {
-        this.intervalTree.map(fn);
-    }
-    mapUntil(fn) {
-        this.intervalTree.mapUntil(fn);
-    }
-    gatherIterationResults(results, iteratesForward, start, end) {
-        if (this.intervalTree.intervals.isEmpty()) {
-            return;
-        }
-        if (start === undefined && end === undefined) {
-            // No start/end provided. Gather the whole tree in the specified order.
-            if (iteratesForward) {
-                this.intervalTree.map((interval) => {
-                    results.push(interval);
-                });
-            }
-            else {
-                this.intervalTree.mapBackward((interval) => {
-                    results.push(interval);
-                });
-            }
-        }
-        else {
-            const transientInterval = this.helpers.create("transient", start, end, this.client, IntervalType.Transient);
-            if (start === undefined) {
-                // Only end position provided. Since the tree is not sorted by end position,
-                // walk the whole tree in the specified order, gathering intervals that match the end.
-                if (iteratesForward) {
-                    this.intervalTree.map((interval) => {
-                        if (transientInterval.compareEnd(interval) === 0) {
-                            results.push(interval);
-                        }
-                    });
-                }
-                else {
-                    this.intervalTree.mapBackward((interval) => {
-                        if (transientInterval.compareEnd(interval) === 0) {
-                            results.push(interval);
-                        }
-                    });
-                }
-            }
-            else {
-                // Start and (possibly) end provided. Walk the subtrees that may contain
-                // this start position.
-                const compareFn = end === undefined
-                    ? (node) => {
-                        return transientInterval.compareStart(node.key);
-                    }
-                    : (node) => {
-                        return transientInterval.compare(node.key);
-                    };
-                const continueLeftFn = (cmpResult) => cmpResult <= 0;
-                const continueRightFn = (cmpResult) => cmpResult >= 0;
-                const actionFn = (node) => {
-                    results.push(node.key);
-                };
-                if (iteratesForward) {
-                    this.intervalTree.intervals.walkExactMatchesForward(compareFn, actionFn, continueLeftFn, continueRightFn);
-                }
-                else {
-                    this.intervalTree.intervals.walkExactMatchesBackward(compareFn, actionFn, continueLeftFn, continueRightFn);
-                }
-            }
-        }
-    }
-    /**
-     * @returns an array of all intervals contained in this collection that overlap the range
-     * `[startPosition, endPosition)`.
-     */
-    findOverlappingIntervals(startPosition, endPosition) {
-        if (endPosition < startPosition || this.intervalTree.intervals.isEmpty()) {
-            return [];
-        }
-        const transientInterval = this.helpers.create("transient", startPosition, endPosition, this.client, IntervalType.Transient);
-        const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
-        return overlappingIntervalNodes.map((node) => node.key);
-    }
-    remove(interval) {
-        this.intervalTree.removeExisting(interval);
-    }
-    add(interval) {
-        this.intervalTree.put(interval);
-    }
-}
 class IdIntervalIndex {
     constructor() {
         this.intervalIdMap = new Map();
@@ -840,7 +748,7 @@ export class LocalIntervalCollection {
         this.label = label;
         this.helpers = helpers;
         this.onPositionChange = onPositionChange;
-        this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
+        this.overlappingIntervalsIndex = createOverlappingIntervalsIndex(client, helpers);
         this.idIntervalIndex = new IdIntervalIndex();
         this.endIntervalIndex = new EndpointIndex(client, helpers);
         this.indexes = new Set([
@@ -1234,7 +1142,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 }
             });
         }
-        this.localCollection = new LocalIntervalCollection(client, label, this.helpers, (interval, previousInterval) => this.emitChange(interval, previousInterval, true));
+        this.localCollection = new LocalIntervalCollection(client, label, this.helpers, (interval, previousInterval) => this.emitChange(interval, previousInterval, true, true));
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
                 this.localCollection.ensureSerializedId(serializedInterval);
@@ -1257,7 +1165,7 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         return 0;
     }
-    emitChange(interval, previousInterval, local, op) {
+    emitChange(interval, previousInterval, local, slide, op) {
         // 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.
@@ -1268,12 +1176,12 @@ export class IntervalCollection extends TypedEventEmitter {
             endRefType = previousInterval.end.refType;
             previousInterval.start.refType = ReferenceType.Transient;
             previousInterval.end.refType = ReferenceType.Transient;
-            this.emit("changeInterval", interval, previousInterval, local, op);
+            this.emit("changeInterval", interval, previousInterval, local, op, slide);
             previousInterval.start.refType = startRefType;
             previousInterval.end.refType = endRefType;
         }
         else {
-            this.emit("changeInterval", interval, previousInterval, local, op);
+            this.emit("changeInterval", interval, previousInterval, local, op, slide);
         }
     }
     /**
@@ -1409,7 +1317,7 @@ export class IntervalCollection extends TypedEventEmitter {
             this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
             this.emitter.emit("change", undefined, serializedInterval, { localSeq });
             this.addPendingChange(id, serializedInterval);
-            this.emitChange(newInterval, interval, true);
+            this.emitChange(newInterval, interval, true, false);
             return newInterval;
         }
         // No interval to change
@@ -1517,7 +1425,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 this.onDeserialize(newInterval);
             }
             if (newInterval !== interval) {
-                this.emitChange(newInterval, interval, local, op);
+                this.emitChange(newInterval, interval, local, false, op);
             }
             const changedProperties = Object.keys(newProps).length > 0;
             if (changedProperties) {
@@ -1683,7 +1591,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 (_b = oldSeg === null || oldSeg === void 0 ? void 0 : oldSeg.localRefs) === null || _b === void 0 ? void 0 : _b.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
             }
             this.localCollection.add(interval);
-            this.emitChange(interval, oldInterval, true, op);
+            this.emitChange(interval, oldInterval, true, true, op);
         }
     }
     /** @internal */