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

package/lib/core/tree/anchorSet.d.ts

@@ -2,14 +2,14 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Listenable } from "../../events/index.js";
-import { Brand, BrandedKey, BrandedMapSubset, Opaque } from "../../util/index.js";
-import { FieldKey } from "../schema-stored/index.js";
-import { UpPath } from "./pathTree.js";
-import { Value } from "./types.js";
-import { DeltaVisitor } from "./visitDelta.js";
-import { PathVisitor } from "./visitPath.js";
-import { AnnouncedVisitor } from "./visitorUtils.js";
+import { type Listenable } from "../../events/index.js";
+import { type Brand, type BrandedKey, type BrandedMapSubset, type Opaque } from "../../util/index.js";
+import type { FieldKey } from "../schema-stored/index.js";
+import type { UpPath } from "./pathTree.js";
+import { type Value } from "./types.js";
+import type { DeltaVisitor } from "./visitDelta.js";
+import type { PathVisitor } from "./visitPath.js";
+import type { AnnouncedVisitor } from "./visitorUtils.js";
 /**
  * A way to refer to a particular tree location within an {@link AnchorSet}.
  * Associated with a ref count on the underlying {@link AnchorNode}.
@@ -65,28 +65,50 @@ export interface AnchorEvents {
      */
     afterDestroy(anchor: AnchorNode): void;
     /**
-     * One or more of the children of this node is just about to change.
+     * Emitted in the middle of applying a batch of changes (i.e. during a delta a visit), if one or more of this node's
+     * direct children are about to change due to updates from the batch.
      *
      * @remarks
-     * Does not include edits of child subtrees: instead only includes changes to nodes which are direct children in this node's fields.
+     * Does not include edits of child subtrees: instead only includes changes to nodes which are direct children in this
+     * node's fields.
      */
     childrenChanging(anchor: AnchorNode): void;
     /**
-     * One or more of the children of this node has just changed.
+     * Emitted in the middle of applying a batch of changes (i.e. during a delta a visit), if one or more of this node's
+     * direct children just changed due to updates from the batch.
      *
      * @remarks
-     * Does not include edits of child subtrees: instead only includes changes to nodes which are direct children in this node's fields.
+     * Does not include edits of child subtrees: instead only includes changes to nodes which are direct children in this
+     * node's fields.
+     *
+     * Compare to {@link AnchorEvents.childrenChangedAfterBatch} which is emitted after the whole batch has been applied.
      */
     childrenChanged(anchor: AnchorNode): void;
     /**
-     * Something in this tree is changing.
+     * Emitted after a batch of changes has been applied (i.e. when a delta visit completes), if one or more of this node's
+     * direct children changed due to updates from the batch.
+     *
+     * @remarks
+     * Does not include edits of child subtrees: instead only includes changes to nodes which are direct children in this
+     * node's fields.
+     *
+     * This event is guaranteed to be emitted on a given node only once per batch.
+     *
+     * Compare to {@link AnchorEvents.childrenChanged} which is emitted in the middle of the batch/delta-visit.
+     */
+    childrenChangedAfterBatch(anchor: AnchorNode): void;
+    /**
+     * Emitted in the middle of applying a batch of changes (i.e. during a delta a visit), if something in the subtree
+     * rooted at `anchor` _may_ be about to change due to updates from the batch.
+     *
+     * @remarks
      * The event can optionally return a {@link PathVisitor} to traverse the subtree.
      * Called on every parent (transitively) when a change is occurring.
-     * Includes changes to this node itself.
      */
     subtreeChanging(anchor: AnchorNode): PathVisitor | void;
     /**
-     * Emitted after the subtree rooted at `anchor` may have been changed.
+     * Emitted in the middle of applying a batch of changes (i.e. during a delta a visit), if something in the subtree
+     * rooted at `anchor` _may_ have just changed due to updates from the batch.
      *
      * @remarks
      * While this event is always emitted in the presence of changes to the subtree,
@@ -96,15 +118,31 @@ export interface AnchorEvents {
      * If this event is emitted by a node, it will later be emitted by all its ancestors up to the root as well, at
      * least once on each ancestor.
      *
+     * Compare to {@link AnchorEvents.subtreeChangedAfterBatch} which is emitted after the whole batch has been applied.
+     *
      * @privateRemarks
      * The delta visit algorithm is complicated and it may fire this event multiple times for the same change to a node.
      * The change to the tree may not be visible until the event fires for the last time.
      * Refer to the documentation of the delta visit algorithm for more details.
-     *
-     * TODO: can we make it so this event is guaranteed to only fire once during the delta visit? Specifically when
-     * changes to the tree did happen and are visible to the listener.
      */
     subtreeChanged(anchor: AnchorNode): void;
