@fluidframework/tree 2.2.0 → 2.3.0

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

@@ -8,31 +8,14 @@ export {
 	type FlexTreeNode,
 	type FlexTreeEntity,
 	type FlexTreeTypedField,
-	type FlexibleFieldContent,
-	type FlexibleNodeContent,
-	type FlexTreeLeafNode,
-	type FlexTreeMapNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
-	type FlexTreeObjectNode,
-	type FlexTreeObjectNodeTyped,
-	type AssignableFieldKinds,
-	type FlexTreeTypedNode,
-	type FlexTreeTypedNodeUnion,
-	type CheckTypesOverlap,
 	TreeStatus,
 	type FlexTreeUnknownUnboxed,
-	type FlexTreeUnboxField,
 	flexTreeMarker,
 	FlexTreeEntityKind,
 	isFlexTreeNode,
-	type PropertyNameFromFieldKey,
-	type ReservedObjectNodeFieldPropertyNames,
-	type ReservedObjectNodeFieldPropertyNamePrefixes,
-	reservedObjectNodeFieldPropertyNames,
-	reservedObjectNodeFieldPropertyNamePrefixes,
-	type FlexTreeObjectNodeFieldsInner,
 	flexTreeSlot,
 } from "./flexTreeTypes.js";
 
@@ -44,21 +27,16 @@ export {
 	visitIterableTreeWithState,
 } from "./navigation.js";
 
