@fluidframework/tree 2.1.0-281041 → 2.2.0

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

@@ -0,0 +1,179 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils/internal";
+
+import type { ITreeCursorSynchronous, SchemaAndPolicy } from "../../core/index.js";
+import { fail } from "../../util/index.js";
+import type {
+	TreeLeafValue,
+	ImplicitFieldSchema,
+	InsertableTreeFieldFromImplicitField,
+	TreeFieldFromImplicitField,
+	FieldSchema,
+	FieldKind,
+} from "../schemaTypes.js";
+import type { Unhydrated } from "../core/index.js";
+import {
+	cursorForMapTreeNode,
+	defaultSchemaPolicy,
+	FieldKinds,
+	intoStoredSchema,
+	mapTreeFromCursor,
+	type NodeKeyManager,
+} from "../../feature-libraries/index.js";
+import { getOrCreateNodeFromFlexTreeNode, type InsertableContent } from "../proxies.js";
+import { getOrCreateMapTreeNode, isFieldInSchema } from "../../feature-libraries/index.js";
+import { toFlexSchema } from "../toFlexSchema.js";
+import { inSchemaOrThrow, mapTreeFromNodeData } from "../toMapTree.js";
+import {
+	applySchemaToParserOptions,
+	cursorFromVerbose,
+	type ParseOptions,
+	type VerboseTree,
+	type VerboseTreeNode,
+} from "./verboseTree.js";
+
+/**
+ * Construct tree content that is compatible with the field defined by the provided `schema`.
+ * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
+ * @param data - The data used to construct the field content.
+ * @remarks
+ * When providing a {@link TreeNodeSchemaClass}, this is the same as invoking its constructor except that an unhydrated node can also be provided.
+ * This function exists as a generalization that can be used in other cases as well,
+ * such as when `undefined` might be allowed (for an optional field), or when the type should be inferred from the data when more than one type is possible.
+ *
+ * Like with {@link TreeNodeSchemaClass}'s constructor, its an error to provide an existing node to this API.
+ * TODO: For that case, use we should provide `Tree.clone`.
+ * @privateRemarks
+ * This could be exposed as a public `Tree.create` function.
+ */
+export function createFromInsertable<TSchema extends ImplicitFieldSchema>(
+	schema: TSchema,
+	data: InsertableTreeFieldFromImplicitField<TSchema>,
+	context?: NodeKeyManager | undefined,
+): Unhydrated<TreeFieldFromImplicitField<TSchema>> {
+	const cursor = cursorFromInsertable(schema, data, context);
+	const result = cursor === undefined ? undefined : createFromCursor(schema, cursor);
+	return result as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+}
+
+/**
+ * Construct tree content that is compatible with the field defined by the provided `schema`.
+ * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
+ * @param data - The data used to construct the field content.
+ * @remarks
+ * When providing a {@link TreeNodeSchemaClass},
+ * this is the same as invoking its constructor except that an unhydrated node can also be provided and the returned value is a cursor.
+ * When `undefined` is provided (for an optional field), `undefined` is returned.
+ */
+export function cursorFromInsertable<TSchema extends ImplicitFieldSchema>(
+	schema: TSchema,
+	data: InsertableTreeFieldFromImplicitField<TSchema>,
+	context?: NodeKeyManager | undefined,
+):
+	| ITreeCursorSynchronous
+	| (TSchema extends FieldSchema<FieldKind.Optional> ? undefined : never) {
+	const flexSchema = toFlexSchema(schema);
+	const schemaValidationPolicy: SchemaAndPolicy = {
+		policy: defaultSchemaPolicy,
+		// TODO: optimize: This isn't the most efficient operation since its not cached, and has to convert all the schema.
+		schema: intoStoredSchema(flexSchema),
+	};
+
+	const mapTree = mapTreeFromNodeData(
+		data as InsertableContent | undefined,
+		schema,
+		context,
+		schemaValidationPolicy,
+	);
+	if (mapTree === undefined) {
+		assert(
+			flexSchema.rootFieldSchema.kind === FieldKinds.optional,
+			0xa10 /* missing non-optional field */,
+		);
+		return undefined as TSchema extends FieldSchema<FieldKind.Optional> ? undefined : never;
+	}
+	return cursorForMapTreeNode(mapTree);
+}
+
+/**
+ * Construct tree content compatible with a field defined by the provided `schema`.
+ * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
+ * @param data - The data used to construct the field content. See `Tree.cloneToJSONVerbose`.
+ * @privateRemarks
+ * This could be exposed as a public `Tree.createFromVerbose` function.
+ */
+export function createFromVerbose<TSchema extends ImplicitFieldSchema, THandle>(
+	schema: TSchema,
+	data: VerboseTreeNode<THandle> | undefined,
+	options: ParseOptions<THandle>,
+): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+
+/**
+ * Construct tree content compatible with a field defined by the provided `schema`.
+ * @param schema - The schema for what to construct. As this is an {@link ImplicitFieldSchema}, a {@link FieldSchema}, {@link TreeNodeSchema} or {@link AllowedTypes} array can be provided.
+ * @param data - The data used to construct the field content. See `Tree.cloneToJSONVerbose`.
+ */
+export function createFromVerbose<TSchema extends ImplicitFieldSchema>(
+	schema: TSchema,
+	data: VerboseTreeNode | undefined,
+	options?: Partial<ParseOptions<IFluidHandle>>,
+): Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+
+export function createFromVerbose<TSchema extends ImplicitFieldSchema, THandle>(
+	schema: TSchema,
+	data: VerboseTreeNode<THandle> | undefined,
+	options?: Partial<ParseOptions<THandle>>,
+): Unhydrated<TreeFieldFromImplicitField<TSchema>> {
+	const config: ParseOptions<THandle> = {
+		valueConverter: (input: VerboseTree<THandle>) => {
+			return input as TreeLeafValue | VerboseTreeNode<THandle>;
+		},
+		...options,
+	};
+	const schemalessConfig = applySchemaToParserOptions(schema, config);
+	const cursor = cursorFromVerbose(data, schemalessConfig);
+	return createFromCursor(schema, cursor);
+}
+
+/**
+ * Creates an unhydrated simple-tree field from a cursor in nodes mode.
+ */
+export function createFromCursor<TSchema extends ImplicitFieldSchema>(
+	schema: TSchema,
+	cursor: ITreeCursorSynchronous | undefined,
+): Unhydrated<TreeFieldFromImplicitField<TSchema>> {
+	const mapTrees = cursor === undefined ? [] : [mapTreeFromCursor(cursor)];
+	const flexSchema = toFlexSchema(schema);
+
+	const schemaValidationPolicy: SchemaAndPolicy = {
+		policy: defaultSchemaPolicy,
+		// TODO: optimize: This isn't the most efficient operation since its not cached, and has to convert all the schema.
+		schema: intoStoredSchema(flexSchema),
+	};
+
+	const maybeError = isFieldInSchema(
+		mapTrees,
+		flexSchema.rootFieldSchema.stored,
+		schemaValidationPolicy,
+	);
+	inSchemaOrThrow(maybeError);
+
+	if (mapTrees.length === 0) {
+		return undefined as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+	}
+	assert(mapTrees.length === 1, 0xa11 /* unexpected field length */);
+	// Length asserted above, so this is safe. This assert is done instead of checking for undefined after indexing to ensure a length greater than 1 also errors.
+	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+	const mapTree = mapTrees[0]!;
+	const rootSchema = flexSchema.nodeSchema.get(mapTree.type) ?? fail("missing schema");
+	const mapTreeNode = getOrCreateMapTreeNode(rootSchema, mapTree);
+
+	// TODO: ensure this works for InnerNodes to create unhydrated nodes
+	const result = getOrCreateNodeFromFlexTreeNode(mapTreeNode);
+	return result as Unhydrated<TreeFieldFromImplicitField<TSchema>>;
+}

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

