@fluidframework/merge-tree 0.59.2000-63294 → 0.59.3000-66610

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/merge-tree",
-  "version": "0.59.2000-63294",
+  "version": "0.59.3000-66610",
   "description": "Merge tree",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -63,19 +63,20 @@
     "@fluidframework/common-utils": "^0.32.1",
     "@fluidframework/container-definitions": "^0.48.1000",
     "@fluidframework/core-interfaces": "^0.43.1000",
-    "@fluidframework/datastore-definitions": "0.59.2000-63294",
+    "@fluidframework/datastore-definitions": "0.59.3000-66610",
     "@fluidframework/protocol-definitions": "^0.1028.1000",
-    "@fluidframework/runtime-definitions": "0.59.2000-63294",
-    "@fluidframework/runtime-utils": "0.59.2000-63294",
-    "@fluidframework/shared-object-base": "0.59.2000-63294",
-    "@fluidframework/telemetry-utils": "0.59.2000-63294"
+    "@fluidframework/runtime-definitions": "0.59.3000-66610",
+    "@fluidframework/runtime-utils": "0.59.3000-66610",
+    "@fluidframework/shared-object-base": "0.59.3000-66610",
+    "@fluidframework/telemetry-utils": "0.59.3000-66610"
   },
   "devDependencies": {
     "@fluidframework/build-common": "^0.23.0",
-    "@fluidframework/eslint-config-fluid": "^0.28.1000",
-    "@fluidframework/merge-tree-previous": "npm:@fluidframework/merge-tree@^0.58.0",
-    "@fluidframework/mocha-test-setup": "0.59.2000-63294",
-    "@fluidframework/test-runtime-utils": "0.59.2000-63294",
+    "@fluidframework/build-tools": "^0.2.66048",
+    "@fluidframework/eslint-config-fluid": "^0.28.2000-0",
+    "@fluidframework/merge-tree-previous": "npm:@fluidframework/merge-tree@0.59.2000",
+    "@fluidframework/mocha-test-setup": "0.59.3000-66610",
+    "@fluidframework/test-runtime-utils": "0.59.3000-66610",
     "@microsoft/api-extractor": "^7.22.2",
     "@rushstack/eslint-config": "^2.5.1",
     "@types/diff": "^3.5.1",
@@ -103,12 +104,80 @@
     "random-js": "^1.0.8",
     "rimraf": "^2.6.2",
     "source-map-support": "^0.5.16",
-    "typescript": "~4.1.3",
+    "typescript": "~4.5.5",
     "typescript-formatter": "7.1.0"
   },
   "typeValidation": {
-    "version": "0.59.1000",
-    "broken": {},
-    "disabled": true
+    "version": "0.59.3000",
+    "broken": {
+      "InterfaceDeclaration_IMergeTreeAnnotateMsg": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IMergeTreeDelta": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IMergeTreeDeltaCallbackArgs": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "TypeAliasDeclaration_IMergeTreeDeltaOp": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IMergeTreeDeltaOpArgs": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IMergeTreeGroupMsg": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IMergeTreeInsertMsg": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IMergeTreeMaintenanceCallbackArgs": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "TypeAliasDeclaration_IMergeTreeOp": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IMergeTreeRemoveMsg": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "TypeAliasDeclaration_IntervalNode": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "TypeAliasDeclaration_MergeTreeDeltaOperationType": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "TypeAliasDeclaration_MergeTreeDeltaOperationTypes": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "EnumDeclaration_MergeTreeDeltaType": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "EnumDeclaration_MergeTreeMaintenanceType": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "EnumDeclaration_RBColor": {
+        "forwardCompat": false,
+        "backCompat": false
+      },
+      "InterfaceDeclaration_RBNode": {
+        "forwardCompat": false,
+        "backCompat": false
+      }
+    }
   }
 }

package/src/client.ts

@@ -25,7 +25,6 @@ import {
     ISegmentAction,
     Marker,
     MergeTree,
-    RangeStackMap,
     SegmentGroup,
 } from "./mergeTree";
 import { MergeTreeDeltaCallback } from "./mergeTreeDeltaCallback";
@@ -53,11 +52,11 @@ import { SnapshotLegacy } from "./snapshotlegacy";
 import { SnapshotLoader } from "./snapshotLoader";
 import { MergeTreeTextHelper } from "./textSegment";
 import { SnapshotV1 } from "./snapshotV1";
