@fluidframework/tree 2.74.0 → 2.81.0-374083

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

@@ -25,7 +25,7 @@ export const EncodedChangeAtomId = Type.Union([
 ]);
 export type EncodedChangeAtomId = Static<typeof EncodedChangeAtomId>;
 
-const EncodedFieldChange = Type.Object(
+export const EncodedFieldChange = Type.Object(
 	{
 		fieldKey: schemaFormatV1.FieldKeySchema,
 		fieldKind: schemaFormatV1.FieldKindIdentifierSchema,
@@ -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.
@@ -125,7 +125,7 @@ export const EncodedBuilds = Type.Object(
 
 export type EncodedBuilds = Static<typeof EncodedBuilds>;
 
-export const EncodedModularChangeset = Type.Object(
+export const EncodedModularChangesetV1 = Type.Object(
 	{
 		maxId: Type.Optional(ChangesetLocalIdSchema),
 		changes: EncodedFieldChangeMap,
@@ -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.
 		 */
@@ -142,4 +143,4 @@ export const EncodedModularChangeset = Type.Object(
 	noAdditionalProps,
 );
 
-export type EncodedModularChangeset = Static<typeof EncodedModularChangeset>;
+export type EncodedModularChangesetV1 = Static<typeof EncodedModularChangesetV1>;

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

@@ -0,0 +1,34 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+
+import { EncodedModularChangesetV1 } from "./modularChangeFormatV1.js";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+const EncodedNoChangeConstraint = Type.Object(
+	{
+		violated: Type.Boolean(),
+	},
+	noAdditionalProps,
+);
+export type EncodedNoChangeConstraint = Static<typeof EncodedNoChangeConstraint>;
+
+export const EncodedModularChangesetV2 = Type.Composite(
+	[
+		EncodedModularChangesetV1,
+		Type.Object(
+			{
+				/** Global no change constraint that gets violated whenever the changeset is rebased */
+				noChangeConstraint: Type.Optional(EncodedNoChangeConstraint),
+			},
+			noAdditionalProps,
+		),
+	],
+	noAdditionalProps,
+);
+
+export type EncodedModularChangesetV2 = Static<typeof EncodedModularChangesetV2>;

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,18 +6,23 @@
 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 } from "../../util/index.js";
+import type { ChangeAtomIdBTree } from "../changeAtomIdBTree.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 +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.
@@ -60,6 +67,10 @@ export interface ModularChangeset extends HasFieldChanges {
 	 * If this count is greater than 0, it will prevent the changeset from being applied.
 	 */
 	readonly constraintViolationCount?: number;
+	/** Constraint that the document must be in the same state before this change is applied as it was before this change was authored */
+	readonly noChangeConstraint?: NoChangeConstraint;
+	/** Constraint that the document must be in the same state before the revert of this change is applied as it was after this change was applied */
+	readonly noChangeConstraintOnRevert?: NoChangeConstraint;
 	/**
 	 * The number of constraint violations that apply to the revert of the changeset. If this count is greater than 0, it will
 	 * prevent the changeset from being reverted or undone.
@@ -70,12 +81,31 @@ 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 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 {
@@ -99,8 +129,8 @@ export interface CrossFieldKey extends ChangeAtomId {
 }
 
 export interface CrossFieldKeyRange {
-	key: CrossFieldKey;
-	count: number;
+	readonly key: CrossFieldKey;
+	readonly count: number;
 }
 
 export interface FieldId {
@@ -108,30 +138,56 @@ 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;
 }
 
+/**
+ * A constraint that is violated whenever the state of the document is different from when the change was authored.
+ */
+export interface NoChangeConstraint {
+	violated: boolean;
+}
+
 /**
  * Changeset for a subtree rooted at a specific node.
  */
 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/node-identifier/mockNodeIdentifierManager.ts

@@ -46,7 +46,7 @@ export class MockNodeIdentifierManager implements NodeIdentifierManager {
 		if (!isStableNodeIdentifier(key) || !key.startsWith("a110ca7e-add1-4000-8000-")) {
 			return undefined;
 		}
-		const localNodeIdentifier = Number.parseInt(key.substring(24), 16);
+		const localNodeIdentifier = Number.parseInt(key.slice(24), 16);
 		return localNodeIdentifier < this.count
 			? brand(localNodeIdentifier as SessionSpaceCompressedId)
 			: undefined;

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

@@ -104,12 +104,12 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 		roots?: MapTree,
 	) {
 		this.#roots =
-			roots !== undefined
-				? deepCopyMapTree(roots)
-				: {
+			roots === undefined
+				? {
 						type: aboveRootPlaceholder,
 						fields: new Map(),
-					};
+					}
+				: deepCopyMapTree(roots);
 
 		if (additionalAsserts) {
 			this.checkSchema();
@@ -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,