@fluidframework/tree 2.4.0-299374 → 2.4.0

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

@@ -3,8 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { TreeLeafValue } from "../schemaTypes.js";
-import type { InternalTreeNode, TreeNode, Unhydrated } from "./types.js";
+import type { InternalTreeNode, Unhydrated } from "./types.js";
 
 /**
  * Schema for a tree node.
@@ -20,7 +19,7 @@ import type { InternalTreeNode, TreeNode, Unhydrated } from "./types.js";
 export type TreeNodeSchema<
 	Name extends string = string,
 	Kind extends NodeKind = NodeKind,
-	TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue,
+	TNode = unknown,
 	TBuild = never,
 	ImplicitlyConstructable extends boolean = boolean,
 	Info = unknown,
@@ -39,7 +38,7 @@ export type TreeNodeSchema<
 export interface TreeNodeSchemaNonClass<
 	out Name extends string = string,
 	out Kind extends NodeKind = NodeKind,
-	out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue,
+	out TNode = unknown,
 	in TInsertable = never,
 	out ImplicitlyConstructable extends boolean = boolean,
 	out Info = unknown,
@@ -95,8 +94,7 @@ export interface TreeNodeSchemaNonClass<
 export interface TreeNodeSchemaClass<
 	out Name extends string = string,
 	out Kind extends NodeKind = NodeKind,
-	// TODO: maybe this can be more specific (exclude leaves)
-	out TNode extends TreeNode | TreeLeafValue = TreeNode | TreeLeafValue,
+	out TNode = unknown,
 	in TInsertable = never,
 	out ImplicitlyConstructable extends boolean = boolean,
 	out Info = unknown,
@@ -117,7 +115,7 @@ export interface TreeNodeSchemaClass<
 export type TreeNodeSchemaBoth<
 	Name extends string = string,
 	Kind extends NodeKind = NodeKind,
-	TNode extends TreeNode = TreeNode,
+	TNode = unknown,
 	TInsertable = never,
 	ImplicitlyConstructable extends boolean = boolean,
 	Info = unknown,

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

@@ -445,7 +445,7 @@ class EagerMapTreeRequiredField
 		// This cannot use ?? since null is a legal value here.
 		assert(
 			super.content !== undefined,
-			"Expected EagerMapTree required field to have a value",
+			0xa57 /* Expected EagerMapTree required field to have a value */,
 		);
 		return super.content;
 	}

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

@@ -3,9 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { TreeLeafValue } from "../schemaTypes.js";
 import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
