@fluidframework/tree 2.3.1 → 2.4.0-297027

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,
@@ -19,14 +20,14 @@ import type {
 	SimpleTreeSchema,
 } from "./simpleSchema.js";
 import type { ValueSchema } from "../../core/index.js";
-import { getOrCreate } from "../../util/index.js";
+import { getOrCreate, type Mutable } from "../../util/index.js";
 import { isObjectNodeSchema, type ObjectNodeSchema } from "../objectNodeTypes.js";
 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;
 }
 
 /**
@@ -126,11 +135,16 @@ function fieldSchemaToSimpleSchema(schema: FieldSchema): SimpleFieldSchema {
 	}
 
 	const allowedTypes = allowedTypesFromFieldSchema(schema);
-	const result = {
+	const result: Mutable<SimpleFieldSchema> = {
 		kind: schema.kind,
 		allowedTypes,
 	};
 
+	// Don't include "description" property at all if it's not present.
+	if (schema.metadata?.description !== undefined) {
+		result.description = schema.metadata.description;
+	}
+
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	(schema as any)[simpleFieldSchemaCacheSymbol] = result;