@fluidframework/tree 2.4.0-294316 → 2.4.0-297385

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

@@ -16,21 +16,19 @@ import {
 	FieldKind,
 } from "../schemaTypes.js";
 import { NodeKind, type TreeNodeSchema } from "../core/index.js";
-import { toFlexSchema } from "../toFlexSchema.js";
+import { toStoredSchema } from "../toFlexSchema.js";
 import { LeafNodeSchema } from "../leafNodeSchema.js";
 import { assert } from "@fluidframework/core-utils/internal";
 import { isObjectNodeSchema, type ObjectNodeSchema } from "../objectNodeTypes.js";
 import { markSchemaMostDerived } from "./schemaFactory.js";
 import { fail, getOrCreate } from "../../util/index.js";
 import type { MakeNominal } from "../../util/index.js";
-import { walkFieldSchema } from "../walkSchema.js";
+import { walkFieldSchema } from "../walkFieldSchema.js";
 /**
- * Channel for a Fluid Tree DDS.
- * @remarks
- * Allows storing and collaboratively editing schema-aware hierarchial data.
- * @sealed @public
+ * A tree from which a {@link TreeView} can be created.
+ * @system @sealed @public
  */
-export interface ITree extends IFluidLoadable {
+export interface ViewableTree {
 	/**
 	 * Returns a {@link TreeView} using the provided schema.
 	 * If the stored schema is compatible with the view schema specified by `config`,
@@ -68,6 +66,14 @@ export interface ITree extends IFluidLoadable {
 	): TreeView<TRoot>;
 }
 
+/**
+ * Channel for a Fluid Tree DDS.
+ * @remarks
+ * Allows storing and collaboratively editing schema-aware hierarchial data.
+ * @sealed @public
+ */
+export interface ITree extends ViewableTree, IFluidLoadable {}
+
 /**
  * Options when constructing a tree view.
  * @public
@@ -181,7 +187,7 @@ export interface ITreeViewConfiguration<
 }
 
 /**
- * Configuration for {@link ITree.viewWith}.
+ * Configuration for {@link ViewableTree.viewWith}.
  * @sealed @public
  */
 export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema>
@@ -236,7 +242,7 @@ export class TreeViewConfiguration<TSchema extends ImplicitFieldSchema = Implici
 		}
 
 		// Eagerly perform this conversion to surface errors sooner.
-		toFlexSchema(config.schema);
+		toStoredSchema(config.schema);
 	}
 }
 

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

@@ -11,13 +11,9 @@ import {
 	type TreeStatus,
 	isLazy,
 	isTreeValue,
-	FlexObjectNodeSchema,
-	isMapTreeNode,
 	FieldKinds,
 } from "../../feature-libraries/index.js";
 import { fail, extractFromOpaque, isReadonlyArray } from "../../util/index.js";
