@fluidframework/sequence 2.90.0-378676 → 2.91.0

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -3,18 +3,15 @@
  * Licensed under the MIT License.
  */
 
-import {
-	Client,
-	SequencePlace,
-	endpointPosAndSide,
-} from "@fluidframework/merge-tree/internal";
+import { SequencePlace, endpointPosAndSide } from "@fluidframework/merge-tree/internal";
 
 import { IntervalNode, IntervalTree } from "../intervalTree.js";
 import {
 	SequenceInterval,
-	SequenceIntervalClass,
-	createTransientInterval,
+	BaseSequenceInterval,
+	createTransientIntervalFromSequence,
 } from "../intervals/index.js";
+import type { ISharedSegmentSequence } from "../sequence.js";
 import { ISharedString } from "../sharedString.js";
 
 import type { SequenceIntervalIndex } from "./intervalIndex.js";
@@ -41,12 +38,9 @@ export interface ISequenceOverlappingIntervalsIndex extends SequenceIntervalInde
 }
 
 export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsIndex {
-	protected readonly intervalTree = new IntervalTree<SequenceIntervalClass>();
-	protected readonly client: Client;
+	protected readonly intervalTree = new IntervalTree<BaseSequenceInterval>();
 
-	constructor(client: Client) {
-		this.client = client;
-	}
+	constructor(protected readonly sequence: ISharedSegmentSequence<any>) {}
 
 	public map(fn: (interval: SequenceInterval) => void) {
 		this.intervalTree.map(fn);
@@ -69,7 +63,7 @@ export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsI
 		if (start === undefined && end === undefined) {
 			// No start/end provided. Gather the whole tree in the specified order.
 			if (iteratesForward) {
-				this.intervalTree.map((interval: SequenceIntervalClass) => {
+				this.intervalTree.map((interval: SequenceInterval) => {
 					results.push(interval);
 				});
 			} else {
@@ -78,23 +72,23 @@ export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsI
 				});
 			}
 		} else {
-			const transientInterval: SequenceIntervalClass = createTransientInterval(
+			const transientInterval: BaseSequenceInterval = createTransientIntervalFromSequence(
 				start ?? "start",
 				end ?? "end",
-				this.client,
+				this.sequence,
 			);
 
 			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: SequenceIntervalClass) => {
+					this.intervalTree.map((interval: SequenceInterval) => {
 						if (transientInterval.compareEnd(interval) === 0) {
 							results.push(interval);
 						}
 					});
 				} else {
-					this.intervalTree.mapBackward((interval: SequenceIntervalClass) => {
+					this.intervalTree.mapBackward((interval: SequenceInterval) => {
 						if (transientInterval.compareEnd(interval) === 0) {
 							results.push(interval);
 						}
@@ -105,15 +99,15 @@ export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsI
 				// this start position.
 				const compareFn =
 					end === undefined
-						? (node: IntervalNode<SequenceIntervalClass>) => {
+						? (node: IntervalNode<BaseSequenceInterval>) => {
 								return transientInterval.compareStart(node.key);
 							}
-						: (node: IntervalNode<SequenceIntervalClass>) => {
+						: (node: IntervalNode<BaseSequenceInterval>) => {
 								return transientInterval.compare(node.key);
 							};
 				const continueLeftFn = (cmpResult: number) => cmpResult <= 0;
 				const continueRightFn = (cmpResult: number) => cmpResult >= 0;
-				const actionFn = (node: IntervalNode<SequenceIntervalClass>) => {
+				const actionFn = (node: IntervalNode<BaseSequenceInterval>) => {
 					results.push(node.key);
 				};
 
@@ -152,17 +146,17 @@ export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsI
 		) {
 			return [];
 		}
-		const transientInterval = createTransientInterval(start, end, this.client);
+		const transientInterval = createTransientIntervalFromSequence(start, end, this.sequence);
 
 		const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
 		return overlappingIntervalNodes.map((node) => node.key);
 	}
 
-	public remove(interval: SequenceIntervalClass) {
+	public remove(interval: BaseSequenceInterval) {
 		this.intervalTree.removeExisting(interval);
 	}
 
-	public add(interval: SequenceIntervalClass) {
+	public add(interval: BaseSequenceInterval) {
 		this.intervalTree.put(interval);
 	}
 }
@@ -175,6 +169,5 @@ export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsI
 export function createOverlappingIntervalsIndex(
 	sharedString: ISharedString,
 ): ISequenceOverlappingIntervalsIndex {
-	const client = (sharedString as unknown as { client: Client }).client;
-	return new OverlappingIntervalsIndex(client);
+	return new OverlappingIntervalsIndex(sharedString);
 }

package/src/intervalIndex/startpointInRangeIndex.ts

@@ -3,9 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree/internal";
+import { PropertyAction, RedBlackTree } from "@fluidframework/merge-tree/internal";
 
-import { SequenceInterval, createTransientInterval } from "../intervals/index.js";
+import { SequenceInterval, createTransientIntervalFromSequence } from "../intervals/index.js";
+import type { ISharedSegmentSequence } from "../sequence.js";
 import { ISharedString } from "../sharedString.js";
 
 import type { SequenceIntervalIndex } from "./intervalIndex.js";
@@ -31,7 +32,7 @@ export interface IStartpointInRangeIndex extends SequenceIntervalIndex {
 export class StartpointInRangeIndex implements IStartpointInRangeIndex {
 	private readonly intervalTree;
 
-	constructor(private readonly client: Client) {
+	constructor(private readonly sequence: ISharedSegmentSequence<any>) {
 		this.intervalTree = new RedBlackTree<SequenceInterval, SequenceInterval>(
 			(a: SequenceInterval, b: SequenceInterval) => {
 				const compareStartsResult = a.compareStart(b);
@@ -74,9 +75,13 @@ export class StartpointInRangeIndex implements IStartpointInRangeIndex {
 			return true;
 		};
 
-		const transientStartInterval = createTransientInterval(start, start, this.client);
+		const transientStartInterval = createTransientIntervalFromSequence(
+			start,
+			start,
+			this.sequence,
+		);
 
-		const transientEndInterval = createTransientInterval(end, end, this.client);
+		const transientEndInterval = createTransientIntervalFromSequence(end, end, this.sequence);
 
 		// Add comparison overrides to the transient intervals
 		(transientStartInterval as Partial<HasComparisonOverride>)[forceCompare] = -1;
@@ -94,6 +99,5 @@ export class StartpointInRangeIndex implements IStartpointInRangeIndex {
 export function createStartpointInRangeIndex(
 	sharedString: ISharedString,
 ): IStartpointInRangeIndex {
-	const client = (sharedString as unknown as { client: Client }).client;
-	return new StartpointInRangeIndex(client);
+	return new StartpointInRangeIndex(sharedString);
 }

package/src/intervals/index.ts

@@ -19,8 +19,10 @@ export {
 export {
 	SequenceInterval,
 	SequenceIntervalClass,
+	BaseSequenceInterval,
 	createSequenceInterval,
 	createPositionReferenceFromSegoff,
-	createTransientInterval,
+	createTransientIntervalFromSequence,
+	resolvePositionRef,
 	getSerializedProperties,
 } from "./sequenceInterval.js";

package/src/intervals/sequenceInterval.ts

@@ -35,6 +35,8 @@ import {
 import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 
+import type { ISharedSegmentSequence } from "../sequence.js";
+
 import {
 	ISerializableInterval,
 	ISerializedInterval,
@@ -182,8 +184,148 @@ export interface SequenceInterval extends IInterval {
 	getIntervalId(): string;
 }
 
+/**
+ * Lightweight interval for index queries (overlap, comparison).
+ * Has no Client dependency; cannot serialize or be disposed.
+ */
+export class BaseSequenceInterval implements SequenceInterval, ISerializableInterval {
+	readonly #id: string;
+	readonly #properties: PropertySet = createMap<any>();
+
+	constructor(
+		id: string,
+		/**
+		 * Start endpoint of this interval.
+		 * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
+		 */
+		public start: LocalReferencePosition,
+		/**
+		 * End endpoint of this interval.
+		 * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
+		 */
+		public end: LocalReferencePosition,
+		public intervalType: IntervalType,
+		public readonly startSide: Side = Side.Before,
+		public readonly endSide: Side = Side.Before,
+	) {
+		this.#id = id;
+	}
+
+	public get properties(): Readonly<PropertySet> {
+		return this.#properties;
+	}
+
+	/***/
+	public get stickiness(): IntervalStickiness {
+		this.verifyNotDispose();
+
+		const startSegment: ISegmentInternal | undefined = this.start.getSegment();
+		const endSegment: ISegmentInternal | undefined = this.end.getSegment();
+		return computeStickinessFromSide(
+			startSegment?.endpointType,
+			this.startSide,
+			endSegment?.endpointType,
+			this.endSide,
+		);
+	}
+
+	/**
+	 * {@inheritDoc ISerializableInterval.getIntervalId}
+	 */
+	public getIntervalId(): string {
+		return this.#id;
+	}
+
+	/**
+	 * {@inheritDoc IInterval.compare}
+	 */
+	public compare(b: SequenceInterval) {
+		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}
+	 */
+	public compareStart(b: SequenceInterval) {
+		this.verifyNotDispose();
+
+		const dist = compareReferencePositions(this.start, b.start);
+
+		if (dist === 0) {
+			return compareSides(this.startSide, b.startSide);
+		}
+
+		return dist;
+	}
+
+	/**
+	 * {@inheritDoc IInterval.compareEnd}
+	 */
+	public compareEnd(b: SequenceInterval): number {
+		this.verifyNotDispose();
+
+		const dist = compareReferencePositions(this.end, b.end);
+
+		if (dist === 0) {
+			return compareSides(b.endSide, this.endSide);
+		}
+
+		return dist;
+	}
+
+	/**
+	 * {@inheritDoc IInterval.overlaps}
+	 */
+	public overlaps(b: SequenceInterval) {
+		this.verifyNotDispose();
+
+		const result =
+			compareReferencePositions(this.start, b.end) <= 0 &&
+			compareReferencePositions(this.end, b.start) >= 0;
+		return result;
+	}
+
+	/**
+	 * Whether this interval overlaps the provided numerical positions.
+	 */
+	public overlapsPos(_bstart: number, _bend: number): boolean {
+		assert(false, 0xcd7 /* overlapsPos not supported on BaseSequenceInterval */);
+	}
+
+	public clone(): BaseSequenceInterval {
+		assert(false, 0xcd8 /* clone not supported on BaseSequenceInterval */);
+	}
+
+	public union(_b: BaseSequenceInterval): BaseSequenceInterval {
+		assert(false, 0xcd9 /* union not supported on BaseSequenceInterval */);
+	}
+
+	protected verifyNotDispose(): void {
+		// No-op: transient intervals are not disposable.
+	}
+}
+
 export class SequenceIntervalClass
-	implements SequenceInterval, ISerializableInterval, IDisposable
+	extends BaseSequenceInterval
+	implements ISerializableInterval, IDisposable
 {
 	readonly #props: {
 		propertyManager?: PropertiesManager;
@@ -193,7 +335,7 @@ export class SequenceIntervalClass
 	/**
 	 * {@inheritDoc ISerializableInterval.properties}
 	 */
-	public get properties(): Readonly<PropertySet> {
+	public override get properties(): Readonly<PropertySet> {
 		this.verifyNotDispose();
 		return this.#props.properties;
 	}
@@ -220,39 +362,18 @@ export class SequenceIntervalClass
 		}
 	}
 
-	/***/
-	public get stickiness(): IntervalStickiness {
-		this.verifyNotDispose();
-
-		const startSegment: ISegmentInternal | undefined = this.start.getSegment();
-		const endSegment: ISegmentInternal | undefined = this.end.getSegment();
-		return computeStickinessFromSide(
-			startSegment?.endpointType,
-			this.startSide,
-			endSegment?.endpointType,
-			this.endSide,
-		);
-	}
-
 	constructor(
 		private readonly client: Client,
-		private readonly id: string,
+		id: string,
 		private readonly label: string,
-		/**
-		 * Start endpoint of this interval.
-		 * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
-		 */
-		public start: LocalReferencePosition,
-		/**
-		 * End endpoint of this interval.
-		 * @remarks This endpoint can be resolved into a character position using the SharedString it's a part of.
-		 */
-		public end: LocalReferencePosition,
-		public intervalType: IntervalType,
+		start: LocalReferencePosition,
+		end: LocalReferencePosition,
+		intervalType: IntervalType,
 		props?: PropertySet,
-		public readonly startSide: Side = Side.Before,
-		public readonly endSide: Side = Side.Before,
+		startSide: Side = Side.Before,
+		endSide: Side = Side.Before,
 	) {
+		super(id, start, end, intervalType, startSide, endSide);
 		if (props) {
 			this.#props.properties = addProperties(this.#props.properties, props);
 		}
@@ -270,7 +391,7 @@ export class SequenceIntervalClass
 		this.#props.propertyManager = undefined;
 	}
 
-	private verifyNotDispose() {
+	protected override verifyNotDispose() {
 		if (this.#disposed) {
 			throw new LoggingError("Invalid interval access after dispose");
 		}
@@ -350,7 +471,7 @@ export class SequenceIntervalClass
 			endSide: includeEndpoints ? this.endSide : undefined,
 			properties: {
 				...props,
-				[reservedIntervalIdKey]: this.id,
+				[reservedIntervalIdKey]: this.getIntervalId(),
 				[reservedRangeLabelsKey]: [this.label],
 			},
 		} satisfies SerializedIntervalDelta;
@@ -364,7 +485,7 @@ export class SequenceIntervalClass
 
 		return new SequenceIntervalClass(
 			this.client,
-			this.id,
+			this.getIntervalId(),
 			this.label,
 			this.start,
 			this.end,
@@ -375,80 +496,6 @@ export class SequenceIntervalClass
 		);
 	}
 
-	/**
-	 * {@inheritDoc IInterval.compare}
-	 */
-	public compare(b: SequenceInterval) {
-		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}
-	 */
-	public compareStart(b: SequenceInterval) {
-		this.verifyNotDispose();
-
-		const dist = compareReferencePositions(this.start, b.start);
-
-		if (dist === 0) {
-			return compareSides(this.startSide, b.startSide);
-		}
-
-		return dist;
-	}
-
-	/**
-	 * {@inheritDoc IInterval.compareEnd}
-	 */
-	public compareEnd(b: SequenceInterval): number {
-		this.verifyNotDispose();
-
-		const dist = compareReferencePositions(this.end, b.end);
-
-		if (dist === 0) {
-			return compareSides(b.endSide, this.endSide);
-		}
-
-		return dist;
-	}
-
-	/**
-	 * {@inheritDoc IInterval.overlaps}
-	 */
-	public overlaps(b: SequenceInterval) {
-		this.verifyNotDispose();
-
-		const result =
-			compareReferencePositions(this.start, b.end) <= 0 &&
-			compareReferencePositions(this.end, b.start) >= 0;
-		return result;
-	}
-
-	/**
-	 * {@inheritDoc ISerializableInterval.getIntervalId}
-	 */
-	public getIntervalId(): string {
-		return this.id;
-	}
-
 	/**
 	 * {@inheritDoc IInterval.union}
 	 */
@@ -490,7 +537,7 @@ export class SequenceIntervalClass
 	/**
 	 * Whether this interval overlaps the provided numerical positions.
 	 */
-	public overlapsPos(bstart: number, bend: number) {
+	public override overlapsPos(bstart: number, bend: number) {
 		this.verifyNotDispose();
 
 		const startPos = this.client.localReferencePositionToPosition(this.start);
@@ -602,7 +649,7 @@ export class SequenceIntervalClass
 
 		const newInterval = new SequenceIntervalClass(
 			this.client,
-			this.id,
+			this.getIntervalId(),
 			this.label,
 			startRef,
 			endRef,
@@ -697,6 +744,41 @@ export function createPositionReferenceFromSegoff({
 	return createDetachedLocalReferencePosition(slidingPreference, refType);
 }
 
+/**
+ * Resolves a position to a {@link LocalReferencePosition} using an
+ * {@link ISharedSegmentSequence} (no Client or op context needed).
+ */
+export function resolvePositionRef(
+	sequence: ISharedSegmentSequence<any>,
+	pos: number | "start" | "end",
+	refType: ReferenceType,
+	slidingPreference: SlidingPreference,
+	canSlideToEndpoint?: boolean,
+): LocalReferencePosition {
+	if (pos === "start" || pos === "end") {
+		return sequence.createLocalReferencePosition(
+			pos,
+			undefined,
+			refType,
+			undefined,
+			slidingPreference,
+			canSlideToEndpoint,
+		);
+	}
+	const segoff = sequence.getContainingSegment(pos);
+	if (segoff?.segment !== undefined && segoff?.offset !== undefined) {
+		return sequence.createLocalReferencePosition(
+			segoff.segment,
+			segoff.offset,
+			refType,
+			undefined,
+			slidingPreference,
+			canSlideToEndpoint,
+		);
+	}
+	return createDetachedLocalReferencePosition(slidingPreference, refType);
+}
+
 function createPositionReference({
 	client,
 	pos,
@@ -758,18 +840,61 @@ function createPositionReference({
 	});
 }
 
-export function createTransientInterval(
+/**
+ * Creates a transient interval using an `ISharedSegmentSequence` instead of a `Client`.
+ * This avoids coupling index classes to merge-tree internals.
+ */
+export function createTransientIntervalFromSequence(
 	start: SequencePlace | undefined,
 	end: SequencePlace | undefined,
-	client: Client,
-) {
-	return createSequenceInterval(
-		"transient",
+	sequence: ISharedSegmentSequence<any>,
+): BaseSequenceInterval {
+	const { startPos, startSide, endPos, endSide } = endpointPosAndSide(
+		start ?? "start",
+		end ?? "end",
+	);
+	assert(
+		startPos !== undefined &&
+			endPos !== undefined &&
+			startSide !== undefined &&
+			endSide !== undefined,
+		0xcda /* start and end cannot be undefined because they were not passed in as undefined */,
+	);
+
+	const startSlidingPref = startReferenceSlidingPreference(
+		startPos,
+		startSide,
+		endPos,
+		endSide,
+	);
+	const endSlidingPref = endReferenceSlidingPreference(startPos, startSide, endPos, endSide);
+
+	const startLref = resolvePositionRef(
+		sequence,
+		startPos,
+		ReferenceType.Transient,
+		startSlidingPref,
+	);
+	const endLref = resolvePositionRef(
+		sequence,
+		endPos,
+		ReferenceType.Transient,
+		endSlidingPref,
+	);
+
+	const rangeProp = {
+		[reservedRangeLabelsKey]: ["transient"],
+	};
+	startLref.addProperties(rangeProp);
+	endLref.addProperties(rangeProp);
+
+	return new BaseSequenceInterval(
 		uuid(),
-		start,
-		end,
-		client,
+		startLref,
+		endLref,
 		IntervalType.Transient,
+		startSide,
+		endSide,
 	);
 }
 
@@ -824,6 +949,13 @@ export function createSequenceInterval(
 		endSide,
 	);
 
+	const endSlidingPreference = endReferenceSlidingPreference(
+		startPos,
+		startSide,
+		endPos,
+		endSide,
+	);
+
 	const startLref = createPositionReference({
 		client,
 		pos: startPos,
@@ -835,13 +967,6 @@ export function createSequenceInterval(
 		rollback,
 	});
 
-	const endSlidingPreference = endReferenceSlidingPreference(
-		startPos,
-		startSide,
-		endPos,
-		endSide,
-	);
-
 	const endLref = createPositionReference({
 		client,
 		pos: endPos,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "2.90.0-378676";
+export const pkgVersion = "2.91.0";