@fluidframework/tree 2.61.0-356132 → 2.61.0-356312

package/src/index.ts

@@ -145,6 +145,9 @@ export {
 	type IdentifierIndex,
 	createSimpleTreeIndex,
 	createIdentifierIndex,
+	type DirtyTreeStatus,
+	trackDirtyNodes,
+	type DirtyTreeMap,
 	// experimental @alpha APIs:
 	adaptEnum,
 	enumFromStrings,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.61.0-356132";
+export const pkgVersion = "2.61.0-356312";

package/src/shared-tree/treeAlpha.ts

@@ -17,7 +17,7 @@ import type { IIdCompressor } from "@fluidframework/id-compressor";
 import {
 	asIndex,
 	getKernel,
-	TreeNode,
+	type TreeNode,
 	type Unhydrated,
 	TreeBeta,
 	tryGetSchema,
@@ -55,7 +55,6 @@ import {
 	convertField,
 	toUnhydratedSchema,
 	type TreeParsingOptions,
-	type NodeChangedData,
 } from "../simple-tree/index.js";
 import { brand, extractFromOpaque, type JsonCompatible } from "../util/index.js";
 import {
@@ -64,7 +63,7 @@ import {
 	type ICodecOptions,
 	type CodecWriteOptions,
 } from "../codec/index.js";
-import { EmptyKey, type FieldKey, type ITreeCursorSynchronous } from "../core/index.js";
+import { EmptyKey, type ITreeCursorSynchronous } from "../core/index.js";
 import {
 	cursorForMapTreeField,
 	defaultSchemaPolicy,
@@ -77,9 +76,6 @@ import {
 	fluidVersionToFieldBatchCodecWriteVersion,
 	type LocalNodeIdentifier,
 	type FlexTreeSequenceField,
-	type FlexTreeNode,
-	type Observer,
-	withObservation,
 } from "../feature-libraries/index.js";
 import { independentInitializedView, type ViewContent } from "./independentView.js";
 import { SchematizingSimpleTreeView, ViewSlot } from "./schematizingTreeView.js";
@@ -423,189 +419,6 @@ export interface TreeAlpha {
 	children(
 		node: TreeNode,
 	): Iterable<[propertyKey: string | number, child: TreeNode | TreeLeafValue]>;
-
-	/**
-	 * Track observations of any TreeNode content.
-	 * @remarks
-	 * This subscribes to changes to any nodes content observed during `trackDuring`.
-	 *
-	 * Currently this does not support tracking parentage (see {@link (TreeAlpha:interface).trackObservationsOnce} for a version which does):
-	 * if accessing parentage during `trackDuring`, this will throw a usage error.
-	 *
-	 * This also does not track node status changes (e.g. whether a node is attached to a view or not).
-	 * The current behavior of checking status is unspecified: future versions may track it, error, or ignore it.
-	 *
-	 * Even after onInvalidation is called, these subscriptions remain active until `unsubscribe` is called.
-	 * See {@link (TreeAlpha:interface).trackObservationsOnce} for a version which automatically unsubscribes on the first invalidation.
-	 */
-	trackObservations<TResult>(
-		onInvalidation: () => void,
-		trackDuring: () => TResult,
-	): { result: TResult; unsubscribe: () => void };
-
-	/**
-	 * {@link (TreeAlpha:interface).trackObservations} except automatically unsubscribes when the first invalidation occurs.
-	 * @remarks
-	 * This also supports tracking parentage, unlike {@link (TreeAlpha:interface).trackObservations}, as long as the parent is not undefined.
-	 */
-	trackObservationsOnce<TResult>(
-		onInvalidation: () => void,
-		trackDuring: () => TResult,
-	): { result: TResult; unsubscribe: () => void };
-}
-
-/**
- * Subscription to changes on a single node.
- * @remarks
- * Either tracks some set of fields, or all fields and can be updated to track more fields.
- */
-class NodeSubscription {
-	/**
-	 * If undefined, subscribes to all keys.
-	 * Otherwise only subscribes to the keys in the set.
-	 */
-	private keys: Set<FieldKey> | undefined;
-	private readonly unsubscribe: () => void;
-	private constructor(
-		private readonly onInvalidation: () => void,
-		flexNode: FlexTreeNode,
-	) {
-		// TODO:Performance: It is possible to optimize this to not use the public TreeNode API.
-		const node = getOrCreateNodeFromInnerNode(flexNode);
-		assert(node instanceof TreeNode, "Unexpected leaf value");
-
-		const handler = (data: NodeChangedData): void => {
-			if (this.keys === undefined || data.changedProperties === undefined) {
-				this.onInvalidation();
-			} else {
-				let keyMap: ReadonlyMap<FieldKey, string> | undefined;
-				const schema = treeNodeApi.schema(node);
-				if (isObjectNodeSchema(schema)) {
-					keyMap = schema.storedKeyToPropertyKey;
-				}
-				// TODO:Performance: Ideally this would use Set.prototype.isDisjointFrom when available.
-				for (const flexKey of this.keys) {
-					// TODO:Performance: doing everything at the flex tree layer could avoid this translation
-					const key = keyMap?.get(flexKey) ?? flexKey;
-
-					if (data.changedProperties.has(key)) {
-						this.onInvalidation();
-						return;
-					}
-				}
-			}
-		};
-		this.unsubscribe = TreeBeta.on(node, "nodeChanged", handler);
-	}
-
-	/**
-	 * Create an {@link Observer} which subscribes to what was observed in {@link NodeSubscription}s.
-	 */
-	public static createObserver(
-		invalidate: () => void,
-		onlyOnce = false,
-	): { observer: Observer; unsubscribe: () => void } {
-		const subscriptions = new Map<FlexTreeNode, NodeSubscription>();
-		const observer: Observer = {
-			observeNodeFields(flexNode: FlexTreeNode): void {
-				if (flexNode.value !== undefined) {
-					// Leaf value, nothing to observe.
-					return;
-				}
-				const subscription = subscriptions.get(flexNode);
-				if (subscription !== undefined) {
-					// Already subscribed to this node.
-					subscription.keys = undefined; // Now subscribed to all keys.
-				} else {
-					const newSubscription = new NodeSubscription(invalidate, flexNode);
-					subscriptions.set(flexNode, newSubscription);
-				}
-			},
-			observeNodeField(flexNode: FlexTreeNode, key: FieldKey): void {
-				if (flexNode.value !== undefined) {
-					// Leaf value, nothing to observe.
-					return;
-				}
-				const subscription = subscriptions.get(flexNode);
-				if (subscription !== undefined) {
-					// Already subscribed to this node: if not subscribed to all keys, subscribe to this one.
-					// TODO:Performance: due to how JavaScript set ordering works,
-					// it might be faster to check `has` and only add if not present in case the same field is viewed many times.
-					subscription.keys?.add(key);
-				} else {
-					const newSubscription = new NodeSubscription(invalidate, flexNode);
-					newSubscription.keys = new Set([key]);
-					subscriptions.set(flexNode, newSubscription);
-				}
-			},
-			observeParentOf(node: FlexTreeNode): void {
-				// Supporting parent tracking is more difficult that it might seem at first.
-				// There are two main complicating factors:
-				// 1. The parent may be undefined (the node is a root).
-				// 2. If tracking this by subscribing to the parent's changes, then which events are subscribed to needs to be updated after the parent changes.
-				//
-				// If not supporting the first case (undefined parents), the second case gets problematic since it would result in edits which take a node who's parent was observed,
-				// and un-parent it, could then throw a usage error.
-
-				if (!onlyOnce) {
-					// TODO: better APIS should be provided which make handling this case practical.
-					throw new UsageError("Observation tracking for parents is currently not supported.");
-				}
-
-				const parent = withObservation(undefined, () => node.parentField.parent);
-
-				if (parent.parent === undefined) {
-					// TODO: better APIS should be provided which make handling this case practical.
-					throw new UsageError(
-						"Observation tracking for parents is currently not supported when parent is undefined.",
-					);
-				}
-				observer.observeNodeField(parent.parent, parent.key);
-			},
-		};
-
-		let subscribed = true;
-
-		return {
-			observer,
-			unsubscribe: () => {
-				if (!subscribed) {
-					throw new UsageError("Already unsubscribed");
-				}
-				subscribed = false;
-				for (const subscription of subscriptions.values()) {
-					subscription.unsubscribe();
-				}
-			},
-		};
-	}
-}
-
-/**
- * Handles both {@link (TreeAlpha:interface).trackObservations} and {@link (TreeAlpha:interface).trackObservationsOnce}.
- */
-function trackObservations<TResult>(
-	onInvalidation: () => void,
-	trackDuring: () => TResult,
-	onlyOnce = false,
-): { result: TResult; unsubscribe: () => void } {
-	let observing = true;
-
-	const invalidate = (): void => {
-		if (observing) {
-			throw new UsageError("Cannot invalidate while tracking observations");
-		}
-		onInvalidation();
-	};
-
-	const { observer, unsubscribe } = NodeSubscription.createObserver(invalidate, onlyOnce);
-	const result = withObservation(observer, trackDuring);
-	observing = false;
-
-	return {
-		result,
-		unsubscribe,
-	};
 }
 
 /**
@@ -614,30 +427,6 @@ function trackObservations<TResult>(
  * @alpha
  */
 export const TreeAlpha: TreeAlpha = {
-	trackObservations<TResult>(
-		onInvalidation: () => void,
-		trackDuring: () => TResult,
-	): { result: TResult; unsubscribe: () => void } {
-		return trackObservations(onInvalidation, trackDuring);
-	},
-
-	trackObservationsOnce<TResult>(
-		onInvalidation: () => void,
-		trackDuring: () => TResult,
-	): { result: TResult; unsubscribe: () => void } {
-		const result = trackObservations(
-			() => {
-				// trackObservations ensures no invalidation occurs while its running,
-				// so this callback can only run after trackObservations has returns and thus result is defined.
-				result.unsubscribe();
-				onInvalidation();
-			},
-			trackDuring,
-			true,
-		);
-		return result;
-	},
-
 	branch(node: TreeNode): TreeBranch | undefined {
 		const kernel = getKernel(node);
 		if (!kernel.isHydrated()) {

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

@@ -0,0 +1,155 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils/internal";
+import {
+	createAnnouncedVisitor,
+	CursorLocationType,
+	type AnnouncedVisitor,
+	type FieldKey,
+	type IEditableForest,
+	type UpPath,
+} from "../../core/index.js";
+import { TreeNode, treeNodeFromAnchor } from "../core/index.js";
+import type { TreeViewAlpha } from "./tree.js";
+import type { SchematizingSimpleTreeView } from "../../shared-tree/index.js";
+import type { ImplicitFieldSchema } from "../fieldSchema.js";
+
+/**
+ * The status of a node in a that has been {@link trackDirtyNodes | tracked for changes}.
+ * @remarks Nodes can be marked "new", "changed", or "moved", with "new" taking precedence over "changed" and "changed" taking precedence over "moved".
+ * * "new": The node was added.
+ * * "changed": A direct child was updated, added, removed, or moved (and the node is not "new").
+ * * "moved": The node was moved between/within arrays (and the node is not "new" or "changed").
+ * @alpha
+ */
+export type DirtyTreeStatus = "new" | "changed" | "moved";
+
+/**
+ * A map-like interface for tracking the {@link DirtyTreeStatus | status} of nodes that have been {@link trackDirtyNodes | tracked for changes}.
+ * @privateRemarks TODO: Replace this with `MapGetSet` from `@fluidframework/core-interfaces`.
+ * @alpha
+ */
+export interface DirtyTreeMap {
+	get(node: TreeNode): DirtyTreeStatus | undefined;
+	set(node: TreeNode, status: DirtyTreeStatus): void;
+}
+
+/**
+ * Registers a visitor on the view's forest that tracks which nodes are dirty.
+ * @param view - The view to track dirty nodes on
+ * @param dirty - A {@link DirtyTreeMap | map} that will be updated over time to reflect the {@link DirtyTreeStatus | status} of nodes as they change.
+ * Nodes that have not changed will not be inserted/updated in the map.
+ * @returns a cleanup function that should be called when the tracking is no longer needed.
+ * @example
+ * ```typescript
+ * const dirty = new Map<TreeNode, DirtyTreeStatus>();
+ * const stopTracking = trackDirtyNodes(view, dirty);
+ * // ... make changes to the view ...
+ * console.log(`The root of the tree is ${dirty.get(view.root) ?? "unchanged"}`);
+ * stopTracking();
+ * ```
+ * @alpha
+ */
+export function trackDirtyNodes(
+	view: TreeViewAlpha<ImplicitFieldSchema>,
+	dirty: DirtyTreeMap,
+): () => void {
+	const forest = (view as SchematizingSimpleTreeView<ImplicitFieldSchema>).checkout.forest;
+	const announcedVisitor = (): AnnouncedVisitor => createDirtyVisitor(forest, dirty);
+	forest.registerAnnouncedVisitor(announcedVisitor);
+	return () => {
+		forest.deregisterAnnouncedVisitor(announcedVisitor);
+	};
+}
+
+function createDirtyVisitor(forest: IEditableForest, dirty: DirtyTreeMap): AnnouncedVisitor {
+	// When cursor is in Fields mode, `parentField` is the field and `parent` is the parent node above that field (if any).
+	// When cursor is in Nodes mode, `parent` is the current node and `parentField` is undefined.
+	let parentField: FieldKey | undefined;
+	let parent: UpPath | undefined;
+
+	return createAnnouncedVisitor({
+		beforeDetach: (src) => {
+			assert(parent !== undefined, "Expected node");
+			assert(parentField !== undefined, "Expected field");
+			for (let parentIndex = src.start; parentIndex < src.end; parentIndex++) {
+				const path: UpPath = {
+					parent,
+					parentField,
+					parentIndex,
+				};
+				// The only way a detached node can be re-attached (and become visible/usable again) is via a move, so mark it as moved ahead of time.
+				const node = getNodeAtPath(forest, path);
+				if (node !== undefined && dirty.get(node) === undefined) {
+					// Only mark the node as moved if it is not already marked as something else.
+					dirty.set(node, "moved");
+				}
+				// Mark the parent as changed unless it is already marked as new.
+				const parentNode = getNodeAtPath(forest, parent);
+				if (parentNode !== undefined && dirty.get(parentNode) !== "new") {
+					dirty.set(parentNode, "changed");
+				}
+			}
+		},
+		afterAttach: (_, dst) => {
+			assert(parent !== undefined, "Expected node");
+			assert(parentField !== undefined, "Expected field");
+			for (let parentIndex = dst.start; parentIndex < dst.end; parentIndex++) {
+				const path: UpPath = {
+					parent,
+					parentField,
+					parentIndex,
+				};
+				const node = getNodeAtPath(forest, path);
+				if (node !== undefined && dirty.get(node) === undefined) {
+					// Only mark the node as new if it is not already marked as something else - this ensures that a moved node is not marked as new (since nodes are marked move when detached).
+					dirty.set(node, "new");
+				}
+				// Mark the parent as changed unless it is already marked as new.
+				const parentNode = getNodeAtPath(forest, parent);
+				if (parentNode !== undefined && dirty.get(parentNode) !== "new") {
+					dirty.set(parentNode, "changed");
+				}
+			}
+		},
+		enterNode(index: number): void {
+			assert(parentField !== undefined, "Expected field");
+			parent = {
+				parent,
+				parentField,
+				parentIndex: index,
+			};
+			parentField = undefined;
+		},
+		exitNode(): void {
+			assert(parent !== undefined, "Expected node");
+			parentField = parent.parentField;
+			parent = parent.parent;
+		},
+		enterField: (key: FieldKey) => {
+			parentField = key;
+		},
+		exitField(): void {
+			parentField = undefined;
+		},
+	});
+}
+
+function getNodeAtPath(forest: IEditableForest, path: UpPath): TreeNode | undefined {
+	const cursor = forest.allocateCursor();
+	forest.moveCursorToPath(path, cursor);
+	assert(cursor.mode === CursorLocationType.Nodes, 0xa9c /* attach should happen in a node */);
+	const anchor = cursor.buildAnchor();
+	const anchorNode = forest.anchors.locate(anchor);
+	cursor.free();
+	if (anchorNode !== undefined) {
+		const node = treeNodeFromAnchor(anchorNode);
+		if (node instanceof TreeNode) {
+			return node;
+		}
+	}
+	return undefined;
+}

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

@@ -56,6 +56,11 @@ export {
 	tryGetSchema,
 } from "./treeNodeApi.js";
 export { createFromCursor } from "./create.js";
+export {
+	type DirtyTreeStatus,
+	trackDirtyNodes,
+	type DirtyTreeMap,
+} from "./dirtyIndex.js";
 export {
 	type JsonSchemaId,
 	type JsonSchemaType,

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

@@ -257,11 +257,12 @@ export interface TreeBranch extends IDisposable {
 /**
  * An editable view of a (version control style) branch of a shared tree based on some schema.
  *
- * This schema--known as the view schema--may or may not align the stored schema of the document.
+ * @remarks
+ * This schema (known as the view schema) may or may not align with the stored schema of the document.
  * Information about discrepancies between the two schemas is available via {@link TreeView.compatibility | compatibility}.
  *
- * Application authors are encouraged to read [schema-evolution.md](../../docs/user-facing/schema-evolution.md) and
- * choose a schema compatibility policy that aligns with their application's needs.
+ * Application authors are encouraged to read {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/docs/user-facing/schema-evolution.md | schema-evolution.md}
+ * and choose a schema compatibility policy that aligns with their application's needs.
  *
  * @privateRemarks
  * From an API design perspective, `upgradeSchema` could be merged into `viewWith` and/or `viewWith` could return errors explicitly on incompatible documents.

package/src/simple-tree/core/unhydratedFlexTree.ts

@@ -50,7 +50,6 @@ import {
 	type HydratedFlexTreeNode,
 	cursorForMapTreeField,
 	type MinimalFieldMap,
-	currentObserver,
 } from "../../feature-libraries/index.js";
 import { brand, filterIterable, getOrCreate, mapIterable } from "../../util/index.js";
 
@@ -145,10 +144,8 @@ export class UnhydratedFlexTreeNode
 	 */
 	public readonly fields: MinimalFieldMap<UnhydratedFlexTreeField> = {
 		get: (key: FieldKey): UnhydratedFlexTreeField | undefined => this.tryGetField(key),
-		[Symbol.iterator]: (): IterableIterator<[FieldKey, UnhydratedFlexTreeField]> => {
-			currentObserver?.observeNodeFields(this);
-			return filterIterable(this.fieldsAll, ([, field]) => field.length > 0);
-		},
+		[Symbol.iterator]: (): IterableIterator<[FieldKey, UnhydratedFlexTreeField]> =>
+			filterIterable(this.fieldsAll, ([, field]) => field.length > 0),
 	};
 
 	public [Symbol.iterator](): IterableIterator<UnhydratedFlexTreeField> {
@@ -221,7 +218,6 @@ export class UnhydratedFlexTreeNode
 	 * @remarks If this node is unparented, this method will return the special {@link unparentedLocation} as the parent.
 	 */
 	public get parentField(): LocationInField {
-		currentObserver?.observeParentOf(this);
 		return this.location;
 	}
 
@@ -230,8 +226,6 @@ export class UnhydratedFlexTreeNode
 	}
 
 	public tryGetField(key: FieldKey): UnhydratedFlexTreeField | undefined {
-		currentObserver?.observeNodeField(this, key);
-
 		const field = this.fieldsAll.get(key);
 		// Only return the field if it is not empty, in order to fulfill the contract of `tryGetField`.
 		if (field !== undefined && field.length > 0) {
@@ -241,9 +235,6 @@ export class UnhydratedFlexTreeNode
 
 	public getBoxed(key: string): UnhydratedFlexTreeField {
 		const fieldKey: FieldKey = brand(key);
-
-		currentObserver?.observeNodeField(this, fieldKey);
-
 		return this.getOrCreateField(fieldKey);
 	}
 

package/src/simple-tree/index.ts

@@ -89,6 +89,9 @@ export {
 	type IdentifierIndex,
 	createSimpleTreeIndex,
 	createIdentifierIndex,
+	type DirtyTreeStatus,
+	trackDirtyNodes,
+	type DirtyTreeMap,
 	type JsonSchemaId,
 	type JsonSchemaType,
 	type JsonObjectNodeSchema,

package/dist/feature-libraries/flex-tree/observer.d.ts

@@ -1,27 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { FlexTreeNode } from "./flexTreeTypes.js";
-import type { FieldKey } from "../../core/index.js";
-/**
- * An object informed about observation made to trees.
- * @remarks
- * See {@link withObservation} and {@link currentObserver}.
- */
-export interface Observer {
-    observeNodeFields(node: FlexTreeNode): void;
-    observeNodeField(node: FlexTreeNode, key: FieldKey): void;
-    observeParentOf(node: FlexTreeNode): void;
-}
-/**
- * The current observer, if any.
- * @remarks
- * Set via {@link setObserver} as used by {@link withObservation}.
- */
-export declare let currentObserver: Observer | undefined;
-/**
- * For the duration of `f`, pushes `newObserver` onto the observer stack, making it the {@link currentObserver}.
- */
-export declare function withObservation<T>(newObserver: Observer | undefined, f: () => T): T;
-//# sourceMappingURL=observer.d.ts.map

package/dist/feature-libraries/flex-tree/observer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observer.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/observer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AASpD;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACxB,iBAAiB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5C,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1D,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;CAC1C;AACD;;;;GAIG;AACH,eAAO,IAAI,eAAe,EAAE,QAAQ,GAAG,SAAS,CAAC;AAgBjD;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAOnF"}

package/dist/feature-libraries/flex-tree/observer.js

@@ -1,33 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withObservation = exports.currentObserver = void 0;
-const internal_1 = require("@fluidframework/core-utils/internal");
-const observerStack = [];
-function setObserver(newObserver) {
-    observerStack.push(newObserver);
-    exports.currentObserver = newObserver;
-}
-function clearObserver() {
-    (0, internal_1.debugAssert)(() => observerStack.length > 0 || "Empty Observer stack on clear");
-    const popped = observerStack.pop();
-    (0, internal_1.debugAssert)(() => popped === exports.currentObserver || "Mismatched observer stack");
-    exports.currentObserver = observerStack[observerStack.length - 1];
-}
-/**
- * For the duration of `f`, pushes `newObserver` onto the observer stack, making it the {@link currentObserver}.
- */
-function withObservation(newObserver, f) {
-    setObserver(newObserver);
-    try {
-        return f();
-    }
-    finally {
-        clearObserver();
-    }
-}
-exports.withObservation = withObservation;
-//# sourceMappingURL=observer.js.map

package/dist/feature-libraries/flex-tree/observer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"observer.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/observer.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAAkE;AA4BlE,MAAM,aAAa,GAA6B,EAAE,CAAC;AAEnD,SAAS,WAAW,CAAC,WAAiC;IACrD,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAChC,uBAAe,GAAG,WAAW,CAAC;AAC/B,CAAC;AAED,SAAS,aAAa;IACrB,IAAA,sBAAW,EAAC,GAAG,EAAE,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,+BAA+B,CAAC,CAAC;IAC/E,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;IACnC,IAAA,sBAAW,EAAC,GAAG,EAAE,CAAC,MAAM,KAAK,uBAAe,IAAI,2BAA2B,CAAC,CAAC;IAC7E,uBAAe,GAAG,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAAI,WAAiC,EAAE,CAAU;IAC/E,WAAW,CAAC,WAAW,CAAC,CAAC;IACzB,IAAI,CAAC;QACJ,OAAO,CAAC,EAAE,CAAC;IACZ,CAAC;YAAS,CAAC;QACV,aAAa,EAAE,CAAC;IACjB,CAAC;AACF,CAAC;AAPD,0CAOC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { debugAssert } from \"@fluidframework/core-utils/internal\";\nimport type { FlexTreeNode } from \"./flexTreeTypes.js\";\nimport type { FieldKey } from \"../../core/index.js\";\n\n/*\n * This file sets up a static observation tracking system.\n *\n * This library used to contain a more general variant of this which was deleted in https://github.com/microsoft/FluidFramework/pull/18659.\n * This pattern somewhat resembles the approach in https://github.com/tc39/proposal-signals.\n */\n\n/**\n * An object informed about observation made to trees.\n * @remarks\n * See {@link withObservation} and {@link currentObserver}.\n */\nexport interface Observer {\n\tobserveNodeFields(node: FlexTreeNode): void;\n\tobserveNodeField(node: FlexTreeNode, key: FieldKey): void;\n\tobserveParentOf(node: FlexTreeNode): void;\n}\n/**\n * The current observer, if any.\n * @remarks\n * Set via {@link setObserver} as used by {@link withObservation}.\n */\nexport let currentObserver: Observer | undefined;\n\nconst observerStack: (Observer | undefined)[] = [];\n\nfunction setObserver(newObserver: Observer | undefined): void {\n\tobserverStack.push(newObserver);\n\tcurrentObserver = newObserver;\n}\n\nfunction clearObserver(): void {\n\tdebugAssert(() => observerStack.length > 0 || \"Empty Observer stack on clear\");\n\tconst popped = observerStack.pop();\n\tdebugAssert(() => popped === currentObserver || \"Mismatched observer stack\");\n\tcurrentObserver = observerStack[observerStack.length - 1];\n}\n\n/**\n * For the duration of `f`, pushes `newObserver` onto the observer stack, making it the {@link currentObserver}.\n */\nexport function withObservation<T>(newObserver: Observer | undefined, f: () => T): T {\n\tsetObserver(newObserver);\n\ttry {\n\t\treturn f();\n\t} finally {\n\t\tclearObserver();\n\t}\n}\n"]}

package/lib/feature-libraries/flex-tree/observer.d.ts

@@ -1,27 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { FlexTreeNode } from "./flexTreeTypes.js";
-import type { FieldKey } from "../../core/index.js";
-/**
- * An object informed about observation made to trees.
- * @remarks
- * See {@link withObservation} and {@link currentObserver}.
- */
-export interface Observer {
-    observeNodeFields(node: FlexTreeNode): void;
-    observeNodeField(node: FlexTreeNode, key: FieldKey): void;
-    observeParentOf(node: FlexTreeNode): void;
-}
-/**
- * The current observer, if any.
- * @remarks
- * Set via {@link setObserver} as used by {@link withObservation}.
- */
-export declare let currentObserver: Observer | undefined;
-/**
- * For the duration of `f`, pushes `newObserver` onto the observer stack, making it the {@link currentObserver}.
- */
-export declare function withObservation<T>(newObserver: Observer | undefined, f: () => T): T;
-//# sourceMappingURL=observer.d.ts.map

package/lib/feature-libraries/flex-tree/observer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observer.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/observer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AASpD;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACxB,iBAAiB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5C,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1D,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;CAC1C;AACD;;;;GAIG;AACH,eAAO,IAAI,eAAe,EAAE,QAAQ,GAAG,SAAS,CAAC;AAgBjD;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAOnF"}

package/lib/feature-libraries/flex-tree/observer.js

@@ -1,35 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { debugAssert } from "@fluidframework/core-utils/internal";
-/**
- * The current observer, if any.
- * @remarks
- * Set via {@link setObserver} as used by {@link withObservation}.
- */
-export let currentObserver;
-const observerStack = [];
-function setObserver(newObserver) {
-    observerStack.push(newObserver);
-    currentObserver = newObserver;
-}
-function clearObserver() {
-    debugAssert(() => observerStack.length > 0 || "Empty Observer stack on clear");
-    const popped = observerStack.pop();
-    debugAssert(() => popped === currentObserver || "Mismatched observer stack");
-    currentObserver = observerStack[observerStack.length - 1];
-}
-/**
- * For the duration of `f`, pushes `newObserver` onto the observer stack, making it the {@link currentObserver}.
- */
-export function withObservation(newObserver, f) {
-    setObserver(newObserver);
-    try {
-        return f();
-    }
-    finally {
-        clearObserver();
-    }
-}
-//# sourceMappingURL=observer.js.map

package/lib/feature-libraries/flex-tree/observer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"observer.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/observer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAqBlE;;;;GAIG;AACH,MAAM,CAAC,IAAI,eAAqC,CAAC;AAEjD,MAAM,aAAa,GAA6B,EAAE,CAAC;AAEnD,SAAS,WAAW,CAAC,WAAiC;IACrD,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAChC,eAAe,GAAG,WAAW,CAAC;AAC/B,CAAC;AAED,SAAS,aAAa;IACrB,WAAW,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,+BAA+B,CAAC,CAAC;IAC/E,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;IACnC,WAAW,CAAC,GAAG,EAAE,CAAC,MAAM,KAAK,eAAe,IAAI,2BAA2B,CAAC,CAAC;IAC7E,eAAe,GAAG,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAI,WAAiC,EAAE,CAAU;IAC/E,WAAW,CAAC,WAAW,CAAC,CAAC;IACzB,IAAI,CAAC;QACJ,OAAO,CAAC,EAAE,CAAC;IACZ,CAAC;YAAS,CAAC;QACV,aAAa,EAAE,CAAC;IACjB,CAAC;AACF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { debugAssert } from \"@fluidframework/core-utils/internal\";\nimport type { FlexTreeNode } from \"./flexTreeTypes.js\";\nimport type { FieldKey } from \"../../core/index.js\";\n\n/*\n * This file sets up a static observation tracking system.\n *\n * This library used to contain a more general variant of this which was deleted in https://github.com/microsoft/FluidFramework/pull/18659.\n * This pattern somewhat resembles the approach in https://github.com/tc39/proposal-signals.\n */\n\n/**\n * An object informed about observation made to trees.\n * @remarks\n * See {@link withObservation} and {@link currentObserver}.\n */\nexport interface Observer {\n\tobserveNodeFields(node: FlexTreeNode): void;\n\tobserveNodeField(node: FlexTreeNode, key: FieldKey): void;\n\tobserveParentOf(node: FlexTreeNode): void;\n}\n/**\n * The current observer, if any.\n * @remarks\n * Set via {@link setObserver} as used by {@link withObservation}.\n */\nexport let currentObserver: Observer | undefined;\n\nconst observerStack: (Observer | undefined)[] = [];\n\nfunction setObserver(newObserver: Observer | undefined): void {\n\tobserverStack.push(newObserver);\n\tcurrentObserver = newObserver;\n}\n\nfunction clearObserver(): void {\n\tdebugAssert(() => observerStack.length > 0 || \"Empty Observer stack on clear\");\n\tconst popped = observerStack.pop();\n\tdebugAssert(() => popped === currentObserver || \"Mismatched observer stack\");\n\tcurrentObserver = observerStack[observerStack.length - 1];\n}\n\n/**\n * For the duration of `f`, pushes `newObserver` onto the observer stack, making it the {@link currentObserver}.\n */\nexport function withObservation<T>(newObserver: Observer | undefined, f: () => T): T {\n\tsetObserver(newObserver);\n\ttry {\n\t\treturn f();\n\t} finally {\n\t\tclearObserver();\n\t}\n}\n"]}