@fluidframework/tree 2.20.0 → 2.22.0

package/src/simple-tree/api/schemaFactory.ts

@@ -171,6 +171,141 @@ export type ScopedSchemaName<
 > = TScope extends undefined ? `${TName}` : `${TScope}.${TName}`;
 // > = `${TScope extends undefined ? "" : `${TScope}.`}${TName}`;
 
+/**
+ * Stateless APIs exposed via {@link SchemaFactory} as both instance properties and as statics.
+ * @privateRemarks
+ * We have no way to make linkable members which exist both as statics and instance properties since API-Extractor does not support this.
+ * As a workaround, we have this type as a third place which can be linked.
+ * @system @sealed @public
+ */
+export const schemaStatics = {
+	/**
+	 * {@link TreeNodeSchema} for holding a JavaScript `string`.
+	 *
+	 * @remarks
+	 * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.
+	 *
+	 * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.
+	 * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.
+	 * @privateRemarks
+	 * TODO:
+	 * We should be much more clear about what happens if you use problematic values.
+	 * We should validate and/or normalize them when inserting content.
+	 */
+	string: stringSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for holding a JavaScript `number`.
+	 *
+	 * @remarks
+	 * The number is a {@link https://en.wikipedia.org/wiki/Double-precision_floating-point_format | double-precision 64-bit binary format IEEE 754} value, however there are some exceptions:
+	 * - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).
+	 * - `-0` may be converted to `0` in some cases.
+	 *
+	 * These limitations match the limitations of JSON.
+	 * @privateRemarks
+	 * TODO:
+	 * We should be much more clear about what happens if you use problematic values.
+	 * We should validate and/or normalize them when inserting content.
+	 */
+	number: numberSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for holding a boolean.
+	 */
+	boolean: booleanSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for JavaScript `null`.
+	 *
+	 * @remarks
+	 * There are good {@link https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null | reasons to avoid using null} in JavaScript, however sometimes it is desired.
+	 * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.
+	 * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.
+	 */
+	null: nullSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.
+	 */
+	handle: handleSchema,
+
+	/**
+	 * {@link AllowedTypes} for holding any of the leaf types.
+	 */
+	leaves: [stringSchema, numberSchema, booleanSchema, nullSchema, handleSchema],
+
+	/**
+	 * Make a field optional instead of the default, which is required.
+	 *
+	 * @param t - The types allowed under the field.
+	 * @param props - Optional properties to associate with the field.
+	 *
+	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+	 * See {@link FieldSchemaMetadata.custom}.
+	 */
+	optional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
+		t: T,
+		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
+	): FieldSchema<FieldKind.Optional, T, TCustomMetadata> => {
+		const defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => {
+			return undefined;
+		});
+		return createFieldSchema(FieldKind.Optional, t, {
+			defaultProvider: defaultOptionalProvider,
+			...props,
+		});
+	},
+
+	/**
+	 * Make a field explicitly required.
+	 *
+	 * @param t - The types allowed under the field.
+	 * @param props - Optional properties to associate with the field.
+	 *
+	 * @remarks
+	 * Fields are required by default, but this API can be used to make the required nature explicit in the schema,
+	 * and allows associating custom {@link FieldProps | properties} with the field.
+	 *
+	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+	 * See {@link FieldSchemaMetadata.custom}.
+	 */
+	required: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
+		t: T,
+		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
+	): FieldSchema<FieldKind.Required, T, TCustomMetadata> => {
+		return createFieldSchema(FieldKind.Required, t, props);
+	},
+
+	/**
+	 * {@link schemaStatics.optional} except tweaked to work better for recursive types.
+	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
+	 * @remarks
+	 * This version of {@link schemaStatics.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
+	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 */
+	optionalRecursive: <const T extends Unenforced<ImplicitAllowedTypes>>(
+		t: T,
+		props?: Omit<FieldProps, "defaultProvider">,
+	): FieldSchemaUnsafe<FieldKind.Optional, T> => {
+		return createFieldSchemaUnsafe(FieldKind.Optional, t, props);
+	},
+
+	/**
+	 * {@link schemaStatics.required} except tweaked to work better for recursive types.
+	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
+	 * @remarks
+	 * This version of {@link schemaStatics.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
+	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 */
+	requiredRecursive: <const T extends Unenforced<ImplicitAllowedTypes>>(
+		t: T,
+		props?: Omit<FieldProps, "defaultProvider">,
+	): FieldSchemaUnsafe<FieldKind.Required, T> => {
+		return createFieldSchemaUnsafe(FieldKind.Required, t, props);
+	},
+} as const;
+
 // TODO:
 // SchemaFactory.array references should link to the correct overloads, however the syntax for this does not seems to work currently for methods unless the they are not qualified with the class.
 // API-Extractor requires such links to be qualified with the class, so it can't work.
