@fluidframework/merge-tree 2.10.0-306579 → 2.10.0-307399

package/src/segmentPropertiesManager.ts

@@ -3,13 +3,16 @@
  * Licensed under the MIT License.
  */
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-
 import { assert } from "@fluidframework/core-utils/internal";
 
+import { DoublyLinkedList, iterateListValuesWhile } from "./collections/index.js";
 import { UnassignedSequenceNumber, UniversalSequenceNumber } from "./constants.js";
-import { IMergeTreeAnnotateMsg } from "./ops.js";
-import { MapLike, PropertySet, clone, createMap, extend } from "./properties.js";
+import type {
+	AdjustParams,
+	IMergeTreeAnnotateAdjustMsg,
+	IMergeTreeAnnotateMsg,
+} from "./ops.js";
+import { MapLike, PropertySet, clone, createMap } from "./properties.js";
 
 /**
  * @internal
@@ -25,7 +28,6 @@ export enum PropertiesRollback {
 	 */
 	Rollback,
 }
-
 /**
  * Minimally copies properties and the property manager from source to destination.
  * @internal
@@ -45,133 +47,320 @@ export function copyPropertiesAndManager(
 			destination.properties = clone(source.properties);
 		} else {
 			destination.propertyManager ??= new PropertiesManager();
-			destination.properties = source.propertyManager.copyTo(
-				source.properties,
-				destination.properties,
-				destination.propertyManager,
-			);
+			source.propertyManager.copyTo(source.properties, destination);
 		}
 	}
 }
 
+type PropertyChange = {
+	seq: number;
+} & ({ adjust: AdjustParams; raw?: undefined } | { raw: unknown; adjust?: undefined });
+
+interface PropertyChanges {
+	msnConsensus: unknown;
+	remote: DoublyLinkedList<PropertyChange>;
+	local: DoublyLinkedList<PropertyChange>;
+}
+
+function computePropertyValue(
+	consensus: unknown,
+	...changes: Iterable<PropertyChange>[]
+): unknown {
+	let computedValue: unknown = consensus;
+	for (const change of changes) {
+		for (const op of change) {
+			const { raw, adjust } = op;
+			if (adjust === undefined) {
+				computedValue = raw;
+			} else {
+				const adjusted =
+					(typeof computedValue === "number" ? computedValue : 0) + adjust.delta;
+				if (adjust.max !== undefined && adjusted > adjust.max) {
+					computedValue = adjust.max;
+				} else if (adjust.min !== undefined && adjusted < adjust.min) {
+					computedValue = adjust.min;
+				} else {
+					computedValue = adjusted;
+				}
+			}
+		}
+	}
+	return computedValue;
+}
+
 /**
  * @internal
  */
