@fluidframework/map 2.41.0 → 2.43.0-343119

package/src/localValues.ts

@@ -19,125 +19,52 @@ import type { ISerializableValue, ISerializedValue } from "./internalInterfaces.
  * A local value to be stored in a container type Distributed Data Store (DDS).
  */
 export interface ILocalValue {
-	/**
-	 * Type indicator of the value stored within.
-	 */
-	readonly type: string;
-
 	/**
 	 * The in-memory value stored within.
 	 */
-	// TODO: Use `unknown` instead (breaking change).
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	readonly value: any;
-
-	/**
-	 * Retrieve the serialized form of the value stored within.
-	 * @param serializer - Data store runtime's serializer
-	 * @param bind - Container type's handle
-	 * @returns The serialized form of the contained value
-	 */
-	makeSerialized(serializer: IFluidSerializer, bind: IFluidHandle): ISerializedValue;
+	readonly value: unknown;
 }
 
 /**
- * Converts the provided `localValue` to its serialized form.
- *
- * @param localValue - The value to serialize.
- * @param serializer - Data store runtime's serializer.
- * @param bind - Container type's handle.
- *
- * @see {@link ILocalValue.makeSerialized}
+ * Convert a value to its serialized form, i.e. to be used in ops and summaries.
  */
-export function makeSerializable(
-	localValue: ILocalValue,
+export const serializeValue = (
+	value: unknown,
 	serializer: IFluidSerializer,
 	bind: IFluidHandle,
-	// eslint-disable-next-line import/no-deprecated
-): ISerializableValue {
-	const value = localValue.makeSerialized(serializer, bind);
+): ISerializedValue => {
+	const serializedValue = serializeHandles(value, serializer, bind);
+
 	return {
-		type: value.type,
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-		value: value.value && JSON.parse(value.value),
+		type: ValueType[ValueType.Plain],
+		value: serializedValue,
 	};
-}
+};
 
 /**
- * Manages a contained plain value.  May also contain shared object handles.
+ * Very old versions of Fluid permitted a different type of stored value, which represented a
+ * SharedObject held directly.  This functionality has since been replaced with handles.
+ *
+ * If the passed serializable is one of these old values, this function will mutate it to a modern
+ * value with a handle.  Otherwise it does nothing.
+ * @param serializable - The serializable value to potentially convert.
  */
