@fluidframework/sequence 2.0.0-internal.5.3.2 → 2.0.0-internal.5.4.0

package/lib/intervalCollection.js

@@ -16,39 +16,12 @@ var __rest = (this && this.__rest) || function (s, e) {
 /* eslint-disable no-bitwise */
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
-import { addProperties, compareReferencePositions, createMap, getSlideToSegoff, MergeTreeDeltaType, minReferencePosition, PropertiesManager, RedBlackTree, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, maxReferencePosition, createDetachedLocalReferencePosition, DetachedReferencePosition, SlidingPreference, } from "@fluidframework/merge-tree";
+import { addProperties, createMap, getSlideToSegoff, MergeTreeDeltaType, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, DetachedReferencePosition, } from "@fluidframework/merge-tree";
 import { LoggingError } from "@fluidframework/telemetry-utils";
 import { v4 as uuid } from "uuid";
-import { createOverlappingIntervalsIndex } from "./intervalIndex";
+import { IntervalOpType, IntervalStickiness, IntervalType, SequenceInterval, createPositionReferenceFromSegoff, endReferenceSlidingPreference, startReferenceSlidingPreference, sequenceIntervalHelpers, createInterval, } from "./intervals";
+import { createEndpointIndex, createIdIntervalIndex, createOverlappingIntervalsIndex, } from "./intervalIndex";
 const reservedIntervalIdKey = "intervalId";
-/**
- * Values are used in persisted formats (ops) and revertibles.
- * @alpha
- */
-export const IntervalOpType = {
-    ADD: "add",
-    DELETE: "delete",
-    CHANGE: "change",
-    PROPERTY_CHANGED: "propertyChanged",
-    POSITION_REMOVE: "positionRemove",
-};
-export var IntervalType;
-(function (IntervalType) {
-    IntervalType[IntervalType["Simple"] = 0] = "Simple";
-    IntervalType[IntervalType["Nest"] = 1] = "Nest";
-    /**
-     * SlideOnRemove indicates that the ends of the interval will slide if the segment
-     * they reference is removed and acked.
-     * See `packages\dds\merge-tree\docs\REFERENCEPOSITIONS.md` for details
-     * SlideOnRemove is the default interval behavior and does not need to be specified.
-     */
-    IntervalType[IntervalType["SlideOnRemove"] = 2] = "SlideOnRemove";
-    /**
-     * A temporary interval, used internally
-     * @internal
-     */
-    IntervalType[IntervalType["Transient"] = 4] = "Transient";
-})(IntervalType || (IntervalType = {}));
 /**
  * Decompress an interval after loading a summary from JSON. The exact format
  * of this compression is unspecified and subject to change
@@ -81,665 +54,14 @@ function compressInterval(interval) {
     }
     return base;
 }
-function startReferenceSlidingPreference(stickiness) {
-    // if any start stickiness, prefer sliding backwards
-    return (stickiness & IntervalStickiness.START) !== 0
-        ? SlidingPreference.BACKWARD
-        : SlidingPreference.FORWARD;
-}
-function endReferenceSlidingPreference(stickiness) {
-    // if any end stickiness, prefer sliding forwards
-    return (stickiness & IntervalStickiness.END) !== 0
-        ? SlidingPreference.FORWARD
-        : SlidingPreference.BACKWARD;
-}
-/**
- * Determines how an interval should expand when segments are inserted adjacent
- * to the range it spans
- *
- * Note that interval stickiness is currently an experimental feature and must
- * be explicitly enabled with the `intervalStickinessEnabled` flag
- */
-export const IntervalStickiness = {
-    /**
-     * Interval does not expand to include adjacent segments
-     */
-    NONE: 0b00,
-    /**
-     * Interval expands to include segments inserted adjacent to the start
-     */
-    START: 0b01,
-    /**
-     * Interval expands to include segments inserted adjacent to the end
-     *
-     * This is the default stickiness
-     */
-    END: 0b10,
-    /**
-     * Interval expands to include all segments inserted adjacent to it
-     */
-    FULL: 0b11,
-};
-/**
- * Serializable interval whose endpoints are plain-old numbers.
- */
-export class Interval {
-    constructor(start, end, props) {
-        this.start = start;
-        this.end = end;
-        this.propertyManager = new PropertiesManager();
-        this.properties = {};
-        if (props) {
-            this.addProperties(props);
-        }
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.getIntervalId}
-     */
-    getIntervalId() {
-        var _a;
-        const id = (_a = this.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        assert(id !== undefined, 0x5e1 /* interval ID should not be undefined */);
-        return `${id}`;
-    }
-    /**
-     * @returns an array containing any auxiliary property sets added with `addPropertySet`.
-     */
-    getAdditionalPropertySets() {
-        var _a;
-        return (_a = this.auxProps) !== null && _a !== void 0 ? _a : [];
-    }
-    /**
-     * Adds an auxiliary set of properties to this interval.
-     * These properties can be recovered using `getAdditionalPropertySets`
-     * @param props - set of properties to add
-     * @remarks - This gets called as part of the default conflict resolver for `IIntervalCollection<Interval>`
-     * (i.e. non-sequence-based interval collections). However, the additional properties don't get serialized.
-     * This functionality seems half-baked.
-     */
-    addPropertySet(props) {
-        if (this.auxProps === undefined) {
-            this.auxProps = [];
-        }
-        this.auxProps.push(props);
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.serialize}
-     * @internal
-     */
-    serialize() {
-        const serializedInterval = {
-            end: this.end,
-            intervalType: 0,
-            sequenceNumber: 0,
-            start: this.start,
-        };
-        if (this.properties) {
-            serializedInterval.properties = this.properties;
-        }
-        return serializedInterval;
-    }
-    /**
-     * {@inheritDoc IInterval.clone}
-     */
-    clone() {
-        return new Interval(this.start, this.end, this.properties);
-    }
-    /**
-     * {@inheritDoc IInterval.compare}
-     */
-    compare(b) {
-        const startResult = this.compareStart(b);
-        if (startResult === 0) {
-            const endResult = this.compareEnd(b);
-            if (endResult === 0) {
-                const thisId = this.getIntervalId();
-                if (thisId) {
-                    const bId = b.getIntervalId();
-                    if (bId) {
-                        return thisId > bId ? 1 : thisId < bId ? -1 : 0;
-                    }
-                    return 0;
-                }
-                return 0;
-            }
-            else {
-                return endResult;
-            }
-        }
-        else {
-            return startResult;
-        }
-    }
-    /**
-     * {@inheritDoc IInterval.compareStart}
-     */
-    compareStart(b) {
-        return this.start - b.start;
-    }
-    /**
-     * {@inheritDoc IInterval.compareEnd}
-     */
-    compareEnd(b) {
-        return this.end - b.end;
-    }
-    /**
-     * {@inheritDoc IInterval.overlaps}
-     */
-    overlaps(b) {
-        const result = this.start <= b.end && this.end >= b.start;
-        return result;
-    }
-    /**
-     * {@inheritDoc IInterval.union}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    union(b) {
-        return new Interval(Math.min(this.start, b.start), Math.max(this.end, b.end), this.properties);
-    }
-    getProperties() {
-        return this.properties;
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.addProperties}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    addProperties(newProps, collaborating = false, seq, op) {
-        if (newProps) {
-            this.initializeProperties();
-            return this.propertyManager.addProperties(this.properties, newProps, op, seq, collaborating);
-        }
-    }
-    /**
-     * {@inheritDoc IInterval.modify}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    modify(label, start, end, op) {
-        const startPos = start !== null && start !== void 0 ? start : this.start;
-        const endPos = end !== null && end !== void 0 ? end : this.end;
-        if (this.start === startPos && this.end === endPos) {
-            // Return undefined to indicate that no change is necessary.
-            return;
-        }
-        const newInterval = new Interval(startPos, endPos);
-        if (this.properties) {
-            newInterval.initializeProperties();
-            this.propertyManager.copyTo(this.properties, newInterval.properties, newInterval.propertyManager);
-        }
-        return newInterval;
-    }
-    initializeProperties() {
-        if (!this.propertyManager) {
-            this.propertyManager = new PropertiesManager();
-        }
-        if (!this.properties) {
-            this.properties = createMap();
-        }
-    }
-}
-/**
- * Interval implementation whose ends are associated with positions in a mutatable sequence.
- * As such, when content is inserted into the middle of the interval, the interval expands to
- * include that content.
- *
- * @remarks - The endpoint's position should be treated exclusively to get reasonable behavior--i.e.
- * an interval referring to "hello" in "hello world" should have a start position of 0 and an end
- * position of 5.
- *
- * To see why, consider what happens if "llo wor" is removed from the string to make "held".
- * The interval's startpoint remains on the "h" (it isn't altered), but the interval's endpoint
- * slides forward to the next unremoved position, which is the "l" in "held".
- * Users would generally expect the interval to now refer to "he" (as it is the subset of content
- * remaining after the removal), hence the "l" should be excluded.
- * If the interval endpoint was treated inclusively, the interval would now refer to "hel", which
- * is undesirable.
- *
- * Since the end of an interval is treated exclusively but cannot be greater than or equal to the
- * length of the associated sequence, application models which leverage interval collections should
- * consider inserting a marker at the end of the sequence to represent the end of the content.
- */
-export class SequenceInterval {
-    constructor(client, 
-    /**
-     * Start endpoint of this interval.
-     * @remarks - This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    start, 
-    /**
-     * End endpoint of this interval.
-     * @remarks - This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    end, intervalType, props, stickiness = IntervalStickiness.END) {
-        this.client = client;
-        this.start = start;
-        this.end = end;
-        this.intervalType = intervalType;
-        this.stickiness = stickiness;
-        this.propertyManager = new PropertiesManager();
-        this.properties = {};
-        if (props) {
-            this.addProperties(props);
-        }
-    }
-    /**
-     * Subscribes to position change events on this interval if there are no current listeners.
-     * @internal
-     */
-    addPositionChangeListeners(beforePositionChange, afterPositionChange) {
-        var _a, _b;
-        var _c, _d;
-        if (this.callbacks === undefined) {
-            this.callbacks = {
-                beforePositionChange,
-                afterPositionChange,
-            };
-            const startCbs = ((_a = (_c = this.start).callbacks) !== null && _a !== void 0 ? _a : (_c.callbacks = {}));
-            const endCbs = ((_b = (_d = this.end).callbacks) !== null && _b !== void 0 ? _b : (_d.callbacks = {}));
-            startCbs.beforeSlide = endCbs.beforeSlide = beforePositionChange;
-            startCbs.afterSlide = endCbs.afterSlide = afterPositionChange;
-        }
-    }
-    /**
-     * Removes the currently subscribed position change listeners.
-     * @internal
-     */
-    removePositionChangeListeners() {
-        if (this.callbacks) {
-            this.callbacks = undefined;
-            this.start.callbacks = undefined;
-            this.end.callbacks = undefined;
-        }
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.serialize}
-     * @internal
-     */
-    serialize() {
-        const startPosition = this.client.localReferencePositionToPosition(this.start);
-        const endPosition = this.client.localReferencePositionToPosition(this.end);
-        const serializedInterval = {
-            end: endPosition,
-            intervalType: this.intervalType,
-            sequenceNumber: this.client.getCurrentSeq(),
-            start: startPosition,
-        };
-        if (this.properties) {
-            serializedInterval.properties = this.properties;
-        }
-        if (this.stickiness !== IntervalStickiness.END) {
-            serializedInterval.stickiness = this.stickiness;
-        }
-        return serializedInterval;
-    }
-    /**
-     * {@inheritDoc IInterval.clone}
-     */
-    clone() {
-        return new SequenceInterval(this.client, this.start, this.end, this.intervalType, this.properties, this.stickiness);
-    }
-    /**
-     * {@inheritDoc IInterval.compare}
-     */
-    compare(b) {
-        const startResult = this.compareStart(b);
-        if (startResult === 0) {
-            const endResult = this.compareEnd(b);
-            if (endResult === 0) {
-                const thisId = this.getIntervalId();
-                if (thisId) {
-                    const bId = b.getIntervalId();
-                    if (bId) {
-                        return thisId > bId ? 1 : thisId < bId ? -1 : 0;
-                    }
-                    return 0;
-                }
-                return 0;
-            }
-            else {
-                return endResult;
-            }
-        }
-        else {
-            return startResult;
-        }
-    }
-    /**
-     * {@inheritDoc IInterval.compareStart}
-     */
-    compareStart(b) {
-        return compareReferencePositions(this.start, b.start);
-    }
-    /**
-     * {@inheritDoc IInterval.compareEnd}
-     */
-    compareEnd(b) {
-        return compareReferencePositions(this.end, b.end);
-    }
-    /**
-     * {@inheritDoc IInterval.overlaps}
-     */
-    overlaps(b) {
-        const result = compareReferencePositions(this.start, b.end) <= 0 &&
-            compareReferencePositions(this.end, b.start) >= 0;
-        return result;
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.getIntervalId}
-     */
-    getIntervalId() {
-        var _a;
-        const id = (_a = this.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        assert(id !== undefined, 0x5e2 /* interval ID should not be undefined */);
-        return `${id}`;
-    }
-    /**
-     * {@inheritDoc IInterval.union}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    union(b) {
-        return new SequenceInterval(this.client, minReferencePosition(this.start, b.start), maxReferencePosition(this.end, b.end), this.intervalType);
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.addProperties}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    addProperties(newProps, collab = false, seq, op) {
-        this.initializeProperties();
-        return this.propertyManager.addProperties(this.properties, newProps, op, seq, collab);
-    }
-    /**
-     * @returns whether this interval overlaps two numerical positions.
-     */
-    overlapsPos(bstart, bend) {
-        const startPos = this.client.localReferencePositionToPosition(this.start);
-        const endPos = this.client.localReferencePositionToPosition(this.end);
-        return endPos > bstart && startPos < bend;
-    }
-    /**
-     * {@inheritDoc IInterval.modify}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    modify(label, start, end, op, localSeq, stickiness = IntervalStickiness.END) {
-        const getRefType = (baseType) => {
-            let refType = baseType;
-            if (op === undefined) {
-                refType &= ~ReferenceType.SlideOnRemove;
-                refType |= ReferenceType.StayOnRemove;
-            }
-            return refType;
-        };
-        let startRef = this.start;
-        if (start !== undefined) {
-            startRef = createPositionReference(this.client, start, getRefType(this.start.refType), op, undefined, localSeq, startReferenceSlidingPreference(stickiness));
-            if (this.start.properties) {
-                startRef.addProperties(this.start.properties);
-            }
-        }
-        let endRef = this.end;
-        if (end !== undefined) {
-            endRef = createPositionReference(this.client, end, getRefType(this.end.refType), op, undefined, localSeq, endReferenceSlidingPreference(stickiness));
-            if (this.end.properties) {
-                endRef.addProperties(this.end.properties);
-            }
-        }
-        const newInterval = new SequenceInterval(this.client, startRef, endRef, this.intervalType);
-        if (this.properties) {
-            newInterval.initializeProperties();
-            this.propertyManager.copyTo(this.properties, newInterval.properties, newInterval.propertyManager);
-        }
-        return newInterval;
-    }
-    initializeProperties() {
-        if (!this.propertyManager) {
-            this.propertyManager = new PropertiesManager();
-        }
-        if (!this.properties) {
-            this.properties = createMap();
-        }
-    }
-}
-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;
-    }
-    // Creating references on detached segments is allowed for:
-    // - Transient segments
-    // - References coming from a remote client (location may have been concurrently removed)
-    // - References being rebased to a new sequence number
-    //   (segment they originally referred to may have been removed with no suitable replacement)
-    if (!op &&
-        !localSeq &&
-        !fromSnapshot &&
-        !refTypeIncludesFlag(refType, ReferenceType.Transient)) {
-        throw new UsageError("Non-transient references need segment");
-    }
-    return createDetachedLocalReferencePosition(refType);
-}
-function createPositionReference(client, pos, refType, op, fromSnapshot, localSeq, slidingPreference) {
-    let segoff;
-    if (op) {
-        assert((refType & ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
-        segoff = client.getContainingSegment(pos, {
-            referenceSequenceNumber: op.referenceSequenceNumber,
-            clientId: op.clientId,
-        });
-        segoff = getSlideToSegoff(segoff);
-    }
-    else {
-        assert((refType & ReferenceType.SlideOnRemove) === 0 || !!fromSnapshot, 0x2f6 /* SlideOnRemove references must be op created */);
-        segoff = client.getContainingSegment(pos, undefined, localSeq);
-    }
-    return createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference);
-}
-export function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot, stickiness = IntervalStickiness.END) {
-    let beginRefType = ReferenceType.RangeBegin;
-    let endRefType = ReferenceType.RangeEnd;
-    if (intervalType === IntervalType.Transient) {
-        beginRefType = ReferenceType.Transient;
-        endRefType = ReferenceType.Transient;
-    }
-    else {
-        if (intervalType === IntervalType.Nest) {
-            beginRefType = ReferenceType.NestBegin;
-            endRefType = ReferenceType.NestEnd;
-        }
-        // All non-transient interval references must eventually be SlideOnRemove
-        // To ensure eventual consistency, they must start as StayOnRemove when
-        // pending (created locally and creation op is not acked)
-        if (op || fromSnapshot) {
-            beginRefType |= ReferenceType.SlideOnRemove;
-            endRefType |= ReferenceType.SlideOnRemove;
-        }
-        else {
-            beginRefType |= ReferenceType.StayOnRemove;
-            endRefType |= ReferenceType.StayOnRemove;
-        }
-    }
-    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot, undefined, startReferenceSlidingPreference(stickiness));
-    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot, undefined, endReferenceSlidingPreference(stickiness));
-    const rangeProp = {
-        [reservedRangeLabelsKey]: [label],
-    };
-    startLref.addProperties(rangeProp);
-    endLref.addProperties(rangeProp);
-    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp, stickiness);
-    return ival;
-}
 export function createIntervalIndex() {
     const helpers = {
-        compareEnds: compareIntervalEnds,
+        compareEnds: (a, b) => a.end - b.end,
         create: createInterval,
     };
     const lc = new LocalIntervalCollection(undefined, "", helpers);
     return lc;
 }
