@fluidframework/tree 2.74.0-368706 → 2.74.0-370705

package/src/feature-libraries/optional-field/optionalFieldChangeFormatV3.ts

@@ -0,0 +1,45 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, type TSchema, Type } from "@sinclair/typebox";
+
+import { EncodedChangeAtomId } from "../modular-schema/index.js";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+// Type is intentionally derived.
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const EncodedOptionalChangeset = <Schema extends TSchema>(tNodeChange: Schema) =>
+	Type.Object(
+		{
+			// Nested changes
+			c: Type.Optional(tNodeChange),
+
+			// How to replace the current value of the field.
+			r: Type.Optional(EncodedReplace),
+
+			// Node detach
+			d: Type.Optional(EncodedChangeAtomId),
+		},
+		noAdditionalProps,
+	);
+
+export type EncodedOptionalChangeset<Schema extends TSchema> = Static<
+	ReturnType<typeof EncodedOptionalChangeset<Schema>>
+>;
+
+const EncodedReplace = Type.Object(
+	{
+		// Whether the field is empty in the input context of this change.
+		e: Type.Boolean(),
+		// The ID for the node to put in this field, or undefined if the field should be emptied.
+		// Will be "self" when the intention is to keep the current node in this field.
+		s: Type.Optional(EncodedChangeAtomId),
+		// An ID to associate with the node (if any) which is detached by this edit.
+		d: EncodedChangeAtomId,
+	},
+	noAdditionalProps,
+);
+export type EncodedReplace = Static<typeof EncodedReplace>;

package/src/feature-libraries/optional-field/optionalFieldCodecV3.ts

@@ -0,0 +1,94 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { TAnySchema } from "@sinclair/typebox";
+
+import type { IJsonCodec } from "../../codec/index.js";
+import type {
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
+} from "../../core/index.js";
+import type { Mutable } from "../../util/index.js";
+import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
+import {
+	EncodedNodeChangeset,
+	type FieldChangeEncodingContext,
+} from "../modular-schema/index.js";
+
+import { EncodedOptionalChangeset } from "./optionalFieldChangeFormatV3.js";
+import type { OptionalChangeset, Replace } from "./optionalFieldChangeTypes.js";
+
+export function makeOptionalFieldCodec(
+	revisionTagCodec: IJsonCodec<
+		RevisionTag,
+		EncodedRevisionTag,
+		EncodedRevisionTag,
+		ChangeEncodingContext
+	>,
+): IJsonCodec<
+	OptionalChangeset,
+	EncodedOptionalChangeset<TAnySchema>,
+	EncodedOptionalChangeset<TAnySchema>,
+	FieldChangeEncodingContext
+> {
+	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
+
+	return {
+		encode: (change: OptionalChangeset, context: FieldChangeEncodingContext) => {
+			const encoded: EncodedOptionalChangeset<TAnySchema> = {};
+
+			if (change.valueReplace !== undefined) {
+				encoded.r = {
+					e: change.valueReplace.isEmpty,
+					d: changeAtomIdCodec.encode(change.valueReplace.dst, context.baseContext),
+				};
+
+				if (change.valueReplace.src !== undefined) {
+					encoded.r.s = changeAtomIdCodec.encode(change.valueReplace.src, context.baseContext);
+				}
+			}
+
+			if (change.nodeDetach !== undefined) {
+				encoded.d = changeAtomIdCodec.encode(change.nodeDetach, context.baseContext);
+			}
+
+			if (change.childChange !== undefined) {
+				encoded.c = context.encodeNode(change.childChange);
+			}
+
+			return encoded;
+		},
+
+		decode: (
+			encoded: EncodedOptionalChangeset<TAnySchema>,
+			context: FieldChangeEncodingContext,
+		) => {
+			const decoded: Mutable<OptionalChangeset> = {};
+
+			if (encoded.r !== undefined) {
+				const replace: Mutable<Replace> = {
+					isEmpty: encoded.r.e,
+					dst: changeAtomIdCodec.decode(encoded.r.d, context.baseContext),
+				};
+				if (encoded.r.s !== undefined) {
+					replace.src = changeAtomIdCodec.decode(encoded.r.s, context.baseContext);
+				}
+				decoded.valueReplace = replace;
+			}
+
+			if (encoded.d !== undefined) {
+				decoded.nodeDetach = changeAtomIdCodec.decode(encoded.d, context.baseContext);
+			}
+
+			if (encoded.c !== undefined) {
+				decoded.childChange = context.decodeNode(encoded.c);
+			}
+
+			return decoded;
+		},
+		encodedSchema: EncodedOptionalChangeset(EncodedNodeChangeset),
+	};
+}