+    /**
+     * Emitted after a batch of changes has been applied (i.e. when a delta visit completes), if something in the subtree
+     * rooted at `anchor` changed due to updates from the batch.
+     *
+     * @remarks
+     * If this event is emitted by a node, it will later be emitted by all its ancestors up to the root as well, from bottom to top.
+     *
+     * This event is guaranteed to be emitted on a given node only once per batch.
+     *
+     * Compare to {@link AnchorEvents.subtreeChanged} which is emitted in the middle of the batch/delta-visit.
+     *
+     * @privateRemarks
+     * Note that because this is fired after the full batch of changes is applied, it guarantees that something in the
+     * subtree changed, compared to {@link AnchorEvents.subtreeChanged} or {@link AnchorEvents.subtreeChanging} which
+     * fire when something _may_ have changed or _may_ be about to change.
+     */
+    subtreeChangedAfterBatch(anchor: AnchorNode): void;
     /**
      * Value on this node is changing.
      */

package/lib/core/tree/anchorSet.d.ts.map

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

package/lib/core/tree/anchorSet.js

@@ -42,35 +42,34 @@ export function anchorSlot() {
  * @internal
  */
 export class AnchorSet {
-    events = createEmitter();
-    /**
-     * Incrementing counter to give each anchor in this set a unique index for its identifier.
-     * "0" is reserved for the `NeverAnchor`.
-     */
-    anchorCounter = 1;
-    /**
-     * Incrementing number that is bumped each time that the {@link AnchorSet} is changed.
-     * This allows consumers to cache state associated with a particular generation number and later determine if that state may have been invalidated using a comparison with the current generation number.
-     * For example, anchor slots can be used to cache the removal status of a node to memoize repeated walks up the tree.
-     */
-    generationNumber = 0;
-    /**
-     * Special root node under which all anchors in this anchor set are transitively parented.
-     * This does not appear in the UpPaths (instead they use undefined for the root).
-     * Immediate children of this root are in detached fields (which have their identifiers used as the field keys).
-     *
-     * This is allocated with refCount one, which is never freed so it is never cleaned up
-     * (as long as this AnchorSet is not garbage collected).
-     *
-     * There should never be any children other than the special root detached field under this between transactions:
-     * TODO: check for and enforce this.
-     */
-    root = new PathNode(this, EmptyKey, 0, undefined);
-    // TODO: anchor system could be optimized a bit to avoid the maps (Anchor is ref to Path, path has ref count).
-    // For now use this more encapsulated approach with maps.
-    anchorToPath = new Map();
-    activeVisitor;
     constructor() {
+        this.events = createEmitter();
+        /**
+         * Incrementing counter to give each anchor in this set a unique index for its identifier.
+         * "0" is reserved for the `NeverAnchor`.
+         */
+        this.anchorCounter = 1;
+        /**
+         * Incrementing number that is bumped each time that the {@link AnchorSet} is changed.
+         * This allows consumers to cache state associated with a particular generation number and later determine if that state may have been invalidated using a comparison with the current generation number.
+         * For example, anchor slots can be used to cache the removal status of a node to memoize repeated walks up the tree.
+         */
+        this.generationNumber = 0;
+        /**
+         * Special root node under which all anchors in this anchor set are transitively parented.
+         * This does not appear in the UpPaths (instead they use undefined for the root).
+         * Immediate children of this root are in detached fields (which have their identifiers used as the field keys).
+         *
+         * This is allocated with refCount one, which is never freed so it is never cleaned up
+         * (as long as this AnchorSet is not garbage collected).
+         *
+         * There should never be any children other than the special root detached field under this between transactions:
+         * TODO: check for and enforce this.
+         */
+        this.root = new PathNode(this, EmptyKey, 0, undefined);
+        // TODO: anchor system could be optimized a bit to avoid the maps (Anchor is ref to Path, path has ref count).
+        // For now use this more encapsulated approach with maps.
+        this.anchorToPath = new Map();
         this.on("treeChanging", () => {
             this.generationNumber += 1;
         });
@@ -407,18 +406,57 @@ export class AnchorSet {
             pathVisitors: new Map(),
             parentField: undefined,
             parent: undefined,
+            bufferedEvents: [],
+            // 'currentDepth' and 'depthThresholdForSubtreeChanged' serve to keep track of when do we need to emit
+            // subtreeChangedAfterBatch events.
+            // The algorithm works as follows:
+            // - Initialize both to 0.
+            // - As we walk the tree from the root towards the leaves, when we enter a node increment currentDepth by 1.
+            // - When we edit a node, set depthThresholdForSubtreeChanged = currentDepth.
+            //   Intuitively, depthThresholdForSubtreeChanged means "as you walk the tree towards the root, when you exit a
+            //   node at this depth you should emit a subtreeChangedAfterBatch event".
+            // - When we exit a node, if d === currentDepth then emit a subtreeChangedAfterBatch and decrement d by 1.
+            //   Then decrement currentDepth unconditionally.
+            // Note that the event will be emitted when exiting a node that was edited (depthThresholdForSubtreeChanged will
+            // have been set to the current depth when the edit happened), it will be emitted when exiting a node that is the
+            // parent of a node that already emitted the event (because both depthThresholdForSubtreeChanged and currentDepth
+            // get decremented when exiting a node so they stay in sync), and if we're already emitting the event but start
+            // walking the tree back towards the leaves in a path where no edits happen, currentDepth will be increased again
+            // as we walk that path, depthThresholdForSubtreeChanged will not, and thus no event will be emitted when walking
+            // back up that path, until we get back to the depth where we were already emitting the event, and will continue
+            // emitting it on the way to the root.
+            currentDepth: 0,
+            depthThresholdForSubtreeChanged: 0,
             free() {
                 assert(this.anchorSet.activeVisitor !== undefined, 0x768 /* Multiple free calls for same visitor */);
                 for (const node of referencedPathNodes) {
                     node.removeRef();
                 }
                 this.anchorSet.activeVisitor = undefined;
+                const alreadyEmitted = new Map();
+                for (const { node, event } of this.bufferedEvents) {
+                    if (!alreadyEmitted.has(node)) {
+                        alreadyEmitted.set(node, []);
+                    }
+                    const emittedEvents = alreadyEmitted.get(node);
+                    if (emittedEvents?.includes(event) ?? false) {
+                        continue;
+                    }
+                    emittedEvents?.push(event);
+                    node.events.emit(event, node);
+                }
             },
             notifyChildrenChanging() {
                 this.maybeWithNode((p) => p.events.emit("childrenChanging", p), () => this.anchorSet.events.emit("childrenChanging", this.anchorSet));
             },
             notifyChildrenChanged() {
-                this.maybeWithNode((p) => p.events.emit("childrenChanged", p), () => { });
+                this.maybeWithNode((p) => {
+                    p.events.emit("childrenChanged", p);
+                    this.bufferedEvents.push({
+                        node: p,
+                        event: "childrenChangedAfterBatch",
+                    });
+                }, () => { });
             },
             beforeAttach(source, count, destination) {
                 assert(this.parentField !== undefined, 0x7a0 /* Must be in a field in order to attach */);
@@ -473,6 +511,7 @@ export class AnchorSet {
                     parentIndex: destination,
                 };
                 this.anchorSet.moveChildren(sourcePath, destinationPath, count);
+                this.depthThresholdForSubtreeChanged = this.currentDepth;
             },
             beforeDetach(source, destination) {
                 assert(this.parentField !== undefined, 0x7a3 /* Must be in a field in order to attach */);
@@ -527,6 +566,7 @@ export class AnchorSet {
                     parentIndex: 0,
                 };
                 this.anchorSet.moveChildren(sourcePath, destinationPath, source.end - source.start);
+                this.depthThresholdForSubtreeChanged = this.currentDepth;
             },
             beforeReplace(newContent, oldContent, destination) {
                 assert(this.parentField !== undefined, 0x7a6 /* Must be in a field in order to replace */);
@@ -630,17 +670,26 @@ export class AnchorSet {
                         }
                     }
                 });
+                this.currentDepth++;
             },
             exitNode(index) {
                 assert(this.parent !== undefined, 0x3ac /* Must have parent node */);
                 this.maybeWithNode((p) => {
                     p.events.emit("subtreeChanged", p);
+                    if (this.depthThresholdForSubtreeChanged === this.currentDepth) {
+                        this.bufferedEvents.push({
+                            node: p,
+                            event: "subtreeChangedAfterBatch",
+                        });
+                        this.depthThresholdForSubtreeChanged--;
+                    }
                     // Remove subtree path visitors added at this node if there are any
                     this.pathVisitors.delete(p);
                 });
                 const parent = this.parent;
                 this.parentField = parent.parentField;
                 this.parent = parent.parent;
+                this.currentDepth--;
             },
             enterField(key) {
                 this.parentField = key;
@@ -712,29 +761,6 @@ var Status;
  * 3. events are registered.
  */
 class PathNode extends ReferenceCountedBase {
-    anchorSet;
-    parentField;
-    parentIndex;
-    parentPath;
-    status = Status.Alive;
-    /**
-     * Event emitter for this anchor.
-     */
-    events = createEmitter(() => this.considerDispose());
-    /**
-     * PathNode arrays are kept sorted the PathNode's parentIndex for efficient search.
-     * Users of this field must take care to maintain invariants (correct parent pointers, not empty child arrays etc.)
-     *
-     * Performance Note:
-     * Large child lists could be updated more efficiently here using a data-structure optimized
-     * for efficient prefix sum updates, such as a Fenwick tree or Finger tree.
-     * This would be complicated by the need for parent pointers (including indexes),
-     * but is possible to do.
-     */
-    children = new Map();
-    // TODO: use something other than `any`
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    slots = new Map();
     /**
      * Construct a PathNode with refcount 1.
      * @param anchorSet - used to determine if this PathNode is already part of a specific anchorSet
@@ -758,6 +784,25 @@ class PathNode extends ReferenceCountedBase {
         this.parentField = parentField;
         this.parentIndex = parentIndex;
         this.parentPath = parentPath;
+        this.status = Status.Alive;
+        /**
+         * Event emitter for this anchor.
+         */
+        this.events = createEmitter(() => this.considerDispose());
+        /**
+         * PathNode arrays are kept sorted the PathNode's parentIndex for efficient search.
+         * Users of this field must take care to maintain invariants (correct parent pointers, not empty child arrays etc.)
+         *
+         * Performance Note:
+         * Large child lists could be updated more efficiently here using a data-structure optimized
+         * for efficient prefix sum updates, such as a Fenwick tree or Finger tree.
+         * This would be complicated by the need for parent pointers (including indexes),
+         * but is possible to do.
+         */
+        this.children = new Map();
+        // TODO: use something other than `any`
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.slots = new Map();
     }
     on(eventName, listener) {
         return this.events.on(eventName, listener);