-class IdIntervalIndex {
-    constructor() {
-        this.intervalIdMap = new Map();
-    }
-    add(interval) {
-        const id = interval.getIntervalId();
-        assert(id !== undefined, 0x2c0 /* "ID must be created before adding interval to collection" */);
-        // Make the ID immutable.
-        Object.defineProperty(interval.properties, reservedIntervalIdKey, {
-            configurable: false,
-            enumerable: true,
-            writable: false,
-        });
-        this.intervalIdMap.set(id, interval);
-    }
-    remove(interval) {
-        const id = interval.getIntervalId();
-        assert(id !== undefined, 0x311 /* expected id to exist on interval */);
-        this.intervalIdMap.delete(id);
-    }
-    getIntervalById(id) {
-        return this.intervalIdMap.get(id);
-    }
-    [Symbol.iterator]() {
-        return this.intervalIdMap.values();
-    }
-}
-class EndpointIndex {
-    constructor(client, helpers) {
-        this.client = client;
-        this.helpers = helpers;
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        this.endIntervalTree = new RedBlackTree(helpers.compareEnds);
-    }
-    previousInterval(pos) {
-        const transientInterval = this.helpers.create("transient", pos, pos, this.client, IntervalType.Transient);
-        const rbNode = this.endIntervalTree.floor(transientInterval);
-        if (rbNode) {
-            return rbNode.data;
-        }
-    }
-    nextInterval(pos) {
-        const transientInterval = this.helpers.create("transient", pos, pos, this.client, IntervalType.Transient);
-        const rbNode = this.endIntervalTree.ceil(transientInterval);
-        if (rbNode) {
-            return rbNode.data;
-        }
-    }
-    add(interval) {
-        this.endIntervalTree.put(interval, interval);
-    }
-    remove(interval) {
-        this.endIntervalTree.remove(interval);
-    }
-}
-/**
- * Interface for intervals that have comparison override properties.
- */
-const forceCompare = Symbol();
-/**
- * Compares two objects based on their comparison override properties.
- * @returns A number indicating the order of the intervals (negative for a is lower than b, 0 for tie, positive for a is greater than b).
- */
-function compareOverrideables(a, b) {
-    var _a, _b;
-    const forceCompareA = (_a = a[forceCompare]) !== null && _a !== void 0 ? _a : 0;
-    const forceCompareB = (_b = b[forceCompare]) !== null && _b !== void 0 ? _b : 0;
-    return forceCompareA - forceCompareB;
-}
-class EndpointInRangeIndex {
-    constructor(helpers, client) {
-        this.helpers = helpers;
-        this.client = client;
-        this.intervalTree = new RedBlackTree((a, b) => {
-            const compareEndsResult = helpers.compareEnds(a, b);
-            if (compareEndsResult !== 0) {
-                return compareEndsResult;
-            }
-            const overrideablesComparison = compareOverrideables(a, b);
-            if (overrideablesComparison !== 0) {
-                return overrideablesComparison;
-            }
-            const aId = a.getIntervalId();
-            const bId = b.getIntervalId();
-            if (aId !== undefined && bId !== undefined) {
-                return aId.localeCompare(bId);
-            }
-            return 0;
-        });
-    }
-    add(interval) {
-        this.intervalTree.put(interval, interval);
-    }
-    remove(interval) {
-        this.intervalTree.remove(interval);
-    }
-    findIntervalsWithEndpointInRange(start, end) {
-        if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
-            return [];
-        }
-        const results = [];
-        const action = (node) => {
-            results.push(node.data);
-            return true;
-        };
-        const transientStartInterval = this.helpers.create("transient", start, start, this.client, IntervalType.Transient);
-        const transientEndInterval = this.helpers.create("transient", end, end, this.client, IntervalType.Transient);
-        // Add comparison overrides to the transient intervals
-        transientStartInterval[forceCompare] = -1;
-        transientEndInterval[forceCompare] = 1;
-        this.intervalTree.mapRange(action, results, transientStartInterval, transientEndInterval);
-        return results;
-    }
-}
-class StartpointInRangeIndex {
-    constructor(helpers, client) {
-        this.helpers = helpers;
-        this.client = client;
-        this.intervalTree = new RedBlackTree((a, b) => {
-            assert(typeof helpers.compareStarts === "function", 0x6d1 /* compareStarts does not exist in the helpers */);
-            const compareStartsResult = helpers.compareStarts(a, b);
-            if (compareStartsResult !== 0) {
-                return compareStartsResult;
-            }
-            const overrideablesComparison = compareOverrideables(a, b);
-            if (overrideablesComparison !== 0) {
-                return overrideablesComparison;
-            }
-            const aId = a.getIntervalId();
-            const bId = b.getIntervalId();
-            if (aId !== undefined && bId !== undefined) {
-                return aId.localeCompare(bId);
-            }
-            return 0;
-        });
-    }
-    add(interval) {
-        this.intervalTree.put(interval, interval);
-    }
-    remove(interval) {
-        this.intervalTree.remove(interval);
-    }
-    findIntervalsWithStartpointInRange(start, end) {
-        if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
-            return [];
-        }
-        const results = [];
-        const action = (node) => {
-            results.push(node.data);
-            return true;
-        };
-        const transientStartInterval = this.helpers.create("transient", start, start, this.client, IntervalType.Transient);
-        const transientEndInterval = this.helpers.create("transient", end, end, this.client, IntervalType.Transient);
-        // Add comparison overrides to the transient intervals
-        transientStartInterval[forceCompare] = -1;
-        transientEndInterval[forceCompare] = 1;
-        this.intervalTree.mapRange(action, results, transientStartInterval, transientEndInterval);
-        return results;
-    }
-}
-export function createEndpointInRangeIndex(helpers, client) {
-    return new EndpointInRangeIndex(helpers, client);
-}
-export function createStartpointInRangeIndex(helpers, client) {
-    return new StartpointInRangeIndex(helpers, client);
-}
 export class LocalIntervalCollection {
     constructor(client, label, helpers, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
@@ -749,8 +71,8 @@ export class LocalIntervalCollection {
         this.helpers = helpers;
         this.onPositionChange = onPositionChange;
         this.overlappingIntervalsIndex = createOverlappingIntervalsIndex(client, helpers);
-        this.idIntervalIndex = new IdIntervalIndex();
-        this.endIntervalIndex = new EndpointIndex(client, helpers);
+        this.idIntervalIndex = createIdIntervalIndex();
+        this.endIntervalIndex = createEndpointIndex(client, helpers);
         this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
@@ -904,18 +226,6 @@ export class LocalIntervalCollection {
     }
 }
 LocalIntervalCollection.legacyIdPrefix = "legacy";
-export const compareSequenceIntervalEnds = (a, b) => compareReferencePositions(a.end, b.end);
-export const compareSequenceIntervalStarts = (a, b) => compareReferencePositions(a.start, b.start);
-export const sequenceIntervalHelpers = {
-    compareEnds: compareSequenceIntervalEnds,
-    compareStarts: compareSequenceIntervalStarts,
-    create: createSequenceInterval,
-};
-export const intervalHelpers = {
-    compareEnds: (a, b) => a.end - b.end,
-    compareStarts: (a, b) => a.start - b.start,
-    create: createInterval,
-};
 class SequenceIntervalCollectionFactory {
     load(emitter, raw = [], options) {
         return new IntervalCollection(sequenceIntervalHelpers, true, emitter, raw, options);
@@ -938,18 +248,10 @@ export class SequenceIntervalCollectionValueType {
 SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
 SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
 SequenceIntervalCollectionValueType._ops = makeOpsMap();
-const compareIntervalEnds = (a, b) => a.end - b.end;
-function createInterval(label, start, end, client, intervalType, op, fromSnapshot) {
-    const rangeProp = {};
-    if (label && label.length > 0) {
-        rangeProp[reservedRangeLabelsKey] = [label];
-    }
-    return new Interval(start, end, rangeProp);
-}
 class IntervalCollectionFactory {
     load(emitter, raw = [], options) {
         const helpers = {
-            compareEnds: compareIntervalEnds,
+            compareEnds: (a, b) => a.end - b.end,
             create: createInterval,
         };
         const collection = new IntervalCollection(helpers, false, emitter, raw, options);
@@ -1667,6 +969,8 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithStartPosition}
+     *
+     * @deprecated - The sequence order of collection order will not be supported
      */
     CreateForwardIteratorWithStartPosition(startPosition) {
         const iterator = new IntervalCollectionIterator(this, true, startPosition);
@@ -1674,6 +978,8 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithStartPosition}
+     *
+     * @deprecated - The sequence order of collection order will not be supported
      */
     CreateBackwardIteratorWithStartPosition(startPosition) {
         const iterator = new IntervalCollectionIterator(this, false, startPosition);
@@ -1681,6 +987,8 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithEndPosition}
+     *
+     * @deprecated - The sequence order of collection order will not be supported
      */
     CreateForwardIteratorWithEndPosition(endPosition) {
         const iterator = new IntervalCollectionIterator(this, true, undefined, endPosition);
@@ -1688,6 +996,8 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithEndPosition}
+     *
+     * @deprecated - The sequence order of collection order will not be supported
      */
     CreateBackwardIteratorWithEndPosition(endPosition) {
         const iterator = new IntervalCollectionIterator(this, false, undefined, endPosition);
@@ -1695,6 +1005,8 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.gatherIterationResults}
+     * @deprecated - This API will be deprecated as its functionality will be moved to the `OverlappingIntervalsIndex`.
+     * We would like the user to attach the index to the collection on their own.
      */
     gatherIterationResults(results, iteratesForward, start, end) {
         if (!this.localCollection) {
@@ -1704,6 +1016,8 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.findOverlappingIntervals}
+     * @deprecated - This API will be deprecated as its functionality will be moved to the `OverlappingIntervalsIndex`.
+     * We would like the user to attach the index to the collection on their own.
      */
     findOverlappingIntervals(startPosition, endPosition) {
         if (!this.localCollection) {
@@ -1724,6 +1038,9 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.previousInterval}
+     *
+     * @deprecated - This API will be deprecated as its functionality will be moved to the `EndpointIndex`.
+     * We would like the user to attach the index to the collection on their own.
      */
     previousInterval(pos) {
         if (!this.localCollection) {
@@ -1733,6 +1050,9 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.nextInterval}
+     *
+     * @deprecated - This API will be deprecated as its functionality will be moved to the `EndpointIndex`.
+     * We would like the user to attach the index to the collection on their own.
      */
     nextInterval(pos) {
         if (!this.localCollection) {