@fluidframework/tree 2.74.0-370705 → 2.80.0

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

@@ -5,115 +5,132 @@
 
 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";
 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 type { Mutable } from "../../util/index.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 = { ...replaceEffectRevisions(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;
 }
 
-function replaceEffectRevisions<TMark extends MarkEffect>(
-	mark: TMark,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+function updateEffect<TMark extends MarkEffect>(
+	input: TMark,
+	replacer: RevisionReplacer,
 ): TMark {
+	const mark = isDetach(input) || isRename(input) ? updateIdOverride(input, replacer) : input;
 	const type = mark.type;
 	switch (type) {
-		case NoopMarkType:
-			return mark;
-		case "Insert":
-			return replaceRevision<TMark & HasRevisionTag>(mark, revisionsToReplace, newRevision);
-
-		case "Remove":
-			return replaceDetachRevisions<TMark & Detach>(
-				mark as Detach & TMark,
-				revisionsToReplace,
-				newRevision,
-			);
 		case "Rename":
+		case NoopMarkType: {
+			return mark;
+		}
+		case "AttachAndDetach": {
 			return {
 				...mark,
-				idOverride: replaceAtomRevisions(mark.idOverride, revisionsToReplace, newRevision),
+				attach: updateEffect(mark.attach, replacer),
+				detach: updateEffect(mark.detach, replacer),
 			};
-		default:
+		}
+		case "MoveIn":
+		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,
+				replacer,
+			);
+		}
+		case "Insert":
+		case "Remove": {
+			return updateRevisionAndId(mark as (TMark & Insert) | (TMark & Remove), replacer);
+		}
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
-function replaceDetachRevisions<TDetach extends Detach>(
-	detach: TDetach,
-	revisionsToReplace: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
-): TDetach {
-	const updated = replaceRevision(detach, revisionsToReplace, newRevision) as Mutable<TDetach>;
-	if (updated.cellRename !== undefined) {
-		updated.cellRename = replaceAtomRevisions(
-			updated.cellRename,
-			revisionsToReplace,
-			newRevision,
-		);
+function updateIdOverride<TEffect extends Detach | Rename>(
+	effect: TEffect,
+	replacer: RevisionReplacer,
+): TEffect {
+	if (effect.idOverride === undefined) {
+		return effect;
 	}
+	const idOverride = replacer.getUpdatedAtomId(effect.idOverride);
+	return { ...effect, idOverride };
+}
 
-	if (updated.detachCellId !== undefined) {
-		updated.detachCellId = replaceAtomRevisions(
-			updated.detachCellId,
-			revisionsToReplace,
-			newRevision,
-		);
-	}
-	return updated;
+function updateMoveEffect<TEffect extends HasMoveFields>(
+	effect: TEffect,
+	replacer: RevisionReplacer,
+): TEffect {
+	return effect.finalEndpoint === undefined
+		? updateRevisionAndId(effect, replacer)
+		: updateRevisionAndId(
+				{
+					...effect,
+					finalEndpoint: replacer.getUpdatedAtomId(effect.finalEndpoint),
+				},
+				replacer,
+			);
 }
 
-function replaceRevision<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/sequenceFieldChangeHandler.ts

@@ -5,6 +5,7 @@
 
 import type { FieldChangeHandler } from "../modular-schema/index.js";
 
+import { relevantRemovedRoots } from "./relevantRemovedRoots.js";
 import { sequenceFieldChangeRebaser } from "./sequenceFieldChangeRebaser.js";
 import { sequenceFieldChangeCodecFactory } from "./sequenceFieldCodecs.js";
 import { type SequenceFieldEditor, sequenceFieldEditor } from "./sequenceFieldEditor.js";
@@ -19,6 +20,7 @@ export const sequenceFieldChangeHandler: SequenceFieldChangeHandler = {
 	codecsFactory: sequenceFieldChangeCodecFactory,
 	editor: sequenceFieldEditor,
 	intoDelta: sequenceFieldToDelta,
+	relevantRemovedRoots,
 	isEmpty,
 	getNestedChanges,
 	createEmpty,