-import type { TreeNode } from "./types.js";
 
 /**
  * The type of a {@link TreeNode}.
@@ -89,12 +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,
-		TreeNode | TreeLeafValue,
-		never,
-		boolean,
-		TInfo
-	>;
+	get [typeSchemaSymbol](): TreeNodeSchemaClass<TName, TKind, unknown, never, boolean, TInfo>;
 }

package/src/simple-tree/index.ts

@@ -92,11 +92,6 @@ export {
 	type NodeBuilderDataUnsafe,
 	type NodeFromSchemaUnsafe,
 	type ReadonlyMapInlined,
-	type TreeNodeSchemaClassUnsafe,
-	type TreeNodeSchemaUnsafe,
-	type AllowedTypesUnsafe,
-	type TreeNodeSchemaNonClassUnsafe,
-	type TreeViewAlpha,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,
@@ -118,9 +113,6 @@ export {
 	normalizeFieldSchema,
 	type ApplyKind,
 	type FieldSchemaMetadata,
-	type InsertableField,
-	type Insertable,
-	type UnsafeUnknownSchema,
 } from "./schemaTypes.js";
 export {
 	getTreeNodeForField,
@@ -130,7 +122,6 @@ export {
 	TreeArrayNode,
 	IterableTreeArrayContent,
 	type TreeArrayNodeBase,
-	type ReadonlyArrayNode,
 } from "./arrayNode.js";
 export {
 	type FieldHasDefault,
@@ -140,12 +131,7 @@ export {
 	setField,
 } from "./objectNode.js";
 export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
-export {
-	mapTreeFromNodeData,
-	type InsertableContent,
-	type FactoryContent,
-	type FactoryContentObject,
-} from "./toMapTree.js";
+export { mapTreeFromNodeData, type InsertableContent } from "./toMapTree.js";
 export { toStoredSchema, getStoredSchema } from "./toFlexSchema.js";
 export {
 	numberSchema,

package/src/simple-tree/schemaTypes.ts

@@ -14,7 +14,6 @@ import type {
 	NodeKind,
 	TreeNodeSchema,
 	TreeNodeSchemaClass,
-	TreeNode,
 } from "./core/index.js";
 import type { FieldKey } from "../core/index.js";
 import type { InsertableContent } from "./toMapTree.js";
@@ -26,7 +25,7 @@ import { isLazy, type FlexListToUnion, type LazyItem } from "./flexList.js";
 export function isTreeNodeSchemaClass<
 	Name extends string,
 	Kind extends NodeKind,
-	TNode extends TreeNode | TreeLeafValue,
+	TNode,
 	TBuild,
 	ImplicitlyConstructable extends boolean,
 	Info,
@@ -382,17 +381,7 @@ export type ImplicitAllowedTypes = AllowedTypes | TreeNodeSchema;
 export type ImplicitFieldSchema = FieldSchema | ImplicitAllowedTypes;
 
 /**
- * Converts an `ImplicitFieldSchema` to a property type suitable for reading a field with this that schema.
- *
- * @typeparam TSchema - When non-exact schema are provided this errors on the side of returning too general of a type (a conservative union of all possibilities).
- * This is ideal for "output APIs" - i.e. it converts the schema type to the runtime type that a user will _read_ from the tree.
- * Examples of such "non-exact" schema include `ImplicitFieldSchema`, `ImplicitAllowedTypes`, and  TypeScript unions of schema types.
- * @privateRemarks
- * TODO:
- * There are two known problematic usages of this type (which produce invalid/unsound results when given non-specific schema):
- * 1. setters for fields (on object nodes the Tree.view.root).
- * 2. Indirectly in InsertableTreeFieldFromImplicitField via InsertableTypedNode including NodeFromSchema.
- * These cases should be mitigated by introducing a way to detect inexact schema and special casing them in these two places.
+ * Converts ImplicitFieldSchema to the corresponding tree node's field type.
  * @public
  */
 export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = FieldSchema> =
@@ -400,7 +389,7 @@ export type TreeFieldFromImplicitField<TSchema extends ImplicitFieldSchema = Fie
 		? ApplyKind<TreeNodeFromImplicitAllowedTypes<Types>, Kind, false>
 		: TSchema extends ImplicitAllowedTypes
 			? TreeNodeFromImplicitAllowedTypes<TSchema>
