@fluidframework/tree 2.4.0-297027 → 2.4.0-297385

package/src/core/change-family/editBuilder.ts

@@ -3,12 +3,13 @@
  * Licensed under the MIT License.
  */
 
+import type { TaggedChange } from "../rebase/index.js";
 import type { ChangeFamily, ChangeFamilyEditor } from "./changeFamily.js";
 
 export abstract class EditBuilder<TChange> implements ChangeFamilyEditor {
 	public constructor(
 		protected readonly changeFamily: ChangeFamily<ChangeFamilyEditor, TChange>,
-		private readonly changeReceiver: (change: TChange) => void,
+		private readonly changeReceiver: (change: TaggedChange<TChange>) => void,
 	) {}
 
 	/**
@@ -16,7 +17,7 @@ export abstract class EditBuilder<TChange> implements ChangeFamilyEditor {
 	 *
 	 * @sealed
 	 */
-	protected applyChange(change: TChange): void {
+	protected applyChange(change: TaggedChange<TChange>): void {
 		this.changeReceiver(change);
 	}
 

package/src/core/rebase/changeRebaser.ts

@@ -51,6 +51,7 @@ export interface ChangeRebaser<TChangeset> {
 	 * @param changes - The changes to invert.
 	 * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
 	 * performing a sandwich rebase.
+	 * @param revision - The revision for the invert changeset.
 	 * This flag is relevant to merge semantics that are dependent on edit sequencing order:
 	 * - In the context of an undo, this function inverts a change that is sequenced and applied before the produced inverse.
 	 * - In the context of a rollback, this function inverts a change that is sequenced after but applied before the produced inverse.
@@ -59,7 +60,11 @@ export interface ChangeRebaser<TChangeset> {
 	 * `compose([changes, inverse(changes)])` be equal to `compose([])`:
 	 * See {@link ChangeRebaser} for details.
 	 */
-	invert(changes: TaggedChange<TChangeset>, isRollback: boolean): TChangeset;
+	invert(
+		changes: TaggedChange<TChangeset>,
+		isRollback: boolean,
+		revision: RevisionTag,
+	): TChangeset;
 
 	/**
 	 * Rebase `change` over `over`.

package/src/core/rebase/utils.ts

@@ -444,8 +444,8 @@ function rollbackFromCommit<TChange>(
 	if (commit.rollback !== undefined) {
 		return commit.rollback;
 	}
-	const untagged = changeRebaser.invert(commit, true);
 	const tag = mintRevisionTag();
+	const untagged = changeRebaser.invert(commit, true, tag);
 	const deeplyTaggedRollback = changeRebaser.changeRevision(untagged, tag, commit.revision);
 	const fullyTaggedRollback = tagRollbackInverse(deeplyTaggedRollback, tag, commit.revision);
 

package/src/feature-libraries/default-schema/defaultEditBuilder.ts

@@ -8,16 +8,17 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import type { ICodecFamily } from "../../codec/index.js";
 import {
+	type ChangeAtomId,
 	type ChangeEncodingContext,
 	type ChangeFamily,
 	type ChangeFamilyEditor,
 	type ChangeRebaser,
-	type ChangesetLocalId,
 	CursorLocationType,
 	type DeltaDetachedNodeId,
 	type DeltaRoot,
 	type FieldUpPath,
 	type ITreeCursorSynchronous,
+	type RevisionTag,
 	type TaggedChange,
 	type UpPath,
 	compareFieldUpPaths,
@@ -43,6 +44,7 @@ import {
 	required as valueFieldKind,
 } from "./defaultFieldKinds.js";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
+import type { CellId } from "../sequence-field/index.js";
 
 export type DefaultChangeset = ModularChangeset;
 
@@ -68,8 +70,11 @@ export class DefaultChangeFamily
 		return this.modularFamily.codecs;
 	}
 
-	public buildEditor(changeReceiver: (change: DefaultChangeset) => void): DefaultEditBuilder {
-		return new DefaultEditBuilder(this, changeReceiver);
+	public buildEditor(
+		mintRevisionTag: () => RevisionTag,
+		changeReceiver: (change: TaggedChange<DefaultChangeset>) => void,
+	): DefaultEditBuilder {
+		return new DefaultEditBuilder(this, mintRevisionTag, changeReceiver);
 	}
 }
 
@@ -168,7 +173,8 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 
 	public constructor(
 		family: ChangeFamily<ChangeFamilyEditor, DefaultChangeset>,
-		changeReceiver: (change: DefaultChangeset) => void,
+		private readonly mintRevisionTag: () => RevisionTag,
+		changeReceiver: (change: TaggedChange<DefaultChangeset>) => void,
 		private readonly idCompressor?: IIdCompressor,
 	) {
 		this.modularBuilder = new ModularEditBuilder(family, fieldKinds, changeReceiver);
@@ -182,19 +188,25 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 	}
 
 	public addNodeExistsConstraint(path: UpPath): void {
-		this.modularBuilder.addNodeExistsConstraint(path);
+		this.modularBuilder.addNodeExistsConstraint(path, this.mintRevisionTag());
 	}
 
 	public valueField(field: FieldUpPath): ValueFieldEditBuilder<ITreeCursorSynchronous> {
 		return {
 			set: (newContent: ITreeCursorSynchronous): void => {
-				const fillId = this.modularBuilder.generateId();
-
-				const build = this.modularBuilder.buildTrees(fillId, newContent, this.idCompressor);
+				const revision = this.mintRevisionTag();
+				const fill: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
+				const detach: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
+				const build = this.modularBuilder.buildTrees(
+					fill.localId,
+					newContent,
+					revision,
+					this.idCompressor,
+				);
 				const change: FieldChangeset = brand(
 					valueFieldKind.changeHandler.editor.set({
-						fill: fillId,
-						detach: this.modularBuilder.generateId(),
+						fill,
+						detach,
 					}),
 				);
 
@@ -203,8 +215,9 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 					field,
 					fieldKind: valueFieldKind.identifier,
 					change,
+					revision,
 				};
-				this.modularBuilder.submitChanges([build, edit]);
+				this.modularBuilder.submitChanges([build, edit], revision);
 			},
 		};
 	}
@@ -212,21 +225,26 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 	public optionalField(field: FieldUpPath): OptionalFieldEditBuilder<ITreeCursorSynchronous> {
 		return {
 			set: (newContent: ITreeCursorSynchronous | undefined, wasEmpty: boolean): void => {
-				const detachId = this.modularBuilder.generateId();
-				let fillId: ChangesetLocalId | undefined;
 				const edits: EditDescription[] = [];
 				let optionalChange: OptionalChangeset;
+				const revision = this.mintRevisionTag();
+				const detach: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
 				if (newContent !== undefined) {
-					fillId = this.modularBuilder.generateId();
-					const build = this.modularBuilder.buildTrees(fillId, newContent, this.idCompressor);
+					const fill: ChangeAtomId = { localId: this.modularBuilder.generateId(), revision };
+					const build = this.modularBuilder.buildTrees(
+						fill.localId,
+						newContent,
+						revision,
+						this.idCompressor,
+					);
 					edits.push(build);
 
 					optionalChange = optional.changeHandler.editor.set(wasEmpty, {
-						fill: fillId,
-						detach: detachId,
+						fill,
+						detach,
 					});
 				} else {
-					optionalChange = optional.changeHandler.editor.clear(wasEmpty, detachId);
+					optionalChange = optional.changeHandler.editor.clear(wasEmpty, detach);
 				}
 
 				const change: FieldChangeset = brand(optionalChange);
@@ -235,10 +253,11 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 					field,
 					fieldKind: optional.identifier,
 					change,
+					revision,
 				};
 				edits.push(edit);
 
-				this.modularBuilder.submitChanges(edits);
+				this.modularBuilder.submitChanges(edits, revision);
 			},
 		};
 	}
@@ -255,17 +274,24 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		} else if (count < 0 || !Number.isSafeInteger(count)) {
 			throw new UsageError(`Expected non-negative integer count, got ${count}.`);
 		}
-		const detachId = this.modularBuilder.generateId(count);
-		const attachId = this.modularBuilder.generateId(count);
+		const revision = this.mintRevisionTag();
+		const detachCellId = this.modularBuilder.generateId(count);
+		const attachCellId: CellId = { localId: this.modularBuilder.generateId(count), revision };
 		if (compareFieldUpPaths(sourceField, destinationField)) {
 			const change = sequence.changeHandler.editor.move(
 				sourceIndex,
 				count,
 				destIndex,
-				detachId,
-				attachId,
+				detachCellId,
+				attachCellId,
+				revision,
+			);
+			this.modularBuilder.submitChange(
+				sourceField,
+				sequence.identifier,
+				brand(change),
+				revision,
 			);
-			this.modularBuilder.submitChange(sourceField, sequence.identifier, brand(change));
 		} else {
 			const detachPath = topDownPath(sourceField.parent);
 			const attachPath = topDownPath(destinationField.parent);
@@ -307,27 +333,38 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 					}
 				}
 			}
-			const moveOut = sequence.changeHandler.editor.moveOut(sourceIndex, count, detachId);
+			const moveOut = sequence.changeHandler.editor.moveOut(
+				sourceIndex,
+				count,
+				detachCellId,
+				revision,
+			);
 			const moveIn = sequence.changeHandler.editor.moveIn(
 				destIndex,
 				count,
-				detachId,
-				attachId,
+				detachCellId,
+				attachCellId,
+				revision,
+			);
+			this.modularBuilder.submitChanges(
+				[
+					{
+						type: "field",
+						field: sourceField,
+						fieldKind: sequence.identifier,
+						change: brand(moveOut),
+						revision,
+					},
+					{
+						type: "field",
+						field: adjustedAttachField,
+						fieldKind: sequence.identifier,
+						change: brand(moveIn),
+						revision,
+					},
+				],
+				revision,
 			);
-			this.modularBuilder.submitChanges([
-				{
-					type: "field",
-					field: sourceField,
-					fieldKind: sequence.identifier,
-					change: brand(moveOut),
-				},
-				{
-					type: "field",
-					field: adjustedAttachField,
-					fieldKind: sequence.identifier,
-					change: brand(moveIn),
-				},
-			]);
 		}
 	}
 
@@ -340,30 +377,38 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 					return;
 				}
 
-				const firstId = this.modularBuilder.generateId(length);
-				const build = this.modularBuilder.buildTrees(firstId, content, this.idCompressor);
+				const revision = this.mintRevisionTag();
+				const firstId: CellId = { localId: this.modularBuilder.generateId(length), revision };
+				const build = this.modularBuilder.buildTrees(
+					firstId.localId,
+					content,
+					revision,
+					this.idCompressor,
+				);
 				const change: FieldChangeset = brand(
-					sequence.changeHandler.editor.insert(index, length, firstId),
+					sequence.changeHandler.editor.insert(index, length, firstId, revision),
 				);
 				const attach: FieldEditDescription = {
 					type: "field",
 					field,
 					fieldKind: sequence.identifier,
 					change,
+					revision,
 				};
 				// The changes have to be submitted together, otherwise they will be assigned different revisions,
 				// which will prevent the build ID and the insert ID from matching.
-				this.modularBuilder.submitChanges([build, attach]);
+				this.modularBuilder.submitChanges([build, attach], revision);
 			},
 			remove: (index: number, count: number): void => {
 				if (count === 0) {
 					return;
 				}
+				const revision = this.mintRevisionTag();
 				const id = this.modularBuilder.generateId(count);
 				const change: FieldChangeset = brand(
-					sequence.changeHandler.editor.remove(index, count, id),
+					sequence.changeHandler.editor.remove(index, count, id, revision),
 				);
-				this.modularBuilder.submitChange(field, sequence.identifier, change);
+				this.modularBuilder.submitChange(field, sequence.identifier, change, revision);
 			},
 		};
 	}

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -4,7 +4,7 @@
  */
 
 import {
-	type ChangesetLocalId,
+	type ChangeAtomId,
 	type DeltaDetachedNodeId,
 	type DeltaFieldChanges,
 	type FieldKindIdentifier,
@@ -54,11 +54,9 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 export interface ValueFieldEditor extends FieldEditor<OptionalChangeset> {
 	/**
 	 * Creates a change which replaces the current value of the field with `newValue`.
-	 * @param newContent - the new content for the field
-	 * @param changeId - the ID associated with the replacement of the current content.
-	 * @param buildId - the ID associated with the creation of the `newContent`.
+	 * @param ids - The ids for the fill and detach fields.
 	 */
-	set(ids: { fill: ChangesetLocalId; detach: ChangesetLocalId }): OptionalChangeset;
+	set(ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset;
 }
 
 const optionalIdentifier = "Optional";
@@ -77,8 +75,10 @@ export const optional = new FieldKindWithEditor(
 
 export const valueFieldEditor: ValueFieldEditor = {
 	...optionalFieldEditor,
-	set: (ids: { fill: ChangesetLocalId; detach: ChangesetLocalId }): OptionalChangeset =>
-		optionalFieldEditor.set(false, ids),
+	set: (ids: {
+		fill: ChangeAtomId;
+		detach: ChangeAtomId;
+	}): OptionalChangeset => optionalFieldEditor.set(false, ids),
 };
 
 export const valueChangeHandler: FieldChangeHandler<OptionalChangeset, ValueFieldEditor> = {

package/src/feature-libraries/mitigatedChangeFamily.ts

@@ -32,8 +32,11 @@ export function makeMitigatedChangeFamily<TEditor extends ChangeFamilyEditor, TC
 	onError: (error: unknown) => void,
 ): ChangeFamily<TEditor, TChange> {
 	return {
-		buildEditor: (changeReceiver: (change: TChange) => void): TEditor => {
-			return unmitigatedChangeFamily.buildEditor(changeReceiver);
+		buildEditor: (
+			mintRevisionTag: () => RevisionTag,
+			changeReceiver: (change: TaggedChange<TChange>) => void,
+		): TEditor => {
+			return unmitigatedChangeFamily.buildEditor(mintRevisionTag, changeReceiver);
 		},
 		rebaser: makeMitigatedRebaser(unmitigatedChangeFamily.rebaser, fallbackChange, onError),
 		codecs: unmitigatedChangeFamily.codecs,
@@ -58,8 +61,12 @@ export function makeMitigatedRebaser<TChange>(
 		compose: (changes: TaggedChange<TChange>[]): TChange => {
 			return withFallback(() => unmitigatedRebaser.compose(changes));
 		},
-		invert: (changes: TaggedChange<TChange>, isRollback: boolean): TChange => {
-			return withFallback(() => unmitigatedRebaser.invert(changes, isRollback));
+		invert: (
+			changes: TaggedChange<TChange>,
+			isRollback: boolean,
+			revision: RevisionTag,
+		): TChange => {
+			return withFallback(() => unmitigatedRebaser.invert(changes, isRollback, revision));
 		},
 		rebase: (
 			change: TaggedChange<TChange>,

package/src/feature-libraries/modular-schema/fieldChangeHandler.ts

@@ -117,6 +117,7 @@ export interface FieldChangeRebaser<TChangeset> {
 		change: TChangeset,
 		isRollback: boolean,
 		genId: IdAllocator,
+		revision: RevisionTag | undefined,
 		crossFieldManager: CrossFieldManager,
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;