@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/feature-libraries/modular-schema/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,
@@ -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,7 +134,6 @@ 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.
 		 */
@@ -143,4 +142,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

@@ -4,59 +4,31 @@
  */
 
 import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
-import {
-	ChangesetLocalIdSchema,
-	EncodedBuilds,
-	EncodedChangeAtomId,
-	EncodedFieldChangeMap,
-	EncodedNodeChangeset,
-	EncodedRevisionInfo,
-} from "./modularChangeFormatV1.js";
+
+import { EncodedModularChangesetV1 } from "./modularChangeFormatV1.js";
 
 const noAdditionalProps: ObjectOptions = { additionalProperties: false };
 
-const EncodedRenames = Type.Optional(
-	Type.Array(
-		Type.Object({
-			oldId: EncodedChangeAtomId,
-			newId: EncodedChangeAtomId,
-			count: Type.Number(),
-		}),
-		noAdditionalProps,
-	),
+const EncodedNoChangeConstraint = Type.Object(
+	{
+		violated: Type.Boolean(),
+	},
+	noAdditionalProps,
 );
+export type EncodedNoChangeConstraint = Static<typeof EncodedNoChangeConstraint>;
 
-export type EncodedRenames = Static<typeof EncodedRenames>;
-
-const EncodedRootNodes = Type.Optional(
-	Type.Array(
+export const EncodedModularChangesetV2 = Type.Composite(
+	[
+		EncodedModularChangesetV1,
 		Type.Object(
-			{ detachId: EncodedChangeAtomId, nodeChangeset: EncodedNodeChangeset },
+			{
+				/** Global no change constraint that gets violated whenever the changeset is rebased */
+				noChangeConstraint: Type.Optional(EncodedNoChangeConstraint),
+			},
 			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>;
+export type EncodedModularChangesetV2 = Static<typeof EncodedModularChangesetV2>;

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

@@ -6,29 +6,18 @@
 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 RangeQueryResult,
-	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.
@@ -46,14 +35,12 @@ 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,
-	 * or the detach ID, if this node is detached.
+	 * Maps from this changeset's canonical ID for a node to the ID for the field which contains that node.
 	 */
 	// TODO: Should this be merged with `nodeChanges`?
-	readonly nodeToParent: ChangeAtomIdBTree<NodeLocation>;
+	readonly nodeToParent: ChangeAtomIdBTree<FieldId>;
 
 	/**
 	 * Maps from a node ID to another ID for the same node.
@@ -73,6 +60,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.
@@ -83,68 +74,10 @@ export interface ModularChangeset extends HasFieldChanges {
 	readonly refreshers?: ChangeAtomIdBTree<TreeChunk>;
 }
 
-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 CrossFieldRangeTable<T> = RangeMap<CrossFieldKey, T>;
-export type CrossFieldKeyTable = CrossFieldRangeTable<FieldId>;
+export type CrossFieldKeyTable = RangeMap<CrossFieldKey, FieldId>;
 
-export function newCrossFieldRangeTable<V>(): CrossFieldRangeTable<V> {
-	return new RangeMap<CrossFieldKey, V>(offsetCrossFieldKey, subtractCrossFieldKeys);
+export function newCrossFieldKeyTable(): CrossFieldKeyTable {
+	return new RangeMap(offsetCrossFieldKey, subtractCrossFieldKeys);
 }
 
 function offsetCrossFieldKey(key: CrossFieldKey, offset: number): CrossFieldKey {
@@ -177,25 +110,14 @@ 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 NodeExistsConstraint {
+export interface NoChangeConstraint {
 	violated: boolean;
 }
 
@@ -204,16 +126,15 @@ export interface NodeExistsConstraint {
  */
 export interface NodeChangeset extends HasFieldChanges {
 	/** Keeps track of whether node exists constraint has been violated by this change */
-	readonly nodeExistsConstraint?: NodeExistsConstraint;
-
+	nodeExistsConstraint?: NodeExistsConstraint;
 	/** Keeps track of whether node exists constraint will be violated when this change is reverted */
-	readonly nodeExistsConstraintOnRevert?: NodeExistsConstraint;
+	nodeExistsConstraintOnRevert?: NodeExistsConstraint;
 }
 
 export type NodeId = ChangeAtomId;
 
 export interface HasFieldChanges {
-	readonly fieldChanges?: FieldChangeMap;
+	fieldChanges?: FieldChangeMap;
 }
 
 export type FieldChangeMap = Map<FieldKey, FieldChange>;

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();

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

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