@fluidframework/tree 2.41.0-338186 → 2.41.0

package/src/simple-tree/{objectNode.ts → node-kinds/object/objectNode.ts}

@@ -5,33 +5,19 @@
 
 import { assert, Lazy, fail, debugAssert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+import { createIdCompressor } from "@fluidframework/id-compressor/internal";
 
-import type { FieldKey, SchemaPolicy } from "../core/index.js";
+import type { FieldKey, SchemaPolicy } from "../../../core/index.js";
 import {
 	FieldKinds,
 	type FlexTreeField,
 	type FlexTreeNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
-} from "../feature-libraries/index.js";
-import { getTreeNodeForField } from "./proxies.js";
-import {
-	type ImplicitFieldSchema,
-	getStoredKey,
-	getExplicitStoredKey,
-	type TreeFieldFromImplicitField,
-	type InsertableTreeFieldFromImplicitField,
-	type FieldSchema,
-	normalizeFieldSchema,
-	type ImplicitAllowedTypes,
-	FieldKind,
-	type NodeSchemaMetadata,
-	type FieldSchemaAlpha,
-	ObjectFieldSchema,
-	type ImplicitAnnotatedFieldSchema,
-	unannotateSchemaRecord,
-	type UnannotateSchemaRecord,
-} from "./schemaTypes.js";
+} from "../../../feature-libraries/index.js";
+import { type RestrictiveStringRecord, type FlattenKeys, brand } from "../../../util/index.js";
+
 import {
 	type TreeNodeSchema,
 	NodeKind,
@@ -44,18 +30,36 @@ import {
 	type Context,
 	UnhydratedFlexTreeNode,
 	getOrCreateInnerNode,
-} from "./core/index.js";
-import { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
-import { prepareForInsertion } from "./prepareForInsertion.js";
-import type { RestrictiveStringRecord, FlattenKeys } from "../util/index.js";
+} from "../../core/index.js";
+import { getUnhydratedContext } from "../../createContext.js";
+import { getTreeNodeForField } from "../../getTreeNodeForField.js";
 import {
 	isObjectNodeSchema,
 	type ObjectNodeSchema,
 	type ObjectNodeSchemaInternalData,
 } from "./objectNodeTypes.js";
-import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
-import { getUnhydratedContext } from "./createContext.js";
-import type { SimpleObjectFieldSchema } from "./simpleSchema.js";
+import { prepareForInsertion } from "../../prepareForInsertion.js";
+import {
+	type ImplicitFieldSchema,
+	getStoredKey,
+	getExplicitStoredKey,
+	type TreeFieldFromImplicitField,
+	type InsertableTreeFieldFromImplicitField,
+	type FieldSchema,
+	normalizeFieldSchema,
+	type ImplicitAllowedTypes,
+	FieldKind,
+	type NodeSchemaMetadata,
+	type FieldSchemaAlpha,
+	ObjectFieldSchema,
+	type ImplicitAnnotatedFieldSchema,
+	unannotateSchemaRecord,
+	type UnannotateSchemaRecord,
+} from "../../schemaTypes.js";
+import type { SimpleObjectFieldSchema } from "../../simpleSchema.js";
+import { mapTreeFromNodeData, type InsertableContent } from "../../toMapTree.js";
+import { TreeNodeValid, type MostDerivedData } from "../../treeNodeValid.js";
+import { stringSchema } from "../../leafNodeSchema.js";
 
 /**
  * Generates the properties for an ObjectNode from its field schema object.
@@ -197,6 +201,37 @@ function createFlexKeyMapping(fields: Record<string, ImplicitFieldSchema>): Simp
 	return keyMap;
 }
 
+const globalIdentifierAllocator: IIdCompressor = createIdCompressor();
+
+/**
+ * Modify `flexNode` to add a newly generated identifier under the given `storedKey`.
+ * @remarks
+ * This is used after checking if the user is trying to read an identifier field of an unhydrated node, but the identifier is not present.
+ * This means the identifier is an "auto-generated identifier", because otherwise it would have been supplied by the user at construction time and would have been successfully read just above.
+ * In this case, it is categorically impossible to provide an identifier (auto-generated identifiers can't be created until hydration/insertion time), so we emit an error.
+ * @privateRemarks
+ * TODO: this special case logic should move to the inner node (who's schema claims it has an identifier), rather than here, after we already read undefined out of a required field.
+ * TODO: unify this with a more general defaults mechanism.
+ */
+export function lazilyAllocateIdentifier(
+	flexNode: UnhydratedFlexTreeNode,
+	storedKey: FieldKey,
+): string {
+	debugAssert(() => !flexNode.mapTree.fields.has(storedKey) || "Identifier field already set");
+	const value = globalIdentifierAllocator.decompress(
+		globalIdentifierAllocator.generateCompressedId(),
+	);
+	flexNode.mapTree.fields.set(storedKey, [
+		{
+			type: brand(stringSchema.identifier),
+			value,
+			fields: new Map(),
+		},
+	]);
+
+	return value;
+}
+
 /**
  * Creates a proxy handler for the given schema.
  *
@@ -230,17 +265,11 @@ function createProxyHandler(
 					return getTreeNodeForField(field);
 				}
 
-				// TODO: this special case logic should move to the inner node (who's schema claims it has an identifier), rather than here, after we already read undefined out of a required field.
-				// Check if the user is trying to read an identifier field of an unhydrated node, but the identifier is not present.
-				// This means the identifier is an "auto-generated identifier", because otherwise it would have been supplied by the user at construction time and would have been successfully read just above.
-				// In this case, it is categorically impossible to provide an identifier (auto-generated identifiers can't be created until hydration/insertion time), so we emit an error.
 				if (
 					fieldInfo.schema.kind === FieldKind.Identifier &&
 					flexNode instanceof UnhydratedFlexTreeNode
 				) {
-					throw new UsageError(
-						"An automatically generated node identifier may not be queried until the node is inserted into the tree",
-					);
+					return lazilyAllocateIdentifier(flexNode, fieldInfo.storedKey);
 				}
 
 				return undefined;

package/src/simple-tree/{objectNodeTypes.ts → node-kinds/object/objectNodeTypes.ts}

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { RestrictiveStringRecord } from "../util/index.js";
+import type { RestrictiveStringRecord } from "../../../util/index.js";
 import type {
 	TreeObjectNode,
 	SimpleKeyMap,
@@ -13,10 +13,10 @@ import type {
 	FieldSchemaAlpha,
 	ImplicitAnnotatedFieldSchema,
 	UnannotateSchemaRecord,
-} from "./schemaTypes.js";
-import { NodeKind, type TreeNodeSchemaClass, type TreeNodeSchema } from "./core/index.js";
-import type { FieldKey } from "../core/index.js";
-import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "./simpleSchema.js";
+} from "../../schemaTypes.js";
+import { NodeKind, type TreeNodeSchemaClass, type TreeNodeSchema } from "../../core/index.js";
+import type { FieldKey } from "../../../core/index.js";
+import type { SimpleObjectFieldSchema, SimpleObjectNodeSchema } from "../../simpleSchema.js";
 
 /**
  * A schema for {@link TreeObjectNode}s.

package/src/simple-tree/prepareForInsertion.ts

@@ -12,13 +12,19 @@ import type {
 	NodeIndex,
 	FieldKey,
 	DetachedField,
+	TreeFieldStoredSchema,
 } from "../core/index.js";
 import {
 	type FlexTreeContext,
 	getSchemaAndPolicy,
 	type FlexTreeHydratedContext,
+	FieldKinds,
 } from "../feature-libraries/index.js";
-import type { ImplicitAllowedTypes, ImplicitFieldSchema } from "./schemaTypes.js";
+import {
+	normalizeFieldSchema,
+	type ImplicitAllowedTypes,
+	type ImplicitFieldSchema,
+} from "./schemaTypes.js";
 import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { brand } from "../util/index.js";
@@ -28,12 +34,17 @@ import {
 	tryUnhydratedFlexTreeNode,
 	unhydratedFlexTreeNodeToTreeNode,
 } from "./core/index.js";
-import { debugAssert } from "@fluidframework/core-utils/internal";
+import { debugAssert, oob } from "@fluidframework/core-utils/internal";
+import { inSchemaOrThrow, isFieldInSchema } from "../feature-libraries/index.js";
+import { convertField } from "./toStoredSchema.js";
 
 /**
  * Prepare content from a user for insertion into a tree.
  * @remarks
  * This validates and converts the input, and if necessary invokes {@link prepareContentForHydration}.
+ *
+ * The next edit made to `destinationContext`'s forest must be the creation of a detached field containing this content,
+ * (Triggering {@link ForestEvents.afterRootFieldCreated}) otherwise hydration will break.
  */
 export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 	data: TIn,
@@ -50,13 +61,18 @@ export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 
 /**
  * {@link prepareForInsertion} but batched for array content.
+ * @remarks
+ * This is for inserting items into an array, not a inserting a {@link TreeArrayNode} (that would use {@link prepareForInsertion}).
+ *
+ * The next edits made to `destinationContext`'s forest must be the creation of a detached field.
+ * One edit for each item in `data`, in order.
+ *
  * @privateRemarks
- * TODO:
- * Experimentally it was determined that making separate calls to prepareContentForHydration for each array item did not work.
- * This should be understood and fixed or have the factors that cause it clearly documented.
- * If fixed, this function should be removed, and arrays can just map over prepareForInsertion.
+ * This has to be done as a single operation for all items in data
+ * (as opposed to mapping {@link prepareForInsertion} over the array)
+ * due to how the eventing in prepareContentForHydration works.
  */
-export function prepareArrayForInsertion(
+export function prepareArrayContentForInsertion(
 	data: readonly InsertableContent[],
 	schema: ImplicitAllowedTypes,
 	destinationContext: FlexTreeContext,
@@ -66,19 +82,27 @@ export function prepareArrayForInsertion(
 			item,
 			schema,
 			destinationContext.isHydrated() ? destinationContext.nodeKeyManager : undefined,
-			getSchemaAndPolicy(destinationContext),
 		),
 	);
 
-	if (destinationContext.isHydrated()) {
-		prepareContentForHydration(mapTrees, destinationContext.checkout.forest);
-	}
+	const fieldSchema = convertField(normalizeFieldSchema(schema));
+
+	validateAndPrepare(
+		getSchemaAndPolicy(destinationContext),
+		destinationContext.isHydrated() ? destinationContext : undefined,
+		{ kind: FieldKinds.sequence.identifier, types: fieldSchema.types },
+		mapTrees,
+	);
 
 	return mapTrees;
 }
 
 /**
  * Split out from {@link prepareForInsertion} as to allow use without a context.
+ *
+ * @param hydratedData - If specified, the `mapTrees` will be prepared for hydration into this context.
+ * `undefined` when `mapTrees` are being inserted into an {@link Unhydrated} tree.
+ *
  * @remarks
  * Adding this entry point is a workaround for initialize not currently having a context.
  */
@@ -88,18 +112,34 @@ export function prepareForInsertionContextless<TIn extends InsertableContent | u
 	schemaAndPolicy: SchemaAndPolicy,
 	hydratedData: Pick<FlexTreeHydratedContext, "checkout" | "nodeKeyManager"> | undefined,
 ): TIn extends undefined ? undefined : ExclusiveMapTree {
-	const mapTree = mapTreeFromNodeData(
-		data,
-		schema,
-		hydratedData?.nodeKeyManager,
-		schemaAndPolicy,
-	);
+	const mapTree = mapTreeFromNodeData(data, schema, hydratedData?.nodeKeyManager);
 
-	if (mapTree !== undefined && hydratedData !== undefined) {
-		prepareContentForHydration([mapTree], hydratedData.checkout.forest);
-	}
+	const contentArray = mapTree === undefined ? [] : [mapTree];
+	const fieldSchema = convertField(normalizeFieldSchema(schema));
+	validateAndPrepare(schemaAndPolicy, hydratedData, fieldSchema, contentArray);
+
+	return mapTree;
+}
 
