@fluidframework/sequence 2.31.1 → 2.33.0-333010

package/src/intervalCollectionMap.ts

@@ -13,10 +13,6 @@ import { ValueType, IFluidSerializer } from "@fluidframework/shared-object-base/
 import { makeSerializable } from "./IntervalCollectionValues.js";
 import {
 	IntervalCollection,
-	opsMap,
-	reservedIntervalIdKey,
-	toOptionalSequencePlace,
-	toSequencePlace,
 	type ISerializedIntervalCollectionV1,
 	type ISerializedIntervalCollectionV2,
 } from "./intervalCollection.js";
@@ -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);
 
-			switch (value.opName) {
-				case "add": {
-					map.add({
-						// 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: value.value.properties,
-					});
-					return true;
-				}
-				case "change": {
-					const { [reservedIntervalIdKey]: id, ...props } = value.value.properties ?? {};
-					map.change(id, {
-						start: toOptionalSequencePlace(value.value.start, value.value.startSide),
-						end: toOptionalSequencePlace(value.value.end, value.value.endSide),
-						props,
-					});
-					return true;
-				}
-				case "delete": {
-					const { [reservedIntervalIdKey]: id } = value.value.properties ?? {};
-					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/intervalIndex/endpointInRangeIndex.ts

@@ -7,7 +7,7 @@
 
 import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree/internal";
 
-import { IntervalType, SequenceInterval, createSequenceInterval } from "../intervals/index.js";
+import { SequenceInterval, createTransientInterval } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
 import { type SequenceIntervalIndex } from "./intervalIndex.js";
@@ -77,21 +77,9 @@ export class EndpointInRangeIndex implements IEndpointInRangeIndex {
 			return true;
 		};
 
-		const transientStartInterval = createSequenceInterval(
-			"transient",
-			start,
-			start,
-			this.client,
-			IntervalType.Transient,
-		);
+		const transientStartInterval = createTransientInterval(start, start, this.client);
 
-		const transientEndInterval = createSequenceInterval(
-			"transient",
-			end,
-			end,
-			this.client,
-			IntervalType.Transient,
-		);
+		const transientEndInterval = createTransientInterval(end, end, this.client);
 
 		// Add comparison overrides to the transient intervals
 		(transientStartInterval as Partial<HasComparisonOverride>)[forceCompare] = -1;

package/src/intervalIndex/endpointIndex.ts

@@ -3,11 +3,9 @@
  * Licensed under the MIT License.
  */
 
-/* eslint-disable import/no-deprecated */
-
 import { Client, RedBlackTree } from "@fluidframework/merge-tree/internal";
 
-import { createSequenceInterval, IntervalType, SequenceInterval } from "../intervals/index.js";
+import { createTransientInterval, SequenceInterval } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
 import { type SequenceIntervalIndex } from "./intervalIndex.js";
@@ -39,13 +37,7 @@ export class EndpointIndex implements IEndpointIndex {
 	}
 
 	public previousInterval(pos: number): SequenceInterval | undefined {
-		const transientInterval = createSequenceInterval(
-			"transient",
-			pos,
-			pos,
-			this.client,
-			IntervalType.Transient,
-		);
+		const transientInterval = createTransientInterval(pos, pos, this.client);
 		const rbNode = this.endIntervalTree.floor(transientInterval);
 		if (rbNode) {
 			return rbNode.data;
@@ -53,13 +45,7 @@ export class EndpointIndex implements IEndpointIndex {
 	}
 
 	public nextInterval(pos: number): SequenceInterval | undefined {
-		const transientInterval = createSequenceInterval(
-			"transient",
-			pos,
-			pos,
-			this.client,
-			IntervalType.Transient,
-		);
+		const transientInterval = createTransientInterval(pos, pos, this.client);
 		const rbNode = this.endIntervalTree.ceil(transientInterval);
 		if (rbNode) {
 			return rbNode.data;

package/src/intervalIndex/idIntervalIndex.ts

@@ -5,7 +5,6 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import { reservedIntervalIdKey } from "../intervalCollection.js";
 import { type SequenceIntervalClass } from "../intervals/index.js";
 
 import { type SequenceIntervalIndex } from "./intervalIndex.js";
@@ -26,12 +25,6 @@ class IdIntervalIndex implements IIdIntervalIndex, Iterable<SequenceIntervalClas
 			id !== undefined,
 			0x2c0 /* "ID must be created before adding interval to collection" */,
 		);
-		// Make the ID immutable.
-		Object.defineProperty(interval.properties, reservedIntervalIdKey, {
-			configurable: false,
-			enumerable: true,
-			writable: false,
-		});
 		this.intervalIdMap.set(id, interval);
 	}
 

package/src/intervalIndex/index.ts

@@ -23,4 +23,3 @@ export {
 	OverlappingIntervalsIndex,
 	ISequenceOverlappingIntervalsIndex,
 } from "./overlappingIntervalsIndex.js";
-export { createOverlappingSequenceIntervalsIndex } from "./overlappingSequenceIntervalsIndex.js";

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -14,9 +14,8 @@ import {
 import { IntervalNode, IntervalTree } from "../intervalTree.js";
 import {
 	ISerializableInterval,
-	IntervalType,
 	SequenceInterval,
-	createSequenceInterval,
+	createTransientInterval,
 } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
@@ -108,12 +107,10 @@ export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsI
 				});
 			}
 		} else {
-			const transientInterval: SequenceInterval = createSequenceInterval(
-				"transient",
+			const transientInterval: SequenceInterval = createTransientInterval(
 				start ?? "start",
 				end ?? "end",
 				this.client,
-				IntervalType.Transient,
 			);
 
 			if (start === undefined) {
@@ -184,13 +181,7 @@ export class OverlappingIntervalsIndex implements ISequenceOverlappingIntervalsI
 		) {
 			return [];
 		}
-		const transientInterval = createSequenceInterval(
-			"transient",
-			start,
-			end,
-			this.client,
-			IntervalType.Transient,
-		);
+		const transientInterval = createTransientInterval(start, end, this.client);
 
 		const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
 		return overlappingIntervalNodes.map((node) => node.key);

package/src/intervalIndex/startpointInRangeIndex.ts

@@ -7,7 +7,7 @@
 
 import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree/internal";
 
-import { IntervalType, SequenceInterval, createSequenceInterval } from "../intervals/index.js";
+import { SequenceInterval, createTransientInterval } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
 import { type SequenceIntervalIndex } from "./intervalIndex.js";
@@ -76,21 +76,9 @@ export class StartpointInRangeIndex implements IStartpointInRangeIndex {
 			return true;
 		};
 
-		const transientStartInterval = createSequenceInterval(
-			"transient",
-			start,
-			start,
-			this.client,
-			IntervalType.Transient,
-		);
+		const transientStartInterval = createTransientInterval(start, start, this.client);
 
-		const transientEndInterval = createSequenceInterval(
-			"transient",
-			end,
-			end,
-			this.client,
-			IntervalType.Transient,
-		);
+		const transientEndInterval = createTransientInterval(end, end, this.client);
 
 		// Add comparison overrides to the transient intervals
 		(transientStartInterval as Partial<HasComparisonOverride>)[forceCompare] = -1;

package/src/intervals/index.ts

@@ -11,7 +11,6 @@ export {
 	IntervalType,
 	IntervalDeltaOpType,
 	IntervalStickiness,
-	ISerializableIntervalPrivate,
 	SerializedIntervalDelta,
 	CompressedSerializedInterval,
 	endReferenceSlidingPreference,
@@ -22,4 +21,6 @@ export {
 	SequenceIntervalClass,
 	createSequenceInterval,
 	createPositionReferenceFromSegoff,
+	createTransientInterval,
+	getSerializedProperties,
 } from "./sequenceInterval.js";

package/src/intervals/intervalUtils.ts

@@ -7,15 +7,12 @@
 
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import {
-	PropertiesManager,
 	PropertySet,
 	SlidingPreference,
 	SequencePlace,
 	Side,
 } from "@fluidframework/merge-tree/internal";
 
-import type { SequenceIntervalClass } from "./sequenceInterval.js";
-
 /**
  * Basic interval abstraction
  * @legacy
@@ -171,10 +168,6 @@ export interface ISerializableInterval extends IInterval {
 	getIntervalId(): string;
 }
 
-export type ISerializableIntervalPrivate = SequenceIntervalClass & {
-	propertyManager?: PropertiesManager;
-};
-
 /**
  * Represents a change that should be applied to an existing interval.
  * Changes can modify any of start/end/properties, with `undefined` signifying no change should be made.