@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/src/feature-libraries/typed-schema/typedTreeSchema.ts

@@ -3,33 +3,35 @@
  * Licensed under the MIT License.
  */
 
-import { Lazy, assert } from "@fluidframework/core-utils";
+import { assert, Lazy } from "@fluidframework/core-utils/internal";
+
 import {
 	Adapters,
 	EmptyKey,
 	FieldKey,
-	TreeNodeStoredSchema,
+	LeafNodeStoredSchema,
+	MapNodeStoredSchema,
+	ObjectNodeStoredSchema,
+	StoredSchemaCollection,
 	TreeFieldStoredSchema,
 	TreeNodeSchemaIdentifier,
+	TreeNodeStoredSchema,
+	TreeStoredSchema,
 	TreeTypeSet,
 	ValueSchema,
-	TreeStoredSchema,
-	StoredSchemaCollection,
-	MapNodeStoredSchema,
-	LeafNodeStoredSchema,
-	ObjectNodeStoredSchema,
 } from "../../core/index.js";
 import {
+	Assume,
 	MakeNominal,
 	Named,
-	requireAssignableTo,
 	compareSets,
-	oneFromSet,
-	Assume,
 	mapIterable,
+	oneFromSet,
+	requireAssignableTo,
 } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
 import { FlexFieldKind, FullSchemaPolicy } from "../modular-schema/index.js";
+
 import { LazyItem } from "./flexList.js";
 import { ObjectToMap, objectToMapTyped } from "./typeUtils.js";
 
@@ -53,7 +55,7 @@ export type NormalizeObjectNodeFields<T extends FlexObjectNodeFields> = {
  * These extends constraints only serve as documentation:
  * to avoid breaking compilation, this type has to not actually enforce anything, and thus is just `unknown`.
  * Therefore the type safety is the responsibility of the user of the API.
- * @beta
+ * @public
  */
 export type Unenforced<_DesiredExtendsConstraint> = unknown;
 
@@ -102,7 +104,7 @@ export class FlexMapNodeSchema<
 			builder,
 			name,
 			specification,
-			new MapNodeStoredSchema(specification),
+			new MapNodeStoredSchema(specification.stored),
 		);
 	}
 
@@ -185,7 +187,8 @@ export class FlexObjectNodeSchema<
 		// Stricter typing caused Specification to no longer be covariant, so has been removed.
 		public readonly objectNodeFields: ReadonlyMap<FieldKey, FlexFieldSchema>,
 	) {
-		super(builder, name, info, new ObjectNodeStoredSchema(objectNodeFields));
+		const fields = mapIterable(objectNodeFields, ([k, v]) => [k, v.stored] as const);
+		super(builder, name, info, new ObjectNodeStoredSchema(new Map(fields)));
 	}
 
 	public override getFieldSchema(field: FieldKey): FlexFieldSchema {
@@ -215,7 +218,7 @@ export class FlexFieldNodeSchema<
 		name: TreeNodeSchemaIdentifier<Name>,
 		info: Specification,
 	) {
-		const objectNodeFields = new Map([[EmptyKey, info as FlexFieldSchema]]);
+		const objectNodeFields = new Map([[EmptyKey, (info as FlexFieldSchema).stored]]);
 		super(builder, name, info, new ObjectNodeStoredSchema(objectNodeFields));
 	}
 
@@ -328,8 +331,7 @@ export type FlexMapFieldSchema = FlexFieldSchema<
 export class FlexFieldSchema<
 	out TKind extends FlexFieldKind = FlexFieldKind,
 	const out TTypes extends Unenforced<FlexAllowedTypes> = FlexAllowedTypes,
-> implements TreeFieldStoredSchema
-{
+> {
 	/**
 	 * Schema for a field which must always be empty.
 	 */
@@ -392,7 +394,8 @@ export class FlexFieldSchema<
 				);
 			}
 		}
