@fluidframework/merge-tree 2.117.0 → 3.0.0

package/dist/mergeTreeNodeWalk.js

@@ -4,7 +4,11 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.walkAllChildSegments = exports.backwardExcursion = exports.forwardExcursion = exports.depthFirstNodeWalk = exports.NodeAction = exports.LeafAction = void 0;
+exports.NodeAction = exports.LeafAction = void 0;
+exports.depthFirstNodeWalk = depthFirstNodeWalk;
+exports.forwardExcursion = forwardExcursion;
+exports.backwardExcursion = backwardExcursion;
+exports.walkAllChildSegments = walkAllChildSegments;
 const segmentInfos_js_1 = require("./segmentInfos.js");
 exports.LeafAction = {
     Exit: false,
@@ -94,7 +98,6 @@ function depthFirstNodeWalk(startBlock, startChild, downAction, leafActionOverri
         start = block.children[nextIndex];
     }
 }
-exports.depthFirstNodeWalk = depthFirstNodeWalk;
 /**
  * Visit segments starting from node's right/far/forward siblings, then up to node's parent.
  * All segments past `node` are visited, regardless of their visibility.
@@ -109,7 +112,6 @@ function forwardExcursion(startNode, leafAction) {
     // the startNode only
     startNode.parent.children[startNode.index + 1], undefined /* downAction */, leafAction);
 }
-exports.forwardExcursion = forwardExcursion;
 /**
  * Visit segments starting from node's left/near/backwards siblings, then up to node's parent.
  * All segments past `node` are visited, regardless of their visibility.
@@ -124,7 +126,6 @@ function backwardExcursion(startNode, leafAction) {
     // the startNode only
     startNode.parent.children[startNode.index - 1], undefined /* downAction */, leafAction, undefined /* upAction */, false /* forward */);
 }
