@fluidframework/tree 2.11.0 → 2.13.0

package/lib/shared-tree/treeCheckout.js

@@ -7,15 +7,21 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _TreeCheckout_transaction;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _TreeCheckout_events, _TreeCheckout_transaction, _TreeCheckout_validatedCommits;
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { UsageError, } from "@fluidframework/telemetry-utils/internal";
 import { noopValidator } from "../codec/index.js";
 import { AnchorSet, CommitKind, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, } from "../core/index.js";
 import { buildForest, createNodeKeyManager, intoDelta, jsonableTreeFromCursor, makeFieldBatchCodec, } from "../feature-libraries/index.js";
-import { SharedTreeBranch, TransactionResult, TransactionStack, getChangeReplaceType, onForkTransitive, } from "../shared-tree-core/index.js";
-import { Breakable, disposeSymbol, fail, getLast, hasSome } from "../util/index.js";
+import { SquashingTransactionStack, SharedTreeBranch, TransactionResult, onForkTransitive, } from "../shared-tree-core/index.js";
+import { Breakable, disposeSymbol, fail, getOrCreate } from "../util/index.js";
 import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
 import { getCheckout, SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 /**
@@ -38,30 +44,28 @@ export function createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCod
             change: changeFamily.rebaser.compose([]),
             revision: "root",
         }, changeFamily, () => idCompressor.generateCompressedId());
-    const events = args?.events ?? createEmitter();
-    return new TreeCheckout(branch, false, changeFamily, schema, forest, events, mintRevisionTag, revisionTagCodec, idCompressor, args?.removedRoots, args?.logger, args?.breaker);
+    return new TreeCheckout(branch, false, changeFamily, schema, forest, mintRevisionTag, revisionTagCodec, idCompressor, args?.removedRoots, args?.logger, args?.breaker, args?.disposeForksAfterTransaction);
 }
 /**
  * An implementation of {@link ITreeCheckoutFork}.
  */
 export class TreeCheckout {
-    constructor(_branch, 
+    constructor(branch, 
     /** True if and only if this checkout is for a forked branch and not the "main branch" of the tree. */
-    isBranch, changeFamily, storedSchema, forest, events, mintRevisionTag, revisionTagCodec, idCompressor, removedRoots = makeDetachedFieldIndex("repair", revisionTagCodec, idCompressor), 
+    isBranch, changeFamily, storedSchema, forest, mintRevisionTag, revisionTagCodec, idCompressor, removedRoots = makeDetachedFieldIndex("repair", revisionTagCodec, idCompressor), 
     /** Optional logger for telemetry. */
-    logger, breaker = new Breakable("TreeCheckout")) {
-        this._branch = _branch;
+    logger, breaker = new Breakable("TreeCheckout"), disposeForksAfterTransaction = true) {
         this.isBranch = isBranch;
         this.changeFamily = changeFamily;
         this.storedSchema = storedSchema;
         this.forest = forest;
-        this.events = events;
         this.mintRevisionTag = mintRevisionTag;
         this.revisionTagCodec = revisionTagCodec;
         this.idCompressor = idCompressor;
         this.removedRoots = removedRoots;
         this.logger = logger;
         this.breaker = breaker;
+        this.disposeForksAfterTransaction = disposeForksAfterTransaction;
         this.disposed = false;
         this.views = new Set();
         /**
@@ -74,69 +78,15 @@ export class TreeCheckout {
          * being reverted.
          */
         this.revertibleCommitBranches = new Map();
-        /**
-         * The {@link Transactor} for this checkout.
-         * @remarks In the context of a checkout, transactions allow edits to be batched into atomic units.
-         * Edits made during a transaction will update the local state of the tree immediately, but will be squashed into a single edit when the transaction is committed.
-         * If the transaction is aborted, the local state will be reset to what it was before the transaction began.
-         * Transactions may nest, meaning that a transaction may be started while a transaction is already ongoing.
-         *
-         * To avoid updating observers of the view state with intermediate results during a transaction,
-         * use {@link ITreeCheckout#branch} and {@link ISharedTreeFork#merge}.
-         */
-        _TreeCheckout_transaction.set(this, new TransactionStack(() => {
-            // Keep track of the commit that each transaction was on when it started
-            // TODO:#8603: This may need to be computed differently if we allow rebasing during a transaction.
-            const startCommit = this._branch.getHead();
-            // Keep track of all the forks created during the transaction so that we can dispose them when the transaction ends.
-            // This is a policy decision that we think is useful for the user, but it is not necessary for correctness.
-            const forks = new Set();
-            const onDisposeUnSubscribes = [];
-            const onForkUnSubscribe = onForkTransitive(this, (fork) => {
-                forks.add(fork);
-                onDisposeUnSubscribes.push(fork.events.on("dispose", () => forks.delete(fork)));
-            });
-            // When each transaction is started, take a snapshot of the current state of removed roots
-            const removedRoots = this.removedRoots.clone();
-            this._branch.editor.enterTransaction();
-            return (result) => {
-                this._branch.editor.exitTransaction();
-                switch (result) {
-                    case TransactionResult.Abort:
-                        this._branch.removeAfter(startCommit);
-                        // If a transaction is rolled back, revert removed roots back to the latest snapshot
-                        this.removedRoots = removedRoots;
-                        break;
-                    case TransactionResult.Commit: {
-                        const removedCommits = this._branch.squashAfter(startCommit);
-                        const transactionRevision = this._branch.getHead().revision;
-                        for (const transactionStep of removedCommits) {
-                            this.removedRoots.updateMajor(transactionStep.revision, transactionRevision);
-                        }
-                        break;
-                    }
-                    default:
-                        unreachableCase(result);
-                }
-                forks.forEach((fork) => fork.dispose());
-                onDisposeUnSubscribes.forEach((unsubscribe) => unsubscribe());
-                onForkUnSubscribe();
-            };
-        }));
-        // We subscribe to `beforeChange` rather than `afterChange` here because it's possible that the change is invalid WRT our forest.
-        // For example, a bug in the editor might produce a malformed change object and thus applying the change to the forest will throw an error.
-        // In such a case we will crash here, preventing the change from being added to the commit graph, and preventing `afterChange` from firing.
-        // One important consequence of this is that we will not submit the op containing the invalid change, since op submissions happens in response to `afterChange`.
-        _branch.events.on("beforeChange", (event) => {
+        _TreeCheckout_events.set(this, createEmitter());
+        this.events = __classPrivateFieldGet(this, _TreeCheckout_events, "f");
+        this.onAfterChange = (event) => {
+            this.editLock.lock();
+            __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("beforeBatch", event);
             if (event.change !== undefined) {
-                let revision;
-                if (event.type === "replace") {
-                    assert(hasSome(event.newCommits), 0xa81 /* Expected new commit for non no-op change event */);
-                    revision = getLast(event.newCommits).revision;
-                }
-                else {
-                    revision = event.change.revision;
-                }
+                const revision = event.type === "rebase"
+                    ? __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.getHead().revision
+                    : event.change.revision;
                 // Conflicts due to schema will be empty and thus are not applied.
                 for (const change of event.change.change.changes) {
                     if (change.type === "data") {
@@ -161,54 +111,22 @@ export class TreeCheckout {
                         // They will however be rebased over the rollback of the schema change. This rebasing will
                         // ensure that these data changes are muted if they would render some trees invalid under the
                         // original (reinstated) schema.
-                        storedSchema.apply(change.innerChange.schema.new);
+                        this.storedSchema.apply(change.innerChange.schema.new);
                     }
                     else {
                         fail("Unknown Shared Tree change type.");
                     }
                 }
-                this.events.emit("afterBatch");
             }
-        });
-        _branch.events.on("afterChange", (event) => {
-            // The following logic allows revertibles to be generated for the change.
-            // Currently only appends (including merges) and transaction commits are supported.
-            if (!this.transaction.isInProgress()) {
-                if (event.type === "append" ||
-                    (event.type === "replace" && getChangeReplaceType(event) === "transactionCommit")) {
-                    // TODO:#20949: When the SharedTree is detached, these commits will already have been garbage collected.
-                    //       Figure out a way to generate revertibles before the commits are garbage collected.
-                    for (const commit of event.newCommits) {
-                        const kind = event.type === "append" ? event.kind : CommitKind.Default;
-                        const { change, revision } = commit;
-                        const getRevertible = hasSchemaChange(change)
-                            ? undefined
-                            : (onRevertibleDisposed) => {
-                                if (!withinEventContext) {
-                                    throw new UsageError("Cannot get a revertible outside of the context of a changed event.");
-                                }
-                                if (this.revertibleCommitBranches.get(revision) !== undefined) {
-                                    throw new UsageError("Cannot generate the same revertible more than once. Note that this can happen when multiple changed event listeners are registered.");
-                                }
-                                const revertible = this.createRevertible(revision, kind, this, onRevertibleDisposed);
-                                this.revertibleCommitBranches.set(revision, _branch.fork(commit));
-                                this.revertibles.add(revertible);
-                                return revertible;
-                            };
-                        let withinEventContext = true;
-                        this.events.emit("changed", { isLocal: true, kind }, getRevertible);
-                        withinEventContext = false;
-                    }
-                }
-                else if (this.isRemoteChangeEvent(event)) {
-                    // TODO: figure out how to plumb through commit kind info for remote changes
-                    this.events.emit("changed", { isLocal: false, kind: CommitKind.Default });
-                }
+            __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
+            this.editLock.unlock();
+            if (event.type === "append") {
+                event.newCommits.forEach((commit) => this.validateCommit(commit));
             }
-        });
-        // When the branch is trimmed, we can garbage collect any repair data whose latest relevant revision is one of the
-        // trimmed revisions.
-        _branch.events.on("ancestryTrimmed", (revisions) => {
+        };
+        this.onAncestryTrimmed = (revisions) => {
+            // When the branch is trimmed, we can garbage collect any repair data whose latest relevant revision is one of the
+            // trimmed revisions.
             this.withCombinedVisitor((visitor) => {
                 revisions.forEach((revision) => {
                     // get all the roots last created or used by the revision
@@ -220,7 +138,88 @@ export class TreeCheckout {
                     this.removedRoots.deleteRootsLastTouchedByRevision(revision);
                 });
             });
+        };
+        /**
+         * The {@link Transactor} for this checkout.
+         * @remarks In the context of a checkout, transactions allow edits to be batched into atomic units.
+         * Edits made during a transaction will update the local state of the tree immediately, but will be squashed into a single edit when the transaction is committed.
+         * If the transaction is aborted, the local state will be reset to what it was before the transaction began.
+         * Transactions may nest, meaning that a transaction may be started while a transaction is already ongoing.
+         *
+         * To avoid updating observers of the view state with intermediate results during a transaction,
+         * use {@link ITreeCheckout#branch} and {@link ISharedTreeFork#merge}.
+         */
+        _TreeCheckout_transaction.set(this, void 0);
+        // #region Commit Validation
+        /** Used to maintain the contract of {@link onCommitValid}(). */
+        _TreeCheckout_validatedCommits.set(this, new WeakMap());
+        __classPrivateFieldSet(this, _TreeCheckout_transaction, new SquashingTransactionStack(branch, (commits) => {
+            const revision = this.mintRevisionTag();
+            for (const transactionStep of commits) {
+                this.removedRoots.updateMajor(transactionStep.revision, revision);
+            }
+            const squashedChange = this.changeFamily.rebaser.compose(commits);
+            const change = this.changeFamily.rebaser.changeRevision(squashedChange, revision);
+            return tagChange(change, revision);
+        }, () => {
+            const disposeForks = this.disposeForksAfterTransaction
+                ? trackForksForDisposal(this)
+                : undefined;
+            // When each transaction is started, take a snapshot of the current state of removed roots
+            const removedRootsSnapshot = this.removedRoots.clone();
+            return (result) => {
+                switch (result) {
+                    case TransactionResult.Abort:
+                        this.removedRoots = removedRootsSnapshot;
+                        break;
+                    case TransactionResult.Commit:
+                        if (!this.transaction.isInProgress()) {
+                            // The changes in a transaction squash commit have already applied to the checkout and are known to be valid, so we can validate the squash commit automatically.
+                            this.validateCommit(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead());
+                        }
+                        break;
+                    default:
+                        unreachableCase(result);
+                }
+                disposeForks?.();
+            };
+        }), "f");
+        this.editLock = new EditLock(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEditor);
+        branch.events.on("afterChange", (event) => {
+            // The following logic allows revertibles to be generated for the change.
+            // Currently only appends (including merges and transaction commits) are supported.
+            if (event.type === "append") {
+                // TODO:#20949: When the SharedTree is detached, these commits will already have been garbage collected.
+                //       Figure out a way to generate revertibles before the commits are garbage collected.
+                for (const commit of event.newCommits) {
+                    const kind = event.type === "append" ? event.kind : CommitKind.Default;
+                    const { change, revision } = commit;
+                    const getRevertible = hasSchemaChange(change)
+                        ? undefined
+                        : (onRevertibleDisposed) => {
+                            if (!withinEventContext) {
+                                throw new UsageError("Cannot get a revertible outside of the context of a changed event.");
+                            }
+                            if (this.revertibleCommitBranches.get(revision) !== undefined) {
+                                throw new UsageError("Cannot generate the same revertible more than once. Note that this can happen when multiple changed event listeners are registered.");
+                            }
+                            const revertible = this.createRevertible(revision, kind, this, onRevertibleDisposed);
+                            this.revertibleCommitBranches.set(revision, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.fork(commit));
+                            this.revertibles.add(revertible);
+                            return revertible;
+                        };
+                    let withinEventContext = true;
+                    __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", { isLocal: true, kind }, getRevertible);
+                    withinEventContext = false;
+                }
+            }
+            else if (this.isRemoteChangeEvent(event)) {
+                // TODO: figure out how to plumb through commit kind info for remote changes
+                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", { isLocal: false, kind: CommitKind.Default });
+            }
         });
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("afterChange", this.onAfterChange);
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("ancestryTrimmed", this.onAncestryTrimmed);
     }
     withCombinedVisitor(fn) {
         const anchorVisitor = this.forest.anchors.acquireVisitor();
@@ -301,7 +300,7 @@ export class TreeCheckout {
     }
     get editor() {
         this.checkNotDisposed();
-        return this._branch.editor;
+        return this.editLock.editor;
     }
     locate(anchor) {
         this.checkNotDisposed();
@@ -312,20 +311,22 @@ export class TreeCheckout {
     }
     branch() {
         this.checkNotDisposed("The parent branch has already been disposed and can no longer create new branches.");
+        this.editLock.checkUnlocked("Branching");
         const anchors = new AnchorSet();
-        const branch = this._branch.fork();
+        const branch = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.fork();
         const storedSchema = this.storedSchema.clone();
         const forest = this.forest.clone(storedSchema, anchors);
-        const checkout = new TreeCheckout(branch, true, this.changeFamily, storedSchema, forest, createEmitter(), this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this.removedRoots.clone(), this.logger, this.breaker);
-        this.events.emit("fork", checkout);
+        const checkout = new TreeCheckout(branch, true, this.changeFamily, storedSchema, forest, this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this.removedRoots.clone(), this.logger, this.breaker, this.disposeForksAfterTransaction);
+        __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("fork", checkout);
         return checkout;
     }
     rebase(checkout) {
         this.checkNotDisposed("The target of the branch rebase has been disposed and cannot be rebased.");
         checkout.checkNotDisposed("The source of the branch rebase has been disposed and cannot be rebased.");
+        this.editLock.checkUnlocked("Rebasing");
         assert(!checkout.transaction.isInProgress(), 0x9af /* A view cannot be rebased while it has a pending transaction */);
         assert(checkout.isBranch, 0xa5d /* The main branch cannot be rebased onto another branch. */);
-        checkout._branch.rebaseOnto(this._branch);
+        __classPrivateFieldGet(checkout, _TreeCheckout_transaction, "f").activeBranch.rebaseOnto(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch);
     }
     rebaseOnto(checkout) {
         this.checkNotDisposed("The target of the branch rebase has been disposed and cannot be rebased.");
@@ -334,11 +335,12 @@ export class TreeCheckout {
     merge(checkout, disposeMerged = true) {
         this.checkNotDisposed("The target of the branch merge has been disposed and cannot be merged.");
         checkout.checkNotDisposed("The source of the branch merge has been disposed and cannot be merged.");
+        this.editLock.checkUnlocked("Merging");
         assert(!this.transaction.isInProgress(), 0x9b0 /* Views cannot be merged into a view while it has a pending transaction */);
         while (checkout.transaction.isInProgress()) {
             checkout.transaction.commit();
         }
-        this._branch.merge(checkout._branch);
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.merge(__classPrivateFieldGet(checkout, _TreeCheckout_transaction, "f").activeBranch);
         if (disposeMerged && checkout.isBranch) {
             // Dispose the merged checkout unless it is the main branch.
             checkout[disposeSymbol]();
@@ -349,18 +351,19 @@ export class TreeCheckout {
         this.editor.schema.setStoredSchema(this.storedSchema.clone(), newSchema);
     }
     dispose() {
+        this.editLock.checkUnlocked("Disposing a view");
         this[disposeSymbol]();
     }
-    [(_TreeCheckout_transaction = new WeakMap(), disposeSymbol)]() {
+    [(_TreeCheckout_events = new WeakMap(), _TreeCheckout_transaction = new WeakMap(), _TreeCheckout_validatedCommits = new WeakMap(), disposeSymbol)]() {
         this.checkNotDisposed("The branch has already been disposed and cannot be disposed again.");
         this.disposed = true;
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.dispose();
         __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").dispose();
         this.purgeRevertibles();
-        this._branch.dispose();
         for (const view of this.views) {
             view.dispose();
         }
-        this.events.emit("dispose");
+        __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("dispose");
     }
     getRemovedRoots() {
         this.assertNoUntrackedRoots();
@@ -379,11 +382,16 @@ export class TreeCheckout {
         return trees;
     }
     /**
-     * This sets the tip revision as the latest relevant revision for any removed roots that are loaded from a summary.
-     * This needs to be called right after loading {@link this.removedRoots} from a summary to allow loaded data to be garbage collected.
+     * This must be called on the root/main checkout after loading from a summary.
+     * @remarks This pattern is necessary because the EditManager skips the normal process of applying commits to branches when loading a summary.
+     * Instead, it simply {@link SharedTreeBranch#setHead | mutates} the branches directly which does not propagate the typical events throughout the rest of the system.
      */
-    setTipRevisionForLoadedData(revision) {
-        this.removedRoots.setRevisionsForLoadedData(revision);
+    load() {
+        // Set the tip revision as the latest relevant revision for any removed roots that are loaded from a summary - this allows them to be garbage collected later.
+        // When a load happens, the head of the trunk and the head of the local/main branch must be the same (this is enforced by SharedTree).
+        this.removedRoots.setRevisionsForLoadedData(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead().revision);
+        // The content of the checkout (e.g. the forest) has (maybe) changed, so fire an afterBatch event.
+        __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
     }
     purgeRevertibles() {
         for (const revertible of this.revertibles) {
@@ -404,12 +412,12 @@ export class TreeCheckout {
         const commitToRevert = revertibleBranch.getHead();
         const revisionForInvert = this.mintRevisionTag();
         let change = tagChange(this.changeFamily.rebaser.invert(commitToRevert, false, revisionForInvert), revisionForInvert);
-        const headCommit = this._branch.getHead();
+        const headCommit = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.getHead();
         // Rebase the inverted change onto any commits that occurred after the undoable commits.
         if (commitToRevert !== headCommit) {
             change = tagChange(rebaseChange(this.changeFamily.rebaser, change, commitToRevert, headCommit, this.mintRevisionTag).change, revisionForInvert);
         }
-        this._branch.apply(change, kind === CommitKind.Default || kind === CommitKind.Redo
+        __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.apply(change, kind === CommitKind.Default || kind === CommitKind.Redo
             ? CommitKind.Undo
             : CommitKind.Redo);
         // Derive some stats about the reversion to return to the caller.
@@ -447,8 +455,33 @@ export class TreeCheckout {
         !this.isBranch &&
             // Remote changes are applied to the main branch by rebasing it onto the trunk.
             // No other rebases are allowed on the main branch, so we can use this to detect remote changes.
-            event.type === "replace" &&
-            getChangeReplaceType(event) === "rebase");
+            event.type === "rebase");
+    }
+    /**
+     * Registers a function to be called when the given commit is validated.
+     * @remarks A commit is validated by the checkout after it has been applied to the checkout's state (e.g. it has an effect on the forest).
+     * If the commit applies successfully (i.e. it does not raise any unexpected errors), the commit is considered valid and the registered function is called.
+     * If the commit does not apply successfully (because it causes an unexpected error), the function is not called (and the checkout will left in an error state).
+     *
+     * If the commit has already been validated when this function is called, the function is called immediately and this function returns `true`.
+     * Otherwise, the function is registered to be called later and this function returns `false`.
+     */
+    onCommitValid(commit, fn) {
+        const validated = getOrCreate(__classPrivateFieldGet(this, _TreeCheckout_validatedCommits, "f"), commit, () => []);
+        if (validated === true) {
+            fn(commit);
+            return true;
+        }
+        validated.push(fn);
+        return false;
+    }
+    /** Mark the given commit as "validated" according to the contract of {@link onCommitValid}(). */
+    validateCommit(commit) {
+        const validated = getOrCreate(__classPrivateFieldGet(this, _TreeCheckout_validatedCommits, "f"), commit, () => []);
+        if (validated !== true) {
+            validated.forEach((fn) => fn(commit));
+            __classPrivateFieldGet(this, _TreeCheckout_validatedCommits, "f").set(commit, true);
+        }
     }
 }
 /**
@@ -456,4 +489,118 @@ export class TreeCheckout {
  * @privateRemarks Exposed for testing purposes.
  */
 TreeCheckout.revertTelemetryEventName = "RevertRevertible";
+/**
+ * A helper class that assists {@link TreeCheckout} in preventing functionality from being used while the tree is in the middle of being edited.
+ */
+class EditLock {
+    /**
+     * @param editor - an editor which will be used to create a new editor that is monitored to determine if any changes are happening to the tree.
+     * Use {@link EditLock.editor} in place of the original editor to ensure that changes are monitored.
+     */
+    constructor(editor) {
+        this.locked = false;
+        const checkLock = () => this.checkUnlocked("Editing the tree");
+        this.editor = {
+            get schema() {
+                return editor.schema;
+            },
+            valueField(...fieldArgs) {
+                const valueField = editor.valueField(...fieldArgs);
+                return {
+                    set(...editArgs) {
+                        checkLock();
+                        valueField.set(...editArgs);
+                    },
+                };
+            },
+            optionalField(...fieldArgs) {
+                const optionalField = editor.optionalField(...fieldArgs);
+                return {
+                    set(...editArgs) {
+                        checkLock();
+                        optionalField.set(...editArgs);
+                    },
+                };
+            },
+            sequenceField(...fieldArgs) {
+                const sequenceField = editor.sequenceField(...fieldArgs);
+                return {
+                    insert(...editArgs) {
+                        checkLock();
+                        sequenceField.insert(...editArgs);
+                    },
+                    remove(...editArgs) {
+                        checkLock();
+                        sequenceField.remove(...editArgs);
+                    },
+                };
+            },
+            move(...moveArgs) {
+                checkLock();
+                editor.move(...moveArgs);
+            },
+            addNodeExistsConstraint(path) {
+                editor.addNodeExistsConstraint(path);
+            },
+            addNodeExistsConstraintOnRevert(path) {
+                editor.addNodeExistsConstraintOnRevert(path);
+            },
+        };
+    }
+    /**
+     * Prevent further changes from being made to {@link EditLock.editor} until {@link EditLock.unlock} is called.
+     * @remarks May only be called when the lock is not already locked.
+     */
+    lock() {
+        if (this.locked) {
+            debugger;
+        }
+        assert(!this.locked, 0xaa7 /* Checkout has already been locked */);
+        this.locked = true;
+    }
+    /**
+     * Throws an error if the lock is currently locked.
+     * @param action - The current action being performed by the user.
+     * This must start with a capital letter, as it shows up as the first part of the error message and we want it to look nice.
+     */
+    checkUnlocked(action) {
+        if (this.locked) {
+            // These type assertions ensure that the event name strings used here match the actual event names
+            const nodeChanged = "nodeChanged";
+            const treeChanged = "treeChanged";
+            throw new UsageError(`${action} is forbidden during a ${nodeChanged} or ${treeChanged} event`);
+        }
+    }
+    /**
+     * Allow changes to be made to {@link EditLock.editor} again.
+     * @remarks May only be called when the lock is currently locked.
+     */
+    unlock() {
+        assert(this.locked, 0xaa8 /* Checkout has not been locked */);
+        this.locked = false;
+    }
+}
+/**
+ * Keeps track of all new forks created until the returned function is invoked, which will dispose all of those for.
+ * The returned function may only be called once.
+ *
+ * @param checkout - The tree checkout for which you want to monitor forks for disposal.
+ * @returns a function which can be called to dispose all of the tracked forks.
+ */
+function trackForksForDisposal(checkout) {
+    const forks = new Set();
+    const onDisposeUnSubscribes = [];
+    const onForkUnSubscribe = onForkTransitive(checkout, (fork) => {
+        forks.add(fork);
+        onDisposeUnSubscribes.push(fork.events.on("dispose", () => forks.delete(fork)));
+    });
+    let disposed = false;
+    return () => {
+        assert(!disposed, 0xaa9 /* Forks may only be disposed once */);
+        forks.forEach((fork) => fork.dispose());
+        onDisposeUnSubscribes.forEach((unsubscribe) => unsubscribe());
+        onForkUnSubscribe();
+        disposed = true;
+    };
+}
 //# sourceMappingURL=treeCheckout.js.map