@fluidframework/tree 2.3.0-288113 → 2.3.0

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

@@ -12,15 +12,31 @@ import {
 	type Off,
 } from "../../events/index.js";
 import type { TreeNode, Unhydrated } from "./types.js";
-import type { AnchorEvents, AnchorNode } from "../../core/index.js";
 import {
+	anchorSlot,
+	type AnchorEvents,
+	type AnchorNode,
+	type AnchorSet,
+	type UpPath,
+} from "../../core/index.js";
+import {
+	assertFlexTreeEntityNotFreed,
+	ContextSlot,
 	flexTreeSlot,
+	isFlexTreeNode,
 	isFreedSymbol,
+	isMapTreeNode,
 	LazyEntity,
 	TreeStatus,
 	treeStatusFromAnchorCache,
+	type FlexTreeNode,
+	type MapTreeNode,
 } from "../../feature-libraries/index.js";
 import type { TreeNodeSchema } from "./treeNodeSchema.js";
+import { fail } from "../../util/index.js";
+// TODO: decide how to deal with dependencies on flex-tree implementation.
+// eslint-disable-next-line import/no-internal-modules
+import { makeTree } from "../../feature-libraries/flex-tree/lazyNode.js";
 
 const treeNodeToKernel = new WeakMap<TreeNode, TreeNodeKernel>();
 