-export class PropertiesManager {
-	private pendingKeyUpdateCount: MapLike<number> | undefined;
+export type PropsOrAdjust =
+	| Pick<IMergeTreeAnnotateAdjustMsg, "props" | "adjust">
+	| Pick<IMergeTreeAnnotateMsg, "props" | "adjust">;
+
+const opToChanges = (op: PropsOrAdjust, seq: number): [string, PropertyChange][] => [
+	...Object.entries(op.props ?? {})
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		.map<[string, PropertyChange]>(([k, raw]) => [k, { raw, seq }])
+		.filter(([_, v]) => v.raw !== undefined),
+	...Object.entries(op.adjust ?? {}).map<[string, PropertyChange]>(([k, adjust]) => [
+		k,
+		{ adjust, seq },
+	]),
+];
 
-	public ackPendingProperties(annotateOp: IMergeTreeAnnotateMsg): void {
-		this.decrementPendingCounts(annotateOp.props);
+function applyChanges(
+	op: PropsOrAdjust,
+	seg: { properties?: MapLike<unknown> },
+	seq: number,
+	run: (
+		properties: MapLike<unknown>,
+		deltas: MapLike<unknown>,
+		key: string,
+		value: PropertyChange,
+	) => void,
+): MapLike<unknown> {
+	const properties = (seg.properties ??= createMap<unknown>());
+	const deltas: MapLike<unknown> = {};
+	for (const [key, value] of opToChanges(op, seq)) {
+		run(properties, deltas, key, value);
+		if (properties[key] === null) {
+			// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+			delete properties[key];
+		}
 	}
+	return deltas;
+}
 
-	private decrementPendingCounts(props: PropertySet): void {
-		for (const [key, value] of Object.entries(props)) {
-			if (value !== undefined && this.pendingKeyUpdateCount?.[key] !== undefined) {
+/**
+ * The PropertiesManager class handles changes to properties, both remote and local.
+ * It manages the lifecycle for local property changes, ensures all property changes are eventually consistent,
+ * and provides methods to acknowledge changes, update the minimum sequence number (msn), and copy properties to another manager.
+ * This class is essential for maintaining the integrity and consistency of property changes in collaborative environments.
+ * @internal
+ */
+export class PropertiesManager {
+	private readonly changes = new Map<string, PropertyChanges>();
+
+	/**
+	 * Rolls back local property changes.
+	 * This method reverts property changes based on the provided operation and segment.
+	 * If the operation is part of a collaborative session, it ensures that the changes are consistent with the remote state.
+	 *
+	 * @param op - The operation containing property changes. This can be an adjustment or a set of properties.
+	 * @param seg - The segment containing properties. This object may have a properties map that will be modified.
+	 * @param collaborating - Indicates if the operation is part of a collaborative session. Defaults to false.
+	 * @returns The deltas of the rolled-back properties. This is a map-like object representing the changes that were reverted.
+	 */
+	public rollbackProperties(
+		op: PropsOrAdjust,
+		seg: { properties?: MapLike<unknown> },
+		collaborating: boolean = false,
+	): MapLike<unknown> {
+		return applyChanges(op, seg, UniversalSequenceNumber, (properties, deltas, key, value) => {
+			// eslint-disable-next-line unicorn/no-null
+			const previousValue = properties[key] ?? null;
+
+			const pending = this.changes.get(key);
+			if (collaborating) {
 				assert(
-					this.pendingKeyUpdateCount[key]! > 0,
-					0x05c /* "Trying to update more annotate props than do exist!" */,
+					pending !== undefined,
+					"Pending changes must exist for rollback when collaborating",
+				);
+				pending.local.pop();
+				properties[key] = computePropertyValue(
+					pending.msnConsensus,
+					pending.remote.map((n) => n.data),
+					pending.local.map((n) => n.data),
 				);
-				this.pendingKeyUpdateCount[key]--;
-				if (this.pendingKeyUpdateCount?.[key] === 0) {
-					// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-					delete this.pendingKeyUpdateCount[key];
+				if (pending.local.empty && pending.remote.empty) {
+					this.changes.delete(key);
 				}
+			} else {
+				assert(pending === undefined, "Pending changes must not exist when not collaborating");
+				properties[key] = computePropertyValue(previousValue, [value]);
 			}
-		}
+			deltas[key] = previousValue;
+		});
 	}
 
-	public addProperties(
-		oldProps: PropertySet,
-		newProps: PropertySet,
-		seq?: number,
+	/**
+	 * Handles property changes.
+	 * This method applies property changes based on the provided operation, segment, sequence number, and collaboration state.
+	 * It also handles rolling back changes if specified.
+	 *
+	 * @param op - The operation containing property changes.
+	 * @param seg - The segment containing properties.
+	 * @param seq - The sequence number for the operation.
+	 * @param msn - The minimum sequence number for the operation.
+	 * @param collaborating - Indicates if the operation is part of a collaborative session. Defaults to false.
+	 * @param rollback - Specifies if the changes should be rolled back. Defaults to PropertiesRollback.None.
+	 * @returns The deltas of the applied or rolled-back properties. This is a map-like object representing the changes.
+	 */
+	public handleProperties(
+		op: PropsOrAdjust,
+		seg: { properties?: MapLike<unknown> },
+		seq: number,
+		msn: number,
 		collaborating: boolean = false,
 		rollback: PropertiesRollback = PropertiesRollback.None,
-	): PropertySet {
-		this.pendingKeyUpdateCount ??= createMap<number>();
-
-		// Clean up counts for rolled back edits before modifying oldProps
-		if (collaborating && rollback === PropertiesRollback.Rollback) {
-			this.decrementPendingCounts(newProps);
+	): MapLike<unknown> {
+		if (rollback === PropertiesRollback.Rollback) {
+			return this.rollbackProperties(op, seg, collaborating);
 		}
-
-		const shouldModifyKey = (key: string): boolean => {
-			if (
-				seq === UnassignedSequenceNumber ||
-				seq === UniversalSequenceNumber ||
-				this.pendingKeyUpdateCount?.[key] === undefined
-			) {
-				return true;
-			}
-			return false;
-		};
-
-		const deltas: PropertySet = {};
-
-		for (const [key, newValue] of Object.entries(newProps)) {
-			if (newValue === undefined) {
-				continue;
-			}
-
+		const rtn = applyChanges(op, seg, seq, (properties, deltas, key, value) => {
+			// eslint-disable-next-line unicorn/no-null
+			const previousValue = properties[key] ?? null;
 			if (collaborating) {
-				if (seq === UnassignedSequenceNumber) {
-					if (this.pendingKeyUpdateCount?.[key] === undefined) {
-						this.pendingKeyUpdateCount[key] = 0;
+				const pending: PropertyChanges | undefined = this.changes.get(key) ?? {
+					msnConsensus: previousValue,
+					remote: new DoublyLinkedList(),
+					local: new DoublyLinkedList(),
+				};
+				this.changes.set(key, pending);
+				const local = seq === UnassignedSequenceNumber;
+				if (local) {
+					pending.local.push(value);
+				} else {
+					// we only track remotes if there are adjusts, as only adjusts make application anti-commutative
+					// this will limit the impact of this change to only those using adjusts. Additionally, we only
+					// need to track remotes at all to support emitting the legacy snapshot format, which only sharedstring
+					// uses. when we remove the ability to emit that format, we can remove all remote op tracking
+					if (value.raw !== undefined && pending.remote.empty) {
+						pending.msnConsensus = computePropertyValue(pending.msnConsensus, [value]);
+					} else {
+						pending.remote.push(value);
 					}
-					this.pendingKeyUpdateCount[key]++;
-				} else if (!shouldModifyKey(key)) {
-					continue;
 				}
+				properties[key] = computePropertyValue(
+					pending.msnConsensus,
+					pending.remote.map((n) => n.data),
+					pending.local.map((n) => n.data),
+				);
+				if (local || pending.local.empty || properties[key] !== previousValue) {
+					deltas[key] = previousValue;
+				}
+			} else {
+				properties[key] = computePropertyValue(previousValue, [value]);
+				deltas[key] = previousValue;
 			}
+		});
+		this.updateMsn(msn);
+		return rtn;
+	}
 
-			const previousValue: unknown = oldProps[key];
-			// The delta should be null if undefined, as that's how we encode delete
-			// eslint-disable-next-line unicorn/no-null
-			deltas[key] = previousValue === undefined ? null : previousValue;
-			if (newValue === null) {
-				// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-				delete oldProps[key];
+	/**
+	 * Acknowledges property changes.
+	 * This method acknowledges the property changes based on the provided sequence number and operation.
+	 *
+	 * @param seq - The sequence number for the operation.
+	 * @param msn - The minimum sequence number for the operation.
+	 * @param op - The operation containing property changes.
+	 */
+	public ack(seq: number, msn: number, op: PropsOrAdjust): void {
+		for (const [key, value] of opToChanges(op, seq)) {
+			const change = this.changes.get(key);
+			const acked = change?.local?.shift();
+			assert(change !== undefined && acked !== undefined, "must have local change to ack");
+			// we only track remotes if there are adjusts, as only adjusts make application anti-commutative
+			// this will limit the impact of this change to only those using adjusts. Additionally, we only
+			// need to track remotes at all to support emitting the legacy snapshot format, which only sharedstring
+			// uses. when we remove the ability to emit that format, we can remove all remote op tracking
+			if (value.raw !== undefined && change.remote.empty) {
+				change.msnConsensus = computePropertyValue(change.msnConsensus, [value]);
 			} else {
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-				oldProps[key] = newValue;
+				change.remote.push(value);
 			}
 		}
+		this.updateMsn(msn);
+	}
 
-		return deltas;
+	/**
+	 * Updates the minimum sequence number (msn).
+	 * This method updates the minimum sequence number and removes any changes that have been acknowledged.
+	 *
+	 * @param msn - The minimum sequence number to update.
+	 */
+	public updateMsn(msn: number): void {
+		for (const [key, pending] of this.changes) {
+			pending.msnConsensus = computePropertyValue(
+				pending.msnConsensus,
+				iterateListValuesWhile(pending.remote.first, (n) => {
+					if (n.data.seq <= msn) {
+						n.list?.remove(n);
+						return true;
+					}
+					return false;
+				}),
+			);
+			if (pending.local.empty && pending.remote.empty) {
+				this.changes.delete(key);
+			}
+		}
 	}
 
+	/**
+	 * Copies properties to another manager.
+	 * This method copies the properties and their changes from the current manager to the destination manager.
+	 *
+	 * @param oldProps - The old properties to be copied.
+	 * @param dest - The destination object containing properties and property manager.
+	 */
 	public copyTo(
-		oldProps: PropertySet,
-		newProps: PropertySet | undefined,
-		newManager: PropertiesManager,
-	): PropertySet | undefined {
-		if (oldProps) {
-			// eslint-disable-next-line no-param-reassign
-			newProps ??= createMap<unknown>();
-			if (!newManager) {
-				throw new Error("Must provide new PropertyManager");
-			}
-			extend(newProps, oldProps);
+		oldProps: PropertySet | undefined,
+		dest: {
+			properties?: PropertySet;
+			propertyManager?: PropertiesManager;
+		},
+	): void {
+		const newManager = (dest.propertyManager ??= new PropertiesManager());
+		dest.properties = clone(oldProps);
+		for (const [key, { local, remote, msnConsensus }] of this.changes.entries()) {
+			newManager.changes.set(key, {
+				msnConsensus,
+				remote: new DoublyLinkedList(remote.empty ? undefined : remote.map((c) => c.data)),
+				local: new DoublyLinkedList(local.empty ? undefined : local.map((c) => c.data)),
+			});
+		}
+	}
 
-			if (this.pendingKeyUpdateCount) {
-				newManager.pendingKeyUpdateCount = clone(this.pendingKeyUpdateCount);
+	/**
+	 * Gets properties at a specific sequence number.
+	 * This method retrieves the properties at the given sequence number.
+	 * This is only needed to support emitting snapshots in the legacy format.
+	 * If we remove the ability to emit the legacy format, we can remove this method, along with the need to track remote changes at all.
+	 *
+	 * @param oldProps - The old properties to be retrieved.
+	 * @param sequenceNumber - The sequence number to get properties at.
+	 * @returns The properties at the given sequence number.
+	 */
+	public getAtSeq(
+		oldProps: MapLike<unknown> | undefined,
+		sequenceNumber: number,
+	): MapLike<unknown> {
+		const properties: MapLike<unknown> = { ...oldProps };
+		for (const [key, changes] of this.changes) {
+			properties[key] = computePropertyValue(
+				changes.msnConsensus,
+				iterateListValuesWhile(changes.remote.first, (c) => c.data.seq <= sequenceNumber),
+			);
+			if (properties[key] === null) {
+				// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+				delete properties[key];
 			}
 		}
-		return newProps;
+		return properties;
 	}
 
 	/**
 	 * Determines if all of the defined properties in a given property set are pending.
+	 *
+	 * @param props - The properties to check.
+	 * @returns True if all the properties are pending, false otherwise.
 	 */
 	public hasPendingProperties(props: PropertySet): boolean {
 		for (const [key, value] of Object.entries(props)) {
-			if (value !== undefined && this.pendingKeyUpdateCount?.[key] === undefined) {
+			if (value !== undefined && this.changes.get(key)?.local.empty !== false) {
 				return false;
 			}
 		}
 		return true;
 	}
-
-	public hasPendingProperty(key: string): boolean {
-		return (this.pendingKeyUpdateCount?.[key] ?? 0) > 0;
-	}
 }

package/src/zamboni.ts

@@ -35,6 +35,9 @@ export function zamboniSegments(
 
 	for (let i = 0; i < zamboniSegmentsMaxCount; i++) {
 		let segmentToScour = mergeTree.segmentsToScour.peek()?.value;
+
+		segmentToScour?.segment?.propertyManager?.updateMsn(mergeTree.collabWindow.minSeq);
+
 		if (!segmentToScour || segmentToScour.maxSeq > mergeTree.collabWindow.minSeq) {
 			break;
 		}