@fluidframework/tree 2.73.0 → 2.74.0-368706

package/src/feature-libraries/default-schema/defaultFieldKinds.ts

@@ -7,13 +7,12 @@ import { fail } from "@fluidframework/core-utils/internal";
 
 import {
 	type ChangeAtomId,
-	type DeltaDetachedNodeId,
+	type DeltaFieldChanges,
 	type FieldKindIdentifier,
 	forbiddenFieldKindIdentifier,
 	Multiplicity,
 } from "../../core/index.js";
 import {
-	type FieldChangeDelta,
 	type FieldChangeHandler,
 	type FieldEditor,
 	type FieldKindConfiguration,
@@ -21,7 +20,6 @@ import {
 	FlexFieldKind,
 	type FullSchemaPolicy,
 	type ToDelta,
-	allowsTreeSchemaIdentifierSuperset,
 	referenceFreeFieldChangeRebaser,
 } from "../modular-schema/index.js";
 import {
@@ -51,8 +49,7 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 	}),
 	codecsFactory: () => noChangeCodecFamily,
 	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },
-	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
-	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
+	intoDelta: (change, deltaFromChild: ToDelta): DeltaFieldChanges => [],
 	isEmpty: (change: 0) => true,
 	getNestedChanges: (change: 0) => [],
 	createEmpty: () => 0,
@@ -76,15 +73,20 @@ export interface RequiredFieldEditor extends FieldEditor<OptionalChangeset> {
 }
 
 const optionalIdentifier = brandConst("Optional")<FieldKindIdentifier>();
+const requiredIdentifier = brandConst("Value")<FieldKindIdentifier>();
+const sequenceIdentifier = brandConst("Sequence")<FieldKindIdentifier>();
+const identifierFieldIdentifier = brandConst("Identifier")<FieldKindIdentifier>();
 
 /**
  * 0 or 1 items.
  */
 export const optional = new FlexFieldKind(optionalIdentifier, Multiplicity.Optional, {
 	changeHandler: optionalChangeHandler,
-	allowsTreeSupersetOf: (types, other) =>
-		(other.kind === sequence.identifier || other.kind === optionalIdentifier) &&
-		allowsTreeSchemaIdentifierSuperset(types, other.types),
+	allowMonotonicUpgradeFrom: new Set([
+		identifierFieldIdentifier,
+		requiredIdentifier,
+		forbiddenFieldKindIdentifier,
+	]),
 });
 
 export const requiredFieldEditor: RequiredFieldEditor = {
@@ -103,51 +105,38 @@ export const requiredFieldChangeHandler: FieldChangeHandler<
 	editor: requiredFieldEditor,
 };
 
-const requiredIdentifier = brandConst("Value")<FieldKindIdentifier>();
-
 /**
  * Exactly one item.
  */
 export const required = new FlexFieldKind(requiredIdentifier, Multiplicity.Single, {
 	changeHandler: requiredFieldChangeHandler,
-	allowsTreeSupersetOf: (types, other) =>
-		// By omitting Identifier here,
-		// this is making a policy choice that a schema upgrade cannot be done from required to identifier.
-		// Since an identifier can be upgraded into a required field,
-		// preventing the inverse helps ensure that schema upgrades are monotonic.
-		// Which direction is allowed is a subjective policy choice.
-		(other.kind === sequence.identifier ||
-			other.kind === requiredIdentifier ||
-			other.kind === optional.identifier) &&
-		allowsTreeSchemaIdentifierSuperset(types, other.types),
+	allowMonotonicUpgradeFrom: new Set([identifierFieldIdentifier]),
 });
 
-const sequenceIdentifier = brandConst("Sequence")<FieldKindIdentifier>();
-
 /**
  * 0 or more items.
  */
 export const sequence = new FlexFieldKind(sequenceIdentifier, Multiplicity.Sequence, {
 	changeHandler: sequenceFieldChangeHandler,
-	allowsTreeSupersetOf: (types, other) =>
-		other.kind === sequenceIdentifier &&
-		allowsTreeSchemaIdentifierSuperset(types, other.types),
+	allowMonotonicUpgradeFrom: new Set([
+		required.identifier,
+		optional.identifier,
+		identifierFieldIdentifier,
+		forbiddenFieldKindIdentifier,
+	]),
 });
 
