@fluidframework/sequence 2.43.0 → 2.50.0

package/src/intervals/sequenceInterval.ts

@@ -5,6 +5,7 @@
 
 /* eslint-disable no-bitwise */
 
+import type { IDisposable } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import {
@@ -27,12 +28,11 @@ import {
 	Side,
 	endpointPosAndSide,
 	addProperties,
-	copyPropertiesAndManager,
 	type ISegmentInternal,
 	UnassignedSequenceNumber,
 	UniversalSequenceNumber,
 } from "@fluidframework/merge-tree/internal";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 
 import {
@@ -222,8 +222,10 @@ export interface SequenceInterval extends ISerializableInterval {
 	getIntervalId(): string;
 }
 
-// eslint-disable-next-line import/no-deprecated
-export class SequenceIntervalClass implements SequenceInterval, ISerializableInterval {
+export class SequenceIntervalClass
+	// eslint-disable-next-line import/no-deprecated
+	implements SequenceInterval, ISerializableInterval, IDisposable
+{
 	readonly #props: {
 		propertyManager?: PropertiesManager;
 		properties: PropertySet;
@@ -233,6 +235,7 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * {@inheritDoc ISerializableInterval.properties}
 	 */
 	public get properties(): Readonly<PropertySet> {
+		this.verifyNotDispose();
 		return this.#props.properties;
 	}
 
@@ -241,6 +244,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 		op?: ISequencedDocumentMessage,
 		rollback?: boolean,
 	) {
+		this.verifyNotDispose();
+
 		if (props !== undefined) {
 			this.#props.propertyManager ??= new PropertiesManager();
 			return this.#props.propertyManager.handleProperties(
@@ -258,6 +263,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 
 	/***/
 	public get stickiness(): IntervalStickiness {
+		this.verifyNotDispose();
+
 		const startSegment: ISegmentInternal | undefined = this.start.getSegment();
 		const endSegment: ISegmentInternal | undefined = this.end.getSegment();
 		return computeStickinessFromSide(
@@ -291,6 +298,24 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 			this.#props.properties = addProperties(this.#props.properties, props);
 		}
 	}
+	#disposed = false;
+	public get disposed() {
+		return this.#disposed;
+	}
+	public dispose(error?: Error): void {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.client.removeLocalReferencePosition(this.start);
+		this.client.removeLocalReferencePosition(this.end);
+		this.removePositionChangeListeners();
+		this.#props.propertyManager = undefined;
+	}
+
+	private verifyNotDispose() {
+		if (this.#disposed) {
+			throw new LoggingError("Invalid interval access after dispose");
+		}
+	}
 
 	private callbacks?: Record<"beforePositionChange" | "afterPositionChange", () => void>;
 
@@ -301,6 +326,7 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 		beforePositionChange: () => void,
 		afterPositionChange: () => void,
 	): void {
+		this.verifyNotDispose();
 		if (this.callbacks === undefined) {
 			this.callbacks = {
 				beforePositionChange,
@@ -329,6 +355,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * {@inheritDoc ISerializableInterval.serialize}
 	 */
 	public serialize(): ISerializedInterval {
+		this.verifyNotDispose();
+
 		return this.serializeDelta({
 			props: this.properties,
 			includeEndpoints: true,
@@ -342,6 +370,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 		props: PropertySet | undefined;
 		includeEndpoints: boolean;
 	}): SerializedIntervalDelta {
+		this.verifyNotDispose();
+
 		const startSegment: ISegmentInternal | undefined = this.start.getSegment();
 		const endSegment: ISegmentInternal | undefined = this.end.getSegment();
 		const startPosition = includeEndpoints
@@ -371,6 +401,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * {@inheritDoc IInterval.clone}
 	 */
 	public clone(): SequenceIntervalClass {
+		this.verifyNotDispose();
+
 		return new SequenceIntervalClass(
 			this.client,
 			this.id,
@@ -413,6 +445,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * {@inheritDoc IInterval.compareStart}
 	 */
 	public compareStart(b: SequenceInterval) {
+		this.verifyNotDispose();
+
 		const dist = compareReferencePositions(this.start, b.start);
 
 		if (dist === 0) {
@@ -426,6 +460,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * {@inheritDoc IInterval.compareEnd}
 	 */
 	public compareEnd(b: SequenceInterval): number {
+		this.verifyNotDispose();
+
 		const dist = compareReferencePositions(this.end, b.end);
 
 		if (dist === 0) {
@@ -439,6 +475,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * {@inheritDoc IInterval.overlaps}
 	 */
 	public overlaps(b: SequenceInterval) {
+		this.verifyNotDispose();
+
 		const result =
 			compareReferencePositions(this.start, b.end) <= 0 &&
 			compareReferencePositions(this.end, b.start) >= 0;
@@ -456,6 +494,8 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * {@inheritDoc IInterval.union}
 	 */
 	public union(b: SequenceIntervalClass) {
+		this.verifyNotDispose();
+
 		const newStart = minReferencePosition(this.start, b.start);
 		const newEnd = maxReferencePosition(this.end, b.end);
 
@@ -492,41 +532,41 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 	 * @returns whether this interval overlaps two numerical positions.
 	 */
 	public overlapsPos(bstart: number, bend: number) {
+		this.verifyNotDispose();
+
 		const startPos = this.client.localReferencePositionToPosition(this.start);
 		const endPos = this.client.localReferencePositionToPosition(this.end);
 		return endPos > bstart && startPos < bend;
 	}
 
 	public moveEndpointReferences(
-		rebased: Partial<Record<"start" | "end", { segment: ISegment; offset: number }>>,
+		rebased: Record<"start" | "end", { segment: ISegment; offset: number }>,
 	) {
-		if (rebased.start) {
-			const startRef = createPositionReferenceFromSegoff({
-				client: this.client,
-				segoff: rebased.start,
-				refType: this.start.refType,
-				slidingPreference: this.start.slidingPreference,
-				canSlideToEndpoint: this.start.canSlideToEndpoint,
-			});
-			if (this.start.properties) {
-				startRef.addProperties(this.start.properties);
-			}
-			this.start = startRef;
+		this.verifyNotDispose();
+
+		const startRef = createPositionReferenceFromSegoff({
+			client: this.client,
+			segoff: rebased.start,
+			refType: this.start.refType,
+			slidingPreference: this.start.slidingPreference,
+			canSlideToEndpoint: this.start.canSlideToEndpoint,
+		});
+		if (this.start.properties) {
+			startRef.addProperties(this.start.properties);
 		}
-
-		if (rebased.end) {
-			const endRef = createPositionReferenceFromSegoff({
-				client: this.client,
-				segoff: rebased.end,
-				refType: this.end.refType,
-				slidingPreference: this.end.slidingPreference,
-				canSlideToEndpoint: this.end.canSlideToEndpoint,
-			});
-			if (this.end.properties) {
-				endRef.addProperties(this.end.properties);
-			}
-			this.end = endRef;
+		this.start = startRef;
+
+		const endRef = createPositionReferenceFromSegoff({
+			client: this.client,
+			segoff: rebased.end,
+			refType: this.end.refType,
+			slidingPreference: this.end.slidingPreference,
+			canSlideToEndpoint: this.end.canSlideToEndpoint,
+		});
+		if (this.end.properties) {
+			endRef.addProperties(this.end.properties);
 		}
+		this.end = endRef;
 	}
 
 	/**
@@ -540,12 +580,17 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 		localSeq?: number,
 		canSlideToEndpoint: boolean = false,
 	) {
+		this.verifyNotDispose();
+
 		const { startSide, endSide, startPos, endPos } = endpointPosAndSide(start, end);
 		const getRefType = (baseType: ReferenceType): ReferenceType => {
 			let refType = baseType;
 			if (op === undefined) {
 				refType &= ~ReferenceType.SlideOnRemove;
 				refType |= ReferenceType.StayOnRemove;
+			} else {
+				refType &= ~ReferenceType.StayOnRemove;
+				refType |= ReferenceType.SlideOnRemove;
 			}
 			return refType;
 		};
@@ -607,12 +652,23 @@ export class SequenceIntervalClass implements SequenceInterval, ISerializableInt
 			startSide ?? this.startSide,
 			endSide ?? this.endSide,
 		);
-		copyPropertiesAndManager(this.#props, newInterval.#props);
+		newInterval.#props.propertyManager = this.#props.propertyManager ??=
+			new PropertiesManager();
+		newInterval.#props.properties = this.#props.properties;
 		return newInterval;
 	}
 
 	public ackPropertiesChange(newProps: PropertySet, op: ISequencedDocumentMessage) {
-		this.#props.propertyManager ??= new PropertiesManager();
+		this.verifyNotDispose();
+
+		if (Object.keys(newProps).length === 0) {
+			return;
+		}
+
+		assert(
+			this.#props.propertyManager !== undefined,
+			0xbd5 /* must have property manager to ack */,
+		);
 		// Let the propertyManager prune its pending change-properties set.
 		this.#props.propertyManager.ack(op.sequenceNumber, op.minimumSequenceNumber, {
 			props: newProps,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "2.43.0";
+export const pkgVersion = "2.50.0";