@@ -0,0 +1,36 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	type ITree,
+	type TreeView,
+	type TreeViewEvents,
+	TreeViewConfiguration,
+	type ITreeViewConfiguration,
+	type SchemaCompatibilityStatus,
+	type ITreeConfigurationOptions,
+} from "./tree.js";
+export { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
+export type {
+	ValidateRecursiveSchema,
+	FixRecursiveArraySchema,
+} from "./schemaFactoryRecursive.js";
+export {
+	adaptEnum,
+	enumFromStrings,
+	singletonSchema,
+	typedObjectValues,
+	type EmptyObject,
+} from "./schemaCreationUtilities.js";
+export { treeNodeApi, type TreeNodeApi } from "./treeNodeApi.js";
+export { createFromInsertable, cursorFromInsertable } from "./create.js";
+
+// Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
+// These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639
+export {
+	RecursiveObject as test_RecursiveObject,
+	base as test_RecursiveObject_base,
+	RecursiveObjectPojoMode as test_RecursiveObjectPojoMode,
+} from "./testRecursiveDomain.js";

package/src/simple-tree/{schemaCreationUtilities.ts → api/schemaCreationUtilities.ts}

@@ -5,16 +5,24 @@
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import type { EmptyObject } from "../feature-libraries/index.js";
-import { fail } from "../util/index.js";
+import { fail } from "../../util/index.js";
 
 import type { SchemaFactory, ScopedSchemaName } from "./schemaFactory.js";
-import type { NodeFromSchema, NodeKind, TreeNodeSchemaClass } from "./schemaTypes.js";
-import type { TreeNode } from "./types.js";
+import type { NodeFromSchema } from "../schemaTypes.js";
+import type { NodeKind, TreeNodeSchemaClass, TreeNode } from "../core/index.js";
 import type {
 	InsertableObjectFromSchemaRecord,
 	ObjectFromSchemaRecord,
-} from "./objectNode.js";
+} from "../objectNode.js";
+
+/**
+ * Empty Object for use in type computations that should contribute no fields when `&`ed with another type.
+ * @internal
+ */
+// Using {} instead of interface {} or Record<string, never> for empty object here produces better IntelliSense in the generated types than `Record<string, never>` recommended by the linter.
+// Making this a type instead of an interface prevents it from showing up in IntelliSense, and also avoids breaking the typing somehow.
+// eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/consistent-type-definitions
+export type EmptyObject = {};
 
 /**
  * Create a schema for a node with no state.

package/src/simple-tree/{schemaFactory.ts → api/schemaFactory.ts}

@@ -11,13 +11,17 @@ import type { IFluidHandle as _dummyImport } from "@fluidframework/core-interfac
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
 
-import type { TreeValue } from "../core/index.js";
-import { type NodeKeyManager, type Unenforced, isLazy } from "../feature-libraries/index.js";
+import type { TreeValue } from "../../core/index.js";
+import {
+	type NodeKeyManager,
+	type Unenforced,
+	isLazy,
+} from "../../feature-libraries/index.js";
 import {
 	type RestrictiveReadonlyRecord,
 	getOrCreate,
 	isReadonlyArray,
-} from "../util/index.js";
+} from "../../util/index.js";
 
 import {
 	booleanSchema,
@@ -26,29 +30,32 @@ import {
 	nullSchema,
 	numberSchema,
 	stringSchema,
-} from "./leafNodeSchema.js";
+} from "../leafNodeSchema.js";
 import {
 	FieldKind,
 	type FieldSchema,
 	type ImplicitAllowedTypes,
 	type ImplicitFieldSchema,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
-	type NodeKind,
-	type TreeNodeSchema,
-	type TreeNodeSchemaClass,
-	type WithType,
 	type FieldProps,
 	createFieldSchema,
 	type DefaultProvider,
 	getDefaultProvider,
-} from "./schemaTypes.js";
-import { type TreeArrayNode, arraySchema } from "./arrayNode.js";
+} from "../schemaTypes.js";
+import { inPrototypeChain } from "../core/index.js";
+import type {
+	NodeKind,
+	WithType,
+	TreeNodeSchema,
+	TreeNodeSchemaClass,
+} from "../core/index.js";
+import { type TreeArrayNode, arraySchema } from "../arrayNode.js";
 import {
 	type InsertableObjectFromSchemaRecord,
 	type TreeObjectNode,
 	objectSchema,
-} from "./objectNode.js";
-import { type TreeMapNode, mapSchema } from "./mapNode.js";
+} from "../objectNode.js";
+import { type MapNodeInsertableData, type TreeMapNode, mapSchema } from "../mapNode.js";
 import type {
 	FieldSchemaUnsafe,
 	// Adding these unused imports makes the generated d.ts file produced by TypeScript stop breaking API-Extractor's rollup generation.
@@ -64,9 +71,9 @@ import type {
 	TreeArrayNodeUnsafe,
 	TreeMapNodeUnsafe,
 	TreeObjectNodeUnsafe,
-} from "./typesUnsafe.js";
+} from "../typesUnsafe.js";
 import { createFieldSchemaUnsafe } from "./schemaFactoryRecursive.js";
-import { inPrototypeChain, TreeNodeValid } from "./types.js";
+import { TreeNodeValid } from "../treeNodeValid.js";
 /**
  * Gets the leaf domain schema compatible with a given {@link TreeValue}.
  */
