@fluidframework/sequence 2.0.0-dev.5.2.0.169897 → 2.0.0-dev.5.3.2.178189

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/sequence",
-  "version": "2.0.0-dev.5.2.0.169897",
+  "version": "2.0.0-dev.5.3.2.178189",
   "description": "Distributed sequence",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -37,30 +37,30 @@
   "dependencies": {
     "@fluidframework/common-definitions": "^0.20.1",
     "@fluidframework/common-utils": "^1.1.1",
-    "@fluidframework/container-utils": "2.0.0-dev.5.2.0.169897",
-    "@fluidframework/core-interfaces": "2.0.0-dev.5.2.0.169897",
-    "@fluidframework/datastore-definitions": "2.0.0-dev.5.2.0.169897",
-    "@fluidframework/merge-tree": "2.0.0-dev.5.2.0.169897",
+    "@fluidframework/container-utils": "2.0.0-dev.5.3.2.178189",
+    "@fluidframework/core-interfaces": "2.0.0-dev.5.3.2.178189",
+    "@fluidframework/datastore-definitions": "2.0.0-dev.5.3.2.178189",
+    "@fluidframework/merge-tree": "2.0.0-dev.5.3.2.178189",
     "@fluidframework/protocol-definitions": "^1.1.0",
-    "@fluidframework/runtime-definitions": "2.0.0-dev.5.2.0.169897",
-    "@fluidframework/runtime-utils": "2.0.0-dev.5.2.0.169897",
-    "@fluidframework/shared-object-base": "2.0.0-dev.5.2.0.169897",
-    "@fluidframework/telemetry-utils": "2.0.0-dev.5.2.0.169897",
+    "@fluidframework/runtime-definitions": "2.0.0-dev.5.3.2.178189",
+    "@fluidframework/runtime-utils": "2.0.0-dev.5.3.2.178189",
+    "@fluidframework/shared-object-base": "2.0.0-dev.5.3.2.178189",
+    "@fluidframework/telemetry-utils": "2.0.0-dev.5.3.2.178189",
     "uuid": "^8.3.1"
   },
   "devDependencies": {
-    "@fluid-internal/stochastic-test-utils": "2.0.0-dev.5.2.0.169897",
-    "@fluid-internal/test-dds-utils": "2.0.0-dev.5.2.0.169897",
-    "@fluid-tools/benchmark": "^0.47.0",
-    "@fluid-tools/build-cli": "^0.20.0-169245",
+    "@fluid-internal/stochastic-test-utils": "2.0.0-dev.5.3.2.178189",
+    "@fluid-internal/test-dds-utils": "2.0.0-dev.5.3.2.178189",
+    "@fluid-tools/benchmark": "^0.48.0",
+    "@fluid-tools/build-cli": "^0.21.0",
     "@fluidframework/build-common": "^1.2.0",
-    "@fluidframework/build-tools": "^0.20.0-169245",
+    "@fluidframework/build-tools": "^0.21.0",
     "@fluidframework/eslint-config-fluid": "^2.0.0",
     "@fluidframework/gitresources": "^0.1039.1000",
-    "@fluidframework/mocha-test-setup": "2.0.0-dev.5.2.0.169897",
-    "@fluidframework/sequence-previous": "npm:@fluidframework/sequence@2.0.0-internal.5.0.0",
+    "@fluidframework/mocha-test-setup": "2.0.0-dev.5.3.2.178189",
+    "@fluidframework/sequence-previous": "npm:@fluidframework/sequence@2.0.0-internal.5.2.0",
     "@fluidframework/server-services-client": "^0.1039.1000",
-    "@fluidframework/test-runtime-utils": "2.0.0-dev.5.2.0.169897",
+    "@fluidframework/test-runtime-utils": "2.0.0-dev.5.3.2.178189",
     "@microsoft/api-extractor": "^7.34.4",
     "@types/diff": "^3.5.1",
     "@types/mocha": "^9.1.1",
@@ -124,6 +124,6 @@
     "testfarm": "node dist/test/testFarm.js",
     "tsc": "tsc",
     "typetests:gen": "fluid-type-test-generator",
-    "typetests:prepare": "flub generate typetests --prepare --dir . --pin"
+    "typetests:prepare": "flub typetests --dir . --reset --previous --normalize"
   }
 }

package/src/index.ts

