fix(map): Emit valueChanged event when there are pending local ops after remote clear (#26010)

When a remote clear operation is received while there are pending local
set operations, the map emits a "clear" event but the map still contains
keys. This made the clear event unreliable as an indicator of map state,
requiring the oracle to re-read all keys after every clear event.

This change adds functionality to emit `valueChanged` event for keys
which are deleted during remote clears. This way the customers would
have to just focus on the `valueChanged` event and not `clear` event for
remote ops.


[ADO#48665](https://dev.azure.com/fluidframework/internal/_workitems/edit/48665)

Follow-up:
[ADO#55457](https://dev.azure.com/fluidframework/internal/_workitems/edit/55457)

Author: sonalideshpandemsft

packages/dds/map/src/mapKernel.ts

@@ -685,8 +685,8 @@ export class MapKernel {
 				local: boolean,
 				localOpMetadata: PendingLocalOpMetadata | undefined,
 			) => {
-				this.sequencedData.clear();
 				if (local) {
+					this.sequencedData.clear();
 					const pendingClear = this.pendingData.shift();
 					assert(
 						pendingClear !== undefined &&
@@ -695,10 +695,35 @@ export class MapKernel {
 						0xbf6 /* Got a local clear message we weren't expecting */,
 					);
 				} else {
+					const keysToDelete: { key: string; previousValue: unknown }[] = [];
+					for (const [key, value] of this.sequencedData) {
+						// Check if this key has pending local operations that supersede the remote op
+						const hasPendingOps = this.pendingData.some(
+							(entry) =>
+								(entry.type === "delete" && entry.key === key) ||
+								(entry.type === "lifetime" && entry.key === key),
+						);
+						// Only collect keys without pending operations (i.e., actually deleted)
+						if (!hasPendingOps) {
+							keysToDelete.push({ key, previousValue: value.value });
+						}
+					}
+					this.sequencedData.clear();
+
 					// Only emit for remote ops, we would have already emitted for local ops. Only emit if there
 					// is no optimistically-applied local pending clear that would supersede this remote clear.
 					if (!this.pendingData.some((entry) => entry.type === "clear")) {
 						this.eventEmitter.emit("clear", local, this.eventEmitter);
+
+						// Emit delete-like valueChanged events for keys that were removed
+						for (const { key, previousValue } of keysToDelete) {
+							this.eventEmitter.emit(
+								"valueChanged",
+								{ key, previousValue },
+								local,
+								this.eventEmitter,
+							);
+						}
 					}
 				}
 			},

packages/dds/map/src/test/mapOracle.ts

@@ -42,13 +42,8 @@ export class SharedMapOracle {
 	};
 
 	private readonly onClear = (local: boolean): void => {
-		this.oracle.clear();
-
-		// AB#48665: https://dev.azure.com/fluidframework/internal/_workitems/edit/48665
-		if (!local) {
-			for (const [k, v] of this.fuzzMap.entries()) {
-				this.oracle.set(k, v);
-			}
+		if (local) {
+			this.oracle.clear();
 		}
 	};
 

packages/dds/map/src/test/mocha/map.spec.ts

@@ -517,18 +517,27 @@ describe("Map", () => {
 
 					containerRuntimeFactory.processSomeMessages(2);
 
-					assert.equal(valuesChanged.length, 2);
+					// After remote clear: emit clear + valueChanged delete events for removed keys
+					assert.equal(valuesChanged.length, 3, "2 initial sets + 1 delete for map2key");
 					assert.equal(valuesChanged[0].key, "map1Key");
 					assert.equal(valuesChanged[0].previousValue, undefined);
 					assert.equal(valuesChanged[1].key, "map2key");
 					assert.equal(valuesChanged[1].previousValue, undefined);
+					assert.equal(valuesChanged[2].key, "map2key", "Delete event for map2key");
+					assert.equal(
+						valuesChanged[2].previousValue,
+						"value2",
+						"Previous value before clear",
+					);
 					assert.equal(clearCount, 1);
 					assert.equal(map1.size, 1);
 					assert.equal(map1.get("map1Key"), "value1");
 
 					containerRuntimeFactory.processSomeMessages(2);
 
-					assert.equal(valuesChanged.length, 2);
+					assert.equal(valuesChanged.length, 4, "One more delete for map1Key");
+					assert.equal(valuesChanged[3].key, "map1Key");
+					assert.equal(valuesChanged[3].previousValue, "value1");
 					assert.equal(clearCount, 2);
 					assert.equal(map1.size, 0);
 				});