@fluidframework/tree 2.21.0 → 2.23.0-323641

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

@@ -171,6 +171,141 @@ export type ScopedSchemaName<
 > = TScope extends undefined ? `${TName}` : `${TScope}.${TName}`;
 // > = `${TScope extends undefined ? "" : `${TScope}.`}${TName}`;
 
+/**
+ * Stateless APIs exposed via {@link SchemaFactory} as both instance properties and as statics.
+ * @privateRemarks
+ * We have no way to make linkable members which exist both as statics and instance properties since API-Extractor does not support this.
+ * As a workaround, we have this type as a third place which can be linked.
+ * @system @sealed @public
+ */
+export const schemaStatics = {
+	/**
+	 * {@link TreeNodeSchema} for holding a JavaScript `string`.
+	 *
+	 * @remarks
+	 * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.
+	 *
+	 * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.
+	 * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.
+	 * @privateRemarks
+	 * TODO:
+	 * We should be much more clear about what happens if you use problematic values.
+	 * We should validate and/or normalize them when inserting content.
+	 */
+	string: stringSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for holding a JavaScript `number`.
+	 *
+	 * @remarks
+	 * The number is a {@link https://en.wikipedia.org/wiki/Double-precision_floating-point_format | double-precision 64-bit binary format IEEE 754} value, however there are some exceptions:
+	 * - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).
+	 * - `-0` may be converted to `0` in some cases.
+	 *
+	 * These limitations match the limitations of JSON.
+	 * @privateRemarks
+	 * TODO:
+	 * We should be much more clear about what happens if you use problematic values.
+	 * We should validate and/or normalize them when inserting content.
+	 */
+	number: numberSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for holding a boolean.
+	 */
+	boolean: booleanSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for JavaScript `null`.
+	 *
+	 * @remarks
+	 * There are good {@link https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null | reasons to avoid using null} in JavaScript, however sometimes it is desired.
+	 * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.
+	 * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.
+	 */
+	null: nullSchema,
+
+	/**
+	 * {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.
+	 */
+	handle: handleSchema,
+
+	/**
+	 * {@link AllowedTypes} for holding any of the leaf types.
+	 */
+	leaves: [stringSchema, numberSchema, booleanSchema, nullSchema, handleSchema],
+
+	/**
+	 * Make a field optional instead of the default, which is required.
+	 *
+	 * @param t - The types allowed under the field.
+	 * @param props - Optional properties to associate with the field.
+	 *
+	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+	 * See {@link FieldSchemaMetadata.custom}.
+	 */
+	optional: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
+		t: T,
+		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
+	): FieldSchema<FieldKind.Optional, T, TCustomMetadata> => {
+		const defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => {
+			return undefined;
+		});
+		return createFieldSchema(FieldKind.Optional, t, {
+			defaultProvider: defaultOptionalProvider,
+			...props,
+		});
+	},
+
+	/**
+	 * Make a field explicitly required.
+	 *
+	 * @param t - The types allowed under the field.
+	 * @param props - Optional properties to associate with the field.
+	 *
+	 * @remarks
+	 * Fields are required by default, but this API can be used to make the required nature explicit in the schema,
+	 * and allows associating custom {@link FieldProps | properties} with the field.
+	 *
+	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
+	 * See {@link FieldSchemaMetadata.custom}.
+	 */
+	required: <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
+		t: T,
+		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
+	): FieldSchema<FieldKind.Required, T, TCustomMetadata> => {
+		return createFieldSchema(FieldKind.Required, t, props);
+	},
+
+	/**
+	 * {@link schemaStatics.optional} except tweaked to work better for recursive types.
+	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
+	 * @remarks
+	 * This version of {@link schemaStatics.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
+	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 */
+	optionalRecursive: <const T extends Unenforced<ImplicitAllowedTypes>>(
+		t: T,
+		props?: Omit<FieldProps, "defaultProvider">,
+	): FieldSchemaUnsafe<FieldKind.Optional, T> => {
+		return createFieldSchemaUnsafe(FieldKind.Optional, t, props);
+	},
+
+	/**
+	 * {@link schemaStatics.required} except tweaked to work better for recursive types.
+	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
+	 * @remarks
+	 * This version of {@link schemaStatics.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
+	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 */
+	requiredRecursive: <const T extends Unenforced<ImplicitAllowedTypes>>(
+		t: T,
+		props?: Omit<FieldProps, "defaultProvider">,
+	): FieldSchemaUnsafe<FieldKind.Required, T> => {
+		return createFieldSchemaUnsafe(FieldKind.Required, t, props);
+	},
+} as const;
+
 // TODO:
 // SchemaFactory.array references should link to the correct overloads, however the syntax for this does not seems to work currently for methods unless the they are not qualified with the class.
 // API-Extractor requires such links to be qualified with the class, so it can't work.
