@fluidframework/tree 2.74.0 → 2.80.0

package/src/feature-libraries/sequence-field/moveEffectTable.ts

@@ -103,9 +103,9 @@ export function getMoveEffect(
 	addDependency: boolean = true,
 ): RangeQueryResult<ChangeAtomId, MoveEffect> {
 	const result = moveEffects.get(target, revision, id, count, addDependency);
-	return result.value !== undefined
-		? { ...result, value: adjustMoveEffectBasis(result.value as MoveEffectWithBasis, id) }
-		: result;
+	return result.value === undefined
+		? result
+		: { ...result, value: adjustMoveEffectBasis(result.value as MoveEffectWithBasis, id) };
 }
 
 export type MoveMark = CellMark<MoveMarkEffect>;
@@ -124,12 +124,15 @@ export function isMoveIn(effect: MarkEffect): effect is MoveIn {
 
 export function getMoveIn(effect: MarkEffect): MoveIn | undefined {
 	switch (effect.type) {
-		case "MoveIn":
+		case "MoveIn": {
 			return effect;
-		case "AttachAndDetach":
+		}
+		case "AttachAndDetach": {
 			return getMoveIn(effect.attach);
-		default:
+		}
+		default: {
 			return undefined;
+		}
 	}
 }
 
@@ -196,12 +199,15 @@ function getFirstMoveEffectLength(
 export function getCrossFieldTargetFromMove(mark: MoveMarkEffect): CrossFieldTarget {
 	const type = mark.type;
 	switch (type) {
-		case "MoveIn":
+		case "MoveIn": {
 			return CrossFieldTarget.Destination;
-		case "MoveOut":
+		}
+		case "MoveOut": {
 			return CrossFieldTarget.Source;
-		default:
+		}
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 

package/src/feature-libraries/sequence-field/rebase.ts

@@ -172,14 +172,18 @@ class RebaseQueue {
 				this.metadata,
 			);
 			switch (comparison) {
-				case CellOrder.SameCell:
+				case CellOrder.SameCell: {
 					return this.dequeueBoth();
-				case CellOrder.OldThenNew:
+				}
+				case CellOrder.OldThenNew: {
 					return this.dequeueBase();
-				case CellOrder.NewThenOld:
+				}
+				case CellOrder.NewThenOld: {
 					return this.dequeueNew();
-				default:
+				}
+				default: {
 					unreachableCase(comparison);
+				}
 			}
 		} else if (areInputCellsEmpty(newMark)) {
 			return this.dequeueNew();
@@ -192,7 +196,7 @@ class RebaseQueue {
 
 	private dequeueBase(length?: number): RebaseMarks {
 		const baseMark =
-			length !== undefined ? this.baseMarks.dequeueUpTo(length) : this.baseMarks.dequeue();
+			length === undefined ? this.baseMarks.dequeue() : this.baseMarks.dequeueUpTo(length);
 
 		let newMark: Mark = generateNoOpWithCellId(baseMark);
 
@@ -368,13 +372,16 @@ function separateEffectsForMove(mark: MarkEffect): {
 			}
 			return { follows: mark };
 		}
-		case "AttachAndDetach":
+		case "AttachAndDetach": {
 			return { follows: mark.detach, remains: mark.attach };
+		}
 		case "MoveIn":
-		case "Rename":
+		case "Rename": {
 			return { remains: mark };
-		case NoopMarkType:
+		}
+		case NoopMarkType: {
 			return {};
+		}
 		case "Insert": {
 			const follows: MoveOut = {
 				type: "MoveOut",
@@ -390,8 +397,9 @@ function separateEffectsForMove(mark: MarkEffect): {
 			}
 			return { remains, follows };
 		}
-		default:
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
@@ -413,9 +421,9 @@ function sendEffectToDest(
 	if (effect.length < count) {
 		const [markEffect1, markEffect2] = splitMarkEffect(markEffect, effect.length);
 		const newEffect =
-			effect.value !== undefined
-				? { ...effect.value, movedMark: markEffect1 }
-				: { movedMark: markEffect1 };
+			effect.value === undefined
+				? { movedMark: markEffect1 }
+				: { ...effect.value, movedMark: markEffect1 };
 		setMoveEffect(
 			moveEffects,
 			CrossFieldTarget.Destination,
@@ -432,9 +440,9 @@ function sendEffectToDest(
 		);
 	} else {
 		const newEffect: MoveEffect =
-			effect.value !== undefined
-				? { ...effect.value, movedEffect: markEffect }
-				: { movedEffect: markEffect };
+			effect.value === undefined
+				? { movedEffect: markEffect }
+				: { ...effect.value, movedEffect: markEffect };
 		setMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count, newEffect);
 	}
 }
@@ -454,9 +462,9 @@ function moveRebasedChanges(
 	).value;
 
 	const newEffect =
-		effect !== undefined
-			? { ...effect, rebasedChanges: nodeChange }
-			: { rebasedChanges: nodeChange };
+		effect === undefined
+			? { rebasedChanges: nodeChange }
+			: { ...effect, rebasedChanges: nodeChange };
 
 	setMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, 1, newEffect);
 }

package/src/feature-libraries/sequence-field/replaceRevisions.ts

@@ -5,7 +5,12 @@
 
 import { unreachableCase } from "@fluidframework/core-utils/internal";
 
-import { type RevisionTag, replaceAtomRevisions } from "../../core/index.js";
+import {
+	makeChangeAtomId,
+	type ChangesetLocalId,
+	type RevisionReplacer,
+	type RevisionTag,
+} from "../../core/index.js";
 
 import type { MoveMarkEffect } from "./helperTypes.js";
 import { MarkListFactory } from "./markListFactory.js";
@@ -13,40 +18,35 @@ import {
 	type Changeset,
 	type Detach,
 	type HasMoveFields,
+	type HasMoveId,
 	type HasRevisionTag,
+	type Insert,
 	type Mark,
 	type MarkEffect,
 	NoopMarkType,
+	type Remove,
 	type Rename,
 } from "./types.js";
 import { isDetach, isRename } from "./utils.js";
 
-export function replaceRevisions(
-	changeset: Changeset,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): Changeset {
+export function replaceRevisions(changeset: Changeset, replacer: RevisionReplacer): Changeset {
 	const updatedMarks = new MarkListFactory();
 	for (const mark of changeset) {
-		const updatedMark = updateMark(mark, revisionsToReplace, newRevision);
+		const updatedMark = updateMark(mark, replacer);
 		updatedMarks.push(updatedMark);
 	}
 
 	return updatedMarks.list;
 }
 
-function updateMark(
-	mark: Mark,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): Mark {
-	const updatedMark = { ...updateEffect(mark, revisionsToReplace, newRevision) };
+function updateMark(mark: Mark, replacer: RevisionReplacer): Mark {
+	const updatedMark = { ...updateEffect(mark, replacer) };
 	if (mark.cellId !== undefined) {
-		updatedMark.cellId = replaceAtomRevisions(mark.cellId, revisionsToReplace, newRevision);
+		updatedMark.cellId = replacer.getUpdatedAtomId(mark.cellId);
 	}
 
 	if (mark.changes !== undefined) {
-		updatedMark.changes = replaceAtomRevisions(mark.changes, revisionsToReplace, newRevision);
+		updatedMark.changes = replacer.getUpdatedAtomId(mark.changes);
 	}
 
 	return updatedMark;
@@ -54,87 +54,83 @@ function updateMark(
 
 function updateEffect<TMark extends MarkEffect>(
 	input: TMark,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): TMark {
-	const mark =
-		isDetach(input) || isRename(input)
-			? updateIdOverride(input, revisionsToReplace, newRevision)
-			: input;
+	const mark = isDetach(input) || isRename(input) ? updateIdOverride(input, replacer) : input;
 	const type = mark.type;
 	switch (type) {
 		case "Rename":
-		case NoopMarkType:
+		case NoopMarkType: {
 			return mark;
-		case "AttachAndDetach":
+		}
+		case "AttachAndDetach": {
 			return {
 				...mark,
-				attach: updateEffect(mark.attach, revisionsToReplace, newRevision),
-				detach: updateEffect(mark.detach, revisionsToReplace, newRevision),
+				attach: updateEffect(mark.attach, replacer),
+				detach: updateEffect(mark.detach, replacer),
 			};
+		}
 		case "MoveIn":
-		case "MoveOut":
+		case "MoveOut": {
 			return updateMoveEffect<TMark & MoveMarkEffect>(
 				// For some reason, TypeScript is not able to infer that `mark` cannot be a `NoopMark` here.
 				mark as MoveMarkEffect,
-				revisionsToReplace,
-				newRevision,
+				replacer,
 			);
+		}
 		case "Insert":
-		case "Remove":
-			return updateRevision<TMark & HasRevisionTag>(mark, revisionsToReplace, newRevision);
-		default:
+		case "Remove": {
+			return updateRevisionAndId(mark as (TMark & Insert) | (TMark & Remove), replacer);
+		}
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
 function updateIdOverride<TEffect extends Detach | Rename>(
 	effect: TEffect,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): TEffect {
-	if (effect.idOverride !== undefined) {
-		const idOverride = replaceAtomRevisions(
-			effect.idOverride,
-			revisionsToReplace,
-			newRevision,
-		);
-		return { ...effect, idOverride };
-	} else {
+	if (effect.idOverride === undefined) {
 		return effect;
 	}
+	const idOverride = replacer.getUpdatedAtomId(effect.idOverride);
+	return { ...effect, idOverride };
 }
 
 function updateMoveEffect<TEffect extends HasMoveFields>(
 	effect: TEffect,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): TEffect {
-	return effect.finalEndpoint !== undefined
-		? updateRevision(
+	return effect.finalEndpoint === undefined
+		? updateRevisionAndId(effect, replacer)
+		: updateRevisionAndId(
 				{
 					...effect,
-					finalEndpoint: updateRevision(effect.finalEndpoint, revisionsToReplace, newRevision),
+					finalEndpoint: replacer.getUpdatedAtomId(effect.finalEndpoint),
 				},
-				revisionsToReplace,
-				newRevision,
-			)
-		: updateRevision(effect, revisionsToReplace, newRevision);
+				replacer,
+			);
 }
 
-function updateRevision<T extends HasRevisionTag>(
+function updateRevisionAndId<T extends HasRevisionTag & HasMoveId>(
 	input: T,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): T {
-	return revisionsToReplace.has(input.revision) ? withRevision(input, newRevision) : input;
+	if (!replacer.isObsolete(input.revision)) {
+		return input;
+	}
+	const newAtom = replacer.getUpdatedAtomId(makeChangeAtomId(input.id, input.revision));
+	return withRevisionAndId(input, newAtom.revision, newAtom.localId);
 }
 
-function withRevision<T extends HasRevisionTag>(
+function withRevisionAndId<T extends HasRevisionTag>(
 	input: T,
 	revision: RevisionTag | undefined,
+	id: ChangesetLocalId,
 ): T {
-	const updated = { ...input, revision };
+	const updated = { ...input, revision, id };
 	if (revision === undefined) {
 		delete updated.revision;
 	}

package/src/feature-libraries/sequence-field/sequenceFieldCodecV2.ts

@@ -70,7 +70,7 @@ export function makeV2CodecHelpers(
 
 			const type = effect.type;
 			switch (type) {
-				case "MoveIn":
+				case "MoveIn": {
 					return {
 						moveIn: {
 							revision: encodeRevision(effect.revision),
@@ -81,14 +81,16 @@ export function makeV2CodecHelpers(
 							id: effect.id,
 						},
 					};
-				case "Insert":
+				}
+				case "Insert": {
 					return {
 						insert: {
 							revision: encodeRevision(effect.revision),
 							id: effect.id,
 						},
 					};
-				case "Remove":
+				}
+				case "Remove": {
 					return {
 						remove: {
 							revision: encodeRevision(effect.revision),
@@ -99,7 +101,8 @@ export function makeV2CodecHelpers(
 							id: effect.id,
 						},
 					};
-				case "MoveOut":
+				}
+				case "MoveOut": {
 					return {
 						moveOut: {
 							revision: encodeRevision(effect.revision),
@@ -114,14 +117,16 @@ export function makeV2CodecHelpers(
 							id: effect.id,
 						},
 					};
-				case "AttachAndDetach":
+				}
+				case "AttachAndDetach": {
 					return {
 						attachAndDetach: {
 							attach: markEffectCodec.encode(effect.attach, context) as Encoded.Attach,
 							detach: markEffectCodec.encode(effect.detach, context) as Encoded.Detach,
 						},
 					};
-				case "Rename":
+				}
+				case "Rename": {
 					// In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
 					// renames are encoded as AttachAndDetach with a special id.
 					// This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
@@ -133,10 +138,13 @@ export function makeV2CodecHelpers(
 						},
 						context,
 					);
-				case NoopMarkType:
+				}
+				case NoopMarkType: {
 					fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
-				default:
+				}
+				default: {
 					unreachableCase(type);
+				}
 			}
 		},
 		decode(encoded: Encoded.MarkEffect, context: ChangeEncodingContext): MarkEffect {

package/src/feature-libraries/sequence-field/sequenceFieldCodecV3.ts

@@ -50,14 +50,16 @@ export function makeV3Codec(
 		encode(effect: MarkEffect, context: ChangeEncodingContext): Encoded.MarkEffect {
 			const type = effect.type;
 			switch (type) {
-				case "Rename":
+				case "Rename": {
 					return {
 						rename: {
 							idOverride: atomIdCodec.encode(effect.idOverride, context),
 						},
 					};
-				default:
+				}
+				default: {
 					return markEffectV2Codec.encode(effect, context);
+				}
 			}
 		},
 		decode(encoded: Encoded.MarkEffect, context: ChangeEncodingContext): MarkEffect {

package/src/feature-libraries/sequence-field/sequenceFieldToDelta.ts

@@ -158,19 +158,22 @@ export function sequenceFieldToDelta(
 					local.push(deltaMark);
 					break;
 				}
-				case NoopMarkType:
+				case NoopMarkType: {
 					if (inputCellId === undefined) {
 						local.push(deltaMark);
 					}
 					break;
-				case "Rename":
+				}
+				case "Rename": {
 					assert(
 						mark.cellId !== undefined,
 						0x9f9 /* Renames should only target empty cells */,
 					);
 					break;
-				default:
+				}
+				default: {
 					unreachableCase(type);
+				}
 			}
 		}
 	}

package/src/feature-libraries/sequence-field/utils.ts

@@ -71,8 +71,8 @@ export function getNestedChanges(change: Changeset): NestedChangesIndices {
 		if (changes !== undefined) {
 			output.push([
 				changes,
-				!areInputCellsEmpty(mark) ? inputIndex : undefined /* inputIndex */,
-				!areOutputCellsEmpty(mark) ? outputIndex : undefined /* outputIndex */,
+				areInputCellsEmpty(mark) ? undefined : inputIndex /* inputIndex */,
+				areOutputCellsEmpty(mark) ? undefined : outputIndex /* outputIndex */,
 			]);
 		}
 		if (!areInputCellsEmpty(mark)) {
@@ -208,12 +208,12 @@ export function compareCellPositionsUsingTombstones(
 		// If both changesets know of both cells, but we've been asked to compare different cells,
 		// Then either the changesets they originate from do not represent the same context,
 		// or the ordering of their cells in inconsistent.
-		// The only exception to this is when we're composing anonymous changesets in a transaction.
+		// The only exception to this is when we're composing changesets in a transaction since they have the same revision but different sets of cells.
 		assert(
-			oldMarkCell.revision === undefined && newMarkCell.revision === undefined,
+			oldMarkCell.revision === newMarkCell.revision,
 			0x8a0 /* Inconsistent cell ordering */,
 		);
-		// We are composing anonymous changesets in a transaction. The new changeset is creating a cell in a gap
+		// We are composing changesets in a transaction. The new changeset is creating a cell in a gap
 		// where the old changeset knows of some now empty cell. We order the new cell relative to the old cell in a
 		// way that is consistent with its tie-breaking behavior should the old cell be concurrently re-filled.
 		// Since only tie-break left is supported at the moment, the new cell comes first.
@@ -315,8 +315,9 @@ export function getDetachedNodeId(mark: Detach | Rename): ChangeAtomId {
 		case "MoveOut": {
 			return makeChangeAtomId(mark.id, mark.revision);
 		}
-		default:
+		default: {
 			unreachableCase(mark);
+		}
 	}
 }
 
@@ -461,18 +462,22 @@ export function areInputCellsEmpty(mark: Mark): mark is EmptyInputCellMark {
 export function areOutputCellsEmpty(mark: Mark): boolean {
 	const type = mark.type;
 	switch (type) {
-		case NoopMarkType:
+		case NoopMarkType: {
 			return mark.cellId !== undefined;
+		}
 		case "Remove":
 		case "Rename":
 		case "MoveOut":
-		case "AttachAndDetach":
+		case "AttachAndDetach": {
 			return true;
+		}
 		case "MoveIn":
-		case "Insert":
+		case "Insert": {
 			return false;
-		default:
+		}
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
@@ -500,10 +505,12 @@ export function settleMark(mark: Mark): Mark {
 export function isImpactful(mark: Mark): boolean {
 	const type = mark.type;
 	switch (type) {
-		case NoopMarkType:
+		case NoopMarkType: {
 			return false;
-		case "Rename":
+		}
+		case "Rename": {
 			return true;
+		}
 		case "Remove": {
 			const inputId = getInputCellId(mark);
 			if (inputId === undefined) {
@@ -514,17 +521,21 @@ export function isImpactful(mark: Mark): boolean {
 			return !areEqualChangeAtomIds(inputId, outputId);
 		}
 		case "AttachAndDetach":
-		case "MoveOut":
+		case "MoveOut": {
 			return true;
-		case "MoveIn":
+		}
+		case "MoveIn": {
 			// MoveIn marks always target an empty cell.
 			assert(mark.cellId !== undefined, 0x825 /* MoveIn marks should target empty cells */);
 			return true;
-		case "Insert":
+		}
+		case "Insert": {
 			// A Revive has no impact if the nodes are already in the document.
 			return mark.cellId !== undefined;
-		default:
+		}
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
@@ -726,8 +737,9 @@ function tryMergeEffects(
 			}
 			break;
 		}
-		default:
+		default: {
 			unreachableCase(type);
+		}
 	}
 
 	return undefined;
@@ -768,8 +780,9 @@ export function splitMarkEffect<TEffect extends MarkEffect>(
 ): [TEffect, TEffect] {
 	const type = effect.type;
 	switch (type) {
-		case NoopMarkType:
+		case NoopMarkType: {
 			return [effect, effect];
+		}
 		case "Insert": {
 			const effect1: TEffect = {
 				...effect,
@@ -841,8 +854,9 @@ export function splitMarkEffect<TEffect extends MarkEffect>(
 
 			return [effect1, effect2];
 		}
-		default:
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
@@ -876,10 +890,10 @@ export function withNodeChange<TMark extends CellMark<TKind>, TKind extends Mark
 	changes: NodeId | undefined,
 ): TMark {
 	const newMark = { ...mark };
-	if (changes !== undefined) {
-		newMark.changes = changes;
-	} else {
+	if (changes === undefined) {
 		delete newMark.changes;
+	} else {
+		newMark.changes = changes;
 	}
 	return newMark;
 }
@@ -940,7 +954,7 @@ function getCrossFieldKeysForMarkEffect(
 	count: number,
 ): CrossFieldKeyRange[] {
 	switch (effect.type) {
-		case "Insert":
+		case "Insert": {
 			// An insert behaves like a move where the source and destination are at the same location.
 			// An insert can become a move when after rebasing.
 			return [
@@ -961,7 +975,8 @@ function getCrossFieldKeysForMarkEffect(
 					count,
 				},
 			];
-		case "MoveOut":
+		}
+		case "MoveOut": {
 			return [
 				{
 					key: {
@@ -972,7 +987,8 @@ function getCrossFieldKeysForMarkEffect(
 					count,
 				},
 			];
-		case "MoveIn":
+		}
+		case "MoveIn": {
 			return [
 				{
 					key: {
@@ -983,12 +999,15 @@ function getCrossFieldKeysForMarkEffect(
 					count,
 				},
 			];
-		case "AttachAndDetach":
+		}
+		case "AttachAndDetach": {
 			return [
 				...getCrossFieldKeysForMarkEffect(effect.attach, count),
 				...getCrossFieldKeysForMarkEffect(effect.detach, count),
 			];
-		default:
+		}
+		default: {
 			return [];
+		}
 	}
 }

package/src/feature-libraries/treeCursorUtils.ts

@@ -473,18 +473,18 @@ export function prefixFieldPath(
  * TODO: tests for this.
  */
 export function prefixPathPrefix(root: PathRootPrefix, inner: PathRootPrefix): PathRootPrefix {
-	if (inner.parent !== undefined) {
+	if (inner.parent === undefined) {
 		const composedPrefix: PathRootPrefix = {
-			parent: new PrefixedPath(root, inner.parent),
-			rootFieldOverride: inner.rootFieldOverride,
-			indexOffset: inner.indexOffset,
+			parent: root.parent,
+			rootFieldOverride: root.rootFieldOverride ?? inner.rootFieldOverride,
+			indexOffset: (inner.indexOffset ?? 0) + (root.indexOffset ?? 0),
 		};
 		return composedPrefix;
 	} else {
 		const composedPrefix: PathRootPrefix = {
-			parent: root.parent,
-			rootFieldOverride: root.rootFieldOverride ?? inner.rootFieldOverride,
-			indexOffset: (inner.indexOffset ?? 0) + (root.indexOffset ?? 0),
+			parent: new PrefixedPath(root, inner.parent),
+			rootFieldOverride: inner.rootFieldOverride,
+			indexOffset: inner.indexOffset,
 		};
 		return composedPrefix;
 	}