@fluidframework/sequence 2.32.0 → 2.33.0

package/src/intervalCollectionMap.ts

@@ -13,9 +13,6 @@ import { ValueType, IFluidSerializer } from "@fluidframework/shared-object-base/
 import { makeSerializable } from "./IntervalCollectionValues.js";
 import {
 	IntervalCollection,
-	opsMap,
-	toOptionalSequencePlace,
-	toSequencePlace,
 	type ISerializedIntervalCollectionV1,
 	type ISerializedIntervalCollectionV2,
 } from "./intervalCollection.js";
@@ -25,7 +22,6 @@ import {
 	ISerializableIntervalCollection,
 	SequenceOptions,
 } from "./intervalCollectionMapInterfaces.js";
-import { getSerializedProperties } from "./intervals/index.js";
 
 function isMapOperation(op: unknown): op is IMapOperation {
 	return typeof op === "object" && op !== null && "type" in op && op.type === "act";
@@ -190,63 +186,46 @@ export class IntervalCollectionMap {
 
 	/**
 	 * Submit the given op if a handler is registered.
-	 * @param op - The operation to attempt to submit
+	 * @param content - The operation to attempt to submit
 	 * @param localOpMetadata - The local metadata associated with the op. This is kept locally by the runtime
 	 * and not sent to the server. This will be sent back when this message is received back from the server. This is
 	 * also sent if we are asked to resubmit the message.
 	 * @returns True if the operation was submitted, false otherwise.
 	 */
-	public tryResubmitMessage(op: unknown, localOpMetadata: IMapMessageLocalMetadata): boolean {
-		if (isMapOperation(op)) {
-			const localValue = this.data.get(op.key);
-
+	public tryResubmitMessage(
+		content: unknown,
+		localOpMetadata: IMapMessageLocalMetadata,
+	): boolean {
+		if (isMapOperation(content)) {
+			const { value, key } = content;
+			const localValue = this.data.get(key);
 			assert(localValue !== undefined, 0x3f8 /* Local value expected on resubmission */);
+			localValue.resubmitMessage(value, localOpMetadata);
+			return true;
+		}
+		return false;
+	}
+
+	public tryRollback(content: any, localOpMetadata: unknown) {
+		if (isMapOperation(content)) {
+			const localValue = this.data.get(content.key);
+
+			assert(localValue !== undefined, 0xb7e /* Local value expected on rollback */);
+
+			localValue.rollback(content.value, localOpMetadata as IMapMessageLocalMetadata);
 
-			const handler = opsMap[op.value.opName];
-			const rebased = handler.rebase(localValue, op.value, localOpMetadata);
-			if (rebased !== undefined) {
-				const { rebasedOp, rebasedLocalOpMetadata } = rebased;
-				this.submitMessage({ ...op, value: rebasedOp }, rebasedLocalOpMetadata);
-			}
 			return true;
 		}
 		return false;
 	}
 
-	public tryApplyStashedOp(op: unknown): boolean {
-		if (isMapOperation(op)) {
-			const { value, key } = op;
+	public tryApplyStashedOp(content: unknown): boolean {
+		if (isMapOperation(content)) {
+			const { value, key } = content;
 			const map = this.get(key);
-			const { id, properties } = getSerializedProperties(value.value);
 
-			switch (value.opName) {
-				case "add": {
-					map.add({
-						id,
-						// Todo: we should improve typing so we know add ops always have start and end
-						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-						start: toSequencePlace(value.value.start!, value.value.startSide),
-						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-						end: toSequencePlace(value.value.end!, value.value.endSide),
-						props: properties,
-					});
-					return true;
-				}
-				case "change": {
-					map.change(id, {
-						start: toOptionalSequencePlace(value.value.start, value.value.startSide),
-						end: toOptionalSequencePlace(value.value.end, value.value.endSide),
-						props: properties,
-					});
-					return true;
-				}
-				case "delete": {
-					map.removeIntervalById(id);
-					return true;
-				}
-				default:
-					throw new Error("unknown ops should not be stashed");
-			}
+			map.applyStashedOp(value);
+			return true;
 		}
 		return false;
 	}
@@ -267,23 +246,15 @@ export class IntervalCollectionMap {
 	 * (since its data no longer matches what other clients think the data should be) and will avoid overriding document content or misleading the users into thinking their current state is accurate.
 	 */
 	public tryProcessMessage(
-		op: unknown,
+		content: unknown,
 		local: boolean,
 		message: ISequencedDocumentMessage,
 		localOpMetadata: unknown,
 	): boolean {
-		if (isMapOperation(op)) {
-			const localValue = this.data.get(op.key) ?? this.createCore(op.key, local);
-			const handler = opsMap[op.value.opName];
-			const previousValue = localValue;
-			const translatedValue = op.value.value as any;
-			handler.process(
-				previousValue,
-				translatedValue,
-				local,
-				message,
-				localOpMetadata as IMapMessageLocalMetadata,
-			);
+		if (isMapOperation(content)) {
+			const { value, key } = content;
+			const localValue = this.data.get(key) ?? this.createCore(key, local);
+			localValue.process(value, local, message, localOpMetadata as IMapMessageLocalMetadata);
 			return true;
 		}
 		return false;

package/src/intervalCollectionMapInterfaces.ts

@@ -19,6 +19,7 @@ import {
 
 export interface IMapMessageLocalMetadata {
 	localSeq: number;
+	previous?: ISerializedInterval;
 }
 
 /**
@@ -74,25 +75,6 @@ export interface IIntervalCollectionOperation {
 		message: ISequencedDocumentMessage | undefined,
 		localOpMetadata: IMapMessageLocalMetadata | undefined,
 	): void;
-
-	/**
-	 * Rebases an `op` on `value` from its original perspective (ref/local seq) to the current
-	 * perspective. Should be invoked on reconnection.
-	 * @param value - The current value stored at the given key, which should be the value type.
-	 * @param op - The op to be rebased.
-	 * @param localOpMetadata - Any local metadata that was originally submitted with the op.
-	 * @returns A rebased version of the op and any local metadata that should be submitted with it.
-	 */
-	rebase(
-		value: IntervalCollection,
-		op: IIntervalCollectionTypeOperationValue,
-		localOpMetadata: IMapMessageLocalMetadata,
-	):
-		| {
-				rebasedOp: IIntervalCollectionTypeOperationValue;
-				rebasedLocalOpMetadata: IMapMessageLocalMetadata;
-		  }
-		| undefined;
 }
 
 /**
@@ -138,14 +120,37 @@ export interface ISerializedIntervalCollection {
  * serializable via JSON.stringify/parse but differs in that it has no equivalency with an in-memory value - rather
  * it just describes an operation to be applied to an already-in-memory value.
  */
-export interface IIntervalCollectionTypeOperationValue {
-	/**
-	 * The name of the operation.
-	 */
-	opName: IntervalDeltaOpType;
+export type IIntervalCollectionTypeOperationValue =
+	| {
+			/**
+			 * The name of the operation.
+			 */
+			opName: typeof IntervalDeltaOpType.ADD;
 
-	/**
-	 * The payload that is submitted along with the operation.
-	 */
-	value: SerializedIntervalDelta;
-}
+			/**
+			 * The payload that is submitted along with the operation.
+			 */
+			value: ISerializedInterval;
+	  }
+	| {
+			/**
+			 * The name of the operation.
+			 */
+			opName: typeof IntervalDeltaOpType.CHANGE;
+
+			/**
+			 * The payload that is submitted along with the operation.
+			 */
+			value: SerializedIntervalDelta;
+	  }
+	| {
+			/**
+			 * The name of the operation.
+			 */
+			opName: typeof IntervalDeltaOpType.DELETE;
+
+			/**
+			 * The payload that is submitted along with the operation.
+			 */
+			value: SerializedIntervalDelta;
+	  };

package/src/intervalIndex/intervalIndex.ts

@@ -16,7 +16,7 @@ import { ISerializableInterval, type SequenceInterval } from "../intervals/index
  * @legacy
  * @alpha
  *
- * @remarks The generic version of this interface is no longer used and will be removed. Use {@link SequenceIntervalIndex} instead.
+ * @deprecated The generic version of this interface is no longer used and will be removed. Use {@link SequenceIntervalIndex} instead.
  */
 export interface IntervalIndex<TInterval extends ISerializableInterval> {
 	/**

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -26,7 +26,7 @@ import { IntervalIndex, type SequenceIntervalIndex } from "./intervalIndex.js";
  * Use {@link ISequenceOverlappingIntervalsIndex} instead.
  * @legacy
  * @alpha
- * @remarks The generic version of this interface is no longer used and will be removed. Use {@link ISequenceOverlappingIntervalsIndex} instead.
+ * @deprecated The generic version of this interface is no longer used and will be removed. Use {@link ISequenceOverlappingIntervalsIndex} instead.
  */
 export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 	extends IntervalIndex<TInterval> {

package/src/intervals/sequenceInterval.ts

@@ -219,7 +219,11 @@ export class SequenceIntervalClass implements SequenceInterval {
 		return this.#props.properties;
 	}
 
-	public changeProperties(props: PropertySet | undefined, op?: ISequencedDocumentMessage) {
+	public changeProperties(
+		props: PropertySet | undefined,
+		op?: ISequencedDocumentMessage,
+		rollback?: boolean,
+	) {
 		if (props !== undefined) {
 			this.#props.propertyManager ??= new PropertiesManager();
 			return this.#props.propertyManager.handleProperties(
@@ -230,6 +234,7 @@ export class SequenceIntervalClass implements SequenceInterval {
 					: UniversalSequenceNumber,
 				op?.minimumSequenceNumber ?? UniversalSequenceNumber,
 				this.client.getCollabWindow().collaborating,
+				rollback,
 			);
 		}
 	}
@@ -573,6 +578,7 @@ export function createPositionReferenceFromSegoff(
 	fromSnapshot?: boolean,
 	slidingPreference?: SlidingPreference,
 	canSlideToEndpoint?: boolean,
+	rollback?: boolean,
 ): LocalReferencePosition {
 	if (segoff === "start" || segoff === "end") {
 		return client.createLocalReferencePosition(
@@ -606,7 +612,8 @@ export function createPositionReferenceFromSegoff(
 		!op &&
 		!localSeq &&
 		!fromSnapshot &&
-		!refTypeIncludesFlag(refType, ReferenceType.Transient)
+		!refTypeIncludesFlag(refType, ReferenceType.Transient) &&
+		!rollback
 	) {
 		throw new UsageError("Non-transient references need segment");
 	}
@@ -624,6 +631,7 @@ function createPositionReference(
 	slidingPreference?: SlidingPreference,
 	exclusive: boolean = false,
 	useNewSlidingBehavior: boolean = false,
+	rollback?: boolean,
 ): LocalReferencePosition {
 	let segoff;
 
@@ -661,6 +669,7 @@ function createPositionReference(
 		fromSnapshot,
 		slidingPreference,
 		exclusive,
+		rollback,
 	);
 }
 
@@ -690,6 +699,7 @@ export function createSequenceInterval(
 	fromSnapshot?: boolean,
 	useNewSlidingBehavior: boolean = false,
 	props?: PropertySet,
+	rollback?: boolean,
 ): SequenceIntervalClass {
 	const { startPos, startSide, endPos, endSide } = endpointPosAndSide(
 		start ?? "start",
@@ -731,6 +741,7 @@ export function createSequenceInterval(
 		startReferenceSlidingPreference(stickiness),
 		startReferenceSlidingPreference(stickiness) === SlidingPreference.BACKWARD,
 		useNewSlidingBehavior,
+		rollback,
 	);
 
 	const endLref = createPositionReference(
@@ -743,6 +754,7 @@ export function createSequenceInterval(
 		endReferenceSlidingPreference(stickiness),
 		endReferenceSlidingPreference(stickiness) === SlidingPreference.FORWARD,
 		useNewSlidingBehavior,
+		rollback,
 	);
 
 	const rangeProp = {

package/src/packageVersion.ts

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

package/src/sequence.ts

@@ -796,6 +796,21 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 		});
 	}
 
+	/**
+	 * Revert an op
+	 */
+	protected rollback(content: any, localOpMetadata: unknown): void {
+		const originalRefSeq = this.inFlightRefSeqs.pop();
+		assert(
+			originalRefSeq !== undefined,
+			0xb7f /* Expected a recorded refSeq when rolling back an op  */,
+		);
+
+		if (!this.intervalCollections.tryRollback(content, localOpMetadata)) {
+			this.client.rollback(content, localOpMetadata);
+		}
+	}
+
 	/**
 	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
 	 */

package/src/sharedIntervalCollection.ts

@@ -10,7 +10,7 @@ import { ISerializableInterval } from "./intervals/index.js";
 /**
  * @legacy
  * @alpha
- * @remarks This interface is no longer used and will be removed.
+ * @deprecated This interface is no longer used and will be removed.
  */
 export interface ISharedIntervalCollection<TInterval extends ISerializableInterval> {
 	// eslint-disable-next-line import/no-deprecated

package/src/sharedString.ts

@@ -271,17 +271,6 @@ export class SharedStringClass
 	public getMarkerFromId(id: string): ISegment | undefined {
 		return this.client.getMarkerFromId(id);
 	}
-
-	/**
-	 * Revert an op
-	 */
-	protected rollback(content: any, localOpMetadata: unknown): void {
-		if (this.client.rollback !== undefined) {
-			this.client.rollback(content, localOpMetadata);
-		} else {
-			super.rollback(content, localOpMetadata);
-		}
-	}
 }
 
 interface ITextAndMarkerAccumulator {