package/src/feature-libraries/optional-field/optionalFieldCodecs.ts

@@ -13,6 +13,7 @@ import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
 import type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
 import { makeOptionalFieldCodec as makeV2Codec } from "./optionalFieldCodecV2.js";
+import { makeOptionalFieldCodec as makeV3Codec } from "./optionalFieldCodecV3.js";
 
 export const makeOptionalFieldCodecFamily = (
 	revisionTagCodec: IJsonCodec<
@@ -22,4 +23,7 @@ export const makeOptionalFieldCodecFamily = (
 		ChangeEncodingContext
 	>,
 ): ICodecFamily<OptionalChangeset, FieldChangeEncodingContext> =>
-	makeCodecFamily([[2, makeV2Codec(revisionTagCodec)]]);
+	makeCodecFamily([
+		[2, makeV2Codec(revisionTagCodec)],
+		[3, makeV3Codec(revisionTagCodec)],
+	]);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.74.0-368706";
+export const pkgVersion = "2.74.0-370705";

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -20,6 +20,7 @@ import {
 	type TreeChunk,
 	chunkTree,
 	defaultChunkPolicy,
+	getBuildsIds,
 	intoDelta,
 	relevantRemovedRoots,
 	updateRefreshers as updateDataChangeRefreshers,
@@ -62,6 +63,7 @@ export class SharedTreeReadonlyChangeEnricher
 	public updateChangeEnrichments(change: SharedTreeChange): SharedTreeChange {
 		return updateRefreshers(
 			change,
+			getBuildsIds,
 			this.getDetachedRoot,
 			relevantRemovedRoots,
 			updateDataChangeRefreshers,

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -262,6 +262,7 @@ function mapDataChanges(
  */
 export function updateRefreshers(
 	change: SharedTreeChange,
+	buildsFromDataChange: (taggedChange: ModularChangeset) => Iterable<DeltaDetachedNodeId>,
 	getDetachedNode: (id: DeltaDetachedNodeId) => TreeChunk | undefined,
 	relevantRemovedRootsFromDataChange: (
 		taggedChange: ModularChangeset,
@@ -308,13 +309,19 @@ export function updateRefreshers(
 	}
 	let isFirstDataChange = true;
 	return mapDataChanges(change, (dataChange) => {
+		const builtRoots = buildsFromDataChange(dataChange);
+		for (const id of builtRoots) {
+			// Detached root IDs that are used for builds are only ever used by a single node,
+			// so there is no risk of excluding needed refreshers by adding them to the list of already included roots.
+			addToNestedSet(includedRoots, id.major, id.minor);
+		}
 		const removedRoots = relevantRemovedRootsFromDataChange(dataChange);
 		if (isFirstDataChange) {
 			isFirstDataChange = false;
 			return updateDataChangeRefreshers(
 				dataChange,
 				getAndRememberDetachedNode,
-				removedRoots,
+				filterIncludedRoots(removedRoots),
 				true,
 			);
 		} else {

package/src/shared-tree/sharedTreeEditBuilder.ts

@@ -86,7 +86,7 @@ export class IdBasedSharedTreeEditBuilder
 
 		this.schema = {
 			setStoredSchema: (oldSchema, newSchema) => {
-				this.changeReceiver({
+				changeReceiver({
 					revision: mintRevisionTag(),
 					change: {
 						changes: [