@@ -72,6 +88,12 @@ export class TreeNodeKernel implements Listenable<KernelEvents> {
 	/**
 	 * Generation number which is incremented any time we have an edit on the node.
 	 * Used during iteration to make sure there has been no edits that were concurrently made.
+	 * @remarks
+	 * This is updated monotonically by this class when edits are applied.
+	 * TODO: update this when applying edits to unhydrated trees.
+	 *
+	 * If TypeScript supported making this immutable from outside the class without making it readonly from inside, that would be used here,
+	 * but they only way to do that is add a separate public accessor and make it private, which was deemed not worth the boilerplate, runtime overhead and bundle size.
 	 */
 	public generationNumber: number = 0;
 
@@ -83,7 +105,7 @@ export class TreeNodeKernel implements Listenable<KernelEvents> {
 	/**
 	 * Events registered before hydration.
 	 * @remarks
-	 *
+	 * As an optimization these are allocated lazily as they are usually unused.
 	 */
 	#preHydrationEvents?: Listenable<KernelEvents> &
 		IEmitter<KernelEvents> &
@@ -96,7 +118,7 @@ export class TreeNodeKernel implements Listenable<KernelEvents> {
 	 * This design avoids allocating `#preHydrationEvents` if unneeded.
 	 *
 	 * This design also avoids extra forwarding overhead for events from anchorNode and also
-	 * avoids registering for events that the are unneeded.
+	 * avoids registering for events that are unneeded.
 	 * This means optimizations like skipping processing data in subtrees where no subtreeChanged events are subscribed to would be able to work,
 	 * since this code does not unconditionally subscribe to those events (like a design simply forwarding all events would).
 	 */
@@ -111,24 +133,50 @@ export class TreeNodeKernel implements Listenable<KernelEvents> {
 
 	/**
 	 * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
+	 *
+	 * @param innerNode - When unhydrated/raw or marinated the MapTreeNode. FlexTreeNode when cooked.
 	 * @remarks
 	 * Exactly one kernel per TreeNode should be created.
 	 */
 	public constructor(
 		public readonly node: TreeNode,
 		public readonly schema: TreeNodeSchema,
+		private innerNode: InnerNode,
 	) {
 		assert(!treeNodeToKernel.has(node), 0xa1a /* only one kernel per node can be made */);
 		treeNodeToKernel.set(node, this);
+
+		if (isMapTreeNode(innerNode)) {
+			// Unhydrated case
+			mapTreeNodeToProxy.set(innerNode, node);
+		} else {
+			// Hydrated case
+			assert(
+				!innerNode.anchorNode.slots.has(proxySlot),
+				0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
+			);
+			this.hydrate(innerNode.anchorNode);
+		}
 	}
 
 	/**
 	 * Transition from {@link Unhydrated} to hydrated.
+	 * Bi-directionally associates the given hydrated TreeNode to the given anchor node.
 	 * @remarks
 	 * Happens at most once for any given node.
+	 * Cleans up mappings to {@link MapTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
 	 */
 	public hydrate(anchorNode: AnchorNode): void {
-		assert(!this.disposed, "cannot use a disposed node");
+		assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
+		assert(this.#hydrated === undefined, 0xa2b /* hydration should only happen once */);
+
+		// If the this node is raw and thus has a MapTreeNode, forget it:
+		if (isMapTreeNode(this.innerNode)) {
+			mapTreeNodeToProxy.delete(this.innerNode);
+		}
+
+		// However, it's fine for an anchor node to rotate through different proxies when the content at that place in the tree is replaced.
+		anchorNode.slots.set(proxySlot, this.node);
 
 		this.#hydrated = {
 			anchorNode,
@@ -158,7 +206,7 @@ export class TreeNodeKernel implements Listenable<KernelEvents> {
 	}
 
 	public isHydrated(): boolean {
-		assert(!this.disposed, "cannot use a disposed node");
+		assert(!this.disposed, 0xa2c /* cannot use a disposed node */);
 		return this.#hydrated !== undefined;
 	}
 
@@ -193,8 +241,153 @@ export class TreeNodeKernel implements Listenable<KernelEvents> {
 		}
 		// TODO: go to the context and remove myself from withAnchors
 	}
+
+	/**
+	 * Retrieves the flex node associated with the given target via {@link setInnerNode}.
+	 * @remarks
+	 * For {@link Unhydrated} nodes, this returns the MapTreeNode.
+	 *
+	 * For hydrated nodes it returns a FlexTreeNode backed by the forest.
+	 * Note that for "marinated" nodes, this FlexTreeNode exists and returns it: it does not return the MapTreeNode which is the current InnerNode.
+	 */
+	public getOrCreateInnerNode(allowFreed = false): InnerNode {
+		if (!isMapTreeNode(this.innerNode)) {
+			// Cooked case
+			return this.innerNode;
+		}
+
+		if (this.#hydrated === undefined) {
+			// Unhydrated case
+			return this.innerNode;
+		}
+
+		// Marinated case -> cooked
+		const anchorNode = this.#hydrated.anchorNode;
+		// The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
+		const flexNode = anchorNode.slots.get(flexTreeSlot);
+		if (flexNode !== undefined) {
+			this.innerNode = flexNode;
+			return flexNode; // If it does have a flex node, return it...
+		} // ...otherwise, the flex node must be created
+		const context = anchorNode.anchorSet.slots.get(ContextSlot) ?? fail("missing context");
+		const cursor = context.checkout.forest.allocateCursor("getFlexNode");
+		context.checkout.forest.moveCursorToPath(anchorNode, cursor);
+		const newFlexNode = makeTree(context, cursor);
+		cursor.free();
+		this.innerNode = newFlexNode;
+		// Calling this is a performance improvement, however, do this only after demand to avoid momentarily having no anchors to anchorNode
+		anchorForgetters?.get(this.node)?.();
+		if (!allowFreed) {
+			assertFlexTreeEntityNotFreed(newFlexNode);
+		}
+		return newFlexNode;
+	}
+
+	/**
+	 * Creates an anchor node and associates it with the given proxy.
+	 * @privateRemarks
+	 * Use `forgetters` to cleanup the anchor allocated by this function once the anchor is no longer needed.
+	 * In practice, this happens when either the anchor node is destroyed, or another anchor to the same node is created by a new flex node.
+	 *
+	 * The FlexTreeNode holds a reference to the same anchor, and has a lifetime at least as long as the simple-tree,
+	 * so this would be unnecessary except for the case of "marinated" nodes, which have an anchor,
+	 * but might not have a FlexTreeNode.
+	 * Handling this case is an optimization assuming that this extra anchor reference is cheaper than eagerly creating FlexTreeNodes.
+	 */
+	public anchorProxy(anchors: AnchorSet, path: UpPath): AnchorNode {
+		assert(!anchorForgetters.has(this.node), 0x91c /* Proxy anchor should not be set twice */);
+		const anchor = anchors.track(path);
+		const anchorNode = anchors.locate(anchor) ?? fail("Expected anchor node to be present");
+		this.hydrate(anchorNode);
+		const forget = (): void => {
+			if (anchors.locate(anchor)) {
+				anchors.forget(anchor);
+			}
+			anchorForgetters.delete(this.node);
+			off();
+		};
+		anchorForgetters.set(this.node, forget);
+		const off = anchorNode.on("afterDestroy", forget);
+		return anchorNode;
+	}
+
+	/**
+	 * Retrieves the InnerNode associated with the given target via {@link setInnerNode}, if any.
+	 * @remarks
+	 * If `target` is a unhydrated node, returns its MapTreeNode.
+	 * If `target` is a cooked node (or marinated but a FlexTreeNode exists) returns the FlexTreeNode.
+	 * If the target is not a node, or a marinated node with no FlexTreeNode for its anchor, returns undefined.
+	 */
+	public tryGetInnerNode(): InnerNode | undefined {
+		if (isFlexTreeNode(this.innerNode)) {
+			// Cooked case
+			return this.innerNode;
+		}
+
+		if (this.#hydrated === undefined) {
+			// Unhydrated case
+			return this.innerNode;
+		}
+
+		// Marinated case -> cooked
+		const anchorNode = this.#hydrated.anchorNode;
+		// The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
+		return anchorNode.slots.get(flexTreeSlot);
+	}
 }
 
+/**
+ * Used by {@link anchorProxy} as an optimization to ensure that only one anchor is remembered at a time for a given anchor node
+ */
+const anchorForgetters = new WeakMap<TreeNode, () => void>();
+
 const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"] as const;
 
 type KernelEvents = Pick<AnchorEvents, (typeof kernelEvents)[number]>;
+
+/**
+ * For "cooked" nodes this is a FlexTreeNode thats a projection of forest content.
+ * For {@link Unhydrated} nodes this is a MapTreeNode.
+ * For "marinated" nodes, some code (ex: getOrCreateInnerNode) returns the FlexTreeNode thats a projection of forest content, and some code (ex: tryGetInnerNode) returns undefined.
+ *
+ * @remarks
+ * Currently MapTreeNode extends FlexTreeNode, and most code which can work with either just uses FlexTreeNode.
+ * TODO: Code should be migrating toward using this type to distinguish to two use-cases.
+ *
+ * TODO: The inconsistent handling of "marinated" cases should be cleaned up.
+ * Maybe getOrCreateInnerNode should cook marinated nodes so they have a proper InnerNode?
+ */
+export type InnerNode = FlexTreeNode | MapTreeNode;
+
+/**
+ * {@inheritdoc proxyToMapTreeNode}
+ */
+const mapTreeNodeToProxy = new WeakMap<MapTreeNode, TreeNode>();
+
+/**
+ * An anchor slot which associates an anchor with its corresponding TreeNode, if there is one.
+ * @remarks
+ * For this to work, we have to require that there is at most a single view using a given AnchorSet.
+ * FlexTree already has this assumption, and we also assume there is a single simple-tree per FlexTree, so this is valid.
+ */
+const proxySlot = anchorSlot<TreeNode>();
+
+/**
+ * Retrieves the proxy associated with the given flex node via {@link setInnerNode}, if any.
+ */
+export function tryGetCachedTreeNode(flexNode: InnerNode): TreeNode | undefined {
+	if (isMapTreeNode(flexNode)) {
+		// Unhydrated case
+		return mapTreeNodeToProxy.get(flexNode);
+	}
+	// Hydrated case
+	return flexNode.anchorNode.slots.get(proxySlot);
+}
+
+export function tryDisposeTreeNode(anchorNode: AnchorNode): void {
+	const treeNode = anchorNode.slots.get(proxySlot);
+	if (treeNode !== undefined) {
+		const kernel = getKernel(treeNode);
+		kernel.dispose();
+	}
+}

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

@@ -33,7 +33,7 @@ export type TreeNodeSchema<
  * This is used for schema which cannot have their instances constructed using constructors, like leaf schema.
  * @privateRemarks
  * Non-class based schema can have issues with recursive types due to https://github.com/microsoft/TypeScript/issues/55832.
- * @sealed @public
+ * @system @sealed @public
  */
 export interface TreeNodeSchemaNonClass<
 	out Name extends string = string,

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

@@ -20,28 +20,20 @@ import { isFlexTreeNode, type FlexTreeNode } from "../../feature-libraries/index
  *
  * Since un-hydrated nodes become hydrated when inserted, strong typing can't be used to distinguish them.
  * This no-op wrapper is used instead.
+ * @remarks
+ * Nodes which are Unhydrated report {@link TreeStatus}.new from `Tree.status(node)`.
+ * @privateRemarks
+ * TODO: Linking tree status is failing in intellisense and linking directly to its .new item is failing in API extractor as well.
+ * WOuld be nice to have a working link here.
  * @public
  */
 export type Unhydrated<T> = T;
 
-/**
- * Data included for {@link TreeChangeEvents.nodeChanged}.
- * @public
- */
-export interface NodeChangedData {
-	/**
-	 * When the node changed is an object or Map node, this lists all the properties which changed.
-	 * @remarks
-	 * This only includes changes to the node itself (which would trigger {@link TreeChangeEvents.nodeChanged}).
-	 */
-	readonly changedProperties?: ReadonlySet<string>;
-}
-
 /**
  * A collection of events that can be emitted by a {@link TreeNode}.
  *
  * @remarks
- * Currently events can be subscribed to for {@link Unhydrated} nodes, however no events will be triggered for the nodes until after they are hydrated.
+ * Currently, events can be subscribed to for {@link Unhydrated} nodes, however no events will be triggered for the nodes until after they are hydrated.
  * This is considered a known issue, and should be fixed in future versions.
  * Do not rely on the fact that editing unhydrated nodes does not trigger their events.
  *
@@ -63,16 +55,21 @@ export interface NodeChangedData {
  *
  * @sealed @public
  */
-export interface TreeChangeEvents<TNode = TreeNode> {
+export interface TreeChangeEvents {
 	/**
 	 * Emitted by a node after a batch of changes has been applied to the tree, if any of the changes affected the node.
 	 *
-	 * - Object nodes define a change as the value of one of its properties changing (i.e., the property's value is set, including when set to undefined).
+	 * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).
 	 *
-	 * - Array node define a change as when an element is added, removed, moved or replaced.
+	 * - Array nodes define a change as when an element is added, removed, moved or replaced.
 	 *
 	 * - Map nodes define a change as when an entry is added, updated, or removed.
 	 *
+	 * @param unstable - Future versions of this API (such as the one in beta on TreeBeta) may use this argument to provide additional data to the event.
+	 * users of this event should ensure that they do not provide a listener callback which has an optional parameter in this position, since unexpected data might get provided to it.
+	 * This parameter exists to capture this fact in the type system.
+	 * Using an inline lambda expression as the listener callback is a good pattern to avoid cases like this were arguments are added from breaking due to optional arguments.
+	 *
 	 * @remarks
 	 * This event is not emitted when:
 	 *
@@ -94,15 +91,9 @@ export interface TreeChangeEvents<TNode = TreeNode> {
 	 * node, or when the node has to be updated due to resolution of a merge conflict
 	 * (for example a previously applied local change might be undone, then reapplied differently or not at all).
 	 *
-	 * TODO: defined and document event ordering (ex: bottom up, with nodeChanged before treeCHange on each level).
+	 * TODO: define and document event ordering (ex: bottom up, with nodeChanged before treeChange on each level).
 	 */
-	nodeChanged(
-		data: NodeChangedData &
-			// For object and Map nodes, make properties specific to them required instead of optional:
-			(TNode extends WithType<string, NodeKind.Map | NodeKind.Object>
-				? Required<Pick<NodeChangedData, "changedProperties">>
-				: unknown),
-	): void;
+	nodeChanged(unstable?: unknown): void;
 
 	/**
 	 * Emitted by a node after a batch of changes has been applied to the tree, when something changed anywhere in the
@@ -123,8 +114,6 @@ export interface TreeChangeEvents<TNode = TreeNode> {
 	treeChanged(): void;
 }
 
-export type IsListener2<TListener> = TListener extends (...args: any[]) => void ? true : false;
-
 /**
  * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.
  *

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

@@ -43,6 +43,7 @@ export const typeSchemaSymbol: unique symbol = Symbol("TreeNode Schema");
  *
  * @typeParam TName - Same as {@link TreeNodeSchema}'s "Name" parameter.
  * @typeParam TKind - Same as {@link TreeNodeSchema}'s "Kind" parameter.
+ * @typeParam TInfo - Same as {@link TreeNodeSchema}'s "Info" parameter: format depends on the Kind.
  * @remarks
  * Powers {@link TreeNode}'s strong typing setup.
  * @example Narrow types for overloading based on NodeKind
@@ -75,6 +76,7 @@ export const typeSchemaSymbol: unique symbol = Symbol("TreeNode Schema");
 export interface WithType<
 	out TName extends string = string,
 	out TKind extends NodeKind = NodeKind,
+	out TInfo = unknown,
 > {
 	/**
 	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
@@ -85,5 +87,5 @@ export interface WithType<
 	/**
 	 * Type symbol, marking a type in a way to increase type safety via strong type checking.
 	 */
-	get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind>;
+	get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
 }

package/src/simple-tree/index.ts

@@ -19,7 +19,7 @@ export {
 	type Unhydrated,
 	type InternalTreeNode,
 	isTreeNode,
-	type NodeChangedData,
+	tryDisposeTreeNode,
 } from "./core/index.js";
 export {
 	type ITree,
@@ -45,6 +45,25 @@ export {
 	type TreeNodeApi,
 	cursorFromInsertable,
 	createFromInsertable,
+	type NodeChangedData,
+	TreeBeta,
+	type TreeChangeEventsBeta,
+	type SimpleTreeSchema,
+	type JsonSchemaId,
+	type JsonSchemaType,
+	type JsonObjectNodeSchema,
+	type JsonArrayNodeSchema,
+	type JsonMapNodeSchema,
+	type JsonLeafNodeSchema,
+	type JsonSchemaRef,
+	type JsonRefPath,
+	type JsonNodeSchema,
+	type JsonNodeSchemaBase,
+	type JsonTreeSchema,
+	type JsonFieldSchema,
+	type JsonLeafSchemaType,
+	getJsonSchema,
+	getSimpleSchema,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,
@@ -66,7 +85,7 @@ export {
 	normalizeFieldSchema,
 	type ApplyKind,
 } from "./schemaTypes.js";
-export { getOrCreateInnerNode, tryDisposeTreeNode } from "./proxyBinding.js";
+export { getOrCreateInnerNode } from "./proxyBinding.js";
 export { toFlexSchema } from "./toFlexSchema.js";
 export type {
 	FieldHasDefaultUnsafe,
@@ -87,7 +106,6 @@ export type {
 } from "./typesUnsafe.js";
 export {
 	getTreeNodeForField,
-	type InsertableContent,
 	prepareContentForHydration,
 } from "./proxies.js";
 
@@ -104,22 +122,12 @@ export {
 	setField,
 } from "./objectNode.js";
 export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
-export { mapTreeFromNodeData } from "./toMapTree.js";
-export type { SimpleTreeSchema } from "./simpleSchema.js";
+export { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
+export { toStoredSchema, getStoredSchema, getFlexSchema } from "./toFlexSchema.js";
 export {
-	type JsonSchemaId,
-	type JsonSchemaType,
-	type JsonObjectNodeSchema,
-	type JsonArrayNodeSchema,
-	type JsonMapNodeSchema,
-	type JsonLeafNodeSchema,
-	type JsonSchemaRef,
-	type JsonRefPath,
-	type JsonNodeSchema,
-	type JsonNodeSchemaBase,
-	type JsonTreeSchema,
-	type JsonFieldSchema,
-	type JsonLeafSchemaType,
-} from "./jsonSchema.js";
-export { getJsonSchema } from "./getJsonSchema.js";
-export { getSimpleSchema } from "./getSimpleSchema.js";
+	numberSchema,
+	stringSchema,
+	booleanSchema,
+	handleSchema,
+	nullSchema,
+} from "./leafNodeSchema.js";

package/src/simple-tree/leafNodeSchema.ts

@@ -5,10 +5,9 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import type { TreeNodeSchemaIdentifier, TreeValue } from "../core/index.js";
-import { leaf } from "../domains/index.js";
+import { type TreeValue, ValueSchema } from "../core/index.js";
 import {
-	type LeafNodeSchema as FlexLeafNodeSchema,
+	LeafNodeSchema as FlexLeafNodeSchema,
 	type FlexTreeNode,
 	isFlexTreeNode,
 	valueSchemaAllows,
@@ -20,12 +19,6 @@ import {
 	type TreeNodeSchemaNonClass,
 } from "./core/index.js";
 
-type UnbrandedName<T extends FlexLeafNodeSchema> = T["name"] extends TreeNodeSchemaIdentifier<
-	infer Name extends string
->
-	? Name
-	: T["name"];
-
 /**
  * Instances of this class are schema for leaf nodes.
  * @remarks
@@ -35,14 +28,14 @@ type UnbrandedName<T extends FlexLeafNodeSchema> = T["name"] extends TreeNodeSch
  * @privateRemarks
  * This class refers to the underlying flex tree schema in its constructor, so this class can't be included in the package API.
  */
-export class LeafNodeSchema<T extends FlexLeafNodeSchema>
-	implements TreeNodeSchemaNonClass<UnbrandedName<T>, NodeKind.Leaf, TreeValue<T["info"]>>
+export class LeafNodeSchema<Name extends string, const T extends ValueSchema>
+	implements TreeNodeSchemaNonClass<Name, NodeKind.Leaf, TreeValue<T>, TreeValue<T>>
 {
-	public readonly identifier: UnbrandedName<T>;
+	public readonly identifier: Name;
 	public readonly kind = NodeKind.Leaf;
-	public readonly info: T["info"];
+	public readonly info: T;
 	public readonly implicitlyConstructable = true as const;
-	public create(data: TreeValue<T["info"]> | FlexTreeNode): TreeValue<T["info"]> {
+	public create(data: TreeValue<T> | FlexTreeNode): TreeValue<T> {
 		if (isFlexTreeNode(data)) {
 			const value = data.value;
 			assert(valueSchemaAllows(this.info, value), 0x916 /* invalid value */);
@@ -51,30 +44,33 @@ export class LeafNodeSchema<T extends FlexLeafNodeSchema>
 		return data;
 	}
 
-	public constructor(schema: T) {
+	public constructor(name: Name, t: T) {
+		const schema: FlexLeafNodeSchema = new FlexLeafNodeSchema({ name: "makeLeaf" }, name, t);
 		setFlexSchemaFromClassSchema(this, schema);
-		this.identifier = schema.name as UnbrandedName<T>;
-		this.info = schema.info;
+		this.identifier = name;
+		this.info = t;
 	}
 }
 
 /**
  * Wrapper around LeafNodeSchema's constructor that provides the return type that is desired in the package public API.
  */
-function makeLeaf<T extends FlexLeafNodeSchema>(
-	schema: T,
+function makeLeaf<Name extends string, const T extends ValueSchema>(
+	name: Name,
+	t: T,
 ): TreeNodeSchema<
-	UnbrandedName<T>,
+	`com.fluidframework.leaf.${Name}`,
 	NodeKind.Leaf,
-	TreeValue<T["info"]>,
-	TreeValue<T["info"]>
+	TreeValue<T>,
+	TreeValue<T>
 > {
-	return new LeafNodeSchema(schema);
+	// Names in this domain follow https://en.wikipedia.org/wiki/Reverse_domain_name_notation
+	return new LeafNodeSchema(`com.fluidframework.leaf.${name}`, t);
 }
 
 // Leaf schema shared between all SchemaFactory instances.
-export const stringSchema = makeLeaf(leaf.string);
-export const numberSchema = makeLeaf(leaf.number);
-export const booleanSchema = makeLeaf(leaf.boolean);
-export const nullSchema = makeLeaf(leaf.null);
-export const handleSchema = makeLeaf(leaf.handle);
+export const stringSchema = makeLeaf("string", ValueSchema.String);
+export const numberSchema = makeLeaf("number", ValueSchema.Number);
+export const booleanSchema = makeLeaf("boolean", ValueSchema.Boolean);
+export const nullSchema = makeLeaf("null", ValueSchema.Null);
+export const handleSchema = makeLeaf("handle", ValueSchema.FluidHandle);