@fluidframework/sequence 2.32.0 → 2.33.0-333010

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,33 @@ 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 */);
-
-			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);
-			}
+			localValue.resubmitMessage(value, localOpMetadata);
 			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 +233,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

@@ -74,25 +74,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 +119,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/packageVersion.ts

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