+import { ReferencePosition, RangeStackMap } from "./referencePositions";
 import {
     IMergeTreeClientSequenceArgs,
     IMergeTreeDeltaOpArgs,
     MergeTreeMaintenanceCallback,
-    ReferencePosition,
 } from "./index";
 
 function elapsedMicroseconds(trace: Trace) {
@@ -629,8 +628,7 @@ export class Client {
     getLongClientId(shortClientId: number) {
         if (shortClientId >= 0) {
             return this.shortClientIdMap[shortClientId];
-        }
-        else {
+        } else {
             return "original";
         }
     }
@@ -780,22 +778,29 @@ export class Client {
 
     public applyStashedOp(op: IMergeTreeDeltaOp): SegmentGroup;
     public applyStashedOp(op: IMergeTreeGroupMsg): SegmentGroup[];
-    public applyStashedOp(op: IMergeTreeOp) {
+    public applyStashedOp(op: IMergeTreeOp): SegmentGroup | SegmentGroup[];
+    public applyStashedOp(op: IMergeTreeOp): SegmentGroup | SegmentGroup[] {
+        let metadata: SegmentGroup | SegmentGroup[] | undefined;
         switch (op.type) {
             case MergeTreeDeltaType.INSERT:
                 this.applyInsertOp({ op });
-                return this.peekPendingSegmentGroups();
+                metadata = this.peekPendingSegmentGroups();
+                break;
             case MergeTreeDeltaType.REMOVE:
                 this.applyRemoveRangeOp({ op });
-                return this.peekPendingSegmentGroups();
+                metadata = this.peekPendingSegmentGroups();
+                break;
             case MergeTreeDeltaType.ANNOTATE:
                 this.applyAnnotateRangeOp({ op });
-                return this.peekPendingSegmentGroups();
+                metadata = this.peekPendingSegmentGroups();
+                break;
             case MergeTreeDeltaType.GROUP:
                 return op.ops.map((o) => this.applyStashedOp(o));
             default:
                 unreachableCase(op, "unrecognized op type");
         }
+        assert(!!metadata, 0x2db /* "Applying op must generate a pending segment" */);
+        return metadata;
     }
 
     public applyMsg(msg: ISequencedDocumentMessage, local: boolean = false) {
@@ -809,8 +814,7 @@ export class Client {
             };
             if (opArgs.sequencedMessage?.clientId === this.longClientId || local) {
                 this.ackPendingSegment(opArgs);
-            }
-            else {
+            } else {
                 this.applyRemoteOp(opArgs);
             }
         }
@@ -915,7 +919,7 @@ export class Client {
             assert(
                 catchUpMsgs === undefined || catchUpMsgs.length === 0,
                 0x03f /* "New format should not emit catchup ops" */);
-            const snap = new SnapshotV1(this.mergeTree, this.logger, (id)=>this.getLongClientId(id));
+            const snap = new SnapshotV1(this.mergeTree, this.logger, (id) => this.getLongClientId(id));
             snap.extractSync();
             return snap.emit(serializer, handle);
         } else {
@@ -929,7 +933,7 @@ export class Client {
         runtime: IFluidDataStoreRuntime,
         storage: IChannelStorageService,
         serializer: IFluidSerializer,
-    ): Promise<{ catchupOpsP: Promise<ISequencedDocumentMessage[]> }> {
+    ): Promise<{ catchupOpsP: Promise<ISequencedDocumentMessage[]>; }> {
         const loader = new SnapshotLoader(runtime, this, this.mergeTree, this.logger, serializer);
 
         return loader.initialize(storage);
@@ -943,8 +947,7 @@ export class Client {
         const segWindow = this.getCollabWindow();
         if (segWindow.collaborating) {
             return UnassignedSequenceNumber;
-        }
-        else {
+        } else {
             return UniversalSequenceNumber;
         }
     }
@@ -998,9 +1001,8 @@ export class Client {
         let clientId: number;
         if (op) {
             clientId = this.getOrAddShortClientId(op.clientId);
-            seq = op.sequenceNumber;
-        }
-        else {
+            seq = op.referenceSequenceNumber;
+        } else {
             const segWindow = this.mergeTree.getCollabWindow();
             seq = segWindow.currentSeq;
             clientId = segWindow.clientId;

package/src/collections.ts

@@ -38,11 +38,9 @@ export class Stack<T> {
 function ListRemoveEntry<U>(entry: List<U>): List<U> | undefined {
     if (entry === undefined) {
         return undefined;
-    }
-    else if (entry.isHead) {
+    } else if (entry.isHead) {
         return undefined;
-    }
-    else {
+    } else {
         entry.next.prev = entry.prev;
         entry.prev.next = entry.next;
     }
@@ -286,11 +284,9 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
             const cmp = this.compareKeys(key, _node.key);
             if (cmp < 0) {
                 _node = _node.left;
-            }
-            else if (cmp > 0) {
+            } else if (cmp > 0) {
                 _node = _node.right;
-            }
-            else {
+            } else {
                 return _node;
             }
         }
@@ -387,8 +383,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
         if (key !== undefined) {
             if (data === undefined) {
                 this.remove(key);
-            }
-            else {
+            } else {
                 this.root = this.nodePut(this.root, key, data, conflict);
                 this.root.color = RBColor.BLACK;
             }
@@ -403,16 +398,13 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
         let _node = node;
         if (!_node) {
             return this.makeNode(key, data, RBColor.RED, 1);
-        }
-        else {
+        } else {
             const cmp = this.compareKeys(key, _node.key);
             if (cmp < 0) {
                 _node.left = this.nodePut(_node.left, key, data, conflict);
-            }
-            else if (cmp > 0) {
+            } else if (cmp > 0) {
                 _node.right = this.nodePut(_node.right, key, data, conflict);
-            }
-            else {
+            } else {
                 if (conflict) {
                     const kd = conflict(key, _node.key, data, _node.data);
                     if (kd.key) {
@@ -423,8 +415,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
                     } else {
                         _node.data = data;
                     }
-                }
-                else {
+                } else {
                     _node.data = data;
                 }
             }
@@ -504,8 +495,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
             }
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             _node.left = this.nodeRemove(_node.left!, key);
-        }
-        else {
+        } else {
             if (this.isRed(_node.left)) {
                 _node = this.rotateRight(_node);
             }
@@ -523,8 +513,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
                 _node.data = subtreeMin.data;
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 _node.right = this.nodeRemoveMin(_node.right!);
-            }
-            else {
+            } else {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 _node.right = this.nodeRemove(_node.right!, key);
             }
@@ -543,16 +532,13 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
             const cmp = this.compareKeys(key, node.key);
             if (cmp === 0) {
                 return node;
-            }
-            else if (cmp < 0) {
+            } else if (cmp < 0) {
                 return this.nodeFloor(node.left, key);
-            }
-            else {
+            } else {
                 const rightFloor = this.nodeFloor(node.right, key);
                 if (rightFloor) {
                     return rightFloor;
-                }
-                else {
+                } else {
                     return node;
                 }
             }
@@ -570,16 +556,13 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
             const cmp = this.compareKeys(key, node.key);
             if (cmp === 0) {
                 return node;
-            }
-            else if (cmp > 0) {
+            } else if (cmp > 0) {
                 return this.nodeCeil(node.right, key);
-            }
-            else {
+            } else {
                 const leftCeil = this.nodeCeil(node.left, key);
                 if (leftCeil) {
                     return leftCeil;
-                }
-                else {
+                } else {
                     return node;
                 }
             }
@@ -595,8 +578,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
     private nodeMin(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
         if (!node.left) {
             return node;
-        }
-        else {
+        } else {
             return this.nodeMin(node.left);
         }
     }
@@ -610,8 +592,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
     private nodeMax(node: RBNode<TKey, TData>): RBNode<TKey, TData> {
         if (!node.right) {
             return node;
-        }
-        else {
+        } else {
             return this.nodeMax(node.right);
         }
     }
@@ -985,14 +966,11 @@ export class TST<T> {
         const c = key.charAt(d);
         if (c < x.c) {
             return this.nodeGet(x.left, key, d);
-        }
-        else if (c > x.c) {
+        } else if (c > x.c) {
             return this.nodeGet(x.right, key, d);
-        }
-        else if (d < (key.length - 1)) {
+        } else if (d < (key.length - 1)) {
             return this.nodeGet(x.mid, key, d + 1);
-        }
-        else { return x; }
+        } else { return x; }
     }
 
     public put(key: string, val: T) {
@@ -1010,14 +988,11 @@ export class TST<T> {
         }
         if (c < _x.c) {
             _x.left = this.nodePut(_x.left, key, val, d);
-        }
-        else if (c > _x.c) {
+        } else if (c > _x.c) {
             _x.right = this.nodePut(_x.right, key, val, d);
-        }
-        else if (d < (key.length - 1)) {
+        } else if (d < (key.length - 1)) {
             _x.mid = this.nodePut(_x.mid, key, val, d + 1);
-        }
-        else {
+        } else {
             _x.val = val;
         }
         return _x;
@@ -1124,8 +1099,7 @@ export class TST<T> {
         const recurD = (d < (pattern.length - 1)) ? d + 1 : d;
         if (c === x.c) {
             this.nodeProximity(x.mid, { text: prefix.text + x.c }, recurD, pattern, distance, q);
-        }
-        else {
+        } else {
             this.nodeProximity(x.mid, { text: prefix.text + x.c }, recurD, pattern, distance - 1, q);
         }
         if ((distance > 0) || (c > x.c)) {

package/src/index.ts

@@ -19,3 +19,4 @@ export * from "./segmentPropertiesManager";
 export * from "./snapshotlegacy";
 export * from "./sortedSegmentSet";
 export * from "./textSegment";
+export * from "./referencePositions";

package/src/localReference.ts

@@ -7,61 +7,79 @@ import { assert } from "@fluidframework/common-utils";
 import { Client } from "./client";
 import {
     ISegment,
+} from "./mergeTree";
+import { ICombiningOp, ReferenceType } from "./ops";
+import { addProperties, PropertySet } from "./properties";
+import { minReferencePosition,
+    maxReferencePosition,
+    compareReferencePositions,
+    refHasTileLabels,
+    refHasRangeLabels,
     ReferencePosition,
     refGetRangeLabels,
     refGetTileLabels,
     refHasRangeLabel,
     refHasTileLabel,
-} from "./mergeTree";
-import { ICombiningOp, ReferenceType } from "./ops";
-import { addProperties, PropertySet } from "./properties";
+} from "./referencePositions";
 
-export class LocalReference implements ReferencePosition {
+/**
+ * @deprecated - Use ReferencePosition
+ */
+ export class LocalReference implements ReferencePosition {
+    /**
+     * @deprecated - use DetachedReferencePosition
+     */
     public static readonly DetachedPosition: number = -1;
 
     public properties: PropertySet | undefined;
+    /**
+     * @deprecated - use properties to store pair
+     */
     public pairedRef?: LocalReference;
+    /**
+     * @deprecated - use getSegment
+     */
     public segment: ISegment | undefined;
 
+    /**
+     * @deprecated - use createReferencePosition
+     */
     constructor(
         private readonly client: Client,
         initSegment: ISegment,
+        /**
+         * @deprecated - use getOffset
+         */
         public offset = 0,
         public refType = ReferenceType.Simple,
+        properties?: PropertySet,
     ) {
         this.segment = initSegment;
+        this.properties = properties;
     }
 
+    /**
+     * @deprecated - use minReferencePosition
+     */
     public min(b: LocalReference) {
-        if (this.compare(b) < 0) {
-            return this;
-        } else {
-            return b;
-        }
+        return minReferencePosition(this, b);
     }
-
+    /**
+     * @deprecated - use maxReferencePosition
+     */
     public max(b: LocalReference) {
-        if (this.compare(b) > 0) {
-            return this;
-        } else {
-            return b;
-        }
+        return maxReferencePosition(this, b);
     }
-
+    /**
+     * @deprecated - use compareReferencePositions
+     */
     public compare(b: LocalReference) {
-        if (this.segment === b.segment) {
-            return this.offset - b.offset;
-        } else {
-            if (this.segment === undefined
-                || (b.segment !== undefined &&
-                    this.segment.ordinal < b.segment.ordinal)) {
-                return -1;
-            } else {
-                return 1;
-            }
-        }
+        return compareReferencePositions(this, b);
     }
 
+    /**
+     * @deprecated - use getLocalReferencePosition
+     */
     public toPosition() {
         if (this.segment && this.segment.parent) {
             return this.getOffset() + this.client.getPosition(this.segment);
@@ -70,26 +88,39 @@ export class LocalReference implements ReferencePosition {
         }
     }
 
+    /**
+     * @deprecated - use refHasTileLabels
+     */
     public hasTileLabels() {
-        return !!this.getTileLabels();
+        return refHasTileLabels(this);
     }
-
+    /**
+     * @deprecated - use refHasRangeLabels
+     */
     public hasRangeLabels() {
-        return !!this.getRangeLabels();
+        return refHasRangeLabels(this);
     }
-
+    /**
+     * @deprecated - use refHasTileLabel
+     */
     public hasTileLabel(label: string): boolean {
         return refHasTileLabel(this, label);
     }
-
+    /**
+     * @deprecated - use refHasRangeLabel
+     */
     public hasRangeLabel(label: string): boolean {
         return refHasRangeLabel(this, label);
     }
-
+    /**
+     * @deprecated - use refGetTileLabels
+     */
     public getTileLabels(): string[] | undefined {
         return refGetTileLabels(this);
     }
-
+    /**
+     * @deprecated - use refGetRangeLabels
+     */
     public getRangeLabels(): string[] | undefined {
         return refGetRangeLabels(this);
     }
@@ -102,6 +133,9 @@ export class LocalReference implements ReferencePosition {
         this.properties = addProperties(this.properties, newProps, op);
     }
 
+    /**
+     * @deprecated - no longer supported
+     */
     public getClient() {
         return this.client;
     }
@@ -140,8 +174,7 @@ export class LocalReferenceCollection {
             assert(seg1.localRefs.refsByOffset.length === seg1.cachedLength,
                 0x2be /* "LocalReferences array contains a gap" */);
             seg1.localRefs.append(seg2.localRefs);
-        }
-        else if (seg1.localRefs) {
+        } else if (seg1.localRefs) {
             // Since creating the LocalReferenceCollection, we may have appended
             // segments that had no local references. Account for them now by padding the array.
             seg1.localRefs.refsByOffset.length += seg2.cachedLength;