@fluidframework/tree 2.114.0 → 2.116.0-416006

package/lib/shared-tree/treeCheckout.js

@@ -7,14 +7,14 @@ import { createEmitter } from "@fluid-internal/client-utils";
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { FluidClientVersion, FormatValidatorNoOp, } from "../codec/index.js";
-import { CommitKind, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, diffHistories, makeAnonChange, deltaFieldMapHasVisibleChanges, findCommonAncestor, rebaseBranch, } from "../core/index.js";
+import { CommitKind, CommitOutcome, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, diffHistories, makeAnonChange, deltaFieldMapHasVisibleChanges, findCommonAncestor, rebaseBranch, } from "../core/index.js";
 import { allowsRepoSuperset, buildForest, createNodeIdentifierManager, defaultSchemaPolicy, fieldBatchCodecBuilder, TreeStatus, intoDelta, jsonableTreeFromCursor, } from "../feature-libraries/index.js";
 import { SquashingTransactionStack, SharedTreeBranch, TransactionResult as InternalTransactionResult, } from "../shared-tree-core/index.js";
 import { getInnerNode, getKernel, customFromCursorStored, } from "../simple-tree/index.js";
 import { Breakable, breakingMethod, disposeSymbol, getOrCreate, hasSome, throwIfBroken, } from "../util/index.js";
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import { SharedTreeChangeEnricher } from "./sharedTreeChangeEnricher.js";
-import { SharedTreeChangeFamily, hasSchemaChange } from "./sharedTreeChangeFamily.js";
+import { ConstraintStatus, SharedTreeChangeFamily, getConstraintStatus, hasSchemaChange, } from "./sharedTreeChangeFamily.js";
 import { extractTransactionChangeProcessor } from "./transactionPostProcessor.js";
 import { SerializedChange } from "./serializedChange.js";
 /**
@@ -191,6 +191,10 @@ let TreeCheckout = (() => {
                 this.disposeForksAfterTransaction = disposeForksAfterTransaction;
                 this.disposed = false;
                 this.views = new Set();
+                /**
+                 * Event emitters for local commits.
+                 */
+                this.localCommitEventEmitters = new Map();
                 /**
                  * Revertibles maintained for automatic disposal
                  */
