@fluidframework/tree 2.118.1 → 3.0.1

package/lib/simple-tree/core/treeNodeKernel.js

@@ -2,8 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var _TreeNodeKernel_hydrationState, _TreeNodeKernel_eventBuffer, _KernelEventBuffer_instances, _KernelEventBuffer_disposed, _KernelEventBuffer_events, _KernelEventBuffer_eventSource, _KernelEventBuffer_disposeSourceListeners, _KernelEventBuffer_childrenChangedBuffer, _KernelEventBuffer_fieldMarksBuffer, _KernelEventBuffer_invalidatedFieldMarkKeys, _KernelEventBuffer_subTreeChangedBuffer, _KernelEventBuffer_emit, _KernelEventBuffer_handleChildrenChangedAfterBatch, _KernelEventBuffer_handleSubtreeChangedAfterBatch, _KernelEventBuffer_assertNotDisposed;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { assert, fail, debugAssert, unreachableCase, } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
@@ -55,6 +53,33 @@ function isHydrated(state) {
  * The kernel has the same lifetime as the node and spans both its unhydrated and hydrated states.
  */
 export class TreeNodeKernel {
+    node;
+    schema;
+    initialContext;
+    disposed = false;
+    /**
+     * Generation number which is incremented any time we have an edit on the node.
+     * Used during iteration to make sure there has been no edits that were concurrently made.
+     * @remarks
+     * This is updated monotonically by this class when edits are applied.
+     * TODO: update this when applying edits to unhydrated trees.
+     *
+     * If TypeScript supported making this immutable from outside the class without making it readonly from inside, that would be used here,
+     * but they only way to do that is add a separate public accessor and make it private, which was deemed not worth the boilerplate, runtime overhead and bundle size.
+     */
+    generationNumber = 0;
+    #hydrationState;
+    /**
+     * Handler for events listeners registered with the kernel.
+     *
+     * @remarks
+     * Supports event buffering via {@link withBufferedEvents}.
+     *
+     * Allocated lazily on first access to {@link TreeNodeKernel.events}.
+     * We expect the majority of nodes to never have event listeners registered, so
+     * deferring construction avoids per-kernel allocations.
+     */
+    #eventBuffer;
     /**
      * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
      *
@@ -67,30 +92,6 @@ export class TreeNodeKernel {
         this.node = node;
         this.schema = schema;
         this.initialContext = initialContext;
-        this.disposed = false;
-        /**
-         * Generation number which is incremented any time we have an edit on the node.
-         * Used during iteration to make sure there has been no edits that were concurrently made.
-         * @remarks
-         * This is updated monotonically by this class when edits are applied.
-         * TODO: update this when applying edits to unhydrated trees.
-         *
-         * If TypeScript supported making this immutable from outside the class without making it readonly from inside, that would be used here,
-         * but they only way to do that is add a separate public accessor and make it private, which was deemed not worth the boilerplate, runtime overhead and bundle size.
-         */
-        this.generationNumber = 0;
-        _TreeNodeKernel_hydrationState.set(this, void 0);
-        /**
-         * Handler for events listeners registered with the kernel.
-         *
-         * @remarks
-         * Supports event buffering via {@link withBufferedEvents}.
-         *
-         * Allocated lazily on first access to {@link TreeNodeKernel.events}.
-         * We expect the majority of nodes to never have event listeners registered, so
-         * deferring construction avoids per-kernel allocations.
-         */
-        _TreeNodeKernel_eventBuffer.set(this, void 0);
         splitInnerNodeType(innerNode);
         assert(!treeNodeToKernel.has(node), 0xa1a /* only one kernel per node can be made */);
         treeNodeToKernel.set(node, this);
@@ -98,19 +99,19 @@ export class TreeNodeKernel {
             // Unhydrated case
             debugAssert(() => innerNode.treeNode === undefined);
             innerNode.treeNode = node;
-            __classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, {
+            this.#hydrationState = {
                 innerNode,
-            }, "f");
+            };
         }
         else {
             // Hydrated case
-            __classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, this.createHydratedState(innerNode), "f");
+            this.#hydrationState = this.createHydratedState(innerNode);
         }
     }
     get context() {
-        if (isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+        if (isHydrated(this.#hydrationState)) {
             // This can't be cached on this.#hydrated during hydration since initial tree is hydrated before the context is cached on the anchorSet.
-            return (__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode.anchorSet.slots.get(SimpleContextSlot) ??
+            return (this.#hydrationState.innerNode.anchorNode.anchorSet.slots.get(SimpleContextSlot) ??
                 fail(0xb40 /* missing simple-tree context */));
         }
         return this.initialContext;
@@ -124,12 +125,12 @@ export class TreeNodeKernel {
      */
     hydrate(inner) {
         assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
-        assert(!isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f")), 0xa2b /* hydration should only happen once */);
-        __classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, this.createHydratedState(inner), "f");
+        assert(!isHydrated(this.#hydrationState), 0xa2b /* hydration should only happen once */);
+        this.#hydrationState = this.createHydratedState(inner);
         // Lazily migrate existing event listeners to the anchor node.
         // If no one ever subscribed to this kernel's events, the buffer was never allocated
         // and there is nothing to migrate.
-        __classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f")?.migrateEventSource(inner.anchorNode.events);
+        this.#eventBuffer?.migrateEventSource(inner.anchorNode.events);
     }
     createHydratedState(innerNode) {
         assert(!innerNode.anchorNode.slots.has(simpleTreeNodeSlot), 0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */);
@@ -149,47 +150,47 @@ export class TreeNodeKernel {
         if (this.disposed) {
             return TreeStatus.Deleted;
         }
-        if (!isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+        if (!isHydrated(this.#hydrationState)) {
             return TreeStatus.New;
         }
         // TODO: Replace this check with the proper check against the cursor state when the cursor becomes part of the kernel
-        const flex = __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode.slots.get(flexTreeSlot);
+        const flex = this.#hydrationState.innerNode.anchorNode.slots.get(flexTreeSlot);
         if (flex !== undefined) {
             assert(flex instanceof LazyEntity, 0x9b4 /* Unexpected flex node implementation */);
             if (flex.isFreed()) {
                 return TreeStatus.Deleted;
             }
         }
-        return treeStatusFromAnchorCache(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode);
+        return treeStatusFromAnchorCache(this.#hydrationState.innerNode.anchorNode);
     }
     get events() {
         assert(!this.disposed, 0xcfa /* Cannot register events on a disposed node */);
         // Allocate the buffer on first access. See {@link TreeNodeKernel.#eventBuffer} for rationale.
-        if (__classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f") === undefined) {
-            const eventSource = isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))
-                ? __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode.events
-                : __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.events;
-            __classPrivateFieldSet(this, _TreeNodeKernel_eventBuffer, new KernelEventBuffer(eventSource), "f");
+        if (this.#eventBuffer === undefined) {
+            const eventSource = isHydrated(this.#hydrationState)
+                ? this.#hydrationState.innerNode.anchorNode.events
+                : this.#hydrationState.innerNode.events;
+            this.#eventBuffer = new KernelEventBuffer(eventSource);
         }
-        return __classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f");
+        return this.#eventBuffer;
     }
     dispose() {
         debugAssert(() => !this.disposed || "Cannot dispose a disposed node");
         this.disposed = true;
-        if (isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
-            for (const off of __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").offAnchorNode) {
+        if (isHydrated(this.#hydrationState)) {
+            for (const off of this.#hydrationState.offAnchorNode) {
                 off();
             }
         }
-        __classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f")?.dispose();
+        this.#eventBuffer?.dispose();
         // TODO: go to the context and remove myself from withAnchors
     }
     isHydrated() {
-        return isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"));
+        return isHydrated(this.#hydrationState);
     }
     get anchorNode() {
-        return isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))
-            ? __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode
+        return isHydrated(this.#hydrationState)
+            ? this.#hydrationState.innerNode.anchorNode
             : undefined;
     }
     /**
@@ -202,27 +203,26 @@ export class TreeNodeKernel {
      * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been deleted.
      */
     getInnerNode() {
-        if (!isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
-            debugAssert(() => __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode?.context.isDisposed() === false ||
+        if (!isHydrated(this.#hydrationState)) {
+            debugAssert(() => this.#hydrationState.innerNode?.context.isDisposed() === false ||
                 "Unhydrated node should never be disposed");
-            return __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode; // Unhydrated case
+            return this.#hydrationState.innerNode; // Unhydrated case
         }
         if (this.disposed) {
             throw new UsageError("Cannot access a deleted node.");
         }
-        return __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode;
+        return this.#hydrationState.innerNode;
     }
     /**
      * Retrieves the {@link UnhydratedFlexTreeNode} if unhydrated. otherwise undefined.
      */
     getInnerNodeIfUnhydrated() {
-        if (isHydrated(__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+        if (isHydrated(this.#hydrationState)) {
             return undefined;
         }
-        return __classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode;
+        return this.#hydrationState.innerNode;
     }
 }
-_TreeNodeKernel_hydrationState = new WeakMap(), _TreeNodeKernel_eventBuffer = new WeakMap();
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"];
 // #region TreeNodeEventBuffer
@@ -289,6 +289,34 @@ export function TEST_activeBufferCount() {
  * {@link withBufferedTreeEvents} can flush it at the end of the buffering window.
  */
 class KernelEventBuffer {
+    #disposed = false;
+    #events = createEmitter();
+    #eventSource;
+    #disposeSourceListeners = new Map();
+    /**
+     * Buffer of fields that have changed since events were paused.
+     * When events are flushed, a single {@link AnchorEvents.childrenChangedAfterBatch} event will be emitted
+     * containing the accumulated set of changed fields.
+     */
+    #childrenChangedBuffer = new Set();
+    /**
+     * Buffer of field marks accumulated since events were paused.
+     * Emitted alongside the buffered changed-fields set when flushed.
+     */
+    #fieldMarksBuffer = new Map();
+    /**
+     * Fields whose marks have been permanently invalidated within the current buffer window due to
+     * two or more separate delta batches touching the same field.
+     * Once a key is in this set it must never be re-added to the marks buffer, even if
+     * a third (or later) batch arrives for that field.
+     */
+    #invalidatedFieldMarkKeys = new Set();
+    /**
+     * Whether or not the subtree has changed since events were paused.
+     * When events are flushed, a single {@link AnchorEvents.subTreeChanged} event will be emitted if and only
+     * if the subtree has changed.
+     */
+    #subTreeChangedBuffer = false;
     constructor(
     /**
      * Source of the kernel events.
@@ -296,36 +324,7 @@ class KernelEventBuffer {
      * and those subscriptions will be cleaned up when all corresponding listeners have been removed.
      */
     eventSource) {
-        _KernelEventBuffer_instances.add(this);
-        _KernelEventBuffer_disposed.set(this, false);
-        _KernelEventBuffer_events.set(this, createEmitter());
-        _KernelEventBuffer_eventSource.set(this, void 0);
-        _KernelEventBuffer_disposeSourceListeners.set(this, new Map());
-        /**
-         * Buffer of fields that have changed since events were paused.
-         * When events are flushed, a single {@link AnchorEvents.childrenChangedAfterBatch} event will be emitted
-         * containing the accumulated set of changed fields.
-         */
-        _KernelEventBuffer_childrenChangedBuffer.set(this, new Set());
-        /**
-         * Buffer of field marks accumulated since events were paused.
-         * Emitted alongside the buffered changed-fields set when flushed.
-         */
-        _KernelEventBuffer_fieldMarksBuffer.set(this, new Map());
-        /**
-         * Fields whose marks have been permanently invalidated within the current buffer window due to
-         * two or more separate delta batches touching the same field.
-         * Once a key is in this set it must never be re-added to the marks buffer, even if
-         * a third (or later) batch arrives for that field.
-         */
-        _KernelEventBuffer_invalidatedFieldMarkKeys.set(this, new Set());
-        /**
-         * Whether or not the subtree has changed since events were paused.
-         * When events are flushed, a single {@link AnchorEvents.subTreeChanged} event will be emitted if and only
-         * if the subtree has changed.
-         */
-        _KernelEventBuffer_subTreeChangedBuffer.set(this, false);
-        __classPrivateFieldSet(this, _KernelEventBuffer_eventSource, eventSource, "f");
+        this.#eventSource = eventSource;
     }
     /**
      * Migrate this event buffer to a new event source.
@@ -336,136 +335,139 @@ class KernelEventBuffer {
      */
     migrateEventSource(newSource) {
         // Unsubscribe from the old source
-        for (const off of __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").values()) {
+        for (const off of this.#disposeSourceListeners.values()) {
             off();
         }
-        __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").clear();
-        __classPrivateFieldSet(this, _KernelEventBuffer_eventSource, newSource, "f");
-        if (__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners("childrenChangedAfterBatch")) {
-            const off = __classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on("childrenChangedAfterBatch", ({ changedFields, fieldMarks }) => __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, "childrenChangedAfterBatch", { changedFields, fieldMarks }));
-            __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").set("childrenChangedAfterBatch", off);
+        this.#disposeSourceListeners.clear();
+        this.#eventSource = newSource;
+        if (this.#events.hasListeners("childrenChangedAfterBatch")) {
+            const off = this.#eventSource.on("childrenChangedAfterBatch", ({ changedFields, fieldMarks }) => this.#emit("childrenChangedAfterBatch", { changedFields, fieldMarks }));
+            this.#disposeSourceListeners.set("childrenChangedAfterBatch", off);
         }
-        if (__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners("subtreeChangedAfterBatch")) {
-            const off = __classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on("subtreeChangedAfterBatch", () => __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, "subtreeChangedAfterBatch"));
-            __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").set("subtreeChangedAfterBatch", off);
+        if (this.#events.hasListeners("subtreeChangedAfterBatch")) {
+            const off = this.#eventSource.on("subtreeChangedAfterBatch", () => this.#emit("subtreeChangedAfterBatch"));
+            this.#disposeSourceListeners.set("subtreeChangedAfterBatch", off);
         }
     }
     on(eventName, listener) {
-        __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_assertNotDisposed).call(this);
+        this.#assertNotDisposed();
         // Lazily bind event listeners to the source.
         // If we do not have any existing listeners for this event, then we need to bind to the source.
-        if (!__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners(eventName)) {
-            assert(!__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").has(eventName), 0xc4f /* Should not have a dispose function without listeners */);
+        if (!this.#events.hasListeners(eventName)) {
+            assert(!this.#disposeSourceListeners.has(eventName), 0xc4f /* Should not have a dispose function without listeners */);
             const off = eventName === "childrenChangedAfterBatch"
-                ? __classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on(eventName, (args) => __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, eventName, args))
-                : __classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on(eventName, () => __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, eventName));
-            __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").set(eventName, off);
+                ? this.#eventSource.on(eventName, (args) => this.#emit(eventName, args))
+                : this.#eventSource.on(eventName, () => this.#emit(eventName));
+            this.#disposeSourceListeners.set(eventName, off);
         }
-        __classPrivateFieldGet(this, _KernelEventBuffer_events, "f").on(eventName, listener);
+        this.#events.on(eventName, listener);
         // Return a bound method instead of an arrow closure. A bound function captures
         // (target, thisArg, ...boundArgs) in a fixed shape that V8 can optimize more
         // uniformly than a closure that captures its lexical context.
         return this.off.bind(this, eventName, listener);
     }
     off(eventName, listener) {
-        __classPrivateFieldGet(this, _KernelEventBuffer_events, "f").off(eventName, listener);
+        this.#events.off(eventName, listener);
         // If there are no remaining listeners for the event, unbind from the source
-        if (!__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners(eventName)) {
-            const off = __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").get(eventName);
+        if (!this.#events.hasListeners(eventName)) {
+            const off = this.#disposeSourceListeners.get(eventName);
             off?.();
-            __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").delete(eventName);
+            this.#disposeSourceListeners.delete(eventName);
+        }
+    }
+    #emit(eventName, arg) {
+        this.#assertNotDisposed();
+        switch (eventName) {
+            case "childrenChangedAfterBatch": {
+                assert(arg !== undefined, 0xcea /* childrenChangedAfterBatch requires arg */);
+                return this.#handleChildrenChangedAfterBatch(arg.changedFields, arg.fieldMarks);
+            }
+            case "subtreeChangedAfterBatch": {
+                return this.#handleSubtreeChangedAfterBatch();
+            }
+            default: {
+                unreachableCase(eventName);
+            }
+        }
+    }
+    #handleChildrenChangedAfterBatch(changedFields, fieldMarks) {
+        if (bufferTreeEvents) {
+            activeBuffers.add(this);
+            for (const fieldKey of changedFields) {
+                this.#childrenChangedBuffer.add(fieldKey);
+            }
+            for (const [key, marks] of fieldMarks) {
+                if (this.#invalidatedFieldMarkKeys.has(key)) {
+                    // Already permanently invalidated by an earlier collision; ignore this batch too.
+                    // TODO: Once the eventing stack is rewritten to walk the composed delta at flush
+                    // time, this collision path will be unreachable and can be removed entirely.
+                    continue;
+                }
+                if (this.#fieldMarksBuffer.has(key)) {
+                    // A second batch of marks arrived for the same field before the buffer was flushed.
+                    // We have no delta composition logic, so permanently invalidate this field so that
+                    // any further batches are also discarded rather than incorrectly surfaced.
+                    this.#fieldMarksBuffer.delete(key);
+                    this.#invalidatedFieldMarkKeys.add(key);
+                }
+                else {
+                    this.#fieldMarksBuffer.set(key, marks);
+                }
+            }
+        }
+        else {
+            this.#events.emit("childrenChangedAfterBatch", { changedFields, fieldMarks });
+        }
+    }
+    #handleSubtreeChangedAfterBatch() {
+        if (bufferTreeEvents) {
+            activeBuffers.add(this);
+            this.#subTreeChangedBuffer = true;
+        }
+        else {
+            this.#events.emit("subtreeChangedAfterBatch");
         }
     }
     /**
      * Flushes any events buffered due to {@link withBufferedTreeEvents}.
      */
     flush() {
-        __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_assertNotDisposed).call(this);
-        if (__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").size > 0) {
-            __classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("childrenChangedAfterBatch", {
-                changedFields: __classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f"),
-                fieldMarks: __classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f"),
+        this.#assertNotDisposed();
+        if (this.#childrenChangedBuffer.size > 0) {
+            this.#events.emit("childrenChangedAfterBatch", {
+                changedFields: this.#childrenChangedBuffer,
+                fieldMarks: this.#fieldMarksBuffer,
             });
-            __classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").clear();
-            __classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").clear();
-            __classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").clear();
+            this.#childrenChangedBuffer.clear();
+            this.#fieldMarksBuffer.clear();
+            this.#invalidatedFieldMarkKeys.clear();
         }
-        if (__classPrivateFieldGet(this, _KernelEventBuffer_subTreeChangedBuffer, "f")) {
-            __classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("subtreeChangedAfterBatch");
-            __classPrivateFieldSet(this, _KernelEventBuffer_subTreeChangedBuffer, false, "f");
+        if (this.#subTreeChangedBuffer) {
+            this.#events.emit("subtreeChangedAfterBatch");
+            this.#subTreeChangedBuffer = false;
         }
     }
+    #assertNotDisposed() {
+        assert(!this.#disposed, 0xc51 /* Event handler disposed. */);
+    }
     dispose() {
-        if (__classPrivateFieldGet(this, _KernelEventBuffer_disposed, "f")) {
+        if (this.#disposed) {
             return;
         }
-        debugAssert(() => (__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").size === 0 && !__classPrivateFieldGet(this, _KernelEventBuffer_subTreeChangedBuffer, "f")) ||
+        debugAssert(() => (this.#childrenChangedBuffer.size === 0 && !this.#subTreeChangedBuffer) ||
             "Buffered kernel events should have been flushed before disposing.");
         debugAssert(() => !activeBuffers.has(this) || "Disposed buffer should not be in activeBuffers.");
-        for (const off of __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").values()) {
+        for (const off of this.#disposeSourceListeners.values()) {
             off();
         }
-        __classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").clear();
-        __classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").clear();
-        __classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").clear();
-        __classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").clear();
-        __classPrivateFieldSet(this, _KernelEventBuffer_subTreeChangedBuffer, false, "f");
-        __classPrivateFieldSet(this, _KernelEventBuffer_disposed, true, "f");
+        this.#disposeSourceListeners.clear();
+        this.#childrenChangedBuffer.clear();
+        this.#fieldMarksBuffer.clear();
+        this.#invalidatedFieldMarkKeys.clear();
+        this.#subTreeChangedBuffer = false;
+        this.#disposed = true;
     }
 }
-_KernelEventBuffer_disposed = new WeakMap(), _KernelEventBuffer_events = new WeakMap(), _KernelEventBuffer_eventSource = new WeakMap(), _KernelEventBuffer_disposeSourceListeners = new WeakMap(), _KernelEventBuffer_childrenChangedBuffer = new WeakMap(), _KernelEventBuffer_fieldMarksBuffer = new WeakMap(), _KernelEventBuffer_invalidatedFieldMarkKeys = new WeakMap(), _KernelEventBuffer_subTreeChangedBuffer = new WeakMap(), _KernelEventBuffer_instances = new WeakSet(), _KernelEventBuffer_emit = function _KernelEventBuffer_emit(eventName, arg) {
-    __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_assertNotDisposed).call(this);
-    switch (eventName) {
-        case "childrenChangedAfterBatch": {
-            assert(arg !== undefined, 0xcea /* childrenChangedAfterBatch requires arg */);
-            return __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_handleChildrenChangedAfterBatch).call(this, arg.changedFields, arg.fieldMarks);
-        }
-        case "subtreeChangedAfterBatch": {
-            return __classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_handleSubtreeChangedAfterBatch).call(this);
-        }
-        default: {
-            unreachableCase(eventName);
-        }
-    }
-}, _KernelEventBuffer_handleChildrenChangedAfterBatch = function _KernelEventBuffer_handleChildrenChangedAfterBatch(changedFields, fieldMarks) {
-    if (bufferTreeEvents) {
-        activeBuffers.add(this);
-        for (const fieldKey of changedFields) {
-            __classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").add(fieldKey);
-        }
-        for (const [key, marks] of fieldMarks) {
-            if (__classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").has(key)) {
-                // Already permanently invalidated by an earlier collision; ignore this batch too.
-                // TODO: Once the eventing stack is rewritten to walk the composed delta at flush
-                // time, this collision path will be unreachable and can be removed entirely.
-                continue;
-            }
-            if (__classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").has(key)) {
-                // A second batch of marks arrived for the same field before the buffer was flushed.
-                // We have no delta composition logic, so permanently invalidate this field so that
-                // any further batches are also discarded rather than incorrectly surfaced.
-                __classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").delete(key);
-                __classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").add(key);
-            }
-            else {
-                __classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").set(key, marks);
-            }
-        }
-    }
-    else {
-        __classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("childrenChangedAfterBatch", { changedFields, fieldMarks });
-    }
-}, _KernelEventBuffer_handleSubtreeChangedAfterBatch = function _KernelEventBuffer_handleSubtreeChangedAfterBatch() {
-    if (bufferTreeEvents) {
-        activeBuffers.add(this);
-        __classPrivateFieldSet(this, _KernelEventBuffer_subTreeChangedBuffer, true, "f");
-    }
-    else {
-        __classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("subtreeChangedAfterBatch");
-    }
-}, _KernelEventBuffer_assertNotDisposed = function _KernelEventBuffer_assertNotDisposed() {
-    assert(!__classPrivateFieldGet(this, _KernelEventBuffer_disposed, "f"), 0xc51 /* Event handler disposed. */);
-};
 /**
  * Narrows innerNode to either {@link UnhydratedFlexTreeNode} or {@link HydratedFlexTreeNode}.
  */