-	return mapTree as TIn extends undefined ? undefined : ExclusiveMapTree;
+/**
+ * If hydrating, do a final validation against the schema and prepare the content for hydration.
+ *
+ * @param hydratedData - If specified, the `mapTrees` will be prepared for hydration into this context.
+ * `undefined` when `mapTrees` are being inserted into an {@link Unhydrated} tree.
+ */
+function validateAndPrepare(
+	schemaAndPolicy: SchemaAndPolicy,
+	hydratedData: Pick<FlexTreeHydratedContext, "checkout" | "nodeKeyManager"> | undefined,
+	fieldSchema: TreeFieldStoredSchema,
+	mapTrees: ExclusiveMapTree[],
+): void {
+	if (hydratedData !== undefined) {
+		if (schemaAndPolicy.policy.validateSchema === true) {
+			const maybeError = isFieldInSchema(mapTrees, fieldSchema, schemaAndPolicy);
+			inSchemaOrThrow(maybeError);
+		}
+		prepareContentForHydration(mapTrees, hydratedData.checkout.forest);
+	}
 }
 
 /**
@@ -164,7 +204,7 @@ function prepareContentForHydration(
 		});
 	}
 
-	bindTreeNodes(batches, forest);
+	scheduleHydration(batches, forest);
 }
 
 function walkMapTree(
@@ -206,12 +246,13 @@ function walkMapTree(
 }
 
 /**
- * Register a collection of nodes with the forest so that they can be hydrated.
+ * Register events which will hydrate batches of nodes when they are inserted.
+ * The next edits to forest must be their insertions, in order, or data corruption can occur.
  * @param locatedNodes - the nodes to register with the forest.
  * Each index in this array expects its content to be added and produce its own `afterRootFieldCreated` event.
  * If array subsequence insertion is optimized to produce a single event, this will not work correctly as is, and will need to be modified to take in a single {@link LocatedNodesBatch}.
  */