-			: TreeNode | TreeLeafValue | undefined;
+			: unknown;
 
 /**
  * Type of content that can be inserted into the tree for a field of the given schema.
@@ -412,55 +401,7 @@ export type InsertableTreeFieldFromImplicitField<
 	? ApplyKind<InsertableTreeNodeFromImplicitAllowedTypes<Types>, Kind, true>
 	: TSchema extends ImplicitAllowedTypes
 		? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>
-		: never;
-
-/**
- * {@inheritdoc (UnsafeUnknownSchema:type)}
- * @alpha
- */
-export const UnsafeUnknownSchema: unique symbol = Symbol("UnsafeUnknownSchema");
-
-/**
- * A special type which can be provided to some APIs as the schema type parameter when schema cannot easily be provided at compile time and an unsafe (instead of disabled) editing API is desired.
- * @remarks
- * When used this means the TypeScript typing should error on the side of completeness (allow all inputs that could be valid).
- * This introduces the risk that out of schema data could be allowed at compile time, and only error at runtime.
- *
- * @privateRemarks
- * This only applies to APIs which input data which is expected to be in schema, since APIs outputting have easy mechanisms to do so in a type safe way even when the schema is unknown.
- * In most cases that amounts to returning `TreeNode | TreeLeafValue`.
- *
- * This can be contrasted with the default behavior of TypeScript, which is to require the intersection of the possible types for input APIs,
- * which for unknown schema defining input trees results in the `never` type.
- *
- * Any APIs which use this must produce UsageErrors when out of schema data is encountered, and never produce unrecoverable errors,
- * or silently accept invalid data.
- * This is currently only type exported from the package: the symbol is just used as a way to get a named type.
- * @alpha
- */
-export type UnsafeUnknownSchema = typeof UnsafeUnknownSchema;
-
-/**
- * Content which could be inserted into a tree.
- * @remarks
- * Extended version of {@link InsertableTreeNodeFromImplicitAllowedTypes} that also allows {@link (UnsafeUnknownSchema:type)}.
- * @alpha
- */
-export type Insertable<TSchema extends ImplicitAllowedTypes | UnsafeUnknownSchema> =
-	TSchema extends ImplicitAllowedTypes
-		? InsertableTreeNodeFromImplicitAllowedTypes<TSchema>
-		: InsertableContent;
-
-/**
- * Content which could be inserted into a field within a tree.
- * @remarks
- * Extended version of {@link InsertableTreeFieldFromImplicitField} that also allows {@link (UnsafeUnknownSchema:type)}.
- * @alpha
- */
-export type InsertableField<TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema> =
-	TSchema extends ImplicitFieldSchema
-		? InsertableTreeFieldFromImplicitField<TSchema>
-		: InsertableContent | undefined;
+		: unknown;
 
 /**
  * Suitable for output.
@@ -512,10 +453,6 @@ export type NodeFromSchema<T extends TreeNodeSchema> = T extends TreeNodeSchema<
 /**
  * Data which can be used as a node to be inserted.
  * Either an unhydrated node, or content to build a new node.
- * @privateRemarks
- * TODO:
- * This should behave contravariantly, but it uses NodeFromSchema which behaves covariantly.
- * This results in unsoundness where when the schema is less specific, more types are allowed instead of less.
  * @public
  */
 export type InsertableTypedNode<T extends TreeNodeSchema> =
@@ -534,7 +471,7 @@ export type InsertableTypedNode<T extends TreeNodeSchema> =
 export type NodeBuilderData<T extends TreeNodeSchema> = T extends TreeNodeSchema<
 	string,
 	NodeKind,
-	TreeNode | TreeLeafValue,
+	unknown,
 	infer TBuild
 >
 	? TBuild

package/src/simple-tree/toFlexSchema.ts

@@ -98,7 +98,7 @@ export function getStoredSchema(schema: TreeNodeSchema): TreeNodeStoredSchema {
 	const kind = schema.kind;
 	switch (kind) {
 		case NodeKind.Leaf: {
-			assert(schema instanceof LeafNodeSchema, "invalid kind");
+			assert(schema instanceof LeafNodeSchema, 0xa4a /* invalid kind */);
 			return new LeafNodeStoredSchema(schema.info);
 		}
 		case NodeKind.Map: {
@@ -116,7 +116,7 @@ export function getStoredSchema(schema: TreeNodeSchema): TreeNodeStoredSchema {
 			return new ObjectNodeStoredSchema(fields);
 		}
 		case NodeKind.Object: {
-			assert(isObjectNodeSchema(schema), "invalid kind");
+			assert(isObjectNodeSchema(schema), 0xa4b /* invalid kind */);
 			const fields: Map<FieldKey, TreeFieldStoredSchema> = new Map();
 			for (const field of schema.flexKeyMap.values()) {
 				fields.set(field.storedKey, convertField(field.schema));

package/src/simple-tree/toMapTree.ts

@@ -726,7 +726,6 @@ function tryGetInnerNode(target: unknown): InnerNode | undefined {
  * Content which can be used to build a node.
  * @remarks
  * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
- * @system @alpha
  */
 export type FactoryContent =
 	| IFluidHandle
@@ -745,14 +744,12 @@ export type FactoryContent =
  * Can contain unhydrated nodes, but can not be an unhydrated node at the root.
  *
  * Supports object and map nodes.
- * @system @alpha
  */
-export type FactoryContentObject = {
+type FactoryContentObject = {
 	readonly [P in string]?: InsertableContent;
 };
 
 /**
  * Content which can be inserted into a tree.
- * @system @alpha
  */
 export type InsertableContent = Unhydrated<TreeNode> | FactoryContent;