@@ -328,56 +463,65 @@ export class SchemaFactory<
 	}
 
 	/**
-	 * {@link TreeNodeSchema} for holding a JavaScript `string`.
-	 *
-	 * @remarks
-	 * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.
-	 *
-	 * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.
-	 * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
+	 * {@inheritDoc schemaStatics.string}
 	 */
 	public readonly string = stringSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for holding a JavaScript `number`.
-	 *
-	 * @remarks
-	 * The number is a [double-precision 64-bit binary format IEEE 754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) value, however there are some exceptions:
-	 * - `NaN`, and the infinities are converted to `null` (and may therefore only be used where `null` is allowed by the schema).
-	 * - `-0` may be converted to `0` in some cases.
-	 *
-	 * These limitations match the limitations of JSON.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
+	 * {@inheritDoc schemaStatics.number}
 	 */
 	public readonly number = numberSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for holding a boolean.
+	 * {@inheritDoc schemaStatics.boolean}
 	 */
 	public readonly boolean = booleanSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for JavaScript `null`.
-	 *
-	 * @remarks
-	 * There are good [reasons to avoid using null](https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null) in JavaScript, however sometimes it is desired.
-	 * This {@link TreeNodeSchema} node provides the option to include nulls in trees when desired.
-	 * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.
+	 * {@inheritDoc schemaStatics.null}
 	 */
 	public readonly null = nullSchema;
 
 	/**
-	 * {@link TreeNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.
+	 * {@inheritDoc schemaStatics.handle}
 	 */
 	public readonly handle = handleSchema;
 
+	/**
+	 * {@inheritDoc schemaStatics.leaves}
+	 */
+	public readonly leaves = schemaStatics.leaves;
+
+	/**
+	 * {@inheritDoc schemaStatics.string}
+	 */
+	public static readonly string = stringSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.number}
+	 */
+	public static readonly number = numberSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.boolean}
+	 */
+	public static readonly boolean = booleanSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.null}
+	 */
+	public static readonly null = nullSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.handle}
+	 */
+	public static readonly handle = handleSchema;
+
+	/**
+	 * {@inheritDoc schemaStatics.leaves}
+	 */
+	public static readonly leaves = schemaStatics.leaves;
+
 	/**
 	 * Define a {@link TreeNodeSchemaClass} for a {@link TreeObjectNode}.
 	 *
@@ -696,74 +840,44 @@ export class SchemaFactory<
 	}
 
 	/**
-	 * Make a field optional instead of the default, which is required.
-	 *
-	 * @param t - The types allowed under the field.
-	 * @param props - Optional properties to associate with the field.
-	 *
-	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
-	 * See {@link FieldSchemaMetadata.custom}.
+	 * {@inheritDoc schemaStatics.optional}
 	 */