@@ -296,8 +303,8 @@ export class SchemaFactory<
 	): TreeNodeSchema<
 		ScopedSchemaName<TScope, `Map<${string}>`>,
 		NodeKind.Map,
-		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>>,
-		Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,
+		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, `Map<${string}>`>, NodeKind.Map>,
+		MapNodeInsertableData<T>,
 		true,
 		T
 	>;
@@ -318,8 +325,8 @@ export class SchemaFactory<
 	): TreeNodeSchemaClass<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Map,
-		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>,
-		Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,
+		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>,
+		MapNodeInsertableData<T>,
 		true,
 		T
 	>;
@@ -327,14 +334,7 @@ export class SchemaFactory<
 	public map<const T extends ImplicitAllowedTypes>(
 		nameOrAllowedTypes: TName | ((T & TreeNodeSchema) | readonly TreeNodeSchema[]),
 		allowedTypes?: T,
-	): TreeNodeSchema<
-		string,
-		NodeKind.Map,
-		TreeMapNode<T>,
-		Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,
-		true,
-		T
-	> {
+	): TreeNodeSchema<string, NodeKind.Map, TreeMapNode<T>, MapNodeInsertableData<T>, true, T> {
 		if (allowedTypes === undefined) {
 			const types = nameOrAllowedTypes as (T & TreeNodeSchema) | readonly TreeNodeSchema[];
 			const fullName = structuralName("Map", types);
@@ -352,7 +352,7 @@ export class SchemaFactory<
 				string,
 				NodeKind.Map,
 				TreeMapNode<T>,
-				Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,
+				MapNodeInsertableData<T>,
 				true,
 				T
 			>;
@@ -377,8 +377,8 @@ export class SchemaFactory<
 	): TreeNodeSchemaClass<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Map,
-		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>>,
-		Iterable<[string, InsertableTreeNodeFromImplicitAllowedTypes<T>]>,
+		TreeMapNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>,
+		MapNodeInsertableData<T>,
 		ImplicitlyConstructable,
 		T
 	> {
@@ -429,7 +429,7 @@ export class SchemaFactory<
 	): TreeNodeSchema<
 		ScopedSchemaName<TScope, `Array<${string}>`>,
 		NodeKind.Array,
-		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, `Array<${string}>`>>,
+		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, `Array<${string}>`>, NodeKind.Array>,
 		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 		true,
 		T
@@ -453,7 +453,7 @@ export class SchemaFactory<
 	): TreeNodeSchemaClass<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Array,