-const identifierFieldIdentifier = brandConst("Identifier")<FieldKindIdentifier>();
-
 /**
  * Exactly one identifier.
  */
 export const identifier = new FlexFieldKind(identifierFieldIdentifier, Multiplicity.Single, {
 	changeHandler: noChangeHandler,
-	allowsTreeSupersetOf: (types, other) =>
-		// Allows upgrading from identifier to required: which way this upgrade is allowed to go is a subjective policy choice.
-		(other.kind === sequence.identifier ||
-			other.kind === requiredIdentifier ||
-			other.kind === optional.identifier ||
-			other.kind === identifierFieldIdentifier) &&
-		allowsTreeSchemaIdentifierSuperset(types, other.types),
+	// By omitting required here,
+	// this is making a policy choice that a schema upgrade cannot be done from required to identifier.
+	// Since an identifier can be upgraded into a required field,
+	// preventing the inverse helps ensure that schema upgrades are monotonic.
+	// Which direction is allowed is a subjective policy choice.
+	allowMonotonicUpgradeFrom: new Set([]),
 });
 
 /**
@@ -183,9 +172,7 @@ export const forbidden = new FlexFieldKind(
 	Multiplicity.Forbidden,
 	{
 		changeHandler: noChangeHandler,
-		// All multiplicities other than Value support empty.
-		allowsTreeSupersetOf: (types, other) =>
-			fieldKinds.get(other.kind)?.multiplicity !== Multiplicity.Single,
+		allowMonotonicUpgradeFrom: new Set(),
 	},
 );
 
@@ -213,9 +200,19 @@ export const fieldKindConfigurations: ReadonlyMap<
 			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
 		]),
 	],
+	[
+		brand(101), // Detached roots
+		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
+			[required.identifier, { kind: required, formatVersion: 2 }],
+			[optional.identifier, { kind: optional, formatVersion: 2 }],
+			[sequence.identifier, { kind: sequence, formatVersion: 2 }],
+			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
+			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
+		]),
+	],
 ]);
 
-export type ModularChangeFormatVersion = Brand<3 | 4, "ModularChangeFormatVersion">;
+export type ModularChangeFormatVersion = Brand<3 | 4 | 101, "ModularChangeFormatVersion">;
 export function getCodecTreeForModularChangeFormat(
 	version: ModularChangeFormatVersion,
 ): CodecTree {

package/src/feature-libraries/default-schema/index.ts

@@ -19,14 +19,25 @@ export {
 
 export {
 	type DefaultChangeset,
+	type DetachedRootIds,
+	type DetachedRootIdRange,
 	DefaultChangeFamily,
-	DefaultEditBuilder,
-	type IDefaultEditBuilder,
-	type ValueFieldEditBuilder,
-	type OptionalFieldEditBuilder,
-	type SequenceFieldEditBuilder,
+	type IdBasedChangeFamilyDataEditor,
+	DefaultIdBasedDataEditor,
+	type DataEditor,
+	type RequiredFieldEditor,
+	type OptionalFieldEditor,
+	type SequenceFieldEditor,
 	intoDelta,
 	relevantRemovedRoots,
 } from "./defaultEditBuilder.js";
 
+export {
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
+	type Locator,
+	LocationBasedDataEditor,
+	type ILocationBasedDataEditor,
+} from "./locationBasedEditBuilder.js";
+
 export { MappedEditBuilder } from "./mappedEditBuilder.js";

package/src/feature-libraries/default-schema/locationBasedEditBuilder.ts

@@ -0,0 +1,180 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import {
+	type ChangeAtomId,
+	type FieldKey,
+	type FieldUpPath,
+	type UpPath,
+	type TreeChunk,
+	type NormalizedUpPath,
+	type NormalizedFieldUpPath,
+	rootFieldKey,
+	makeDetachedNodeId,
+} from "../../core/index.js";
+
+import type {
+	DetachedRootIds,
+	DataEditor,
+	OptionalFieldEditor,
+	RequiredFieldEditor,
+	SequenceFieldEditor,
+} from "./defaultEditBuilder.js";
+
+export type DetachedRootLocation = FieldKey;
+export type DetachedRootsLocation = readonly DetachedRootRangeLocation[];
+export interface DetachedRootRangeLocation {
+	readonly field: FieldKey;
+	readonly count: number;
+}
+
+export interface Locator {
+	locationFromId(id: ChangeAtomId): DetachedRootLocation;
+	idFromLocation(id: DetachedRootLocation): ChangeAtomId;
+	locationsFromIdRanges(id: DetachedRootIds): DetachedRootsLocation;
+	idRangesFromLocations(id: DetachedRootsLocation): DetachedRootIds;
+}
+
+export type ILocationBasedDataEditor = DataEditor<
+	TreeChunk,
+	DetachedRootLocation,
+	DetachedRootsLocation
+>;
+
+/**
+ * Implementation of {@link DataEditor} based on the default set of supported field kinds.
+ * @sealed
+ */
+export class LocationBasedDataEditor
+	implements DataEditor<TreeChunk, DetachedRootLocation, DetachedRootsLocation>
+{
+	public constructor(
+		private readonly idBasedEditor: DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>,
+		private readonly locator: Locator,
+	) {}
+
+	public addNodeExistsConstraint(path: UpPath): void {
+		const normal = normalizeUpPath(path, this.locator);
+		this.idBasedEditor.addNodeExistsConstraint(normal);
+	}
+
+	public addNodeExistsConstraintOnRevert(path: UpPath): void {
+		const normal = normalizeUpPath(path, this.locator);
+		this.idBasedEditor.addNodeExistsConstraintOnRevert(normal);
+	}
+
+	public buildRoots(content: TreeChunk): DetachedRootsLocation {
+		const roots = this.idBasedEditor.buildRoots(content);
+		const locations = this.locator.locationsFromIdRanges(roots);
+		return locations;
+	}
+
+	public valueField(field: FieldUpPath): RequiredFieldEditor<TreeChunk, DetachedRootLocation> {
+		const normal = normalizeFieldUpPath(field, this.locator);
+		const lowLevelEditor = this.idBasedEditor.valueField(normal);
+		const locator = this.locator;
+		const editBuilder = {
+			set: (newContent: TreeChunk): void => {
+				lowLevelEditor.set(newContent);
+			},
+			attach: (newContent: DetachedRootLocation): void => {
+				const changeAtom = locator.idFromLocation(newContent);
+				lowLevelEditor.attach(changeAtom);
+			},
+		};
+		return editBuilder;
+	}
+
+	public optionalField(
+		field: FieldUpPath,
+	): OptionalFieldEditor<TreeChunk, DetachedRootLocation> {
+		const normal = normalizeFieldUpPath(field, this.locator);
+		const lowLevelEditor = this.idBasedEditor.optionalField(normal);
+		const locator = this.locator;
+		const editBuilder = {
+			set: (newContent: TreeChunk | undefined, wasEmpty: boolean): void => {
+				lowLevelEditor.set(newContent, wasEmpty);
+			},
+			attach: (newContent: DetachedRootLocation | undefined, wasEmpty: boolean): void => {
+				if (newContent === undefined) {
+					editBuilder.clear(wasEmpty);
+					return;
+				}
+				const changeAtom = locator.idFromLocation(newContent);
+				lowLevelEditor.attach(changeAtom, wasEmpty);
+			},
+			clear: (wasEmpty: boolean): void => {
+				lowLevelEditor.clear(wasEmpty);
+			},
+		};
+		return editBuilder;
+	}
+
+	public move(
+		sourceField: FieldUpPath,
+		sourceIndex: number,
+		count: number,
+		destinationField: FieldUpPath,
+		destIndex: number,
+	): void {
+		const normalSource = normalizeFieldUpPath(sourceField, this.locator);
+		const normalDestination = normalizeFieldUpPath(destinationField, this.locator);
+		this.idBasedEditor.move(normalSource, sourceIndex, count, normalDestination, destIndex);
+	}
+
+	public sequenceField(
+		field: FieldUpPath,
+	): SequenceFieldEditor<TreeChunk, DetachedRootsLocation> {
+		const normal = normalizeFieldUpPath(field, this.locator);
+		const lowLevelEditor = this.idBasedEditor.sequenceField(normal);
+		const locator = this.locator;
+		const editBuilder = {
+			insert: (index: number, content: TreeChunk): void => {
+				lowLevelEditor.insert(index, content);
+			},
+			attach: (index: number, newContent: DetachedRootsLocation): void => {
+				const range = locator.idRangesFromLocations(newContent);
+				lowLevelEditor.attach(index, range);
+			},
+			remove: (index: number, count: number): void => {
+				lowLevelEditor.remove(index, count);
+			},
+		};
+		return editBuilder;
+	}
+}
+
+function normalizeUpPath(path: UpPath, locator: Locator): NormalizedUpPath {
+	if (path.parent === undefined) {
+		if (path.parentField === rootFieldKey) {
+			return { ...path, parent: undefined, detachedNodeId: undefined };
+		} else {
+			const nodeId = locator.idFromLocation(path.parentField);
+			const detachedNodeId = makeDetachedNodeId(nodeId.revision, nodeId.localId);
+			return { ...path, parent: undefined, detachedNodeId };
+		}
+	} else {
+		return {
+			parent: normalizeUpPath(path.parent, locator),
+			parentField: path.parentField,
+			parentIndex: path.parentIndex,
+		};
+	}
+}
+
+function normalizeFieldUpPath(path: FieldUpPath, locator: Locator): NormalizedFieldUpPath {
+	if (path.parent === undefined) {
+		if (path.field === rootFieldKey) {
+			return { parent: undefined, field: rootFieldKey };
+		} else {
+			throw new UsageError(
+				"Editing only allowed on the root field or on fields under nodes with TreeStatus.InDocument or TreeStatus.Removed status",
+			);
+		}
+	} else {
+		return { parent: normalizeUpPath(path.parent, locator), field: path.field };
+	}
+}

