@fluidframework/tree 2.0.0-dev-rc.5.0.0.271045 → 2.0.0-dev-rc.5.0.0.271717

package/src/simple-tree/arrayNode.ts

@@ -3,20 +3,24 @@
  * Licensed under the MIT License.
  */
 
-import { EmptyKey, ITreeCursorSynchronous, TreeNodeSchemaIdentifier } from "../core/index.js";
 import {
-	FlexAllowedTypes,
-	FlexFieldNodeSchema,
-	FlexTreeNode,
-	FlexTreeSequenceField,
-	MapTreeNode,
+	EmptyKey,
+	type ITreeCursorSynchronous,
+	type TreeNodeSchemaIdentifier,
+} from "../core/index.js";
+import {
+	type FlexAllowedTypes,
+	type FlexFieldNodeSchema,
+	type FlexTreeNode,
+	type FlexTreeSequenceField,
+	type MapTreeNode,
 	cursorForMapTreeField,
 	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
 	isMapTreeNode,
 } from "../feature-libraries/index.js";
 import {
-	InsertableContent,
+	type InsertableContent,
 	getOrCreateNodeProxy,
 	markContentType,
 	prepareContentForHydration,
@@ -27,14 +31,14 @@ import {
 	type ImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
 	type TreeNodeFromImplicitAllowedTypes,
-	TreeNodeSchemaClass,
-	WithType,
-	TreeNodeSchema,
+	type TreeNodeSchemaClass,
+	type WithType,
+	type TreeNodeSchema,
 	type,
 	normalizeFieldSchema,
 } from "./schemaTypes.js";
 import { mapTreeFromNodeData } from "./toMapTree.js";
-import { TreeNode, TreeNodeValid } from "./types.js";
+import { type TreeNode, TreeNodeValid } from "./types.js";
 import { fail } from "../util/index.js";
 import { getFlexSchema } from "./toFlexSchema.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
@@ -372,34 +376,34 @@ declare abstract class NodeWithArrayFeatures<Input, T>
 {
 	concat(...items: ConcatArray<T>[]): T[];
 	concat(...items: (T | ConcatArray<T>)[]): T[];
-	join(separator?: string | undefined): string;
-	slice(start?: number | undefined, end?: number | undefined): T[];
-	indexOf(searchElement: T, fromIndex?: number | undefined): number;
-	lastIndexOf(searchElement: T, fromIndex?: number | undefined): number;
+	entries(): IterableIterator<[number, T]>;
 	every<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): this is readonly S[];
 	every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
-	some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
-	forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
-	map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
 	filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
 	filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
+	find<S extends T>(predicate: (value: T, index: number, obj: readonly T[]) => value is S, thisArg?: any): S | undefined;
+	find(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): T | undefined;
+	findIndex(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): number;
+	flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+	flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | readonly U[], thisArg?: This | undefined): U[];
+	forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
+	includes(searchElement: T, fromIndex?: number | undefined): boolean;
+	indexOf(searchElement: T, fromIndex?: number | undefined): number;
+	join(separator?: string | undefined): string;
+	keys(): IterableIterator<number>;
+	lastIndexOf(searchElement: T, fromIndex?: number | undefined): number;
+	map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
 	reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
 	reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
 	reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
 	reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
 	reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
 	reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
-	find<S extends T>(predicate: (value: T, index: number, obj: readonly T[]) => value is S, thisArg?: any): S | undefined;
-	find(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): T | undefined;
-	findIndex(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): number;
-	entries(): IterableIterator<[number, T]>;
-	keys(): IterableIterator<number>;
-	values(): IterableIterator<T>;
-	includes(searchElement: T, fromIndex?: number | undefined): boolean;
-	flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | readonly U[], thisArg?: This | undefined): U[];
-	flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
-	toString(): string;
+	slice(start?: number | undefined, end?: number | undefined): T[];
+	some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
 	toLocaleString(): string;
+	toString(): string;
+	values(): IterableIterator<T>;
 }
 /* eslint-enable @typescript-eslint/explicit-member-accessibility, @typescript-eslint/no-explicit-any */
 

package/src/simple-tree/leafNodeSchema.ts

