@fluidframework/tree 2.1.0 → 2.3.0-288113

package/src/feature-libraries/flex-tree/index.ts

@@ -8,7 +8,6 @@ export {
 	type FlexTreeNode,
 	type FlexTreeEntity,
 	type FlexTreeTypedField,
-	type FlexTreeFieldNode,
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
 	type FlexTreeLeafNode,
@@ -17,7 +16,6 @@ export {
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
 	type FlexTreeObjectNode,
-	type FlexTreeObjectNodeTyped,
 	type AssignableFieldKinds,
 	type FlexTreeTypedNode,
 	type FlexTreeTypedNodeUnion,
@@ -28,12 +26,6 @@ export {
 	flexTreeMarker,
 	FlexTreeEntityKind,
 	isFlexTreeNode,
-	type PropertyNameFromFieldKey,
-	type ReservedObjectNodeFieldPropertyNames,
-	type ReservedObjectNodeFieldPropertyNamePrefixes,
-	reservedObjectNodeFieldPropertyNames,
-	reservedObjectNodeFieldPropertyNamePrefixes,
-	type FlexTreeObjectNodeFieldsInner,
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
 
@@ -49,16 +41,7 @@ export { getTreeContext, type FlexTreeContext, Context, ContextSlot } from "./co
 
 export { type FlexTreeNodeEvents } from "./treeEvents.js";
 
-// Below here are things that are used by the above, but not part of the desired API surface.
-export type {
-	FlexTreeTypedFieldInner,
-	FlexTreeUnboxFieldInner,
-	FlexTreeObjectNodeFields,
-	FlexTreeUnboxNode,
-	FlexTreeUnboxNodeUnion,
-	IsArrayOfOne,
-	FlexibleNodeSubSequence,
-} from "./flexTreeTypes.js";
+export type { FlexTreeUnboxNodeUnion } from "./flexTreeTypes.js";
 
 export {
 	assertFlexTreeEntityNotFreed,

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -7,6 +7,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
+	type ExclusiveMapTree,
 	type FieldAnchor,
 	type FieldKey,
 	type FieldUpPath,
@@ -14,26 +15,16 @@ import {
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
 	inCursorNode,
-	isCursor,
 	iterateCursorField,
 	rootFieldKey,
 } from "../../core/index.js";
-import {
-	assertValidIndex,
-	assertValidRangeIndices,
-	disposeSymbol,
-	fail,
-	getOrCreate,
-} from "../../util/index.js";
-// TODO: stop depending on contextuallyTyped
-import { applyTypesFromContext, cursorFromContextualData } from "../contextuallyTyped.js";
+import { disposeSymbol, fail, getOrCreate } from "../../util/index.js";
 import {
 	FieldKinds,
 	type OptionalFieldEditBuilder,
 	type SequenceFieldEditBuilder,
 	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
-import { cursorForMapTreeField } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 import type { FlexAllowedTypes, FlexFieldSchema } from "../typed-schema/index.js";
 
@@ -48,8 +39,6 @@ import {
 	type FlexTreeTypedField,
 	type FlexTreeTypedNodeUnion,
 	type FlexTreeUnboxNodeUnion,
-	type FlexibleNodeContent,
-	type FlexibleNodeSubSequence,
 	TreeStatus,
 	flexTreeMarker,
 	flexTreeSlot,
@@ -66,6 +55,7 @@ import { type LazyTreeNode, makeTree } from "./lazyNode.js";
 import { unboxedUnion } from "./unboxed.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { cursorForMapTreeField, cursorForMapTreeNode } from "../mapTreeCursor.js";
 
 /**
  * Reuse fields.
@@ -133,8 +123,7 @@ export function makeField(
 }
 
 /**
- * A Proxy target, which together with a `fieldProxyHandler` implements a basic access to
- * the nodes of {@link EditableField} by means of the cursors.
+ * Base type for fields implementing {@link FlexTreeField} using cursors.
  */
 export abstract class LazyField<
 		out TKind extends FlexFieldKind,
@@ -236,12 +225,6 @@ export abstract class LazyField<
 		return Array.from(this, callbackfn);
 	}
 
-	public mapBoxed<U>(
-		callbackfn: (value: FlexTreeTypedNodeUnion<TTypes>, index: number) => U,
-	): U[] {
-		return Array.from(this.boxedIterator(), callbackfn);
-	}
-
 	public boxedIterator(): IterableIterator<FlexTreeTypedNodeUnion<TTypes>> {
 		return iterateCursorField(
 			this[cursorSymbol],
@@ -308,150 +291,18 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 		return this.map((x) => x);
 	}
 
-	public sequenceEditor(): SequenceFieldEditBuilder {
-		const fieldPath = this.getFieldPathForEditing();
-		const fieldEditor = this.context.checkout.editor.sequenceField(fieldPath);
-		return fieldEditor;
-	}
-
-	public insertAt(index: number, value: FlexibleNodeSubSequence<TTypes>): void {
-		assertValidIndex(index, this, true);
-		const content: ITreeCursorSynchronous = isCursor(value)
-			? prepareFieldCursorForInsert(value)
-			: cursorForMapTreeField(
-					Array.from(value, (item) =>
-						applyTypesFromContext(this.context, this.schema.allowedTypeSet, item),
-					),
-				);
-
-		const fieldEditor = this.sequenceEditor();
-		fieldEditor.insert(index, content);
-	}
-
-	public insertAtStart(value: FlexibleNodeSubSequence<TTypes>): void {
-		this.insertAt(0, value);
-	}
-
-	public insertAtEnd(value: FlexibleNodeSubSequence<TTypes>): void {
-		this.insertAt(this.length, value);
-	}
-
-	public removeAt(index: number): void {
-		const fieldEditor = this.sequenceEditor();
-		fieldEditor.remove(index, 1);
-	}
-
-	public moveToStart(sourceIndex: number): void;
-	public moveToStart(
-		sourceIndex: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveToStart(
-		sourceIndex: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(0, sourceIndex, sourceIndex + 1, source);
-	}
-	public moveToEnd(sourceIndex: number): void;
-	public moveToEnd(sourceIndex: number, source: FlexTreeSequenceField<FlexAllowedTypes>): void;
-	public moveToEnd(
-		sourceIndex: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(this.length, sourceIndex, sourceIndex + 1, source);
-	}
-	public moveToIndex(index: number, sourceIndex: number): void;
-	public moveToIndex(
-		index: number,
-		sourceIndex: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveToIndex(
-		index: number,
-		sourceIndex: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(index, sourceIndex, sourceIndex + 1, source);
-	}
-
-	public moveRangeToStart(sourceStart: number, sourceEnd: number): void;
-	public moveRangeToStart(
-		sourceStart: number,
-		sourceEnd: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveRangeToStart(
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(0, sourceStart, sourceEnd, source);
-	}
-
-	public moveRangeToEnd(sourceStart: number, sourceEnd: number): void;
-	public moveRangeToEnd(
-		sourceStart: number,
-		sourceEnd: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveRangeToEnd(
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(this.length, sourceStart, sourceEnd, source);
-	}
-
-	public moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number): void;
-	public moveRangeToIndex(
-		index: number,
-		sourceStart: number,
-		sourceEnd: number,
-		source: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void;
-	public moveRangeToIndex(
-		index: number,
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		this._moveRangeToIndex(index, sourceStart, sourceEnd, source);
-	}
-
-	private _moveRangeToIndex(
-		index: number,
-		sourceStart: number,
-		sourceEnd: number,
-		source?: FlexTreeSequenceField<FlexAllowedTypes>,
-	): void {
-		const sourceField = source ?? this;
+	public editor: SequenceFieldEditBuilder<ExclusiveMapTree[]> = {
+		insert: (index, newContent) => {
+			this.sequenceEditor().insert(index, cursorForMapTreeField(newContent));
+		},
+		remove: (index, count) => {
+			this.sequenceEditor().remove(index, count);
+		},
+	};
 
-		// TODO: determine support for move across different sequence types
-		assert(
-			sourceField instanceof LazySequence,
-			0x7b1 /* Unsupported sequence implementation. */,
-		);
-		assertValidRangeIndices(sourceStart, sourceEnd, sourceField);
-		if (this.schema.types !== undefined && sourceField !== this) {
-			for (let i = sourceStart; i < sourceEnd; i++) {
-				const sourceNode =
-					sourceField.boxedAt(sourceStart) ?? fail("impossible out of bounds index");
-				if (!this.schema.types.has(sourceNode.schema.name)) {
-					throw new Error("Type in source sequence is not allowed in destination.");
-				}
-			}
-		}
-		const movedCount = sourceEnd - sourceStart;
-		assertValidIndex(index, this, true);
-		const sourceFieldPath = sourceField.getFieldPath();
-		const destinationFieldPath = this.getFieldPath();
-		this.context.checkout.editor.move(
-			sourceFieldPath,
-			sourceStart,
-			movedCount,
-			destinationFieldPath,
-			index,
-		);
+	private sequenceEditor(): SequenceFieldEditBuilder<ITreeCursorSynchronous> {
+		const fieldPath = this.getFieldPathForEditing();
+		return this.context.checkout.editor.sequenceField(fieldPath);
 	}
 }
 
@@ -468,13 +319,15 @@ export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
 		super(context, schema, cursor, fieldAnchor);
 	}
 
+	public editor: ValueFieldEditBuilder<ExclusiveMapTree> = {
+		set: (newContent) => {
+			assert(false, 0xa0c /* Unexpected set of readonly field */);
+		},
+	};
+
 	public get content(): FlexTreeUnboxNodeUnion<TTypes> {
 		return this.atIndex(0);
 	}
-
-	public set content(newContent: FlexibleNodeContent<TTypes>) {
-		fail("cannot set content in readonly field");
-	}
 }
 
 export class LazyValueField<TTypes extends FlexAllowedTypes>
@@ -490,7 +343,13 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 		super(context, schema, cursor, fieldAnchor);
 	}
 
-	private valueFieldEditor(): ValueFieldEditBuilder {
+	public override editor: ValueFieldEditBuilder<ExclusiveMapTree> = {
+		set: (newContent) => {
+			this.valueFieldEditor().set(cursorForMapTreeNode(newContent));
+		},
+	};
+
+	private valueFieldEditor(): ValueFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.context.checkout.editor.valueField(fieldPath);
 		return fieldEditor;
@@ -499,15 +358,6 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 	public override get content(): FlexTreeUnboxNodeUnion<TTypes> {
 		return this.atIndex(0);
 	}
-
-	public override set content(newContent: FlexibleNodeContent<TTypes>) {
-		const content: ITreeCursorSynchronous[] = isCursor(newContent)
-			? prepareNodeCursorForInsert(newContent)
-			: [cursorFromContextualData(this.context, this.schema.allowedTypeSet, newContent)];
-		const fieldEditor = this.valueFieldEditor();
-		assert(content.length === 1, 0x780 /* value field content should normalize to one item */);
-		fieldEditor.set(content[0]);
-	}
 }
 
 export class LazyIdentifierField<TTypes extends FlexAllowedTypes>
@@ -537,7 +387,16 @@ export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 		super(context, schema, cursor, fieldAnchor);
 	}
 
-	private optionalEditor(): OptionalFieldEditBuilder {
+	public editor: OptionalFieldEditBuilder<ExclusiveMapTree> = {
+		set: (newContent, wasEmpty) => {
+			this.optionalEditor().set(
+				newContent !== undefined ? cursorForMapTreeNode(newContent) : newContent,
+				wasEmpty,
+			);
+		},
+	};
+
+	private optionalEditor(): OptionalFieldEditBuilder<ITreeCursorSynchronous> {
 		const fieldPath = this.getFieldPathForEditing();
 		const fieldEditor = this.context.checkout.editor.optionalField(fieldPath);
 		return fieldEditor;
@@ -546,21 +405,6 @@ export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 	public get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined {
 		return this.length === 0 ? undefined : this.atIndex(0);
 	}
-
-	public set content(newContent: FlexibleNodeContent<TTypes> | undefined) {
-		const content: ITreeCursorSynchronous[] =
-			newContent === undefined
-				? []
-				: isCursor(newContent)
-					? prepareNodeCursorForInsert(newContent)
-					: [cursorFromContextualData(this.context, this.schema.allowedTypeSet, newContent)];
-		const fieldEditor = this.optionalEditor();
-		assert(
-			content.length <= 1,
-			0x781 /* optional field content should normalize at most one item */,
-		);
-		fieldEditor.set(content.length === 0 ? undefined : content[0], this.length === 0);
-	}
 }
 
 export class LazyForbiddenField<TTypes extends FlexAllowedTypes> extends LazyField<
@@ -588,23 +432,3 @@ const builderList: [FlexFieldKind, Builder][] = [
 ];
 
 const kindToClass: ReadonlyMap<FlexFieldKind, Builder> = new Map(builderList);
-
-/**
- * Prepare a fields cursor (holding a sequence of nodes) for inserting.
- */
-function prepareFieldCursorForInsert(cursor: ITreeCursorSynchronous): ITreeCursorSynchronous {
-	// TODO: optionally validate content against schema.
-
-	assert(cursor.mode === CursorLocationType.Fields, 0x8cb /* should be in fields mode */);
-	return cursor;
-}
-
-/**
- * Prepare a node cursor (holding a single node) for inserting.
- */
-function prepareNodeCursorForInsert(cursor: ITreeCursorSynchronous): ITreeCursorSynchronous[] {
-	// TODO: optionally validate content against schema.
-
-	assert(cursor.mode === CursorLocationType.Nodes, 0x805 /* should be in nodes mode */);
-	return [cursor];
-}

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -9,30 +9,24 @@ import {
 	type Anchor,
 	type AnchorNode,
 	CursorLocationType,
-	EmptyKey,
 	type FieldKey,
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
 	type TreeNodeSchemaIdentifier,
 	type TreeValue,
 	type Value,
-	forEachField,
 	inCursorField,
 	mapCursorFields,
 	rootFieldKey,
 } from "../../core/index.js";
-import { brand, capitalize, disposeSymbol, fail, getOrCreate } from "../../util/index.js";
+import { brand, disposeSymbol, fail } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
 import {
 	Any,
-	type FlexAllowedTypes,
-	type FlexFieldNodeSchema,
 	FlexFieldSchema,
 	type FlexMapNodeSchema,
-	type FlexObjectNodeSchema,
 	type FlexTreeNodeSchema,
 	type LeafNodeSchema,
-	schemaIsFieldNode,
 	schemaIsLeaf,
 	schemaIsMap,
 	schemaIsObjectNode,
@@ -42,23 +36,14 @@ import type { Context } from "./context.js";
 import {
 	FlexTreeEntityKind,
 	type FlexTreeField,
-	type FlexTreeFieldNode,
 	type FlexTreeLeafNode,
 	type FlexTreeMapNode,
 	type FlexTreeNode,
-	type FlexTreeObjectNodeTyped,
-	type FlexTreeOptionalField,
-	type FlexTreeRequiredField,
 	type FlexTreeTypedField,
 	type FlexTreeTypedNode,
 	type FlexTreeUnboxField,
-	type FlexibleFieldContent,
-	type FlexibleNodeContent,
-	type PropertyNameFromFieldKey,
 	flexTreeMarker,
 	flexTreeSlot,
-	reservedObjectNodeFieldPropertyNamePrefixes,
-	reservedObjectNodeFieldPropertyNames,
 } from "./flexTreeTypes.js";
 import {
 	LazyEntity,
@@ -108,11 +93,8 @@ function buildSubclass(
 	if (schemaIsLeaf(schema)) {
 		return new LazyLeaf(context, schema, cursor, anchorNode, anchor);
 	}
-	if (schemaIsFieldNode(schema)) {
-		return new LazyFieldNode(context, schema, cursor, anchorNode, anchor);
-	}
 	if (schemaIsObjectNode(schema)) {
-		return buildLazyObjectNode(context, schema, cursor, anchorNode, anchor);
+		return new LazyTreeNode(context, schema, cursor, anchorNode, anchor);
 	}
 	// TODO: there should be a common fallback that works for cases without a specialized implementation.
 	fail("unrecognized node kind");
@@ -121,7 +103,7 @@ function buildSubclass(
 /**
  * Lazy implementation of {@link FlexTreeNode}.
  */
-export abstract class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchema>
+export class LazyTreeNode<TSchema extends FlexTreeNodeSchema = FlexTreeNodeSchema>
 	extends LazyEntity<TSchema, Anchor>
 	implements FlexTreeNode
 {
@@ -268,12 +250,6 @@ export class LazyMap<TSchema extends FlexMapNodeSchema>
 		super(context, schema, cursor, anchorNode, anchor);
 	}
 
-	public get size(): number {
-		let fieldCount = 0;
-		forEachField(this[cursorSymbol], () => (fieldCount += 1));
-		return fieldCount;
-	}
-
 	public keys(): IterableIterator<FieldKey> {
 		return mapCursorFields(this[cursorSymbol], (cursor) => cursor.getFieldKey()).values();
 	}
@@ -318,46 +294,10 @@ export class LazyMap<TSchema extends FlexMapNodeSchema>
 		}
 	}
 
-	public has(key: string): boolean {
-		return this.tryGetField(brand(key)) !== undefined;
-	}
-
-	public get(key: string): FlexTreeUnboxField<TSchema["info"]> {
-		return inCursorField(this[cursorSymbol], brand(key), (cursor) =>
-			unboxedField(this.context, this.schema.info, cursor),
-		) as FlexTreeUnboxField<TSchema["info"]>;
-	}
-
 	public override getBoxed(key: string): FlexTreeTypedField<TSchema["info"]> {
 		return super.getBoxed(brand(key)) as FlexTreeTypedField<TSchema["info"]>;
 	}
 
-	public set(key: string, content: FlexibleFieldContent<TSchema["info"]> | undefined): void {
-		const field = this.getBoxed(key);
-		const fieldSchema = this.schema.info;
-
-		if (fieldSchema.kind === FieldKinds.optional) {
-			const optionalField = field as FlexTreeOptionalField<FlexAllowedTypes>;
-			optionalField.content = content;
-		} else {
-			assert(fieldSchema.kind === FieldKinds.sequence, 0x807 /* Unexpected map field kind */);
-
-			// TODO: implement setting of sequence fields once we have defined clear merged semantics for doing so.
-			// For now, we will throw an error, since the public API does not currently expose a way to do this anyways.
-			throw new Error("Setting of sequence values in maps is not yet supported.");
-		}
-	}
-
-	public delete(key: FieldKey): void {
-		// Since all keys implicitly exist under a Map node, and we represent "no value" with `undefined`,
-		// "deleting" a key/value pair is the same as setting the value to `undefined`.
-		this.set(key, undefined);
-	}
-
-	public override boxedIterator(): IterableIterator<FlexTreeTypedField<TSchema["info"]>> {
-		return super.boxedIterator() as IterableIterator<FlexTreeTypedField<TSchema["info"]>>;
-	}
-
 	public [Symbol.iterator](): IterableIterator<
 		[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]
 	> {
@@ -384,65 +324,6 @@ export class LazyLeaf<TSchema extends LeafNodeSchema>
 	}
 }
 
-export class LazyFieldNode<TSchema extends FlexFieldNodeSchema>
-	extends LazyTreeNode<TSchema>
-	implements FlexTreeFieldNode<TSchema>
-{
-	public get content(): FlexTreeUnboxField<TSchema["info"]> {
-		return inCursorField(this[cursorSymbol], EmptyKey, (cursor) =>
-			unboxedField(this.context, this.schema.info, cursor),
-		) as FlexTreeUnboxField<TSchema["info"]>;
-	}
-}
-
-/**
- * {@link reservedObjectNodeFieldPropertyNames} but as a set.
- */
-export const reservedObjectNodeFieldPropertyNameSet: ReadonlySet<string> = new Set(
-	reservedObjectNodeFieldPropertyNames,
-);
-
-export function propertyNameFromFieldKey<T extends string>(
-	key: T,
-): PropertyNameFromFieldKey<T> {
-	if (reservedObjectNodeFieldPropertyNameSet.has(key)) {
-		return `field${capitalize(key)}` as PropertyNameFromFieldKey<T>;
-	}
-	for (const prefix of reservedObjectNodeFieldPropertyNamePrefixes) {
-		if (key.startsWith(prefix)) {
-			const afterPrefix = key.slice(prefix.length);
-			if (afterPrefix === capitalize(afterPrefix)) {
-				return `field${capitalize(key)}` as PropertyNameFromFieldKey<T>;
-			}
-		}
-	}
-	return key as PropertyNameFromFieldKey<T>;
-}
-
-export function buildLazyObjectNode<TSchema extends FlexObjectNodeSchema>(
-	context: Context,
-	schema: TSchema,
-	cursor: ITreeSubscriptionCursor,
-	anchorNode: AnchorNode,
-	anchor: Anchor,
-): LazyTreeNode<TSchema> & FlexTreeObjectNodeTyped<TSchema> {
-	const objectNodeClass = getOrCreate(cachedStructClasses, schema, () =>
-		buildStructClass(schema),
-	);
-	return new objectNodeClass(context, cursor, anchorNode, anchor) as LazyTreeNode<TSchema> &
-		FlexTreeObjectNodeTyped<TSchema>;
-}
-
-const cachedStructClasses = new WeakMap<
-	FlexObjectNodeSchema,
-	new (
-		context: Context,
-		cursor: ITreeSubscriptionCursor,
-		anchorNode: AnchorNode,
-		anchor: Anchor,
-	) => LazyTreeNode<FlexObjectNodeSchema>
->();
-
 function getBoxedField(
 	objectNode: LazyTreeNode,
 	key: FieldKey,
@@ -452,96 +333,3 @@ function getBoxedField(
 		return makeField(objectNode.context, fieldSchema, cursor);
 	});
 }
-
-function buildStructClass<TSchema extends FlexObjectNodeSchema>(
-	schema: TSchema,
-): new (
-	context: Context,
-	cursor: ITreeSubscriptionCursor,
-	anchorNode: AnchorNode,
-	anchor: Anchor,
-) => LazyTreeNode<TSchema> {
-	const propertyDescriptorMap: PropertyDescriptorMap = {};
-
-	for (const [key, fieldSchema] of schema.objectNodeFields) {
-		const escapedKey = propertyNameFromFieldKey(key);
-		let setter: ((newContent: FlexibleNodeContent<FlexAllowedTypes>) => void) | undefined;
-		switch (fieldSchema.kind) {
-			case FieldKinds.optional: {
-				setter = function (
-					this: CustomStruct,
-					newContent: FlexibleNodeContent<FlexAllowedTypes> | undefined,
-				): void {
-					const field = getBoxedField(
-						this,
-						key,
-						fieldSchema,
-					) as FlexTreeOptionalField<FlexAllowedTypes>;
-					field.content = newContent;
-				};
-				break;
-			}
-			case FieldKinds.required: {
-				setter = function (
-					this: CustomStruct,
-					newContent: FlexibleNodeContent<FlexAllowedTypes>,
-				): void {
-					const field = getBoxedField(
-						this,
-						key,
-						fieldSchema,
-					) as FlexTreeRequiredField<FlexAllowedTypes>;
-					field.content = newContent;
-				};
-				break;
-			}
-			default:
-				setter = undefined;
-				break;
-		}
-
-		// Create getter and setter (when appropriate) for property
-		propertyDescriptorMap[escapedKey] = {
-			enumerable: true,
-			get(this: CustomStruct): unknown {
-				return inCursorField(this[cursorSymbol], key, (cursor) =>
-					unboxedField(this.context, fieldSchema, cursor),
-				);
-			},
-			set: setter,
-		};
-
-		// Create set method for property (when appropriate)
-		if (setter !== undefined) {
-			propertyDescriptorMap[`set${capitalize(escapedKey)}`] = {
-				enumerable: false,
-				get(this: CustomStruct) {
-					return setter;
-				},
-			};
-		}
-
-		propertyDescriptorMap[`boxed${capitalize(escapedKey)}`] = {
-			enumerable: false,
-			get(this: CustomStruct) {
-				return getBoxedField(this, key, fieldSchema);
-			},
-		};
-	}
-
-	// This must implement `StructTyped<TSchema>`, but TypeScript can't constrain it to do so.
-	class CustomStruct extends LazyTreeNode<TSchema> {
-		public constructor(
-			context: Context,
-			cursor: ITreeSubscriptionCursor,
-			anchorNode: AnchorNode,
-			anchor: Anchor,
-		) {
-			super(context, schema, cursor, anchorNode, anchor);
-		}
-	}
-
-	Object.defineProperties(CustomStruct.prototype, propertyDescriptorMap);
-
-	return CustomStruct;
-}

package/src/feature-libraries/flex-tree/treeEvents.ts

@@ -28,8 +28,6 @@ import type { PathVisitor, UpPath } from "../../core/index.js";
  * - Add more events.
  * - Have some events (or a way to defer events) until the tree can be read.
  * - Consider removing this and just using AnchorEvents and simple-tree's events (and extending them as needed).
- *
- * @internal
  */
 export interface FlexTreeNodeEvents {
 	/**