-		this.lazyTypes = new Lazy(() => {
+
+		const lazy = new Lazy(() => {
 			const input = this.allowedTypes as unknown as FlexAllowedTypes;
 			const schema = allowedTypesSchemaSet(input);
 			return {
@@ -401,8 +404,19 @@ export class FlexFieldSchema<
 				monomorphicChildType: schema !== Any ? oneFromSet(schema) : undefined,
 			};
 		});
+
+		this.lazyTypes = lazy;
+
+		this.stored = {
+			kind: this.kind.identifier,
+			get types() {
+				return lazy.value.names;
+			},
+		};
 	}
 
+	public readonly stored: TreeFieldStoredSchema;
+
 	/**
 	 * Types which are allowed in this field (by {@link TreeNodeSchemaIdentifier}), in a format optimized for stored schema.
 	 * This is the same set of types in {@link FlexFieldSchema.allowedTypes}, just in a different format.
@@ -533,7 +547,7 @@ export interface FlexTreeSchema<out T extends FlexFieldSchema = FlexFieldSchema>
  */
 export function intoStoredSchema(treeSchema: FlexTreeSchema): TreeStoredSchema {
 	return {
-		rootFieldSchema: treeSchema.rootFieldSchema,
+		rootFieldSchema: treeSchema.rootFieldSchema.stored,
 		...intoStoredSchemaCollection(treeSchema),
 	};
 }

package/src/feature-libraries/typed-schema/view.ts

@@ -3,17 +3,18 @@
  * Licensed under the MIT License.
  */
 
-import { Named, fail } from "../../util/index.js";
 import {
+	AdaptedViewSchema,
+	Adapters,
+	Compatibility,
 	TreeFieldStoredSchema,
-	TreeNodeStoredSchema,
 	TreeNodeSchemaIdentifier,
+	TreeNodeStoredSchema,
 	TreeStoredSchema,
-	Adapters,
-	AdaptedViewSchema,
-	Compatibility,
 } from "../../core/index.js";
+import { Named, fail } from "../../util/index.js";
 import { FullSchemaPolicy, allowsRepoSuperset, isNeverTree } from "../modular-schema/index.js";
+
 import { FlexFieldSchema, FlexTreeSchema, intoStoredSchema } from "./typedTreeSchema.js";
 
 /**

package/src/feature-libraries/valueUtilities.ts

@@ -3,9 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils";
 import { IFluidHandle } from "@fluidframework/core-interfaces";
-import { Value, ValueSchema, TreeValue } from "../core/index.js";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+
+import { TreeValue, Value, ValueSchema } from "../core/index.js";
 
 export function allowsValue(schema: ValueSchema | undefined, nodeValue: Value): boolean {
 	if (schema === undefined) {
@@ -75,19 +76,20 @@ export function isFluidHandle(value: unknown): value is IFluidHandle {
 
 export function assertAllowedValue(
 	value: undefined | FluidSerializableReadOnly,
-): asserts value is Value {
-	assert(isAllowedValue(value), 0x843 /* invalid value */);
+): asserts value is TreeValue {
+	assert(isTreeValue(value), 0x843 /* invalid value */);
 }
 
