@fluidframework/tree 2.73.0 → 2.74.0-368706

package/src/feature-libraries/modular-schema/{modularChangeFormat.ts → modularChangeFormatV1.ts}

@@ -44,7 +44,7 @@ export interface EncodedFieldChange extends Static<typeof EncodedFieldChange> {
 	change: JsonCompatibleReadOnly;
 }
 
-const EncodedFieldChangeMap = Type.Array(EncodedFieldChange);
+export const EncodedFieldChangeMap = Type.Array(EncodedFieldChange);
 
 /**
  * Format for encoding as json.
@@ -134,6 +134,7 @@ export const EncodedModularChangeset = 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

@@ -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,18 +6,29 @@
 import {
 	subtractChangeAtomIds,
 	type ChangeAtomId,
+	type ChangeAtomIdRangeMap,
 	type ChangesetLocalId,
 	type FieldKey,
 	type FieldKindIdentifier,
 	type RevisionInfo,
 	type RevisionTag,
 } from "../../core/index.js";
-import { brand, RangeMap, type Brand, type TupleBTree } from "../../util/index.js";
+import {
+	brand,
+	RangeMap,
+	type Brand,
+	type RangeQueryResult,
+	type TupleBTree,
+} from "../../util/index.js";
 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 +46,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.
@@ -70,12 +83,68 @@ export interface ModularChangeset extends HasFieldChanges {
 	readonly refreshers?: ChangeAtomIdBTree<TreeChunk>;
 }
 
-export type ChangeAtomIdBTree<V> = TupleBTree<[RevisionTag | undefined, ChangesetLocalId], V>;
+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 ChangeAtomIdBTree<V> = TupleBTree<ChangeAtomIdKey, V>;
+export type ChangeAtomIdKey = [RevisionTag | undefined, ChangesetLocalId];
+
+export function getFromChangeAtomIdMap<T>(
+	map: ChangeAtomIdBTree<T>,
+	id: ChangeAtomId,
+): T | undefined {
+	return map.get([id.revision, id.localId]);
+}
+
+export function rangeQueryChangeAtomIdMap<T>(
+	map: ChangeAtomIdBTree<T>,
+	id: ChangeAtomId,
+	count: number,
+): RangeQueryResult<T | undefined> {
+	const pair = map.getPairOrNextHigher([id.revision, id.localId]);
+	if (pair === undefined) {
+		return { value: undefined, length: count };
+	}
+
+	const [[revision, localId], value] = pair;
+	const lengthBefore = subtractChangeAtomIds({ revision, localId }, id);
+	if (lengthBefore === 0) {
+		return { value, length: 1 };
+	}
+
+	return { value: undefined, length: Math.min(lengthBefore, count) };
+}
+
+export function setInChangeAtomIdMap<T>(
+	map: ChangeAtomIdBTree<T>,
+	id: ChangeAtomId,
+	value: T,
+): boolean {
+	return map.set([id.revision, id.localId], value);
+}
 
-export type CrossFieldKeyTable = RangeMap<CrossFieldKey, 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 {
@@ -108,6 +177,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;
 }
@@ -117,15 +204,16 @@ export interface NodeExistsConstraint {
  */
 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>;

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,