-		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, Name>>,
+		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Array>,
 		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 		true,
 		T
@@ -508,7 +508,7 @@ export class SchemaFactory<
 	): TreeNodeSchemaClass<
 		ScopedSchemaName<TScope, Name>,
 		NodeKind.Array,
-		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, string>>,
+		TreeArrayNode<T> & WithType<ScopedSchemaName<TScope, string>, NodeKind.Array>,
 		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
 		ImplicitlyConstructable,
 		T
@@ -663,7 +663,7 @@ export class SchemaFactory<
 		return RecursiveArray as TreeNodeSchemaClass<
 			ScopedSchemaName<TScope, Name>,
 			NodeKind.Array,
-			TreeArrayNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,
+			TreeArrayNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Array>,
 			{
 				/**
 				 * Iterator for the iterable of content for this node.
@@ -705,7 +705,7 @@ export class SchemaFactory<
 		return MapSchema as TreeNodeSchemaClass<
 			ScopedSchemaName<TScope, Name>,
 			NodeKind.Map,
-			TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>>,
+			TreeMapNodeUnsafe<T> & WithType<ScopedSchemaName<TScope, Name>, NodeKind.Map>,
 			{
 				/**
 				 * Iterator for the iterable of content for this node.
@@ -722,6 +722,8 @@ export class SchemaFactory<
 					[string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>]
 				>;
 			},
+			// Ideally this would be included, but doing so breaks recursive types.
+			// | RestrictiveReadonlyRecord<string, InsertableTreeNodeFromImplicitAllowedTypesUnsafe<T>>,
 			false,
 			T
 		>;

package/src/simple-tree/{schemaFactoryRecursive.ts → api/schemaFactoryRecursive.ts}

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import type { Unenforced } from "../feature-libraries/index.js";
-import type { RestrictiveReadonlyRecord } from "../util/index.js";
-import type { InsertableObjectFromSchemaRecord } from "./objectNode.js";
+import type { Unenforced } from "../../feature-libraries/index.js";
+import type { RestrictiveReadonlyRecord } from "../../util/index.js";
+import type { InsertableObjectFromSchemaRecord } from "../objectNode.js";
 
 import {
 	type FieldKind,
@@ -14,12 +14,15 @@ import {
 	type ImplicitAllowedTypes,
 	type ImplicitFieldSchema,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
-	type NodeKind,
-	type TreeNodeSchemaClass,
-	type WithType,
-} from "./schemaTypes.js";
-import type { TreeNode } from "./types.js";
-import type { FieldSchemaUnsafe } from "./typesUnsafe.js";
+} from "../schemaTypes.js";
+import type {
+	NodeKind,
+	TreeNodeSchemaClass,
+	TreeNodeSchema,
+	WithType,
+	TreeNode,
+} from "../core/index.js";
+import type { FieldSchemaUnsafe } from "../typesUnsafe.js";
 
 export function createFieldSchemaUnsafe<
 	Kind extends FieldKind,
@@ -124,7 +127,7 @@ export type ValidateRecursiveSchema<
 		// NodeKind: These are the NodeKinds which currently can be used recursively.
 		NodeKind.Array | NodeKind.Map | NodeKind.Object,
 		// TNode: The produced node API. This is pretty minimal validation: more could be added if similar to how TInsertable works below if needed.
-		TreeNode & WithType<T["identifier"]>,
+		TreeNode & WithType<T["identifier"], T["kind"]>,
 		// TInsertable: What can be passed to the constructor. This should be enough to catch most issues with incorrect schema.
 		// These match whats defined in the recursive methods on `SchemaFactory` except they do not use `Unenforced`.
 		{
@@ -151,3 +154,37 @@ export type ValidateRecursiveSchema<
 		}[T["kind"]]
 	>,
 > = true;
+
+/**
+ * Workaround for fixing errors resulting from an issue with recursive ArrayNode schema exports.
+ * @remarks
+ * Importing a recursive ArrayNode schema via a d.ts file can produce an error like
+ * `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.`
+ * if using a tsconfig with `"skipLibCheck": false`.
+ *
+ * This error occurs due to the TypeScript compiler splitting the class definition into two separate declarations in the d.ts file (one for the base, and one for the actual class).
+ * For unknown reasons, splitting the class declaration in this way breaks the recursive type handling, leading to the mentioned error.
+ *
+ * This type always evaluates to `undefined` to ensure the dummy export (which doesn't exist at runtime) is typed correctly.
+ *
+ * [TypeScript Issue 59550](https://github.com/microsoft/TypeScript/issues/59550) tracks a suggestion which would make this workaround unnecessary.
+ *
+ * @example Usage
+ * Since recursive type handling in TypeScript is order dependent, putting just the right kind of usages of the type before the declarations can cause it to not hit this error.
+ * For the case of ArrayNodes, this can be done via usage that looks like this:
+ *
+ * This example should use a doc comment to ensure the workaround comment shows up in the intellisense for the dummy export,
+ * however doing so is impossible due to how this example is included in a doc comment.
+ * ```typescript
+ *  // Workaround to avoid
+ *  // `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.` in the d.ts file.
+ * export declare const _RecursiveArrayWorkaround: FixRecursiveArraySchema<typeof RecursiveArray>;
+ * export class RecursiveArray extends schema.arrayRecursive("RA", [() => RecursiveArray]) {}
+ * {
+ * 	type _check = ValidateRecursiveSchema<typeof RecursiveArray>;
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export type FixRecursiveArraySchema<T> = T extends TreeNodeSchema ? undefined : undefined;

package/src/simple-tree/{testRecursiveDomain.ts → api/testRecursiveDomain.ts}

@@ -16,7 +16,9 @@ import { SchemaFactory } from "./schemaFactory.js";
 // If we let TypeScript generate these includes, they use relative paths which break API extractor's rollup.
 // API-Extractor issue: https://github.com/microsoft/rushstack/issues/4507
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
-import type { FieldKind, NodeKind } from "./schemaTypes.js";
+import type { FieldKind } from "../schemaTypes.js";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
+import type { NodeKind } from "../core/index.js";
 
 const builder = new SchemaFactory("Test Recursive Domain");