@@ -263,6 +398,8 @@ export type ScopedSchemaName<
  *
  * Note: the comparison between the customizable and POJO modes is not done in a table because TSDoc does not currently have support for embedded markdown.
  *
+ * @see {@link SchemaFactoryAlpha}
+ *
  * @sealed @public
  */
 export class SchemaFactory<
@@ -326,56 +463,65 @@ export class SchemaFactory<
 	}
 
 	/**
-	 * {@link TreeNodeSchema} for holding a JavaScript `string`.
-	 *
-	 * @remarks
-	 * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.
-	 *
-	 * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.
-	 * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
+	 * {@inheritDoc schemaStatics.string}
 	 */
 	public readonly string = stringSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for holding a JavaScript `number`.
-	 *
-	 * @remarks
-	 * The number is a [double-precision 64-bit binary format IEEE 754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) value, however there are some exceptions:
-	 * - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).
-	 * - `-0` may be converted to `0` in some cases.
-	 *
-	 * These limitations match the limitations of JSON.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
+	 * {@inheritDoc schemaStatics.number}
 	 */
 	public readonly number = numberSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for holding a boolean.
+	 * {@inheritDoc schemaStatics.boolean}
 	 */
 	public readonly boolean = booleanSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for JavaScript `null`.
-	 *
-	 * @remarks
-	 * There are good [reasons to avoid using null](https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null) in JavaScript, however sometimes it is desired.
-	 * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.
-	 * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.
+	 * {@inheritDoc schemaStatics.null}
 	 */
 	public readonly null = nullSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.
+	 * {@inheritDoc schemaStatics.handle}
 	 */
 	public readonly handle = handleSchema;
 
+	/**
+	 * {@inheritDoc schemaStatics.leaves}
+	 */
+	public readonly leaves = schemaStatics.leaves;
+
+	/**
+	 * {@inheritDoc schemaStatics.string}
+	 */
+	public static readonly string = stringSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.number}
+	 */
+	public static readonly number = numberSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.boolean}
+	 */
+	public static readonly boolean = booleanSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.null}
+	 */
+	public static readonly null = nullSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.handle}
+	 */
+	public static readonly handle = handleSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.leaves}
+	 */
+	public static readonly leaves = schemaStatics.leaves;
+
 	/**
 	 * Define a {@link TreeNodeSchemaClass} for a {@link TreeObjectNode}.
 	 *
@@ -694,74 +840,44 @@ export class SchemaFactory<
 	}
 
 	/**
-	 * Make a field optional instead of the default, which is required.
-	 *
-	 * @param t - The types allowed under the field.
-	 * @param props - Optional properties to associate with the field.
-	 *
-	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
-	 * See {@link FieldSchemaMetadata.custom}.
+	 * {@inheritDoc schemaStatics.optional}
 	 */
-	public optional<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	): FieldSchema<FieldKind.Optional, T, TCustomMetadata> {
-		const defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => {
-			return undefined;
-		});
-		return createFieldSchema(FieldKind.Optional, t, {
-			defaultProvider: defaultOptionalProvider,
-			...props,
-		});
-	}
+	public readonly optional = schemaStatics.optional;
 
 	/**
-	 * Make a field explicitly required.
-	 *
-	 * @param t - The types allowed under the field.
-	 * @param props - Optional properties to associate with the field.
-	 *
-	 * @remarks
-	 * Fields are required by default, but this API can be used to make the required nature explicit in the schema,
-	 * and allows associating custom {@link FieldProps | properties} with the field.
-	 *
-	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
-	 * See {@link FieldSchemaMetadata.custom}.
+	 * {@inheritDoc schemaStatics.required}
 	 */