-	public optional<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	): FieldSchema<FieldKind.Optional, T, TCustomMetadata> {
-		const defaultOptionalProvider: DefaultProvider = getDefaultProvider(() => {
-			return undefined;
-		});
-		return createFieldSchema(FieldKind.Optional, t, {
-			defaultProvider: defaultOptionalProvider,
-			...props,
-		});
-	}
+	public readonly optional = schemaStatics.optional;
 
 	/**
-	 * Make a field explicitly required.
-	 *
-	 * @param t - The types allowed under the field.
-	 * @param props - Optional properties to associate with the field.
-	 *
-	 * @remarks
-	 * Fields are required by default, but this API can be used to make the required nature explicit in the schema,
-	 * and allows associating custom {@link FieldProps | properties} with the field.
-	 *
-	 * @typeParam TCustomMetadata - Custom metadata properties to associate with the field.
-	 * See {@link FieldSchemaMetadata.custom}.
+	 * {@inheritDoc schemaStatics.required}
 	 */
-	public required<const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(
-		t: T,
-		props?: Omit<FieldProps<TCustomMetadata>, "defaultProvider">,
-	): FieldSchema<FieldKind.Required, T, TCustomMetadata> {
-		return createFieldSchema(FieldKind.Required, t, props);
-	}
+	public readonly required = schemaStatics.required;
 
 	/**
-	 * {@link SchemaFactory.optional} except tweaked to work better for recursive types.
-	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
-	 * @remarks
-	 * This version of {@link SchemaFactory.optional} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 * {@inheritDoc schemaStatics.optionalRecursive}
 	 */
-	public optionalRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(
-		t: T,
-		props?: Omit<FieldProps, "defaultProvider">,
-	): FieldSchemaUnsafe<FieldKind.Optional, T> {
-		return createFieldSchemaUnsafe(FieldKind.Optional, t, props);
-	}
+	public readonly optionalRecursive = schemaStatics.optionalRecursive;
 
 	/**
-	 * {@link SchemaFactory.required} except tweaked to work better for recursive types.
-	 * Use with {@link ValidateRecursiveSchema} for improved type safety.
-	 * @remarks
-	 * This version of {@link SchemaFactory.required} has fewer type constraints to work around TypeScript limitations, see {@link Unenforced}.
-	 * See {@link ValidateRecursiveSchema} for additional information about using recursive schema.
+	 * {@inheritDoc schemaStatics.requiredRecursive}
 	 */