-exports.backwardExcursion = backwardExcursion;
 /**
  * Walks all segments below the specific start block
  * @param startBlock - The block to start the walk at
@@ -145,5 +146,4 @@ function walkAllChildSegments(startBlock, leafAction) {
         ? undefined
         : (node) => ancestors.has(node.parent) ? exports.NodeAction.Exit : exports.NodeAction.Continue, leafAction);
 }
-exports.walkAllChildSegments = walkAllChildSegments;
 //# sourceMappingURL=mergeTreeNodeWalk.js.map

package/dist/mergeTreeNodeWalk.js.map

@@ -1 +1 @@
-{"version":3,"file":"mergeTreeNodeWalk.js","sourceRoot":"","sources":["../src/mergeTreeNodeWalk.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 type { ISegmentLeaf, MergeBlock, IMergeNode } from \"./mergeTreeNodes.js\";\nimport { isMergeNodeInfo } from \"./segmentInfos.js\";\n\nexport const LeafAction = {\n\tExit: false,\n} as const;\n\nexport type LeafAction = boolean | undefined | void;\n\nexport const NodeAction = {\n\tContinue: undefined,\n\t// exit is false to unify with leafActionOverride\n\tExit: LeafAction.Exit,\n\tSkip: 2,\n} as const;\n\n// we exclude true from, as we only want one continue value, undefined\nexport type NodeAction =\n\t| (typeof NodeAction)[keyof typeof NodeAction]\n\t| Exclude<LeafAction, true>;\n\n/**\n * Does a depth first walk of the tree from the specific start.\n *\n * @param startBlock - The block of the tree to start the walk from\n * @param startChild - The child of that block to start from\n * @param downAction - Called as we walk down the tree to the leaves.\n * @param leafActionOverride - Overrides downAction for leaves, generally used without downAction\n * @param upAction - Called after all the children of a block are walked.\n * @param forward - whether to walk forward or backward\n * @returns true if we naturally exit, false if exiting due to Exit action result\n */\nexport function depthFirstNodeWalk(\n\tstartBlock: MergeBlock,\n\tstartChild: IMergeNode | undefined,\n\tdownAction?: (node: IMergeNode) => NodeAction,\n\tleafActionOverride?: (seg: ISegmentLeaf) => LeafAction,\n\tupAction?: (block: MergeBlock) => void,\n\tforward: boolean = true,\n): boolean {\n\tconst increment = forward ? 1 : -1;\n\tconst leafAction = leafActionOverride ?? downAction;\n\tif (leafAction === undefined) {\n\t\treturn true;\n\t}\n\n\tlet block = startBlock;\n\tlet childCount = block.childCount;\n\tlet start: IMergeNode | undefined = startChild;\n\n\twhile (true) {\n\t\t// go down to the leaf level\n\t\tlet blockResult: NodeAction;\n\t\twhile (start?.isLeaf() === false) {\n\t\t\t// cast is safe due to isLeaf === false in while above\n\t\t\tblock = start as MergeBlock;\n\t\t\tchildCount = block.childCount;\n\t\t\tblockResult = downAction?.(block);\n\t\t\t// setting start undefined will skip the leaf walk\n\t\t\t// so if the block result isn't continue, set it\n\t\t\t// undefined\n\t\t\tstart =\n\t\t\t\tblockResult === NodeAction.Continue\n\t\t\t\t\t? block.children[forward ? 0 : childCount - 1]\n\t\t\t\t\t: undefined;\n\t\t}\n\n\t\tlet exit = blockResult === NodeAction.Exit;\n\n\t\t// walk the leaves if we reached them\n\t\tif (start !== undefined) {\n\t\t\tfor (let i = start.index; i !== -1 && i !== childCount; i += increment) {\n\t\t\t\t// the above loop ensures start is a leaf or undefined, so all children\n\t\t\t\t// will be leaves if start exits, so the cast is safe\n\t\t\t\tif (leafAction(block.children[i] as ISegmentLeaf) === LeafAction.Exit) {\n\t\t\t\t\texit = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// if there is no upAction, we don't need to walk up before exiting\n\t\tif (upAction === undefined && exit) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// since we already enumerated the children\n\t\t// we walk up to the next level until there is a sibling\n\t\t// or all the way up if exit is true\n\t\tlet nextIndex = -1;\n\t\tdo {\n\t\t\t// if the blockAction was exit or skip\n\t\t\t// we shouldn't process that block again,\n\t\t\t// if there are subsequent parents while walking up\n\t\t\t// we will process those.\n\t\t\tif (blockResult === NodeAction.Continue) {\n\t\t\t\tupAction?.(block);\n\t\t\t} else {\n\t\t\t\tblockResult = NodeAction.Continue;\n\t\t\t}\n\t\t\tif (block.parent === undefined) {\n\t\t\t\treturn !exit;\n\t\t\t}\n\t\t\tstart = block;\n\t\t\tblock = block.parent;\n\t\t\tchildCount = block.childCount;\n\t\t\tnextIndex = start.index + increment;\n\t\t} while (exit || nextIndex === -1 || nextIndex === childCount);\n\t\t// the above loop ensured that siblings are possible\n\t\tstart = block.children[nextIndex];\n\t}\n}\n\n/**\n * Visit segments starting from node's right/far/forward siblings, then up to node's parent.\n * All segments past `node` are visited, regardless of their visibility.\n */\nexport function forwardExcursion(\n\tstartNode: IMergeNode,\n\tleafAction: (seg: ISegmentLeaf) => boolean | undefined,\n): boolean {\n\tif (!isMergeNodeInfo(startNode)) {\n\t\treturn true;\n\t}\n\n\treturn depthFirstNodeWalk(\n\t\tstartNode.parent,\n\t\t// this will either be the sibling, or undefined\n\t\t// either is fine, and will result in skipping\n\t\t// the startNode only\n\t\tstartNode.parent.children[startNode.index + 1],\n\t\tundefined /* downAction */,\n\t\tleafAction,\n\t);\n}\n\n/**\n * Visit segments starting from node's left/near/backwards siblings, then up to node's parent.\n * All segments past `node` are visited, regardless of their visibility.\n */\nexport function backwardExcursion(\n\tstartNode: IMergeNode,\n\tleafAction: (seg: ISegmentLeaf) => boolean | undefined,\n): boolean {\n\tif (!isMergeNodeInfo(startNode)) {\n\t\treturn true;\n\t}\n\treturn depthFirstNodeWalk(\n\t\tstartNode.parent,\n\t\t// this will either be the sibling, or undefined\n\t\t// either is fine, and will result in skipping\n\t\t// the startNode only\n\t\tstartNode.parent.children[startNode.index - 1],\n\t\tundefined /* downAction */,\n\t\tleafAction,\n\t\tundefined /* upAction */,\n\t\tfalse /* forward */,\n\t);\n}\n\n/**\n * Walks all segments below the specific start block\n * @param startBlock - The block to start the walk at\n * @param leafAction - The action to perform on the leaves\n * @returns true if we naturally exit, false if exiting due to leaf action result\n */\nexport function walkAllChildSegments(\n\tstartBlock: MergeBlock,\n\tleafAction: (segment: ISegmentLeaf) => boolean | undefined | void,\n): boolean {\n\tif (startBlock.childCount === 0) {\n\t\treturn true;\n\t}\n\n\t// undefined shouldn't actually be added, but this allows subsequent check for `node.parent` to typecheck\n\t// without further runtime work.\n\tconst ancestors = new Set<MergeBlock | undefined>();\n\tfor (let cur = startBlock.parent; cur !== undefined; cur = cur.parent) {\n\t\tancestors.add(cur);\n\t}\n\n\treturn depthFirstNodeWalk(\n\t\tstartBlock,\n\t\tstartBlock.children[0],\n\t\tancestors.size === 0\n\t\t\t? undefined\n\t\t\t: (node): false | undefined =>\n\t\t\t\t\tancestors.has(node.parent) ? NodeAction.Exit : NodeAction.Continue,\n\t\tleafAction,\n\t);\n}\n"]}
+{"version":3,"file":"mergeTreeNodeWalk.js","sourceRoot":"","sources":["../src/mergeTreeNodeWalk.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 type { ISegmentLeaf, MergeBlock, IMergeNode } from \"./mergeTreeNodes.js\";\nimport { isMergeNodeInfo } from \"./segmentInfos.js\";\n\nexport const LeafAction = {\n\tExit: false,\n} as const;\n\nexport type LeafAction = boolean | undefined | void;\n\nexport const NodeAction = {\n\tContinue: undefined,\n\t// exit is false to unify with leafActionOverride\n\tExit: LeafAction.Exit,\n\tSkip: 2,\n} as const;\n\n// we exclude true from, as we only want one continue value, undefined\nexport type NodeAction =\n\t| (typeof NodeAction)[keyof typeof NodeAction]\n\t| Exclude<LeafAction, true>;\n\n/**\n * Does a depth first walk of the tree from the specific start.\n *\n * @param startBlock - The block of the tree to start the walk from\n * @param startChild - The child of that block to start from\n * @param downAction - Called as we walk down the tree to the leaves.\n * @param leafActionOverride - Overrides downAction for leaves, generally used without downAction\n * @param upAction - Called after all the children of a block are walked.\n * @param forward - whether to walk forward or backward\n * @returns true if we naturally exit, false if exiting due to Exit action result\n */\nexport function depthFirstNodeWalk(\n\tstartBlock: MergeBlock,\n\tstartChild: IMergeNode | undefined,\n\tdownAction?: (node: IMergeNode) => NodeAction,\n\tleafActionOverride?: (seg: ISegmentLeaf) => LeafAction,\n\tupAction?: (block: MergeBlock) => void,\n\tforward: boolean = true,\n): boolean {\n\tconst increment = forward ? 1 : -1;\n\tconst leafAction = leafActionOverride ?? downAction;\n\tif (leafAction === undefined) {\n\t\treturn true;\n\t}\n\n\tlet block = startBlock;\n\tlet childCount = block.childCount;\n\tlet start: IMergeNode | undefined = startChild;\n\n\twhile (true) {\n\t\t// go down to the leaf level\n\t\tlet blockResult: NodeAction;\n\t\twhile (start?.isLeaf() === false) {\n\t\t\t// cast is safe due to isLeaf === false in while above\n\t\t\tblock = start as MergeBlock;\n\t\t\tchildCount = block.childCount;\n\t\t\tblockResult = downAction?.(block);\n\t\t\t// setting start undefined will skip the leaf walk\n\t\t\t// so if the block result isn't continue, set it\n\t\t\t// undefined\n\t\t\tstart =\n\t\t\t\tblockResult === NodeAction.Continue\n\t\t\t\t\t? block.children[forward ? 0 : childCount - 1]\n\t\t\t\t\t: undefined;\n\t\t}\n\n\t\tlet exit = blockResult === NodeAction.Exit;\n\n\t\t// walk the leaves if we reached them\n\t\tif (start !== undefined) {\n\t\t\tfor (let i = start.index; i !== -1 && i !== childCount; i += increment) {\n\t\t\t\t// the above loop ensures start is a leaf or undefined, so all children\n\t\t\t\t// will be leaves if start exits, so the cast is safe\n\t\t\t\tif (leafAction(block.children[i] as ISegmentLeaf) === LeafAction.Exit) {\n\t\t\t\t\texit = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// if there is no upAction, we don't need to walk up before exiting\n\t\tif (upAction === undefined && exit) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// since we already enumerated the children\n\t\t// we walk up to the next level until there is a sibling\n\t\t// or all the way up if exit is true\n\t\tlet nextIndex = -1;\n\t\tdo {\n\t\t\t// if the blockAction was exit or skip\n\t\t\t// we shouldn't process that block again,\n\t\t\t// if there are subsequent parents while walking up\n\t\t\t// we will process those.\n\t\t\tif (blockResult === NodeAction.Continue) {\n\t\t\t\tupAction?.(block);\n\t\t\t} else {\n\t\t\t\tblockResult = NodeAction.Continue;\n\t\t\t}\n\t\t\tif (block.parent === undefined) {\n\t\t\t\treturn !exit;\n\t\t\t}\n\t\t\tstart = block;\n\t\t\tblock = block.parent;\n\t\t\tchildCount = block.childCount;\n\t\t\tnextIndex = start.index + increment;\n\t\t} while (exit || nextIndex === -1 || nextIndex === childCount);\n\t\t// the above loop ensured that siblings are possible\n\t\tstart = block.children[nextIndex];\n\t}\n}\n\n/**\n * Visit segments starting from node's right/far/forward siblings, then up to node's parent.\n * All segments past `node` are visited, regardless of their visibility.\n */\nexport function forwardExcursion(\n\tstartNode: IMergeNode,\n\tleafAction: (seg: ISegmentLeaf) => boolean | undefined,\n): boolean {\n\tif (!isMergeNodeInfo(startNode)) {\n\t\treturn true;\n\t}\n\n\treturn depthFirstNodeWalk(\n\t\tstartNode.parent,\n\t\t// this will either be the sibling, or undefined\n\t\t// either is fine, and will result in skipping\n\t\t// the startNode only\n\t\tstartNode.parent.children[startNode.index + 1],\n\t\tundefined /* downAction */,\n\t\tleafAction,\n\t);\n}\n\n/**\n * Visit segments starting from node's left/near/backwards siblings, then up to node's parent.\n * All segments past `node` are visited, regardless of their visibility.\n */\nexport function backwardExcursion(\n\tstartNode: IMergeNode,\n\tleafAction: (seg: ISegmentLeaf) => boolean | undefined,\n): boolean {\n\tif (!isMergeNodeInfo(startNode)) {\n\t\treturn true;\n\t}\n\treturn depthFirstNodeWalk(\n\t\tstartNode.parent,\n\t\t// this will either be the sibling, or undefined\n\t\t// either is fine, and will result in skipping\n\t\t// the startNode only\n\t\tstartNode.parent.children[startNode.index - 1],\n\t\tundefined /* downAction */,\n\t\tleafAction,\n\t\tundefined /* upAction */,\n\t\tfalse /* forward */,\n\t);\n}\n\n/**\n * Walks all segments below the specific start block\n * @param startBlock - The block to start the walk at\n * @param leafAction - The action to perform on the leaves\n * @returns true if we naturally exit, false if exiting due to leaf action result\n */\nexport function walkAllChildSegments(\n\tstartBlock: MergeBlock,\n\tleafAction: (segment: ISegmentLeaf) => boolean | undefined | void,\n): boolean {\n\tif (startBlock.childCount === 0) {\n\t\treturn true;\n\t}\n\n\t// undefined shouldn't actually be added, but this allows subsequent check for `node.parent` to typecheck\n\t// without further runtime work.\n\tconst ancestors = new Set<MergeBlock | undefined>();\n\tfor (let cur = startBlock.parent; cur !== undefined; cur = cur.parent) {\n\t\tancestors.add(cur);\n\t}\n\n\treturn depthFirstNodeWalk(\n\t\tstartBlock,\n\t\tstartBlock.children[0],\n\t\tancestors.size === 0\n\t\t\t? undefined\n\t\t\t: (node): false | undefined =>\n\t\t\t\t\tancestors.has(node.parent) ? NodeAction.Exit : NodeAction.Continue,\n\t\tleafAction,\n\t);\n}\n"]}

package/dist/mergeTreeNodes.d.ts.map

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

package/dist/mergeTreeNodes.js

@@ -4,7 +4,12 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareStrings = exports.compareNumbers = exports.CollaborationWindow = exports.getMinSeqPerspective = exports.getMinSeqStamp = exports.Marker = exports.reservedMarkerSimpleTypeKey = exports.reservedMarkerIdKey = exports.BaseSegment = exports.seqLTE = exports.assignChild = exports.MergeBlock = exports.MaxNodesInBlock = exports.segmentIsRemoved = exports.assertSegmentLeaf = exports.toSegmentLeaf = exports.isSegmentLeaf = void 0;
+exports.compareStrings = exports.compareNumbers = exports.CollaborationWindow = exports.Marker = exports.reservedMarkerSimpleTypeKey = exports.reservedMarkerIdKey = exports.BaseSegment = exports.MergeBlock = exports.MaxNodesInBlock = exports.assertSegmentLeaf = exports.toSegmentLeaf = exports.isSegmentLeaf = void 0;
+exports.segmentIsRemoved = segmentIsRemoved;
+exports.assignChild = assignChild;
+exports.seqLTE = seqLTE;
+exports.getMinSeqStamp = getMinSeqStamp;
+exports.getMinSeqPerspective = getMinSeqPerspective;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const constants_js_1 = require("./constants.js");
 const localReference_js_1 = require("./localReference.js");
@@ -44,7 +49,6 @@ exports.assertSegmentLeaf = assertSegmentLeaf;
 function segmentIsRemoved(segment) {
     return (0, segmentInfos_js_1.isRemoved)(segment);
 }
-exports.segmentIsRemoved = segmentIsRemoved;
 /**
  * Note that the actual branching factor of the MergeTree is `MaxNodesInBlock - 1`.  This is because
  * the MergeTree always inserts first, then checks for overflow and splits if the child count equals
@@ -53,14 +57,39 @@ exports.segmentIsRemoved = segmentIsRemoved;
  */
 exports.MaxNodesInBlock = 8;
 class MergeBlock {
+    childCount;
+    children;
+    needsScour;
+    parent;
+    index = 0;
+    ordinal = "";
+    cachedLength = 0;
+    /**
+     * Maps each tile label in this block to the rightmost (i.e. furthest) marker associated with that tile label.
+     * When combined with the tree structure of MergeBlocks, this allows accelerated queries for nearest tile
+     * with a certain label before a given position
+     */
+    rightmostTiles;
+    /**
+     * Maps each tile label in this block to the leftmost (i.e. nearest) marker associated with that tile label.
+     * When combined with the tree structure of MergeBlocks, this allows accelerated queries for nearest tile
+     * with a certain label before a given position
+     */
+    leftmostTiles;
     isLeaf() {
         return false;
     }
+    /**
+     * Supports querying the total length of all descendants of this IMergeBlock from the perspective of any
+     * (clientId, seq) within the collab window.
+     *
+     * @remarks This is only optional for implementation reasons (internal nodes can be created/moved without
+     * immediately initializing the partial lengths). Aside from mid-update on tree operations, these lengths
+     * objects are always defined.
+     */
+    partialLengths;
     constructor(childCount) {
         this.childCount = childCount;
-        this.index = 0;
-        this.ordinal = "";
-        this.cachedLength = 0;
         // Suppression needed due to the way the merge tree children are initialized - we
         // allocate 8 children blocks, but any unused blocks are not counted in the childCount.
         // Using Array.from leads to unused children being undefined, which are counted in childCount.
@@ -87,18 +116,19 @@ function assignChild(parent, child, index, updateOrdinal = true) {
     }
     parent.children[index] = node;
 }
-exports.assignChild = assignChild;
 function seqLTE(seq, minOrRefSeq) {
     return seq !== constants_js_1.UnassignedSequenceNumber && seq <= minOrRefSeq;
 }
-exports.seqLTE = seqLTE;
 /**
  * @legacy @beta
  */
 class BaseSegment {
+    cachedLength = 0;
+    trackingCollection = new mergeTreeTracking_js_1.TrackingGroupCollection(this);
+    /***/
+    attribution;
+    properties;
     constructor(properties) {
-        this.cachedLength = 0;
-        this.trackingCollection = new mergeTreeTracking_js_1.TrackingGroupCollection(this);
         if (properties !== undefined) {
             this.properties = (0, properties_js_1.clone)(properties);
         }
@@ -214,16 +244,18 @@ exports.reservedMarkerSimpleTypeKey = "markerSimpleType";
  * @legacy @beta
  */
 class Marker extends BaseSegment {
+    refType;
+    static type = "Marker";
     static is(segment) {
         return segment.type === Marker.type;
     }
+    type = Marker.type;
     static make(refType, props) {
         return new Marker(refType, props);
     }
     constructor(refType, props) {
         super(props);
         this.refType = refType;
-        this.type = Marker.type;
         this.cachedLength = 1;
     }
     toJSONObject() {
@@ -268,7 +300,6 @@ class Marker extends BaseSegment {
     }
 }
 exports.Marker = Marker;
-Marker.type = "Marker";
 /**
  * Returns a stamp that occurs at the minimum sequence number.
  * @privateRemarks
@@ -281,7 +312,6 @@ Marker.type = "Marker";
 function getMinSeqStamp(collabWindow) {
     return { seq: collabWindow.minSeq, clientId: constants_js_1.NonCollabClient };
 }
-exports.getMinSeqStamp = getMinSeqStamp;
 /**
  * Returns a perspective representing a readonly client's view of the tree at the minimum sequence number.
  * @privateRemarks
@@ -294,7 +324,6 @@ exports.getMinSeqStamp = getMinSeqStamp;
 function getMinSeqPerspective(collabWindow) {
     return new perspective_js_1.PriorPerspective(collabWindow.minSeq, constants_js_1.NonCollabClient);
 }
-exports.getMinSeqPerspective = getMinSeqPerspective;
 /**
  * This class is used to track facts about the current window of collaboration. This window is defined by the server
  * specified minimum sequence number to the last sequence number seen. Additionally, it track state for outstanding
@@ -302,83 +331,81 @@ exports.getMinSeqPerspective = getMinSeqPerspective;
  * @internal
  */
 class CollaborationWindow {
-    constructor() {
-        this.clientId = constants_js_1.LocalClientId;
-        this.collaborating = false;
-        /**
-         * Lowest-numbered segment in window; no client can reference a state before this one
-         */
-        this.minSeq = 0;
-        /**
-         * Highest-numbered segment in window and current reference sequence number for this client.
-         */
-        this.currentSeq = 0;
-        /**
-         * Highest-numbered localSeq used for a pending segment.
-         * Semantically, `localSeq`s provide an ordering on in-flight merge-tree operations:
-         * for operations stamped with localSeqs `a` and `b`, `a < b` if and only if `a` was submitted before `b`.
-         *
-         * @remarks This field is analogous to the `clientSequenceNumber` field on ops, but it's accessible to merge-tree
-         * at op submission time rather than only at ack time. This enables more natural state tracking for in-flight ops.
-         *
-         * It's useful to stamp ops with such an incrementing counter because it enables reasoning about which segments existed from
-         * the perspective of the local client at a given point in 'un-acked' time, which is necessary to support the reconnect flow.
-         *
-         * For example, imagine a client with initial state "123456" submits some ops to create the text "123456ABC".
-         * If they insert the "C" first, then "B", then "A", their local segment state might look like this:
-         * ```js
-         * [
-         *     { seq: 0, text: "1234" },
-         *     { seq: 5, text: "56" },
-         *     { localSeq: 3, seq: UnassignedSequenceNumber, text: "A" },
-         *     { localSeq: 2, seq: UnassignedSequenceNumber, text: "B" },
-         *     { localSeq: 1, seq: UnassignedSequenceNumber, text: "C" },
-         * ]
-         * ```
-         * (note that localSeq tracks the localSeq at which a segment was inserted)
-         *
-         * Suppose the client then disconnects and reconnects before any of its insertions are acked. The reconnect flow will necessitate
-         * that the client regenerates and resubmits ops based on its current segment state as well as the original op that was sent.
-         *
-         * It will generate the ops
-         * 1. \{ pos: 6, text: "C" \}
-         * 2. \{ pos: 6, text: "B" \}
-         * 3. \{ pos: 6, text: "A" \}
-         *
-         * since when submitting the first op, remote clients don't know that this client is about to submit the "A" and "B".
-         *
-         * On the other hand, imagine if the client had originally submitted the ops in the order "A", "B", "C"
-         * such that the segments' local state was instead:
-         *
-         * ```js
-         * [
-         *     { seq: 0, text: "1234" },
-         *     { seq: 5, text: "56" },
-         *     { localSeq: 1, seq: UnassignedSequenceNumber, text: "A" },
-         *     { localSeq: 2, seq: UnassignedSequenceNumber, text: "B" },
-         *     { localSeq: 3, seq: UnassignedSequenceNumber, text: "C" },
-         * ]
-         * ```
-         *
-         * The resubmitted ops should instead be:
-         * 1. \{ pos: 6, text: "A" \}
-         * 2. \{ pos: 7, text: "B" \}
-         * 3. \{ pos: 8, text: "C" \}
-         *
-         * since remote clients will have seen the "A" when processing the "B" as well as both the "A" and "B" when processing the "C".
-         * As can be seen, the list of resubmitted ops is different in the two cases despite the merge-tree's segment state only differing
-         * in `localSeq`.
-         *
-         * This example is a bit simplified from the general scenario: since no remote clients modified the merge-tree while the client
-         * was disconnected, the resubmitted ops end up matching the original ops exactly.
-         * However, this is not generally true: the production reconnect code takes into account visibility of segments based on both acked
-         * and local information as appropriate.
-         * Nonetheless, this simple scenario is enough to understand why it's useful to be able to determine if a segment should be visible
-         * from a given (seq, localSeq) perspective.
-         */
-        this.localSeq = 0;
-        this.localPerspective = new perspective_js_1.LocalDefaultPerspective(this.clientId);
-    }
+    clientId = constants_js_1.LocalClientId;
+    collaborating = false;
+    /**
+     * Lowest-numbered segment in window; no client can reference a state before this one
+     */
+    minSeq = 0;
+    /**
+     * Highest-numbered segment in window and current reference sequence number for this client.
+     */
+    currentSeq = 0;
+    /**
+     * Highest-numbered localSeq used for a pending segment.
+     * Semantically, `localSeq`s provide an ordering on in-flight merge-tree operations:
+     * for operations stamped with localSeqs `a` and `b`, `a < b` if and only if `a` was submitted before `b`.
+     *
+     * @remarks This field is analogous to the `clientSequenceNumber` field on ops, but it's accessible to merge-tree
+     * at op submission time rather than only at ack time. This enables more natural state tracking for in-flight ops.
+     *
+     * It's useful to stamp ops with such an incrementing counter because it enables reasoning about which segments existed from
+     * the perspective of the local client at a given point in 'un-acked' time, which is necessary to support the reconnect flow.
+     *
+     * For example, imagine a client with initial state "123456" submits some ops to create the text "123456ABC".
+     * If they insert the "C" first, then "B", then "A", their local segment state might look like this:
+     * ```js
+     * [
+     *     { seq: 0, text: "1234" },
+     *     { seq: 5, text: "56" },
+     *     { localSeq: 3, seq: UnassignedSequenceNumber, text: "A" },
+     *     { localSeq: 2, seq: UnassignedSequenceNumber, text: "B" },
+     *     { localSeq: 1, seq: UnassignedSequenceNumber, text: "C" },
+     * ]
+     * ```
+     * (note that localSeq tracks the localSeq at which a segment was inserted)
+     *
+     * Suppose the client then disconnects and reconnects before any of its insertions are acked. The reconnect flow will necessitate
+     * that the client regenerates and resubmits ops based on its current segment state as well as the original op that was sent.
+     *
+     * It will generate the ops
+     * 1. \{ pos: 6, text: "C" \}
+     * 2. \{ pos: 6, text: "B" \}
+     * 3. \{ pos: 6, text: "A" \}
+     *
+     * since when submitting the first op, remote clients don't know that this client is about to submit the "A" and "B".
+     *
+     * On the other hand, imagine if the client had originally submitted the ops in the order "A", "B", "C"
+     * such that the segments' local state was instead:
+     *
+     * ```js
+     * [
+     *     { seq: 0, text: "1234" },
+     *     { seq: 5, text: "56" },
+     *     { localSeq: 1, seq: UnassignedSequenceNumber, text: "A" },
+     *     { localSeq: 2, seq: UnassignedSequenceNumber, text: "B" },
+     *     { localSeq: 3, seq: UnassignedSequenceNumber, text: "C" },
+     * ]
+     * ```
+     *
+     * The resubmitted ops should instead be:
+     * 1. \{ pos: 6, text: "A" \}
+     * 2. \{ pos: 7, text: "B" \}
+     * 3. \{ pos: 8, text: "C" \}
+     *
+     * since remote clients will have seen the "A" when processing the "B" as well as both the "A" and "B" when processing the "C".
+     * As can be seen, the list of resubmitted ops is different in the two cases despite the merge-tree's segment state only differing
+     * in `localSeq`.
+     *
+     * This example is a bit simplified from the general scenario: since no remote clients modified the merge-tree while the client
+     * was disconnected, the resubmitted ops end up matching the original ops exactly.
+     * However, this is not generally true: the production reconnect code takes into account visibility of segments based on both acked
+     * and local information as appropriate.
+     * Nonetheless, this simple scenario is enough to understand why it's useful to be able to determine if a segment should be visible
+     * from a given (seq, localSeq) perspective.
+     */
+    localSeq = 0;
+    localPerspective = new perspective_js_1.LocalDefaultPerspective(this.clientId);
     loadFrom(a) {
         this.clientId = a.clientId;
         this.collaborating = a.collaborating;

package/dist/mergeTreeNodes.js.map

@@ -1 +1 @@
-{"version":3,"file":"mergeTreeNodes.js","sourceRoot":"","sources":["../src/mergeTreeNodes.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 type { AttributionKey } from \"@fluidframework/runtime-definitions/internal\";\n\nimport type { IAttributionCollection } from \"./attributionCollection.js\";\nimport {\n\tLocalClientId,\n\tNonCollabClient,\n\tUnassignedSequenceNumber,\n\tUniversalSequenceNumber,\n} from \"./constants.js\";\nimport { LocalReferenceCollection, type LocalReferencePosition } from \"./localReference.js\";\nimport { TrackingGroupCollection, type ITrackingGroup } from \"./mergeTreeTracking.js\";\nimport type { IJSONSegment, IMarkerDef, ReferenceType } from \"./ops.js\";\nimport { computeHierarchicalOrdinal } from \"./ordinal.js\";\nimport type { PartialSequenceLengths } from \"./partialLengths.js\";\nimport { LocalDefaultPerspective, PriorPerspective, type Perspective } from \"./perspective.js\";\nimport { type PropertySet, clone, createMap, type MapLike } from \"./properties.js\";\nimport type { ReferencePosition } from \"./referencePositions.js\";\nimport type { SegmentGroupCollection } from \"./segmentGroupCollection.js\";\nimport {\n\thasProp,\n\tisInserted,\n\tisMergeNodeInfo as isMergeNode,\n\tisRemoved,\n\toverwriteInfo,\n\ttype IHasInsertionInfo,\n\ttype IMergeNodeInfo,\n\ttype IHasRemovalInfo,\n\ttype SegmentWithInfo,\n\ttype ISegmentInsideObliterateInfo,\n\tisInsideObliterate,\n} from \"./segmentInfos.js\";\nimport type { PropertiesManager } from \"./segmentPropertiesManager.js\";\nimport type { Side } from \"./sequencePlace.js\";\nimport type { OperationStamp, SliceRemoveOperationStamp } from \"./stamps.js\";\n\n/**\n * This interface exposes internal things to dds that leverage merge tree,\n * like sequence and matrix.\n *\n * We use tiered interface to control visibility of segment properties.\n * This sits between ISegment and ISegmentPrivate. It should only expose\n * things tagged internal.\n *\n * Everything added here beyond ISegment should be optional to keep the ability\n * to implicitly convert between the tiered interfaces.\n *\n * @internal\n */\nexport interface ISegmentInternal extends ISegment {\n\tlocalRefs?: LocalReferenceCollection;\n\t/**\n\t * Whether or not this segment is a special segment denoting the start or\n\t * end of the tree\n\t *\n\t * Endpoint segments are imaginary segments positioned immediately before or\n\t * after the tree. These segments cannot be referenced by regular operations\n\t * and exist primarily as a bucket for local references to slide onto during\n\t * deletion of regular segments.\n\t */\n\treadonly endpointType?: \"start\" | \"end\";\n}\n\n/**\n * We use tiered interface to control visibility of segment properties.\n * This is the lowest interface and is not exported, it site below ISegment and ISegmentInternal.\n * It should only expose unexported things.\n *\n * Everything added here beyond ISegmentInternal should be optional to keep the ability\n * to implicitly convert between the tiered interfaces.\n *\n * someday we may split tree leaves from segments, but for now they are the same\n * this is just a convenience type that makes it clear that we need something that is both a segment and a leaf node\n */\nexport interface ISegmentPrivate extends ISegmentInternal {\n\tsegmentGroups?: SegmentGroupCollection;\n\tpropertyManager?: PropertiesManager;\n}\n/**\n * Segment leafs are segments that have both IMergeNodeInfo and IHasInsertionInfo. This means they\n * are inserted at a position, and bound via their parent MergeBlock to the merge tree. MergeBlocks'\n * children are either a segment leaf, or another merge block for interior nodes of the tree. When working\n * within the tree it is generally unnecessary to use type coercions methods common to the infos, and segment\n * leafs, as the children of MergeBlocks are already well typed. However, when segments come from outside the\n * merge tree, like via client's public methods, it becomes necessary to use the type coercions methods\n * to ensure the passed in segment objects are correctly bound to the merge tree.\n */\nexport type ISegmentLeaf = SegmentWithInfo<IMergeNodeInfo & IHasInsertionInfo>;\n/**\n * A type-guard which determines if the segment has segment leaf, and\n * returns true if it does, along with applying strong typing.\n * @param nodeLike - The segment-like object to check.\n * @returns True if the segment is a segment leaf, otherwise false.\n */\nexport const isSegmentLeaf = (segmentLike: unknown): segmentLike is ISegmentLeaf =>\n\tisInserted(segmentLike) && isMergeNode(segmentLike);\n\n/**\n * Converts a segment-like object to a segment leaf object if possible.\n *\n * @param segmentLike - The segment-like object to convert.\n * @returns The segment leaf if the conversion is possible, otherwise undefined.\n */\nexport const toSegmentLeaf = (segmentLike: unknown): ISegmentLeaf | undefined =>\n\tisSegmentLeaf(segmentLike) ? segmentLike : undefined;\n/**\n * Asserts that the segment is a segment leaf. Usage of this function should not produce a user facing error.\n *\n * @param segmentLike - The segment-like object to check.\n * @throws Will throw an error if the segment is not a segment leaf.\n */\nexport const assertSegmentLeaf: (segmentLike: unknown) => asserts segmentLike is ISegmentLeaf =\n\t(segmentLike) => assert(isSegmentLeaf(segmentLike), 0xaab /* must be segment leaf */);\n/**\n * This type is used for building MergeBlocks from segments and other MergeBlocks. We need this\n * type as segments may not yet be bound to the tree, so lack merge node info which is required for\n * segment leafs.\n */\nexport type IMergeNodeBuilder = MergeBlock | SegmentWithInfo<IHasInsertionInfo>;\n\n/**\n * This type is used by MergeBlocks to define their children, which are either segments or other\n * MergeBlocks.\n */\nexport type IMergeNode = MergeBlock | ISegmentLeaf;\n\n/**\n * A segment representing a portion of the merge tree.\n * Segments are leaf nodes of the merge tree and contain data.\n * @legacy @beta\n */\nexport interface ISegment {\n\treadonly type: string;\n\n\treadonly trackingCollection: TrackingGroupCollection;\n\n\t/**\n\t * The length of the contents of the node.\n\t */\n\tcachedLength: number;\n\t/**\n\t * Stores attribution keys associated with offsets of this segment.\n\t * This data is only persisted if MergeTree's `attributions.track` flag is set to true.\n\t * Pending segments (i.e. ones that only exist locally and haven't been acked by the server) also have\n\t * `attribution === undefined` until ack.\n\t *\n\t * Keys can be used opaquely with an IAttributor or a container runtime that provides attribution.\n\t * @remarks There are plans to make the shape of the data stored extensible in a couple ways:\n\t *\n\t * 1. Injection of custom attribution information associated with the segment (ex: copy-paste of\n\t * content but keeping the old attribution information).\n\t *\n\t * 2. Storage of multiple \"channels\" of information (ex: track property changes separately from insertion,\n\t * or only attribute certain property modifications, etc.)\n\t */\n\tattribution?: IAttributionCollection<AttributionKey>;\n\n\t/**\n\t * Properties that have been added to this segment via annotation.\n\t */\n\tproperties?: PropertySet;\n\n\tclone(): ISegment;\n\tcanAppend(segment: ISegment): boolean;\n\tappend(segment: ISegment): void;\n\tsplitAt(pos: number): ISegment | undefined;\n\t// Changing this to something other than any would break consumers.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\ttoJSONObject(): any;\n\tisLeaf(): this is ISegment;\n}\n\n/**\n * Determine if a segment has been removed.\n * @legacy @beta\n */\nexport function segmentIsRemoved(segment: ISegment): boolean {\n\treturn isRemoved(segment);\n}\n\n/**\n * @legacy @beta\n */\nexport interface ISegmentAction<TClientData> {\n\t// eslint-disable-next-line @typescript-eslint/prefer-function-type\n\t(\n\t\tsegment: ISegment,\n\t\tpos: number,\n\t\trefSeq: number,\n\t\tclientId: number,\n\t\tstart: number,\n\t\tend: number,\n\t\taccum: TClientData,\n\t): boolean;\n}\nexport interface ISegmentChanges {\n\tnext?: SegmentWithInfo<IHasInsertionInfo>;\n\treplaceCurrent?: SegmentWithInfo<IHasInsertionInfo>;\n}\n\nexport interface InsertContext {\n\tcandidateSegment?: SegmentWithInfo<IHasInsertionInfo>;\n\tleaf: (segment: ISegmentLeaf | undefined, pos: number, ic: InsertContext) => ISegmentChanges;\n\tcontinuePredicate?: (continueFromBlock: MergeBlock) => boolean;\n}\n\nexport interface ObliterateInfo {\n\tstart: LocalReferencePosition;\n\tstartSide: Side;\n\tend: LocalReferencePosition;\n\tendSide: Side;\n\trefSeq: number;\n\tstamp: SliceRemoveOperationStamp;\n\tsegmentGroup: SegmentGroup | undefined;\n\t/**\n\t * Defined only for unacked obliterates.\n\t *\n\t * Contains all segments inserted into the range this obliterate affects where at the time of insertion,\n\t * this obliterate was the newest concurrent obliterate that overlapped the insertion point (this information\n\t * is relevant for the tiebreak policy of allowing last-obliterater to insert).\n\t *\n\t * We need to keep this around for unacked ops because on reconnect, outstanding local obliterates may have set `obliteratePrecedingInsertion`\n\t * (tiebreak) on segments they no longer apply to, since the reissued obliterate may affect a smaller range than the original one when content\n\t * near the obliterate's endpoints was removed by another client between the time of the original obliterate and reissuing.\n\t */\n\ttiebreakTrackingGroup: ITrackingGroup | undefined;\n}\n\nexport interface SegmentGroup {\n\tsegments: ISegmentLeaf[];\n\tpreviousProps?: PropertySet[];\n\tlocalSeq?: number;\n\trefSeq: number;\n\tobliterateInfo?: ObliterateInfo;\n}\n\n/**\n * Note that the actual branching factor of the MergeTree is `MaxNodesInBlock - 1`.  This is because\n * the MergeTree always inserts first, then checks for overflow and splits if the child count equals\n * `MaxNodesInBlock`.  (i.e., `MaxNodesInBlock` contains 1 extra slot for temporary storage to\n * facilitate splits.)\n */\nexport const MaxNodesInBlock = 8;\nexport class MergeBlock implements Partial<IMergeNodeInfo> {\n\tpublic children: IMergeNode[];\n\tpublic needsScour?: boolean;\n\tpublic parent?: MergeBlock;\n\tpublic index: number = 0;\n\tpublic ordinal: string = \"\";\n\tpublic cachedLength: number | undefined = 0;\n\n\t/**\n\t * Maps each tile label in this block to the rightmost (i.e. furthest) marker associated with that tile label.\n\t * When combined with the tree structure of MergeBlocks, this allows accelerated queries for nearest tile\n\t * with a certain label before a given position\n\t */\n\tpublic rightmostTiles: Readonly<MapLike<Marker>>;\n\t/**\n\t * Maps each tile label in this block to the leftmost (i.e. nearest) marker associated with that tile label.\n\t * When combined with the tree structure of MergeBlocks, this allows accelerated queries for nearest tile\n\t * with a certain label before a given position\n\t */\n\tpublic leftmostTiles: Readonly<MapLike<Marker>>;\n\n\tisLeaf(): this is ISegmentInternal {\n\t\treturn false;\n\t}\n\n\t/**\n\t * Supports querying the total length of all descendants of this IMergeBlock from the perspective of any\n\t * (clientId, seq) within the collab window.\n\t *\n\t * @remarks This is only optional for implementation reasons (internal nodes can be created/moved without\n\t * immediately initializing the partial lengths). Aside from mid-update on tree operations, these lengths\n\t * objects are always defined.\n\t */\n\tpartialLengths?: PartialSequenceLengths;\n\n\tpublic constructor(public childCount: number) {\n\t\t// Suppression needed due to the way the merge tree children are initialized - we\n\t\t// allocate 8 children blocks, but any unused blocks are not counted in the childCount.\n\t\t// Using Array.from leads to unused children being undefined, which are counted in childCount.\n\t\t// eslint-disable-next-line unicorn/no-new-array\n\t\tthis.children = new Array<IMergeNode>(MaxNodesInBlock);\n\t\tthis.rightmostTiles = createMap<Marker>();\n\t\tthis.leftmostTiles = createMap<Marker>();\n\t}\n\n\tpublic setOrdinal(child: IMergeNode, index: number): void {\n\t\tconst childCount = this.childCount;\n\t\tassert(\n\t\t\tchildCount >= 1 && childCount <= MaxNodesInBlock,\n\t\t\t0x040 /* \"Child count is not within [1,8] range!\" */,\n\t\t);\n\t\tchild.ordinal = computeHierarchicalOrdinal(\n\t\t\tMaxNodesInBlock,\n\t\t\tchildCount,\n\t\t\tthis.ordinal,\n\t\t\tindex === 0 ? undefined : this.children[index - 1]?.ordinal,\n\t\t);\n\t}\n}\nexport function assignChild<C extends IMergeNodeBuilder>(\n\tparent: MergeBlock,\n\tchild: C,\n\tindex: number,\n\tupdateOrdinal = true,\n): asserts child is C & IMergeNodeInfo {\n\tconst node = Object.assign<C, IMergeNodeInfo>(child, {\n\t\tparent,\n\t\tindex,\n\t\tordinal: hasProp(child, \"ordinal\", \"string\") ? child.ordinal : \"\",\n\t});\n\tif (updateOrdinal) {\n\t\tparent.setOrdinal(node, index);\n\t}\n\tparent.children[index] = node;\n}\n\nexport function seqLTE(seq: number, minOrRefSeq: number): boolean {\n\treturn seq !== UnassignedSequenceNumber && seq <= minOrRefSeq;\n}\n\n/**\n * @legacy @beta\n */\nexport abstract class BaseSegment implements ISegment {\n\tpublic cachedLength: number = 0;\n\n\tpublic readonly trackingCollection: TrackingGroupCollection = new TrackingGroupCollection(\n\t\tthis,\n\t);\n\t/***/\n\tpublic attribution?: IAttributionCollection<AttributionKey>;\n\n\tpublic properties?: PropertySet;\n\tpublic abstract readonly type: string;\n\tpublic constructor(properties?: PropertySet) {\n\t\tif (properties !== undefined) {\n\t\t\tthis.properties = clone(properties);\n\t\t}\n\t}\n\n\tpublic hasProperty(key: string): boolean {\n\t\treturn !!this.properties && this.properties[key] !== undefined;\n\t}\n\n\tpublic isLeaf(): this is ISegment {\n\t\treturn true;\n\t}\n\n\tprotected cloneInto(b: ISegment): void {\n\t\tconst seg: ISegmentPrivate = b;\n\t\tif (isInserted(this)) {\n\t\t\toverwriteInfo<IHasInsertionInfo>(seg, {\n\t\t\t\tinsert: this.insert,\n\t\t\t});\n\t\t}\n\t\t// TODO: deep clone properties\n\t\tseg.properties = clone(this.properties);\n\t\tif (isRemoved(this)) {\n\t\t\toverwriteInfo<IHasRemovalInfo>(seg, {\n\t\t\t\tremoves: [...this.removes],\n\t\t\t});\n\t\t}\n\n\t\tseg.attribution = this.attribution?.clone();\n\t}\n\n\tpublic canAppend(segment: ISegment): boolean {\n\t\treturn false;\n\t}\n\n\tprotected addSerializedProps(jseg: IJSONSegment): void {\n\t\tif (this.properties) {\n\t\t\tjseg.props = { ...this.properties };\n\t\t}\n\t}\n\t// This has to return any type because the return type is different for different segment types.\n\t// TODO: If possible, change the return type to match what should be returned for each segment type.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tpublic abstract toJSONObject(): any;\n\n\tpublic splitAt(pos: number): ISegment | undefined {\n\t\tif (pos <= 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst leafSegment: ISegmentPrivate | undefined = this.createSplitSegmentAt(pos);\n\n\t\tif (!leafSegment) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tif (isMergeNode(this)) {\n\t\t\toverwriteInfo<IMergeNodeInfo>(leafSegment, {\n\t\t\t\tindex: this.index + 1,\n\t\t\t\t// Give the leaf a temporary yet valid ordinal.\n\t\t\t\t// when this segment is put in the tree, it will get its real ordinal,\n\t\t\t\t// but this ordinal meets all the necessary invariants for now.\n\t\t\t\t// Ordinals exist purely for lexicographical sort order and use a small set of valid bytes for each string character.\n\t\t\t\t// The extra handling fromCodePoint has for things like surrogate pairs is therefore unnecessary.\n\t\t\t\t// eslint-disable-next-line unicorn/prefer-code-point\n\t\t\t\tordinal: this.ordinal + String.fromCharCode(0),\n\t\t\t\tparent: this.parent,\n\t\t\t});\n\t\t}\n\n\t\tif (isInserted(this)) {\n\t\t\toverwriteInfo<IHasInsertionInfo>(leafSegment, { insert: this.insert });\n\t\t}\n\t\tif (isRemoved(this)) {\n\t\t\toverwriteInfo<IHasRemovalInfo>(leafSegment, {\n\t\t\t\tremoves: [...this.removes],\n\t\t\t});\n\t\t}\n\t\tif (isInsideObliterate(this)) {\n\t\t\toverwriteInfo<ISegmentInsideObliterateInfo>(leafSegment, {\n\t\t\t\tobliteratePrecedingInsertion: this.obliteratePrecedingInsertion,\n\t\t\t\tinsertionRefSeqStamp: this.insertionRefSeqStamp,\n\t\t\t});\n\t\t}\n\n\t\tthis.trackingCollection.copyTo(leafSegment);\n\t\tif (this.attribution) {\n\t\t\tleafSegment.attribution = this.attribution.splitAt(pos);\n\t\t}\n\n\t\treturn leafSegment;\n\t}\n\n\tpublic abstract clone(): ISegment;\n\n\tpublic append(other: ISegment): void {\n\t\t// Note: Must call 'appendLocalRefs' before modifying this segment's length as\n\t\t//       'this.cachedLength' is used to adjust the offsets of the local refs.\n\t\tLocalReferenceCollection.append(this, other);\n\t\tif (this.attribution) {\n\t\t\tassert(\n\t\t\t\tother.attribution !== undefined,\n\t\t\t\t0x4bd /* attribution should be set on appendee */,\n\t\t\t);\n\t\t\tthis.attribution.append(other.attribution);\n\t\t} else {\n\t\t\tassert(\n\t\t\t\tother.attribution === undefined,\n\t\t\t\t0x4be /* attribution should not be set on appendee */,\n\t\t\t);\n\t\t}\n\n\t\tthis.cachedLength ??= 0;\n\t\tthis.cachedLength += other.cachedLength;\n\t}\n\n\tprotected abstract createSplitSegmentAt(pos: number): BaseSegment | undefined;\n}\n\n/**\n * The special-cased property key that tracks the id of a {@link Marker}.\n *\n * @remarks In general, marker ids should be accessed using the inherent method\n * {@link Marker.getId}. Marker ids should not be updated after creation.\n * @legacy @beta\n */\nexport const reservedMarkerIdKey = \"markerId\";\n\n/**\n * @internal\n */\nexport const reservedMarkerSimpleTypeKey = \"markerSimpleType\";\n\n/**\n * @legacy @beta\n */\nexport interface IJSONMarkerSegment extends IJSONSegment {\n\tmarker: IMarkerDef;\n}\n\n/**\n * Markers are a special kind of segment that do not hold any content.\n *\n * Markers with a reference type of {@link ReferenceType.Tile} support spatially\n * accelerated queries for finding the next marker to the left or right of it in\n * sub-linear time. This is useful, for example, in the case of jumping from the\n * start of a paragraph to the end, assuming a paragraph is bound by markers at\n * the start and end.\n *\n * @legacy @beta\n */\nexport class Marker extends BaseSegment implements ReferencePosition, ISegment {\n\tpublic static readonly type = \"Marker\";\n\tpublic static is(segment: ISegment): segment is Marker {\n\t\treturn segment.type === Marker.type;\n\t}\n\tpublic readonly type = Marker.type;\n\n\tpublic static make(refType: ReferenceType, props?: PropertySet): Marker {\n\t\treturn new Marker(refType, props);\n\t}\n\n\tconstructor(\n\t\tpublic refType: ReferenceType,\n\t\tprops?: PropertySet,\n\t) {\n\t\tsuper(props);\n\t\tthis.cachedLength = 1;\n\t}\n\n\ttoJSONObject(): IJSONMarkerSegment {\n\t\tconst obj: IJSONMarkerSegment = { marker: { refType: this.refType } };\n\t\tsuper.addSerializedProps(obj);\n\t\treturn obj;\n\t}\n\n\tstatic fromJSONObject(spec: IJSONSegment): Marker | undefined {\n\t\tif (spec && typeof spec === \"object\" && \"marker\" in spec) {\n\t\t\treturn Marker.make((spec.marker as Marker).refType, spec.props as PropertySet);\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tclone(): Marker {\n\t\tconst b = Marker.make(this.refType, this.properties);\n\t\tthis.cloneInto(b);\n\t\treturn b;\n\t}\n\n\tgetSegment(): Marker {\n\t\treturn this;\n\t}\n\n\tgetOffset(): number {\n\t\treturn 0;\n\t}\n\n\tgetProperties(): PropertySet | undefined {\n\t\treturn this.properties;\n\t}\n\n\tgetId(): string | undefined {\n\t\treturn this.properties?.[reservedMarkerIdKey] as string;\n\t}\n\n\ttoString(): string {\n\t\treturn `M${this.getId()}`;\n\t}\n\n\tprotected createSplitSegmentAt(pos: number): undefined {\n\t\treturn undefined;\n\t}\n\n\tcanAppend(segment: ISegment): boolean {\n\t\treturn false;\n\t}\n\n\tappend(): void {\n\t\tthrow new Error(\"Can not append to marker\");\n\t}\n}\n\n/**\n * Returns a stamp that occurs at the minimum sequence number.\n * @privateRemarks\n * This is a free function over something obtainable on CollaborationWindow to avoid exposing Perspective\n * and OperationStamp from the package (even internally), at least for now.\n * If/when `Client`'s API is refactored to be structured similarly to MergeTree (so that SharedString passes in\n * things closer to `Perspective`s when calling methods on `Client` rather than refSeq/localSeq/clientId etc),\n * it may be more reasonable to expose this more directly on `CollaborationWindow`.\n */\nexport function getMinSeqStamp(collabWindow: CollaborationWindow): OperationStamp {\n\treturn { seq: collabWindow.minSeq, clientId: NonCollabClient };\n}\n\n/**\n * Returns a perspective representing a readonly client's view of the tree at the minimum sequence number.\n * @privateRemarks\n * This is a free function over something obtainable on CollaborationWindow to avoid exposing Perspective\n * and OperationStamp from the package (even internally), at least for now.\n * If/when `Client`'s API is refactored to be structured similarly to MergeTree (so that SharedString passes in\n * things closer to `Perspective`s when calling methods on `Client` rather than refSeq/localSeq/clientId etc),\n * it may be more reasonable to expose this more directly on `CollaborationWindow`.\n */\nexport function getMinSeqPerspective(collabWindow: CollaborationWindow): Perspective {\n\treturn new PriorPerspective(collabWindow.minSeq, NonCollabClient);\n}\n\n/**\n * This class is used to track facts about the current window of collaboration. This window is defined by the server\n * specified minimum sequence number to the last sequence number seen. Additionally, it track state for outstanding\n * local operations.\n * @internal\n */\nexport class CollaborationWindow {\n\tclientId = LocalClientId;\n\tcollaborating = false;\n\n\t/**\n\t * Lowest-numbered segment in window; no client can reference a state before this one\n\t */\n\tminSeq = 0;\n\t/**\n\t * Highest-numbered segment in window and current reference sequence number for this client.\n\t */\n\tcurrentSeq = 0;\n\n\t/**\n\t * Highest-numbered localSeq used for a pending segment.\n\t * Semantically, `localSeq`s provide an ordering on in-flight merge-tree operations:\n\t * for operations stamped with localSeqs `a` and `b`, `a < b` if and only if `a` was submitted before `b`.\n\t *\n\t * @remarks This field is analogous to the `clientSequenceNumber` field on ops, but it's accessible to merge-tree\n\t * at op submission time rather than only at ack time. This enables more natural state tracking for in-flight ops.\n\t *\n\t * It's useful to stamp ops with such an incrementing counter because it enables reasoning about which segments existed from\n\t * the perspective of the local client at a given point in 'un-acked' time, which is necessary to support the reconnect flow.\n\t *\n\t * For example, imagine a client with initial state \"123456\" submits some ops to create the text \"123456ABC\".\n\t * If they insert the \"C\" first, then \"B\", then \"A\", their local segment state might look like this:\n\t * ```js\n\t * [\n\t *     { seq: 0, text: \"1234\" },\n\t *     { seq: 5, text: \"56\" },\n\t *     { localSeq: 3, seq: UnassignedSequenceNumber, text: \"A\" },\n\t *     { localSeq: 2, seq: UnassignedSequenceNumber, text: \"B\" },\n\t *     { localSeq: 1, seq: UnassignedSequenceNumber, text: \"C\" },\n\t * ]\n\t * ```\n\t * (note that localSeq tracks the localSeq at which a segment was inserted)\n\t *\n\t * Suppose the client then disconnects and reconnects before any of its insertions are acked. The reconnect flow will necessitate\n\t * that the client regenerates and resubmits ops based on its current segment state as well as the original op that was sent.\n\t *\n\t * It will generate the ops\n\t * 1. \\{ pos: 6, text: \"C\" \\}\n\t * 2. \\{ pos: 6, text: \"B\" \\}\n\t * 3. \\{ pos: 6, text: \"A\" \\}\n\t *\n\t * since when submitting the first op, remote clients don't know that this client is about to submit the \"A\" and \"B\".\n\t *\n\t * On the other hand, imagine if the client had originally submitted the ops in the order \"A\", \"B\", \"C\"\n\t * such that the segments' local state was instead:\n\t *\n\t * ```js\n\t * [\n\t *     { seq: 0, text: \"1234\" },\n\t *     { seq: 5, text: \"56\" },\n\t *     { localSeq: 1, seq: UnassignedSequenceNumber, text: \"A\" },\n\t *     { localSeq: 2, seq: UnassignedSequenceNumber, text: \"B\" },\n\t *     { localSeq: 3, seq: UnassignedSequenceNumber, text: \"C\" },\n\t * ]\n\t * ```\n\t *\n\t * The resubmitted ops should instead be:\n\t * 1. \\{ pos: 6, text: \"A\" \\}\n\t * 2. \\{ pos: 7, text: \"B\" \\}\n\t * 3. \\{ pos: 8, text: \"C\" \\}\n\t *\n\t * since remote clients will have seen the \"A\" when processing the \"B\" as well as both the \"A\" and \"B\" when processing the \"C\".\n\t * As can be seen, the list of resubmitted ops is different in the two cases despite the merge-tree's segment state only differing\n\t * in `localSeq`.\n\t *\n\t * This example is a bit simplified from the general scenario: since no remote clients modified the merge-tree while the client\n\t * was disconnected, the resubmitted ops end up matching the original ops exactly.\n\t * However, this is not generally true: the production reconnect code takes into account visibility of segments based on both acked\n\t * and local information as appropriate.\n\t * Nonetheless, this simple scenario is enough to understand why it's useful to be able to determine if a segment should be visible\n\t * from a given (seq, localSeq) perspective.\n\t */\n\tlocalSeq = 0;\n\n\tpublic localPerspective: Perspective = new LocalDefaultPerspective(this.clientId);\n\n\tpublic loadFrom(a: CollaborationWindow): void {\n\t\tthis.clientId = a.clientId;\n\t\tthis.collaborating = a.collaborating;\n\t\tthis.minSeq = a.minSeq;\n\t\tthis.currentSeq = a.currentSeq;\n\t}\n\n\tpublic mintNextLocalOperationStamp(): OperationStamp {\n\t\tif (this.collaborating) {\n\t\t\tthis.localSeq++;\n\t\t}\n\n\t\treturn {\n\t\t\tseq: this.collaborating ? UnassignedSequenceNumber : UniversalSequenceNumber,\n\t\t\tclientId: this.clientId,\n\t\t\tlocalSeq: this.localSeq,\n\t\t};\n\t}\n}\n\n/**\n * Compares two numbers.\n */\nexport const compareNumbers = (a: number, b: number): number => a - b;\n\n/**\n * Compares two strings.\n */\nexport const compareStrings = (a: string, b: string): number => a.localeCompare(b);\n"]}
+{"version":3,"file":"mergeTreeNodes.js","sourceRoot":"","sources":["../src/mergeTreeNodes.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 type { AttributionKey } from \"@fluidframework/runtime-definitions/internal\";\n\nimport type { IAttributionCollection } from \"./attributionCollection.js\";\nimport {\n\tLocalClientId,\n\tNonCollabClient,\n\tUnassignedSequenceNumber,\n\tUniversalSequenceNumber,\n} from \"./constants.js\";\nimport { LocalReferenceCollection, type LocalReferencePosition } from \"./localReference.js\";\nimport { TrackingGroupCollection, type ITrackingGroup } from \"./mergeTreeTracking.js\";\nimport type { IJSONSegment, IMarkerDef, ReferenceType } from \"./ops.js\";\nimport { computeHierarchicalOrdinal } from \"./ordinal.js\";\nimport type { PartialSequenceLengths } from \"./partialLengths.js\";\nimport { LocalDefaultPerspective, PriorPerspective, type Perspective } from \"./perspective.js\";\nimport { type PropertySet, clone, createMap, type MapLike } from \"./properties.js\";\nimport type { ReferencePosition } from \"./referencePositions.js\";\nimport type { SegmentGroupCollection } from \"./segmentGroupCollection.js\";\nimport {\n\thasProp,\n\tisInserted,\n\tisMergeNodeInfo as isMergeNode,\n\tisRemoved,\n\toverwriteInfo,\n\ttype IHasInsertionInfo,\n\ttype IMergeNodeInfo,\n\ttype IHasRemovalInfo,\n\ttype SegmentWithInfo,\n\ttype ISegmentInsideObliterateInfo,\n\tisInsideObliterate,\n} from \"./segmentInfos.js\";\nimport type { PropertiesManager } from \"./segmentPropertiesManager.js\";\nimport type { Side } from \"./sequencePlace.js\";\nimport type { OperationStamp, SliceRemoveOperationStamp } from \"./stamps.js\";\n\n/**\n * This interface exposes internal things to dds that leverage merge tree,\n * like sequence and matrix.\n *\n * We use tiered interface to control visibility of segment properties.\n * This sits between ISegment and ISegmentPrivate. It should only expose\n * things tagged internal.\n *\n * Everything added here beyond ISegment should be optional to keep the ability\n * to implicitly convert between the tiered interfaces.\n *\n * @internal\n */\nexport interface ISegmentInternal extends ISegment {\n\tlocalRefs?: LocalReferenceCollection;\n\t/**\n\t * Whether or not this segment is a special segment denoting the start or\n\t * end of the tree\n\t *\n\t * Endpoint segments are imaginary segments positioned immediately before or\n\t * after the tree. These segments cannot be referenced by regular operations\n\t * and exist primarily as a bucket for local references to slide onto during\n\t * deletion of regular segments.\n\t */\n\treadonly endpointType?: \"start\" | \"end\";\n}\n\n/**\n * We use tiered interface to control visibility of segment properties.\n * This is the lowest interface and is not exported, it site below ISegment and ISegmentInternal.\n * It should only expose unexported things.\n *\n * Everything added here beyond ISegmentInternal should be optional to keep the ability\n * to implicitly convert between the tiered interfaces.\n *\n * someday we may split tree leaves from segments, but for now they are the same\n * this is just a convenience type that makes it clear that we need something that is both a segment and a leaf node\n */\nexport interface ISegmentPrivate extends ISegmentInternal {\n\tsegmentGroups?: SegmentGroupCollection;\n\tpropertyManager?: PropertiesManager;\n}\n/**\n * Segment leafs are segments that have both IMergeNodeInfo and IHasInsertionInfo. This means they\n * are inserted at a position, and bound via their parent MergeBlock to the merge tree. MergeBlocks'\n * children are either a segment leaf, or another merge block for interior nodes of the tree. When working\n * within the tree it is generally unnecessary to use type coercions methods common to the infos, and segment\n * leafs, as the children of MergeBlocks are already well typed. However, when segments come from outside the\n * merge tree, like via client's public methods, it becomes necessary to use the type coercions methods\n * to ensure the passed in segment objects are correctly bound to the merge tree.\n */\nexport type ISegmentLeaf = SegmentWithInfo<IMergeNodeInfo & IHasInsertionInfo>;\n/**\n * A type-guard which determines if the segment has segment leaf, and\n * returns true if it does, along with applying strong typing.\n * @param nodeLike - The segment-like object to check.\n * @returns True if the segment is a segment leaf, otherwise false.\n */\nexport const isSegmentLeaf = (segmentLike: unknown): segmentLike is ISegmentLeaf =>\n\tisInserted(segmentLike) && isMergeNode(segmentLike);\n\n/**\n * Converts a segment-like object to a segment leaf object if possible.\n *\n * @param segmentLike - The segment-like object to convert.\n * @returns The segment leaf if the conversion is possible, otherwise undefined.\n */\nexport const toSegmentLeaf = (segmentLike: unknown): ISegmentLeaf | undefined =>\n\tisSegmentLeaf(segmentLike) ? segmentLike : undefined;\n/**\n * Asserts that the segment is a segment leaf. Usage of this function should not produce a user facing error.\n *\n * @param segmentLike - The segment-like object to check.\n * @throws Will throw an error if the segment is not a segment leaf.\n */\nexport const assertSegmentLeaf: (segmentLike: unknown) => asserts segmentLike is ISegmentLeaf =\n\t(segmentLike) => assert(isSegmentLeaf(segmentLike), 0xaab /* must be segment leaf */);\n/**\n * This type is used for building MergeBlocks from segments and other MergeBlocks. We need this\n * type as segments may not yet be bound to the tree, so lack merge node info which is required for\n * segment leafs.\n */\nexport type IMergeNodeBuilder = MergeBlock | SegmentWithInfo<IHasInsertionInfo>;\n\n/**\n * This type is used by MergeBlocks to define their children, which are either segments or other\n * MergeBlocks.\n */\nexport type IMergeNode = MergeBlock | ISegmentLeaf;\n\n/**\n * A segment representing a portion of the merge tree.\n * Segments are leaf nodes of the merge tree and contain data.\n * @legacy @beta\n */\nexport interface ISegment {\n\treadonly type: string;\n\n\treadonly trackingCollection: TrackingGroupCollection;\n\n\t/**\n\t * The length of the contents of the node.\n\t */\n\tcachedLength: number;\n\t/**\n\t * Stores attribution keys associated with offsets of this segment.\n\t * This data is only persisted if MergeTree's `attributions.track` flag is set to true.\n\t * Pending segments (i.e. ones that only exist locally and haven't been acked by the server) also have\n\t * `attribution === undefined` until ack.\n\t *\n\t * Keys can be used opaquely with an IAttributor or a container runtime that provides attribution.\n\t * @remarks There are plans to make the shape of the data stored extensible in a couple ways:\n\t *\n\t * 1. Injection of custom attribution information associated with the segment (ex: copy-paste of\n\t * content but keeping the old attribution information).\n\t *\n\t * 2. Storage of multiple \"channels\" of information (ex: track property changes separately from insertion,\n\t * or only attribute certain property modifications, etc.)\n\t */\n\tattribution?: IAttributionCollection<AttributionKey>;\n\n\t/**\n\t * Properties that have been added to this segment via annotation.\n\t */\n\tproperties?: PropertySet;\n\n\tclone(): ISegment;\n\tcanAppend(segment: ISegment): boolean;\n\tappend(segment: ISegment): void;\n\tsplitAt(pos: number): ISegment | undefined;\n\t// Changing this to something other than any would break consumers.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\ttoJSONObject(): any;\n\tisLeaf(): this is ISegment;\n}\n\n/**\n * Determine if a segment has been removed.\n * @legacy @beta\n */\nexport function segmentIsRemoved(segment: ISegment): boolean {\n\treturn isRemoved(segment);\n}\n\n/**\n * @legacy @beta\n */\nexport interface ISegmentAction<TClientData> {\n\t// eslint-disable-next-line @typescript-eslint/prefer-function-type\n\t(\n\t\tsegment: ISegment,\n\t\tpos: number,\n\t\trefSeq: number,\n\t\tclientId: number,\n\t\tstart: number,\n\t\tend: number,\n\t\taccum: TClientData,\n\t): boolean;\n}\nexport interface ISegmentChanges {\n\tnext?: SegmentWithInfo<IHasInsertionInfo>;\n\treplaceCurrent?: SegmentWithInfo<IHasInsertionInfo>;\n}\n\nexport interface InsertContext {\n\tcandidateSegment?: SegmentWithInfo<IHasInsertionInfo>;\n\tleaf: (segment: ISegmentLeaf | undefined, pos: number, ic: InsertContext) => ISegmentChanges;\n\tcontinuePredicate?: (continueFromBlock: MergeBlock) => boolean;\n}\n\nexport interface ObliterateInfo {\n\tstart: LocalReferencePosition;\n\tstartSide: Side;\n\tend: LocalReferencePosition;\n\tendSide: Side;\n\trefSeq: number;\n\tstamp: SliceRemoveOperationStamp;\n\tsegmentGroup: SegmentGroup | undefined;\n\t/**\n\t * Defined only for unacked obliterates.\n\t *\n\t * Contains all segments inserted into the range this obliterate affects where at the time of insertion,\n\t * this obliterate was the newest concurrent obliterate that overlapped the insertion point (this information\n\t * is relevant for the tiebreak policy of allowing last-obliterater to insert).\n\t *\n\t * We need to keep this around for unacked ops because on reconnect, outstanding local obliterates may have set `obliteratePrecedingInsertion`\n\t * (tiebreak) on segments they no longer apply to, since the reissued obliterate may affect a smaller range than the original one when content\n\t * near the obliterate's endpoints was removed by another client between the time of the original obliterate and reissuing.\n\t */\n\ttiebreakTrackingGroup: ITrackingGroup | undefined;\n}\n\nexport interface SegmentGroup {\n\tsegments: ISegmentLeaf[];\n\tpreviousProps?: PropertySet[];\n\tlocalSeq?: number;\n\trefSeq: number;\n\tobliterateInfo?: ObliterateInfo;\n}\n\n/**\n * Note that the actual branching factor of the MergeTree is `MaxNodesInBlock - 1`.  This is because\n * the MergeTree always inserts first, then checks for overflow and splits if the child count equals\n * `MaxNodesInBlock`.  (i.e., `MaxNodesInBlock` contains 1 extra slot for temporary storage to\n * facilitate splits.)\n */\nexport const MaxNodesInBlock = 8;\nexport class MergeBlock implements Partial<IMergeNodeInfo> {\n\tpublic children: IMergeNode[];\n\tpublic needsScour?: boolean;\n\tpublic parent?: MergeBlock;\n\tpublic index: number = 0;\n\tpublic ordinal: string = \"\";\n\tpublic cachedLength: number | undefined = 0;\n\n\t/**\n\t * Maps each tile label in this block to the rightmost (i.e. furthest) marker associated with that tile label.\n\t * When combined with the tree structure of MergeBlocks, this allows accelerated queries for nearest tile\n\t * with a certain label before a given position\n\t */\n\tpublic rightmostTiles: Readonly<MapLike<Marker>>;\n\t/**\n\t * Maps each tile label in this block to the leftmost (i.e. nearest) marker associated with that tile label.\n\t * When combined with the tree structure of MergeBlocks, this allows accelerated queries for nearest tile\n\t * with a certain label before a given position\n\t */\n\tpublic leftmostTiles: Readonly<MapLike<Marker>>;\n\n\tisLeaf(): this is ISegmentInternal {\n\t\treturn false;\n\t}\n\n\t/**\n\t * Supports querying the total length of all descendants of this IMergeBlock from the perspective of any\n\t * (clientId, seq) within the collab window.\n\t *\n\t * @remarks This is only optional for implementation reasons (internal nodes can be created/moved without\n\t * immediately initializing the partial lengths). Aside from mid-update on tree operations, these lengths\n\t * objects are always defined.\n\t */\n\tpartialLengths?: PartialSequenceLengths;\n\n\tpublic constructor(public childCount: number) {\n\t\t// Suppression needed due to the way the merge tree children are initialized - we\n\t\t// allocate 8 children blocks, but any unused blocks are not counted in the childCount.\n\t\t// Using Array.from leads to unused children being undefined, which are counted in childCount.\n\t\t// eslint-disable-next-line unicorn/no-new-array\n\t\tthis.children = new Array<IMergeNode>(MaxNodesInBlock);\n\t\tthis.rightmostTiles = createMap<Marker>();\n\t\tthis.leftmostTiles = createMap<Marker>();\n\t}\n\n\tpublic setOrdinal(child: IMergeNode, index: number): void {\n\t\tconst childCount = this.childCount;\n\t\tassert(\n\t\t\tchildCount >= 1 && childCount <= MaxNodesInBlock,\n\t\t\t0x040 /* \"Child count is not within [1,8] range!\" */,\n\t\t);\n\t\tchild.ordinal = computeHierarchicalOrdinal(\n\t\t\tMaxNodesInBlock,\n\t\t\tchildCount,\n\t\t\tthis.ordinal,\n\t\t\tindex === 0 ? undefined : this.children[index - 1]?.ordinal,\n\t\t);\n\t}\n}\nexport function assignChild<C extends IMergeNodeBuilder>(\n\tparent: MergeBlock,\n\tchild: C,\n\tindex: number,\n\tupdateOrdinal = true,\n): asserts child is C & IMergeNodeInfo {\n\tconst node = Object.assign<C, IMergeNodeInfo>(child, {\n\t\tparent,\n\t\tindex,\n\t\tordinal: hasProp(child, \"ordinal\", \"string\") ? child.ordinal : \"\",\n\t});\n\tif (updateOrdinal) {\n\t\tparent.setOrdinal(node, index);\n\t}\n\tparent.children[index] = node;\n}\n\nexport function seqLTE(seq: number, minOrRefSeq: number): boolean {\n\treturn seq !== UnassignedSequenceNumber && seq <= minOrRefSeq;\n}\n\n/**\n * @legacy @beta\n */\nexport abstract class BaseSegment implements ISegment {\n\tpublic cachedLength: number = 0;\n\n\tpublic readonly trackingCollection: TrackingGroupCollection = new TrackingGroupCollection(\n\t\tthis,\n\t);\n\t/***/\n\tpublic attribution?: IAttributionCollection<AttributionKey>;\n\n\tpublic properties?: PropertySet;\n\tpublic abstract readonly type: string;\n\tpublic constructor(properties?: PropertySet) {\n\t\tif (properties !== undefined) {\n\t\t\tthis.properties = clone(properties);\n\t\t}\n\t}\n\n\tpublic hasProperty(key: string): boolean {\n\t\treturn !!this.properties && this.properties[key] !== undefined;\n\t}\n\n\tpublic isLeaf(): this is ISegment {\n\t\treturn true;\n\t}\n\n\tprotected cloneInto(b: ISegment): void {\n\t\tconst seg: ISegmentPrivate = b;\n\t\tif (isInserted(this)) {\n\t\t\toverwriteInfo<IHasInsertionInfo>(seg, {\n\t\t\t\tinsert: this.insert,\n\t\t\t});\n\t\t}\n\t\t// TODO: deep clone properties\n\t\tseg.properties = clone(this.properties);\n\t\tif (isRemoved(this)) {\n\t\t\toverwriteInfo<IHasRemovalInfo>(seg, {\n\t\t\t\tremoves: [...this.removes],\n\t\t\t});\n\t\t}\n\n\t\tseg.attribution = this.attribution?.clone();\n\t}\n\n\tpublic canAppend(segment: ISegment): boolean {\n\t\treturn false;\n\t}\n\n\tprotected addSerializedProps(jseg: IJSONSegment): void {\n\t\tif (this.properties) {\n\t\t\tjseg.props = { ...this.properties };\n\t\t}\n\t}\n\t// This has to return any type because the return type is different for different segment types.\n\t// TODO: If possible, change the return type to match what should be returned for each segment type.\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tpublic abstract toJSONObject(): any;\n\n\tpublic splitAt(pos: number): ISegment | undefined {\n\t\tif (pos <= 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst leafSegment: ISegmentPrivate | undefined = this.createSplitSegmentAt(pos);\n\n\t\tif (!leafSegment) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tif (isMergeNode(this)) {\n\t\t\toverwriteInfo<IMergeNodeInfo>(leafSegment, {\n\t\t\t\tindex: this.index + 1,\n\t\t\t\t// Give the leaf a temporary yet valid ordinal.\n\t\t\t\t// when this segment is put in the tree, it will get its real ordinal,\n\t\t\t\t// but this ordinal meets all the necessary invariants for now.\n\t\t\t\t// Ordinals exist purely for lexicographical sort order and use a small set of valid bytes for each string character.\n\t\t\t\t// The extra handling fromCodePoint has for things like surrogate pairs is therefore unnecessary.\n\t\t\t\t// eslint-disable-next-line unicorn/prefer-code-point\n\t\t\t\tordinal: this.ordinal + String.fromCharCode(0),\n\t\t\t\tparent: this.parent,\n\t\t\t});\n\t\t}\n\n\t\tif (isInserted(this)) {\n\t\t\toverwriteInfo<IHasInsertionInfo>(leafSegment, { insert: this.insert });\n\t\t}\n\t\tif (isRemoved(this)) {\n\t\t\toverwriteInfo<IHasRemovalInfo>(leafSegment, {\n\t\t\t\tremoves: [...this.removes],\n\t\t\t});\n\t\t}\n\t\tif (isInsideObliterate(this)) {\n\t\t\toverwriteInfo<ISegmentInsideObliterateInfo>(leafSegment, {\n\t\t\t\tobliteratePrecedingInsertion: this.obliteratePrecedingInsertion,\n\t\t\t\tinsertionRefSeqStamp: this.insertionRefSeqStamp,\n\t\t\t});\n\t\t}\n\n\t\tthis.trackingCollection.copyTo(leafSegment);\n\t\tif (this.attribution) {\n\t\t\tleafSegment.attribution = this.attribution.splitAt(pos);\n\t\t}\n\n\t\treturn leafSegment;\n\t}\n\n\tpublic abstract clone(): ISegment;\n\n\tpublic append(other: ISegment): void {\n\t\t// Note: Must call 'appendLocalRefs' before modifying this segment's length as\n\t\t//       'this.cachedLength' is used to adjust the offsets of the local refs.\n\t\tLocalReferenceCollection.append(this, other);\n\t\tif (this.attribution) {\n\t\t\tassert(\n\t\t\t\tother.attribution !== undefined,\n\t\t\t\t0x4bd /* attribution should be set on appendee */,\n\t\t\t);\n\t\t\tthis.attribution.append(other.attribution);\n\t\t} else {\n\t\t\tassert(\n\t\t\t\tother.attribution === undefined,\n\t\t\t\t0x4be /* attribution should not be set on appendee */,\n\t\t\t);\n\t\t}\n\n\t\tthis.cachedLength ??= 0;\n\t\tthis.cachedLength += other.cachedLength;\n\t}\n\n\tprotected abstract createSplitSegmentAt(pos: number): BaseSegment | undefined;\n}\n\n/**\n * The special-cased property key that tracks the id of a {@link Marker}.\n *\n * @remarks In general, marker ids should be accessed using the inherent method\n * {@link Marker.getId}. Marker ids should not be updated after creation.\n * @legacy @beta\n */\nexport const reservedMarkerIdKey = \"markerId\";\n\n/**\n * @internal\n */\nexport const reservedMarkerSimpleTypeKey = \"markerSimpleType\";\n\n/**\n * @legacy @beta\n */\nexport interface IJSONMarkerSegment extends IJSONSegment {\n\tmarker: IMarkerDef;\n}\n\n/**\n * Markers are a special kind of segment that do not hold any content.\n *\n * Markers with a reference type of {@link ReferenceType.Tile} support spatially\n * accelerated queries for finding the next marker to the left or right of it in\n * sub-linear time. This is useful, for example, in the case of jumping from the\n * start of a paragraph to the end, assuming a paragraph is bound by markers at\n * the start and end.\n *\n * @legacy @beta\n */\nexport class Marker extends BaseSegment implements ReferencePosition, ISegment {\n\tpublic static readonly type = \"Marker\";\n\tpublic static is(segment: ISegment): segment is Marker {\n\t\treturn segment.type === Marker.type;\n\t}\n\tpublic readonly type = Marker.type;\n\n\tpublic static make(refType: ReferenceType, props?: PropertySet): Marker {\n\t\treturn new Marker(refType, props);\n\t}\n\n\tconstructor(\n\t\tpublic refType: ReferenceType,\n\t\tprops?: PropertySet,\n\t) {\n\t\tsuper(props);\n\t\tthis.cachedLength = 1;\n\t}\n\n\ttoJSONObject(): IJSONMarkerSegment {\n\t\tconst obj: IJSONMarkerSegment = { marker: { refType: this.refType } };\n\t\tsuper.addSerializedProps(obj);\n\t\treturn obj;\n\t}\n\n\tstatic fromJSONObject(spec: IJSONSegment): Marker | undefined {\n\t\tif (spec && typeof spec === \"object\" && \"marker\" in spec) {\n\t\t\treturn Marker.make((spec.marker as Marker).refType, spec.props as PropertySet);\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tclone(): Marker {\n\t\tconst b = Marker.make(this.refType, this.properties);\n\t\tthis.cloneInto(b);\n\t\treturn b;\n\t}\n\n\tgetSegment(): Marker {\n\t\treturn this;\n\t}\n\n\tgetOffset(): number {\n\t\treturn 0;\n\t}\n\n\tgetProperties(): PropertySet | undefined {\n\t\treturn this.properties;\n\t}\n\n\tgetId(): string | undefined {\n\t\treturn this.properties?.[reservedMarkerIdKey] as string;\n\t}\n\n\ttoString(): string {\n\t\treturn `M${this.getId()}`;\n\t}\n\n\tprotected createSplitSegmentAt(pos: number): undefined {\n\t\treturn undefined;\n\t}\n\n\tcanAppend(segment: ISegment): boolean {\n\t\treturn false;\n\t}\n\n\tappend(): void {\n\t\tthrow new Error(\"Can not append to marker\");\n\t}\n}\n\n/**\n * Returns a stamp that occurs at the minimum sequence number.\n * @privateRemarks\n * This is a free function over something obtainable on CollaborationWindow to avoid exposing Perspective\n * and OperationStamp from the package (even internally), at least for now.\n * If/when `Client`'s API is refactored to be structured similarly to MergeTree (so that SharedString passes in\n * things closer to `Perspective`s when calling methods on `Client` rather than refSeq/localSeq/clientId etc),\n * it may be more reasonable to expose this more directly on `CollaborationWindow`.\n */\nexport function getMinSeqStamp(collabWindow: CollaborationWindow): OperationStamp {\n\treturn { seq: collabWindow.minSeq, clientId: NonCollabClient };\n}\n\n/**\n * Returns a perspective representing a readonly client's view of the tree at the minimum sequence number.\n * @privateRemarks\n * This is a free function over something obtainable on CollaborationWindow to avoid exposing Perspective\n * and OperationStamp from the package (even internally), at least for now.\n * If/when `Client`'s API is refactored to be structured similarly to MergeTree (so that SharedString passes in\n * things closer to `Perspective`s when calling methods on `Client` rather than refSeq/localSeq/clientId etc),\n * it may be more reasonable to expose this more directly on `CollaborationWindow`.\n */\nexport function getMinSeqPerspective(collabWindow: CollaborationWindow): Perspective {\n\treturn new PriorPerspective(collabWindow.minSeq, NonCollabClient);\n}\n\n/**\n * This class is used to track facts about the current window of collaboration. This window is defined by the server\n * specified minimum sequence number to the last sequence number seen. Additionally, it track state for outstanding\n * local operations.\n * @internal\n */\nexport class CollaborationWindow {\n\tclientId = LocalClientId;\n\tcollaborating = false;\n\n\t/**\n\t * Lowest-numbered segment in window; no client can reference a state before this one\n\t */\n\tminSeq = 0;\n\t/**\n\t * Highest-numbered segment in window and current reference sequence number for this client.\n\t */\n\tcurrentSeq = 0;\n\n\t/**\n\t * Highest-numbered localSeq used for a pending segment.\n\t * Semantically, `localSeq`s provide an ordering on in-flight merge-tree operations:\n\t * for operations stamped with localSeqs `a` and `b`, `a < b` if and only if `a` was submitted before `b`.\n\t *\n\t * @remarks This field is analogous to the `clientSequenceNumber` field on ops, but it's accessible to merge-tree\n\t * at op submission time rather than only at ack time. This enables more natural state tracking for in-flight ops.\n\t *\n\t * It's useful to stamp ops with such an incrementing counter because it enables reasoning about which segments existed from\n\t * the perspective of the local client at a given point in 'un-acked' time, which is necessary to support the reconnect flow.\n\t *\n\t * For example, imagine a client with initial state \"123456\" submits some ops to create the text \"123456ABC\".\n\t * If they insert the \"C\" first, then \"B\", then \"A\", their local segment state might look like this:\n\t * ```js\n\t * [\n\t *     { seq: 0, text: \"1234\" },\n\t *     { seq: 5, text: \"56\" },\n\t *     { localSeq: 3, seq: UnassignedSequenceNumber, text: \"A\" },\n\t *     { localSeq: 2, seq: UnassignedSequenceNumber, text: \"B\" },\n\t *     { localSeq: 1, seq: UnassignedSequenceNumber, text: \"C\" },\n\t * ]\n\t * ```\n\t * (note that localSeq tracks the localSeq at which a segment was inserted)\n\t *\n\t * Suppose the client then disconnects and reconnects before any of its insertions are acked. The reconnect flow will necessitate\n\t * that the client regenerates and resubmits ops based on its current segment state as well as the original op that was sent.\n\t *\n\t * It will generate the ops\n\t * 1. \\{ pos: 6, text: \"C\" \\}\n\t * 2. \\{ pos: 6, text: \"B\" \\}\n\t * 3. \\{ pos: 6, text: \"A\" \\}\n\t *\n\t * since when submitting the first op, remote clients don't know that this client is about to submit the \"A\" and \"B\".\n\t *\n\t * On the other hand, imagine if the client had originally submitted the ops in the order \"A\", \"B\", \"C\"\n\t * such that the segments' local state was instead:\n\t *\n\t * ```js\n\t * [\n\t *     { seq: 0, text: \"1234\" },\n\t *     { seq: 5, text: \"56\" },\n\t *     { localSeq: 1, seq: UnassignedSequenceNumber, text: \"A\" },\n\t *     { localSeq: 2, seq: UnassignedSequenceNumber, text: \"B\" },\n\t *     { localSeq: 3, seq: UnassignedSequenceNumber, text: \"C\" },\n\t * ]\n\t * ```\n\t *\n\t * The resubmitted ops should instead be:\n\t * 1. \\{ pos: 6, text: \"A\" \\}\n\t * 2. \\{ pos: 7, text: \"B\" \\}\n\t * 3. \\{ pos: 8, text: \"C\" \\}\n\t *\n\t * since remote clients will have seen the \"A\" when processing the \"B\" as well as both the \"A\" and \"B\" when processing the \"C\".\n\t * As can be seen, the list of resubmitted ops is different in the two cases despite the merge-tree's segment state only differing\n\t * in `localSeq`.\n\t *\n\t * This example is a bit simplified from the general scenario: since no remote clients modified the merge-tree while the client\n\t * was disconnected, the resubmitted ops end up matching the original ops exactly.\n\t * However, this is not generally true: the production reconnect code takes into account visibility of segments based on both acked\n\t * and local information as appropriate.\n\t * Nonetheless, this simple scenario is enough to understand why it's useful to be able to determine if a segment should be visible\n\t * from a given (seq, localSeq) perspective.\n\t */\n\tlocalSeq = 0;\n\n\tpublic localPerspective: Perspective = new LocalDefaultPerspective(this.clientId);\n\n\tpublic loadFrom(a: CollaborationWindow): void {\n\t\tthis.clientId = a.clientId;\n\t\tthis.collaborating = a.collaborating;\n\t\tthis.minSeq = a.minSeq;\n\t\tthis.currentSeq = a.currentSeq;\n\t}\n\n\tpublic mintNextLocalOperationStamp(): OperationStamp {\n\t\tif (this.collaborating) {\n\t\t\tthis.localSeq++;\n\t\t}\n\n\t\treturn {\n\t\t\tseq: this.collaborating ? UnassignedSequenceNumber : UniversalSequenceNumber,\n\t\t\tclientId: this.clientId,\n\t\t\tlocalSeq: this.localSeq,\n\t\t};\n\t}\n}\n\n/**\n * Compares two numbers.\n */\nexport const compareNumbers = (a: number, b: number): number => a - b;\n\n/**\n * Compares two strings.\n */\nexport const compareStrings = (a: string, b: string): number => a.localeCompare(b);\n"]}

package/dist/mergeTreeTracking.js

@@ -10,6 +10,7 @@ const sortedSegmentSet_js_1 = require("./sortedSegmentSet.js");
  * @legacy @beta
  */
 class TrackingGroup {
+    trackedSet;
     constructor() {
         this.trackedSet = new sortedSegmentSet_js_1.SortedSegmentSet();
     }
@@ -41,6 +42,7 @@ exports.TrackingGroup = TrackingGroup;
  * Tracking group backed by an unordered set. Lookup, insertion, and deletion are O(1)
  */
 class UnorderedTrackingGroup {
+    trackedSet;
     constructor() {
         this.trackedSet = new Set();
     }
@@ -73,6 +75,8 @@ exports.UnorderedTrackingGroup = UnorderedTrackingGroup;
  * @legacy @beta
  */
 class TrackingGroupCollection {
+    trackable;
+    _trackingGroups;
     get trackingGroups() {
         // Cast here is necessary to avoid a breaking change to
         // `TrackingGroupCollection`. Ideally we could just return