@fluidframework/legacy-dds 2.52.0 → 2.53.0

package/src/array/sharedArray.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import type {
 	Serializable,
 	IChannelAttributes,
@@ -480,8 +480,6 @@ export class SharedArrayClass<T extends SerializableTypeForSharedArray>
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
 		if (message.type === MessageType.Operation) {
 			const op = message.contents as ISharedArrayOperation<T>;
-			const opEntry = this.getEntryForId(op.entryId);
-
 			switch (op.type) {
 				case OperationType.insertEntry: {
 					this.handleInsertOp<SerializableTypeForSharedArray>(
@@ -490,84 +488,22 @@ export class SharedArrayClass<T extends SerializableTypeForSharedArray>
 						local,
 						op.value,
 					);
-
 					break;
 				}
-
 				case OperationType.deleteEntry: {
-					if (local) {
-						// Decrementing local pending counter as op is already applied to local state
-						opEntry.isLocalPendingDelete -= 1;
-					} else {
-						// If local pending, then ignore else apply the remote op
-						if (!this.isLocalPending(op.entryId, "isLocalPendingDelete")) {
-							// last element in skip list is the most recent and live entry, so marking it deleted
-							this.getLiveEntry(op.entryId).isDeleted = true;
-						}
-					}
-
+					this.handleDeleteOp(op, local);
 					break;
 				}
-
 				case OperationType.moveEntry: {
-					this.handleInsertOp<SerializableTypeForSharedArray>(
-						op.changedToEntryId,
-						op.insertAfterEntryId,
-						local,
-						opEntry.value,
-					);
-					if (local) {
-						// decrement the local pending move op as its already applied to local state
-						opEntry.isLocalPendingMove -= 1;
-					} else {
-						const newElementEntryId = op.changedToEntryId;
-						const newElement = this.getEntryForId(newElementEntryId);
-						// If local pending then simply mark the new location dead as finally the local op will win
-						if (
-							this.isLocalPending(op.entryId, "isLocalPendingDelete") ||
-							this.isLocalPending(op.entryId, "isLocalPendingMove")
-						) {
-							this.updateDeadEntry(op.entryId, newElementEntryId);
-						} else {
-							// move the element
-							const liveEntry = this.getLiveEntry(op.entryId);
-							const isDeleted = liveEntry.isDeleted;
-							this.updateLiveEntry(liveEntry.entryId, newElementEntryId);
-							// mark newly added element as deleted if existing live element was already deleted
-							if (isDeleted) {
-								newElement.isDeleted = isDeleted;
-							}
-						}
-					}
+					this.handleMoveOp(op, local);
 					break;
 				}
-
 				case OperationType.toggle: {
-					if (local) {
-						// decrement the local pending delete op as its already applied to local state
-						if (opEntry.isLocalPendingDelete) {
-							opEntry.isLocalPendingDelete -= 1;
-						}
-					} else {
-						if (!this.isLocalPending(op.entryId, "isLocalPendingDelete")) {
-							this.getLiveEntry(op.entryId).isDeleted = op.isDeleted;
-						}
-					}
+					this.handleToggleOp(op, local);
 					break;
 				}
-
 				case OperationType.toggleMove: {
-					if (local) {
-						// decrement the local pending move op as its already applied to local state
-						if (opEntry.isLocalPendingMove) {
-							opEntry.isLocalPendingMove -= 1;
-						}
-					} else if (
-						!this.isLocalPending(op.entryId, "isLocalPendingDelete") &&
-						!this.isLocalPending(op.entryId, "isLocalPendingMove")
-					) {
-						this.updateLiveEntry(this.getLiveEntry(op.entryId).entryId, op.entryId);
-					}
+					this.handleToggleMoveOp(op, local);
 					break;
 				}
 
@@ -581,6 +517,101 @@ export class SharedArrayClass<T extends SerializableTypeForSharedArray>
 		}
 	}
 
+	private handleInsertOp<TWrite>(
+		entryId: string,
+		insertAfterEntryId: string | undefined,
+		local: boolean,
+		value: Serializable<TWrite> & T,
+	): void {
+		let index = 0;
+		if (local) {
+			this.getEntryForId(entryId).isAckPending = false;
+		} else {
+			if (insertAfterEntryId !== undefined) {
+				index = this.findIndexOfEntryId(insertAfterEntryId) + 1;
+			}
+			const newEntry = this.createNewEntry(entryId, value);
+			newEntry.isAckPending = false;
+			this.addEntry(this.getInternalInsertIndexByIgnoringLocalPendingInserts(index), newEntry);
+		}
+	}
+
+	private handleDeleteOp(op: IDeleteOperation, local: boolean): void {
+		const opEntry = this.getEntryForId(op.entryId);
+		if (local) {
+			// Decrementing local pending counter as op is already applied to local state
+			opEntry.isLocalPendingDelete -= 1;
+		} else {
+			// If local pending, then ignore else apply the remote op
+			if (!this.isLocalPending(op.entryId, "isLocalPendingDelete")) {
+				// last element in skip list is the most recent and live entry, so marking it deleted
+				this.getLiveEntry(op.entryId).isDeleted = true;
+			}
+		}
+	}
+
+	private handleMoveOp(op: IMoveOperation, local: boolean): void {
+		const opEntry = this.getEntryForId(op.entryId);
+		this.handleInsertOp<SerializableTypeForSharedArray>(
+			op.changedToEntryId,
+			op.insertAfterEntryId,
+			local,
+			opEntry.value,
+		);
+		if (local) {
+			// decrement the local pending move op as its already applied to local state
+			opEntry.isLocalPendingMove -= 1;
+		} else {
+			const newElementEntryId = op.changedToEntryId;
+			const newElement = this.getEntryForId(newElementEntryId);
+			// If local pending then simply mark the new location dead as finally the local op will win
+			if (
+				this.isLocalPending(op.entryId, "isLocalPendingDelete") ||
+				this.isLocalPending(op.entryId, "isLocalPendingMove")
+			) {
+				this.updateDeadEntry(op.entryId, newElementEntryId);
+			} else {
+				// move the element
+				const liveEntry = this.getLiveEntry(op.entryId);
+				const isDeleted = liveEntry.isDeleted;
+				this.updateLiveEntry(liveEntry.entryId, newElementEntryId);
+				// mark newly added element as deleted if existing live element was already deleted
+				if (isDeleted) {
+					newElement.isDeleted = isDeleted;
+				}
+			}
+		}
+	}
+
+	private handleToggleOp(op: IToggleOperation, local: boolean): void {
+		const opEntry = this.getEntryForId(op.entryId);
+		if (local) {
+			// decrement the local pending delete op as its already applied to local state
+			if (opEntry.isLocalPendingDelete) {
+				opEntry.isLocalPendingDelete -= 1;
+			}
+		} else {
+			if (!this.isLocalPending(op.entryId, "isLocalPendingDelete")) {
+				this.getLiveEntry(op.entryId).isDeleted = op.isDeleted;
+			}
+		}
+	}
+
+	private handleToggleMoveOp(op: IToggleMoveOperation, local: boolean): void {
+		const opEntry = this.getEntryForId(op.entryId);
+		if (local) {
+			// decrement the local pending move op as its already applied to local state
+			if (opEntry.isLocalPendingMove) {
+				opEntry.isLocalPendingMove -= 1;
+			}
+		} else if (
+			!this.isLocalPending(op.entryId, "isLocalPendingDelete") &&
+			!this.isLocalPending(op.entryId, "isLocalPendingMove")
+		) {
+			this.updateLiveEntry(this.getLiveEntry(op.entryId).entryId, op.entryId);
+		}
+	}
+
 	private findInternalIndex(countEntries: number): number {
 		if (countEntries < 0) {
 			throw new Error("Input count is zero");
@@ -723,25 +754,6 @@ export class SharedArrayClass<T extends SerializableTypeForSharedArray>
 		return localOpsIterator;
 	}
 
-	private handleInsertOp<TWrite>(
-		entryId: string,
-		insertAfterEntryId: string | undefined,
-		local: boolean,
-		value: Serializable<TWrite> & T,
-	): void {
-		let index = 0;
-		if (local) {
-			this.getEntryForId(entryId).isAckPending = false;
-		} else {
-			if (insertAfterEntryId !== undefined) {
-				index = this.findIndexOfEntryId(insertAfterEntryId) + 1;
-			}
-			const newEntry = this.createNewEntry(entryId, value);
-			newEntry.isAckPending = false;
-			this.addEntry(this.getInternalInsertIndexByIgnoringLocalPendingInserts(index), newEntry);
-		}
-	}
-
 	private findIndexOfEntryId(entryId: string | undefined): number {
 		for (let index = 0; index < this.sharedArray.length; index = index + 1) {
 			if (this.sharedArray[index]?.entryId === entryId) {
@@ -829,7 +841,39 @@ export class SharedArrayClass<T extends SerializableTypeForSharedArray>
 		deadEntry.isDeleted = true;
 	}
 
-	protected applyStashedOp(_content: unknown): void {
-		throw new Error("Not implemented");
+	protected applyStashedOp(content: unknown): void {
+		const op = content as ISharedArrayOperation<T>;
+
+		switch (op.type) {
+			case OperationType.insertEntry: {
+				this.handleInsertOp<SerializableTypeForSharedArray>(
+					op.entryId,
+					op.insertAfterEntryId,
+					false, // treat it as remote op
+					op.value,
+				);
+				break;
+			}
+			case OperationType.deleteEntry: {
+				this.handleDeleteOp(op, false /* local - treat as remote op */);
+				break;
+			}
+			case OperationType.moveEntry: {
+				this.handleMoveOp(op, false /* local - treat as remote op */);
+				break;
+			}
+			case OperationType.toggle: {
+				this.handleToggleOp(op, false /* local - treat as remote op */);
+				break;
+			}
+			case OperationType.toggleMove: {
+				this.handleToggleMoveOp(op, false /* local - treat as remote op */);
+				break;
+			}
+			default: {
+				unreachableCase(op);
+			}
+		}
+		this.submitLocalMessage(op);
 	}
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/legacy-dds";
-export const pkgVersion = "2.52.0";
+export const pkgVersion = "2.53.0";