@fluidframework/tree 2.83.0 → 2.90.0-378676

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

@@ -7,6 +7,7 @@ import type { TAnySchema } from "@sinclair/typebox";
 
 import { DiscriminatedUnionDispatcher, type IJsonCodec } from "../../codec/index.js";
 import type {
+	ChangeAtomId,
 	ChangeEncodingContext,
 	EncodedRevisionTag,
 	RevisionTag,
@@ -18,9 +19,14 @@ import {
 } from "../modular-schema/index.js";
 
 import { Changeset as ChangesetSchema, type Encoded } from "./formatV3.js";
-import { makeV2CodecHelpers } from "./sequenceFieldCodecV2.js";
+import {
+	decodeSequenceChangeset,
+	encodeRevisionWithContext,
+	encodeSequenceChangeset,
+	makeV2CodecHelpers,
+	tryGetEncodedCellRename,
+} from "./sequenceFieldCodecV2.js";
 import type { Changeset, Mark, MarkEffect, Rename } from "./types.js";
-import { isNoopMark } from "./utils.js";
 
 export function makeV3Codec(
 	revisionTagCodec: IJsonCodec<
@@ -37,46 +43,55 @@ export function makeV3Codec(
 > {
 	const {
 		changeAtomIdCodec: atomIdCodec,
-		markEffectCodec: markEffectV2Codec,
+		encodeMarkEffect: encodeV2MarkEffect,
 		decoderLibrary: decoderLibraryV2,
 	} = makeV2CodecHelpers(revisionTagCodec);
 
-	const markEffectCodec: IJsonCodec<
-		MarkEffect,
-		Encoded.MarkEffect,
-		Encoded.MarkEffect,
-		ChangeEncodingContext
-	> = {
-		encode(effect: MarkEffect, context: ChangeEncodingContext): Encoded.MarkEffect {
-			const type = effect.type;
-			switch (type) {
-				case "Rename": {
-					return {
-						rename: {
-							idOverride: atomIdCodec.encode(effect.idOverride, context),
-						},
-					};
-				}
-				default: {
-					return markEffectV2Codec.encode(effect, context);
-				}
-			}
-		},
-		decode(encoded: Encoded.MarkEffect, context: ChangeEncodingContext): MarkEffect {
-			return decoderLibrary.dispatch(encoded, context);
-		},
-	};
+	function encodeMarkEffect(
+		mark: Mark,
+		context: FieldChangeEncodingContext,
+	): Encoded.MarkEffect {
+		const encoded = encodeV2MarkEffect(mark, context);
+		const encodedRenameId = tryGetEncodedCellRename(encoded);
+		if (encodedRenameId !== undefined) {
+			return {
+				rename: {
+					idOverride: encodedRenameId,
+				},
+			};
+		}
+
+		return encoded;
+	}
+
+	function decodeMarkEffect(
+		encoded: Encoded.MarkEffect,
+		count: number,
+		cellId: ChangeAtomId | undefined,
+		context: FieldChangeEncodingContext,
+	): MarkEffect {
+		return decoderLibrary.dispatch(encoded, count, cellId, context);
+	}
 
 	const decoderLibrary = new DiscriminatedUnionDispatcher<
 		Encoded.MarkEffect,
-		/* args */ [context: ChangeEncodingContext],
+		/* args */ [
+			count: number,
+			cellId: ChangeAtomId | undefined,
+			context: FieldChangeEncodingContext,
+		],
 		MarkEffect
 	>({
 		...decoderLibraryV2,
-		rename(encoded: Encoded.Rename, context: ChangeEncodingContext): Rename {
+		rename(
+			encoded: Encoded.Rename,
+			count: number,
+			cellId: ChangeAtomId | undefined,
+			context: FieldChangeEncodingContext,
+		): Rename {
 			return {
 				type: "Rename",
-				idOverride: atomIdCodec.decode(encoded.idOverride, context),
+				idOverride: atomIdCodec.decode(encoded.idOverride, context.baseContext),
 			};
 		},
 	});
@@ -91,48 +106,19 @@ export function makeV3Codec(
 		encode: (
 			changeset: Changeset,
 			context: FieldChangeEncodingContext,
-		): JsonCompatibleReadOnly & Encoded.Changeset<NodeChangeSchema> => {
-			const jsonMarks: Encoded.Changeset<NodeChangeSchema> = [];
-			for (const mark of changeset) {
-				const encodedMark: Encoded.Mark<NodeChangeSchema> = {
-					count: mark.count,
-				};
-				if (!isNoopMark(mark)) {
-					encodedMark.effect = markEffectCodec.encode(mark, context.baseContext);
-				}
-				if (mark.cellId !== undefined) {
-					encodedMark.cellId = atomIdCodec.encode(mark.cellId, context.baseContext);
-				}
-				if (mark.changes !== undefined) {
-					encodedMark.changes = context.encodeNode(mark.changes);
-				}
-				jsonMarks.push(encodedMark);
-			}
-			return jsonMarks;
-		},
+		): JsonCompatibleReadOnly & Encoded.Changeset<NodeChangeSchema> =>
+			encodeSequenceChangeset(
+				changeset,
+				context,
+				(revision) =>
+					encodeRevisionWithContext(revision, context.baseContext, revisionTagCodec),
+				atomIdCodec,
+				encodeMarkEffect,
+			),
 		decode: (
 			changeset: Encoded.Changeset<NodeChangeSchema>,
 			context: FieldChangeEncodingContext,
-		): Changeset => {
-			const marks: Changeset = [];
-			for (const mark of changeset) {
-				const decodedMark: Mark = {
-					count: mark.count,
-				};
-
-				if (mark.effect !== undefined) {
-					Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context.baseContext));
-				}
-				if (mark.cellId !== undefined) {
-					decodedMark.cellId = atomIdCodec.decode(mark.cellId, context.baseContext);
-				}
-				if (mark.changes !== undefined) {
-					decodedMark.changes = context.decodeNode(mark.changes);
-				}
-				marks.push(decodedMark);
-			}
-			return marks;
-		},
+		): Changeset => decodeSequenceChangeset(changeset, context, atomIdCodec, decodeMarkEffect),
 		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
 	};
 }

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