-export function isAllowedValue(value: undefined | FluidSerializableReadOnly): value is Value {
-	switch (typeof value) {
+/**
+ * Checks if a value is a {@link TreeValue}.
+ */
+export function isTreeValue(nodeValue: unknown): nodeValue is TreeValue {
+	switch (typeof nodeValue) {
 		case "string":
 		case "number":
 		case "boolean":
 			return true;
-		case "object":
-			return value === null || isFluidHandle(value);
 		default:
-			return false;
+			return nodeValue === null || isFluidHandle(nodeValue);
 	}
 }

package/src/index.ts

@@ -76,19 +76,24 @@ export {
 	UpPathDefault,
 	AnchorEvents,
 	AnchorSetRootEvents,
-	FieldKindSpecifier,
+	FieldKindData,
 	AllowedUpdateType,
 	PathVisitor,
 	Adapters,
 	TreeAdapter,
 	MapTree,
 	Revertible,
-	RevertibleKind,
+	CommitKind,
 	RevertibleStatus,
-	RevertibleResult,
+	CommitMetadata,
 	forbiddenFieldKindIdentifier,
 	StoredSchemaCollection,
 	ErasedTreeNodeSchemaDataFormat,
+	ObjectNodeStoredSchema,
+	MapNodeStoredSchema,
+	LeafNodeStoredSchema,
+	Multiplicity,
+	SchemaPolicy,
 } from "./core/index.js";
 
 export {
@@ -128,7 +133,6 @@ export { leaf } from "./domains/index.js";
 
 export {
 	FlexFieldKind,
-	Multiplicity,
 	isNeverField,
 	FullSchemaPolicy,
 	typeNameSymbol,
@@ -152,7 +156,7 @@ export {
 	stackTreeNodeCursor,
 	CursorAdapter,
 	CursorWithNode,
-	EditableTreeEvents,
+	FlexTreeNodeEvents,
 	ArrayLikeMut,
 	FieldKinds,
 	ContextuallyTypedFieldData,
@@ -207,7 +211,6 @@ export {
 	schemaIsObjectNode,
 	AllowedTypeSet,
 	SchemaBuilderOptions,
-	TreeEvent,
 	SchemaCollection,
 	TreeCompressionStrategy,
 	treeSchemaFromStoredSchema,
@@ -222,7 +225,6 @@ export {
 	NormalizeFieldSchema,
 	FlexObjectNodeFields,
 	FlexMapFieldSchema,
-	ArrayToUnion,
 	ExtractItemType,
 	LazyItem,
 	PropertyNameFromFieldKey,
@@ -253,8 +255,13 @@ export {
 	buildTreeConfiguration,
 	ISharedTreeEditor,
 	ISchemaEditor,
+	RevertibleFactory,
+	SharedTreeFormatOptions,
+	SharedTreeFormatVersion,
 	Tree,
 	TreeApi,
+	TransactionConstraint,
+	NodeInDocumentConstraint,
 } from "./shared-tree/index.js";
 
 export {
@@ -273,7 +280,7 @@ export {
 	TreeNodeApi,
 	ImplicitFieldSchema,
 	TreeFieldFromImplicitField,
-	TreeNodeEvents,
+	TreeChangeEvents,
 	NodeFromSchema,
 	TreeMapNode,
 	InsertableTreeNodeFromImplicitAllowedTypes,
@@ -291,27 +298,29 @@ export {
 	NodeBuilderData,
 	NodeKind,
 	ObjectFromSchemaRecord,
+	TreeObjectNode,
 	TreeNodeFromImplicitAllowedTypes,
 	TreeNodeSchemaClass,
 	TreeNodeSchemaCore,
 	TreeNodeSchemaNonClass,
 	SchemaIncompatible,
+	type FieldProps,
 
-	// experimental @beta APIs:
-	SchemaFactoryRecursive,
-	ValidateRecursiveSchema,
-	ObjectFromSchemaRecordUnsafe,
-	TreeFieldFromImplicitFieldUnsafe,
-	TreeNodeFromImplicitAllowedTypesUnsafe,
-	FieldSchemaUnsafe,
-	InsertableTreeNodeFromImplicitAllowedTypesUnsafe,
-	TreeArrayNodeUnsafe,
-	TreeMapNodeUnsafe,
-	InsertableObjectFromSchemaRecordUnsafe,
-	InsertableTreeFieldFromImplicitFieldUnsafe,
-	InsertableTypedNodeUnsafe,
-	NodeBuilderDataUnsafe,
-	NodeFromSchemaUnsafe,
+	// Recursive Schema APIs
+	type ValidateRecursiveSchema,
+	type ObjectFromSchemaRecordUnsafe,
+	type TreeObjectNodeUnsafe,
+	type TreeFieldFromImplicitFieldUnsafe,
+	type TreeNodeFromImplicitAllowedTypesUnsafe,
+	type FieldSchemaUnsafe,
+	type InsertableTreeNodeFromImplicitAllowedTypesUnsafe,
+	type TreeArrayNodeUnsafe,
+	type TreeMapNodeUnsafe,
+	type InsertableObjectFromSchemaRecordUnsafe,
+	type InsertableTreeFieldFromImplicitFieldUnsafe,
+	type InsertableTypedNodeUnsafe,
+	type NodeBuilderDataUnsafe,
+	type NodeFromSchemaUnsafe,
 
 	// experimental @internal APIs:
 	adaptEnum,
@@ -324,7 +333,7 @@ export {
 	test_RecursiveObject_base,
 	test_RecursiveObjectPojoMode,
 } from "./simple-tree/index.js";
-export { SharedTree, TreeFactory } from "./treeFactory.js";
+export { SharedTree, configuredSharedTree } from "./treeFactory.js";
 
 export type { ICodecOptions, JsonValidator, SchemaValidationFunction } from "./codec/index.js";
 export { noopValidator } from "./codec/index.js";
@@ -347,8 +356,6 @@ export {
 	AllowOptionalNotFlattened,
 	isAny,
 	BrandedKeyContent,
-	ErasedType,
-	Erased,
 	RestrictiveReadonlyRecord,
 	MakeNominal,
 } from "./util/index.js";
@@ -380,6 +387,7 @@ export {
 	Required,
 	Optional,
 	NodeKeyFieldKind,
+	Identifier,
 	Forbidden,
 	Sequence,
 } from "./feature-libraries/index.js";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.0.0-rc.2.0.2";
+export const pkgVersion = "2.0.0-rc.3.0.0";

package/src/shared-tree/index.ts

@@ -10,6 +10,8 @@ export {
 	SharedTree,
 	ForestType,
 	SharedTreeContentSnapshot,
+	SharedTreeFormatOptions,
+	SharedTreeFormatVersion,
 } from "./sharedTree.js";
 
 export {
@@ -20,6 +22,7 @@ export {
 	CheckoutEvents,
 	ITransaction,
 	ITreeCheckoutFork,
+	RevertibleFactory,
 } from "./treeCheckout.js";
 
 export {
@@ -34,4 +37,9 @@ export { FlexTreeView, CheckoutFlexTreeView, ITreeViewFork } from "./treeView.js
 
 export { ISharedTreeEditor, ISchemaEditor } from "./sharedTreeEditBuilder.js";
 
-export { treeApi as Tree, TreeApi } from "./treeApi.js";
+export {
+	treeApi as Tree,
+	TreeApi,
+	TransactionConstraint,
+	NodeInDocumentConstraint,
+} from "./treeApi.js";

package/src/shared-tree/schematizeTree.ts

@@ -3,27 +3,29 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+
 import {
 	AllowedUpdateType,
 	Compatibility,
-	TreeStoredSchema,
 	ITreeCursorSynchronous,
-	schemaDataIsEmpty,
+	TreeStoredSchema,
 	rootFieldKey,
+	schemaDataIsEmpty,
 } from "../core/index.js";
 import {
-	defaultSchemaPolicy,
 	FieldKinds,
-	allowsRepoSuperset,
-	FlexTreeSchema,
 	FlexFieldSchema,
-	ViewSchema,
+	FlexTreeSchema,
 	InsertableFlexField,
+	ViewSchema,
+	allowsRepoSuperset,
+	defaultSchemaPolicy,
 	intoStoredSchema,
 	normalizeNewFieldContent,
 } from "../feature-libraries/index.js";
 import { fail } from "../util/index.js";
+
 import { ITreeCheckout } from "./treeCheckout.js";
 
 /**
@@ -53,7 +55,7 @@ export function initializeContent(
 
 	const schema = intoStoredSchema(newSchema);
 	const rootSchema = schema.rootFieldSchema;
-	const rootKind = rootSchema.kind.identifier;
+	const rootKind = rootSchema.kind;
 
 	// To keep the data in schema during the update, first define a schema that tolerates the current (empty) tree as well as the final (initial) tree.
 	let incrementalSchemaUpdate: TreeStoredSchema;
@@ -69,7 +71,7 @@ export function initializeContent(
 		incrementalSchemaUpdate = {
 			nodeSchema: schema.nodeSchema,
 			rootFieldSchema: {
-				kind: FieldKinds.optional,
+				kind: FieldKinds.optional.identifier,
 				types: rootSchema.types,
 			},
 		};
@@ -205,7 +207,7 @@ export function ensureSchema(
 					treeContent.schema.rootFieldSchema,
 					treeContent.initialTree,
 				);
-				switch (checkout.storedSchema.rootFieldSchema.kind.identifier) {
+				switch (checkout.storedSchema.rootFieldSchema.kind) {
 					case FieldKinds.optional.identifier: {
 						const fieldEditor = checkout.editor.optionalField(field);
 						assert(

package/src/shared-tree/schematizingTreeView.ts

@@ -2,27 +2,36 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert, unreachableCase } from "@fluidframework/core-utils";
-import { UsageError } from "@fluidframework/telemetry-utils";
-import { FieldKey, AllowedUpdateType, anchorSlot, Compatibility } from "../core/index.js";
+
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { AllowedUpdateType, Compatibility, FieldKey } from "../core/index.js";
+import { HasListeners, IEmitter, ISubscribable, createEmitter } from "../events/index.js";
 import {
-	defaultSchemaPolicy,
 	FlexFieldSchema,
-	ViewSchema,
 	NodeKeyManager,
+	ViewSchema,
+	defaultSchemaPolicy,
+	ContextSlot,
 } from "../feature-libraries/index.js";
-import { HasListeners, IEmitter, ISubscribable, createEmitter } from "../events/index.js";
-import { disposeSymbol } from "../util/index.js";
 import {
-	TreeConfiguration,
-	toFlexConfig,
+	FieldSchema,
 	ImplicitFieldSchema,
+	InsertableTreeFieldFromImplicitField,
+	SchemaIncompatible,
+	TreeConfiguration,
 	TreeFieldFromImplicitField,
 	TreeView,
 	TreeViewEvents,
 	getProxyForField,
-	SchemaIncompatible,
+	toFlexConfig,
+	setField,
+	normalizeFieldSchema,
+	InsertableContent,
 } from "../simple-tree/index.js";
+import { disposeSymbol } from "../util/index.js";
+
 import { TreeContent, UpdateType, ensureSchema, evaluateUpdate } from "./schematizeTree.js";
 import { TreeCheckout } from "./treeCheckout.js";
 import { CheckoutFlexTreeView } from "./treeView.js";
@@ -31,7 +40,7 @@ import { CheckoutFlexTreeView } from "./treeView.js";
  * Implementation of TreeView wrapping a FlexTreeView.
  */
 export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitFieldSchema>
-	implements TreeView<TreeFieldFromImplicitField<TRootSchema>>
+	implements TreeView<TRootSchema>
 {
 	/**
 	 * In one of three states:
@@ -47,17 +56,27 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 
 	private readonly viewSchema: ViewSchema;
 
+	private readonly unregisterCallbacks = new Set<() => void>();
 	private disposed = false;
 
+	private readonly rootFieldSchema: FieldSchema;
+
 	public constructor(
 		public readonly checkout: TreeCheckout,
 		public readonly config: TreeConfiguration<TRootSchema>,
 		public readonly nodeKeyManager: NodeKeyManager,
 		public readonly nodeKeyFieldKey: FieldKey,
 	) {
+		this.rootFieldSchema = normalizeFieldSchema(config.schema);
 		this.flexConfig = toFlexConfig(config);
 		this.viewSchema = new ViewSchema(defaultSchemaPolicy, {}, this.flexConfig.schema);
 		this.update();
+
+		this.unregisterCallbacks.add(
+			this.checkout.events.on("commitApplied", (data, getRevertible) =>
+				this.events.emit("commitApplied", data, getRevertible),
+			),
+		);
 	}
 
 	public upgradeSchema(): void {
@@ -155,8 +174,10 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 				this.view = new SchematizeError(compatibility);
 				const unregister = this.checkout.storedSchema.on("afterSchemaChange", () => {
 					unregister();
+					this.unregisterCallbacks.delete(unregister);
 					this.update();
 				});
+				this.unregisterCallbacks.add(unregister);
 				break;
 			}
 			default: {
@@ -170,6 +191,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		if (this.view !== undefined && !(this.view instanceof SchematizeError)) {
 			this.view[disposeSymbol]();
 			this.view = undefined;
+			this.unregisterCallbacks.forEach((unregister) => unregister());
 		}
 	}
 
@@ -193,6 +215,17 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		}
 		return getProxyForField(view.flexTree) as TreeFieldFromImplicitField<TRootSchema>;
 	}
+
+	public set root(newRoot: InsertableTreeFieldFromImplicitField<TRootSchema>) {
+		const view = this.getViewOrError();
+		if (view instanceof SchematizeError) {
+			throw new UsageError(
+				"Document is out of schema. Check TreeView.error before accessing TreeView.root.",
+			);
+		}
+
+		setField(view.context.root, this.rootFieldSchema, newRoot as InsertableContent);
+	}
 }
 
 export class SchematizeError implements SchemaIncompatible {
@@ -210,15 +243,6 @@ export class SchematizeError implements SchemaIncompatible {
 	}
 }
 
-/**
- * Creating multiple flex tree contexts for the same branch, and thus with the same underlying AnchorSet does not work due to how TreeNode caching works.
- * This slot is used to detect if one already exists and error if creating a second.
- *
- * TODO:
- * 1. API docs need to reflect this limitation or the limitation has to be removed.
- */
-const ViewSlot = anchorSlot<CheckoutFlexTreeView<any>>();
-
 /**
  * Flex-Tree schematizing layer.
  * Creates a view that self-disposes when stored schema becomes incompatible.
@@ -232,7 +256,7 @@ export function requireSchema<TRoot extends FlexFieldSchema>(
 	nodeKeyFieldKey: FieldKey,
 ): CheckoutFlexTreeView<TRoot> {
 	const slots = checkout.forest.anchors.slots;
-	assert(!slots.has(ViewSlot), 0x8c2 /* Cannot create second view from checkout */);
+	assert(!slots.has(ContextSlot), 0x8c2 /* Cannot create second view from checkout */);
 
 	{
 		const compatibility = viewSchema.checkCompatibility(checkout.storedSchema);
@@ -248,14 +272,9 @@ export function requireSchema<TRoot extends FlexFieldSchema>(
 		viewSchema.schema,
 		nodeKeyManager,
 		nodeKeyFieldKey,
-		() => {
-			const deleted = slots.delete(ViewSlot);
-			assert(deleted, 0x8c4 /* unexpected dispose */);
-			onDispose();
-		},
+		onDispose,
 	);
-	assert(!slots.has(ViewSlot), 0x8c5 /* Cannot create second view from checkout */);
-	slots.set(ViewSlot, view);
+	assert(slots.has(ContextSlot), 0x90d /* Context should be tracked in slot */);
 
 	const unregister = checkout.storedSchema.on("afterSchemaChange", () => {
 		const compatibility = viewSchema.checkCompatibility(checkout.storedSchema);