@fluidframework/tree 2.83.0 → 2.90.0-378676

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

@@ -132,6 +132,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/modularChangeFormatV2.ts

@@ -9,7 +9,7 @@ import { EncodedModularChangesetV1 } from "./modularChangeFormatV1.js";
 
 const noAdditionalProps: ObjectOptions = { additionalProperties: false };
 
-const EncodedNoChangeConstraint = Type.Object(
+export const EncodedNoChangeConstraint = Type.Object(
 	{
 		violated: Type.Boolean(),
 	},

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

@@ -0,0 +1,67 @@
+/*!
+ * 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";
+import { EncodedNoChangeConstraint } from "./modularChangeFormatV2.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 EncodedModularChangesetV3 = 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 })),
+
+		/** Global no change constraint that gets violated whenever the changeset is rebased */
+		noChangeConstraint: Type.Optional(EncodedNoChangeConstraint),
+	},
+	noAdditionalProps,
+);
+
+export type EncodedModularChangesetV3 = Static<typeof EncodedModularChangesetV3>;

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

@@ -6,7 +6,9 @@
 import {
 	subtractChangeAtomIds,
 	type ChangeAtomId,
+	type ChangeAtomIdRangeMap,
 	type ChangesetLocalId,
+	type EditorOptions,
 	type FieldKey,
 	type FieldKindIdentifier,
 	type RevisionInfo,
@@ -15,9 +17,13 @@ import { brand, RangeMap, type Brand } from "../../util/index.js";
 import type { ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
 
-import type { CrossFieldTarget } from "./crossFieldQueries.js";
+import type { NodeMoveType } 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 +41,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 +82,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
+	readonly oldToNewId: ChangeAtomIdRangeMap<ChangeAtomId>;
+	readonly newToOldId: ChangeAtomIdRangeMap<ChangeAtomId>;
+	readonly 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`.
+	 */
+	readonly detachLocations: ChangeAtomIdRangeMap<FieldId>;
 
-export function newCrossFieldKeyTable(): CrossFieldKeyTable {
-	return new RangeMap(offsetCrossFieldKey, subtractCrossFieldKeys);
+	/**
+	 * 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.
+	 */
+	readonly outputDetachLocations: ChangeAtomIdRangeMap<FieldId>;
+}
+
+export type CrossFieldRangeTable<T> = RangeMap<CrossFieldKey, T>;
+export type CrossFieldKeyTable = CrossFieldRangeTable<FieldId>;
+
+export function newCrossFieldRangeTable<V>(): CrossFieldRangeTable<V> {
+	return new RangeMap<CrossFieldKey, V>(offsetCrossFieldKey, subtractCrossFieldKeys);
 }
 
 function offsetCrossFieldKey(key: CrossFieldKey, offset: number): CrossFieldKey {
@@ -97,7 +126,7 @@ function subtractCrossFieldKeys(a: CrossFieldKey, b: CrossFieldKey): number {
 }
 
 export interface CrossFieldKey extends ChangeAtomId {
-	readonly target: CrossFieldTarget;
+	readonly target: NodeMoveType;
 }
 
 export interface CrossFieldKeyRange {
@@ -110,6 +139,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 {
+	readonly field: FieldId;
+	readonly atomId: ChangeAtomId | undefined;
+}
+
+/**
+ */
 export interface NodeExistsConstraint {
 	violated: boolean;
 }
@@ -126,15 +173,16 @@ 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>;
@@ -145,3 +193,7 @@ export interface FieldChange {
 }
 
 export type FieldChangeset = Brand<unknown, "FieldChangeset">;
+
+export interface ModularEditorOptions extends EditorOptions {
+	readonly rebaseVersionOverride?: RebaseVersion;
+}