-export class PlainLocalValue implements ILocalValue {
-	/**
-	 * Create a new PlainLocalValue.
-	 * @param value - The value to store, which may contain shared object handles
-	 */
-	public constructor(public readonly value: unknown) {}
-
-	/**
-	 * {@inheritDoc ILocalValue."type"}
-	 */
-	public get type(): string {
-		return ValueType[ValueType.Plain];
-	}
-
-	/**
-	 * {@inheritDoc ILocalValue.makeSerialized}
-	 */
-	public makeSerialized(serializer: IFluidSerializer, bind: IFluidHandle): ISerializedValue {
-		// Stringify to convert to the serialized handle values - and then parse in order to create
-		// a POJO for the op
-		const value = serializeHandles(this.value, serializer, bind);
-
-		return {
-			type: this.type,
-			value,
+export const migrateIfSharedSerializable = (
+	// eslint-disable-next-line import/no-deprecated
+	serializable: ISerializableValue,
+	serializer: IFluidSerializer,
+	bind: IFluidHandle,
+): void => {
+	// Migrate from old shared value to handles
+	if (serializable.type === ValueType[ValueType.Shared]) {
+		serializable.type = ValueType[ValueType.Plain];
+		const handle: ISerializedHandle = {
+			type: "__fluid_handle__",
+			url: serializable.value as string,
 		};
+		// NOTE: here we require the use of `parseHandles` because the roundtrip
+		// through a string is necessary to resolve the absolute path of
+		// legacy handles (`ValueType.Shared`)
+		serializable.value = serializer.encode(parseHandles(handle, serializer), bind);
 	}
-}
-
-/**
- * Enables a container type {@link https://fluidframework.com/docs/build/dds/ | DDS} to produce and store local
- * values with minimal awareness of how those objects are stored, serialized, and deserialized.
- */
-export class LocalValueMaker {
-	/**
-	 * Create a new LocalValueMaker.
-	 */
-	public constructor() {}
-
-	/**
-	 * Create a new local value from an incoming serialized value.
-	 * @param serializable - The serializable value to make local
-	 */
-	public fromSerializable(
-		// eslint-disable-next-line import/no-deprecated
-		serializable: ISerializableValue,
-		serializer: IFluidSerializer,
-		bind: IFluidHandle,
-	): ILocalValue {
-		// Migrate from old shared value to handles
-		if (serializable.type === ValueType[ValueType.Shared]) {
-			serializable.type = ValueType[ValueType.Plain];
-			const handle: ISerializedHandle = {
-				type: "__fluid_handle__",
-				url: serializable.value as string,
-			};
-			// NOTE: here we require the use of `parseHandles` because the roundtrip
-			// through a string is necessary to resolve the absolute path of
-			// legacy handles (`ValueType.Shared`)
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-			serializable.value = serializer.encode(parseHandles(handle, serializer), bind);
-		}
-
-		return new PlainLocalValue(serializable.value);
-	}
-
-	/**
-	 * Create a new local value containing a given plain object.
-	 * @param value - The value to store
-	 * @returns An ILocalValue containing the value
-	 */
-	public fromInMemory(value: unknown): ILocalValue {
-		return new PlainLocalValue(value);
-	}
-}
+};

package/src/map.ts

@@ -253,12 +253,14 @@ export class SharedMap extends SharedObject<ISharedMapEvents> implements IShared
 		const newFormat = json as IMapSerializationFormat;
 		if (Array.isArray(newFormat.blobs)) {
 			this.kernel.populateFromSerializable(newFormat.content);
-			await Promise.all(
-				newFormat.blobs.map(async (value) => {
-					const content = await readAndParse<IMapDataObjectSerializable>(storage, value);
-					this.kernel.populateFromSerializable(content);
-				}),
+			const blobContents = await Promise.all(
+				newFormat.blobs.map(async (blobName) =>
+					readAndParse<IMapDataObjectSerializable>(storage, blobName),
+				),
 			);
+			for (const blobContent of blobContents) {
+				this.kernel.populateFromSerializable(blobContent);
+			}
 		} else {
 			this.kernel.populateFromSerializable(json as IMapDataObjectSerializable);
 		}

package/src/mapKernel.ts

@@ -21,7 +21,11 @@ import type {
 	ISerializableValue,
 	ISerializedValue,
 } from "./internalInterfaces.js";
-import { type ILocalValue, LocalValueMaker, makeSerializable } from "./localValues.js";
+import {
+	type ILocalValue,
+	serializeValue,
+	migrateIfSharedSerializable,
+} from "./localValues.js";
 
 /**
  * Defines the means to process and submit a given op on a map.
@@ -154,18 +158,13 @@ export class MapKernel {
 	/**
 	 * This is used to assign a unique id to every outgoing operation and helps in tracking unack'd ops.
 	 */
-	private pendingMessageId: number = -1;
+	private nextPendingMessageId: number = 0;
 
 	/**
 	 * The pending ids of any clears that have been performed locally but not yet ack'd from the server
 	 */
 	private readonly pendingClearMessageIds: number[] = [];
 
-	/**
-	 * Object to create encapsulations of the values stored in the map.
-	 */
-	private readonly localValueMaker: LocalValueMaker;
-
 	/**
 	 * Create a new shared map kernel.
 	 * @param serializer - The serializer to serialize / parse handles
@@ -182,7 +181,6 @@ export class MapKernel {
 		private readonly isAttached: () => boolean,
 		private readonly eventEmitter: TypedEventEmitter<ISharedMapEvents>,
 	) {
-		this.localValueMaker = new LocalValueMaker();
 		this.messageHandlers = this.getMessageHandlers();
 	}
 
@@ -198,9 +196,7 @@ export class MapKernel {
 	 * Get an iterator over the entries in this map.
 	 * @returns The iterator
 	 */
-	// TODO: Use `unknown` instead (breaking change).
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	public entries(): IterableIterator<[string, any]> {
+	public entries(): IterableIterator<[string, unknown]> {
 		const localEntriesIterator = this.data.entries();
 		const iterator = {
 			next(): IteratorResult<[string, unknown]> {
@@ -221,9 +217,7 @@ export class MapKernel {
 	 * Get an iterator over the values in this map.
 	 * @returns The iterator
 	 */
-	// TODO: Use `unknown` instead (breaking change).
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	public values(): IterableIterator<any> {
+	public values(): IterableIterator<unknown> {
 		const localValuesIterator = this.data.values();
 		const iterator = {
 			next(): IteratorResult<unknown> {
@@ -231,7 +225,7 @@ export class MapKernel {
 				return nextVal.done
 					? { value: undefined, done: true }
 					: // Unpack the stored value
-						{ value: nextVal.value.value as unknown, done: false };
+						{ value: nextVal.value.value, done: false };
 			},
 			[Symbol.iterator](): IterableIterator<unknown> {
 				return this;
@@ -244,9 +238,7 @@ export class MapKernel {
 	 * Get an iterator over the entries in this map.
 	 * @returns The iterator
 	 */
-	// TODO: Use `unknown` instead (breaking change).
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	public [Symbol.iterator](): IterableIterator<[string, any]> {
+	public [Symbol.iterator](): IterableIterator<[string, unknown]> {
 		return this.entries();
 	}
 
@@ -266,9 +258,7 @@ export class MapKernel {
 	/**
 	 * {@inheritDoc ISharedMap.get}
 	 */
-	// TODO: Use `unknown` instead (breaking change).
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	public get<T = any>(key: string): T | undefined {
+	public get<T = unknown>(key: string): T | undefined {
 		const localValue = this.data.get(key);
 		return localValue === undefined ? undefined : (localValue.value as T);
 	}
@@ -291,11 +281,8 @@ export class MapKernel {
 			throw new Error("Undefined and null keys are not supported");
 		}
 
-		// Create a local value and serialize it.
-		const localValue = this.localValueMaker.fromInMemory(value);
-
 		// Set the value locally.
-		const previousValue = this.setCore(key, localValue, true);
+		const previousValue = this.setCore(key, { value }, true);
 
 		// If we are not attached, don't submit the op.
 		if (!this.isAttached()) {
@@ -305,7 +292,7 @@ export class MapKernel {
 		const op: IMapSetOperation = {
 			key,
 			type: "set",
-			value: { type: localValue.type, value: localValue.value as unknown },
+			value: { type: ValueType[ValueType.Plain], value },
 		};
 		this.submitMapKeyMessage(op, previousValue);
 	}
@@ -362,23 +349,11 @@ export class MapKernel {
 	 * @returns A JSON string containing serialized map data
 	 */
 	public getSerializedStorage(serializer: IFluidSerializer): IMapDataObjectSerialized {
-		const serializableMapData: IMapDataObjectSerialized = {};
+		const serializedMapData: IMapDataObjectSerialized = {};
 		for (const [key, localValue] of this.data.entries()) {
-			serializableMapData[key] = localValue.makeSerialized(serializer, this.handle);
+			serializedMapData[key] = serializeValue(localValue.value, serializer, this.handle);
 		}
-		return serializableMapData;
-	}
-
-	public getSerializableStorage(serializer: IFluidSerializer): IMapDataObjectSerializable {
-		const serializableMapData: IMapDataObjectSerializable = {};
-		for (const [key, localValue] of this.data.entries()) {
-			serializableMapData[key] = makeSerializable(localValue, serializer, this.handle);
-		}
-		return serializableMapData;
-	}
-
-	public serialize(serializer: IFluidSerializer): string {
-		return JSON.stringify(this.getSerializableStorage(serializer));
+		return serializedMapData;
 	}
 
 	/**
@@ -389,12 +364,8 @@ export class MapKernel {
 		for (const [key, serializable] of Object.entries(
 			this.serializer.decode(json) as IMapDataObjectSerializable,
 		)) {
-			const localValue = {
-				key,
-				value: this.makeLocal(key, serializable),
-			};
-
-			this.data.set(localValue.key, localValue.value);
+			migrateIfSharedSerializable(serializable, this.serializer, this.handle);
+			this.data.set(key, { value: serializable.value });
 		}
 	}
 
@@ -426,7 +397,8 @@ export class MapKernel {
 				break;
 			}
 			case "set": {
-				this.set(op.key, this.makeLocal(op.key, op.value).value);
+				migrateIfSharedSerializable(op.value, this.serializer, this.handle);
+				this.set(op.key, op.value.value);
 				break;
 			}
 			default: {
@@ -578,28 +550,6 @@ export class MapKernel {
 		}
 	}
 
-	/**
-	 * 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
-	 */
-	// eslint-disable-next-line import/no-deprecated
-	private makeLocal(key: string, serializable: ISerializableValue): ILocalValue {
-		if (
-			serializable.type === ValueType[ValueType.Plain] ||
-			serializable.type === ValueType[ValueType.Shared]
-		) {
-			return this.localValueMaker.fromSerializable(serializable, this.serializer, this.handle);
-		} else {
-			throw new Error("Unknown local value type");
-		}
-	}
-
 	/**
 	 * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
 	 * not process the incoming operation.
@@ -710,8 +660,8 @@ export class MapKernel {
 				}
 
 				// needProcessKeyOperation should have returned false if local is true
-				const context = this.makeLocal(op.key, op.value);
-				this.setCore(op.key, context, local);
+				migrateIfSharedSerializable(op.value, this.serializer, this.handle);
+				this.setCore(op.key, { value: op.value.value }, local);
 			},
 			submit: (op: IMapSetOperation, localOpMetadata: MapKeyLocalOpMetadata) => {
 				this.resubmitMapKeyMessage(op, localOpMetadata);
@@ -722,7 +672,7 @@ export class MapKernel {
 	}
 
 	private getMapClearMessageId(): number {
-		const pendingMessageId = ++this.pendingMessageId;
+		const pendingMessageId = this.nextPendingMessageId++;
 		this.pendingClearMessageIds.push(pendingMessageId);
 		return pendingMessageId;
 	}
@@ -740,7 +690,7 @@ export class MapKernel {
 	}
 
 	private getMapKeyMessageId(op: IMapKeyOperation): number {
-		const pendingMessageId = ++this.pendingMessageId;
+		const pendingMessageId = this.nextPendingMessageId++;
 		const pendingMessageIds = this.pendingKeys.get(op.key);
 		if (pendingMessageIds === undefined) {
 			this.pendingKeys.set(op.key, [pendingMessageId]);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/map";
-export const pkgVersion = "2.41.0";
+export const pkgVersion = "2.43.0-343119";