-	public requiredRecursive<const T extends Unenforced<ImplicitAllowedTypes>>(
-		t: T,
-		props?: Omit<FieldProps, "defaultProvider">,
-	): FieldSchemaUnsafe<FieldKind.Required, T> {
-		return createFieldSchemaUnsafe(FieldKind.Required, t, props);
-	}
+	public readonly requiredRecursive = schemaStatics.requiredRecursive;
+
+	/**
+	 * {@inheritDoc schemaStatics.optional}
+	 */
+	public static readonly optional = schemaStatics.optional;
+
+	/**
+	 * {@inheritDoc schemaStatics.required}
+	 */
+	public static readonly required = schemaStatics.required;
+
+	/**
+	 * {@inheritDoc schemaStatics.optionalRecursive}
+	 */
+	public static readonly optionalRecursive = schemaStatics.optionalRecursive;
+
+	/**
+	 * {@inheritDoc schemaStatics.requiredRecursive}
+	 */
+	public static readonly requiredRecursive = schemaStatics.requiredRecursive;
 
 	/**
 	 * A special field which holds a unique identifier for an object node.

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

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { TreeNode } from "../simple-tree/index.js";
+import type { TreeNode } from "../core/index.js";
 
 /**
  * A special object that signifies when a SharedTree {@link RunTransaction | transaction} should "roll back".

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

@@ -13,11 +13,6 @@ import type {
 } from "../../core/index.js";
 
 import type {
-	RunTransactionParams,
-	VoidTransactionCallbackStatus,
-	TransactionCallbackStatus,
-	TransactionResult,
-	TransactionResultExt,
 	// This is referenced by doc comments.
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
 	TreeAlpha,
@@ -42,6 +37,15 @@ import { markSchemaMostDerived } from "./schemaFactory.js";
 import { fail, getOrCreate } from "../../util/index.js";
 import type { MakeNominal } from "../../util/index.js";
 import { walkFieldSchema } from "../walkFieldSchema.js";
+import type { VerboseTree } from "./verboseTree.js";
+import type { SimpleTreeSchema } from "./simpleSchema.js";
+import type {
+	RunTransactionParams,
+	TransactionCallbackStatus,
+	TransactionResult,
+	TransactionResultExt,
+	VoidTransactionCallbackStatus,
+} from "./transactionTypes.js";
 /**
  * A tree from which a {@link TreeView} can be created.
  *
@@ -52,7 +56,6 @@ import { walkFieldSchema } from "../walkFieldSchema.js";
  * Maybe rename "exportJsonSchema" to align on "concise" terminology.
  * Ensure schema exporting APIs here align and reference APIs for exporting view schema to the same formats (which should include stored vs property key choice).
  * Make sure users of independentView can use these export APIs (maybe provide a reference back to the ViewableTree from the TreeView to accomplish that).
- * Some of these APIs are on ISharedTree and can get moved here.
  * @system @sealed @public
  */
 export interface ViewableTree {
@@ -101,6 +104,28 @@ export interface ViewableTree {
  */
 export interface ITree extends ViewableTree, IFluidLoadable {}
 
+/**
+ * {@link ITree} extended with some alpha APIs.
+ * @privateRemarks
+ * TODO: Promote this to alpha.
+ * @internal
+ */
+export interface ITreeAlpha extends ITree {
+	/**
+	 * Exports root in the same format as {@link TreeAlpha.(exportVerbose:1)} using stored keys.
+	 * @remarks
+	 * This is `undefined` if and only if the root field is empty (this can only happen if the root field is optional).
+	 */
+	exportVerbose(): VerboseTree | undefined;
+
+	/**
+	 * Exports the SimpleTreeSchema that is stored in the tree, using stored keys for object fields.
+	 * @remarks
+	 * To get the schema using property keys, use {@link getSimpleSchema} on the view schema.
+	 */
+	exportSimpleSchema(): SimpleTreeSchema;
+}
+
 /**
  * Options when constructing a tree view.
  * @public

package/src/simple-tree/index.ts

@@ -124,6 +124,18 @@ export {
 	type CustomTreeNode,
 	type CustomTreeValue,
 	tryStoredSchemaAsArray,
+	type schemaStatics,
+	type ITreeAlpha,
+	type TransactionConstraint,
+	type NodeInDocumentConstraint,
+	type RunTransactionParams,
+	type VoidTransactionCallbackStatus,
+	type TransactionCallbackStatus,
+	type TransactionResult,
+	type TransactionResultExt,
+	type TransactionResultSuccess,
+	type TransactionResultFailed,
+	rollback,
 } from "./api/index.js";
 export {
 	type NodeFromSchema,

package/src/simple-tree/schemaTypes.ts

@@ -281,7 +281,7 @@ export let createFieldSchema: <
  * including functionality that does not have to be kept consistent across versions or deterministic.
  *
  * This can include policy for how to use this schema for "view" purposes, and well as how to expose editing APIs.
- * Use {@link SchemaFactory} to create the FieldSchema instances, for example {@link SchemaFactory.optional}.
+ * Use {@link SchemaFactory} to create the FieldSchema instances, for example {@link schemaStatics.optional}.
  * @privateRemarks
  * Public access to the constructor is removed to prevent creating expressible but unsupported (or not stable) configurations.
  * {@link createFieldSchema} can be used internally to create instances.
@@ -822,7 +822,7 @@ export type NodeBuilderData<T extends TreeNodeSchemaCore<string, NodeKind, boole
 /**
  * Value that may be stored as a leaf node.
  * @remarks
- * Some limitations apply, see the documentation for {@link SchemaFactory.number} and {@link SchemaFactory.string} for those restrictions.
+ * Some limitations apply, see the documentation for {@link schemaStatics.number} and {@link schemaStatics.string} for those restrictions.
  * @public
  */
 // eslint-disable-next-line @rushstack/no-new-null

package/src/treeFactory.ts

@@ -15,25 +15,43 @@ import {
 	createSharedObjectKind,
 } from "@fluidframework/shared-object-base/internal";
 
-import { pkgVersion } from "./packageVersion.js";
-import { SharedTree as SharedTreeImpl, type SharedTreeOptions } from "./shared-tree/index.js";
+import {
+	SharedTree as SharedTreeImpl,
+	type SharedTreeOptions,
+	type SharedTreeOptionsInternal,
+} from "./shared-tree/index.js";
 import type { ITree } from "./simple-tree/index.js";
 
+import { pkgVersion } from "./packageVersion.js";
+
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
+ * @alpha
+ * @legacy
+ */
+export const SharedTreeFactoryType = "https://graph.microsoft.com/types/tree";
+
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory.attributes}
+ * @alpha
+ * @legacy
+ */
+export const SharedTreeAttributes: IChannelAttributes = {
+	type: SharedTreeFactoryType,
+	snapshotFormatVersion: "0.0.0",
+	packageVersion: pkgVersion,
+};
+
 /**
  * A channel factory that creates an {@link ITree}.
  */
 export class TreeFactory implements IChannelFactory<ITree> {
-	public static readonly Type = "https://graph.microsoft.com/types/tree";
-	public static readonly attributes: IChannelAttributes = {
-		type: this.Type,
-		snapshotFormatVersion: "0.0.0",
-		packageVersion: pkgVersion,
-	};
+	public static Type: string = SharedTreeFactoryType;
+	public readonly type: string = SharedTreeFactoryType;
 
-	public readonly type = TreeFactory.Type;
-	public readonly attributes: IChannelAttributes = TreeFactory.attributes;
+	public readonly attributes: IChannelAttributes = SharedTreeAttributes;
 
-	public constructor(private readonly options: SharedTreeOptions) {}
+	public constructor(private readonly options: SharedTreeOptionsInternal) {}
 
 	public async load(
 		runtime: IFluidDataStoreRuntime,

package/src/util/breakable.ts

@@ -47,7 +47,7 @@ export class Breakable {
 	 * @privateRemarks
 	 * If there is a use-case, this should be made public.
 	 */
-	private rethrowCaught(brokenBy: unknown): never {
+	public rethrowCaught(brokenBy: unknown): never {
 		if (brokenBy instanceof Error) {
 			this.break(brokenBy);
 		}

package/src/util/index.ts

@@ -56,6 +56,7 @@ export type {
 export { StackyIterator } from "./stackyIterator.js";
 export {
 	asMutable,
+	balancedReduce,
 	clone,
 	compareSets,
 	fail,

package/src/util/rangeMap.ts

@@ -61,7 +61,7 @@ export class RangeMap<K, V> {
 	 * Retrieves the values for all keys in the query range.
 	 *
 	 * @param start - The first key in the range being queried
-	 * @param length  - The length of the query range
+	 * @param length - The length of the query range
 	 * @returns A list of entries, each describing the value for some subrange of the query.
 	 * The entries are in the same order as the keys, and there is an entry for every key with a non `undefined` value.
 	 */

package/src/util/utils.ts

@@ -616,3 +616,35 @@ export function copyPropertyIfDefined<
 		}
 	}
 }
+
+/**
+ * Reduces an array of values into a single value.
+ * This is similar to `Array.prototype.reduce`,
+ * except that it recursively reduces the left and right halves of the input before reducing their respective reductions.
+ *
+ * When compared with an approach like reducing all the values left-to-right,
+ * this balanced approach is beneficial when the cost of invoking `callbackFn` is proportional to the number reduced values that its parameters collectively represent.
+ * For example, if `T` is an array, and `callbackFn` concatenates its inputs,
+ * then `balancedReduce` will have O(N*log(N)) time complexity instead of `Array.prototype.reduce`'s O(N²).
+ * However, if `callbackFn` is O(1) then both `balancedReduce` and `Array.prototype.reduce` will have O(N) complexity.
+ *
+ * @param array - The array to reduce.
+ * @param callbackFn - The function to execute for each pairwise reduction.
+ * @param emptyCase - A factory function that provides the value to return if the input array is empty.
+ */
+export function balancedReduce<T>(
+	array: readonly T[],
+	callbackFn: (left: T, right: T) => T,
+	emptyCase: () => T,
+): T {
+	if (hasSingle(array)) {
+		return array[0];
+	}
+	if (!hasSome(array)) {
+		return emptyCase();
+	}
+	const mid = Math.floor(array.length / 2);
+	const left = balancedReduce(array.slice(0, mid), callbackFn, emptyCase);
+	const right = balancedReduce(array.slice(mid), callbackFn, emptyCase);
+	return callbackFn(left, right);
+}

package/dist/core/tree/visitPath.d.ts

@@ -1,101 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ProtoNodes } from "./delta.js";
-import type { DetachedPlaceUpPath, DetachedRangeUpPath, PlaceUpPath, RangeUpPath, UpPath } from "./pathTree.js";
-/**
- * Delta visitor for the path tree.
- *
- * For any of these events, the paths are guaranteed to be valid at the time of the event,
- * and it is valid to read from the Forest at that path.
- */
-export interface PathVisitor {
-    /**
-     * Invoked after the creation of a range of nodes.
-     * @param content - The content that was created.
-     */
-    afterCreate(content: DetachedRangeUpPath): void;
-    /**
-     * Invoked before the attaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that will be attached.
-     * @param destination - The location where the content will be attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeAttach(source: DetachedRangeUpPath, destination: PlaceUpPath): void;
-    /**
-     * Invoked after the attaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The location where the content originated.
-     * @param destination - The content that was attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    afterAttach(source: DetachedPlaceUpPath, destination: RangeUpPath): void;
-    /**
-     * Invoked before the detaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that will be detached.
-     * @param destination - The location where the content will be sent to.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeDetach(source: RangeUpPath, destination: DetachedPlaceUpPath): void;
-    /**
-     * Invoked after the detaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that was detached.
-     * @param destination - The location where the content will be attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    afterDetach(source: PlaceUpPath, destination: DetachedRangeUpPath): void;
-    /**
-     * Invoked before the replacement of a range of nodes.
-     *
-     * Note that the `newContent` range length will always match the `oldContent` range length.
-     * A replace might actually be separate detaches and attaches which have been coalesced.
-     *
-     * @param newContent - The content that will be attached in place of the old.
-     * @param oldContent - The old that will be replaced.
-     * @param oldContentDestination - The destination of the old content.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeReplace(newContent: DetachedRangeUpPath, oldContent: RangeUpPath, oldContentDestination: DetachedPlaceUpPath): void;
-    /**
-     * Invoked after the replacement of a range of nodes.
-     *
-     * Note that the `newContent` range length will always match the `oldContent` range length.
-     * A replace might actually be separate detaches and attaches which have been coalesced.
-     *
-     * @param newContentSource - The place that the new content came from.
-     * @param newContent - The new content.
-     * @param oldContent - The content that was replaced.
-     */
-    afterReplace(newContentSource: DetachedPlaceUpPath, newContent: RangeUpPath, oldContent: DetachedRangeUpPath): void;
-    /**
-     * Invoked before content is destroyed.
-     * @param content - The content that will be destroyed
-     */
-    beforeDestroy(content: DetachedRangeUpPath): void;
-    /**
-     * A sequence of nodes of length `count` is being removed starting with `path`.
-     * Called when these nodes are no longer parented under their previous parent, and do not have a new parent.
-     * It is possible they may be restored in the future (for example by a conflicted merge or undo).
-     *
-     * Not called for children of removed nodes.
-     *
-     * @param path - first node in the removed range.
-     * @param count - length of removed range.
-     *
-     * @deprecated Migrate to using the other events.
-     */
-    onRemove(path: UpPath, count: number): void;
-    /**
-     * @param path - location which first node of inserted range will have after insert.
-     * Any nodes at this index (or after it) will be moved to the right (have their indexes increased by `content.length`).
-     * @param content - content which is being inserted.
-     *
-     * @deprecated Migrate to using the other events.
-     */
-    onInsert(path: UpPath, content: ProtoNodes): void;
-}
-//# sourceMappingURL=visitPath.d.ts.map