@fluidframework/tree 2.80.0 → 2.81.0-374083

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

@@ -134,6 +134,7 @@ export const EncodedModularChangesetV1 = Type.Object(
 		// This can lead to a less efficient wire representation because of duplicated schema/shape information.
 		builds: Type.Optional(EncodedBuilds),
 		refreshers: Type.Optional(EncodedBuilds),
+
 		/**
 		 * The number of constraints within this changeset that are violated.
 		 */

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

@@ -0,0 +1,62 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+import {
+	ChangesetLocalIdSchema,
+	EncodedBuilds,
+	EncodedChangeAtomId,
+	EncodedFieldChangeMap,
+	EncodedNodeChangeset,
+	EncodedRevisionInfo,
+} from "./modularChangeFormatV1.js";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+const EncodedRenames = Type.Optional(
+	Type.Array(
+		Type.Object({
+			oldId: EncodedChangeAtomId,
+			newId: EncodedChangeAtomId,
+			count: Type.Number(),
+		}),
+		noAdditionalProps,
+	),
+);
+
+export type EncodedRenames = Static<typeof EncodedRenames>;
+
+const EncodedRootNodes = Type.Optional(
+	Type.Array(
+		Type.Object(
+			{ detachId: EncodedChangeAtomId, nodeChangeset: EncodedNodeChangeset },
+			noAdditionalProps,
+		),
+	),
+);
+
+export type EncodedRootNodes = Static<typeof EncodedRootNodes>;
+
+export const EncodedModularChangeset = Type.Object(
+	{
+		maxId: Type.Optional(ChangesetLocalIdSchema),
+		fieldChanges: EncodedFieldChangeMap,
+		rootNodes: EncodedRootNodes,
+		nodeRenames: EncodedRenames,
+		revisions: Type.ReadonlyOptional(Type.Array(EncodedRevisionInfo)),
+		// TODO#8574: separating `builds` and `refreshers` here means that we encode their `EncodedBuilds.trees` separately.
+		// This can lead to a less efficient wire representation because of duplicated schema/shape information.
+		builds: Type.Optional(EncodedBuilds),
+		refreshers: Type.Optional(EncodedBuilds),
+
+		/**
+		 * The number of constraints within this changeset that are violated.
+		 */
+		violations: Type.Optional(Type.Number({ minimum: 0, multipleOf: 1 })),
+	},
+	noAdditionalProps,
+);
+
+export type EncodedModularChangeset = Static<typeof EncodedModularChangeset>;

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

@@ -6,6 +6,7 @@
 import {
 	subtractChangeAtomIds,
 	type ChangeAtomId,
+	type ChangeAtomIdRangeMap,
 	type ChangesetLocalId,
 	type FieldKey,
 	type FieldKindIdentifier,
@@ -17,7 +18,11 @@ import type { TreeChunk } from "../chunked-forest/index.js";
 
 import type { CrossFieldTarget } from "./crossFieldQueries.js";
 
+export type RebaseVersion = 1 | 2;
+
 export interface ModularChangeset extends HasFieldChanges {
+	readonly rebaseVersion: RebaseVersion;
+
 	/**
 	 * The numerically highest `ChangesetLocalId` used in this changeset.
 	 * If undefined then this changeset contains no IDs.
@@ -35,12 +40,14 @@ export interface ModularChangeset extends HasFieldChanges {
 	 * Maps from this changeset's canonical ID for a node (see comment on node aliases) to the changes for that node.
 	 */
 	readonly nodeChanges: ChangeAtomIdBTree<NodeChangeset>;
+	readonly rootNodes: RootNodeTable;
 
 	/**
-	 * Maps from this changeset's canonical ID for a node to the ID for the field which contains that node.
+	 * Maps from this changeset's canonical ID for a node to the ID for the field which contains that node,
+	 * or the detach ID, if this node is detached.
 	 */
 	// TODO: Should this be merged with `nodeChanges`?
-	readonly nodeToParent: ChangeAtomIdBTree<FieldId>;
+	readonly nodeToParent: ChangeAtomIdBTree<NodeLocation>;
 
 	/**
 	 * Maps from a node ID to another ID for the same node.
@@ -74,10 +81,31 @@ export interface ModularChangeset extends HasFieldChanges {
 	readonly refreshers?: ChangeAtomIdBTree<TreeChunk>;
 }
 
-export type CrossFieldKeyTable = RangeMap<CrossFieldKey, FieldId>;
+export interface RootNodeTable {
+	// TODO: Include builds, destroys, refreshers, and field changes
+	oldToNewId: ChangeAtomIdRangeMap<ChangeAtomId>;
+	newToOldId: ChangeAtomIdRangeMap<ChangeAtomId>;
+	nodeChanges: ChangeAtomIdBTree<NodeId>;
+
+	/**
+	 * Maps from input context detach ID to the field where the node was last attached.
+	 * There should be an entry for every detach ID referenced in `oldToNewId` or `nodeChanges`.
+	 */
+	detachLocations: ChangeAtomIdRangeMap<FieldId>;
+
+	/**
+	 * Maps from the output root ID of a node to the output detach location of that node.
+	 * This is only guaranteed to contain entries for nodes which have an output detach location
+	 * which is different from their location in the input context.
+	 */
+	outputDetachLocations: ChangeAtomIdRangeMap<FieldId>;
+}
+
+export type CrossFieldRangeTable<T> = RangeMap<CrossFieldKey, T>;
+export type CrossFieldKeyTable = CrossFieldRangeTable<FieldId>;
 
-export function newCrossFieldKeyTable(): CrossFieldKeyTable {
-	return new RangeMap(offsetCrossFieldKey, subtractCrossFieldKeys);
+export function newCrossFieldRangeTable<V>(): CrossFieldRangeTable<V> {
+	return new RangeMap<CrossFieldKey, V>(offsetCrossFieldKey, subtractCrossFieldKeys);
 }
 
 function offsetCrossFieldKey(key: CrossFieldKey, offset: number): CrossFieldKey {
@@ -101,8 +129,8 @@ export interface CrossFieldKey extends ChangeAtomId {
 }
 
 export interface CrossFieldKeyRange {
-	key: CrossFieldKey;
-	count: number;
+	readonly key: CrossFieldKey;
+	readonly count: number;
 }
 
 export interface FieldId {
@@ -110,6 +138,24 @@ export interface FieldId {
 	readonly field: FieldKey;
 }
 
+export interface FieldParent {
+	readonly field: FieldId;
+	readonly root?: undefined;
+}
+
+export interface RootParent {
+	readonly field?: undefined;
+	readonly root: ChangeAtomId;
+}
+
+export type NodeLocation = FieldParent | RootParent;
+export interface DetachLocation {
+	field: FieldId;
+	atomId: ChangeAtomId | undefined;
+}
+
+/**
+ */
 export interface NodeExistsConstraint {
 	violated: boolean;
 }
@@ -126,21 +172,22 @@ export interface NoChangeConstraint {
  */
 export interface NodeChangeset extends HasFieldChanges {
 	/** Keeps track of whether node exists constraint has been violated by this change */
-	nodeExistsConstraint?: NodeExistsConstraint;
+	readonly nodeExistsConstraint?: NodeExistsConstraint;
+
 	/** Keeps track of whether node exists constraint will be violated when this change is reverted */
-	nodeExistsConstraintOnRevert?: NodeExistsConstraint;
+	readonly nodeExistsConstraintOnRevert?: NodeExistsConstraint;
 }
 
 export type NodeId = ChangeAtomId;
 
 export interface HasFieldChanges {
-	fieldChanges?: FieldChangeMap;
+	readonly fieldChanges?: FieldChangeMap;
 }
 
 export type FieldChangeMap = Map<FieldKey, FieldChange>;
 
 export interface FieldChange {
-	fieldKind: FieldKindIdentifier;
+	readonly fieldKind: FieldKindIdentifier;
 	change: FieldChangeset;
 }
 

package/src/feature-libraries/object-forest/objectForest.ts

@@ -308,7 +308,9 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 
 		const forestVisitor = new Visitor(this);
 		const announcedVisitors: AnnouncedVisitor[] = [];
-		this.deltaVisitors.forEach((getVisitor) => announcedVisitors.push(getVisitor()));
+		for (const getVisitor of this.deltaVisitors) {
+			announcedVisitors.push(getVisitor());
+		}
 		const combinedVisitor = combineVisitors([forestVisitor, ...announcedVisitors]);
 		this.activeVisitor = combinedVisitor;
 		return combinedVisitor;

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

@@ -4,10 +4,8 @@
  */
 
 export { makeOptionalFieldCodecFamily } from "./optionalFieldCodecs.js";
-export type { Move, OptionalChangeset, RegisterId } from "./optionalFieldChangeTypes.js";
+export type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
 export {
-	type IRegisterMap,
-	RegisterMap,
 	optionalChangeHandler,
 	optionalFieldEditor,
 	optionalChangeRebaser,