@fluidframework/sequence 2.30.0 → 2.31.0

package/src/intervalCollectionMap.ts

@@ -5,36 +5,27 @@
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IFluidHandle } from "@fluidframework/core-interfaces";
+import type { IEvent, IEventProvider } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import { ValueType, IFluidSerializer } from "@fluidframework/shared-object-base/internal";
 
+import { makeSerializable } from "./IntervalCollectionValues.js";
 import {
-	IntervalCollectionTypeLocalValue,
-	makeSerializable,
-} from "./IntervalCollectionValues.js";
-import {
-	type IntervalCollection,
+	IntervalCollection,
+	opsMap,
 	reservedIntervalIdKey,
 	toOptionalSequencePlace,
 	toSequencePlace,
+	type ISerializedIntervalCollectionV1,
+	type ISerializedIntervalCollectionV2,
 } from "./intervalCollection.js";
 import {
-	IIntervalCollectionType,
 	IIntervalCollectionTypeOperationValue,
 	IMapMessageLocalMetadata,
 	ISerializableIntervalCollection,
-	ISharedDefaultMapEvents,
-	IValueChanged,
-	// eslint-disable-next-line import/no-deprecated
-	IValueOpEmitter,
 	SequenceOptions,
 } from "./intervalCollectionMapInterfaces.js";