@@ -203,6 +207,38 @@ let TreeCheckout = (() => {
                 this.revertibleCommitBranches = new Map();
                 _TreeCheckout_events.set(this, createEmitter());
                 this.events = __classPrivateFieldGet(this, _TreeCheckout_events, "f");
+                this.onCommitSequenced = (commit) => {
+                    const emitter = this.localCommitEventEmitters.get(commit.revision);
+                    if (emitter === undefined) {
+                        // If the commit predates the creation of this checkout, there will be no emitter associated with the commit.
+                        // In that case, we don't need to emit any events.
+                        return;
+                    }
+                    const constraintStatus = getConstraintStatus(commit.change);
+                    let outcome;
+                    switch (constraintStatus) {
+                        case ConstraintStatus.Satisfied: {
+                            outcome = CommitOutcome.FullyApplied;
+                            break;
+                        }
+                        case ConstraintStatus.ImplicitViolation: {
+                            outcome = CommitOutcome.FullyDropped;
+                            break;
+                        }
+                        case ConstraintStatus.ExplicitViolation: {
+                            outcome = CommitOutcome.NewContentOnly;
+                            break;
+                        }
+                        default: {
+                            unreachableCase(constraintStatus);
+                        }
+                    }
+                    this.emitChangedLocked(() => {
+                        emitter.emit("settled", outcome);
+                    }, "a commit settled event callback");
+                    // No more events will be emitted for this commit, so we can remove the emitter from the map.
+                    this.localCommitEventEmitters.delete(commit.revision);
+                };
                 this.onAfterBranchChange = (event) => {
                     // The following logic allows revertibles to be generated for the change.
                     // Currently only appends (including merges and transaction commits) are supported.
@@ -231,6 +267,8 @@ let TreeCheckout = (() => {
                                     return revertible;
                                 };
                             let withinEventContext = true;
+                            const events = createEmitter();
+                            this.localCommitEventEmitters.set(commit.revision, events);
                             const metadata = {
                                 kind,
                                 isLocal: true,
@@ -241,6 +279,7 @@ let TreeCheckout = (() => {
                                 getRevertible: (onDisposed) => getRevertible?.(onDisposed),
                                 label: this.labelTreeNode?.label,
                                 labels: buildLabelsSet(this.labelTreeNode),
+                                events,
                             };
                             this.emitChangedLocked(() => {
                                 __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", metadata, getRevertible);
@@ -266,7 +305,7 @@ let TreeCheckout = (() => {
                     }
                 };
                 this.onAfterChange = (event) => {
-                    this.editLock.lock();
+                    this.editLock.lock("a change event callback");
                     __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("beforeBatch", event);
                     if (event.change !== undefined) {
                         const revision = event.type === "rebase"
@@ -429,11 +468,13 @@ let TreeCheckout = (() => {
             }
             registerForBranchEvents() {
                 __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.on("afterChange", this.onAfterBranchChange);
+                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.on("commitSequenced", this.onCommitSequenced);
                 __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("afterChange", this.onAfterChange);
                 __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("ancestryTrimmed", this.onAncestryTrimmed);
             }
             unregisterFromBranchEvents() {
                 __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.off("afterChange", this.onAfterBranchChange);
+                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.off("commitSequenced", this.onCommitSequenced);
                 __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.off("afterChange", this.onAfterChange);
                 __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.off("ancestryTrimmed", this.onAncestryTrimmed);
             }
@@ -497,8 +538,8 @@ let TreeCheckout = (() => {
              * Shared by both the local and remote `changed` emission paths in {@link TreeCheckout.onAfterBranchChange}.
              * The `try`/`finally` ensures the lock is released even if a listener throws.
              */
-            emitChangedLocked(emit) {
-                this.editLock.lock();
+            emitChangedLocked(emit, reason = "a change event callback") {
+                this.editLock.lock(reason);
                 try {
                     emit();
                 }
@@ -1016,7 +1057,11 @@ class EditLock {
      * Use {@link EditLock.editor} in place of the original editor to ensure that changes are monitored.
      */
     constructor(editor) {
-        this.locked = false;
+        /**
+         * The current status of the lock.
+         * The `reason` string will be included in the error message if an attempt is made to edit the tree while the lock is held.
+         */
+        this.status = { isLocked: false };
         const checkLock = () => this.checkUnlocked("Editing the tree");
         this.editor = {
             get schema() {
@@ -1073,14 +1118,15 @@ class EditLock {
     }
     /**
      * Prevent further changes from being made to {@link EditLock.editor} until {@link EditLock.unlock} is called.
+     * @param reason - A string describing why the lock is being acquired. This will be included in the error message if an attempt is made to edit while the lock is held.
      * @remarks May only be called when the lock is not already locked.
      */
-    lock() {
-        if (this.locked) {
+    lock(reason) {
+        if (this.status.isLocked) {
             debugger;
         }
-        assert(!this.locked, 0xaa7 /* Checkout has already been locked */);
-        this.locked = true;
+        assert(!this.status.isLocked, 0xaa7 /* Checkout has already been locked */);
+        this.status = { isLocked: true, reason };
     }
     /**
      * Throws an error if the lock is currently locked.
@@ -1088,8 +1134,8 @@ class EditLock {
      * 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) {
-            throw new UsageError(`${action} is forbidden during a change event callback`);
+        if (this.status.isLocked) {
+            throw new UsageError(`${action} is forbidden during ${this.status.reason}`);
         }
     }
     /**
@@ -1097,8 +1143,8 @@ class EditLock {
      * @remarks May only be called when the lock is currently locked.
      */
     unlock() {
-        assert(this.locked, 0xaa8 /* Checkout has not been locked */);
-        this.locked = false;
+        assert(this.status.isLocked, 0xaa8 /* Checkout has not been locked */);
+        this.status = { isLocked: false };
     }
 }
 function verboseFromCursor(reader, schema) {