@@ -39,6 +39,12 @@ export {
 	createStartpointInRangeIndex,
 } from "./intervalCollection";
 export { IInterval, IntervalConflictResolver } from "./intervalTree";
+export {
+	SequenceIntervalIndexes,
+	IOverlappingIntervalsIndex,
+	createOverlappingIntervalsIndex,
+	createOverlappingSequenceIntervalsIndex,
+} from "./intervalIndex";
 export {
 	appendAddIntervalToRevertibles,
 	appendChangeIntervalToRevertibles,

package/src/intervalCollection.ts

@@ -13,6 +13,7 @@ import {
 	Client,
 	compareReferencePositions,
 	createMap,
+	getSlideToSegoff,
 	ICombiningOp,
 	ISegment,
 	MergeTreeDeltaType,
@@ -43,7 +44,8 @@ import {
 	IValueTypeOperationValue,
 	SequenceOptions,
 } from "./defaultMapInterfaces";
-import { IInterval, IntervalConflictResolver, IntervalTree, IntervalNode } from "./intervalTree";
+import { IInterval, IntervalConflictResolver } from "./intervalTree";
+import { IOverlappingIntervalsIndex, createOverlappingIntervalsIndex } from "./intervalIndex";
 
 const reservedIntervalIdKey = "intervalId";
 
@@ -772,7 +774,7 @@ export class SequenceInterval implements ISerializableInterval {
 	}
 }
 
-function createPositionReferenceFromSegoff(
+export function createPositionReferenceFromSegoff(
 	client: Client,
 	segoff: { segment: ISegment | undefined; offset: number | undefined },
 	refType: ReferenceType,
@@ -828,7 +830,7 @@ function createPositionReference(
 			referenceSequenceNumber: op.referenceSequenceNumber,
 			clientId: op.clientId,
 		});
-		segoff = client.getSlideToSegment(segoff);
+		segoff = getSlideToSegoff(segoff);
 	} else {
 		assert(
 			(refType & ReferenceType.SlideOnRemove) === 0 || !!fromSnapshot,
@@ -889,6 +891,7 @@ export function createSequenceInterval(
 		undefined,
 		startReferenceSlidingPreference(stickiness),
 	);
+
 	const endLref = createPositionReference(
 		client,
 		end,
@@ -898,6 +901,7 @@ export function createSequenceInterval(
 		undefined,
 		endReferenceSlidingPreference(stickiness),
 	);
+
 	const rangeProp = {
 		[reservedRangeLabelsKey]: [label],
 	};
@@ -949,135 +953,6 @@ export interface IntervalIndex<TInterval extends ISerializableInterval> {
 	remove(interval: TInterval): void;
 }
 
-class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
-	implements IntervalIndex<TInterval>
-{
-	private readonly intervalTree = new IntervalTree<TInterval>();
-
-	constructor(
-		private readonly client: Client,
-		private readonly helpers: IIntervalHelpers<TInterval>,
-	) {}
-
-	public map(fn: (interval: TInterval) => void) {
-		this.intervalTree.map(fn);
-	}
-
-	public mapUntil(fn: (interval: TInterval) => boolean) {
-		this.intervalTree.mapUntil(fn);
-	}
-
-	public gatherIterationResults(
-		results: TInterval[],
-		iteratesForward: boolean,
-		start?: number,
-		end?: number,
-	) {
-		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: TInterval) => {
-					results.push(interval);
-				});
-			} else {
-				this.intervalTree.mapBackward((interval: TInterval) => {
-					results.push(interval);
-				});
-			}
-		} else {
-			const transientInterval: TInterval = 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: TInterval) => {
-						if (transientInterval.compareEnd(interval) === 0) {
-							results.push(interval);
-						}
-					});
-				} else {
-					this.intervalTree.mapBackward((interval: TInterval) => {
-						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: IntervalNode<TInterval>) => {
-								return transientInterval.compareStart(node.key);
-						  }
-						: (node: IntervalNode<TInterval>) => {
-								return transientInterval.compare(node.key);
-						  };
-				const continueLeftFn = (cmpResult: number) => cmpResult <= 0;
-				const continueRightFn = (cmpResult: number) => cmpResult >= 0;
-				const actionFn = (node: IntervalNode<TInterval>) => {
-					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)`.
-	 */
-	public findOverlappingIntervals(startPosition: number, endPosition: number) {
-		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);
-	}
-
-	public remove(interval: TInterval) {
-		this.intervalTree.removeExisting(interval);
-	}
-
-	public add(interval: TInterval) {
-		this.intervalTree.put(interval);
-	}
-}
-
 class IdIntervalIndex<TInterval extends ISerializableInterval>
 	implements IntervalIndex<TInterval>, Iterable<TInterval>
 {
@@ -1380,7 +1255,7 @@ export function createStartpointInRangeIndex<TInterval extends ISerializableInte
 
 export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 	private static readonly legacyIdPrefix = "legacy";
-	public readonly overlappingIntervalsIndex: OverlappingIntervalsIndex<TInterval>;
+	public readonly overlappingIntervalsIndex: IOverlappingIntervalsIndex<TInterval>;
 	public readonly idIntervalIndex: IdIntervalIndex<TInterval>;
 	public readonly endIntervalIndex: EndpointIndex<TInterval>;
 	private readonly indexes: Set<IntervalIndex<TInterval>>;
@@ -1395,7 +1270,7 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 			previousInterval: TInterval,
 		) => void,
 	) {
-		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([
@@ -1493,6 +1368,17 @@ export class LocalIntervalCollection<TInterval extends ISerializableInterval> {
 			}
 
 			if (props) {
+				// This check is intended to prevent scenarios where a random interval is created and then
+				// inserted into a collection. The aim is to ensure that the collection is created first
+				// then the user can create/add intervals based on the collection
+				if (
+					props[reservedRangeLabelsKey] !== undefined &&
+					props[reservedRangeLabelsKey][0] !== this.label
+				) {
+					throw new LoggingError(
+						"Adding an interval that belongs to another interval collection is not permitted",
+					);
+				}
 				interval.addProperties(props);
 			}
 			interval.properties[reservedIntervalIdKey] ??= uuid();
@@ -1839,6 +1725,7 @@ export interface IIntervalCollectionEvent<TInterval extends ISerializableInterva
 	 * endpoints. These references should be used for position information only.
 	 * `local` reflects whether the change originated locally.
 	 * `op` is defined if and only if the server has acked this change.
+	 * `slide` is true if the change is due to sliding on removal of position
 	 */
 	(
 		event: "changeInterval",
@@ -1847,6 +1734,7 @@ export interface IIntervalCollectionEvent<TInterval extends ISerializableInterva
 			previousInterval: TInterval,
 			local: boolean,
 			op: ISequencedDocumentMessage | undefined,
+			slide: boolean,
 		) => void,
 	);
 	/**
@@ -2112,7 +2000,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		// if segment is undefined, it slid off the string
 		assert(segment !== undefined, 0x54e /* No segment found */);
 
-		const segoff = this.client.getSlideToSegment({ segment, offset }) ?? segment;
+		const segoff = getSlideToSegoff({ segment, offset }) ?? segment;
 
 		// case happens when rebasing op, but concurrently entire string has been deleted
 		if (segoff.segment === undefined || segoff.offset === undefined) {
@@ -2176,7 +2064,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			client,
 			label,
 			this.helpers,
-			(interval, previousInterval) => this.emitChange(interval, previousInterval, true),
+			(interval, previousInterval) => this.emitChange(interval, previousInterval, true, true),
 		);
 		if (this.savedSerializedIntervals) {
 			for (const serializedInterval of this.savedSerializedIntervals) {
@@ -2216,6 +2104,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		interval: TInterval,
 		previousInterval: TInterval,
 		local: boolean,
+		slide: boolean,
 		op?: ISequencedDocumentMessage,
 	): void {
 		// Temporarily make references transient so that positional queries work (non-transient refs
@@ -2228,11 +2117,11 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			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);
 		}
 	}
 
@@ -2351,6 +2240,13 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		if (!props) {
 			throw new LoggingError("changeProperties should be called with a property set");
 		}
+		// prevent the overwriting of an interval label, it should remain unchanged
+		// once it has been inserted into the collection.
+		if (props[reservedRangeLabelsKey] !== undefined) {
+			throw new LoggingError(
+				"The label property should not be modified once inserted to the collection",
+			);
+		}
 
 		const interval = this.getIntervalById(id);
 		if (interval) {
@@ -2402,7 +2298,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			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
@@ -2538,7 +2434,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 			}
 
 			if (newInterval !== interval) {
-				this.emitChange(newInterval, interval, local, op);
+				this.emitChange(newInterval, interval, local, false, op);
 			}
 
 			const changedProperties = Object.keys(newProps).length > 0;
@@ -2654,7 +2550,9 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		return rebased;
 	}
 
-	private getSlideToSegment(lref: LocalReferencePosition) {
+	private getSlideToSegment(
+		lref: LocalReferencePosition,
+	): { segment: ISegment | undefined; offset: number | undefined } | undefined {
 		if (!this.client) {
 			throw new LoggingError("client does not exist");
 		}
@@ -2662,7 +2560,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 		if (segoff.segment?.localRefs?.has(lref) !== true) {
 			return undefined;
 		}
-		const newSegoff = this.client.getSlideToSegment(segoff);
+		const newSegoff = getSlideToSegoff(segoff);
 		const value: { segment: ISegment | undefined; offset: number | undefined } | undefined =
 			segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
 				? undefined
@@ -2761,7 +2659,7 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 				oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
 			}
 			this.localCollection.add(interval);
-			this.emitChange(interval, oldInterval as TInterval, true, op);
+			this.emitChange(interval, oldInterval as TInterval, true, true, op);
 		}
 	}
 

package/src/intervalIndex/index.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export { SequenceIntervalIndexes } from "./sequenceIntervalIndexes";
+export {
+	IOverlappingIntervalsIndex,
+	createOverlappingIntervalsIndex,
+} from "./overlappingIntervalsIndex";
+export { createOverlappingSequenceIntervalsIndex } from "./overlappingSequenceIntervalsIndex";

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -0,0 +1,166 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Client } from "@fluidframework/merge-tree";
+import {
+	IntervalType,
+	IIntervalHelpers,
+	IntervalIndex,
+	ISerializableInterval,
+} from "../intervalCollection";
+import { IntervalNode, IntervalTree } from "../intervalTree";
+
+export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval>
+	extends IntervalIndex<TInterval> {
+	/**
+	 * @returns an array of all intervals contained in this collection that overlap the range
+	 * `[start end]`.
+	 */
+	findOverlappingIntervals(start: number, end: number): TInterval[];
+
+	/**
+	 * Gathers the interval results based on specified parameters.
+	 */
+	gatherIterationResults(
+		results: TInterval[],
+		iteratesForward: boolean,
+		start?: number,
+		end?: number,
+	): void;
+}
+
+export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
+	implements IOverlappingIntervalsIndex<TInterval>
+{
+	protected readonly intervalTree = new IntervalTree<TInterval>();
+	protected readonly client: Client;
+	protected readonly helpers: IIntervalHelpers<TInterval>;
+
+	constructor(client: Client, helpers: IIntervalHelpers<TInterval>) {
+		this.client = client;
+		this.helpers = helpers;
+	}
+
+	public map(fn: (interval: TInterval) => void) {
+		this.intervalTree.map(fn);
+	}
+
+	public mapUntil(fn: (interval: TInterval) => boolean) {
+		this.intervalTree.mapUntil(fn);
+	}
+
+	public gatherIterationResults(
+		results: TInterval[],
+		iteratesForward: boolean,
+		start?: number,
+		end?: number,
+	): void {
+		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: TInterval) => {
+					results.push(interval);
+				});
+			} else {
+				this.intervalTree.mapBackward((interval: TInterval) => {
+					results.push(interval);
+				});
+			}
+		} else {
+			const transientInterval: TInterval = 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: TInterval) => {
+						if (transientInterval.compareEnd(interval) === 0) {
+							results.push(interval);
+						}
+					});
+				} else {
+					this.intervalTree.mapBackward((interval: TInterval) => {
+						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: IntervalNode<TInterval>) => {
+								return transientInterval.compareStart(node.key);
+						  }
+						: (node: IntervalNode<TInterval>) => {
+								return transientInterval.compare(node.key);
+						  };
+				const continueLeftFn = (cmpResult: number) => cmpResult <= 0;
+				const continueRightFn = (cmpResult: number) => cmpResult >= 0;
+				const actionFn = (node: IntervalNode<TInterval>) => {
+					results.push(node.key);
+				};
+
+				if (iteratesForward) {
+					this.intervalTree.intervals.walkExactMatchesForward(
+						compareFn,
+						actionFn,
+						continueLeftFn,
+						continueRightFn,
+					);
+				} else {
+					this.intervalTree.intervals.walkExactMatchesBackward(
+						compareFn,
+						actionFn,
+						continueLeftFn,
+						continueRightFn,
+					);
+				}
+			}
+		}
+	}
+
+	public findOverlappingIntervals(start: number, end: number): TInterval[] {
+		if (end < start || this.intervalTree.intervals.isEmpty()) {
+			return [];
+		}
+		const transientInterval = this.helpers.create(
+			"transient",
+			start,
+			end,
+			this.client,
+			IntervalType.Transient,
+		);
+
+		const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
+		return overlappingIntervalNodes.map((node) => node.key);
+	}
+
+	public remove(interval: TInterval) {
+		this.intervalTree.removeExisting(interval);
+	}
+
+	public add(interval: TInterval) {
+		this.intervalTree.put(interval);
+	}
+}
+
+export function createOverlappingIntervalsIndex<TInterval extends ISerializableInterval>(
+	client: Client,
+	helpers: IIntervalHelpers<TInterval>,
+): IOverlappingIntervalsIndex<TInterval> {
+	return new OverlappingIntervalsIndex<TInterval>(client, helpers);
+}

package/src/intervalIndex/overlappingSequenceIntervalsIndex.ts

@@ -0,0 +1,71 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	Client,
+	ISegment,
+	ReferenceType,
+	compareReferencePositions,
+	reservedRangeLabelsKey,
+} from "@fluidframework/merge-tree";
+import {
+	sequenceIntervalHelpers,
+	IntervalType,
+	SequenceInterval,
+	createPositionReferenceFromSegoff,
+} from "../intervalCollection";
+import { SequenceIntervalIndexes } from "./sequenceIntervalIndexes";
+import { OverlappingIntervalsIndex } from "./overlappingIntervalsIndex";
+
+class OverlappingSequenceIntervalsIndex
+	extends OverlappingIntervalsIndex<SequenceInterval>
+	implements SequenceIntervalIndexes.Overlapping
+{
+	constructor(client: Client) {
+		super(client, sequenceIntervalHelpers);
+	}
+
+	public findOverlappingIntervalsBySegoff(
+		startSegoff: { segment: ISegment | undefined; offset: number | undefined },
+		endSegoff: { segment: ISegment | undefined; offset: number | undefined },
+	): Iterable<SequenceInterval> {
+		if (this.intervalTree.intervals.isEmpty()) {
+			return [];
+		}
+
+		const startLref = createPositionReferenceFromSegoff(
+			this.client,
+			startSegoff,
+			ReferenceType.Transient,
+		);
+
+		const endLref = createPositionReferenceFromSegoff(
+			this.client,
+			endSegoff,
+			ReferenceType.Transient,
+		);
+
+		if (compareReferencePositions(startLref, endLref) > 0) {
+			return [];
+		}
+
+		const transientInterval = new SequenceInterval(
+			this.client,
+			startLref,
+			endLref,
+			IntervalType.Transient,
+			{ [reservedRangeLabelsKey]: ["transient"] },
+		);
+
+		const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
+		return overlappingIntervalNodes.map((node) => node.key);
+	}
+}
+
+export function createOverlappingSequenceIntervalsIndex(
+	client: Client,
+): SequenceIntervalIndexes.Overlapping {
+	return new OverlappingSequenceIntervalsIndex(client);
+}

package/src/intervalIndex/sequenceIntervalIndexes.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISegment } from "@fluidframework/merge-tree";
+import { SequenceInterval } from "../intervalCollection";
+import { IOverlappingIntervalsIndex } from "./overlappingIntervalsIndex";
+
+/**
+ * This namespace contains specialiazations of indexes which support spatial queries
+ * specifically for `SequenceInterval`s.
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace SequenceIntervalIndexes {
+	/**
+	 * Collection of intervals.
+	 *
+	 * Provides additional APIs to support efficiently querying a collection of intervals based on segments and offset.
+	 */
+	export interface Overlapping extends IOverlappingIntervalsIndex<SequenceInterval> {
+		/**
+		 * Finds overlapping intervals within the specified range.
+		 *
+		 * @returns an array of all intervals that overlap with the specified SegOff range (includes both ends)
+		 */
+		findOverlappingIntervalsBySegoff(
+			startSegoff: { segment: ISegment | undefined; offset: number | undefined },
+			endSegoff: { segment: ISegment | undefined; offset: number | undefined },
+		);
+	}
+}