package/src/feature-libraries/default-schema/mappedEditBuilder.ts

@@ -6,30 +6,45 @@
 import type { NormalizedFieldUpPath, NormalizedUpPath } from "../../core/index.js";
 
 import type {
-	IDefaultEditBuilder,
-	OptionalFieldEditBuilder,
-	SequenceFieldEditBuilder,
-	ValueFieldEditBuilder,
+	DataEditor,
+	OptionalFieldEditor,
+	SequenceFieldEditor,
+	RequiredFieldEditor,
 } from "./defaultEditBuilder.js";
 
 /**
  * An IDefaultEditBuilder implementation based on another IDefaultEditBuilder that uses a different content type for insertions.
  */
-export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<TAdapted> {
+export class MappedEditBuilder<TBase, TAdapted, TDetachedRoot, TDetachedRoots>
+	implements DataEditor<TAdapted, TDetachedRoot, TDetachedRoots>
+{
 	public constructor(
-		private readonly baseBuilder: IDefaultEditBuilder<TBase>,
+		private readonly baseBuilder: DataEditor<TBase, TDetachedRoot, TDetachedRoots>,
 		private readonly mapDelegate: (input: TAdapted) => TBase,
 	) {}
-	public valueField(field: NormalizedFieldUpPath): ValueFieldEditBuilder<TAdapted> {
+
+	public buildRoots(content: TAdapted): TDetachedRoots {
+		return this.baseBuilder.buildRoots(this.mapDelegate(content));
+	}
+
+	public valueField(
+		field: NormalizedFieldUpPath,
+	): RequiredFieldEditor<TAdapted, TDetachedRoot> {
 		const baseField = this.baseBuilder.valueField(field);
 		return {
 			set: (newContent: TAdapted): void => {
 				const mappedContent = this.mapDelegate(newContent);
 				baseField.set(mappedContent);
 			},
+			attach: (content: TDetachedRoot): void => {
+				baseField.attach(content);
+			},
 		};
 	}
-	public optionalField(field: NormalizedFieldUpPath): OptionalFieldEditBuilder<TAdapted> {
+
+	public optionalField(
+		field: NormalizedFieldUpPath,
+	): OptionalFieldEditor<TAdapted, TDetachedRoot> {
 		const baseField = this.baseBuilder.optionalField(field);
 		return {
 			set: (newContent: TAdapted | undefined, wasEmpty: boolean): void => {
@@ -37,9 +52,17 @@ export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<T
 					newContent === undefined ? undefined : this.mapDelegate(newContent);
 				baseField.set(mappedContent, wasEmpty);
 			},
+			attach: (content, wasEmpty: boolean): void => {
+				baseField.attach(content, wasEmpty);
+			},
+			clear(wasEmpty: boolean): void {
+				baseField.clear(wasEmpty);
+			},
 		};
 	}
-	public sequenceField(field: NormalizedFieldUpPath): SequenceFieldEditBuilder<TAdapted> {
+	public sequenceField(
+		field: NormalizedFieldUpPath,
+	): SequenceFieldEditor<TAdapted, TDetachedRoots> {
 		const baseField = this.baseBuilder.sequenceField(field);
 		return {
 			insert: (index: number, content: TAdapted): void => {
@@ -49,6 +72,9 @@ export class MappedEditBuilder<TBase, TAdapted> implements IDefaultEditBuilder<T
 			remove: (index: number, count: number): void => {
 				baseField.remove(index, count);
 			},
+			attach: (index: number, detachedContent: TDetachedRoots): void => {
+				baseField.attach(index, detachedContent);
+			},
 		};
 	}
 	public move(

package/src/feature-libraries/deltaUtils.ts

@@ -7,14 +7,19 @@ import {
 	type ChangeAtomId,
 	type DeltaDetachedNodeId,
 	type DeltaRoot,
+	makeChangeAtomId,
 	makeDetachedNodeId,
 } from "../core/index.js";
-import type { Mutable } from "../util/index.js";
+import { brand, type Mutable } from "../util/index.js";
 
 export function nodeIdFromChangeAtom(changeAtom: ChangeAtomId): DeltaDetachedNodeId {
 	return makeDetachedNodeId(changeAtom.revision, changeAtom.localId);
 }
 
+export function changeAtomFromDetachedNodeId(changeAtom: DeltaDetachedNodeId): ChangeAtomId {
+	return makeChangeAtomId(brand(changeAtom.minor), changeAtom.major);
+}
+
 /**
  * Converts a `Delta.Root` whose tree content is represented with by `TIn` instances
  * into a `Delta.Root`whose tree content is represented with by `TOut` instances.

package/src/feature-libraries/detachedFieldIndexSummarizer.ts

@@ -7,44 +7,91 @@ import { bufferToString } from "@fluid-internal/client-utils";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type {
 	IExperimentalIncrementalSummaryContext,
-	ISummaryTreeWithStats,
 	ITelemetryContext,
+	MinimumVersionForCollab,
 } from "@fluidframework/runtime-definitions/internal";
-import { createSingleBlobSummary } from "@fluidframework/shared-object-base/internal";
+import type { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
 
 import type { DetachedFieldIndex } from "../core/index.js";
-import type {
-	Summarizable,
-	SummaryElementParser,
-	SummaryElementStringifier,
+import {
+	type Summarizable,
+	type SummaryElementParser,
+	type SummaryElementStringifier,
+	VersionedSummarizer,
 } from "../shared-tree-core/index.js";
 import type { JsonCompatibleReadOnly } from "../util/index.js";
 
 /**
  * The storage key for the blob in the summary containing schema data
  */
-const detachedFieldIndexBlobKey = "DetachedFieldIndexBlob";
+export const detachedFieldIndexBlobKey = "DetachedFieldIndexBlob";
 
 /**
- * Provides methods for summarizing and loading a tree index.
+ * The versions for the detached field index summary format.
+ */
+export const enum DetachedFieldIndexSummaryFormatVersion {
+	/**
+	 * This version represents summary format before summary versioning was introduced.
+	 */
+	v1 = 1,
+	/**
+	 * This version adds metadata to the summary. This is backward compatible with version 1.
+	 */
+	v2 = 2,
+	/**
+	 * The latest version of the summary. Must be updated when a new version is added.
+	 */
+	vLatest = v2,
+}
+
+const supportedVersions = new Set<DetachedFieldIndexSummaryFormatVersion>([
+	DetachedFieldIndexSummaryFormatVersion.v1,
+	DetachedFieldIndexSummaryFormatVersion.v2,
+]);
+
+/**
+ * Returns the summary version to use as per the given minimum version for collab.
  */
-export class DetachedFieldIndexSummarizer implements Summarizable {
-	public readonly key = "DetachedFieldIndex";
+function minVersionToDetachedFieldIndexSummaryFormatVersion(
+	version: MinimumVersionForCollab,
+): DetachedFieldIndexSummaryFormatVersion {
+	// Currently, version 2 is written which adds metadata blob to the summary.
+	return DetachedFieldIndexSummaryFormatVersion.v2;
+}
 
-	public constructor(private readonly detachedFieldIndex: DetachedFieldIndex) {}
+/**
+ * Provides methods for summarizing and loading a tree index.
+ */
+export class DetachedFieldIndexSummarizer
+	extends VersionedSummarizer<DetachedFieldIndexSummaryFormatVersion>
+	implements Summarizable
+{
+	public constructor(
+		private readonly detachedFieldIndex: DetachedFieldIndex,
+		minVersionForCollab: MinimumVersionForCollab,
+	) {
+		super(
+			"DetachedFieldIndex",
+			minVersionToDetachedFieldIndexSummaryFormatVersion(minVersionForCollab),
+			supportedVersions,
+			true,
+		);
+	}
 
-	public summarize(props: {
+	protected summarizeInternal(props: {
 		stringify: SummaryElementStringifier;
 		fullTree?: boolean;
 		trackState?: boolean;
 		telemetryContext?: ITelemetryContext;
 		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext;
-	}): ISummaryTreeWithStats {
+		builder: SummaryTreeBuilder;
+	}): void {
+		const { stringify, builder } = props;
 		const data = this.detachedFieldIndex.encode();
-		return createSingleBlobSummary(detachedFieldIndexBlobKey, props.stringify(data));
+		builder.addBlob(detachedFieldIndexBlobKey, stringify(data));
 	}
 
-	public async load(
+	protected async loadInternal(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,
 	): Promise<void> {

package/src/feature-libraries/flex-tree/context.ts

@@ -51,6 +51,8 @@ export interface FlexTreeContext {
 	 * If true, none of the nodes in this context can be used.
 	 */
 	isDisposed(): boolean;
+
+	runInTransaction(fn: () => void): void;
 }
 
 /**
@@ -66,6 +68,14 @@ export interface FlexTreeHydratedContextMinimal {
 	 * The checkout object associated with this context.
 	 */
 	readonly checkout: ITreeCheckout;
+
+	/**
+	 * Returns a new {@link FlexTreeField} that will live as long as the caller allows up to the next call to {@link clear} or disposal of the context.
+	 * @remarks
+	 * Due to limited support for detached fields, not all operations are supported.
+	 * Additionally if the detached field's content is deleted, the field will become out of schema if it is required: it must not be used after that point.
+	 */
+	detachedField?(key: DetachedField, schema: FieldKindIdentifier): FlexTreeField;
 }
 
 /**
@@ -152,6 +162,13 @@ export class Context implements FlexTreeHydratedContext, IDisposable {
 		return this.checkout.storedSchema;
 	}
 
+	public runInTransaction(fn: () => void): void {
+		debugAssert(() => !this.disposed || "Disposed");
+		this.checkout.transaction.start();
+		fn();
+		this.checkout.transaction.commit();
+	}
+
 	/**
 	 * Called before editing.
 	 * Clears all cursors so editing can proceed.

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -14,15 +14,14 @@ import {
 } from "../../core/index.js";
 import type {
 	FieldKinds,
-	SequenceFieldEditBuilder,
-	ValueFieldEditBuilder,
-	OptionalFieldEditBuilder,
+	SequenceFieldEditor,
+	RequiredFieldEditor,
+	OptionalFieldEditor,
 } from "../default-schema/index.js";
 import type {
 	MapTreeFieldViewGeneric,
 	MapTreeNodeViewGeneric,
 	MinimalFieldMap,
-	MinimalMapTreeNodeView,
 } from "../mapTreeCursor.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
 
@@ -309,7 +308,7 @@ export type FlexibleFieldContent = readonly FlexibleNodeContent[];
 /**
  * Tree for inserting as a node.
  */
-export type FlexibleNodeContent = MinimalMapTreeNodeView;
+export type FlexibleNodeContent = FlexTreeNode;
 
 /**
  * {@link FlexTreeField} that stores a sequence of children.
@@ -354,7 +353,7 @@ export interface FlexTreeSequenceField extends FlexTreeField {
 	/**
 	 * Get an editor for this sequence.
 	 */
-	readonly editor: SequenceFieldEditBuilder<FlexibleFieldContent>;
+	readonly editor: SequenceFieldEditor<FlexibleFieldContent, readonly FlexTreeNode[]>;
 }
 
 /**
@@ -366,7 +365,7 @@ export interface FlexTreeSequenceField extends FlexTreeField {
 export interface FlexTreeRequiredField extends FlexTreeField {
 	get content(): FlexTreeUnknownUnboxed;
 
-	readonly editor: ValueFieldEditBuilder<FlexibleNodeContent>;
+	readonly editor: RequiredFieldEditor<FlexibleNodeContent, FlexTreeNode>;
 }
 
 /**
@@ -385,7 +384,7 @@ export interface FlexTreeRequiredField extends FlexTreeField {
 export interface FlexTreeOptionalField extends FlexTreeField {
 	get content(): FlexTreeUnknownUnboxed | undefined;
 
-	readonly editor: OptionalFieldEditBuilder<FlexibleNodeContent>;
+	readonly editor: OptionalFieldEditor<FlexibleNodeContent, FlexTreeNode>;
 }
 
 // #endregion