@fluidframework/merge-tree 2.118.1 → 3.0.1

package/lib/mergeTree.js

@@ -194,24 +194,25 @@ export function getSlideToSegoff(segoff, slidingPreference = SlidingPreference.F
 const forwardPred = (ref) => ref.slidingPreference !== SlidingPreference.BACKWARD;
 const backwardPred = (ref) => ref.slidingPreference === SlidingPreference.BACKWARD;
 class Obliterates {
+    mergeTree;
+    /**
+     * Array containing the all obliterate operations within the
+     * collab window.
+     *
+     * The obliterates are stored in sequence order which accelerates clean up in setMinSeq
+     *
+     * See https://github.com/microsoft/FluidFramework/blob/main/packages/dds/merge-tree/docs/Obliterate.md#remote-perspective
+     * for additional context
+     */
+    seqOrdered = new DoublyLinkedList();
+    /**
+     * This contains a sorted lists of all obliterate starts
+     * and is used to accelerate finding overlapping obliterates
+     * as well as determining if there are any obliterates at all.
+     */
+    startOrdered = new SortedSegmentSet();
     constructor(mergeTree) {
         this.mergeTree = mergeTree;
-        /**
-         * Array containing the all obliterate operations within the
-         * collab window.
-         *
-         * The obliterates are stored in sequence order which accelerates clean up in setMinSeq
-         *
-         * See https://github.com/microsoft/FluidFramework/blob/main/packages/dds/merge-tree/docs/Obliterate.md#remote-perspective
-         * for additional context
-         */
-        this.seqOrdered = new DoublyLinkedList();
-        /**
-         * This contains a sorted lists of all obliterate starts
-         * and is used to accelerate finding overlapping obliterates
-         * as well as determining if there are any obliterates at all.
-         */
-        this.startOrdered = new SortedSegmentSet();
     }
     setMinSeq(minSeq) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
@@ -291,46 +292,41 @@ class Obliterates {
  * @internal
  */
 export class MergeTree {
+    options;
+    static options = {
+        incrementalUpdate: true,
+        insertAfterRemovedSegs: true,
+        zamboniSegments: true,
+    };
+    /**
+     * A sentinel value that indicates an inserting walk should continue to the next block sibling.
+     * This can occur for example when tie-break forces insertion of a segment past an entire block (and
+     * the inserting walk first recurses into the block before realizing that).
+     */
+    static theUnfinishedNode = { childCount: -1 };
+    collabWindow = new CollaborationWindow();
+    pendingSegments = new DoublyLinkedList();
+    segmentsToScour = new Heap(LRUSegmentComparer);
+    attributionPolicy;
     get localPerspective() {
         return this.collabWindow.localPerspective;
     }
+    /**
+     * Whether or not all blocks in the mergeTree currently have information about local partial lengths computed.
+     * This information is only necessary on reconnect, and otherwise costly to bookkeep.
+     * This field enables tracking whether partials need to be recomputed using localSeq information.
+     */
+    localPartialsComputed = false;
+    // for now assume only markers have ids and so point directly at the Segment
+    // if we need to have pointers to non-markers, we can change to point at local refs
+    idToMarker = new Map();
+    mergeTreeDeltaCallback;
+    mergeTreeMaintenanceCallback;
+    // TODO:AB#29553: This property doesn't seem to be adequately round-tripped through summarization.
+    // Specifically, it seems like we drop information about obliterates within the collab window for at least V1 summaries.
+    obliterates = new Obliterates(this);
     constructor(options) {
         this.options = options;
-        this.collabWindow = new CollaborationWindow();
-        this.pendingSegments = new DoublyLinkedList();
-        this.segmentsToScour = new Heap(LRUSegmentComparer);
-        /**
-         * Whether or not all blocks in the mergeTree currently have information about local partial lengths computed.
-         * This information is only necessary on reconnect, and otherwise costly to bookkeep.
-         * This field enables tracking whether partials need to be recomputed using localSeq information.
-         */
-        this.localPartialsComputed = false;
-        // for now assume only markers have ids and so point directly at the Segment
-        // if we need to have pointers to non-markers, we can change to point at local refs
-        this.idToMarker = new Map();
-        // TODO:AB#29553: This property doesn't seem to be adequately round-tripped through summarization.
-        // Specifically, it seems like we drop information about obliterates within the collab window for at least V1 summaries.
-        this.obliterates = new Obliterates(this);
-        this.splitLeafSegment = (segment, pos) => {
-            if (!(pos > 0 && segment)) {
-                return {};
-            }
-            const next = segment.splitAt(pos);
-            assertSegmentLeaf(next);
-            if (segment?.segmentGroups) {
-                next.segmentGroups ??= new SegmentGroupCollection(next);
-                segment.segmentGroups.copyTo(next.segmentGroups);
-            }
-            copyPropertiesAndManager(segment, next);
-            segment.localRefs?.split(pos, next);
-            this.mergeTreeMaintenanceCallback?.({
-                operation: MergeTreeMaintenanceType.SPLIT,
-                deltaSegments: [{ segment }, { segment: next }],
-            }, undefined);
-            return { next };
-        };
-        this.startOfTree = new StartOfTreeSegment(this);
-        this.endOfTree = new EndOfTreeSegment(this);
         this._root = this.makeBlock(0);
         this._root.mergeTree = this;
         this.attributionPolicy = options?.attribution?.policyFactory?.();
@@ -341,6 +337,7 @@ export class MergeTree {
             this.obliterates.addOrUpdate(newObliterate);
         }
     }
+    _root;
     get root() {
         return this._root;
     }
@@ -1094,6 +1091,24 @@ export class MergeTree {
         }
         return newest;
     }
+    splitLeafSegment = (segment, pos) => {
+        if (!(pos > 0 && segment)) {
+            return {};
+        }
+        const next = segment.splitAt(pos);
+        assertSegmentLeaf(next);
+        if (segment?.segmentGroups) {
+            next.segmentGroups ??= new SegmentGroupCollection(next);
+            segment.segmentGroups.copyTo(next.segmentGroups);
+        }
+        copyPropertiesAndManager(segment, next);
+        segment.localRefs?.split(pos, next);
+        this.mergeTreeMaintenanceCallback?.({
+            operation: MergeTreeMaintenanceType.SPLIT,
+            deltaSegments: [{ segment }, { segment: next }],
+        }, undefined);
+        return { next };
+    };
     ensureIntervalBoundary(pos, perspective) {
         this.insertingWalk(pos, perspective, {
             seq: TreeMaintenanceSequenceNumber,
@@ -1640,6 +1655,8 @@ export class MergeTree {
         const segment = lref.getSegment();
         return segment?.localRefs?.removeLocalRef(lref);
     }
+    startOfTree = new StartOfTreeSegment(this);
+    endOfTree = new EndOfTreeSegment(this);
     createLocalReferencePosition(_segment, offset, refType, properties, slidingPreference, canSlideToEndpoint) {
         if (_segment !== "start" &&
             _segment !== "end" &&
@@ -1999,15 +2016,4 @@ export class MergeTree {
         }, undefined, post);
     }
 }
-MergeTree.options = {
-    incrementalUpdate: true,
-    insertAfterRemovedSegs: true,
-    zamboniSegments: true,
-};
-/**
- * A sentinel value that indicates an inserting walk should continue to the next block sibling.
- * This can occur for example when tie-break forces insertion of a segment past an entire block (and
- * the inserting walk first recurses into the block before realizing that).
- */
-MergeTree.theUnfinishedNode = { childCount: -1 };
 //# sourceMappingURL=mergeTree.js.map