@fluidframework/tree 2.74.0 → 2.81.0-374083

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 {
+): path is NormalizedUpPathRoot & { readonly detachedNodeId: DetachedNodeId } {
 	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(path: UpPath | undefined): UpPath[] {
-	const out: UpPath[] = [];
+export function topDownPath<T extends UpPath<T>>(path: T | undefined): T[] {
+	const out: T[] = [];
 	let curr = path;
 	while (curr !== undefined) {
 		out.push(curr);
@@ -262,7 +262,7 @@ export function compareFieldUpPaths(a: FieldUpPath, b: FieldUpPath): boolean {
 }
 
 /**
- * Checks whether or not a given path is parented under the root field.
+ * Returns the field key for the root field.
  * @param path - the path you want to check.
  * @returns the {@link DetachedField} which contains the path.
  */
@@ -277,3 +277,15 @@ 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/core/tree/visitDelta.ts

@@ -64,13 +64,16 @@ export function visitDelta(
 	const rootTransfers: Delta.DetachedNodeRename[] = [];
 	const rootDestructions: Delta.DetachedNodeDestruction[] = [];
 	const refreshers: NestedMap<Major, Minor, ITreeCursorSynchronous> = new Map();
-	delta.refreshers?.forEach(({ id: { major, minor }, trees }) => {
+	for (const {
+		id: { major, minor },
+		trees,
+	} of delta.refreshers ?? []) {
 		const treeCursors = nodeCursorsFromChunk(trees);
 		for (let i = 0; i < trees.topLevelLength; i += 1) {
 			const offsettedId = minor + i;
 			setInNestedMap(refreshers, major, offsettedId, treeCursors[i]);
 		}
-	});
+	}
 	const detachConfig: PassConfig = {
 		func: detachPass,
 		latestRevision,
@@ -204,6 +207,7 @@ function transferRoots(
 				delayed.push({ oldId, newId });
 				continue;
 			}
+			// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- intentional behavior
 			newRootId = detachedFieldIndex.createEntry(newId, revision);
 			const fields = mapToUpdate.get(oldRootId);
 			if (fields !== undefined) {

package/src/core/tree/visitorUtils.ts

@@ -78,24 +78,40 @@ export function combineVisitors(visitors: readonly CombinableVisitor[]): Combine
 	return {
 		type: "Combined",
 		visitors: allVisitors,
-		free: () => visitors.forEach((v) => v.free()),
+		free: () => {
+			for (const v of visitors) {
+				v.free();
+			}
+		},
 		create: (...args) => {
-			allVisitors.forEach((v) => v.create(...args));
-			announcedVisitors.forEach((v) => v.afterCreate(...args));
+			for (const v of allVisitors) {
+				v.create(...args);
+			}
+			for (const v of announcedVisitors) {
+				v.afterCreate(...args);
+			}
 		},
 		destroy: (...args) => {
-			announcedVisitors.forEach((v) => v.beforeDestroy(...args));
-			allVisitors.forEach((v) => v.destroy(...args));
+			for (const v of announcedVisitors) {
+				v.beforeDestroy(...args);
+			}
+			for (const v of allVisitors) {
+				v.destroy(...args);
+			}
 		},
 		attach: (source: FieldKey, count: number, destination: PlaceIndex) => {
-			announcedVisitors.forEach((v) => v.beforeAttach(source, count, destination));
-			allVisitors.forEach((v) => v.attach(source, count, destination));
-			announcedVisitors.forEach((v) =>
+			for (const v of announcedVisitors) {
+				v.beforeAttach(source, count, destination);
+			}
+			for (const v of allVisitors) {
+				v.attach(source, count, destination);
+			}
+			for (const v of announcedVisitors) {
 				v.afterAttach(source, {
 					start: destination,
 					end: destination + count,
-				}),
-			);
+				});
+			}
 		},
 		detach: (
 			source: Range,
@@ -103,16 +119,36 @@ export function combineVisitors(visitors: readonly CombinableVisitor[]): Combine
 			id: DetachedNodeId,
 			isReplaced: boolean,
 		) => {
-			announcedVisitors.forEach((v) => v.beforeDetach(source, destination, isReplaced));
-			allVisitors.forEach((v) => v.detach(source, destination, id, isReplaced));
-			announcedVisitors.forEach((v) =>
-				v.afterDetach(source.start, source.end - source.start, destination, isReplaced),
-			);
+			for (const v of announcedVisitors) {
+				v.beforeDetach(source, destination, isReplaced);
+			}
+			for (const v of allVisitors) {
+				v.detach(source, destination, id, isReplaced);
+			}
+			for (const v of announcedVisitors) {
+				v.afterDetach(source.start, source.end - source.start, destination, isReplaced);
+			}
+		},
+		enterNode: (...args) => {
+			for (const v of allVisitors) {
+				v.enterNode(...args);
+			}
+		},
+		exitNode: (...args) => {
+			for (const v of allVisitors) {
+				v.exitNode(...args);
+			}
+		},
+		enterField: (...args) => {
+			for (const v of allVisitors) {
+				v.enterField(...args);
+			}
+		},
+		exitField: (...args) => {
+			for (const v of allVisitors) {
+				v.exitField(...args);
+			}
 		},
-		enterNode: (...args) => allVisitors.forEach((v) => v.enterNode(...args)),
-		exitNode: (...args) => allVisitors.forEach((v) => v.exitNode(...args)),
-		enterField: (...args) => allVisitors.forEach((v) => v.enterField(...args)),
-		exitField: (...args) => allVisitors.forEach((v) => v.exitField(...args)),
 	};
 }
 

package/src/feature-libraries/changeAtomIdBTree.ts

@@ -0,0 +1,56 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	subtractChangeAtomIds,
+	type ChangeAtomId,
+	type ChangesetLocalId,
+	type RevisionTag,
+} from "../core/index.js";
+import type { RangeQueryResult, TupleBTree } from "../util/index.js";
+
+/**
+ * A BTree which uses ChangeAtomId flattened into a tuple as the key.
+ * @remarks
+ * Read values with {@link getFromChangeAtomIdMap} and write values with {@link setInChangeAtomIdMap}.
+ */
+export type ChangeAtomIdBTree<V> = TupleBTree<
+	readonly [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,
+): boolean {
+	return map.set([id.revision, id.localId], value);
+}
+
+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) };
+}

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob, fail } from "@fluidframework/core-utils/internal";
+import { assert, oob, fail, debugAssert } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -51,6 +51,12 @@ 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 {
@@ -471,7 +477,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,7 +436,12 @@ function newBasicChunkTree(
 ): BasicChunk {
 	return new BasicChunk(
 		cursor.type,
-		new Map(mapCursorFields(cursor, () => [cursor.getFieldKey(), chunkField(cursor, policy)])),
+		new Map(
+			mapCursorFields(cursor, () => {
+				debugAssert(() => cursor.getFieldLength() > 0 || "field must have at least one child");
+				return [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.
@@ -276,7 +276,9 @@ export class ChunkedForest implements IEditableForest {
 		};
 
 		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/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

@@ -159,18 +159,21 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 		| typeof schemaCompressedEncodeV2;
 	let encodedFieldBatchType: typeof EncodedFieldBatchV1 | typeof EncodedFieldBatchV2;
 	switch (writeVersion) {
-		case unbrand(FieldBatchFormatVersion.v1):
+		case unbrand(FieldBatchFormatVersion.v1): {
 			uncompressedEncodeFn = uncompressedEncodeV1;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV1;
 			encodedFieldBatchType = EncodedFieldBatchV1;
 			break;
-		case unbrand(FieldBatchFormatVersion.v2):
+		}
+		case unbrand(FieldBatchFormatVersion.v2): {
 			uncompressedEncodeFn = uncompressedEncodeV2;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV2;
 			encodedFieldBatchType = EncodedFieldBatchV2;
 			break;
-		default:
+		}
+		default: {
 			unreachableCase(writeVersion);
+		}
 	}
 
 	return makeVersionedValidatedCodec(options, validVersions, encodedFieldBatchType, {
@@ -184,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,
@@ -204,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) {
@@ -590,6 +590,7 @@ class LazyFieldEncoder implements FieldEncoder {
 	}
 
 	private get encoder(): FieldEncoder {
+		// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- using ??= could change behavior if value is falsy
 		if (this.encoderLazy === undefined) {
 			this.encoderLazy = this.fieldEncoderFromPolicy(this.nodeBuilder, this.fieldSchema);
 		}

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 {