-
-import { getOrCreateNodeFromFlexTreeNode } from "../proxies.js";
 import { getOrCreateInnerNode } from "../proxyBinding.js";
 import {
 	type TreeLeafValue,
@@ -44,6 +40,9 @@ import {
 	type TreeNode,
 	type TreeChangeEvents,
 	tryGetTreeNodeSchema,
+	getOrCreateNodeFromInnerNode,
+	UnhydratedFlexTreeNode,
+	typeSchemaSymbol,
 } from "../core/index.js";
 import { isObjectNodeSchema } from "../objectNodeTypes.js";
 
@@ -141,7 +140,7 @@ export const treeNodeApi: TreeNodeApi = {
 			return undefined;
 		}
 
-		const output = getOrCreateNodeFromFlexTreeNode(editNode);
+		const output = getOrCreateNodeFromInnerNode(editNode);
 		assert(
 			!isTreeValue(output),
 			0x87f /* Parent can't be a leaf, so it should be a node not a value */,
@@ -231,17 +230,20 @@ export const treeNodeApi: TreeNodeApi = {
 		return tryGetSchema(node) ?? fail("Not a tree node");
 	},
 	shortId(node: TreeNode): number | string | undefined {
+		const schema = node[typeSchemaSymbol];
+		if (!isObjectNodeSchema(schema)) {
+			return undefined;
+		}
+
 		const flexNode = getOrCreateInnerNode(node);
-		const flexSchema = flexNode.flexSchema;
-		const identifierFieldKeys =
-			flexSchema instanceof FlexObjectNodeSchema ? flexSchema.identifierFieldKeys : [];
+		const identifierFieldKeys = schema.identifierFieldKeys;
 
 		switch (identifierFieldKeys.length) {
 			case 0:
 				return undefined;
 			case 1: {
 				const identifier = flexNode.tryGetField(identifierFieldKeys[0] ?? oob())?.boxedAt(0);
-				if (isMapTreeNode(flexNode)) {
+				if (flexNode instanceof UnhydratedFlexTreeNode) {
 					if (identifier === undefined) {
 						throw new UsageError(
 							"Tree.shortId cannot access default identifiers on unhydrated nodes",
@@ -303,7 +305,7 @@ function getStoredKey(node: TreeNode): string | number {
 	// Note: the flex domain strictly works with "stored keys", and knows nothing about the developer-facing
 	// "property keys".
 	const parentField = getOrCreateInnerNode(node).parentField;
-	if (parentField.parent.schema.kind === FieldKinds.sequence.identifier) {
+	if (parentField.parent.schema === FieldKinds.sequence.identifier) {
 		// The parent of `node` is an array node
 		assert(
 			parentField.parent.key === EmptyKey,

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

@@ -25,7 +25,7 @@ import type {
 	ImplicitFieldSchema,
 	ImplicitAllowedTypes,
 } from "../schemaTypes.js";
-import { getSimpleNodeSchema, NodeKind, type TreeNodeSchema } from "../core/index.js";
+import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 import {
 	isTreeValue,
 	stackTreeFieldCursor,
@@ -39,9 +39,9 @@ import {
 	numberSchema,
 	stringSchema,
 } from "../leafNodeSchema.js";
-import { toFlexSchema } from "../toFlexSchema.js";
 import { isObjectNodeSchema } from "../objectNodeTypes.js";
-import { walkFieldSchema } from "../walkSchema.js";
+import { walkFieldSchema } from "../walkFieldSchema.js";
+import { getUnhydratedContext } from "../createContext.js";
 
 /**
  * Verbose encoding of a {@link TreeNode} or {@link TreeValue}.
@@ -174,9 +174,7 @@ export function applySchemaToParserOptions<TCustom>(
 		...options,
 	};
 
-	// TODO: should provide a way to look up schema by name efficiently without converting to flex tree schema and back.
-	// Maybe cache identifier->schema map on simple tree schema lazily.
-	const flexSchema = toFlexSchema(schema);
+	const context = getUnhydratedContext(schema);
 
 	return {
 		valueConverter: config.valueConverter,
@@ -185,9 +183,7 @@ export function applySchemaToParserOptions<TCustom>(
 			: {
 					encode: (type, key: FieldKey): string => {
 						// translate stored key into property key.
-						const flexNodeSchema =
-							flexSchema.nodeSchema.get(brand(type)) ?? fail("missing schema");
-						const simpleNodeSchema = getSimpleNodeSchema(flexNodeSchema);
+						const simpleNodeSchema = context.schema.get(brand(type)) ?? fail("missing schema");
 						if (isObjectNodeSchema(simpleNodeSchema)) {
 							const propertyKey = simpleNodeSchema.storedKeyToPropertyKey.get(key);
 							if (propertyKey !== undefined) {
@@ -208,9 +204,7 @@ export function applySchemaToParserOptions<TCustom>(
 						return key;
 					},
 					parse: (type, inputKey): FieldKey => {
-						const flexNodeSchema =
-							flexSchema.nodeSchema.get(brand(type)) ?? fail("missing schema");
-						const simpleNodeSchema = getSimpleNodeSchema(flexNodeSchema);
+						const simpleNodeSchema = context.schema.get(brand(type)) ?? fail("missing schema");
 						if (isObjectNodeSchema(simpleNodeSchema)) {
 							const info =
 								simpleNodeSchema.flexKeyMap.get(inputKey) ?? fail("missing field info");

package/src/{feature-libraries/typed-schema → simple-tree/api}/view.ts

@@ -12,24 +12,24 @@ import {
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 } from "../../core/index.js";
-import { type Named, fail } from "../../util/index.js";
+import { fail } from "../../util/index.js";
 import {
 	type FullSchemaPolicy,
 	allowsRepoSuperset,
 	isNeverTree,
-} from "../modular-schema/index.js";
+} from "../../feature-libraries/index.js";
 
 /**
  * A collection of View information for schema, including policy.
  */
 export class ViewSchema {
 	/**
-	 * @param storedSchema - Cached conversion of view schema into a stored schema.
+	 * @param schema - Cached conversion of view schema in the stored schema format.
 	 */
 	public constructor(
 		public readonly policy: FullSchemaPolicy,
 		public readonly adapters: Adapters,
-		public readonly storedSchema: TreeStoredSchema,
+		public readonly schema: TreeStoredSchema,
 	) {}
 
 	/**
@@ -50,7 +50,7 @@ export class ViewSchema {
 		// TODO: support adapters
 		// const adapted = this.adaptRepo(stored);
 
-		const read = allowsRepoSuperset(this.policy, stored, this.storedSchema)
+		const read = allowsRepoSuperset(this.policy, stored, this.schema)
 			? Compatibility.Compatible
 			: // TODO: support adapters
 				// : allowsRepoSuperset(this.policy, adapted.adaptedForViewSchema, this.storedSchema)
@@ -58,7 +58,7 @@ export class ViewSchema {
 				Compatibility.Incompatible;
 		// TODO: Extract subset of adapters that are valid to use on stored
 		// TODO: separate adapters from schema updates
-		const write = allowsRepoSuperset(this.policy, this.storedSchema, stored)
+		const write = allowsRepoSuperset(this.policy, this.schema, stored)
 			? Compatibility.Compatible
 			: // TODO: support adapters
 				// : allowsRepoSuperset(this.policy, this.storedSchema, adapted.adaptedForViewSchema)
@@ -74,7 +74,7 @@ export class ViewSchema {
 		let writeAllowingStoredSchemaUpdates =
 			// TODO: This should consider just the updates needed
 			// (ex: when view covers a subset of stored after stored has a update to that subset).
-			allowsRepoSuperset(this.policy, stored, this.storedSchema)
+			allowsRepoSuperset(this.policy, stored, this.schema)
 				? Compatibility.Compatible
 				: // TODO: this assumes adapters can translate in both directions. In general this will not be true.
 					// TODO: this also assumes that schema updates to the adapted repo would translate to
@@ -98,18 +98,12 @@ export class ViewSchema {
 	 */
 	public adaptRepo(stored: TreeStoredSchema): AdaptedViewSchema {
 		// Sanity check on adapters:
-		// it's probably a bug it they use the never types,
+		// it's probably a bug if they use the never types,
 		// since there never is a reason to have a never type as an adapter input,
 		// and its impossible for an adapter to be correctly implemented if its output type is never
 		// (unless its input is also never).
 		for (const adapter of this.adapters?.tree ?? []) {
-			if (
-				isNeverTree(
-					this.policy,
-					this.storedSchema,
-					this.storedSchema.nodeSchema.get(adapter.output),
-				)
-			) {
+			if (isNeverTree(this.policy, this.schema, this.schema.nodeSchema.get(adapter.output))) {
 				fail("tree adapter for stored adapter.output should not be never");
 			}
 		}
@@ -151,10 +145,3 @@ export class ViewSchema {
 		return original;
 	}
 }
-
-/**
- * Record where a schema came from for error reporting purposes.
- */
-export interface Sourced {
-	readonly builder: Named<string>;
-}

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

@@ -8,6 +8,7 @@ import {
 	normalizeFieldSchema,
 	type FieldSchema,
 	type ImplicitAllowedTypes,
+	type ImplicitFieldSchema,
 } from "../schemaTypes.js";
 import type {
 	SimpleArrayNodeSchema,
@@ -26,7 +27,7 @@ import { NodeKind, type TreeNodeSchema } from "../core/index.js";
 /**
  * Converts a "view" schema to a "simple" schema representation.
  */
-export function toSimpleTreeSchema(schema: ImplicitAllowedTypes): SimpleTreeSchema {
+export function toSimpleTreeSchema(schema: ImplicitFieldSchema): SimpleTreeSchema {
 	const normalizedSchema = normalizeFieldSchema(schema);
 
 	const allowedTypes = allowedTypesFromFieldSchema(normalizedSchema);
@@ -34,10 +35,18 @@ export function toSimpleTreeSchema(schema: ImplicitAllowedTypes): SimpleTreeSche
 	const definitions = new Map<string, SimpleNodeSchema>();
 	populateSchemaDefinitionsForField(normalizedSchema, definitions);
 
-	return {
+	const output: Mutable<SimpleTreeSchema> = {
+		kind: normalizedSchema.kind,
 		allowedTypes,
 		definitions,
 	};
+
+	// Include the "description" property only if it's present on the input.
+	if (normalizedSchema.metadata?.description !== undefined) {
+		output.description = normalizedSchema.metadata.description;
+	}
+
+	return output;
 }
 
 /**