@@ -5,17 +5,17 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import { TreeNodeSchemaIdentifier, TreeValue } from "../core/index.js";
+import type { TreeNodeSchemaIdentifier, TreeValue } from "../core/index.js";
 import { leaf } from "../domains/index.js";
 import {
-	LeafNodeSchema as FlexLeafNodeSchema,
-	FlexTreeNode,
+	type LeafNodeSchema as FlexLeafNodeSchema,
+	type FlexTreeNode,
 	isFlexTreeNode,
 	valueSchemaAllows,
 } from "../feature-libraries/index.js";
 
 import { setFlexSchemaFromClassSchema } from "./schemaCaching.js";
-import { NodeKind, TreeNodeSchema, TreeNodeSchemaNonClass } from "./schemaTypes.js";
+import { NodeKind, type TreeNodeSchema, type TreeNodeSchemaNonClass } from "./schemaTypes.js";
 
 type UnbrandedName<T extends FlexLeafNodeSchema> = T["name"] extends TreeNodeSchemaIdentifier<
 	infer Name extends string

package/src/simple-tree/mapNode.ts

@@ -3,18 +3,18 @@
  * Licensed under the MIT License.
  */
 
-import { TreeNodeSchemaIdentifier } from "../core/index.js";
+import type { TreeNodeSchemaIdentifier } from "../core/index.js";
 import {
-	FlexMapNodeSchema,
-	FlexTreeNode,
-	MapTreeNode,
+	type FlexMapNodeSchema,
+	type FlexTreeNode,
+	type MapTreeNode,
 	cursorForMapTreeNode,
 	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
 	isMapTreeNode,
 } from "../feature-libraries/index.js";
 import {
-	InsertableContent,
+	type InsertableContent,
 	getProxyForField,
 	markContentType,
 	prepareContentForHydration,
@@ -25,14 +25,14 @@ import {
 	NodeKind,
 	type ImplicitAllowedTypes,
 	type InsertableTreeNodeFromImplicitAllowedTypes,
-	TreeNodeSchemaClass,
-	WithType,
-	TreeNodeSchema,
-	TreeNodeFromImplicitAllowedTypes,
+	type TreeNodeSchemaClass,
+	type WithType,
+	type TreeNodeSchema,
+	type TreeNodeFromImplicitAllowedTypes,
 	type,
 } from "./schemaTypes.js";
 import { mapTreeFromNodeData } from "./toMapTree.js";
-import { TreeNode, TreeNodeValid } from "./types.js";
+import { type TreeNode, TreeNodeValid } from "./types.js";
 import { getFlexSchema } from "./toFlexSchema.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 

package/src/simple-tree/nodeKeys.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { LocalNodeKey, StableNodeKey } from "../feature-libraries/index.js";
-import { TreeNode } from "./types.js";
+import type { LocalNodeKey, StableNodeKey } from "../feature-libraries/index.js";
+import type { TreeNode } from "./types.js";
 
 /**
  * A collection of utilities for managing {@link StableNodeKey}s.

package/src/simple-tree/objectNode.ts

@@ -5,23 +5,23 @@
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { FieldKey, TreeNodeSchemaIdentifier } from "../core/index.js";
+import type { FieldKey, TreeNodeSchemaIdentifier } from "../core/index.js";
 import {
 	cursorForMapTreeNode,
 	FieldKinds,
-	FlexAllowedTypes,
-	FlexObjectNodeSchema,
-	FlexTreeField,
-	FlexTreeNode,
-	FlexTreeOptionalField,
-	FlexTreeRequiredField,
+	type FlexAllowedTypes,
+	type FlexObjectNodeSchema,
+	type FlexTreeField,
+	type FlexTreeNode,
+	type FlexTreeOptionalField,
+	type FlexTreeRequiredField,
 	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
 	isMapTreeNode,
-	MapTreeNode,
+	type MapTreeNode,
 } from "../feature-libraries/index.js";
 import {
-	InsertableContent,
+	type InsertableContent,
 	getProxyForField,
 	markContentType,
 	prepareContentForHydration,
@@ -29,23 +29,23 @@ import {
 import { getFlexNode } from "./proxyBinding.js";
 import {
 	NodeKind,
-	ImplicitFieldSchema,
-	TreeNodeSchemaClass,
-	WithType,
-	TreeNodeSchema,
+	type ImplicitFieldSchema,
+	type TreeNodeSchemaClass,
+	type WithType,
+	type TreeNodeSchema,
 	getStoredKey,
 	getExplicitStoredKey,
-	TreeFieldFromImplicitField,
-	InsertableTreeFieldFromImplicitField,
-	FieldSchema,
+	type TreeFieldFromImplicitField,
+	type InsertableTreeFieldFromImplicitField,
+	type FieldSchema,
 	normalizeFieldSchema,
 	type,
 	type ImplicitAllowedTypes,
 	FieldKind,
 } from "./schemaTypes.js";
 import { mapTreeFromNodeData } from "./toMapTree.js";
-import { InternalTreeNode, TreeNode, TreeNodeValid } from "./types.js";
-import { type RestrictiveReadonlyRecord, fail, InternalUtilTypes } from "../util/index.js";
+import { type InternalTreeNode, type TreeNode, TreeNodeValid } from "./types.js";
+import { type RestrictiveReadonlyRecord, fail, type InternalUtilTypes } from "../util/index.js";
 import { getFlexSchema } from "./toFlexSchema.js";
 
 /**

package/src/simple-tree/proxies.ts

@@ -3,37 +3,35 @@
  * Licensed under the MIT License.
  */
 
-import { IFluidHandle } from "@fluidframework/core-interfaces";
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 
 import {
 	EmptyKey,
-	IForestSubscription,
-	MapTree,
-	TreeNodeSchemaIdentifier,
-	TreeValue,
-	UpPath,
+	type IForestSubscription,
+	type MapTree,
+	type TreeNodeSchemaIdentifier,
+	type TreeValue,
+	type UpPath,
 } from "../core/index.js";
 
 import {
 	FieldKinds,
-	FlexFieldSchema,
-	FlexTreeField,
-	FlexTreeNode,
-	FlexTreeNodeEvents,
-	FlexTreeTypedField,
-	MapTreeNode,
-	onNodeChanged,
-	onTreeChanged,
+	type FlexFieldSchema,
+	type FlexTreeField,
+	type FlexTreeNode,
+	type FlexTreeNodeEvents,
+	type FlexTreeTypedField,
+	type MapTreeNode,
 	tryGetMapTreeNode,
 	typeNameSymbol,
 } from "../feature-libraries/index.js";
-import { Mutable, fail, isReadonlyArray } from "../util/index.js";
+import { type Mutable, fail, isReadonlyArray } from "../util/index.js";
 
 import { anchorProxy, tryGetFlexNode, tryGetProxy } from "./proxyBinding.js";
 import { tryGetSimpleNodeSchema } from "./schemaCaching.js";
-import { TreeNode, Unhydrated } from "./types.js";
-import { Off } from "../events/index.js";
+import type { TreeNode, Unhydrated } from "./types.js";
+import type { Off } from "../events/index.js";
 
 /**
  * Detects if the given 'candidate' is a TreeNode.
@@ -229,16 +227,12 @@ function bindProxies(proxies: RootedProxyPaths[], forest: IForestSubscription):
 						listener: FlexTreeNodeEvents[K],
 					): Off {
 						switch (eventName) {
-							case "nodeChanged":
-								return onNodeChanged(
-									anchorNode,
-									listener as FlexTreeNodeEvents["nodeChanged"],
-								);
-							case "treeChanged":
-								return onTreeChanged(
-									anchorNode,
-									listener as FlexTreeNodeEvents["treeChanged"],
-								);
+							case "nodeChanged": {
+								return anchorNode.on("childrenChangedAfterBatch", listener);
+							}
+							case "treeChanged": {
+								return anchorNode.on("subtreeChangedAfterBatch", listener);
+							}
 							default:
 								fail("Unexpected event subscription");
 						}

package/src/simple-tree/proxyBinding.ts

@@ -5,30 +5,30 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import { AnchorNode, AnchorSet, UpPath, anchorSlot } from "../core/index.js";
+import { type AnchorNode, type AnchorSet, type UpPath, anchorSlot } from "../core/index.js";
 import {
 	ContextSlot,
-	FlexTreeNodeSchema,
-	FlexMapNodeSchema,
-	FlexObjectNodeSchema,
-	FlexTreeMapNode,
-	FlexTreeNode,
-	FlexTreeObjectNode,
+	type FlexTreeNodeSchema,
+	type FlexMapNodeSchema,
+	type FlexObjectNodeSchema,
+	type FlexTreeMapNode,
+	type FlexTreeNode,
+	type FlexTreeObjectNode,
 	assertFlexTreeEntityNotFreed,
 	flexTreeSlot,
-	FieldKinds,
-	FlexFieldSchema,
-	MapTreeNode,
+	type FieldKinds,
+	type FlexFieldSchema,
+	type MapTreeNode,
 	isMapTreeNode,
 } from "../feature-libraries/index.js";
 import { fail } from "../util/index.js";
-import { WithType } from "./schemaTypes.js";
-import { TreeArrayNode } from "./arrayNode.js";
-import { TreeNode } from "./types.js";
+import type { WithType } from "./schemaTypes.js";
+import type { TreeArrayNode } from "./arrayNode.js";
+import type { TreeNode } from "./types.js";
 // TODO: decide how to deal with dependencies on flex-tree implementation.
 // eslint-disable-next-line import/no-internal-modules
 import { makeTree } from "../feature-libraries/flex-tree/lazyNode.js";
-import { TreeMapNode } from "./mapNode.js";
+import type { TreeMapNode } from "./mapNode.js";
 
 // This file contains various maps and helpers for supporting proxy binding (a.k.a. proxy hydration).
 // See ./ProxyBinding.md for a high-level overview of the process.

package/src/simple-tree/schemaCaching.ts

@@ -5,17 +5,17 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import {
-	type FlexFieldSchema,
-	type FlexTreeNodeSchema,
+import type {
+	FlexFieldSchema,
+	FlexTreeNodeSchema,
 	TreeNodeSchemaBase,
 } from "../feature-libraries/index.js";
 import { fail } from "../util/index.js";
 
 import {
-	FieldSchema,
+	type FieldSchema,
 	type ImplicitFieldSchema,
-	TreeNodeSchema,
+	type TreeNodeSchema,
 	normalizeFieldSchema,
 } from "./schemaTypes.js";
 

package/src/simple-tree/schemaCreationUtilities.ts

@@ -5,13 +5,13 @@
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { EmptyObject } from "../feature-libraries/index.js";
+import type { EmptyObject } from "../feature-libraries/index.js";
 import { fail } from "../util/index.js";
 
-import { SchemaFactory, type ScopedSchemaName } from "./schemaFactory.js";
-import { NodeFromSchema, NodeKind, TreeNodeSchemaClass } from "./schemaTypes.js";
-import { TreeNode } from "./types.js";
-import { InsertableObjectFromSchemaRecord, ObjectFromSchemaRecord } from "./objectNode.js";
+import type { SchemaFactory, ScopedSchemaName } from "./schemaFactory.js";
+import type { NodeFromSchema, NodeKind, TreeNodeSchemaClass } from "./schemaTypes.js";
+import type { TreeNode } from "./types.js";
+import type { InsertableObjectFromSchemaRecord, ObjectFromSchemaRecord } from "./objectNode.js";
 
 /**
  * Create a schema for a node with no state.

package/src/simple-tree/schemaFactory.ts

@@ -9,15 +9,15 @@ import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 // eslint-disable-next-line unused-imports/no-unused-imports
 import type { IFluidHandle as _dummyImport } from "@fluidframework/core-interfaces";
 
-import { TreeValue } from "../core/index.js";
+import type { TreeValue } from "../core/index.js";
 import {
-	FlexTreeNode,
-	NodeKeyManager,
-	Unenforced,
+	type FlexTreeNode,
+	type NodeKeyManager,
+	type Unenforced,
 	isFlexTreeNode,
 	isLazy,
 } from "../feature-libraries/index.js";
-import { RestrictiveReadonlyRecord, getOrCreate, isReadonlyArray } from "../util/index.js";
+import { type RestrictiveReadonlyRecord, getOrCreate, isReadonlyArray } from "../util/index.js";
 
 import {
 	booleanSchema,
@@ -28,23 +28,27 @@ import {
 } from "./leafNodeSchema.js";
 import {
 	FieldKind,
-	FieldSchema,
-	ImplicitAllowedTypes,
-	ImplicitFieldSchema,
-	InsertableTreeNodeFromImplicitAllowedTypes,
-	NodeKind,
-	TreeNodeSchema,
-	TreeNodeSchemaClass,
-	WithType,
+	type FieldSchema,
+	type ImplicitAllowedTypes,
+	type ImplicitFieldSchema,
+	type InsertableTreeNodeFromImplicitAllowedTypes,
+	type NodeKind,
+	type TreeNodeSchema,
+	type TreeNodeSchemaClass,
+	type WithType,
 	type FieldProps,
 	createFieldSchema,
-	DefaultProvider,
+	type DefaultProvider,
 	getDefaultProvider,
 } from "./schemaTypes.js";
-import { TreeArrayNode, arraySchema } from "./arrayNode.js";
+import { type TreeArrayNode, arraySchema } from "./arrayNode.js";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
-import { InsertableObjectFromSchemaRecord, TreeObjectNode, objectSchema } from "./objectNode.js";
-import { TreeMapNode, mapSchema } from "./mapNode.js";
+import {
+	type InsertableObjectFromSchemaRecord,
+	type TreeObjectNode,
+	objectSchema,
+} from "./objectNode.js";
+import { 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.
@@ -563,11 +567,24 @@ export class SchemaFactory<
 	}
 
 	/**
-	 * Make a field of type identifier instead of the default, which is required.
-	 * @remarks Identifiers may be optionally supplied at node construction time.
-	 * If not supplied, they will be generated automatically when the node is inserted into the tree.
-	 * Attempting to read an automatically generated identifier before the node is inserted into the tree will throw an error.
-	 * An automatically generated identifier will not be present when iterating the nodes's fields until after the node is inserted into the tree.
+	 * A special field which holds a unique identifier for an object node.
+	 * @remarks
+	 * The value of this field, a "node identifier", uniquely identifies a node among all other nodes in the tree.
+	 * Node identifiers are strings, and can therefore be used as lookup keys in maps or written to a database.
+	 * When the node is constructed, the identifier field does not need to be populated.
+	 * The SharedTree will provide an identifier for the node automatically.
+	 * An identifier provided automatically by the SharedTree has the following properties:
+	 * - It is a UUID.
+	 * - It is compressed to a space-efficient representation when stored in the document.
+	 * - A compressed form of the identifier can be accessed at runtime via the `Tree.shortId()` API.
+	 * - It will error if read (and will not be present in the object's iterable properties) before the node has been inserted into the tree.
+	 *
+	 * However, a user may alternatively supply their own string as the identifier if desired (for example, if importing identifiers from another system).
+	 * In that case, it is up to the user to ensure that the identifier is unique within the current tree - no other node should have the same identifier at the same time.
+	 * If the identifier is not unique, it may be read, but may cause libraries or features which operate over node identifiers to misbehave.
+	 * User-supplied identifiers may be read immediately, even before insertion into the tree.
+	 *
+	 * A node may have more than one identifier field (though note that this precludes the use of the `Tree.shortId()` API).
 	 */
 	public get identifier(): FieldSchema<FieldKind.Identifier, typeof this.string> {
 		const defaultIdentifierProvider: DefaultProvider = getDefaultProvider(

package/src/simple-tree/schemaFactoryRecursive.ts

@@ -3,23 +3,23 @@
  * Licensed under the MIT License.
  */
 
-import { Unenforced } from "../feature-libraries/index.js";
-import { RestrictiveReadonlyRecord } from "../util/index.js";
-import { 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 {
-	FieldKind,
-	FieldProps,
+	type FieldKind,
+	type FieldProps,
 	createFieldSchema,
-	ImplicitAllowedTypes,
-	ImplicitFieldSchema,
-	InsertableTreeNodeFromImplicitAllowedTypes,
-	NodeKind,
-	TreeNodeSchemaClass,
-	WithType,
+	type ImplicitAllowedTypes,
+	type ImplicitFieldSchema,
+	type InsertableTreeNodeFromImplicitAllowedTypes,
+	type NodeKind,
+	type TreeNodeSchemaClass,
+	type WithType,
 } from "./schemaTypes.js";
-import { TreeNode } from "./types.js";
-import { FieldSchemaUnsafe } from "./typesUnsafe.js";
+import type { TreeNode } from "./types.js";
+import type { FieldSchemaUnsafe } from "./typesUnsafe.js";
 
 export function createFieldSchemaUnsafe<
 	Kind extends FieldKind,

package/src/simple-tree/schemaTypes.ts

@@ -3,20 +3,20 @@
  * Licensed under the MIT License.
  */
 
-import { ErasedType, IFluidHandle } from "@fluidframework/core-interfaces";
+import type { ErasedType, IFluidHandle } from "@fluidframework/core-interfaces";
 import { Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
-	InternalFlexListTypes,
-	LazyItem,
-	NodeKeyManager,
+	type InternalFlexListTypes,
+	type LazyItem,
+	type NodeKeyManager,
 	isLazy,
 } from "../feature-libraries/index.js";
-import { MakeNominal, brand, isReadonlyArray } from "../util/index.js";
-import { InternalTreeNode, Unhydrated } from "./types.js";
-import { FieldKey } from "../core/index.js";
-import { InsertableContent } from "./proxies.js";
+import { type MakeNominal, brand, isReadonlyArray } from "../util/index.js";
+import type { InternalTreeNode, Unhydrated } from "./types.js";
+import type { FieldKey } from "../core/index.js";
+import type { InsertableContent } from "./proxies.js";
 
 /**
  * Schema for a tree node.

package/src/simple-tree/testRecursiveDomain.ts

@@ -16,7 +16,7 @@ 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, type NodeKind } from "./schemaTypes.js";
+import type { FieldKind, NodeKind } from "./schemaTypes.js";
 
 const builder = new SchemaFactory("Test Recursive Domain");
 

package/src/simple-tree/toFlexSchema.ts

@@ -6,31 +6,31 @@
 /* eslint-disable import/no-internal-modules */
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 
-import {
+import type {
 	ITreeCursorSynchronous,
 	TreeNodeSchemaIdentifier,
-	type SchemaAndPolicy,
+	SchemaAndPolicy,
 } from "../core/index.js";
 import {
 	FieldKinds,
-	FlexAllowedTypes,
-	FlexFieldKind,
+	type FlexAllowedTypes,
+	type FlexFieldKind,
 	FlexFieldNodeSchema,
 	FlexFieldSchema,
 	FlexMapNodeSchema,
 	FlexObjectNodeSchema,
-	FlexTreeNodeSchema,
-	FlexTreeSchema,
-	NodeKeyManager,
+	type FlexTreeNodeSchema,
+	type FlexTreeSchema,
+	type NodeKeyManager,
 	TreeNodeSchemaBase,
 	defaultSchemaPolicy,
 	schemaIsLeaf,
 } from "../feature-libraries/index.js";
 import { normalizeFlexListEager } from "../feature-libraries/typed-schema/flexList.js";
-import { TreeContent } from "../shared-tree/index.js";
+import type { TreeContent } from "../shared-tree/index.js";
 import { brand, fail, isReadonlyArray, mapIterable } from "../util/index.js";
 
-import { InsertableContent } from "./proxies.js";
+import type { InsertableContent } from "./proxies.js";
 import {
 	cachedFlexSchemaFromClassSchema,
 	setFlexSchemaFromClassSchema,
@@ -39,11 +39,11 @@ import {
 import {
 	FieldKind,
 	FieldSchema,
-	ImplicitAllowedTypes,
-	ImplicitFieldSchema,
-	InsertableTreeNodeFromImplicitAllowedTypes,
+	type ImplicitAllowedTypes,
+	type ImplicitFieldSchema,
+	type InsertableTreeNodeFromImplicitAllowedTypes,
 	NodeKind,
-	TreeNodeSchema,
+	type TreeNodeSchema,
 	normalizeFieldSchema,
 	getStoredKey,
 } from "./schemaTypes.js";