@@ -9,20 +9,17 @@ import type { ChangesetLocalId, RevisionTag } from "../../core/index.js";
 import type { FieldEditor, NodeId } from "../modular-schema/index.js";
 
 import { MarkListFactory } from "./markListFactory.js";
-import type {
-	CellId,
-	CellMark,
-	Changeset,
-	Insert,
-	Mark,
-	MarkList,
-	MoveIn,
-	MoveOut,
-} from "./types.js";
+import type { Attach, CellId, CellMark, Changeset, Detach, Mark, MarkList } from "./types.js";
 import { splitMark } from "./utils.js";
 
 export interface SequenceFieldEditor extends FieldEditor<Changeset> {
-	insert(index: number, count: number, firstId: CellId, revision: RevisionTag): Changeset;
+	insert(
+		index: number,
+		count: number,
+		cellId: CellId,
+		revision: RevisionTag,
+		moveId: ChangesetLocalId,
+	): Changeset;
 	remove(index: number, count: number, id: ChangesetLocalId, revision: RevisionTag): Changeset;
 	revive(
 		index: number,
@@ -91,14 +88,15 @@ export const sequenceFieldEditor = {
 	insert: (
 		index: number,
 		count: number,
-		firstId: CellId,
+		cellId: CellId,
 		revision: RevisionTag | undefined,
+		moveId: ChangesetLocalId,
 	): Changeset => {
-		const mark: CellMark<Insert> = {
-			type: "Insert",
-			id: firstId.localId,
+		const mark: CellMark<Attach> = {
+			type: "Attach",
+			id: moveId,
 			count,
-			cellId: firstId,
+			cellId,
 			revision,
 		};
 		return markAtIndex(index, mark);
@@ -109,7 +107,7 @@ export const sequenceFieldEditor = {
 		id: ChangesetLocalId,
 		revision: RevisionTag | undefined,
 	): Changeset =>
-		count === 0 ? [] : markAtIndex(index, { type: "Remove", count, id, revision }),
+		count === 0 ? [] : markAtIndex(index, { type: "Detach", count, id, revision }),
 
 	revive: (
 		index: number,
@@ -118,8 +116,8 @@ export const sequenceFieldEditor = {
 		revision: RevisionTag | undefined,
 	): Changeset => {
 		assert(detachEvent.revision !== undefined, 0x724 /* Detach event must have a revision */);
-		const mark: CellMark<Insert> = {
-			type: "Insert",
+		const mark: CellMark<Attach> = {
+			type: "Attach",
 			id: detachEvent.localId,
 			count,
 			cellId: detachEvent,
@@ -137,14 +135,14 @@ export const sequenceFieldEditor = {
 		revision: RevisionTag | undefined,
 	): Changeset {
 		const moveIn: Mark = {
-			type: "MoveIn",
+			type: "Attach",
 			id: detachCellId,
 			count,
 			cellId: attachCellId,
 			revision,
 		};
 		const moveOut: Mark = {
-			type: "MoveOut",
+			type: "Detach",
 			id: detachCellId,
 			count,
 			revision,
@@ -159,7 +157,7 @@ export const sequenceFieldEditor = {
 		revision: RevisionTag,
 	): Changeset {
 		const moveOut: Mark = {
-			type: "MoveOut",
+			type: "Detach",
 			id: detachCellId,
 			count,
 			revision,
@@ -175,7 +173,7 @@ export const sequenceFieldEditor = {
 		revision: RevisionTag,
 	): Changeset {
 		const moveIn: Mark = {
-			type: "MoveIn",
+			type: "Attach",
 			id: moveId,
 			count,
 			cellId: attachCellId,
@@ -192,16 +190,16 @@ export const sequenceFieldEditor = {
 		attachCellId: CellId,
 		revision: RevisionTag | undefined,
 	): Changeset {
-		const moveOut: CellMark<MoveOut> = {
-			type: "MoveOut",
+		const moveOut: CellMark<Detach> = {
+			type: "Detach",
 			id: attachCellId.localId,
-			idOverride: detachCellId,
+			cellRename: detachCellId,
 			count,
 			revision,
 		};
 
-		const returnTo: CellMark<MoveIn> = {
-			type: "MoveIn",
+		const returnTo: CellMark<Attach> = {
+			type: "Attach",
 			id: attachCellId.localId,
 			count,
 			cellId: attachCellId,
@@ -216,8 +214,8 @@ function moveMarksToMarkList(
 	sourceIndex: number,
 	count: number,
 	destIndex: number,
-	detach: CellMark<MoveOut>,
-	attach: CellMark<MoveIn>,
+	detach: CellMark<Detach>,
+	attach: CellMark<Attach>,
 ): MarkList {
 	if (count === 0) {
 		return [];

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

@@ -5,162 +5,61 @@
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 
-import {
-	type DeltaDetachedNodeChanges,
-	type DeltaDetachedNodeRename,
-	type DeltaMark,
-	areEqualChangeAtomIds,
-} from "../../core/index.js";
+import type { DeltaFieldChanges, DeltaMark } from "../../core/index.js";
 import { getLast, hasSome, type Mutable } from "../../util/index.js";
 import { nodeIdFromChangeAtom } from "../deltaUtils.js";
-import type { FieldChangeDelta, ToDelta } from "../modular-schema/index.js";
+import type { ToDelta } from "../modular-schema/index.js";
 
-import { isMoveIn, isMoveOut } from "./moveEffectTable.js";
 import { type MarkList, NoopMarkType } from "./types.js";
 import {
 	areInputCellsEmpty,
 	areOutputCellsEmpty,
-	getDetachedNodeId,
-	getEndpoint,
+	getAttachedRootId,
+	getDetachedRootId,
 	getInputCellId,
-	isAttachAndDetachEffect,
 } from "./utils.js";
 
 export function sequenceFieldToDelta(
 	change: MarkList,
 	deltaFromChild: ToDelta,
-): FieldChangeDelta {
-	const local: DeltaMark[] = [];
-	const global: DeltaDetachedNodeChanges[] = [];
-	const rename: DeltaDetachedNodeRename[] = [];
+): DeltaFieldChanges {
+	const deltaMarks: DeltaMark[] = [];
 
 	for (const mark of change) {
 		const deltaMark: Mutable<DeltaMark> = { count: mark.count };
 		const inputCellId = getInputCellId(mark);
 		const changes = mark.changes;
-		if (changes !== undefined) {
+		if (changes !== undefined && inputCellId === undefined) {
 			const nestedDelta = deltaFromChild(changes);
 			if (nestedDelta.size > 0) {
-				if (inputCellId === undefined) {
-					deltaMark.fields = nestedDelta;
-				} else {
-					global.push({
-						id: nodeIdFromChangeAtom(inputCellId),
-						fields: nestedDelta,
-					});
-				}
+				deltaMark.fields = nestedDelta;
 			}
 		}
 		if (!areInputCellsEmpty(mark) && !areOutputCellsEmpty(mark)) {
 			// Since each cell is associated with exactly one node,
 			// the cell starting end ending populated means the cell content has not changed.
-			local.push(deltaMark);
-		} else if (isAttachAndDetachEffect(mark)) {
-			assert(
-				inputCellId !== undefined,
-				0x81e /* AttachAndDetach mark should have defined input cell ID */,
-			);
-			// The cell starting and ending empty means the cell content has not changed,
-			// unless transient content was inserted/attached.
-			if (isMoveIn(mark.attach) && isMoveOut(mark.detach)) {
-				assert(
-					mark.changes === undefined,
-					0x81f /* AttachAndDetach moves should not have changes */,
-				);
-				continue;
-			}
-
-			const outputId = getDetachedNodeId(mark.detach);
-			assert(
-				outputId !== undefined,
-				0x820 /* AttachAndDetach mark should have defined output cell ID */,
-			);
-			const oldId = nodeIdFromChangeAtom(
-				isMoveIn(mark.attach) ? getEndpoint(mark.attach) : inputCellId,
-			);
-			if (!areEqualChangeAtomIds(inputCellId, outputId)) {
-				rename.push({
-					count: mark.count,
-					oldId,
-					newId: nodeIdFromChangeAtom(outputId),
-				});
-			}
-			if (deltaMark.fields) {
-				global.push({
-					id: oldId,
-					fields: deltaMark.fields,
-				});
-			}
+			deltaMarks.push(deltaMark);
 		} else {
 			const type = mark.type;
 			// Inline into `switch(mark.type)` once we upgrade to TS 4.7
 			switch (type) {
-				case "MoveIn": {
-					local.push({
-						attach: nodeIdFromChangeAtom(getEndpoint(mark)),
-						count: mark.count,
-					});
-					break;
-				}
-				case "Remove": {
-					const newDetachId = getDetachedNodeId(mark);
+				case "Detach": {
+					const newDetachId = getDetachedRootId(mark);
 					if (inputCellId === undefined) {
 						deltaMark.detach = nodeIdFromChangeAtom(newDetachId);
-						local.push(deltaMark);
-					} else {
-						const oldId = nodeIdFromChangeAtom(inputCellId);
-						// Removal of already removed content is only a no-op if the detach IDs are different.
-						if (!areEqualChangeAtomIds(inputCellId, newDetachId)) {
-							rename.push({
-								count: mark.count,
-								oldId,
-								newId: nodeIdFromChangeAtom(newDetachId),
-							});
-						}
-						// In all cases, the nested changes apply
-						if (deltaMark.fields) {
-							global.push({
-								id: oldId,
-								fields: deltaMark.fields,
-							});
-						}
+						deltaMarks.push(deltaMark);
 					}
 					break;
 				}
-				case "MoveOut": {
-					// The move destination will look for the detach ID of the source, so we can ignore `finalEndpoint`.
-					const detachId = nodeIdFromChangeAtom(getDetachedNodeId(mark));
-					if (inputCellId === undefined) {
-						deltaMark.detach = detachId;
-						local.push(deltaMark);
-					} else {
-						// Move sources implicitly restore their content
-						rename.push({
-							count: mark.count,
-							oldId: nodeIdFromChangeAtom(inputCellId),
-							newId: detachId,
-						});
-					}
-					break;
-				}
-				case "Insert": {
-					assert(
-						inputCellId !== undefined,
-						0x821 /* Active Insert marks must have a CellId */,
-					);
-					const buildId = nodeIdFromChangeAtom(inputCellId);
+				case "Attach": {
+					const buildId = nodeIdFromChangeAtom(getAttachedRootId(mark));
 					deltaMark.attach = buildId;
-					if (deltaMark.fields) {
-						// Nested changes are represented on the node in its starting location
-						global.push({ id: buildId, fields: deltaMark.fields });
-						delete deltaMark.fields;
-					}
-					local.push(deltaMark);
+					deltaMarks.push(deltaMark);
 					break;
 				}
 				case NoopMarkType: {
 					if (inputCellId === undefined) {
-						local.push(deltaMark);
+						deltaMarks.push(deltaMark);
 					}
 					break;
 				}
@@ -178,8 +77,8 @@ export function sequenceFieldToDelta(
 		}
 	}
 	// Remove trailing no-op marks
-	while (hasSome(local)) {
-		const lastMark = getLast(local);
+	while (hasSome(deltaMarks)) {
+		const lastMark = getLast(deltaMarks);
 		if (
 			lastMark.attach !== undefined ||
 			lastMark.detach !== undefined ||
@@ -187,17 +86,8 @@ export function sequenceFieldToDelta(
 		) {
 			break;
 		}
-		local.pop();
+		deltaMarks.pop();
 	}
-	const delta: Mutable<FieldChangeDelta> = {};
-	if (local.length > 0) {
-		delta.local = { marks: local };
-	}
-	if (global.length > 0) {
-		delta.global = global;
-	}
-	if (rename.length > 0) {
-		delta.rename = rename;
-	}
-	return delta;
+
+	return { marks: deltaMarks, allowReattach: true };
 }

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

@@ -54,59 +54,26 @@ export interface NoopMark {
 export interface HasRevisionTag {
 	/**
 	 * The revision this mark is part of.
-	 * Only set for marks in fields which are a composition of multiple revisions.
 	 */
 	revision?: RevisionTag;
 }
 
 /**
  * Moves detached roots into cells.
- * The specific content being moved in is determined by the IDs of the cells this mark targets.
- * Always brings about the desired outcome: the content is in the targeted cells.
  *
- * Rebasing this mark never causes it to insert/restore a different set of nodes.
- * Rebasing this mark never causes it to fill a different set of cells
+ * Rebasing this mark never causes it to attach a different set of nodes.
+ * Rebasing this mark never causes it to attach nodes in different cells
  * (though the way those cells are identified may change).
- *
- * Carries a `MoveId` in case it is rebased over the content being moved out, in which case this mark
- * will transform into a pair of returns which will move the content back into this cell.
  */
-export interface Insert extends HasMoveId, HasRevisionTag {
-	type: "Insert";
-}
+export interface Attach extends HasMoveId, HasRevisionTag {
+	readonly type: "Attach";
 
-export interface HasMoveFields extends HasMoveId, HasRevisionTag {
+	// XXX: Use this ID as main ID when serializing
 	/**
-	 * Used when this mark represents the beginning or end of a chain of moves within a changeset.
-	 * If this mark is the start of the chain, this is the ID of the end mark of the chain, and vice-versa if this is the end of the chain.
+	 * See {@link Detach.detachCellId}.
+	 * This field should only be used if the attach is a pin.
 	 */
-	finalEndpoint?: ChangeAtomId;
-}
-
-/**
- * Fills empty cells with content that is moved out from another cell.
- * Always brings about the desired outcome: the nodes being moved are in the target cells.
- * Note that this may not require any changes if these nodes are already in the target cells when this mark is applied.
- *
- * Rebasing this mark never causes it to move-in a different set of nodes.
- * Rebasing this mark never causes it to fill a different set of cells
- * (though the way those cells are identified may change).
- *
- * Only ever targets empty cells. It transforms into a idempotent Insert if the target cells are not empty.
- */
-export interface MoveIn extends HasMoveFields {
-	type: "MoveIn";
-}
-
-export interface DetachFields {
-	/**
-	 * When set, the detach should use the `CellId` specified in this object to characterize the cell being emptied.
-	 *
-	 * This is used in two situations:
-	 * - to restore the prior ID of a cell in a rollback changeset
-	 * - to represent the impact of a detach composed with a rename
-	 */
-	readonly idOverride?: CellId;
+	readonly detachCellId?: ChangeAtomId;
 }
 
 /**
@@ -117,43 +84,33 @@ export interface DetachFields {
  * Rebasing this mark never causes it to target different set of nodes.
  * Rebasing this mark can cause it to clear a different set of cells.
  */
-export interface Remove extends HasRevisionTag, DetachFields {
-	type: "Remove";
-	id: ChangesetLocalId;
-}
-
-/**
- * Removes nodes from their cells so they can be moved into other cells.
- * Always brings about the desired outcome: the targeted nodes are removed from their cells.
- * Note that this may not require any changes if targeted nodes are already removed when this mark is applied.
- *
- * Rebasing this mark never causes it to target different set of nodes.
- * Rebasing this mark can cause it to clear a different set of cells.
- */
-export interface MoveOut extends HasMoveFields, DetachFields {
-	type: "MoveOut";
-}
-
-export type Attach = Insert | MoveIn;
+export interface Detach extends HasRevisionTag {
+	readonly type: "Detach";
+	readonly id: ChangesetLocalId;
 
-export type Detach = Remove | MoveOut;
+	/**
+	 * The ID the cell should be set to when this detach is applied.
+	 * If not set, this the same as the detach ID.
+	 * Note that this does not affect the ID associated with the detached node.
+	 * This is ignored when `cellRename` is set.
+	 *
+	 * This applies to the cell where the node is being detached from,
+	 * or the last cell the node occupied if it is already detached.
+	 *
+	 * This field is used to represent the composition of a pin and a detach.
+	 * The composition will be the second detach but with the pin's detachId as detachCellId.
+	 */
+	readonly detachCellId?: ChangeAtomId;
 
-/**
- * Fills then empties cells.
- *
- * Only ever targets empty cells.
- *
- * As a matter of normalization, we only use an AttachAndDetach to represent MoveIn ○ Remove.
- *
- * We do NOT use AttachAndDetach to represent the following compositions:
- * - Insert/Revive ○ Remove (represented by a Remove)
- * - Insert/Revive ○ MoveOut (represented by a MoveOut)
- * - MoveIn ○ MoveOut (represented by a Rename)
- */
-export interface AttachAndDetach {
-	type: "AttachAndDetach";
-	attach: Attach;
-	detach: Detach;
+	/**
+	 * When set, this represents a rename of this cell to be applied after the detach.
+	 * Note that this does not affect the ID associated with the detached node.
+	 *
+	 * This is used in two situations:
+	 * - to restore the prior ID of a cell in a rollback changeset
+	 * - to represent the impact of a detach composed with a rename
+	 */
+	readonly cellRename?: CellId;
 }
 
 /**
@@ -161,15 +118,19 @@ export interface AttachAndDetach {
  *
  * Only ever targets empty cells.
  *
- * Occurs when a MoveIn is composed with a MoveOut.
+ * Occurs when an Attach is composed with a Detach.
  * TODO: Use Rename when an Insert/Revive is composed with a Remove.
  */
 export interface Rename {
-	type: "Rename";
+	readonly type: "Rename";
 	readonly idOverride: CellId;
 }
 
-export type MarkEffect = NoopMark | Attach | Detach | AttachAndDetach | Rename;
+export interface Pin extends CellMark<Attach> {
+	cellId: undefined;
+}
+
+export type MarkEffect = NoopMark | Attach | Detach | Rename;
 
 export type CellMark<TMark> = TMark & HasMarkFields;