-function bindTreeNodes(
+function scheduleHydration(
 	locatedNodes: readonly LocatedNodesBatch[],
 	forest: IForestSubscription,
 ): void {
@@ -220,13 +261,12 @@ function bindTreeNodes(
 		// Creating a new array emits one event per element in the array, so listen to the event once for each element
 		let i = 0;
 		const off = forest.events.on("afterRootFieldCreated", (fieldKey) => {
-			// Non null asserting here because of the length check above
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			const batch = locatedNodes[i]!;
+			// Indexing is safe here because of the length check above. This assumes the array has not been modified which should be the case.
+			const batch = locatedNodes[i] ?? oob();
 			debugAssert(() => batch.rootPath.parentField === placeholderKey);
 			batch.rootPath.parentField = brand(fieldKey);
 			for (const { path, node } of batch.paths) {
-				getKernel(node).anchorProxy(forest.anchors, path);
+				getKernel(node).hydrate(forest.anchors, path);
 			}
 			if (++i === locatedNodes.length) {
 				off();

package/src/simple-tree/schemaTypes.ts

@@ -7,6 +7,7 @@ import type { ErasedType, IFluidHandle } from "@fluidframework/core-interfaces";
 import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
+import type { FieldKey } from "../core/index.js";
 import type { NodeIdentifierManager } from "../feature-libraries/index.js";
 import {
 	type MakeNominal,
@@ -20,6 +21,7 @@ import {
 	type RestrictiveStringRecord,
 	type IsUnion,
 } from "../util/index.js";
+
 import type {
 	Unhydrated,
 	NodeKind,
@@ -30,12 +32,11 @@ import type {
 	TreeNodeSchemaNonClass,
 } from "./core/index.js";
 import { inPrototypeChain } from "./core/index.js";
-import type { FieldKey } from "../core/index.js";
-import type { InsertableContent } from "./toMapTree.js";
 import { isLazy, type FlexListToUnion, type LazyItem } from "./flexList.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
-import { TreeNodeValid } from "./treeNodeValid.js";
 import type { SimpleFieldSchema, SimpleObjectFieldSchema } from "./simpleSchema.js";
+import type { InsertableContent } from "./toMapTree.js";
+import { TreeNodeValid } from "./treeNodeValid.js";
 
 /**
  * Returns true if the given schema is a {@link TreeNodeSchemaClass}, or otherwise false if it is a {@link TreeNodeSchemaNonClass}.

package/src/simple-tree/simpleSchema.ts

@@ -4,6 +4,7 @@
  */
 
 import type { ValueSchema } from "../core/index.js";
+
 import type { NodeKind } from "./core/index.js";
 import type { FieldKind, FieldSchemaMetadata, NodeSchemaMetadata } from "./schemaTypes.js";
 

package/src/simple-tree/toMapTree.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, fail } from "@fluidframework/core-utils/internal";
+import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 
@@ -13,7 +13,6 @@ import {
 	type MapTree,
 	type TreeValue,
 	type ValueSchema,
-	type SchemaAndPolicy,
 	type ExclusiveMapTree,
 } from "../core/index.js";
 import {
@@ -47,8 +46,12 @@ import {
 	type Unhydrated,
 	UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { SchemaValidationErrors, isNodeInSchema } from "../feature-libraries/index.js";
-import { isObjectNodeSchema } from "./objectNodeTypes.js";
+// Required to prevent the introduction of new circular dependencies
+// TODO: Having the schema provide their own policy functions for compatibility which
+// toMapTree invokes instead of manually handling each kind would remove this bad
+// dependency, and reduce coupling.
+// eslint-disable-next-line import/no-internal-modules
+import { isObjectNodeSchema } from "./node-kinds/object/objectNodeTypes.js";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
 /**
@@ -85,40 +88,13 @@ import type { IFluidHandle } from "@fluidframework/core-interfaces";
  * @param schemaValidationPolicy - The stored schema and policy to be used for validation, if the policy says schema
  * validation should happen. If it does, the input tree will be validated against this schema + policy, and an error will
  * be thrown if the tree does not conform to the schema. If undefined, no validation against the stored schema is done.
- *
- * TODO:BUG: AB#9131
- * This schema validation is done before defaults are provided.
- * This can not easily be fixed by reordering things within this implementation since even at the end of this function defaults requiring a context may not have been filled.
- * This means schema validation reject required fields getting their value from a default like identifier fields.
- *
  * @remarks The resulting tree will be populated with any defaults from {@link FieldProvider}s in the schema.
- *
- * @privateRemarks
- * TODO: AB#9126 AB#9131
- * When an app wants schema validation, we should ensure data is validated. Doing the validation here is not robust (since many callers to this don't have a context and thus can't opt into validation).
- * Additionally the validation here does not correctly handle default values, and introduces a second schema representation which is a bit odd API wise as its typically derivable from the view schema.
- * It may make more sense to validate when hydrating the MapTreeNode when the context is known and the defaults are available.
- * Applying the "parse don't validate" idiom here could help ensuring we capture when the validation optionally happens in the type system to avoid missing or redundant validation,
- * as well as ensuring validation happens after defaulting (or can handle validating data missing defaults)
  */
-export function mapTreeFromNodeData(
-	data: InsertableContent,
-	allowedTypes: ImplicitAllowedTypes,
-	context?: NodeIdentifierManager,
-	schemaValidationPolicy?: SchemaAndPolicy,
-): ExclusiveMapTree;
-export function mapTreeFromNodeData(
-	data: InsertableContent | undefined,
-	allowedTypes: ImplicitFieldSchema,
-	context?: NodeIdentifierManager,
-	schemaValidationPolicy?: SchemaAndPolicy,
-): ExclusiveMapTree | undefined;
-export function mapTreeFromNodeData(
-	data: InsertableContent | undefined,
+export function mapTreeFromNodeData<TIn extends InsertableContent | undefined>(
+	data: TIn,
 	allowedTypes: ImplicitFieldSchema,
 	context?: NodeIdentifierManager,
-	schemaValidationPolicy?: SchemaAndPolicy,
-): ExclusiveMapTree | undefined {
+): TIn extends undefined ? undefined : ExclusiveMapTree {
 	const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
 
 	if (data === undefined) {
@@ -126,24 +102,14 @@ export function mapTreeFromNodeData(
 		if (normalizedFieldSchema.kind !== FieldKind.Optional) {
 			throw new UsageError("Got undefined for non-optional field.");
 		}
-		return undefined;
+		return undefined as TIn extends undefined ? undefined : ExclusiveMapTree;
 	}
 
 	const mapTree = nodeDataToMapTree(data, normalizedFieldSchema.allowedTypeSet);
 	// Add what defaults can be provided. If no `context` is providing, some defaults may still be missing.
 	addDefaultsToMapTree(mapTree, normalizedFieldSchema.allowedTypes, context);
 
-	if (schemaValidationPolicy?.policy.validateSchema === true) {
-		// TODO: BUG: AB#9131
-		// Since some defaults may still be missing, this can give false positives when context is undefined but schemaValidationPolicy is provided.
-		// For now disable this check when context is undefined:
-		if (context !== undefined) {
-			const maybeError = isNodeInSchema(mapTree, schemaValidationPolicy);
-			inSchemaOrThrow(maybeError);
-		}
-	}
-
-	return mapTree;
+	return mapTree as TIn extends undefined ? undefined : ExclusiveMapTree;
 }
 
 /**
@@ -196,21 +162,12 @@ function nodeDataToMapTree(
 			result = objectToMapTree(data, schema);
 			break;
 		default:
-			fail(0xae0 /* Unrecognized schema kind */);
+			unreachableCase(schema.kind);
 	}
 
 	return result;
 }
 
-/**
- * Throws a UsageError if maybeError indicates a tree is out of schema.
- */
-export function inSchemaOrThrow(maybeError: SchemaValidationErrors): void {
-	if (maybeError !== SchemaValidationErrors.NoError) {
-		throw new UsageError("Tree does not conform to schema.");
-	}
-}
-
 /**
  * Transforms data under a Leaf schema.
  * @param data - The tree data to be transformed. Must be a {@link TreeValue}.

package/src/simple-tree/toStoredSchema.ts

@@ -21,16 +21,17 @@ import {
 } from "../core/index.js";
 import { FieldKinds, type FlexFieldKind } from "../feature-libraries/index.js";
 import { brand, getOrCreate } from "../util/index.js";
+
 import { NodeKind } from "./core/index.js";
-import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
-import { walkFieldSchema } from "./walkFieldSchema.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
+import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
 import type {
 	SimpleFieldSchema,
 	SimpleNodeSchema,
 	SimpleNodeSchemaBase,
 	SimpleTreeSchema,
 } from "./simpleSchema.js";
+import { walkFieldSchema } from "./walkFieldSchema.js";
 
 const viewToStoredCache = new WeakMap<ImplicitFieldSchema, TreeStoredSchema>();
 

package/src/simple-tree/treeNodeValid.ts

@@ -4,6 +4,9 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { type FlexTreeNode, isFlexTreeNode } from "../feature-libraries/index.js";
 
 import {
 	type TreeNodeSchema,
@@ -18,9 +21,6 @@ import {
 	type Context,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
-import { type FlexTreeNode, isFlexTreeNode } from "../feature-libraries/index.js";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
-
 import { getSimpleNodeSchemaFromInnerNode } from "./core/index.js";
 import { markEager } from "./flexList.js";
 

package/src/simple-tree/walkFieldSchema.ts

@@ -4,7 +4,6 @@
  */
 
 import { type TreeNodeSchema, walkAllowedTypes, type SchemaVisitor } from "./core/index.js";
-
 import { type ImplicitFieldSchema, normalizeFieldSchema } from "./schemaTypes.js";
 
 /**