-import {
-	type ISerializableInterval,
-	IntervalDeltaOpType,
-	SerializedIntervalDelta,
-} from "./intervals/index.js";
 
 function isMapOperation(op: unknown): op is IMapOperation {
 	return typeof op === "object" && op !== null && "type" in op && op.type === "act";
@@ -67,6 +58,10 @@ export interface IMapDataObjectSerializable {
 	[key: string]: ISerializableIntervalCollection;
 }
 
+export interface IntervalCollectionMapEvents extends IEvent {
+	(event: "createIntervalCollection", listener: (key: string, local: boolean) => void): void;
+}
+
 /**
  * A DefaultMap is a map-like distributed data structure, supporting operations on values stored by
  * string key locations.
@@ -74,7 +69,7 @@ export interface IMapDataObjectSerializable {
  * Creation of values is implicit on access (either via `get` or a remote op application referring to
  * a collection that wasn't previously known)
  */
-export class IntervalCollectionMap<T extends ISerializableInterval> {
+export class IntervalCollectionMap {
 	/**
 	 * The number of key/value pairs stored in the map.
 	 */
@@ -82,45 +77,15 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 		return this.data.size;
 	}
 
-	/**
-	 * Mapping of op types to message handlers.
-	 */
-	private readonly messageHandler = {
-		process: (
-			op: IMapOperation,
-			local: boolean,
-			message: ISequencedDocumentMessage,
-			localOpMetadata: IMapMessageLocalMetadata,
-		) => {
-			const localValue = this.data.get(op.key) ?? this.createCore(op.key, local);
-			const handler = localValue.getOpHandler(op.value.opName);
-			const previousValue = localValue.value;
-			const translatedValue = op.value.value as any;
-			handler.process(previousValue, translatedValue, local, message, localOpMetadata);
-			const event: IValueChanged = { key: op.key, previousValue };
-			this.eventEmitter.emit("valueChanged", event, local, message, this.eventEmitter);
-		},
-		submit: (op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata) => {
-			this.submitMessage(op, localOpMetadata);
-		},
-		resubmit: (op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata) => {
-			const localValue = this.data.get(op.key);
-
-			assert(localValue !== undefined, 0x3f8 /* Local value expected on resubmission */);
-
-			const handler = localValue.getOpHandler(op.value.opName);
-			const rebased = handler.rebase(localValue.value, op.value, localOpMetadata);
-			if (rebased !== undefined) {
-				const { rebasedOp, rebasedLocalOpMetadata } = rebased;
-				this.submitMessage({ ...op, value: rebasedOp }, rebasedLocalOpMetadata);
-			}
-		},
-	};
-
 	/**
 	 * The in-memory data the map is storing.
 	 */
-	private readonly data = new Map<string, IntervalCollectionTypeLocalValue<T>>();
+	private readonly data = new Map<string, IntervalCollection>();
+
+	private readonly eventEmitter = new TypedEventEmitter<IntervalCollectionMapEvents>();
+	public get events(): IEventProvider<IntervalCollectionMapEvents> {
+		return this.eventEmitter;
+	}
 
 	/**
 	 * Create a new default map.
@@ -137,9 +102,7 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 			op: IMapOperation,
 			localOpMetadata: IMapMessageLocalMetadata,
 		) => void,
-		private readonly type: IIntervalCollectionType<T>,
 		private readonly options?: Partial<SequenceOptions>,
-		public readonly eventEmitter = new TypedEventEmitter<ISharedDefaultMapEvents>(),
 	) {}
 
 	/**
@@ -161,7 +124,7 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 				const nextVal = localValuesIterator.next();
 				return nextVal.done
 					? { value: undefined, done: true }
-					: { value: nextVal.value.value, done: false }; // Unpack the stored value
+					: { value: nextVal.value, done: false }; // Unpack the stored value
 			},
 			[Symbol.iterator]() {
 				return this;
@@ -172,22 +135,23 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 	/**
 	 * {@inheritDoc ISharedMap.get}
 	 */
-	public get(key: string): IntervalCollection<T> {
+	public get(key: string): IntervalCollection {
 		const localValue = this.data.get(key) ?? this.createCore(key, true);
 
-		return localValue.value;
+		return localValue;
 	}
 
-	public getSerializableStorage(serializer: IFluidSerializer): IMapDataObjectSerializable {
+	public serialize(serializer: IFluidSerializer): string {
 		const serializableMapData: IMapDataObjectSerializable = {};
 		this.data.forEach((localValue, key) => {
-			serializableMapData[key] = makeSerializable(localValue, serializer, this.handle);
+			serializableMapData[key] = makeSerializable(
+				localValue,
+				serializer,
+				this.handle,
+				this.options?.intervalSerializationFormat ?? "2",
+			);
 		});
-		return serializableMapData;
-	}
-
-	public serialize(serializer: IFluidSerializer): string {
-		return JSON.stringify(this.getSerializableStorage(serializer));
+		return JSON.stringify(serializableMapData);
 	}
 
 	/**
@@ -214,12 +178,13 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 			// collection. See https://github.com/microsoft/FluidFramework/issues/10557 for more context.
 			const normalizedKey = key.startsWith("intervalCollections/") ? key.substring(20) : key;
 
-			const localValue = {
-				key: normalizedKey,
-				value: this.makeLocal(key, serializable),
-			};
+			assert(
+				serializable.type !== ValueType[ValueType.Plain] &&
+					serializable.type !== ValueType[ValueType.Shared],
+				0x2e1 /* "Support for plain value types removed." */,
+			);
 
-			this.data.set(localValue.key, localValue.value);
+			this.createCore(normalizedKey, false, serializable.value);
 		}
 	}
 
@@ -233,7 +198,16 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 	 */
 	public tryResubmitMessage(op: unknown, localOpMetadata: IMapMessageLocalMetadata): boolean {
 		if (isMapOperation(op)) {
-			this.messageHandler.resubmit(op, localOpMetadata);
+			const localValue = this.data.get(op.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);
+			}
 			return true;
 		}
 		return false;
@@ -299,8 +273,13 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 		localOpMetadata: unknown,
 	): boolean {
 		if (isMapOperation(op)) {
-			this.messageHandler.process(
-				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,
@@ -314,77 +293,30 @@ export class IntervalCollectionMap<T extends ISerializableInterval> {
 	 * Initializes a default ValueType at the provided key.
 	 * Should be used when a map operation incurs creation.
 	 * @param key - The key being initialized
-	 * @param local - Whether the message originated from the local client
 	 */
-	private createCore(key: string, local: boolean): IntervalCollectionTypeLocalValue<T> {
-		const localValue = new IntervalCollectionTypeLocalValue(
-			this.type.factory.load(this.makeMapValueOpEmitter(key), undefined, this.options),
-			this.type,
-		);
-		const previousValue = this.data.get(key);
-		this.data.set(key, localValue);
-		const event: IValueChanged = { key, previousValue };
-		this.eventEmitter.emit("create", event, local, this.eventEmitter);
-		return localValue;
-	}
-
-	/**
-	 * The remote ISerializableValue we're receiving (either as a result of a load or an incoming set op) will
-	 * have the information we need to create a real object, but will not be the real object yet.  For example,
-	 * we might know it's a map and the map's ID but not have the actual map or its data yet.  makeLocal's
-	 * job is to convert that information into a real object for local usage.
-	 * @param key - The key that the caller intends to store the local value into (used for ops later).  But
-	 * doesn't actually store the local value into that key.  So better not lie!
-	 * @param serializable - The remote information that we can convert into a real object
-	 * @returns The local value that was produced
-	 */
-	private makeLocal(
+	private createCore(
 		key: string,
-		serializable: ISerializableIntervalCollection,
-	): IntervalCollectionTypeLocalValue<T> {
-		assert(
-			serializable.type !== ValueType[ValueType.Plain] &&
-				serializable.type !== ValueType[ValueType.Shared],
-			0x2e1 /* "Support for plain value types removed." */,
-		);
-
-		const localValue = this.type.factory.load(
-			this.makeMapValueOpEmitter(key),
-			serializable.value,
+		local: boolean,
+		serializedIntervals?: ISerializedIntervalCollectionV1 | ISerializedIntervalCollectionV2,
+	): IntervalCollection {
+		const localValue = new IntervalCollection(
+			(op, md) => {
+				{
+					this.submitMessage(
+						{
+							key,
+							type: "act",
+							value: op,
+						},
+						md,
+					);
+				}
+			},
+			serializedIntervals ?? [],
 			this.options,
 		);
-		return new IntervalCollectionTypeLocalValue(localValue, this.type);
-	}
-
-	/**
-	 * Create an emitter for a value type to emit ops from the given key.
-	 * @param key - The key of the map that the value type will be stored on
-	 * @returns A value op emitter for the given key
-	 */
-	// eslint-disable-next-line import/no-deprecated
-	private makeMapValueOpEmitter(key: string): IValueOpEmitter {
-		// eslint-disable-next-line import/no-deprecated
-		const emit: IValueOpEmitter["emit"] = (
-			opName: IntervalDeltaOpType,
-			previousValue: unknown,
-			params: SerializedIntervalDelta,
-			localOpMetadata: IMapMessageLocalMetadata,
-		): void => {
-			const op: IMapOperation = {
-				key,
-				type: "act",
-				value: {
-					opName,
-					value: params,
-				},
-			};
-
-			this.submitMessage(op, localOpMetadata);
-
-			const event: IValueChanged = { key, previousValue };
-			this.eventEmitter.emit("valueChanged", event, true, null, this.eventEmitter);
-		};
-
-		return { emit };
+		this.data.set(key, localValue);
+		this.eventEmitter.emit("createIntervalCollection", key, local, this.eventEmitter);
+		return localValue;
 	}
 }

package/src/intervalCollectionMapInterfaces.ts

@@ -3,58 +3,20 @@
  * Licensed under the MIT License.
  */
 
-import { IEventThisPlaceHolder } from "@fluidframework/core-interfaces";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import type { IMergeTreeOptions } from "@fluidframework/merge-tree/internal";
-import { ISharedObjectEvents } from "@fluidframework/shared-object-base/internal";
 
-import type { IntervalCollection } from "./intervalCollection.js";
+import type {
+	IntervalCollection,
+	ISerializedIntervalCollectionV1,
+	ISerializedIntervalCollectionV2,
+} from "./intervalCollection.js";
 import {
-	type ISerializableInterval,
 	ISerializedInterval,
 	IntervalDeltaOpType,
-	IntervalOpType,
 	SerializedIntervalDelta,
 } from "./intervals/index.js";
 
-/**
- * Type of "valueChanged" event parameter.
- */
-export interface IValueChanged {
-	/**
-	 * The key storing the value that changed.
-	 */
-	key: string;
-
-	/**
-	 * The value that was stored at the key prior to the change.
-	 */
-	previousValue: any;
-}
-
-/**
- * Value types are given an IValueOpEmitter to emit their ops through the container type that holds them.
- * @internal
- */
-export interface IValueOpEmitter {
-	/**
-	 * Called by the value type to emit a value type operation through the container type holding it.
-	 * @param opName - Name of the emitted operation
-	 * @param previousValue - JSONable previous value as defined by the value type @deprecated unused
-	 * @param params - JSONable params for the operation as defined by the value type
-	 * @param localOpMetadata - JSONable local metadata which should be submitted with the op
-	 */
-	emit(
-		opName: IntervalOpType,
-		previousValue: undefined,
-		params: SerializedIntervalDelta,
-		localOpMetadata: IMapMessageLocalMetadata,
-	): void;
-}
-
-/**
- * @internal
- */
 export interface IMapMessageLocalMetadata {
 	localSeq: number;
 }
@@ -85,42 +47,18 @@ export interface SequenceOptions
 	 * The default value is false.
 	 */
 	intervalStickinessEnabled: boolean;
-}
-
-/**
- * A value factory is used to serialize/deserialize value types to a map
- * @legacy
- * @alpha
- */
-export interface IIntervalCollectionFactory<T extends ISerializableInterval> {
-	/**
-	 * Create a new value type.  Used both in creation of new value types, as well as in loading existing ones
-	 * from remote.
-	 * @param emitter - Emitter object that the created value type will use to emit operations
-	 * @param raw - Initialization parameters as defined by the value type
-	 * @returns The new value type
-	 */
-	load(
-		emitter: IValueOpEmitter,
-		raw: any,
-		options?: Partial<SequenceOptions>,
-	): IntervalCollection<T>;
 
 	/**
-	 * Given a value type, provides a JSONable form of its data to be used for snapshotting.  This data must be
-	 * loadable using the load method of its factory.
-	 * @param value - The value type to serialize
-	 * @returns The JSONable form of the value type
+	 * This is for testing, and allows us to output intervals in the older formats.
 	 */
-	store(value: IntervalCollection<T>): any;
+	intervalSerializationFormat: "1" | "2";
 }
 
 /**
  * Defines an operation that a value type is able to handle.
- * @legacy
- * @alpha
+ *
  */
-export interface IIntervalCollectionOperation<T extends ISerializableInterval> {
+export interface IIntervalCollectionOperation {
 	/**
 	 * Performs the actual processing on the incoming operation.
 	 * @param value - The current value stored at the given key, which should be the value type
@@ -130,7 +68,7 @@ export interface IIntervalCollectionOperation<T extends ISerializableInterval> {
 	 * @param localOpMetadata - any local metadata submitted by `IValueOpEmitter.emit`.
 	 */
 	process(
-		value: IntervalCollection<T>,
+		value: IntervalCollection,
 		params: ISerializedInterval,
 		local: boolean,
 		message: ISequencedDocumentMessage | undefined,
@@ -146,7 +84,7 @@ export interface IIntervalCollectionOperation<T extends ISerializableInterval> {
 	 * @returns A rebased version of the op and any local metadata that should be submitted with it.
 	 */
 	rebase(
-		value: IntervalCollection<T>,
+		value: IntervalCollection,
 		op: IIntervalCollectionTypeOperationValue,
 		localOpMetadata: IMapMessageLocalMetadata,
 	):
@@ -157,33 +95,6 @@ export interface IIntervalCollectionOperation<T extends ISerializableInterval> {
 		| undefined;
 }
 
-/**
- * Defines a value type that can be registered on a container type.
- */
-export interface IIntervalCollectionType<T extends ISerializableInterval> {
-	/**
-	 * Name of the value type.
-	 */
-	name: string;
-
-	/**
-	 * Factory method used to convert to/from a JSON form of the type.
-	 */
-	factory: IIntervalCollectionFactory<T>;
-
-	/**
-	 * Operations that can be applied to the value type.
-	 */
-	ops: Map<IntervalOpType, IIntervalCollectionOperation<T>>;
-}
-
-export interface ISharedDefaultMapEvents extends ISharedObjectEvents {
-	(
-		event: "valueChanged" | "create",
-		listener: (changed: IValueChanged, local: boolean, target: IEventThisPlaceHolder) => void,
-	): void;
-}
-
 /**
  * The _ready-for-serialization_ format of values contained in DDS contents. This allows us to use
  * ISerializableValue.type to understand whether they're storing a Plain JS object, a SharedObject, or a value type.
@@ -199,12 +110,12 @@ export interface ISerializableIntervalCollection {
 	/**
 	 * A type annotation to help indicate how the value serializes.
 	 */
-	type: string;
+	type: "sharedStringIntervalCollection";
 
 	/**
 	 * The JSONable representation of the value.
 	 */
-	value: any;
+	value: ISerializedIntervalCollectionV1 | ISerializedIntervalCollectionV2;
 }
 
 export interface ISerializedIntervalCollection {
@@ -226,8 +137,6 @@ export interface ISerializedIntervalCollection {
  * value is whatever params the ValueType needs to complete that operation.  Similar to ISerializableValue, it is
  * 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.
- * @legacy
- * @alpha
  */
 export interface IIntervalCollectionTypeOperationValue {
 	/**

package/src/intervalIndex/endpointInRangeIndex.ts

@@ -7,16 +7,10 @@
 
 import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree/internal";
 
-import {
-	IIntervalHelpers,
-	ISerializableInterval,
-	IntervalType,
-	SequenceInterval,
-	sequenceIntervalHelpers,
-} from "../intervals/index.js";
+import { IntervalType, SequenceInterval, createSequenceInterval } from "../intervals/index.js";
 import { ISharedString } from "../sharedString.js";
 
-import { IntervalIndex } from "./intervalIndex.js";
+import { type SequenceIntervalIndex } from "./intervalIndex.js";
 import {
 	HasComparisonOverride,
 	compareOverrideables,
@@ -29,25 +23,19 @@ import {
  * Provide additional APIs to support efficiently querying a collection of intervals whose endpoints fall within a specified range.
  * @internal
  */
-export interface IEndpointInRangeIndex<TInterval extends ISerializableInterval>
-	extends IntervalIndex<TInterval> {
+export interface IEndpointInRangeIndex extends SequenceIntervalIndex {
 	/**
 	 * @returns an array of all intervals contained in this collection whose endpoints locate in the range [start, end] (includes both ends)
 	 */
-	findIntervalsWithEndpointInRange(start: number, end: number): TInterval[];
+	findIntervalsWithEndpointInRange(start: number, end: number): SequenceInterval[];
 }
 
-export class EndpointInRangeIndex<TInterval extends ISerializableInterval>
-	implements IEndpointInRangeIndex<TInterval>
-{
+export class EndpointInRangeIndex implements IEndpointInRangeIndex {
 	private readonly intervalTree;
 
-	constructor(
-		private readonly client: Client,
-		private readonly helpers: IIntervalHelpers<TInterval>,
-	) {
-		this.intervalTree = new RedBlackTree<TInterval, TInterval>(
-			(a: TInterval, b: TInterval) => {
+	constructor(private readonly client: Client) {
+		this.intervalTree = new RedBlackTree<SequenceInterval, SequenceInterval>(
+			(a: SequenceInterval, b: SequenceInterval) => {
 				const compareEndsResult = a.compareEnd(b);
 				if (compareEndsResult !== 0) {
 					return compareEndsResult;
@@ -71,25 +59,25 @@ export class EndpointInRangeIndex<TInterval extends ISerializableInterval>
 		);
 	}
 
-	public add(interval: TInterval): void {
+	public add(interval: SequenceInterval): void {
 		this.intervalTree.put(interval, interval);
 	}
 
-	public remove(interval: TInterval): void {
+	public remove(interval: SequenceInterval): void {
 		this.intervalTree.remove(interval);
 	}
 
-	public findIntervalsWithEndpointInRange(start: number, end: number): TInterval[] {
+	public findIntervalsWithEndpointInRange(start: number, end: number): SequenceInterval[] {
 		if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
 			return [];
 		}
-		const results: TInterval[] = [];
-		const action: PropertyAction<TInterval, TInterval> = (node) => {
+		const results: SequenceInterval[] = [];
+		const action: PropertyAction<SequenceInterval, SequenceInterval> = (node) => {
 			results.push(node.data);
 			return true;
 		};
 
-		const transientStartInterval = this.helpers.create(
+		const transientStartInterval = createSequenceInterval(
 			"transient",
 			start,
 			start,
@@ -97,7 +85,7 @@ export class EndpointInRangeIndex<TInterval extends ISerializableInterval>
 			IntervalType.Transient,
 		);
 
-		const transientEndInterval = this.helpers.create(
+		const transientEndInterval = createSequenceInterval(
 			"transient",
 			end,
 			end,
@@ -119,7 +107,7 @@ export class EndpointInRangeIndex<TInterval extends ISerializableInterval>
  */
 export function createEndpointInRangeIndex(
 	sharedString: ISharedString,
-): IEndpointInRangeIndex<SequenceInterval> {
+): IEndpointInRangeIndex {
 	const client = (sharedString as unknown as { client: Client }).client;
-	return new EndpointInRangeIndex<SequenceInterval>(client, sequenceIntervalHelpers);
+	return new EndpointInRangeIndex(client);
 }