@fluidframework/sequence 2.0.0-internal.4.2.1 → 2.0.0-internal.4.4.0

package/dist/intervalCollection.js

@@ -15,7 +15,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.IntervalCollectionIterator = exports.makeOpsMap = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.compareSequenceIntervalEnds = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.createSequenceInterval = exports.SequenceInterval = exports.Interval = exports.IntervalType = void 0;
+exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.IntervalCollectionIterator = exports.makeOpsMap = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.compareSequenceIntervalEnds = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.createSequenceInterval = exports.SequenceInterval = exports.Interval = exports.IntervalStickiness = exports.IntervalType = exports.IntervalOpType = void 0;
 /* eslint-disable no-bitwise */
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
@@ -24,6 +24,17 @@ const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const uuid_1 = require("uuid");
 const intervalTree_1 = require("./intervalTree");
 const reservedIntervalIdKey = "intervalId";
+/**
+ * Values are used in persisted formats (ops) and revertibles.
+ * @alpha
+ */
+exports.IntervalOpType = {
+    ADD: "add",
+    DELETE: "delete",
+    CHANGE: "change",
+    PROPERTY_CHANGED: "propertyChanged",
+    POSITION_REMOVE: "positionRemove",
+};
 var IntervalType;
 (function (IntervalType) {
     IntervalType[IntervalType["Simple"] = 0] = "Simple";
@@ -52,6 +63,7 @@ function decompressInterval(interval, label) {
         sequenceNumber: interval[2],
         intervalType: interval[3],
         properties: Object.assign(Object.assign({}, interval[4]), { [merge_tree_1.reservedRangeLabelsKey]: [label] }),
+        stickiness: interval[5],
     };
 }
 /**
@@ -60,14 +72,57 @@ function decompressInterval(interval, label) {
  */
 function compressInterval(interval) {
     const { start, end, sequenceNumber, intervalType, properties } = interval;
-    return [
+    const base = [
         start,
         end,
         sequenceNumber,
         intervalType,
         Object.assign(Object.assign({}, properties), { [merge_tree_1.reservedRangeLabelsKey]: undefined }),
     ];
+    if (interval.stickiness !== undefined && interval.stickiness !== exports.IntervalStickiness.END) {
+        base.push(interval.stickiness);
+    }
+    return base;
+}
+function startReferenceSlidingPreference(stickiness) {
+    // if any start stickiness, prefer sliding backwards
+    return (stickiness & exports.IntervalStickiness.START) !== 0
+        ? merge_tree_1.SlidingPreference.BACKWARD
+        : merge_tree_1.SlidingPreference.FORWARD;
+}
+function endReferenceSlidingPreference(stickiness) {
+    // if any end stickiness, prefer sliding forwards
+    return (stickiness & exports.IntervalStickiness.END) !== 0
+        ? merge_tree_1.SlidingPreference.FORWARD
+        : merge_tree_1.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
+ */
+exports.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.
  */
@@ -258,11 +313,12 @@ class SequenceInterval {
      * 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) {
+    end, intervalType, props, stickiness = exports.IntervalStickiness.END) {
         this.client = client;
         this.start = start;
         this.end = end;
         this.intervalType = intervalType;
+        this.stickiness = stickiness;
         this.propertyManager = new merge_tree_1.PropertiesManager();
         this.properties = {};
         if (props) {
@@ -314,13 +370,16 @@ class SequenceInterval {
         if (this.properties) {
             serializedInterval.properties = this.properties;
         }
+        if (this.stickiness !== exports.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);
+        return new SequenceInterval(this.client, this.start, this.end, this.intervalType, this.properties, this.stickiness);
     }
     /**
      * {@inheritDoc IInterval.compare}
@@ -404,7 +463,7 @@ class SequenceInterval {
      * {@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) {
+    modify(label, start, end, op, localSeq, stickiness = exports.IntervalStickiness.END) {
         const getRefType = (baseType) => {
             let refType = baseType;
             if (op === undefined) {
@@ -415,14 +474,14 @@ class SequenceInterval {
         };
         let startRef = this.start;
         if (start !== undefined) {
-            startRef = createPositionReference(this.client, start, getRefType(this.start.refType), op, undefined, localSeq);
+            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);
+            endRef = createPositionReference(this.client, end, getRefType(this.end.refType), op, undefined, localSeq, endReferenceSlidingPreference(stickiness));
             if (this.end.properties) {
                 endRef.addProperties(this.end.properties);
             }
@@ -444,9 +503,9 @@ class SequenceInterval {
     }
 }
 exports.SequenceInterval = SequenceInterval;
-function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot) {
+function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference) {
     if (segoff.segment) {
-        const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined);
+        const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined, slidingPreference);
         return ref;
     }
     // Creating references on detached segments is allowed for:
@@ -462,7 +521,7 @@ function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq
     }
     return (0, merge_tree_1.createDetachedLocalReferencePosition)(refType);
 }
-function createPositionReference(client, pos, refType, op, fromSnapshot, localSeq) {
+function createPositionReference(client, pos, refType, op, fromSnapshot, localSeq, slidingPreference) {
     let segoff;
     if (op) {
         (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
@@ -476,9 +535,9 @@ function createPositionReference(client, pos, refType, op, fromSnapshot, localSe
         (0, common_utils_1.assert)((refType & merge_tree_1.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);
+    return createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference);
 }
-function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot) {
+function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot, stickiness = exports.IntervalStickiness.END) {
     let beginRefType = merge_tree_1.ReferenceType.RangeBegin;
     let endRefType = merge_tree_1.ReferenceType.RangeEnd;
     if (intervalType === IntervalType.Transient) {
@@ -502,14 +561,14 @@ function createSequenceInterval(label, start, end, client, intervalType, op, fro
             endRefType |= merge_tree_1.ReferenceType.StayOnRemove;
         }
     }
-    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot);
-    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot);
+    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot, undefined, startReferenceSlidingPreference(stickiness));
+    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot, undefined, endReferenceSlidingPreference(stickiness));
     const rangeProp = {
         [merge_tree_1.reservedRangeLabelsKey]: [label],
     };
     startLref.addProperties(rangeProp);
     endLref.addProperties(rangeProp);
-    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp);
+    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp, stickiness);
     return ival;
 }
 exports.createSequenceInterval = createSequenceInterval;
@@ -680,11 +739,11 @@ class LocalIntervalCollection {
         this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
         this.idIntervalIndex = new IdIntervalIndex();
         this.endIntervalIndex = new EndpointIndex(client, helpers);
-        this.indexes = [
+        this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
             this.endIntervalIndex,
-        ];
+        ]);
     }
     createLegacyId(start, end) {
         // Create a non-unique ID based on start and end to be used on intervals that come from legacy clients
@@ -724,17 +783,23 @@ class LocalIntervalCollection {
             index.remove(interval);
         }
     }
+    appendIndex(index) {
+        this.indexes.add(index);
+    }
+    removeIndex(index) {
+        return this.indexes.delete(index);
+    }
     removeExistingInterval(interval) {
         this.removeIntervalFromIndexes(interval);
         this.removeIntervalListeners(interval);
     }
-    createInterval(start, end, intervalType, op) {
-        return this.helpers.create(this.label, start, end, this.client, intervalType, op);
+    createInterval(start, end, intervalType, op, stickiness = exports.IntervalStickiness.END) {
+        return this.helpers.create(this.label, start, end, this.client, intervalType, op, undefined, stickiness);
     }
-    addInterval(start, end, intervalType, props, op) {
+    addInterval(start, end, intervalType, props, op, stickiness = exports.IntervalStickiness.END) {
         var _a;
         var _b;
-        const interval = this.createInterval(start, end, intervalType, op);
+        const interval = this.createInterval(start, end, intervalType, op, stickiness);
         if (interval) {
             if (!interval.properties) {
                 interval.properties = (0, merge_tree_1.createMap)();
@@ -787,7 +852,7 @@ class LocalIntervalCollection {
                 // either, so this must be special-cased.
                 return ref;
             }
-            return this.client.createLocalReferencePosition(segment, ref.getOffset(), merge_tree_1.ReferenceType.Transient, ref.properties);
+            return this.client.createLocalReferencePosition(segment, ref.getOffset(), merge_tree_1.ReferenceType.Transient, ref.properties, ref.slidingPreference);
         };
         if (interval instanceof SequenceInterval) {
             let previousInterval;
@@ -824,12 +889,12 @@ LocalIntervalCollection.legacyIdPrefix = "legacy";
 const compareSequenceIntervalEnds = (a, b) => (0, merge_tree_1.compareReferencePositions)(a.end, b.end);
 exports.compareSequenceIntervalEnds = compareSequenceIntervalEnds;
 class SequenceIntervalCollectionFactory {
-    load(emitter, raw = []) {
+    load(emitter, raw = [], options) {
         const helpers = {
             compareEnds: exports.compareSequenceIntervalEnds,
             create: createSequenceInterval,
         };
-        return new IntervalCollection(helpers, true, emitter, raw);
+        return new IntervalCollection(helpers, true, emitter, raw, options);
     }
     store(value) {
         return value.serializeInternal();
@@ -851,7 +916,7 @@ SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
 SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
 SequenceIntervalCollectionValueType._ops = makeOpsMap();
 const compareIntervalEnds = (a, b) => a.end - b.end;
-function createInterval(label, start, end, client) {
+function createInterval(label, start, end, client, intervalType, op, fromSnapshot) {
     const rangeProp = {};
     if (label && label.length > 0) {
         rangeProp[merge_tree_1.reservedRangeLabelsKey] = [label];
@@ -859,12 +924,12 @@ function createInterval(label, start, end, client) {
     return new Interval(start, end, rangeProp);
 }
 class IntervalCollectionFactory {
-    load(emitter, raw = []) {
+    load(emitter, raw = [], options) {
         const helpers = {
             compareEnds: compareIntervalEnds,
             create: createInterval,
         };
-        const collection = new IntervalCollection(helpers, false, emitter, raw);
+        const collection = new IntervalCollection(helpers, false, emitter, raw, options);
         collection.attachGraph(undefined, "");
         return collection;
     }
@@ -896,7 +961,7 @@ function makeOpsMap() {
     };
     return new Map([
         [
-            "add",
+            exports.IntervalOpType.ADD,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -911,7 +976,7 @@ function makeOpsMap() {
             },
         ],
         [
-            "delete",
+            exports.IntervalOpType.DELETE,
             {
                 process: (collection, params, local, op) => {
                     (0, common_utils_1.assert)(op !== undefined, 0x3fc /* op should exist here */);
@@ -924,7 +989,7 @@ function makeOpsMap() {
             },
         ],
         [
-            "change",
+            exports.IntervalOpType.CHANGE,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -941,6 +1006,10 @@ function makeOpsMap() {
     ]);
 }
 exports.makeOpsMap = makeOpsMap;
+/**
+ * @deprecated - Public export will be removed. Use an appropriate iterator creation method on
+ * {@link IIntervalCollection} to iterate intervals instead.
+ */
 class IntervalCollectionIterator {
     constructor(collection, iteratesForward = true, start, end) {
         this.results = [];
@@ -962,19 +1031,16 @@ class IntervalCollectionIterator {
 }
 exports.IntervalCollectionIterator = IntervalCollectionIterator;
 /**
- * Collection of intervals that supports addition, modification, removal, and efficient spatial querying.
- * This class is not a DDS in its own right, but emits events on mutating operations such that it's possible to
- * integrate into a DDS.
- * This aligns with its usage in `SharedSegmentSequence`, which allows associating intervals to positions in the
- * sequence DDS which are broadcast to all other clients in an eventually consistent fashion.
+ * @deprecated - Use {@link IIntervalCollection} instead.
  */
 class IntervalCollection extends common_utils_1.TypedEventEmitter {
     /** @internal */
-    constructor(helpers, requiresClient, emitter, serializedIntervals) {
+    constructor(helpers, requiresClient, emitter, serializedIntervals, options = {}) {
         super();
         this.helpers = helpers;
         this.requiresClient = requiresClient;
         this.emitter = emitter;
+        this.options = options;
         this.localSeqToSerializedInterval = new Map();
         this.localSeqToRebasedInterval = new Map();
         this.pendingChangesStart = new Map();
@@ -986,6 +1052,36 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
     get attached() {
         return !!this.localCollection;
     }
+    /**
+     * {@inheritdoc IIntervalCollection.attachIndex}
+     */
+    attachIndex(index) {
+        var _a;
+        if (!this.attached) {
+            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
+        }
+        for (const interval of this) {
+            index.add(interval);
+        }
+        (_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.appendIndex(index);
+    }
+    /**
+     * {@inheritdoc IIntervalCollection.detachIndex}
+     */
+    detachIndex(index) {
+        var _a;
+        if (!this.attached) {
+            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
+        }
+        // Avoid removing intervals if the index does not exist
+        if (!((_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.removeIndex(index))) {
+            return false;
+        }
+        for (const interval of this) {
+            index.remove(interval);
+        }
+        return true;
+    }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
         var _a;
         if (!this.client) {
@@ -1041,8 +1137,8 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
                 this.localCollection.ensureSerializedId(serializedInterval);
-                const { start, end, intervalType, properties } = serializedInterval;
-                const interval = this.helpers.create(label, start, end, client, intervalType, undefined, true);
+                const { start, end, intervalType, properties, stickiness } = serializedInterval;
+                const interval = this.helpers.create(label, start, end, client, intervalType, undefined, true, stickiness);
                 if (properties) {
                     interval.addProperties(properties);
                 }
@@ -1080,8 +1176,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         }
     }
     /**
-     * @returns the interval in this collection that has the provided `id`.
-     * If no interval in the collection has this `id`, returns `undefined`.
+     * {@inheritdoc IIntervalCollection.getIntervalById}
      */
     getIntervalById(id) {
         if (!this.localCollection) {
@@ -1090,16 +1185,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return this.localCollection.idIntervalIndex.getIntervalById(id);
     }
     /**
-     * Creates a new interval and add it to the collection.
-     * @param start - interval start position (inclusive)
-     * @param end - interval end position (exclusive)
-     * @param intervalType - type of the interval. All intervals are SlideOnRemove. Intervals may not be Transient.
-     * @param props - properties of the interval
-     * @returns - the created interval
-     * @remarks - See documentation on {@link SequenceInterval} for comments on interval endpoint semantics: there are subtleties
-     * with how the current half-open behavior is represented.
+     * {@inheritdoc IIntervalCollection.add}
      */
-    add(start, end, intervalType, props) {
+    add(start, end, intervalType, props, stickiness = exports.IntervalStickiness.END) {
         var _a, _b;
         if (!this.localCollection) {
             throw new telemetry_utils_1.LoggingError("attach must be called prior to adding intervals");
@@ -1107,7 +1195,10 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         if (intervalType & IntervalType.Transient) {
             throw new telemetry_utils_1.LoggingError("Can not add transient intervals");
         }
-        const interval = this.localCollection.addInterval(start, end, intervalType, props);
+        if (stickiness !== exports.IntervalStickiness.END && !this.options.intervalStickinessEnabled) {
+            throw new container_utils_1.UsageError("attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag");
+        }
+        const interval = this.localCollection.addInterval(start, end, intervalType, props, undefined, stickiness);
         if (interval) {
             const serializedInterval = {
                 end,
@@ -1115,6 +1206,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
                 properties: interval.properties,
                 sequenceNumber: (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getCurrentSeq()) !== null && _b !== void 0 ? _b : 0,
                 start,
+                stickiness,
             };
             const localSeq = this.getNextLocalSeq();
             this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
@@ -1146,9 +1238,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         this.emit("deleteInterval", interval, local, op);
     }
     /**
-     * Removes an interval from the collection.
-     * @param id - Id of the interval to remove
-     * @returns the removed interval
+     * {@inheritdoc IIntervalCollection.removeIntervalById}
      */
     removeIntervalById(id) {
         if (!this.localCollection) {
@@ -1161,10 +1251,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return interval;
     }
     /**
-     * Changes the properties on an existing interval.
-     * @param id - Id of the interval whose properties should be changed
-     * @param props - Property set to apply to the interval. Shallow merging is used between any existing properties
-     * and `prop`, i.e. the interval will end up with a property object equivalent to `{ ...oldProps, ...props }`.
+     * {@inheritdoc IIntervalCollection.changeProperties}
      */
     changeProperties(id, props) {
         if (!this.attached) {
@@ -1194,11 +1281,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         }
     }
     /**
-     * Changes the endpoints of an existing interval.
-     * @param id - Id of the interval to change
-     * @param start - New start value, if defined. `undefined` signifies this endpoint should be left unchanged.
-     * @param end - New end value, if defined. `undefined` signifies this endpoint should be left unchanged.
-     * @returns the interval that was changed, if it existed in the collection.
+     * {@inheritdoc IIntervalCollection.change}
      */
     change(id, start, end) {
         if (!this.localCollection) {
@@ -1353,6 +1436,9 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
     }
+    /**
+     * {@inheritdoc IIntervalCollection.attachDeserializer}
+     */
     attachDeserializer(onDeserialize) {
         // If no deserializer is specified can skip all processing work
         if (!onDeserialize) {
@@ -1473,7 +1559,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             }
             if (needsStartUpdate) {
                 const props = interval.start.properties;
-                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op);
+                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op, startReferenceSlidingPreference(interval.stickiness));
                 if (props) {
                     interval.start.addProperties(props);
                 }
@@ -1485,7 +1571,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
-                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op);
+                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op, endReferenceSlidingPreference(interval.stickiness));
                 if (props) {
                     interval.end.addProperties(props);
                 }
@@ -1516,7 +1602,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         this.localCollection.ensureSerializedId(serializedInterval);
-        const interval = this.localCollection.addInterval(serializedInterval.start, serializedInterval.end, serializedInterval.intervalType, serializedInterval.properties, op);
+        const interval = this.localCollection.addInterval(serializedInterval.start, serializedInterval.end, serializedInterval.intervalType, serializedInterval.properties, op, serializedInterval.stickiness);
         if (interval) {
             if (this.onDeserialize) {
                 this.onDeserialize(interval);
@@ -1559,40 +1645,35 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return iterator;
     }
     /**
-     * @returns a forward iterator over all intervals in this collection with start point equal to `startPosition`.
+     * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithStartPosition}
      */
     CreateForwardIteratorWithStartPosition(startPosition) {
         const iterator = new IntervalCollectionIterator(this, true, startPosition);
         return iterator;
     }
     /**
-     * @returns a backward iterator over all intervals in this collection with start point equal to `startPosition`.
+     * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithStartPosition}
      */
     CreateBackwardIteratorWithStartPosition(startPosition) {
         const iterator = new IntervalCollectionIterator(this, false, startPosition);
         return iterator;
     }
     /**
-     * @returns a forward iterator over all intervals in this collection with end point equal to `endPosition`.
+     * {@inheritdoc IIntervalCollection.CreateForwardIteratorWithEndPosition}
      */
     CreateForwardIteratorWithEndPosition(endPosition) {
         const iterator = new IntervalCollectionIterator(this, true, undefined, endPosition);
         return iterator;
     }
     /**
-     * @returns a backward iterator over all intervals in this collection with end point equal to `endPosition`.
+     * {@inheritdoc IIntervalCollection.CreateBackwardIteratorWithEndPosition}
      */
     CreateBackwardIteratorWithEndPosition(endPosition) {
         const iterator = new IntervalCollectionIterator(this, false, undefined, endPosition);
         return iterator;
     }
     /**
-     * Gathers iteration results that optionally match a start/end criteria into the provided array.
-     * @param results - Array to gather the results into. In lieu of a return value, this array will be populated with
-     * intervals matching the query upon edit.
-     * @param iteratesForward - whether or not iteration should be in the forward direction
-     * @param start - If provided, only match intervals whose start point is equal to `start`.
-     * @param end - If provided, only match intervals whose end point is equal to `end`.
+     * {@inheritdoc IIntervalCollection.gatherIterationResults}
      */
     gatherIterationResults(results, iteratesForward, start, end) {
         if (!this.localCollection) {
@@ -1601,8 +1682,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         this.localCollection.overlappingIntervalsIndex.gatherIterationResults(results, iteratesForward, start, end);
     }
     /**
-     * @returns an array of all intervals in this collection that overlap with the interval
-     * `[startPosition, endPosition]`.
+     * {@inheritdoc IIntervalCollection.findOverlappingIntervals}
      */
     findOverlappingIntervals(startPosition, endPosition) {
         if (!this.localCollection) {
@@ -1611,7 +1691,7 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
         return this.localCollection.overlappingIntervalsIndex.findOverlappingIntervals(startPosition, endPosition);
     }
     /**
-     * Applies a function to each interval in this collection.
+     * {@inheritdoc IIntervalCollection.map}
      */
     map(fn) {
         if (!this.localCollection) {
@@ -1621,12 +1701,18 @@ class IntervalCollection extends common_utils_1.TypedEventEmitter {
             fn(interval);
         }
     }
+    /**
+     * {@inheritdoc IIntervalCollection.previousInterval}
+     */
     previousInterval(pos) {
         if (!this.localCollection) {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         return this.localCollection.endIntervalIndex.previousInterval(pos);
     }
+    /**
+     * {@inheritdoc IIntervalCollection.nextInterval}
+     */
     nextInterval(pos) {
         if (!this.localCollection) {
             throw new telemetry_utils_1.LoggingError("attachSequence must be called");