@fluidframework/tree 2.118.1 → 3.0.1

package/src/tableSchema.ts

@@ -629,25 +629,9 @@ export namespace System_TableSchema {
 			}
 
 			public insertColumns(
-				columnsOrParams:
-					| readonly ColumnInsertableType[]
-					| TableSchema.InsertColumnsParameters<TColumnSchema>,
-				maybeIndex?: number,
+				columns: readonly ColumnInsertableType[],
+				index?: number,
 			): ColumnValueType[] {
-				// Dispatch on the runtime type of the first argument to disambiguate the two overloads:
-				//  * Array  → positional `(columns, index?)` overload
-				//  * object → deprecated `(params)` property-bag overload
-				let index: number | undefined;
-				let columns: readonly ColumnInsertableType[];
-				if (Array.isArray(columnsOrParams)) {
-					index = maybeIndex;
-					columns = columnsOrParams;
-				} else {
-					const params = columnsOrParams as TableSchema.InsertColumnsParameters<TColumnSchema>;
-					index = params.index;
-					columns = params.columns;
-				}
-
 				// #region Input validation
 
 				// Ensure specified index is valid
@@ -692,26 +676,7 @@ export namespace System_TableSchema {
 				return columns as unknown as ColumnValueType[];
 			}
 
-			public insertRows(
-				rowsOrParams:
-					| readonly RowInsertableType[]
-					| TableSchema.InsertRowsParameters<TRowSchema>,
-				maybeIndex?: number,
-			): RowValueType[] {
-				// Dispatch on the runtime type of the first argument to disambiguate the two overloads:
-				//  * Array  → positional `(rows, index?)` overload
-				//  * object → deprecated `(params)` property-bag overload
-				let index: number | undefined;
-				let rows: readonly RowInsertableType[];
-				if (Array.isArray(rowsOrParams)) {
-					index = maybeIndex;
-					rows = rowsOrParams;
-				} else {
-					const params = rowsOrParams as TableSchema.InsertRowsParameters<TRowSchema>;
-					index = params.index;
-					rows = params.rows;
-				}
-
+			public insertRows(rows: readonly RowInsertableType[], index?: number): RowValueType[] {
 				// #region Input validation
 
 				// Ensure specified index is valid
@@ -755,35 +720,10 @@ export namespace System_TableSchema {
 			}
 
 			public setCell(
-				rowOrParams:
-					| string
-					| number
-					| RowValueType
-					| TableSchema.SetCellParameters<TCellSchema, TColumnSchema, TRowSchema>,
-				maybeColumn?: string | number | ColumnValueType,
-				maybeCell?: CellInsertableType,
+				rowOrId: string | number | RowValueType,
+				columnOrId: string | number | ColumnValueType,
+				cell: CellInsertableType,
 			): void {
-				// Dispatch on the presence of the second argument to disambiguate the two overloads:
-				//  * `maybeColumn === undefined` → deprecated `(params)` property-bag overload; unpack from `params.key`/`params.cell`
-				//  * otherwise                   → positional `(row, column, cell)` overload
-				let rowOrId: string | number | RowValueType;
-				let columnOrId: string | number | ColumnValueType;
-				let cell: CellInsertableType;
-				if (maybeColumn === undefined) {
-					const params = rowOrParams as TableSchema.SetCellParameters<
-						TCellSchema,
-						TColumnSchema,
-						TRowSchema
-					>;
-					rowOrId = params.key.row as string | number | RowValueType;
-					columnOrId = params.key.column as string | number | ColumnValueType;
-					cell = params.cell as CellInsertableType;
-				} else {
-					rowOrId = rowOrParams as string | number | RowValueType;
-					columnOrId = maybeColumn;
-					cell = maybeCell as CellInsertableType;
-				}
-
 				const row = this.#getRow(rowOrId);
 				const column = this.#getColumn(columnOrId);
 
@@ -1009,26 +949,9 @@ export namespace System_TableSchema {
 			}
 
 			public removeCell(
-				rowOrKey:
-					| string
-					| number
-					| RowValueType
-					| TableSchema.CellKey<TColumnSchema, TRowSchema>,
-				maybeColumn?: string | number | ColumnValueType,
+				rowOrIdOrIndex: string | number | RowValueType,
+				columnOrIdOrIndex: string | number | ColumnValueType,
 			): CellValueType | undefined {
-				// Dispatch on the presence of the second argument to disambiguate the two overloads:
-				//  * `maybeColumn === undefined` → deprecated `(key)` overload; unpack from `key.row`/`key.column`
-				//  * otherwise                   → positional `(row, column)` overload
-				let rowOrIdOrIndex: string | number | RowValueType;
-				let columnOrIdOrIndex: string | number | ColumnValueType;
-				if (maybeColumn === undefined) {
-					const key = rowOrKey as TableSchema.CellKey<TColumnSchema, TRowSchema>;
-					rowOrIdOrIndex = key.row as string | number | RowValueType;
-					columnOrIdOrIndex = key.column as string | number | ColumnValueType;
-				} else {
-					rowOrIdOrIndex = rowOrKey as string | number | RowValueType;
-					columnOrIdOrIndex = maybeColumn;
-				}
 				const row = this.#getRow(rowOrIdOrIndex) as RowValueInternalType;
 				const column = this.#getColumn(columnOrIdOrIndex);
 
@@ -1893,63 +1816,6 @@ export namespace TableSchema {
 		readonly row: string | number | TreeNodeFromImplicitAllowedTypes<TRow>;
 	}
 
-	/**
-	 * {@link TableSchema.Table.(insertColumns:2)} parameters.
-	 * @input @beta
-	 * @deprecated Use the positional argument overload of {@link TableSchema.Table.(insertColumns:1)} instead.
-	 */
-	export interface InsertColumnsParameters<TColumn extends ImplicitAllowedTypes> {
-		/**
-		 * The index at which to insert the new columns.
-		 * @remarks If not provided, the columns will be appended to the end of the table.
-		 */
-		readonly index?: number | undefined;
-
-		/**
-		 * The columns to insert.
-		 */
-		readonly columns: InsertableTreeNodeFromImplicitAllowedTypes<TColumn>[];
-	}
-
-	/**
-	 * {@link TableSchema.Table.(insertRows:2)} parameters.
-	 * @input @beta
-	 * @deprecated Use the positional argument overload of {@link TableSchema.Table.(insertRows:1)} instead.
-	 */
-	export interface InsertRowsParameters<TRow extends ImplicitAllowedTypes> {
-		/**
-		 * The index at which to insert the new rows.
-		 * @remarks If not provided, the rows will be appended to the end of the table.
-		 */
-		readonly index?: number | undefined;
-
-		/**
-		 * The rows to insert.
-		 */
-		readonly rows: InsertableTreeNodeFromImplicitAllowedTypes<TRow>[];
-	}
-
-	/**
-	 * {@link TableSchema.Table.(setCell:2)} parameters.
-	 * @input @beta
-	 * @deprecated Use the positional argument overload of {@link TableSchema.Table.(setCell:1)} instead.
-	 */
-	export interface SetCellParameters<
-		TCell extends ImplicitAllowedTypes,
-		TColumn extends ImplicitAllowedTypes,
-		TRow extends ImplicitAllowedTypes,
-	> {
-		/**
-		 * The key to uniquely identify a cell in a table.
-		 */
-		readonly key: CellKey<TColumn, TRow>;
-
-		/**
-		 * The cell to set.
-		 */
-		readonly cell: InsertableTreeNodeFromImplicitAllowedTypes<TCell>;
-	}
-
 	/**
 	 * A table.
 	 *
@@ -2029,19 +1895,6 @@ export namespace TableSchema {
 			columns: readonly InsertableTreeNodeFromImplicitAllowedTypes<TColumn>[],
 			index?: number,
 		): TreeNodeFromImplicitAllowedTypes<TColumn>[];
-		/**
-		 * Inserts 0 or more columns into the table.
-		 *
-		 * @throws Throws an error if the specified index is out of range.
-		 *
-		 * No columns are inserted in this case.
-		 *
-		 * @deprecated Use {@link TableSchema.Table.(insertColumns:1)} instead.
-		 */
-		insertColumns(
-			params: InsertColumnsParameters<TColumn>,
-		): TreeNodeFromImplicitAllowedTypes<TColumn>[];
-
 		/**
 		 * Inserts 0 or more rows into the table.
 		 * @param rows - The rows to insert.
@@ -2059,22 +1912,6 @@ export namespace TableSchema {
 			rows: readonly InsertableTreeNodeFromImplicitAllowedTypes<TRow>[],
 			index?: number,
 		): TreeNodeFromImplicitAllowedTypes<TRow>[];
-		/**
-		 * Inserts 0 or more rows into the table.
-		 *
-		 * @throws
-		 * Throws an error in the following cases:
-		 *
-		 * - The row contains cells, but the table does not contain matching columns for one or more of those cells.
-		 *
-		 * - The specified index is out of range.
-		 *
-		 * No rows are inserted in these cases.
-		 *
-		 * @deprecated Use {@link TableSchema.Table.(insertRows:1)} instead.
-		 */
-		insertRows(params: InsertRowsParameters<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>[];
-
 		/**
 		 * Sets the cell at the specified location in the table.
 		 * @param row - The {@link TableSchema.Row}, {@link TableSchema.Row.id}, or row index at which the cell is located.
@@ -2087,13 +1924,6 @@ export namespace TableSchema {
 			column: string | number | TreeNodeFromImplicitAllowedTypes<TColumn>,
 			cell: InsertableTreeNodeFromImplicitAllowedTypes<TCell>,
 		): void;
-		/**
-		 * Sets the cell at the specified location in the table.
-		 * @remarks To remove a cell, call {@link TableSchema.Table.(removeCell:1)} instead.
-		 * @deprecated Use {@link TableSchema.Table.(setCell:1)} instead.
-		 */
-		setCell(params: SetCellParameters<TCell, TColumn, TRow>): void;
-
 		/**
 		 * Removes a range of columns from the table.
 		 *
@@ -2181,15 +2011,6 @@ export namespace TableSchema {
 			row: string | number | TreeNodeFromImplicitAllowedTypes<TRow>,
 			column: string | number | TreeNodeFromImplicitAllowedTypes<TColumn>,
 		): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
-		/**
-		 * Removes the cell at the specified location in the table.
-		 * @returns The cell if it exists, otherwise undefined.
-		 * @throws Throws an error if the location does not exist in the table.
-		 * @deprecated Use {@link TableSchema.Table.(removeCell:1)} instead.
-		 */
-		removeCell(
-			key: CellKey<TColumn, TRow>,
-		): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
 	}
 
 	/**

package/src/text/codePointUtils.ts

@@ -5,6 +5,8 @@
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
+import { validateIndex } from "../util/index.js";
+
 /**
  * Returns the number of Unicode code points in `value`.
  * @remarks
@@ -17,8 +19,16 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
  * codePointCount("abc");  // 3
  * codePointCount("a😀b"); // 3 — emoji is one code point, but "a😀b".length === 4 (UTF-16 surrogate pair)
  * ```
+ * @privateRemarks
+ * Users of this are assuming the segmentation of their string exactly matches what our text utils do.
+ * If they are using this to evaluate what they will do, it might be better to just use the text APIs directly, and measure the resulting length.
+ * If measuring what they did, then measuring the length of the resulting character array would likely be better.
+ * In short: using this typically means making an assumption about how data in one of our string arrays is or will be segmented,
+ * which can't always be robust since it's possible to violate our default segmentation policy via round tripping the data and injecting irregular segments.
+ * Additionally, using this likely means you will have problems if/when handling embedded objects.
+ * Therefore we might want to reevaluate the code using this, instead of promoting it to a more stable API surface and encouraging use of it.
  *
- * @internal
+ * @alpha
  */
 export function codePointCount(value: string): number {
 	// Iterate instead of spreading to avoid allocating an intermediate array.
@@ -33,7 +43,7 @@ export function codePointCount(value: string): number {
  * Returns the number of UTF-16 code units occupied by the first `count` Unicode code points in `value`,
  * starting at UTF-16 index `start`.
  * @remarks
- * Use this to translate {@link PlainText}-space counts (code points) into JavaScript string indices (UTF-16).
+ * Use this to translate {@link PlainText} substring lengths (code points) into JavaScript string lengths (UTF-16).
  * One code point outside the Basic Multilingual Plane (e.g. most emoji) occupies two UTF-16 code units.
  *
  * Validates that the requested `count` code points are fully consumable from `start`; silent truncation
@@ -51,31 +61,32 @@ export function codePointCount(value: string): number {
  * @param start - The UTF-16 index in `value` to start measuring from. Must be in `[0, value.length]`.
  * @param count - The number of Unicode code points to measure. Must be non-negative, and there must
  * be at least `count` code points available in `value` starting at `start`.
+ * @returns The number of UTF-16 code units occupied by the requested code points.
  * @throws A {@link @fluidframework/telemetry-utils#UsageError} if `start` is out of range,
  * `count` is negative, or fewer than `count` code points are available from `start`.
- * @internal
+ *
+ * @privateRemarks
+ * See remarks on {@link codePointCount} regarding the stability of this API and its assumptions about string segmentation.
+ *
+ * @alpha
  */
 export function utf16LengthForCodePoints(value: string, start: number, count: number): number {
-	if (start < 0 || start > value.length) {
-		throw new UsageError(
-			`start (${start}) must be within [0, ${value.length}] (value.length).`,
-		);
-	}
+	validateIndex(start, value, "utf16LengthForCodePoints", true);
 	if (count < 0) {
 		throw new UsageError(`count (${count}) must be non-negative.`);
 	}
 	let utf16 = 0;
 	let counted = 0;
-	while (counted < count && start + utf16 < value.length) {
+	while (counted < count) {
+		if (start + utf16 >= value.length) {
+			throw new UsageError(
+				`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`,
+			);
+		}
 		// Code points above 0xFFFF are encoded in UTF-16 as a surrogate pair (2 units);
 		// everything else takes a single UTF-16 unit.
 		utf16 += (value.codePointAt(start + utf16) ?? 0) > 0xffff ? 2 : 1;
 		counted++;
 	}
-	if (counted !== count) {
-		throw new UsageError(
-			`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`,
-		);
-	}
 	return utf16;
 }

package/src/text/textDomain.ts

@@ -14,15 +14,17 @@ import {
 import { typeFactory as tf } from "@fluidframework/type-factory/internal";
 
 import { EmptyKey, mapCursorField, type ITreeCursorSynchronous } from "../core/index.js";
-import { TreeAlpha } from "../shared-tree/index.js";
 import {
+	createArrayInsertionAnchor,
 	eraseSchemaDetails,
 	getInnerNode,
 	SchemaFactory,
 	SchemaFactoryAlpha,
 	TreeArrayNode,
 } from "../simple-tree/index.js";
+import { TreeBeta } from "../shared-tree/index.js";
 import type {
+	ArrayPlaceAnchor,
 	ArrayNodeDeltaOp,
 	ArrayNodeTreeChangedDeltaOp,
 	TreeNode,
@@ -176,11 +178,15 @@ class TextNode
 	public onCharactersChanged(
 		callback: (ops: readonly PlainText.TextOp[] | undefined) => void,
 	): () => void {
-		return TreeAlpha.on(this.content, "nodeChanged", ({ delta }) =>
+		return TreeBeta.on(this.content, "nodeChanged", ({ delta }) =>
 			processCharactersChangedDelta(delta, (i) => this.content[i], callback),
 		);
 	}
 
+	public createInsertionAnchor(index: number): ArrayPlaceAnchor {
+		return createArrayInsertionAnchor(this.content, index);
+	}
+
 	public static fromString(value: string): TextNode {
 		// Constructing an ArrayNode from an iterator is supported, so creating an array from the iterable of characters seems like its not necessary here,
 		// but to reduce the risk of incorrect data interpretation, we actually ban this in the special case where the iterable is a string directly, which is the case here.
@@ -501,6 +507,13 @@ export namespace PlainText {
 		 * corresponds to two UTF-16 code units — convert before using the counts as string indices.
 		 */
 		onCharactersChanged(callback: (ops: readonly TextOp[] | undefined) => void): () => void;
+
+		/**
+		 * Creates an anchor that tracks an insertion point at `index` as the text is edited.
+		 * @param index - The character index of the insertion point to track.
+		 * @returns An anchor whose index updates as the text is edited. Call {@link ArrayPlaceAnchor.dispose} when it is no longer needed.
+		 */
+		createInsertionAnchor(index: number): ArrayPlaceAnchor;
 	}
 
 	/**

package/src/text/textDomainFormatted.ts

@@ -14,19 +14,20 @@ import {
 	type TreeValue,
 } from "../core/index.js";
 import { currentObserver, buildNodeComparator } from "../feature-libraries/index.js";
-import { TreeAlpha, Tree as TreeStatic } from "../shared-tree/index.js";
+import { TreeAlpha, Tree as TreeStatic, TreeBeta } from "../shared-tree/index.js";
 import {
+	createArrayInsertionAnchor,
 	getInnerNode,
 	SchemaFactory,
 	SchemaFactoryAlpha,
 	TreeArrayNode,
-	TreeBeta,
 	createCustomizedFluidFrameworkScopedFactory,
 	eraseSchemaDetails,
 	isObjectNodeSchema,
 	eraseSchemaDetailsSubclassable,
 } from "../simple-tree/index.js";
 import type {
+	ArrayPlaceAnchor,
 	TreeNodeSchema,
 	LazyItem,
 	ImplicitAllowedTypes,
@@ -390,7 +391,7 @@ export namespace FormattedText {
 			public onCharactersChanged(
 				callback: (ops: readonly PlainText.TextOp[] | undefined) => void,
 			): () => void {
-				return TreeAlpha.on(this.content, "nodeChanged", ({ delta }) =>
+				return TreeBeta.on(this.content, "nodeChanged", ({ delta }) =>
 					processCharactersChangedDelta(
 						delta,
 						(index) => this.getAtomCharacterAt(index),
@@ -399,10 +400,14 @@ export namespace FormattedText {
 				);
 			}
 
+			public createInsertionAnchor(index: number): ArrayPlaceAnchor {
+				return createArrayInsertionAnchor(this.content, index);
+			}
+
 			public onContentChanged(
 				callback: (ops: readonly PlainText.TextOp[] | undefined) => void,
 			): () => void {
-				return TreeAlpha.on(this.content, "treeChanged", ({ delta }) =>
+				return TreeBeta.on(this.content, "treeChanged", ({ delta }) =>
 					processCharactersChangedDelta(
 						delta,
 						(index) => this.getAtomCharacterAt(index),

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-	"extends": "../../../common/build/build-common/tsconfig.node16.json",
+	"extends": "../../../common/build/build-common/tsconfig.node20.json",
 	"include": ["src/**/*"],
 	"exclude": ["src/test/**/*"],
 	"compilerOptions": {

package/alpha.d.ts

@@ -1,11 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/*
- * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate node10Entrypoints" in @fluid-tools/build-cli.
- */
-
-export * from "./lib/entrypoints/alpha.js";

package/beta.d.ts

@@ -1,11 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/*
- * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate node10Entrypoints" in @fluid-tools/build-cli.
- */
-
-export * from "./lib/entrypoints/beta.js";

package/dist/simple-tree/api/treeAlpha.d.ts

@@ -1,126 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { NodeKind, TreeNode, WithType } from "../core/index.js";
-import type { TreeChangeEventsBeta } from "./treeBeta.js";
-import type { TreeChangeEvents } from "./treeChangeEvents.js";
-import type { ArrayNodeDeltaOp, ArrayNodeTreeChangedDeltaOp } from "./treeNodeApi.js";
-export type { ArrayNodeDeltaOp, ArrayNodeInsertOp, ArrayNodeRemoveOp, ArrayNodeRetainOp, ArrayNodeTreeChangedDeltaOp, ArrayNodeTreeChangedRetainOp, } from "./treeNodeApi.js";
-/**
- * Data included for {@link TreeChangeEventsAlpha.nodeChanged} when the node is an object, map, or record node.
- * @sealed @alpha
- */
-export interface NodeChangedDataProperties<TNode extends TreeNode = TreeNode> {
-    /**
-     * Lists all the properties which changed on the node.
-     * @remarks
-     * This only includes changes to the node itself (which would trigger {@link TreeChangeEvents.nodeChanged}).
-     *
-     * The set should never be empty, since `nodeChanged` will only be triggered when there is a change, and for the supported node types, the only things that can change are properties.
-     */
-    readonly changedProperties: ReadonlySet<TNode extends WithType<string, NodeKind.Object, infer TInfo> ? string & keyof TInfo : string>;
-}
-/**
- * Data carried by the {@link TreeChangeEventsAlpha.nodeChanged} event for array nodes.
- * @sealed @alpha
- */
-export interface NodeChangedDataDelta {
-    /**
-     * The sequential operations describing what changed in the array node.
-     * @remarks
-     * The value may be `undefined` when the document was updated in a way that required multiple
-     * internal change passes in a single operation (for example, a data change combined with a
-     * schema upgrade).
-     *
-     * See {@link ArrayNodeDeltaOp} for op semantics.
-     */
-    readonly delta: readonly ArrayNodeDeltaOp[] | undefined;
-}
-/**
- * Data carried by the {@link TreeChangeEventsAlpha.treeChanged} event for array nodes.
- * @remarks
- * Extends {@link NodeChangedDataDelta}: the retain ops in the delta additionally carry a
- * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} flag indicating whether any descendant
- * of the retained element changed.
- * @sealed @alpha
- */
-export interface NodeChangedDataTreeDelta {
-    /**
-     * The sequential operations describing what changed in the array node,
-     * including subtree-change information on retain ops.
-     * @remarks
-     * The value may be `undefined` when the document was updated in a way that required multiple
-     * internal change passes in a single operation (for example, a data change combined with a
-     * schema upgrade).
-     *
-     * See {@link ArrayNodeTreeChangedDeltaOp} for op semantics.
-     */
-    readonly delta: readonly ArrayNodeTreeChangedDeltaOp[] | undefined;
-}
-/**
- * The data passed to {@link TreeChangeEventsAlpha.nodeChanged} and, for array nodes,
- * to {@link TreeChangeEventsAlpha.treeChanged}.
- * @remarks
- * - For array nodes: {@link NodeChangedDataDelta} (includes a {@link NodeChangedDataDelta.delta | delta} payload).
- * - For object, map, and record nodes: {@link NodeChangedDataProperties} (includes {@link NodeChangedDataProperties.changedProperties | changedProperties}).
- * - For a generic/unknown node type: the union of both.
- * @alpha
- */
-export type NodeChangedDataAlpha<TNode extends TreeNode = TreeNode> = TNode extends WithType<string, NodeKind.Array> ? NodeChangedDataDelta : TNode extends WithType<string, NodeKind.Map | NodeKind.Object | NodeKind.Record> ? NodeChangedDataProperties<TNode> : NodeChangedDataProperties<TNode> | NodeChangedDataDelta;
-/**
- * Extension of {@link TreeChangeEvents} with a richer `nodeChanged` event and a
- * delta-carrying `treeChanged` event for array nodes.
- * @remarks
- * Provides a `nodeChanged` event that includes a delta payload for array nodes and
- * requires `changedProperties` for object, map, and record nodes.
- * Also provides a `treeChanged` event that, for array nodes, carries a {@link NodeChangedDataDelta}
- * payload describing both shallow and deep changes.
- * For non-array nodes, the `treeChanged` signature is the same as the base event.
- *
- * Use via `TreeAlpha.on`.
- * @sealed @alpha
- */
-export interface TreeChangeEventsAlpha<TNode extends TreeNode = TreeNode> extends TreeChangeEvents {
-    /**
-     * Emitted when a shallow change occurs on this node, i.e., when the node's direct children change.
-     *
-     * @remarks
-     * For array nodes: the event data includes a {@link NodeChangedDataDelta.delta | delta} payload
-     * as a sequence of {@link ArrayNodeDeltaOp} values. Does not fire for deep changes (e.g. a
-     * property of an array element changed without any shallow array change). Subscribe to
-     * {@link TreeChangeEventsAlpha.treeChanged} on the array to receive a delta for those cases as well.
-     *
-     * For object, map, and record nodes: the event data includes
-     * {@link NodeChangedDataProperties.changedProperties | changedProperties}.
-     * @privateRemarks
-     * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.
-     */
-    nodeChanged: (data: NodeChangedDataAlpha<TNode>) => void;
-    /**
-     * Emitted when something in the subtree rooted at this node changes.
-     *
-     * @remarks
-     * For array nodes: emitted when any change occurred within the array, including both
-     * shallow changes (insert, remove, move) and deep changes (e.g. a property of an element
-     * changed). The event data carries a {@link NodeChangedDataTreeDelta.delta | delta} payload
-     * describing what changed. The delta uses {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
-     * to flag elements that have deep changes, without describing the details of those deep changes.
-     * To inspect deep changes, subscribe to `nodeChanged` or `treeChanged` on the individual
-     * element nodes.
-     *
-     * When this array is nested inside another array, the outer array's `treeChanged` still
-     * fires with a delta, but that delta only shows `subtreeChanged: true` for the element
-     * position containing this inner array — it does not include the inner array's detailed
-     * insert/remove/retain ops. To receive those detailed ops, subscribe to `treeChanged`
-     * directly on the inner array.
-     * Ancestor non-array nodes still receive the base (no-payload) `treeChanged` via normal
-     * subtree propagation.
-     *
-     * For non-array nodes: same as the base {@link TreeChangeEvents.treeChanged}.
-     * @privateRemarks
-     * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.
-     */
-    treeChanged: TNode extends WithType<string, NodeKind.Array> ? (data: NodeChangedDataTreeDelta) => void : TreeChangeEventsBeta<TNode>["treeChanged"];
-}
-//# sourceMappingURL=treeAlpha.d.ts.map

package/dist/simple-tree/api/treeAlpha.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeAlpha.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/treeAlpha.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AACtF,YAAY,EACX,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,4BAA4B,GAC5B,MAAM,kBAAkB,CAAC;AAE1B;;;GAGG;AACH,MAAM,WAAW,yBAAyB,CAAC,KAAK,SAAS,QAAQ,GAAG,QAAQ;IAC3E;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,WAAW,CAEtC,KAAK,SAAS,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,KAAK,CAAC,GACzD,MAAM,GAAG,MAAM,KAAK,GACpB,MAAM,CACT,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,CAAC;CACxD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,2BAA2B,EAAE,GAAG,SAAS,CAAC;CACnE;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,QAAQ,GAAG,QAAQ,IACjE,KAAK,SAAS,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,GAC3C,oBAAoB,GACpB,KAAK,SAAS,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,GAC/E,yBAAyB,CAAC,KAAK,CAAC,GAChC,yBAAyB,CAAC,KAAK,CAAC,GAAG,oBAAoB,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB,CAAC,KAAK,SAAS,QAAQ,GAAG,QAAQ,CACvE,SAAQ,gBAAgB;IACxB;;;;;;;;;;;;;OAaG;IACH,WAAW,EAAE,CAAC,IAAI,EAAE,oBAAoB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAEzD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,WAAW,EAAE,KAAK,SAAS,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,GACxD,CAAC,IAAI,EAAE,wBAAwB,KAAK,IAAI,GACxC,oBAAoB,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,CAAC;CAC9C"}

package/dist/simple-tree/api/treeAlpha.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeAlpha.js","sourceRoot":"","sources":["../../../src/simple-tree/api/treeAlpha.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { NodeKind, TreeNode, WithType } from \"../core/index.js\";\n\nimport type { TreeChangeEventsBeta } from \"./treeBeta.js\";\nimport type { TreeChangeEvents } from \"./treeChangeEvents.js\";\nimport type { ArrayNodeDeltaOp, ArrayNodeTreeChangedDeltaOp } from \"./treeNodeApi.js\";\nexport type {\n\tArrayNodeDeltaOp,\n\tArrayNodeInsertOp,\n\tArrayNodeRemoveOp,\n\tArrayNodeRetainOp,\n\tArrayNodeTreeChangedDeltaOp,\n\tArrayNodeTreeChangedRetainOp,\n} from \"./treeNodeApi.js\";\n\n/**\n * Data included for {@link TreeChangeEventsAlpha.nodeChanged} when the node is an object, map, or record node.\n * @sealed @alpha\n */\nexport interface NodeChangedDataProperties<TNode extends TreeNode = TreeNode> {\n\t/**\n\t * Lists all the properties which changed on the node.\n\t * @remarks\n\t * This only includes changes to the node itself (which would trigger {@link TreeChangeEvents.nodeChanged}).\n\t *\n\t * The set should never be empty, since `nodeChanged` will only be triggered when there is a change, and for the supported node types, the only things that can change are properties.\n\t */\n\treadonly changedProperties: ReadonlySet<\n\t\t// For Object nodes, strongly type with the property names from the schema:\n\t\tTNode extends WithType<string, NodeKind.Object, infer TInfo>\n\t\t\t? string & keyof TInfo\n\t\t\t: string\n\t>;\n}\n\n/**\n * Data carried by the {@link TreeChangeEventsAlpha.nodeChanged} event for array nodes.\n * @sealed @alpha\n */\nexport interface NodeChangedDataDelta {\n\t/**\n\t * The sequential operations describing what changed in the array node.\n\t * @remarks\n\t * The value may be `undefined` when the document was updated in a way that required multiple\n\t * internal change passes in a single operation (for example, a data change combined with a\n\t * schema upgrade).\n\t *\n\t * See {@link ArrayNodeDeltaOp} for op semantics.\n\t */\n\treadonly delta: readonly ArrayNodeDeltaOp[] | undefined;\n}\n\n/**\n * Data carried by the {@link TreeChangeEventsAlpha.treeChanged} event for array nodes.\n * @remarks\n * Extends {@link NodeChangedDataDelta}: the retain ops in the delta additionally carry a\n * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} flag indicating whether any descendant\n * of the retained element changed.\n * @sealed @alpha\n */\nexport interface NodeChangedDataTreeDelta {\n\t/**\n\t * The sequential operations describing what changed in the array node,\n\t * including subtree-change information on retain ops.\n\t * @remarks\n\t * The value may be `undefined` when the document was updated in a way that required multiple\n\t * internal change passes in a single operation (for example, a data change combined with a\n\t * schema upgrade).\n\t *\n\t * See {@link ArrayNodeTreeChangedDeltaOp} for op semantics.\n\t */\n\treadonly delta: readonly ArrayNodeTreeChangedDeltaOp[] | undefined;\n}\n\n/**\n * The data passed to {@link TreeChangeEventsAlpha.nodeChanged} and, for array nodes,\n * to {@link TreeChangeEventsAlpha.treeChanged}.\n * @remarks\n * - For array nodes: {@link NodeChangedDataDelta} (includes a {@link NodeChangedDataDelta.delta | delta} payload).\n * - For object, map, and record nodes: {@link NodeChangedDataProperties} (includes {@link NodeChangedDataProperties.changedProperties | changedProperties}).\n * - For a generic/unknown node type: the union of both.\n * @alpha\n */\nexport type NodeChangedDataAlpha<TNode extends TreeNode = TreeNode> =\n\tTNode extends WithType<string, NodeKind.Array>\n\t\t? NodeChangedDataDelta\n\t\t: TNode extends WithType<string, NodeKind.Map | NodeKind.Object | NodeKind.Record>\n\t\t\t? NodeChangedDataProperties<TNode>\n\t\t\t: NodeChangedDataProperties<TNode> | NodeChangedDataDelta;\n\n/**\n * Extension of {@link TreeChangeEvents} with a richer `nodeChanged` event and a\n * delta-carrying `treeChanged` event for array nodes.\n * @remarks\n * Provides a `nodeChanged` event that includes a delta payload for array nodes and\n * requires `changedProperties` for object, map, and record nodes.\n * Also provides a `treeChanged` event that, for array nodes, carries a {@link NodeChangedDataDelta}\n * payload describing both shallow and deep changes.\n * For non-array nodes, the `treeChanged` signature is the same as the base event.\n *\n * Use via `TreeAlpha.on`.\n * @sealed @alpha\n */\nexport interface TreeChangeEventsAlpha<TNode extends TreeNode = TreeNode>\n\textends TreeChangeEvents {\n\t/**\n\t * Emitted when a shallow change occurs on this node, i.e., when the node's direct children change.\n\t *\n\t * @remarks\n\t * For array nodes: the event data includes a {@link NodeChangedDataDelta.delta | delta} payload\n\t * as a sequence of {@link ArrayNodeDeltaOp} values. Does not fire for deep changes (e.g. a\n\t * property of an array element changed without any shallow array change). Subscribe to\n\t * {@link TreeChangeEventsAlpha.treeChanged} on the array to receive a delta for those cases as well.\n\t *\n\t * For object, map, and record nodes: the event data includes\n\t * {@link NodeChangedDataProperties.changedProperties | changedProperties}.\n\t * @privateRemarks\n\t * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.\n\t */\n\tnodeChanged: (data: NodeChangedDataAlpha<TNode>) => void;\n\n\t/**\n\t * Emitted when something in the subtree rooted at this node changes.\n\t *\n\t * @remarks\n\t * For array nodes: emitted when any change occurred within the array, including both\n\t * shallow changes (insert, remove, move) and deep changes (e.g. a property of an element\n\t * changed). The event data carries a {@link NodeChangedDataTreeDelta.delta | delta} payload\n\t * describing what changed. The delta uses {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}\n\t * to flag elements that have deep changes, without describing the details of those deep changes.\n\t * To inspect deep changes, subscribe to `nodeChanged` or `treeChanged` on the individual\n\t * element nodes.\n\t *\n\t * When this array is nested inside another array, the outer array's `treeChanged` still\n\t * fires with a delta, but that delta only shows `subtreeChanged: true` for the element\n\t * position containing this inner array — it does not include the inner array's detailed\n\t * insert/remove/retain ops. To receive those detailed ops, subscribe to `treeChanged`\n\t * directly on the inner array.\n\t * Ancestor non-array nodes still receive the base (no-payload) `treeChanged` via normal\n\t * subtree propagation.\n\t *\n\t * For non-array nodes: same as the base {@link TreeChangeEvents.treeChanged}.\n\t * @privateRemarks\n\t * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.\n\t */\n\ttreeChanged: TNode extends WithType<string, NodeKind.Array>\n\t\t? (data: NodeChangedDataTreeDelta) => void\n\t\t: TreeChangeEventsBeta<TNode>[\"treeChanged\"];\n}\n"]}

package/dist/simple-tree/api/treeBeta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeBeta.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/treeBeta.ts"],"names":[],"mappings":"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"}