@fluidframework/tree 2.80.0 → 2.81.0

package/dist/shared-tree/sharedTreeChangeEnricher.d.ts

@@ -2,16 +2,31 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { type DetachedFieldIndex, type IEditableForest, type IForestSubscription, type ReadOnlyDetachedFieldIndex, type RevisionTag, type TreeStoredSchemaRepository } from "../core/index.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
+import { type DetachedFieldIndex, type IEditableForest, type IForestSubscription, type ReadOnlyDetachedFieldIndex, type TaggedChange, type TreeStoredSchemaRepository } from "../core/index.js";
 import { disposeSymbol } from "../util/index.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import type { ChangeEnricherMutableCheckout, ChangeEnricherReadonlyCheckout } from "../shared-tree-core/index.js";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
-export declare class SharedTreeReadonlyChangeEnricher implements ChangeEnricherReadonlyCheckout<SharedTreeChange> {
-    protected readonly borrowedForest: IForestSubscription;
+interface BorrowedState {
+    readonly forest: IForestSubscription;
+    readonly removedRoots: ReadOnlyDetachedFieldIndex;
+}
+interface OwnedState {
+    readonly forest: IEditableForest;
+    readonly removedRoots: DetachedFieldIndex;
+}
+export declare class SharedTreeChangeEnricher {
     private readonly schema;
-    protected readonly borrowedRemovedRoots: ReadOnlyDetachedFieldIndex;
     private readonly idCompressor?;
+    private readonly onEnrichCommit?;
+    private readonly onRefresherAdded?;
+    private readonly onForkState?;
+    private readonly onApplyChange?;
+    /**
+     * Queue of changes to be applied before querying for detached roots.
+     */
+    private readonly changeQueue;
+    protected readonly borrowed: BorrowedState;
+    protected owned?: OwnedState;
     /**
      * @param borrowedForest - The state based on which to enrich changes.
      * Not owned by the constructed instance.
@@ -19,25 +34,17 @@ export declare class SharedTreeReadonlyChangeEnricher implements ChangeEnricherR
      * @param borrowedRemovedRoots - The set of removed roots based on which to enrich changes.
      * Not owned by the constructed instance.
      * @param idCompressor - The id compressor to use when chunking trees.
+     * @param onEnrichCommit - Optional callback invoked whenever a commit is enriched.
+     * @param onRefresherAdded - Optional callback invoked whenever a refresher is added during enrichment.
+     * @param onForkState - Optional callback invoked whenever the enricher forks its state.
+     * @param onApplyChange - Optional callback invoked whenever a change is applied to the owned state.
      */
-    constructor(borrowedForest: IForestSubscription, schema: TreeStoredSchemaRepository, borrowedRemovedRoots: ReadOnlyDetachedFieldIndex, idCompressor?: IIdCompressor | undefined);
-    fork(): ChangeEnricherMutableCheckout<SharedTreeChange>;
-    updateChangeEnrichments(change: SharedTreeChange): SharedTreeChange;
-    private readonly getDetachedRoot;
-}
-export declare class SharedTreeMutableChangeEnricher extends SharedTreeReadonlyChangeEnricher implements ChangeEnricherMutableCheckout<SharedTreeChange> {
-    private readonly forest;
-    private readonly removedRoots;
-    /**
-     * @param forest - The state based on which to enrich changes.
-     * Owned by the constructed instance.
-     * @param schema - The schema that corresponds to the forest.
-     * @param removedRoots - The set of removed roots based on which to enrich changes.
-     * Owned by the constructed instance.
-     * @param idCompressor - The id compressor to use when chunking trees.
-     */
-    constructor(forest: IEditableForest, schema: TreeStoredSchemaRepository, removedRoots: DetachedFieldIndex, idCompressor?: IIdCompressor);
-    applyTipChange(change: SharedTreeChange, revision?: RevisionTag): void;
+    constructor(borrowedForest: IForestSubscription, borrowedRemovedRoots: ReadOnlyDetachedFieldIndex, schema: TreeStoredSchemaRepository, idCompressor?: IIdCompressor | undefined, onEnrichCommit?: (() => void) | undefined, onRefresherAdded?: (() => void) | undefined, onForkState?: (() => void) | undefined, onApplyChange?: (() => void) | undefined);
+    enrich(change: SharedTreeChange): SharedTreeChange;
+    private getDetachedRoot;
+    enqueueChange(change: TaggedChange<SharedTreeChange> | (() => TaggedChange<SharedTreeChange>)): void;
+    private purgeChangeQueue;
     [disposeSymbol](): void;
 }
+export {};
 //# sourceMappingURL=sharedTreeChangeEnricher.d.ts.map

package/dist/shared-tree/sharedTreeChangeEnricher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sharedTreeChangeEnricher.d.ts","sourceRoot":"","sources":["../../src/shared-tree/sharedTreeChangeEnricher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAGN,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,WAAW,EAChB,KAAK,0BAA0B,EAG/B,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EACX,6BAA6B,EAC7B,8BAA8B,EAC9B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,qBAAa,gCACZ,YAAW,8BAA8B,CAAC,gBAAgB,CAAC;IAW1D,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,mBAAmB;IACtD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,SAAS,CAAC,QAAQ,CAAC,oBAAoB,EAAE,0BAA0B;IACnE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IAZ/B;;;;;;;OAOG;gBAEiB,cAAc,EAAE,mBAAmB,EACrC,MAAM,EAAE,0BAA0B,EAChC,oBAAoB,EAAE,0BAA0B,EAClD,YAAY,CAAC,2BAAe;IAGvC,IAAI,IAAI,6BAA6B,CAAC,gBAAgB,CAAC;IAQvD,uBAAuB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB;IAS1E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAa9B;CACF;AAED,qBAAa,+BACZ,SAAQ,gCACR,YAAW,6BAA6B,CAAC,gBAAgB,CAAC;IAWzD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAX9B;;;;;;;OAOG;gBAEe,MAAM,EAAE,eAAe,EACxC,MAAM,EAAE,0BAA0B,EACjB,YAAY,EAAE,kBAAkB,EACjD,YAAY,CAAC,EAAE,aAAa;IAKtB,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAyBtE,CAAC,aAAa,CAAC,IAAI,IAAI;CAG9B"}
+{"version":3,"file":"sharedTreeChangeEnricher.d.ts","sourceRoot":"","sources":["../../src/shared-tree/sharedTreeChangeEnricher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EAGN,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAG/B,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,UAAU,aAAa;IACtB,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,YAAY,EAAE,0BAA0B,CAAC;CAClD;AAED,UAAU,UAAU;IACnB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;CAC1C;AAED,qBAAa,wBAAwB;IAuBnC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IAC9B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IA3BhC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgD;IAC5E,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IAC3C,SAAS,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAE7B;;;;;;;;;;;OAWG;gBAEF,cAAc,EAAE,mBAAmB,EACnC,oBAAoB,EAAE,0BAA0B,EAC/B,MAAM,EAAE,0BAA0B,EAClC,YAAY,CAAC,2BAAe,EAC5B,cAAc,CAAC,SAAQ,IAAI,aAAA,EAC3B,gBAAgB,CAAC,SAAQ,IAAI,aAAA,EAC7B,WAAW,CAAC,SAAQ,IAAI,aAAA,EACxB,aAAa,CAAC,SAAQ,IAAI,aAAA;IAQrC,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB;IAUzD,OAAO,CAAC,eAAe;IAkBhB,aAAa,CACnB,MAAM,EAAE,YAAY,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,YAAY,CAAC,gBAAgB,CAAC,CAAC,GAC7E,IAAI;IAIP,OAAO,CAAC,gBAAgB;IAwCjB,CAAC,aAAa,CAAC,IAAI,IAAI;CAG9B"}

package/dist/shared-tree/sharedTreeChangeEnricher.js

@@ -4,13 +4,13 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedTreeMutableChangeEnricher = exports.SharedTreeReadonlyChangeEnricher = void 0;
+exports.SharedTreeChangeEnricher = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../core/index.js");
 const index_js_2 = require("../feature-libraries/index.js");
 const index_js_3 = require("../util/index.js");
 const sharedTreeChangeFamily_js_1 = require("./sharedTreeChangeFamily.js");
-class SharedTreeReadonlyChangeEnricher {
+class SharedTreeChangeEnricher {
     /**
      * @param borrowedForest - The state based on which to enrich changes.
      * Not owned by the constructed instance.
@@ -18,76 +18,93 @@ class SharedTreeReadonlyChangeEnricher {
      * @param borrowedRemovedRoots - The set of removed roots based on which to enrich changes.
      * Not owned by the constructed instance.
      * @param idCompressor - The id compressor to use when chunking trees.
+     * @param onEnrichCommit - Optional callback invoked whenever a commit is enriched.
+     * @param onRefresherAdded - Optional callback invoked whenever a refresher is added during enrichment.
+     * @param onForkState - Optional callback invoked whenever the enricher forks its state.
+     * @param onApplyChange - Optional callback invoked whenever a change is applied to the owned state.
      */
-    constructor(borrowedForest, schema, borrowedRemovedRoots, idCompressor) {
-        this.borrowedForest = borrowedForest;
+    constructor(borrowedForest, borrowedRemovedRoots, schema, idCompressor, onEnrichCommit, onRefresherAdded, onForkState, onApplyChange) {
         this.schema = schema;
-        this.borrowedRemovedRoots = borrowedRemovedRoots;
         this.idCompressor = idCompressor;
-        this.getDetachedRoot = (id) => {
-            const root = this.borrowedRemovedRoots.tryGetEntry(id);
-            if (root !== undefined) {
-                const cursor = this.borrowedForest.getCursorAboveDetachedFields();
-                const parentField = this.borrowedRemovedRoots.toFieldKey(root);
-                cursor.enterField(parentField);
-                cursor.enterNode(0);
-                return (0, index_js_2.chunkTree)(cursor, {
-                    policy: index_js_2.defaultChunkPolicy,
-                    idCompressor: this.idCompressor,
-                });
-            }
-            return undefined;
+        this.onEnrichCommit = onEnrichCommit;
+        this.onRefresherAdded = onRefresherAdded;
+        this.onForkState = onForkState;
+        this.onApplyChange = onApplyChange;
+        /**
+         * Queue of changes to be applied before querying for detached roots.
+         */
+        this.changeQueue = [];
+        this.borrowed = {
+            forest: borrowedForest,
+            removedRoots: borrowedRemovedRoots,
         };
     }
-    fork() {
-        return new SharedTreeMutableChangeEnricher(this.borrowedForest.clone(this.schema, new index_js_1.AnchorSet()), this.schema, this.borrowedRemovedRoots.clone());
+    enrich(change) {
+        this.onEnrichCommit?.();
+        return (0, sharedTreeChangeFamily_js_1.updateRefreshers)(change, (id) => this.getDetachedRoot(id), index_js_2.relevantRemovedRoots, index_js_2.updateRefreshers);
     }
-    updateChangeEnrichments(change) {
-        return (0, sharedTreeChangeFamily_js_1.updateRefreshers)(change, this.getDetachedRoot, index_js_2.relevantRemovedRoots, index_js_2.updateRefreshers);
+    getDetachedRoot(id) {
+        this.purgeChangeQueue();
+        const state = this.owned ?? this.borrowed;
+        const root = state.removedRoots.tryGetEntry(id);
+        if (root !== undefined) {
+            const cursor = state.forest.getCursorAboveDetachedFields();
+            const parentField = state.removedRoots.toFieldKey(root);
+            cursor.enterField(parentField);
+            cursor.enterNode(0);
+            this.onRefresherAdded?.();
+            return (0, index_js_2.chunkTree)(cursor, {
+                policy: index_js_2.defaultChunkPolicy,
+                idCompressor: this.idCompressor,
+            });
+        }
+        return undefined;
     }
-}
-exports.SharedTreeReadonlyChangeEnricher = SharedTreeReadonlyChangeEnricher;
-class SharedTreeMutableChangeEnricher extends SharedTreeReadonlyChangeEnricher {
-    /**
-     * @param forest - The state based on which to enrich changes.
-     * Owned by the constructed instance.
-     * @param schema - The schema that corresponds to the forest.
-     * @param removedRoots - The set of removed roots based on which to enrich changes.
-     * Owned by the constructed instance.
-     * @param idCompressor - The id compressor to use when chunking trees.
-     */
-    constructor(forest, schema, removedRoots, idCompressor) {
-        super(forest, schema, removedRoots, idCompressor);
-        this.forest = forest;
-        this.removedRoots = removedRoots;
+    enqueueChange(change) {
+        this.changeQueue.push(typeof change === "function" ? change : () => change);
     }
-    applyTipChange(change, revision) {
-        for (const dataOrSchemaChange of change.changes) {
-            const type = dataOrSchemaChange.type;
-            switch (type) {
-                case "data": {
-                    const delta = (0, index_js_2.intoDelta)((0, index_js_1.tagChange)(dataOrSchemaChange.innerChange, revision));
-                    const visitor = this.forest.acquireVisitor();
-                    (0, index_js_1.visitDelta)(delta, visitor, this.removedRoots, revision);
-                    visitor.free();
-                    break;
-                }
-                case "schema": {
-                    // This enricher doesn't need to maintain schema information.
-                    // Note that the refreshers being generated through `updateChangeEnrichments` will be encoded using
-                    // the schema that was used in the input context of the data changeset these refreshers are on.
-                    // See the encoding logic in SharedTreeCore for details.
-                    break;
-                }
-                default: {
-                    (0, internal_1.unreachableCase)(type);
+    purgeChangeQueue() {
+        if (this.changeQueue.length === 0) {
+            return;
+        }
+        if (this.owned === undefined) {
+            this.onForkState?.();
+            this.owned = {
+                forest: this.borrowed.forest.clone(this.schema, new index_js_1.AnchorSet()),
+                removedRoots: this.borrowed.removedRoots.clone(),
+            };
+        }
+        for (const getChange of this.changeQueue) {
+            const { change, revision } = getChange();
+            this.onApplyChange?.();
+            for (const dataOrSchemaChange of change.changes) {
+                const type = dataOrSchemaChange.type;
+                switch (type) {
+                    case "data": {
+                        const delta = (0, index_js_2.intoDelta)((0, index_js_1.tagChange)(dataOrSchemaChange.innerChange, revision));
+                        const visitor = this.owned.forest.acquireVisitor();
+                        (0, index_js_1.visitDelta)(delta, visitor, this.owned.removedRoots, revision);
+                        visitor.free();
+                        break;
+                    }
+                    case "schema": {
+                        // This enricher doesn't need to maintain schema information.
+                        // Note that the refreshers being generated through `updateChangeEnrichments` will be encoded using
+                        // the schema that was used in the input context of the data changeset these refreshers are on.
+                        // See the encoding logic in SharedTreeCore for details.
+                        break;
+                    }
+                    default: {
+                        (0, internal_1.unreachableCase)(type);
+                    }
                 }
             }
         }
+        this.changeQueue.length = 0;
     }
     [index_js_3.disposeSymbol]() {
         // TODO: in the future, forest and/or its AnchorSet may require disposal.
     }
 }
-exports.SharedTreeMutableChangeEnricher = SharedTreeMutableChangeEnricher;
+exports.SharedTreeChangeEnricher = SharedTreeChangeEnricher;
 //# sourceMappingURL=sharedTreeChangeEnricher.js.map

package/dist/shared-tree/sharedTreeChangeEnricher.js.map

@@ -1 +1 @@
-{"version":3,"file":"sharedTreeChangeEnricher.js","sourceRoot":"","sources":["../../src/shared-tree/sharedTreeChangeEnricher.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAAsE;AACtE,+CAW0B;AAC1B,4DAOuC;AACvC,+CAAiD;AACjD,2EAA+D;AAQ/D,MAAa,gCAAgC;IAG5C;;;;;;;OAOG;IACH,YACoB,cAAmC,EACrC,MAAkC,EAChC,oBAAgD,EAClD,YAA4B;QAH1B,mBAAc,GAAd,cAAc,CAAqB;QACrC,WAAM,GAAN,MAAM,CAA4B;QAChC,yBAAoB,GAApB,oBAAoB,CAA4B;QAClD,iBAAY,GAAZ,YAAY,CAAgB;QAoB7B,oBAAe,GAAG,CAAC,EAAuB,EAAyB,EAAE;YACrF,MAAM,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;YACvD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,4BAA4B,EAAE,CAAC;gBAClE,MAAM,WAAW,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBAC/D,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;gBAC/B,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;gBACpB,OAAO,IAAA,oBAAS,EAAC,MAAM,EAAE;oBACxB,MAAM,EAAE,6BAAkB;oBAC1B,YAAY,EAAE,IAAI,CAAC,YAAY;iBAC/B,CAAC,CAAC;YACJ,CAAC;YACD,OAAO,SAAS,CAAC;QAClB,CAAC,CAAC;IAhCC,CAAC;IAEG,IAAI;QACV,OAAO,IAAI,+BAA+B,CACzC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,oBAAS,EAAE,CAAC,EACvD,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,CACjC,CAAC;IACH,CAAC;IAEM,uBAAuB,CAAC,MAAwB;QACtD,OAAO,IAAA,4CAAgB,EACtB,MAAM,EACN,IAAI,CAAC,eAAe,EACpB,+BAAoB,EACpB,2BAA0B,CAC1B,CAAC;IACH,CAAC;CAgBD;AAjDD,4EAiDC;AAED,MAAa,+BACZ,SAAQ,gCAAgC;IAGxC;;;;;;;OAOG;IACH,YACkB,MAAuB,EACxC,MAAkC,EACjB,YAAgC,EACjD,YAA4B;QAE5B,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;QALjC,WAAM,GAAN,MAAM,CAAiB;QAEvB,iBAAY,GAAZ,YAAY,CAAoB;IAIlD,CAAC;IAEM,cAAc,CAAC,MAAwB,EAAE,QAAsB;QACrE,KAAK,MAAM,kBAAkB,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACjD,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,CAAC;YACrC,QAAQ,IAAI,EAAE,CAAC;gBACd,KAAK,MAAM,CAAC,CAAC,CAAC;oBACb,MAAM,KAAK,GAAG,IAAA,oBAAS,EAAC,IAAA,oBAAS,EAAC,kBAAkB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;oBAC7E,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;oBAC7C,IAAA,qBAAU,EAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;oBACxD,OAAO,CAAC,IAAI,EAAE,CAAC;oBACf,MAAM;gBACP,CAAC;gBACD,KAAK,QAAQ,CAAC,CAAC,CAAC;oBACf,6DAA6D;oBAC7D,mGAAmG;oBACnG,+FAA+F;oBAC/F,wDAAwD;oBACxD,MAAM;gBACP,CAAC;gBACD,OAAO,CAAC,CAAC,CAAC;oBACT,IAAA,0BAAe,EAAC,IAAI,CAAC,CAAC;gBACvB,CAAC;YACF,CAAC;QACF,CAAC;IACF,CAAC;IAEM,CAAC,wBAAa,CAAC;QACrB,yEAAyE;IAC1E,CAAC;CACD;AAjDD,0EAiDC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport {\n\tAnchorSet,\n\ttype DeltaDetachedNodeId,\n\ttype DetachedFieldIndex,\n\ttype IEditableForest,\n\ttype IForestSubscription,\n\ttype ReadOnlyDetachedFieldIndex,\n\ttype RevisionTag,\n\ttype TreeStoredSchemaRepository,\n\ttagChange,\n\tvisitDelta,\n} from \"../core/index.js\";\nimport {\n\ttype TreeChunk,\n\tchunkTree,\n\tdefaultChunkPolicy,\n\tintoDelta,\n\trelevantRemovedRoots,\n\tupdateRefreshers as updateDataChangeRefreshers,\n} from \"../feature-libraries/index.js\";\nimport { disposeSymbol } from \"../util/index.js\";\nimport { updateRefreshers } from \"./sharedTreeChangeFamily.js\";\nimport type { SharedTreeChange } from \"./sharedTreeChangeTypes.js\";\nimport type {\n\tChangeEnricherMutableCheckout,\n\tChangeEnricherReadonlyCheckout,\n} from \"../shared-tree-core/index.js\";\nimport type { IIdCompressor } from \"@fluidframework/id-compressor\";\n\nexport class SharedTreeReadonlyChangeEnricher\n\timplements ChangeEnricherReadonlyCheckout<SharedTreeChange>\n{\n\t/**\n\t * @param borrowedForest - The state based on which to enrich changes.\n\t * Not owned by the constructed instance.\n\t * @param schema - The schema that corresponds to the forest.\n\t * @param borrowedRemovedRoots - The set of removed roots based on which to enrich changes.\n\t * Not owned by the constructed instance.\n\t * @param idCompressor - The id compressor to use when chunking trees.\n\t */\n\tpublic constructor(\n\t\tprotected readonly borrowedForest: IForestSubscription,\n\t\tprivate readonly schema: TreeStoredSchemaRepository,\n\t\tprotected readonly borrowedRemovedRoots: ReadOnlyDetachedFieldIndex,\n\t\tprivate readonly idCompressor?: IIdCompressor,\n\t) {}\n\n\tpublic fork(): ChangeEnricherMutableCheckout<SharedTreeChange> {\n\t\treturn new SharedTreeMutableChangeEnricher(\n\t\t\tthis.borrowedForest.clone(this.schema, new AnchorSet()),\n\t\t\tthis.schema,\n\t\t\tthis.borrowedRemovedRoots.clone(),\n\t\t);\n\t}\n\n\tpublic updateChangeEnrichments(change: SharedTreeChange): SharedTreeChange {\n\t\treturn updateRefreshers(\n\t\t\tchange,\n\t\t\tthis.getDetachedRoot,\n\t\t\trelevantRemovedRoots,\n\t\t\tupdateDataChangeRefreshers,\n\t\t);\n\t}\n\n\tprivate readonly getDetachedRoot = (id: DeltaDetachedNodeId): TreeChunk | undefined => {\n\t\tconst root = this.borrowedRemovedRoots.tryGetEntry(id);\n\t\tif (root !== undefined) {\n\t\t\tconst cursor = this.borrowedForest.getCursorAboveDetachedFields();\n\t\t\tconst parentField = this.borrowedRemovedRoots.toFieldKey(root);\n\t\t\tcursor.enterField(parentField);\n\t\t\tcursor.enterNode(0);\n\t\t\treturn chunkTree(cursor, {\n\t\t\t\tpolicy: defaultChunkPolicy,\n\t\t\t\tidCompressor: this.idCompressor,\n\t\t\t});\n\t\t}\n\t\treturn undefined;\n\t};\n}\n\nexport class SharedTreeMutableChangeEnricher\n\textends SharedTreeReadonlyChangeEnricher\n\timplements ChangeEnricherMutableCheckout<SharedTreeChange>\n{\n\t/**\n\t * @param forest - The state based on which to enrich changes.\n\t * Owned by the constructed instance.\n\t * @param schema - The schema that corresponds to the forest.\n\t * @param removedRoots - The set of removed roots based on which to enrich changes.\n\t * Owned by the constructed instance.\n\t * @param idCompressor - The id compressor to use when chunking trees.\n\t */\n\tpublic constructor(\n\t\tprivate readonly forest: IEditableForest,\n\t\tschema: TreeStoredSchemaRepository,\n\t\tprivate readonly removedRoots: DetachedFieldIndex,\n\t\tidCompressor?: IIdCompressor,\n\t) {\n\t\tsuper(forest, schema, removedRoots, idCompressor);\n\t}\n\n\tpublic applyTipChange(change: SharedTreeChange, revision?: RevisionTag): void {\n\t\tfor (const dataOrSchemaChange of change.changes) {\n\t\t\tconst type = dataOrSchemaChange.type;\n\t\t\tswitch (type) {\n\t\t\t\tcase \"data\": {\n\t\t\t\t\tconst delta = intoDelta(tagChange(dataOrSchemaChange.innerChange, revision));\n\t\t\t\t\tconst visitor = this.forest.acquireVisitor();\n\t\t\t\t\tvisitDelta(delta, visitor, this.removedRoots, revision);\n\t\t\t\t\tvisitor.free();\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tcase \"schema\": {\n\t\t\t\t\t// This enricher doesn't need to maintain schema information.\n\t\t\t\t\t// Note that the refreshers being generated through `updateChangeEnrichments` will be encoded using\n\t\t\t\t\t// the schema that was used in the input context of the data changeset these refreshers are on.\n\t\t\t\t\t// See the encoding logic in SharedTreeCore for details.\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tdefault: {\n\t\t\t\t\tunreachableCase(type);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic [disposeSymbol](): void {\n\t\t// TODO: in the future, forest and/or its AnchorSet may require disposal.\n\t}\n}\n"]}
+{"version":3,"file":"sharedTreeChangeEnricher.js","sourceRoot":"","sources":["../../src/shared-tree/sharedTreeChangeEnricher.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport type { IIdCompressor } from \"@fluidframework/id-compressor\";\n\nimport {\n\tAnchorSet,\n\ttype DeltaDetachedNodeId,\n\ttype DetachedFieldIndex,\n\ttype IEditableForest,\n\ttype IForestSubscription,\n\ttype ReadOnlyDetachedFieldIndex,\n\ttype TaggedChange,\n\ttype TreeStoredSchemaRepository,\n\ttagChange,\n\tvisitDelta,\n} from \"../core/index.js\";\nimport {\n\ttype TreeChunk,\n\tchunkTree,\n\tdefaultChunkPolicy,\n\tintoDelta,\n\trelevantRemovedRoots,\n\tupdateRefreshers as updateDataChangeRefreshers,\n} from \"../feature-libraries/index.js\";\nimport { disposeSymbol } from \"../util/index.js\";\n\nimport { updateRefreshers } from \"./sharedTreeChangeFamily.js\";\nimport type { SharedTreeChange } from \"./sharedTreeChangeTypes.js\";\n\ninterface BorrowedState {\n\treadonly forest: IForestSubscription;\n\treadonly removedRoots: ReadOnlyDetachedFieldIndex;\n}\n\ninterface OwnedState {\n\treadonly forest: IEditableForest;\n\treadonly removedRoots: DetachedFieldIndex;\n}\n\nexport class SharedTreeChangeEnricher {\n\t/**\n\t * Queue of changes to be applied before querying for detached roots.\n\t */\n\tprivate readonly changeQueue: (() => TaggedChange<SharedTreeChange>)[] = [];\n\tprotected readonly borrowed: BorrowedState;\n\tprotected owned?: OwnedState;\n\n\t/**\n\t * @param borrowedForest - The state based on which to enrich changes.\n\t * Not owned by the constructed instance.\n\t * @param schema - The schema that corresponds to the forest.\n\t * @param borrowedRemovedRoots - The set of removed roots based on which to enrich changes.\n\t * Not owned by the constructed instance.\n\t * @param idCompressor - The id compressor to use when chunking trees.\n\t * @param onEnrichCommit - Optional callback invoked whenever a commit is enriched.\n\t * @param onRefresherAdded - Optional callback invoked whenever a refresher is added during enrichment.\n\t * @param onForkState - Optional callback invoked whenever the enricher forks its state.\n\t * @param onApplyChange - Optional callback invoked whenever a change is applied to the owned state.\n\t */\n\tpublic constructor(\n\t\tborrowedForest: IForestSubscription,\n\t\tborrowedRemovedRoots: ReadOnlyDetachedFieldIndex,\n\t\tprivate readonly schema: TreeStoredSchemaRepository,\n\t\tprivate readonly idCompressor?: IIdCompressor,\n\t\tprivate readonly onEnrichCommit?: () => void,\n\t\tprivate readonly onRefresherAdded?: () => void,\n\t\tprivate readonly onForkState?: () => void,\n\t\tprivate readonly onApplyChange?: () => void,\n\t) {\n\t\tthis.borrowed = {\n\t\t\tforest: borrowedForest,\n\t\t\tremovedRoots: borrowedRemovedRoots,\n\t\t};\n\t}\n\n\tpublic enrich(change: SharedTreeChange): SharedTreeChange {\n\t\tthis.onEnrichCommit?.();\n\t\treturn updateRefreshers(\n\t\t\tchange,\n\t\t\t(id) => this.getDetachedRoot(id),\n\t\t\trelevantRemovedRoots,\n\t\t\tupdateDataChangeRefreshers,\n\t\t);\n\t}\n\n\tprivate getDetachedRoot(id: DeltaDetachedNodeId): TreeChunk | undefined {\n\t\tthis.purgeChangeQueue();\n\t\tconst state = this.owned ?? this.borrowed;\n\t\tconst root = state.removedRoots.tryGetEntry(id);\n\t\tif (root !== undefined) {\n\t\t\tconst cursor = state.forest.getCursorAboveDetachedFields();\n\t\t\tconst parentField = state.removedRoots.toFieldKey(root);\n\t\t\tcursor.enterField(parentField);\n\t\t\tcursor.enterNode(0);\n\t\t\tthis.onRefresherAdded?.();\n\t\t\treturn chunkTree(cursor, {\n\t\t\t\tpolicy: defaultChunkPolicy,\n\t\t\t\tidCompressor: this.idCompressor,\n\t\t\t});\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tpublic enqueueChange(\n\t\tchange: TaggedChange<SharedTreeChange> | (() => TaggedChange<SharedTreeChange>),\n\t): void {\n\t\tthis.changeQueue.push(typeof change === \"function\" ? change : () => change);\n\t}\n\n\tprivate purgeChangeQueue(): void {\n\t\tif (this.changeQueue.length === 0) {\n\t\t\treturn;\n\t\t}\n\t\tif (this.owned === undefined) {\n\t\t\tthis.onForkState?.();\n\t\t\tthis.owned = {\n\t\t\t\tforest: this.borrowed.forest.clone(this.schema, new AnchorSet()),\n\t\t\t\tremovedRoots: this.borrowed.removedRoots.clone(),\n\t\t\t};\n\t\t}\n\t\tfor (const getChange of this.changeQueue) {\n\t\t\tconst { change, revision } = getChange();\n\t\t\tthis.onApplyChange?.();\n\t\t\tfor (const dataOrSchemaChange of change.changes) {\n\t\t\t\tconst type = dataOrSchemaChange.type;\n\t\t\t\tswitch (type) {\n\t\t\t\t\tcase \"data\": {\n\t\t\t\t\t\tconst delta = intoDelta(tagChange(dataOrSchemaChange.innerChange, revision));\n\t\t\t\t\t\tconst visitor = this.owned.forest.acquireVisitor();\n\t\t\t\t\t\tvisitDelta(delta, visitor, this.owned.removedRoots, revision);\n\t\t\t\t\t\tvisitor.free();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tcase \"schema\": {\n\t\t\t\t\t\t// This enricher doesn't need to maintain schema information.\n\t\t\t\t\t\t// Note that the refreshers being generated through `updateChangeEnrichments` will be encoded using\n\t\t\t\t\t\t// the schema that was used in the input context of the data changeset these refreshers are on.\n\t\t\t\t\t\t// See the encoding logic in SharedTreeCore for details.\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tdefault: {\n\t\t\t\t\t\tunreachableCase(type);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.changeQueue.length = 0;\n\t}\n\n\tpublic [disposeSymbol](): void {\n\t\t// TODO: in the future, forest and/or its AnchorSet may require disposal.\n\t}\n}\n"]}

package/dist/shared-tree/tree.d.ts.map

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

package/dist/shared-tree/tree.js

@@ -5,17 +5,17 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runTransaction = exports.Tree = void 0;
-const internal_1 = require("@fluidframework/telemetry-utils/internal");
-const internal_2 = require("@fluidframework/core-utils/internal");
-const index_js_1 = require("../simple-tree/index.js");
+const internal_1 = require("@fluidframework/core-utils/internal");
+const internal_2 = require("@fluidframework/telemetry-utils/internal");
+const index_js_1 = require("../feature-libraries/index.js");
+const index_js_2 = require("../simple-tree/index.js");
 const schematizingTreeView_js_1 = require("./schematizingTreeView.js");
-const index_js_2 = require("../feature-libraries/index.js");
 /**
  * The {@link (Tree:interface)} singleton which holds various functions for interacting with {@link TreeNode}s.
  * @public
  */
 exports.Tree = {
-    ...index_js_1.treeNodeApi,
+    ...index_js_2.treeNodeApi,
     // Note: the implementation details of `createRunTransaction` are deprecated.
     // We have introduced replacement `@alpha` APIs on `TreeBranch`, but until they are `@public`, we can't reasonably deprecated this.
     // Once they have been promoted to public, we can deprecate this API.
@@ -32,13 +32,13 @@ exports.Tree = {
     },
 };
 // TODO: Add more constraint types here
+/** A type-safe helper to add a "rollback" property (as required by the `RunTransaction` interface) to a given object */
+function defineRollbackProperty(target) {
+    Reflect.defineProperty(target, "rollback", { value: index_js_2.rollback });
+    return target;
+}
 /** Creates a copy of `runTransaction` with the `rollback` property added so as to satisfy the `RunTransaction` interface. */
 function createRunTransaction() {
-    /** A type-safe helper to add a "rollback" property (as required by the `RunTransaction` interface) to a given object */
-    function defineRollbackProperty(target) {
-        Reflect.defineProperty(target, "rollback", { value: index_js_1.rollback });
-        return target;
-    }
     return defineRollbackProperty(runTransaction.bind({}));
 }
 /**
@@ -55,11 +55,11 @@ function runTransaction(treeOrNode, transaction, preconditions = []) {
     else {
         const node = treeOrNode;
         const t = transaction;
-        const context = (0, index_js_1.getInnerNode)(node).context;
+        const context = (0, index_js_2.getInnerNode)(node).context;
         if (context.isHydrated() === false) {
-            throw new internal_1.UsageError("Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.");
+            throw new internal_2.UsageError("Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.");
         }
-        (0, internal_2.assert)(context instanceof index_js_2.Context, 0xbe3 /* Expected context to be a Context instance. */);
+        (0, internal_1.assert)(context instanceof index_js_1.Context, 0xbe3 /* Expected context to be a Context instance. */);
         return runTransactionInCheckout(context.checkout, () => t(node), preconditions);
     }
 }
@@ -82,7 +82,7 @@ function runTransactionInCheckout(checkout, transaction, preconditions) {
         checkout.transaction.abort();
         throw error;
     }
-    if (result === index_js_1.rollback) {
+    if (result === index_js_2.rollback) {
         checkout.transaction.abort();
     }
     else {

package/dist/shared-tree/tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../src/shared-tree/tree.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\ttype ImplicitFieldSchema,\n\ttype TreeNode,\n\ttype TreeNodeApi,\n\ttype TreeView,\n\tgetInnerNode,\n\ttreeNodeApi,\n\trollback,\n\ttype TransactionConstraint,\n} from \"../simple-tree/index.js\";\n\nimport {\n\taddConstraintsToTransaction,\n\tSchematizingSimpleTreeView,\n} from \"./schematizingTreeView.js\";\nimport type { ITreeCheckout } from \"./treeCheckout.js\";\nimport { Context } from \"../feature-libraries/index.js\";\n\n/**\n * Provides various functions for interacting with {@link TreeNode}s.\n * @remarks\n * This type should only be used via the {@link (Tree:variable)} export.\n * @system @sealed @public\n */\nexport interface Tree extends TreeNodeApi {\n\t/**\n\t * Run a {@link RunTransaction | transaction}.\n\t */\n\treadonly runTransaction: RunTransaction;\n\t/**\n\t * Check if the subtree defined by `node` contains `other`.\n\t *\n\t * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.\n\t * @remarks\n\t * This includes direct and indirect children:\n\t * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.\n\t *\n\t * `node` is considered to contain itself, so the case where `node === other` returns true.\n\t *\n\t * This is handy when checking if moving `node` into `other` would create a cycle and would thus be invalid.\n\t *\n\t * This check walks the parents of `other` looking for `node`,\n\t * and thus runs in time proportional to the depth of child in the tree.\n\t */\n\tcontains(node: TreeNode, other: TreeNode): boolean;\n}\n\n/**\n * The {@link (Tree:interface)} singleton which holds various functions for interacting with {@link TreeNode}s.\n * @public\n */\nexport const Tree: Tree = {\n\t...treeNodeApi,\n\n\t// Note: the implementation details of `createRunTransaction` are deprecated.\n\t// We have introduced replacement `@alpha` APIs on `TreeBranch`, but until they are `@public`, we can't reasonably deprecated this.\n\t// Once they have been promoted to public, we can deprecate this API.\n\trunTransaction: createRunTransaction(),\n\n\tcontains(parent: TreeNode, child: TreeNode): boolean {\n\t\tlet toCheck: TreeNode | undefined = child;\n\t\twhile (toCheck !== undefined) {\n\t\t\tif (toCheck === parent) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\ttoCheck = Tree.parent(toCheck);\n\t\t}\n\t\treturn false;\n\t},\n};\n\n/**\n * A function which runs a transaction in a SharedTree.\n * @privateRemarks\n * This interface exists so that the (generously) overloaded `Tree.runTransaction` function can have the \"rollback\" property hanging off of it.\n * The rollback property being available on the function itself gives users a convenient option for rolling back a transaction without having to import another symbol.\n * @sealed @public\n */\nexport interface RunTransaction {\n\t/**\n\t * The {@link rollback} object used to roll back a transaction.\n\t */\n\treadonly rollback: typeof rollback;\n\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult,\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// TODO: TreeView is invariant over the schema, so to accept any view, `any` is the only real option unless a non generic (or covariant) base type for view is introduced (which is planned).\n\t// This use of any is actually type safe as it is only used as a constraint, and the actual strongly typed view (TView) is passed to the callback.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult,\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult | typeof rollback,\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult | typeof rollback,\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>>(tree: TView, transaction: (root: TView[\"root\"]) => void): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult | typeof rollback,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult | typeof rollback,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => void,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => void,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): void;\n}\n\n// TODO: Add more constraint types here\n\n/** Creates a copy of `runTransaction` with the `rollback` property added so as to satisfy the `RunTransaction` interface. */\nfunction createRunTransaction(): RunTransaction {\n\t/** A type-safe helper to add a \"rollback\" property (as required by the `RunTransaction` interface) to a given object */\n\tfunction defineRollbackProperty<T extends object>(\n\t\ttarget: T,\n\t): T & { rollback: typeof rollback } {\n\t\tReflect.defineProperty(target, \"rollback\", { value: rollback });\n\t\treturn target as T & { readonly rollback: typeof rollback };\n\t}\n\n\treturn defineRollbackProperty(runTransaction.bind({}));\n}\n\n/**\n * Run the given transaction.\n * @remarks\n * This API is not publicly exported but is exported outside of this module so that test code may unit test the `Tree.runTransaction` function directly without being restricted to its public API overloads.\n * @deprecated This API catches exceptions then tries to modify the tree before rethrowing: this is not robust. Use {@link TreeViewAlpha.runTransaction} instead which does not try to edit content in the error case.\n */\nexport function runTransaction<\n\tTNode extends TreeNode,\n\tTRoot extends ImplicitFieldSchema,\n\tTResult,\n>(\n\ttreeOrNode: TNode | TreeView<TRoot>,\n\ttransaction:\n\t\t| ((node: TNode) => TResult | typeof rollback)\n\t\t| ((root: TRoot) => TResult | typeof rollback),\n\tpreconditions: readonly TransactionConstraint[] = [],\n): TResult | typeof rollback {\n\tif (treeOrNode instanceof SchematizingSimpleTreeView) {\n\t\tconst t = transaction as (root: TRoot) => TResult | typeof rollback;\n\t\treturn runTransactionInCheckout(\n\t\t\ttreeOrNode.checkout,\n\t\t\t() => t(treeOrNode.root as TRoot),\n\t\t\tpreconditions,\n\t\t);\n\t} else {\n\t\tconst node = treeOrNode as TNode;\n\t\tconst t = transaction as (node: TNode) => TResult | typeof rollback;\n\t\tconst context = getInnerNode(node).context;\n\t\tif (context.isHydrated() === false) {\n\t\t\tthrow new UsageError(\n\t\t\t\t\"Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.\",\n\t\t\t);\n\t\t}\n\t\tassert(context instanceof Context, 0xbe3 /* Expected context to be a Context instance. */);\n\t\treturn runTransactionInCheckout(context.checkout, () => t(node), preconditions);\n\t}\n}\n\n/**\n * Run the given transaction.\n * @deprecated This API catches exceptions then tries to modify the tree before rethrowing: this is not robust. Use {@link TreeViewAlpha.runTransaction} instead which does not try to editing content in the error case.\n */\nfunction runTransactionInCheckout<TResult>(\n\tcheckout: ITreeCheckout,\n\ttransaction: () => TResult | typeof rollback,\n\tpreconditions: readonly TransactionConstraint[],\n): TResult | typeof rollback {\n\tcheckout.transaction.start();\n\taddConstraintsToTransaction(checkout, false, preconditions);\n\n\tlet result: ReturnType<typeof transaction>;\n\ttry {\n\t\tresult = transaction();\n\t} catch (error) {\n\t\t// If the transaction has an unhandled error, abort and rollback the transaction but continue to propagate the error.\n\t\t// This might try and modify the tree or trigger events while things are in an inconsistent state.\n\t\t// It is up to the user of runTransaction to ensure that does not cause problems (and they have no robust way to do that, which is why its deprecated).\n\t\tcheckout.transaction.abort();\n\t\tthrow error;\n\t}\n\n\tif (result === rollback) {\n\t\tcheckout.transaction.abort();\n\t} else {\n\t\tcheckout.transaction.commit();\n\t}\n\n\treturn result;\n}\n"]}
+{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../src/shared-tree/tree.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { Context } from \"../feature-libraries/index.js\";\nimport {\n\ttype ImplicitFieldSchema,\n\ttype TreeNode,\n\ttype TreeNodeApi,\n\ttype TreeView,\n\tgetInnerNode,\n\ttreeNodeApi,\n\trollback,\n\ttype TransactionConstraint,\n} from \"../simple-tree/index.js\";\n\nimport {\n\taddConstraintsToTransaction,\n\tSchematizingSimpleTreeView,\n} from \"./schematizingTreeView.js\";\nimport type { ITreeCheckout } from \"./treeCheckout.js\";\n\n/**\n * Provides various functions for interacting with {@link TreeNode}s.\n * @remarks\n * This type should only be used via the {@link (Tree:variable)} export.\n * @system @sealed @public\n */\nexport interface Tree extends TreeNodeApi {\n\t/**\n\t * Run a {@link RunTransaction | transaction}.\n\t */\n\treadonly runTransaction: RunTransaction;\n\t/**\n\t * Check if the subtree defined by `node` contains `other`.\n\t *\n\t * @returns true if `other` is an inclusive descendant of `node`, and false otherwise.\n\t * @remarks\n\t * This includes direct and indirect children:\n\t * as long as `node` is an ancestor of `other` (occurs in its parentage chain), this returns true, regardless of the number of levels of the tree between.\n\t *\n\t * `node` is considered to contain itself, so the case where `node === other` returns true.\n\t *\n\t * This is handy when checking if moving `node` into `other` would create a cycle and would thus be invalid.\n\t *\n\t * This check walks the parents of `other` looking for `node`,\n\t * and thus runs in time proportional to the depth of child in the tree.\n\t */\n\tcontains(node: TreeNode, other: TreeNode): boolean;\n}\n\n/**\n * The {@link (Tree:interface)} singleton which holds various functions for interacting with {@link TreeNode}s.\n * @public\n */\nexport const Tree: Tree = {\n\t...treeNodeApi,\n\n\t// Note: the implementation details of `createRunTransaction` are deprecated.\n\t// We have introduced replacement `@alpha` APIs on `TreeBranch`, but until they are `@public`, we can't reasonably deprecated this.\n\t// Once they have been promoted to public, we can deprecate this API.\n\trunTransaction: createRunTransaction(),\n\n\tcontains(parent: TreeNode, child: TreeNode): boolean {\n\t\tlet toCheck: TreeNode | undefined = child;\n\t\twhile (toCheck !== undefined) {\n\t\t\tif (toCheck === parent) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\ttoCheck = Tree.parent(toCheck);\n\t\t}\n\t\treturn false;\n\t},\n};\n\n/**\n * A function which runs a transaction in a SharedTree.\n * @privateRemarks\n * This interface exists so that the (generously) overloaded `Tree.runTransaction` function can have the \"rollback\" property hanging off of it.\n * The rollback property being available on the function itself gives users a convenient option for rolling back a transaction without having to import another symbol.\n * @sealed @public\n */\nexport interface RunTransaction {\n\t/**\n\t * The {@link rollback} object used to roll back a transaction.\n\t */\n\treadonly rollback: typeof rollback;\n\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult,\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// TODO: TreeView is invariant over the schema, so to accept any view, `any` is the only real option unless a non generic (or covariant) base type for view is introduced (which is planned).\n\t// This use of any is actually type safe as it is only used as a constraint, and the actual strongly typed view (TView) is passed to the callback.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult,\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult | typeof rollback,\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult | typeof rollback,\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode>(node: TNode, transaction: (node: TNode) => void): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>>(tree: TView, transaction: (root: TView[\"root\"]) => void): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode, TResult>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => TResult | typeof rollback,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * At any point during the transaction, the function may return the special {@link RunTransaction.rollback | rollback value} (`Tree.runTransaction.rollback`) to abort the transaction and discard any changes it made so far.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @returns The value returned by the inner `transaction` function.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back (whether by an error or by returning the {@link RunTransaction.rollback} | rollback value), a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>, TResult>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => TResult | typeof rollback,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): TResult | typeof rollback;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param node - The node that will be passed to `transaction`.\n\t * This is typically the root node of the subtree that will be modified by the transaction.\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the provided `node`.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t<TNode extends TreeNode>(\n\t\tnode: TNode,\n\t\ttransaction: (node: TNode) => void,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): void;\n\t/**\n\t * Apply one or more edits to the tree as a single atomic unit.\n\t * @param tree - The tree which will be edited by the transaction\n\t * @param transaction - The function to run as the body of the transaction.\n\t * This function is passed the root of the tree.\n\t * @param preconditions - An optional list of {@link TransactionConstraint | constraints} that are checked just before the transaction begins.\n\t * If any of the constraints are not met when `runTransaction` is called, it will throw an error.\n\t * If any of the constraints are not met after the transaction has been ordered by the service, it will be rolled back on this client and ignored by all other clients.\n\t * @remarks\n\t * All of the changes in the transaction are applied synchronously and therefore no other changes (either from this client or from a remote client) can be interleaved with those changes.\n\t * Note that this is guaranteed by Fluid for any sequence of changes that are submitted synchronously, whether in a transaction or not.\n\t * However, using a transaction has the following additional consequences:\n\t *\n\t * - If reverted (e.g. via an \"undo\" operation), all the changes in the transaction are reverted together.\n\t *\n\t * - The internal data representation of a transaction with many changes is generally smaller and more efficient than that of the changes when separate.\n\t *\n\t * Local change events will be emitted for each change as the transaction is being applied.\n\t * If the transaction function throws an error then the transaction will be automatically rolled back (discarding any changes made to the tree so far) before the error is propagated up from this function.\n\t * If the transaction is rolled back, a corresponding change event will also be emitted for the rollback.\n\t */\n\t// See comment on previous overload about use of any here.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t<TView extends TreeView<any>>(\n\t\ttree: TView,\n\t\ttransaction: (root: TView[\"root\"]) => void,\n\t\tpreconditions?: readonly TransactionConstraint[],\n\t): void;\n}\n\n// TODO: Add more constraint types here\n\n/** A type-safe helper to add a \"rollback\" property (as required by the `RunTransaction` interface) to a given object */\nfunction defineRollbackProperty<T extends object>(\n\ttarget: T,\n): T & { rollback: typeof rollback } {\n\tReflect.defineProperty(target, \"rollback\", { value: rollback });\n\treturn target as T & { readonly rollback: typeof rollback };\n}\n\n/** Creates a copy of `runTransaction` with the `rollback` property added so as to satisfy the `RunTransaction` interface. */\nfunction createRunTransaction(): RunTransaction {\n\treturn defineRollbackProperty(runTransaction.bind({}));\n}\n\n/**\n * Run the given transaction.\n * @remarks\n * This API is not publicly exported but is exported outside of this module so that test code may unit test the `Tree.runTransaction` function directly without being restricted to its public API overloads.\n * @deprecated This API catches exceptions then tries to modify the tree before rethrowing: this is not robust. Use {@link TreeViewAlpha.runTransaction} instead which does not try to edit content in the error case.\n */\nexport function runTransaction<\n\tTNode extends TreeNode,\n\tTRoot extends ImplicitFieldSchema,\n\tTResult,\n>(\n\ttreeOrNode: TNode | TreeView<TRoot>,\n\ttransaction:\n\t\t| ((node: TNode) => TResult | typeof rollback)\n\t\t| ((root: TRoot) => TResult | typeof rollback),\n\tpreconditions: readonly TransactionConstraint[] = [],\n): TResult | typeof rollback {\n\tif (treeOrNode instanceof SchematizingSimpleTreeView) {\n\t\tconst t = transaction as (root: TRoot) => TResult | typeof rollback;\n\t\treturn runTransactionInCheckout(\n\t\t\ttreeOrNode.checkout,\n\t\t\t() => t(treeOrNode.root as TRoot),\n\t\t\tpreconditions,\n\t\t);\n\t} else {\n\t\tconst node = treeOrNode as TNode;\n\t\tconst t = transaction as (node: TNode) => TResult | typeof rollback;\n\t\tconst context = getInnerNode(node).context;\n\t\tif (context.isHydrated() === false) {\n\t\t\tthrow new UsageError(\n\t\t\t\t\"Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.\",\n\t\t\t);\n\t\t}\n\t\tassert(context instanceof Context, 0xbe3 /* Expected context to be a Context instance. */);\n\t\treturn runTransactionInCheckout(context.checkout, () => t(node), preconditions);\n\t}\n}\n\n/**\n * Run the given transaction.\n * @deprecated This API catches exceptions then tries to modify the tree before rethrowing: this is not robust. Use {@link TreeViewAlpha.runTransaction} instead which does not try to editing content in the error case.\n */\nfunction runTransactionInCheckout<TResult>(\n\tcheckout: ITreeCheckout,\n\ttransaction: () => TResult | typeof rollback,\n\tpreconditions: readonly TransactionConstraint[],\n): TResult | typeof rollback {\n\tcheckout.transaction.start();\n\taddConstraintsToTransaction(checkout, false, preconditions);\n\n\tlet result: ReturnType<typeof transaction>;\n\ttry {\n\t\tresult = transaction();\n\t} catch (error) {\n\t\t// If the transaction has an unhandled error, abort and rollback the transaction but continue to propagate the error.\n\t\t// This might try and modify the tree or trigger events while things are in an inconsistent state.\n\t\t// It is up to the user of runTransaction to ensure that does not cause problems (and they have no robust way to do that, which is why its deprecated).\n\t\tcheckout.transaction.abort();\n\t\tthrow error;\n\t}\n\n\tif (result === rollback) {\n\t\tcheckout.transaction.abort();\n\t} else {\n\t\tcheckout.transaction.commit();\n\t}\n\n\treturn result;\n}\n"]}

package/dist/shared-tree/treeAlpha.d.ts

@@ -4,9 +4,9 @@
  */
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
+import { type ICodecOptions, type CodecWriteOptions } from "../codec/index.js";
 import { TreeNode, type Unhydrated, type ImplicitFieldSchema, type InsertableField, type TreeFieldFromImplicitField, type TreeLeafValue, type UnsafeUnknownSchema, type TreeEncodingOptions, type VerboseTree, type TreeBranch, type TreeParsingOptions, type ConciseTree, type TreeNodeSchema, type TreeBranchAlpha } from "../simple-tree/index.js";
 import { type JsonCompatible } from "../util/index.js";
-import { type ICodecOptions, type CodecWriteOptions } from "../codec/index.js";
 /**
  * A utility interface for manipulating node identifiers.
  * @remarks

package/dist/shared-tree/treeAlpha.d.ts.map

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