-export { getTreeContext, type FlexTreeContext, Context, ContextSlot } from "./context.js";
+export {
+	getTreeContext,
+	type FlexTreeContext,
+	type FlexTreeHydratedContext,
+	Context,
+	ContextSlot,
+} from "./context.js";
 
 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 {
 	assertFlexTreeEntityNotFreed,
 	isFreedSymbol,

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

@@ -44,14 +44,14 @@ export function assertFlexTreeEntityNotFreed(entity: FlexTreeEntity): void {
  * This is a base class for lazy (cursor based) UntypedEntity implementations, which uniformly handles cursors and anchors.
  */
 export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
-	implements FlexTreeEntity<TSchema>, IDisposable
+	implements FlexTreeEntity, IDisposable
 {
 	readonly #lazyCursor: ITreeSubscriptionCursor;
 	public readonly [anchorSymbol]: TAnchor;
 
 	protected constructor(
 		public readonly context: Context,
-		public readonly schema: TSchema,
+		public readonly flexSchema: TSchema,
 		cursor: ITreeSubscriptionCursor,
 		anchor: TAnchor,
 	) {
@@ -109,12 +109,3 @@ export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
 	 */
 	protected abstract [forgetAnchorSymbol](): void;
 }
-
-/**
- * Prevent Entities from inheriting members from Object.prototype including:
- * '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__',
- * 'hasOwnProperty', 'isPrototypeOf', 'valueOf', 'propertyIsEnumerable', 'toLocaleString' and 'toString'.
- *
- * This opens up more options for field names on struct nodes.
- */
-Object.setPrototypeOf(LazyEntity.prototype, null);

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

@@ -13,6 +13,7 @@ import {
 	type FieldUpPath,
 	type ITreeCursorSynchronous,
 	type ITreeSubscriptionCursor,
+	type TreeFieldStoredSchema,
 	type TreeNavigationResult,
 	inCursorNode,
 	iterateCursorField,
@@ -26,7 +27,7 @@ import {
 	type ValueFieldEditBuilder,
 } from "../default-schema/index.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
-import type { FlexAllowedTypes, FlexFieldSchema } from "../typed-schema/index.js";
+import type { FlexFieldSchema } from "../typed-schema/index.js";
 
 import type { Context } from "./context.js";
 import {
@@ -37,8 +38,7 @@ import {
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
 	type FlexTreeTypedField,
-	type FlexTreeTypedNodeUnion,
-	type FlexTreeUnboxNodeUnion,
+	type FlexTreeUnknownUnboxed,
 	TreeStatus,
 	flexTreeMarker,
 	flexTreeSlot,
@@ -52,7 +52,7 @@ import {
 	tryMoveCursorToAnchorSymbol,
 } from "./lazyEntity.js";
 import { type LazyTreeNode, makeTree } from "./lazyNode.js";
-import { unboxedUnion } from "./unboxed.js";
+import { unboxedFlexNode } from "./unboxed.js";
 import { indexForAt, treeStatusFromAnchorCache } from "./utilities.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { cursorForMapTreeField, cursorForMapTreeNode } from "../mapTreeCursor.js";
@@ -125,11 +125,8 @@ export function makeField(
 /**
  * Base type for fields implementing {@link FlexTreeField} using cursors.
  */
-export abstract class LazyField<
-		out TKind extends FlexFieldKind,
-		TTypes extends FlexAllowedTypes,
-	>
-	extends LazyEntity<FlexFieldSchema<TKind, TTypes>, FieldAnchor>
+export abstract class LazyField<out TKind extends FlexFieldKind>
+	extends LazyEntity<FlexFieldSchema<TKind>, FieldAnchor>
 	implements FlexTreeField
 {
 	public get [flexTreeMarker](): FlexTreeEntityKind.Field {
@@ -137,6 +134,10 @@ export abstract class LazyField<
 	}
 	public readonly key: FieldKey;
 
+	public get schema(): TreeFieldStoredSchema {
+		return this.flexSchema.stored;
+	}
+
 	/**
 	 * If this field ends its lifetime before the Anchor does, this needs to be invoked to avoid a double free
 	 * if/when the Anchor is destroyed.
@@ -145,7 +146,7 @@ export abstract class LazyField<
 
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<TKind, TTypes>,
+		schema: FlexFieldSchema<TKind>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -164,15 +165,13 @@ export abstract class LazyField<
 		}
 	}
 
-	public is<TSchema extends FlexFieldSchema>(
-		schema: TSchema,
-	): this is FlexTreeTypedField<TSchema> {
+	public is<TKind2 extends FlexFieldKind>(kind: TKind2): this is FlexTreeTypedField<TKind2> {
 		assert(
-			this.context.schema.policy.fieldKinds.get(schema.kind.identifier) === schema.kind,
-			0x77c /* Narrowing must be done to a kind that exists in this context */,
+			this.context.flexSchema.policy.fieldKinds.get(kind.identifier) === kind,
+			0xa26 /* Narrowing must be done to a kind that exists in this context */,
 		);
 
-		return this.schema.equals(schema);
+		return this.flexSchema.kind === (kind as unknown);
 	}
 
 	public get parent(): FlexTreeNode | undefined {
@@ -203,13 +202,13 @@ export abstract class LazyField<
 		return this[cursorSymbol].getFieldLength();
 	}
 
-	public atIndex(index: number): FlexTreeUnboxNodeUnion<TTypes> {
+	public atIndex(index: number): FlexTreeUnknownUnboxed {
 		return inCursorNode(this[cursorSymbol], index, (cursor) =>
-			unboxedUnion(this.context, this.schema, cursor),
+			unboxedFlexNode(this.context, cursor),
 		);
 	}
 
-	public boxedAt(index: number): FlexTreeTypedNodeUnion<TTypes> | undefined {
+	public boxedAt(index: number): FlexTreeNode | undefined {
 		const finalIndex = indexForAt(index, this.length);
 
 		if (finalIndex === undefined) {
@@ -218,29 +217,20 @@ export abstract class LazyField<
 
 		return inCursorNode(this[cursorSymbol], finalIndex, (cursor) =>
 			makeTree(this.context, cursor),
-		) as unknown as FlexTreeTypedNodeUnion<TTypes>;
+		);
 	}
 
-	public map<U>(callbackfn: (value: FlexTreeUnboxNodeUnion<TTypes>, index: number) => U): U[] {
+	public map<U>(callbackfn: (value: FlexTreeUnknownUnboxed, index: number) => U): U[] {
 		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<FlexTreeNode> {
+		return iterateCursorField(this[cursorSymbol], (cursor) => makeTree(this.context, cursor));
 	}
 
-	public boxedIterator(): IterableIterator<FlexTreeTypedNodeUnion<TTypes>> {
-		return iterateCursorField(
-			this[cursorSymbol],
-			(cursor) => makeTree(this.context, cursor) as unknown as FlexTreeTypedNodeUnion<TTypes>,
-		);
-	}
-
-	public [Symbol.iterator](): IterableIterator<FlexTreeUnboxNodeUnion<TTypes>> {
+	public [Symbol.iterator](): IterableIterator<FlexTreeUnknownUnboxed> {
 		return iterateCursorField(this[cursorSymbol], (cursor) =>
-			unboxedUnion(this.context, this.schema, cursor),
+			unboxedFlexNode(this.context, cursor),
 		);
 	}
 
@@ -269,20 +259,20 @@ export abstract class LazyField<
 	}
 }
 
-export class LazySequence<TTypes extends FlexAllowedTypes>
-	extends LazyField<typeof FieldKinds.sequence, TTypes>
-	implements FlexTreeSequenceField<TTypes>
+export class LazySequence
+	extends LazyField<typeof FieldKinds.sequence>
+	implements FlexTreeSequenceField
 {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.sequence, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.sequence>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
 		super(context, schema, cursor, fieldAnchor);
 	}
 
-	public at(index: number): FlexTreeUnboxNodeUnion<TTypes> | undefined {
+	public at(index: number): FlexTreeUnknownUnboxed | undefined {
 		const finalIndex = indexForAt(index, this.length);
 
 		if (finalIndex === undefined) {
@@ -290,10 +280,10 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 		}
 
 		return inCursorNode(this[cursorSymbol], finalIndex, (cursor) =>
-			unboxedUnion(this.context, this.schema, cursor),
+			unboxedFlexNode(this.context, cursor),
 		);
 	}
-	public get asArray(): readonly FlexTreeUnboxNodeUnion<TTypes>[] {
+	public get asArray(): readonly FlexTreeUnknownUnboxed[] {
 		return this.map((x) => x);
 	}
 
@@ -312,13 +302,13 @@ export class LazySequence<TTypes extends FlexAllowedTypes>
 	}
 }
 
-export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
-	extends LazyField<typeof FieldKinds.required, TTypes>
-	implements FlexTreeRequiredField<TTypes>
+export class ReadonlyLazyValueField
+	extends LazyField<typeof FieldKinds.required>
+	implements FlexTreeRequiredField
 {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.required>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -331,18 +321,15 @@ export class ReadonlyLazyValueField<TTypes extends FlexAllowedTypes>
 		},
 	};
 
-	public get content(): FlexTreeUnboxNodeUnion<TTypes> {
+	public get content(): FlexTreeUnknownUnboxed {
 		return this.atIndex(0);
 	}
 }
 
-export class LazyValueField<TTypes extends FlexAllowedTypes>
-	extends ReadonlyLazyValueField<TTypes>
-	implements FlexTreeRequiredField<TTypes>
-{
+export class LazyValueField extends ReadonlyLazyValueField implements FlexTreeRequiredField {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.required>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -361,32 +348,18 @@ export class LazyValueField<TTypes extends FlexAllowedTypes>
 		return fieldEditor;
 	}
 
-	public override get content(): FlexTreeUnboxNodeUnion<TTypes> {
+	public override get content(): FlexTreeUnknownUnboxed {
 		return this.atIndex(0);
 	}
 }
 
-export class LazyIdentifierField<TTypes extends FlexAllowedTypes>
-	extends ReadonlyLazyValueField<TTypes>
-	implements FlexTreeRequiredField<TTypes>
-{
-	public constructor(
-		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.required, TTypes>,
-		cursor: ITreeSubscriptionCursor,
-		fieldAnchor: FieldAnchor,
-	) {
-		super(context, schema, cursor, fieldAnchor);
-	}
-}
-
-export class LazyOptionalField<TTypes extends FlexAllowedTypes>
-	extends LazyField<typeof FieldKinds.optional, TTypes>
-	implements FlexTreeOptionalField<TTypes>
+export class LazyOptionalField
+	extends LazyField<typeof FieldKinds.optional>
+	implements FlexTreeOptionalField
 {
 	public constructor(
 		context: Context,
-		schema: FlexFieldSchema<typeof FieldKinds.optional, TTypes>,
+		schema: FlexFieldSchema<typeof FieldKinds.optional>,
 		cursor: ITreeSubscriptionCursor,
 		fieldAnchor: FieldAnchor,
 	) {
@@ -408,33 +381,30 @@ export class LazyOptionalField<TTypes extends FlexAllowedTypes>
 		return fieldEditor;
 	}
 
-	public get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined {
+	public get content(): FlexTreeUnknownUnboxed | undefined {
 		return this.length === 0 ? undefined : this.atIndex(0);
 	}
 }
 
-export class LazyForbiddenField<TTypes extends FlexAllowedTypes> extends LazyField<
-	typeof FieldKinds.forbidden,
-	TTypes
-> {}
+export class LazyForbiddenField extends LazyField<typeof FieldKinds.forbidden> {}
 
-type Builder = new <TTypes extends FlexAllowedTypes>(
+type Builder = new (
 	context: Context,
 	// Correct use of these builders requires the builder of the matching type to be used.
 	// Since this has to be done at runtime anyway, trying to use safer typing than `any` here (such as `never`, which is only slightly safer)
 	// does not seem worth it (ends up requiring type casts that are just as unsafe).
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	schema: FlexFieldSchema<any, TTypes>,
+	schema: FlexFieldSchema<any>,
 	cursor: ITreeSubscriptionCursor,
 	fieldAnchor: FieldAnchor,
-) => LazyField<FlexFieldKind, TTypes>;
+) => LazyField<FlexFieldKind>;
 
 const builderList: [FlexFieldKind, Builder][] = [
 	[FieldKinds.forbidden, LazyForbiddenField],
 	[FieldKinds.optional, LazyOptionalField],
 	[FieldKinds.sequence, LazySequence],
 	[FieldKinds.required, LazyValueField],
-	[FieldKinds.identifier, LazyIdentifierField],
+	[FieldKinds.identifier, LazyValueField],
 ];
 
 const kindToClass: ReadonlyMap<FlexFieldKind, Builder> = new Map(builderList);