@fluidframework/merge-tree 0.59.2001 → 0.59.3000

package/src/collections.ts

@@ -35,14 +35,12 @@ export class Stack<T> {
     }
 }
 
-function ListRemoveEntry<U>(entry: List<U>): List<U> | undefined {
+export 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;
     }
@@ -61,7 +59,7 @@ export class List<T> {
     public next: List<T>;
     public prev: List<T>;
 
-    constructor(public isHead: boolean, private data: T | undefined) {
+    constructor(public isHead: boolean, public data: T | undefined) {
         this.prev = this;
         this.next = this;
     }
@@ -146,7 +144,14 @@ export class List<T> {
         return (this.next === this);
     }
 
+    /**
+     * @deprecated - use unshift
+     */
     public push(data: T): void {
+        this.unshift(data);
+    }
+
+    public unshift(data: T): void {
         const entry = ListMakeEntry(data);
         entry.data = data;
         entry.isHead = false;
@@ -155,6 +160,26 @@ export class List<T> {
         this.next = entry;
         entry.next.prev = entry;
     }
+
+    public [Symbol.iterator]() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let node: List<T> | undefined = this;
+        const iterator: IterableIterator<T> = {
+            next(): IteratorResult<T> {
+                while (node && node.next.isHead === false) {
+                    node = node.next;
+                    if (node.data !== undefined) {
+                        return { value: node.data, done: false };
+                    }
+                }
+                return { value: undefined, done: true };
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+        return iterator;
+    }
 }
 
 export interface Comparer<T> {
@@ -286,11 +311,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 +410,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 +425,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 +442,7 @@ export class RedBlackTree<TKey, TData> implements SortedDictionary<TKey, TData>
                     } else {
                         _node.data = data;
                     }
-                }
-                else {
+                } else {
                     _node.data = data;
                 }
             }
@@ -504,8 +522,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 +540,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 +559,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 +583,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 +605,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 +619,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 +993,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 +1015,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 +1126,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";