@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/core/tree/detachedFieldIndexCodecV2.ts

@@ -6,20 +6,18 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor, StableId } from "@fluidframework/id-compressor";
 
-import type { ICodecOptions, IJsonCodec } from "../../codec/index.js";
+import type { CodecAndSchema, IJsonCodec } from "../../codec/index.js";
 import type { EncodedRevisionTag, RevisionTagCodec, RevisionTag } from "../rebase/index.js";
 
-import { type FormatV2, StableOrFinalRevisionTag } from "./detachedFieldIndexFormatV2.js";
+import { StableOrFinalRevisionTag } from "./detachedFieldIndexFormatV2.js";
 import type { DetachedFieldSummaryData, Major } from "./detachedFieldIndexTypes.js";
 import { makeDetachedFieldIndexCodecFromMajorCodec } from "./detachedFieldIndexCodecCommon.js";
 import { isStableId } from "@fluidframework/id-compressor/internal";
 import { DetachedFieldIndexFormatVersion } from "./detachedFieldIndexFormatCommon.js";
-import { brand } from "../../util/index.js";
 
 class MajorCodec implements IJsonCodec<Major> {
 	public constructor(
 		private readonly revisionTagCodec: RevisionTagCodec,
-		private readonly options: ICodecOptions,
 		private readonly idCompressor: IIdCompressor,
 	) {}
 
@@ -57,14 +55,12 @@ class MajorCodec implements IJsonCodec<Major> {
 
 export function makeDetachedNodeToFieldCodecV2(
 	revisionTagCodec: RevisionTagCodec,
-	options: ICodecOptions,
 	idCompressor: IIdCompressor,
-): IJsonCodec<DetachedFieldSummaryData, FormatV2> {
-	const majorCodec = new MajorCodec(revisionTagCodec, options, idCompressor);
+): CodecAndSchema<DetachedFieldSummaryData> {
+	const majorCodec = new MajorCodec(revisionTagCodec, idCompressor);
 	return makeDetachedFieldIndexCodecFromMajorCodec(
-		options,
 		majorCodec,
-		brand(DetachedFieldIndexFormatVersion.v2),
+		DetachedFieldIndexFormatVersion.v2,
 		StableOrFinalRevisionTag,
 	);
 }

package/src/core/tree/detachedFieldIndexCodecs.ts

@@ -4,79 +4,36 @@
  */
 
 import type { IIdCompressor } from "@fluidframework/id-compressor";
-import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
-import {
-	getConfigForMinVersionForCollab,
-	lowestMinVersionForCollab,
-} from "@fluidframework/runtime-utils/internal";
+import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 
 import {
-	type CodecTree,
+	ClientVersionDispatchingCodecBuilder,
 	type CodecWriteOptions,
 	FluidClientVersion,
-	type ICodecFamily,
-	type IJsonCodec,
-	makeCodecFamily,
-	makeVersionDispatchingCodec,
 } from "../../codec/index.js";
 import type { RevisionTagCodec } from "../rebase/index.js";
 
 import { makeDetachedNodeToFieldCodecV1 } from "./detachedFieldIndexCodecV1.js";
 import { makeDetachedNodeToFieldCodecV2 } from "./detachedFieldIndexCodecV2.js";
-import type { DetachedFieldSummaryData } from "./detachedFieldIndexTypes.js";
 import { DetachedFieldIndexFormatVersion } from "./detachedFieldIndexFormatCommon.js";
-import { brand } from "../../util/index.js";
-
-/**
- * Convert a MinimumVersionForCollab to a version for detached field codecs.
- * @param clientVersion - The MinimumVersionForCollab to convert.
- * @returns The detached field codec version that corresponds to the provided MinimumVersionForCollab.
- */
-function clientVersionToDetachedFieldVersion(
-	clientVersion: MinimumVersionForCollab,
-): DetachedFieldIndexFormatVersion {
-	return brand(
-		getConfigForMinVersionForCollab(clientVersion, {
-			[lowestMinVersionForCollab]: DetachedFieldIndexFormatVersion.v1,
-			[FluidClientVersion.v2_52]: DetachedFieldIndexFormatVersion.v2,
-		}),
-	);
-}
-
-export function makeDetachedFieldIndexCodec(
-	revisionTagCodec: RevisionTagCodec,
-	options: CodecWriteOptions,
-	idCompressor: IIdCompressor,
-): IJsonCodec<DetachedFieldSummaryData> {
-	const family = makeDetachedFieldIndexCodecFamily(revisionTagCodec, options, idCompressor);
-	return makeVersionDispatchingCodec(family, {
-		...options,
-		writeVersion: clientVersionToDetachedFieldVersion(options.minVersionForCollab),
-	});
-}
 
-export function makeDetachedFieldIndexCodecFamily(
-	revisionTagCodec: RevisionTagCodec,
-	options: CodecWriteOptions,
-	idCompressor: IIdCompressor,
-): ICodecFamily<DetachedFieldSummaryData> {
-	return makeCodecFamily([
-		[
-			DetachedFieldIndexFormatVersion.v1,
-			makeDetachedNodeToFieldCodecV1(revisionTagCodec, options, idCompressor),
-		],
-		[
-			DetachedFieldIndexFormatVersion.v2,
-			makeDetachedNodeToFieldCodecV2(revisionTagCodec, options, idCompressor),
-		],
-	]);
-}
+type BuildData = CodecWriteOptions & {
+	revisionTagCodec: RevisionTagCodec;
+	idCompressor: IIdCompressor;
+};
 
-export function getCodecTreeForDetachedFieldIndexFormat(
-	clientVersion: MinimumVersionForCollab,
-): CodecTree {
-	return {
-		name: "DetachedFieldIndex",
-		version: clientVersionToDetachedFieldVersion(clientVersion),
-	};
-}
+export const detachedFieldIndexCodecBuilder = ClientVersionDispatchingCodecBuilder.build(
+	"DetachedFieldIndex",
+	{
+		[lowestMinVersionForCollab]: {
+			formatVersion: DetachedFieldIndexFormatVersion.v1,
+			codec: (buildData: BuildData) =>
+				makeDetachedNodeToFieldCodecV1(buildData.revisionTagCodec, buildData.idCompressor),
+		},
+		[FluidClientVersion.v2_52]: {
+			formatVersion: DetachedFieldIndexFormatVersion.v2,
+			codec: (buildData: BuildData) =>
+				makeDetachedNodeToFieldCodecV2(buildData.revisionTagCodec, buildData.idCompressor),
+		},
+	},
+);

package/src/core/tree/detachedFieldIndexFormatCommon.ts

@@ -5,21 +5,18 @@
 
 import { type Static, type TSchema, Type } from "@sinclair/typebox";
 
-import { brandedNumberType, type Brand } from "../../util/index.js";
+import { brandedNumberType, strictEnum, type Values } from "../../util/index.js";
 
 import type { ForestRootId } from "./detachedFieldIndexTypes.js";
 
 /**
  * The format version for the detached field index.
  */
-export const DetachedFieldIndexFormatVersion = {
+export const DetachedFieldIndexFormatVersion = strictEnum("DetachedFieldIndexFormatVersion", {
 	v1: 1,
 	v2: 2,
-} as const;
-export type DetachedFieldIndexFormatVersion = Brand<
-	(typeof DetachedFieldIndexFormatVersion)[keyof typeof DetachedFieldIndexFormatVersion],
-	"DetachedFieldIndexFormatVersion"
->;
+});
+export type DetachedFieldIndexFormatVersion = Values<typeof DetachedFieldIndexFormatVersion>;
 
 /**
  * The ID of a detached node. Is not globally unique on.

package/src/core/tree/index.ts

@@ -59,9 +59,8 @@ export {
 	type NodeIndex,
 	compareUpPaths,
 	compareFieldUpPaths,
-	isDetachedUpPathRoot,
+	isDetachedUpPathRoot as isDetachedUpPath,
 	getDetachedFieldContainingPath,
-	getDetachedFieldContainingFieldPath,
 	type UpPathDefault,
 } from "./pathTree.js";
 export {
@@ -124,7 +123,7 @@ export {
 	type ReadOnlyDetachedFieldIndex,
 } from "./detachedFieldIndex.js";
 
-export { getCodecTreeForDetachedFieldIndexFormat } from "./detachedFieldIndexCodecs.js";
+export { detachedFieldIndexCodecBuilder } from "./detachedFieldIndexCodecs.js";
 export { DetachedFieldIndexFormatVersion } from "./detachedFieldIndexFormatCommon.js";
 export { type FormatV1 } from "./detachedFieldIndexFormatV1.js";
 

package/src/core/tree/mapTree.ts

@@ -50,7 +50,7 @@ export function deepCopyMapTree(mapTree: MinimalMapTreeNodeView): ExclusiveMapTr
 	): ExclusiveMapTree {
 		return {
 			type: child.type,
-			...(child.value !== undefined ? { value: child.value } : {}),
+			...(child.value === undefined ? {} : { value: child.value }),
 			fields,
 		};
 	}

package/src/core/tree/pathTree.ts

@@ -126,7 +126,7 @@ export interface FieldUpPath<TUpPath = UpPath> {
  */
 export function isDetachedUpPathRoot<T>(
 	path: UpPath<T> | NormalizedUpPath,
-): path is NormalizedUpPathRoot & { readonly detachedNodeId: DetachedNodeId } {
+): path is NormalizedUpPathRoot {
 	return (path as NormalizedUpPathRoot).detachedNodeId !== undefined;
 }
 
@@ -219,8 +219,8 @@ export function clonePath(path: UpPath | undefined): UpPath | undefined {
  * Gets the elements of the given `path`, ordered from root-most to child-most.
  * @remarks These elements are unchanged and therefore still point "up".
  */
-export function topDownPath<T extends UpPath<T>>(path: T | undefined): T[] {
-	const out: T[] = [];
+export function topDownPath(path: UpPath | undefined): UpPath[] {
+	const out: UpPath[] = [];
 	let curr = path;
 	while (curr !== undefined) {
 		out.push(curr);
@@ -262,7 +262,7 @@ export function compareFieldUpPaths(a: FieldUpPath, b: FieldUpPath): boolean {
 }
 
 /**
- * Returns the field key for the root field.
+ * Checks whether or not a given path is parented under the root field.
  * @param path - the path you want to check.
  * @returns the {@link DetachedField} which contains the path.
  */
@@ -277,15 +277,3 @@ export function getDetachedFieldContainingPath(path: UpPath): DetachedField {
 	}
 	return keyAsDetachedField(path.parentField);
 }
-
-/**
- * Returns the field key for the root field.
- * @param path - the path you want to check.
- * @returns the {@link DetachedField} which contains the path.
- */
-export function getDetachedFieldContainingFieldPath(path: FieldUpPath): DetachedField {
-	if (path.parent === undefined) {
-		return keyAsDetachedField(path.field);
-	}
-	return getDetachedFieldContainingPath(path.parent);
-}

package/src/core/tree/sparseTree.ts

@@ -140,6 +140,7 @@ export class SparseNode<TData> implements UpPath {
 	 * Allowed when dangling (but not when disposed).
 	 */
 	private disposeThis(): void {
+		// eslint-disable-next-line unicorn/prefer-dom-node-remove -- Custom tree structure, not DOM
 		this.parentPath?.removeChild(this);
 	}
 }

package/src/core/tree/treeTextFormat.ts

@@ -165,15 +165,11 @@ export function genericTreeDeleteIfEmpty<T>(
 	removeMapObject: boolean,
 ): void {
 	const children = getGenericTreeFieldMap(node, false);
-	if (Object.prototype.hasOwnProperty.call(children, key)) {
-		if (children[key]?.length === 0) {
-			// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-			delete children[key];
-			if (removeMapObject) {
-				if (Object.keys(children).length === 0) {
-					delete node.fields;
-				}
-			}
+	if (Object.prototype.hasOwnProperty.call(children, key) && children[key]?.length === 0) {
+		// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+		delete children[key];
+		if (removeMapObject && Object.keys(children).length === 0) {
+			delete node.fields;
 		}
 	}
 }

package/src/feature-libraries/changeAtomIdBTree.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { ChangeAtomId, ChangesetLocalId, RevisionTag } from "../core/index.js";
+import type { TupleBTree } from "../util/index.js";
+
+export type ChangeAtomIdBTree<V> = TupleBTree<[RevisionTag | undefined, ChangesetLocalId], V>;
+
+export function getFromChangeAtomIdMap<T>(
+	map: ChangeAtomIdBTree<T>,
+	id: ChangeAtomId,
+): T | undefined {
+	return map.get([id.revision, id.localId]);
+}
+
+export function setInChangeAtomIdMap<T>(
+	map: ChangeAtomIdBTree<T>,
+	id: ChangeAtomId,
+	value: T,
+): void {
+	map.set([id.revision, id.localId], value);
+}

package/src/feature-libraries/chunked-forest/basicChunk.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob, fail, debugAssert } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -51,12 +51,6 @@ export class BasicChunk extends ReferenceCountedBase implements TreeChunk {
 		public value?: TreeValue,
 	) {
 		super();
-		debugAssert(() => {
-			for (const field of fields.values()) {
-				if (field.length === 0) return "field must have at least one child";
-			}
-			return true;
-		});
 	}
 
 	public clone(): BasicChunk {
@@ -477,7 +471,7 @@ export class BasicChunkCursor extends SynchronousCursor implements ChunkedCursor
 			0x55d /* can only initNestedCursor when in Nodes */,
 		);
 		const chunk = (this.siblings as TreeChunk[])[this.indexOfChunk] ?? oob();
-		this.nestedCursor = !(chunk instanceof BasicChunk) ? chunk.cursor() : undefined;
+		this.nestedCursor = chunk instanceof BasicChunk ? undefined : chunk.cursor();
 		this.nestedCursor?.enterNode(this.indexWithinChunk);
 	}
 

package/src/feature-libraries/chunked-forest/chunkTree.ts

@@ -436,12 +436,7 @@ function newBasicChunkTree(
 ): BasicChunk {
 	return new BasicChunk(
 		cursor.type,
-		new Map(
-			mapCursorFields(cursor, () => {
-				debugAssert(() => cursor.getFieldLength() > 0 || "field must have at least one child");
-				return [cursor.getFieldKey(), chunkField(cursor, policy)];
-			}),
-		),
+		new Map(mapCursorFields(cursor, () => [cursor.getFieldKey(), chunkField(cursor, policy)])),
 		cursor.value,
 	);
 }

package/src/feature-libraries/chunked-forest/chunkedForest.ts

@@ -196,7 +196,11 @@ export class ChunkedForest implements IEditableForest {
 				assertValidRange(source, sourceField);
 				const newField = sourceField.splice(source.start, source.end - source.start);
 
-				if (destination !== undefined) {
+				if (destination === undefined) {
+					for (const child of newField) {
+						child.referenceRemoved();
+					}
+				} else {
 					assert(
 						!this.forest.roots.fields.has(destination),
 						0x7af /* Destination must be a new empty detached field */,
@@ -204,10 +208,6 @@ export class ChunkedForest implements IEditableForest {
 					if (newField.length > 0) {
 						this.forest.roots.fields.set(destination, newField);
 					}
-				} else {
-					for (const child of newField) {
-						child.referenceRemoved();
-					}
 				}
 				// This check is performed after the transfer to ensure that the field is not removed in scenarios
 				// where the source and destination are the same.

package/src/feature-libraries/chunked-forest/codec/chunkDecoding.ts

@@ -177,12 +177,15 @@ export function deaggregateChunks(chunk: TreeChunk): TreeChunk[] {
 export function aggregateChunks(input: TreeChunk[]): TreeChunk {
 	const chunks = input.flatMap(deaggregateChunks);
 	switch (chunks.length) {
-		case 0:
+		case 0: {
 			return emptyChunk;
-		case 1:
+		}
+		case 1: {
 			return chunks[0] ?? oob();
-		default:
+		}
+		default: {
 			return new SequenceChunk(chunks);
+		}
 	}
 }
 
@@ -336,7 +339,7 @@ export class NodeDecoder implements ChunkDecoder {
 			// consider keeping array chunks here if they are longer than some threshold.
 			const chunks = deaggregateChunks(data);
 
-			if (chunks.length !== 0) {
+			if (chunks.length > 0) {
 				fields.set(key, chunks);
 			}
 		}

package/src/feature-libraries/chunked-forest/codec/codecs.ts

@@ -28,6 +28,7 @@ import {
 	brandedNumberType,
 	type Brand,
 	type JsonCompatibleReadOnly,
+	unbrand,
 } from "../../../util/index.js";
 import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
@@ -158,18 +159,21 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 		| typeof schemaCompressedEncodeV2;
 	let encodedFieldBatchType: typeof EncodedFieldBatchV1 | typeof EncodedFieldBatchV2;
 	switch (writeVersion) {
-		case FieldBatchFormatVersion.v1:
+		case unbrand(FieldBatchFormatVersion.v1): {
 			uncompressedEncodeFn = uncompressedEncodeV1;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV1;
 			encodedFieldBatchType = EncodedFieldBatchV1;
 			break;
-		case FieldBatchFormatVersion.v2:
+		}
+		case unbrand(FieldBatchFormatVersion.v2): {
 			uncompressedEncodeFn = uncompressedEncodeV2;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV2;
 			encodedFieldBatchType = EncodedFieldBatchV2;
 			break;
-		default:
+		}
+		default: {
 			unreachableCase(writeVersion);
+		}
 	}
 
 	return makeVersionedValidatedCodec(options, validVersions, encodedFieldBatchType, {
@@ -183,19 +187,25 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 			let encoded: EncodedFieldBatch;
 			let incrementalEncoder: IncrementalEncoder | undefined;
 			switch (context.encodeType) {
-				case TreeCompressionStrategy.Uncompressed:
+				case TreeCompressionStrategy.Uncompressed: {
 					encoded = uncompressedEncodeFn(data);
 					break;
-				case TreeCompressionStrategy.CompressedIncremental:
+				}
+				case TreeCompressionStrategy.CompressedIncremental: {
 					assert(
 						writeVersion >= FieldBatchFormatVersion.v2,
 						0xca0 /* Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher */,
 					);
 					// Incremental encoding is only supported for CompressedIncremental.
 					incrementalEncoder = context.incrementalEncoderDecoder;
-				case TreeCompressionStrategy.Compressed:
+				}
+				// fallthrough
+				case TreeCompressionStrategy.Compressed: {
 					// eslint-disable-next-line unicorn/prefer-ternary
-					if (context.schema !== undefined) {
+					if (context.schema === undefined) {
+						// TODO: consider enabling a somewhat compressed but not schema accelerated encode.
+						encoded = uncompressedEncodeFn(data);
+					} else {
 						encoded = schemaCompressedEncodeFn(
 							context.schema.schema,
 							context.schema.policy,
@@ -203,14 +213,13 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 							context.idCompressor,
 							incrementalEncoder,
 						);
-					} else {
-						// TODO: consider enabling a somewhat compressed but not schema accelerated encode.
-						encoded = uncompressedEncodeFn(data);
 					}
 
 					break;
-				default:
+				}
+				default: {
 					unreachableCase(context.encodeType);
+				}
 			}
 
 			// TODO: consider checking input data was in schema.

package/src/feature-libraries/chunked-forest/codec/compressedEncode.ts

@@ -484,10 +484,10 @@ export function encodeValue(
 	outputBuffer: BufferFormat,
 ): void {
 	if (shape === undefined) {
-		if (value !== undefined) {
-			outputBuffer.push(true, value);
-		} else {
+		if (value === undefined) {
 			outputBuffer.push(false);
+		} else {
+			outputBuffer.push(true, value);
 		}
 	} else {
 		if (shape === true) {

package/src/feature-libraries/chunked-forest/codec/format.ts

@@ -13,19 +13,16 @@ import {
 	IdentifierOrIndex,
 	ShapeIndex,
 } from "./formatGeneric.js";
-import { brand, type Brand } from "../../../util/index.js";
+import { strictEnum, type Values } from "../../../util/index.js";
 
 /**
  * The format version for the field batch.
  */
-export const FieldBatchFormatVersion = {
+export const FieldBatchFormatVersion = strictEnum("FieldBatchFormatVersion", {
 	v1: 1,
 	v2: 2,
-} as const;
-export type FieldBatchFormatVersion = Brand<
-	(typeof FieldBatchFormatVersion)[keyof typeof FieldBatchFormatVersion],
-	"FieldBatchFormatVersion"
->;
+});
+export type FieldBatchFormatVersion = Values<typeof FieldBatchFormatVersion>;
 
 // Compatible versions used for format/version validation.
 // TODO: A proper version update policy will need to be documented.
@@ -219,13 +216,13 @@ export type EncodedAnyShape = Static<typeof EncodedAnyShape>;
 export type EncodedIncrementalChunkShape = Static<typeof EncodedIncrementalChunkShape>;
 
 export const EncodedFieldBatchV1 = EncodedFieldBatchGeneric(
-	brand<FieldBatchFormatVersion>(FieldBatchFormatVersion.v1),
+	FieldBatchFormatVersion.v1,
 	EncodedChunkShape,
 );
 export type EncodedFieldBatchV1 = Static<typeof EncodedFieldBatchV1>;
 
 export const EncodedFieldBatchV2 = EncodedFieldBatchGeneric(
-	brand<FieldBatchFormatVersion>(FieldBatchFormatVersion.v2),
+	FieldBatchFormatVersion.v2,
 	EncodedChunkShape,
 );
 export type EncodedFieldBatchV2 = Static<typeof EncodedFieldBatchV2>;

package/src/feature-libraries/chunked-forest/codec/schemaBasedEncode.ts

@@ -143,7 +143,7 @@ export function getFieldEncoder(
 	const kind = context.fieldShapes.get(field.kind) ?? fail(0xb52 /* missing FieldKind */);
 	const type = oneFromIterable(field.types);
 	const nodeEncoder =
-		type !== undefined ? nodeBuilder.nodeEncoderFromSchema(type) : anyNodeEncoder;
+		type === undefined ? anyNodeEncoder : nodeBuilder.nodeEncoderFromSchema(type);
 	if (kind.multiplicity === Multiplicity.Single) {
 		if (field.kind === identifierFieldKindIdentifier) {
 			assert(type !== undefined, 0x999 /* field type must be defined in identifier field */);
@@ -227,16 +227,20 @@ export function getNodeEncoder(
 
 function valueShapeFromSchema(schema: ValueSchema | undefined): undefined | EncodedValueShape {
 	switch (schema) {
-		case undefined:
+		case undefined: {
 			return false;
+		}
 		case ValueSchema.Number:
 		case ValueSchema.String:
 		case ValueSchema.Boolean:
-		case ValueSchema.FluidHandle:
+		case ValueSchema.FluidHandle: {
 			return true;
-		case ValueSchema.Null:
+		}
+		case ValueSchema.Null: {
 			return [null];
-		default:
+		}
+		default: {
 			unreachableCase(schema);
+		}
 	}
 }

package/src/feature-libraries/chunked-forest/uniformChunk.ts

@@ -66,7 +66,7 @@ export class UniformChunk extends ReferenceCountedBase implements TreeChunk {
 	}
 
 	public clone(): UniformChunk {
-		return new UniformChunk(this.shape, this.values.slice());
+		return new UniformChunk(this.shape, [...this.values]);
 	}
 
 	public cursor(): Cursor {