-	public required<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	): FieldSchema<FieldKind.Required, T, TCustomMetadata> {
-		return createFieldSchema(FieldKind.Required, t, props);
-	}
+	public readonly required = schemaStatics.required;
 
 	/**
-	 * {@link SchemaFactory.optional} except tweaked to work better for recursive types.
-	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
-	 * @remarks
-	 * This version of {@link SchemaFactory.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 * {@inheritDoc schemaStatics.optionalRecursive}
 	 */
-	public optionalRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(
-		t: T,
-		props?: Omit<FieldProps, "defaultProvider">,
-	): FieldSchemaUnsafe<FieldKind.Optional, T> {
-		return createFieldSchemaUnsafe(FieldKind.Optional, t, props);
-	}
+	public readonly optionalRecursive = schemaStatics.optionalRecursive;
 
 	/**
-	 * {@link SchemaFactory.required} except tweaked to work better for recursive types.
-	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
-	 * @remarks
-	 * This version of {@link SchemaFactory.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 * {@inheritDoc schemaStatics.requiredRecursive}
 	 */
-	public requiredRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(
-		t: T,
-		props?: Omit<FieldProps, "defaultProvider">,
-	): FieldSchemaUnsafe<FieldKind.Required, T> {
-		return createFieldSchemaUnsafe(FieldKind.Required, t, props);
-	}
+	public readonly requiredRecursive = schemaStatics.requiredRecursive;
+
+	/**
+	 * {@inheritDoc schemaStatics.optional}
+	 */
+	public static readonly optional = schemaStatics.optional;
+
+	/**
+	 * {@inheritDoc schemaStatics.required}
+	 */
+	public static readonly required = schemaStatics.required;
+
+	/**
+	 * {@inheritDoc schemaStatics.optionalRecursive}
+	 */
+	public static readonly optionalRecursive = schemaStatics.optionalRecursive;
+
+	/**
+	 * {@inheritDoc schemaStatics.requiredRecursive}
+	 */
+	public static readonly requiredRecursive = schemaStatics.requiredRecursive;
 
 	/**
 	 * A special field which holds a unique identifier for an object node.

package/src/{shared-tree → simple-tree/api}/transactionTypes.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { TreeNode } from "../simple-tree/index.js";
+import type { TreeNode } from "../core/index.js";
 
 /**
  * A special object that signifies when a SharedTree {@link RunTransaction | transaction} should "roll back".

package/src/simple-tree/api/tree.ts

@@ -13,11 +13,6 @@ import type {
 } from "../../core/index.js";
 
 import type {
-	RunTransactionParams,
-	VoidTransactionCallbackStatus,
-	TransactionCallbackStatus,
-	TransactionResult,
-	TransactionResultExt,
 	// This is referenced by doc comments.
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
 	TreeAlpha,
@@ -42,6 +37,15 @@ import { markSchemaMostDerived } from "./schemaFactory.js";
 import { fail, getOrCreate } from "../../util/index.js";
 import type { MakeNominal } from "../../util/index.js";
 import { walkFieldSchema } from "../walkFieldSchema.js";
+import type { VerboseTree } from "./verboseTree.js";
+import type { SimpleTreeSchema } from "./simpleSchema.js";
+import type {
+	RunTransactionParams,
+	TransactionCallbackStatus,
+	TransactionResult,
+	TransactionResultExt,
+	VoidTransactionCallbackStatus,
+} from "./transactionTypes.js";
 /**
  * A tree from which a {@link TreeView} can be created.
  *
@@ -52,7 +56,6 @@ import { walkFieldSchema } from "../walkFieldSchema.js";
  * Maybe rename "exportJsonSchema" to align on "concise" terminology.
  * Ensure schema exporting APIs here align and reference APIs for exporting view schema to the same formats (which should include stored vs property key choice).
  * Make sure users of independentView can use these export APIs (maybe provide a reference back to the ViewableTree from the TreeView to accomplish that).
- * Some of these APIs are on ISharedTree and can get moved here.
  * @system @sealed @public
  */
 export interface ViewableTree {
@@ -101,6 +104,28 @@ export interface ViewableTree {
  */
 export interface ITree extends ViewableTree, IFluidLoadable {}
 
+/**
+ * {@link ITree} extended with some alpha APIs.
+ * @privateRemarks
+ * TODO: Promote this to alpha.
+ * @internal
+ */
+export interface ITreeAlpha extends ITree {
+	/**
+	 * Exports root in the same format as {@link TreeAlpha.(exportVerbose:1)} using stored keys.
+	 * @remarks
+	 * This is `undefined` if and only if the root field is empty (this can only happen if the root field is optional).
+	 */
+	exportVerbose(): VerboseTree | undefined;
+
+	/**
+	 * Exports the SimpleTreeSchema that is stored in the tree, using stored keys for object fields.
+	 * @remarks
+	 * To get the schema using property keys, use {@link getSimpleSchema} on the view schema.
+	 */
+	exportSimpleSchema(): SimpleTreeSchema;
+}
+
 /**
  * Options when constructing a tree view.
  * @public
@@ -467,6 +492,10 @@ export interface TreeBranch extends IDisposable {
  * Doing that would however complicate trivial "hello world" style example slightly, as well as be a breaking API change.
  * It also seems more complex to handle invalidation with that pattern.
  * Thus this design was chosen at the risk of apps blindly accessing `root` then breaking unexpectedly when the document is incompatible.
+ *
+ * @see {@link TreeViewAlpha}
+ * @see {@link asTreeViewAlpha}
+ *
  * @sealed @public
  */
 export interface TreeView<in out TSchema extends ImplicitFieldSchema> extends IDisposable {

package/src/simple-tree/core/getOrCreateNode.ts

@@ -6,7 +6,11 @@
 import type { TreeValue } from "../../core/index.js";
 import type { FlexTreeNode } from "../../feature-libraries/index.js";
 import { fail } from "../../util/index.js";
-import { type InnerNode, mapTreeNodeToProxy, proxySlot } from "./treeNodeKernel.js";
+import {
+	type InnerNode,
+	unhydratedFlexTreeNodeToTreeNode,
+	proxySlot,
+} from "./treeNodeKernel.js";
 import { getSimpleNodeSchemaFromInnerNode } from "./schemaCaching.js";
 import type { TreeNode, InternalTreeNode } from "./types.js";
 import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
@@ -20,7 +24,7 @@ import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 export function getOrCreateNodeFromInnerNode(flexNode: InnerNode): TreeNode | TreeValue {
 	const cached =
 		flexNode instanceof UnhydratedFlexTreeNode
-			? mapTreeNodeToProxy.get(flexNode)
+			? unhydratedFlexTreeNodeToTreeNode.get(flexNode)
 			: flexNode.anchorNode.slots.get(proxySlot);
 
 	if (cached !== undefined) {

package/src/simple-tree/core/index.ts

@@ -10,7 +10,7 @@ export {
 	tryGetTreeNodeSchema,
 	type InnerNode,
 	tryDisposeTreeNode,
-	tryGetTreeNodeFromMapNode,
+	unhydratedFlexTreeNodeToTreeNode,
 	getOrCreateInnerNode,
 	treeNodeFromAnchor,
 } from "./treeNodeKernel.js";

package/src/simple-tree/core/treeNodeKernel.ts

@@ -146,7 +146,7 @@ export class TreeNodeKernel {
 
 		if (innerNode instanceof UnhydratedFlexTreeNode) {
 			// Unhydrated case
-			mapTreeNodeToProxy.set(innerNode, node);
+			unhydratedFlexTreeNodeToTreeNodeInternal.set(innerNode, node);
 			// Register for change events from the unhydrated flex node.
 			// These will be fired if the unhydrated node is edited, and will also be forwarded later to the hydrated node.
 			this.#hydrationState = {
@@ -158,7 +158,7 @@ export class TreeNodeKernel {
 
 					let n: UnhydratedFlexTreeNode | undefined = innerNode;
 					while (n !== undefined) {
-						const treeNode = mapTreeNodeToProxy.get(n);
+						const treeNode = unhydratedFlexTreeNodeToTreeNodeInternal.get(n);
 						if (treeNode !== undefined) {
 							const kernel = getKernel(treeNode);
 							kernel.#unhydratedEvents.value.emit("subtreeChangedAfterBatch");
@@ -200,7 +200,7 @@ export class TreeNodeKernel {
 	private hydrate(anchorNode: AnchorNode): void {
 		assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
 		assert(!isHydrated(this.#hydrationState), 0xa2b /* hydration should only happen once */);
-		mapTreeNodeToProxy.delete(this.#hydrationState.innerNode);
+		unhydratedFlexTreeNodeToTreeNodeInternal.delete(this.#hydrationState.innerNode);
 		this.#hydrationState = this.createHydratedState(anchorNode);
 
 		// If needed, register forwarding emitters for events from before hydration
@@ -389,9 +389,20 @@ type KernelEvents = Pick<AnchorEvents, (typeof kernelEvents)[number]>;
 export type InnerNode = FlexTreeNode | UnhydratedFlexTreeNode;
 
 /**
- * {@inheritdoc proxyToMapTreeNode}
+ * Associates a given {@link UnhydratedFlexTreeNode} with a {@link TreeNode}.
  */
-export const mapTreeNodeToProxy = new WeakMap<UnhydratedFlexTreeNode, TreeNode>();
+const unhydratedFlexTreeNodeToTreeNodeInternal = new WeakMap<
+	UnhydratedFlexTreeNode,
+	TreeNode
+>();
+/**
+ * Retrieves the {@link TreeNode} associated with the given {@link UnhydratedFlexTreeNode} if any.
+ */
+export const unhydratedFlexTreeNodeToTreeNode =
+	unhydratedFlexTreeNodeToTreeNodeInternal as Pick<
+		WeakMap<UnhydratedFlexTreeNode, TreeNode>,
+		"get"
+	>;
 
 /**
  * An anchor slot which associates an anchor with its corresponding TreeNode, if there is one.
@@ -401,15 +412,6 @@ export const mapTreeNodeToProxy = new WeakMap<UnhydratedFlexTreeNode, TreeNode>(
  */
 export const proxySlot = anchorSlot<TreeNode>();
 
-/**
- * Retrieves the node associated with the given MapTreeNode node if any.
- */
-export function tryGetTreeNodeFromMapNode(
-	flexNode: UnhydratedFlexTreeNode,
-): TreeNode | undefined {
-	return mapTreeNodeToProxy.get(flexNode);
-}
-
 export function tryDisposeTreeNode(anchorNode: AnchorNode): void {
 	const treeNode = anchorNode.slots.get(proxySlot);
 	if (treeNode !== undefined) {

package/src/simple-tree/index.ts

@@ -124,6 +124,18 @@ export {
 	type CustomTreeNode,
 	type CustomTreeValue,
 	tryStoredSchemaAsArray,
+	type schemaStatics,
+	type ITreeAlpha,
+	type TransactionConstraint,
+	type NodeInDocumentConstraint,
+	type RunTransactionParams,
+	type VoidTransactionCallbackStatus,
+	type TransactionCallbackStatus,
+	type TransactionResult,
+	type TransactionResultExt,
+	type TransactionResultSuccess,
+	type TransactionResultFailed,
+	rollback,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,

package/src/simple-tree/proxies.ts

@@ -24,9 +24,9 @@ import { type Mutable, fail, isReadonlyArray } from "../util/index.js";
 import {
 	getKernel,
 	type TreeNode,
-	tryGetTreeNodeFromMapNode,
 	getOrCreateNodeFromInnerNode,
 	tryUnhydratedFlexTreeNode,
+	unhydratedFlexTreeNodeToTreeNode,
 } from "./core/index.js";
 
 /**
@@ -146,7 +146,7 @@ function walkMapTree(
 		const [p, m] = next;
 		const mapTreeNode = tryUnhydratedFlexTreeNode(m);
 		if (mapTreeNode !== undefined) {
-			const treeNode = tryGetTreeNodeFromMapNode(mapTreeNode);
+			const treeNode = unhydratedFlexTreeNodeToTreeNode.get(mapTreeNode);
 			if (treeNode !== undefined) {
 				onVisitTreeNode(p, treeNode);
 			}

package/src/simple-tree/schemaTypes.ts

@@ -281,7 +281,7 @@ export let createFieldSchema: <
  * including functionality that does not have to be kept consistent across versions or deterministic.
  *
  * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
- * Use {@link SchemaFactory} to create the FieldSchema instances, for example {@link SchemaFactory.optional}.
+ * Use {@link SchemaFactory} to create the FieldSchema instances, for example {@link schemaStatics.optional}.
  * @privateRemarks
  * Public access to the constructor is removed to prevent creating expressible but unsupported (or not stable) configurations.
  * {@link createFieldSchema} can be used internally to create instances.
@@ -822,7 +822,7 @@ export type NodeBuilderData<T extends TreeNodeSchemaCore<string, NodeKind, boole
 /**
  * Value that may be stored as a leaf node.
  * @remarks
- * Some limitations apply, see the documentation for {@link SchemaFactory.number} and {@link SchemaFactory.string} for those restrictions.
+ * Some limitations apply, see the documentation for {@link schemaStatics.number} and {@link schemaStatics.string} for those restrictions.
  * @public
  */
 // eslint-disable-next-line @rushstack/no-new-null

package/src/treeFactory.ts

@@ -15,25 +15,43 @@ import {
 	createSharedObjectKind,
 } from "@fluidframework/shared-object-base/internal";
 
-import { pkgVersion } from "./packageVersion.js";
-import { SharedTree as SharedTreeImpl, type SharedTreeOptions } from "./shared-tree/index.js";
+import {
+	SharedTree as SharedTreeImpl,
+	type SharedTreeOptions,
+	type SharedTreeOptionsInternal,
+} from "./shared-tree/index.js";
 import type { ITree } from "./simple-tree/index.js";
 
+import { pkgVersion } from "./packageVersion.js";
+
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
+ * @alpha
+ * @legacy
+ */
+export const SharedTreeFactoryType = "https://graph.microsoft.com/types/tree";
+
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory.attributes}
+ * @alpha
+ * @legacy
+ */
+export const SharedTreeAttributes: IChannelAttributes = {
+	type: SharedTreeFactoryType,
+	snapshotFormatVersion: "0.0.0",
+	packageVersion: pkgVersion,
+};
+
 /**
  * A channel factory that creates an {@link ITree}.
  */
 export class TreeFactory implements IChannelFactory<ITree> {
-	public static readonly Type = "https://graph.microsoft.com/types/tree";
-	public static readonly attributes: IChannelAttributes = {
-		type: this.Type,
-		snapshotFormatVersion: "0.0.0",
-		packageVersion: pkgVersion,
-	};
+	public static Type: string = SharedTreeFactoryType;
+	public readonly type: string = SharedTreeFactoryType;
 
-	public readonly type = TreeFactory.Type;
-	public readonly attributes: IChannelAttributes = TreeFactory.attributes;
+	public readonly attributes: IChannelAttributes = SharedTreeAttributes;
 
-	public constructor(private readonly options: SharedTreeOptions) {}
+	public constructor(private readonly options: SharedTreeOptionsInternal) {}
 
 	public async load(
 		runtime: IFluidDataStoreRuntime,

package/src/util/breakable.ts

@@ -47,7 +47,7 @@ export class Breakable {
 	 * @privateRemarks
 	 * If there is a use-case, this should be made public.
 	 */
-	private rethrowCaught(brokenBy: unknown): never {
+	public rethrowCaught(brokenBy: unknown): never {
 		if (brokenBy instanceof Error) {
 			this.break(brokenBy);
 		}