@fluidframework/merge-tree 0.51.2 → 0.52.1

package/dist/collections.js

@@ -4,12 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TST = exports.IntervalTree = exports.intervalComparer = exports.IntegerRangeTree = exports.integerRangeToString = exports.integerRangeCopy = exports.integerRangeComparer = exports.integerRangeOverlaps = exports.integerRangeUnion = exports.RedBlackTree = exports.RBColor = exports.LinearDictionary = exports.Heap = exports.numberComparer = exports.List = exports.ListMakeHead = exports.ListMakeEntry = exports.ListRemoveEntry = exports.Stack = void 0;
-/* eslint-disable @typescript-eslint/consistent-type-assertions, eqeqeq, object-shorthand */
-/* eslint-disable no-bitwise */
-/* Remove once strictNullCheck is enabled */
-const common_utils_1 = require("@fluidframework/common-utils");
-const mergeTree_1 = require("./mergeTree");
+exports.TST = exports.IntervalTree = exports.integerRangeToString = exports.RedBlackTree = exports.RBColor = exports.Heap = exports.List = exports.ListMakeHead = exports.Stack = void 0;
 class Stack {
     constructor() {
         this.items = [];
@@ -41,11 +36,9 @@ function ListRemoveEntry(entry) {
     }
     return (entry);
 }
-exports.ListRemoveEntry = ListRemoveEntry;
 function ListMakeEntry(data) {
     return new List(false, data);
 }
-exports.ListMakeEntry = ListMakeEntry;
 function ListMakeHead() {
     return new List(true, undefined);
 }
@@ -127,13 +120,6 @@ class List {
     empty() {
         return (this.next === this);
     }
-    pushEntry(entry) {
-        entry.isHead = false;
-        entry.next = this.next;
-        entry.prev = this;
-        this.next = entry;
-        entry.next.prev = entry;
-    }
     push(data) {
         const entry = ListMakeEntry(data);
         entry.data = data;
@@ -143,47 +129,8 @@ class List {
         this.next = entry;
         entry.next.prev = entry;
     }
-    popEntry(head) {
-        if (this.next.isHead) {
-            return undefined;
-        }
-        else {
-            return ListRemoveEntry(this.next);
-        }
-    }
-    insertEntry(entry) {
-        entry.isHead = false;
-        this.prev.next = entry;
-        entry.next = this;
-        entry.prev = this.prev;
-        this.prev = entry;
-        return entry;
-    }
-    insertAfter(data) {
-        const entry = ListMakeEntry(data);
-        entry.next = this.next;
-        entry.prev = this;
-        this.next = entry;
-        entry.next.prev = entry;
-        return (entry);
-    }
-    insertBefore(data) {
-        const entry = ListMakeEntry(data);
-        return this.insertEntryBefore(entry);
-    }
-    insertEntryBefore(entry) {
-        this.prev.next = entry;
-        entry.next = this;
-        entry.prev = this.prev;
-        this.prev = entry;
-        return (entry);
-    }
 }
 exports.List = List;
-exports.numberComparer = {
-    min: Number.MIN_VALUE,
-    compare: (a, b) => a - b,
-};
 class Heap {
     constructor(a, comp) {
         this.comp = comp;
@@ -236,94 +183,6 @@ class Heap {
     }
 }
 exports.Heap = Heap;
-// For testing
-function LinearDictionary(compareKeys) {
-    const props = [];
-    const compareProps = (a, b) => compareKeys(a.key, b.key);
-    function diag() {
-        console.log(`size is ${props.length}`);
-    }
-    function mapRange(action, accum, start, end) {
-        let _start = start;
-        let _end = end;
-        if (props.length !== 0) {
-            return;
-        }
-        if (_start === undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            _start = min().key;
-        }
-        if (_end === undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            _end = max().key;
-        }
-        for (let i = 0, len = props.length; i < len; i++) {
-            if (compareKeys(_start, props[i].key) <= 0) {
-                const ecmp = compareKeys(_end, props[i].key);
-                if (ecmp < 0) {
-                    break;
-                }
-                if (!action(props[i], accum)) {
-                    break;
-                }
-            }
-        }
-    }
-    function map(action, accum) {
-        mapRange(action, accum);
-    }
-    function min() {
-        if (props.length > 0) {
-            return props[0];
-        }
-    }
-    function max() {
-        if (props.length > 0) {
-            return props[props.length - 1];
-        }
-    }
-    function get(key) {
-        for (let i = 0, len = props.length; i < len; i++) {
-            if (props[i].key == key) {
-                return props[i];
-            }
-        }
-    }
-    function put(key, data) {
-        if (key !== undefined) {
-            if (data === undefined) {
-                remove(key);
-            }
-            else {
-                props.push({ key, data });
-                props.sort(compareProps); // Go to insertion sort if too slow
-            }
-        }
-    }
-    function remove(key) {
-        if (key !== undefined) {
-            for (let i = 0, len = props.length; i < len; i++) {
-                if (props[i].key == key) {
-                    props[i] = props[len - 1];
-                    props.length--;
-                    props.sort(compareProps);
-                    break;
-                }
-            }
-        }
-    }
-    return {
-        min: min,
-        max: max,
-        map: map,
-        mapRange: mapRange,
-        remove: remove,
-        get: get,
-        put: put,
-        diag: diag,
-    };
-}
-exports.LinearDictionary = LinearDictionary;
 var RBColor;
 (function (RBColor) {
     RBColor[RBColor["RED"] = 0] = "RED";
@@ -499,18 +358,6 @@ class RedBlackTree {
             this.aug.update(node);
         }
     }
-    removeMin() {
-        if (this.root) {
-            if ((!this.isRed(this.root.left)) && (!this.isRed(this.root.right))) {
-                this.root.color = 0 /* RED */;
-            }
-            this.root = this.nodeRemoveMin(this.root);
-            if (this.root) {
-                this.root.color = 1 /* BLACK */;
-            }
-        }
-        // TODO: error on empty
-    }
     nodeRemoveMin(node) {
         let _node = node;
         if (_node.left) {
@@ -522,33 +369,6 @@ class RedBlackTree {
             return this.balance(_node);
         }
     }
-    removeMax() {
-        if (this.root) {
-            if ((!this.isRed(this.root.left)) && (!this.isRed(this.root.right))) {
-                this.root.color = 0 /* RED */;
-            }
-            this.root = this.nodeRemoveMax(this.root);
-            if (this.root) {
-                this.root.color = 1 /* BLACK */;
-            }
-        }
-        // TODO: error on empty
-    }
-    nodeRemoveMax(node) {
-        let _node = node;
-        if (this.isRed(_node.left)) {
-            _node = this.rotateRight(_node);
-        }
-        if (!_node.right) {
-            return undefined;
-        }
-        if ((!this.isRed(_node.right)) && (!this.isRed(_node.right.left))) {
-            _node = this.moveRedRight(_node);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        _node.right = this.nodeRemoveMax(_node.right);
-        return this.balance(_node);
-    }
     remove(key) {
         if (key !== undefined) {
             if (!this.contains(key)) {
@@ -886,122 +706,12 @@ class RedBlackTree {
     }
 }
 exports.RedBlackTree = RedBlackTree;
-/**
- * Union of two ranges; assumes for both ranges start \<= end.
- * @param a - A range
- * @param b - A range
- */
-function integerRangeUnion(a, b) {
-    return {
-        start: Math.min(a.start, b.start),
-        end: Math.max(a.end, b.end),
-    };
-}
-exports.integerRangeUnion = integerRangeUnion;
-function integerRangeOverlaps(a, b) {
-    return (a.start < b.end) && (a.end > b.start);
-}
-exports.integerRangeOverlaps = integerRangeOverlaps;
-function integerRangeComparer(a, b) {
-    if (a.start === b.start) {
-        return a.end - b.end;
-    }
-    else {
-        return a.start - b.start;
-    }
-}
-exports.integerRangeComparer = integerRangeComparer;
-const integerRangeCopy = (r) => ({ start: r.start, end: r.end });
-exports.integerRangeCopy = integerRangeCopy;
 const integerRangeToString = (range) => `[${range.start},${range.end})`;
 exports.integerRangeToString = integerRangeToString;
-// TODO: handle duplicate keys
-class IntegerRangeTree {
-    constructor() {
-        this.ranges = new RedBlackTree(integerRangeComparer, this);
-        this.diag = false;
-    }
-    remove(r) {
-        this.ranges.remove(r);
-    }
-    put(r) {
-        this.ranges.put(r, { minmax: exports.integerRangeCopy(r) });
-    }
-    toString() {
-        return this.nodeToString(this.ranges.root);
-    }
-    nodeToString(node) {
-        let buf = "";
-        let indentAmt = 0;
-        const actions = {
-            pre: (n) => {
-                let red = "";
-                if (n.color === 0 /* RED */) {
-                    red = "R ";
-                }
-                buf += mergeTree_1.internedSpaces(indentAmt);
-                buf += `${red}key: ${exports.integerRangeToString(n.key)} minmax: ${exports.integerRangeToString(n.data.minmax)}\n`;
-                indentAmt += 2;
-                return true;
-            },
-            post: (n) => {
-                indentAmt -= 2;
-                return true;
-            },
-            showStructure: true,
-        };
-        this.ranges.nodeWalk(node, actions);
-        return buf;
-    }
-    matchPos(pos) {
-        return this.match({ start: pos, end: pos + 1 });
-    }
-    match(r) {
-        return this.ranges.gather(r, this);
-    }
-    matchNode(node, key) {
-        return !!node && integerRangeOverlaps(node.key, key);
-    }
-    continueSubtree(node, key) {
-        const cont = !!node && integerRangeOverlaps(node.data.minmax, key);
-        if (this.diag && (!cont)) {
-            if (node) {
-                console.log(`skipping subtree of size ${node.size} key ${exports.integerRangeToString(key)}`);
-                console.log(this.nodeToString(node));
-            }
-        }
-        return cont;
-    }
-    update(node) {
-        if (node.left && node.right) {
-            node.data.minmax = integerRangeUnion(node.key, integerRangeUnion(node.left.data.minmax, node.right.data.minmax));
-        }
-        else {
-            if (node.left) {
-                node.data.minmax = integerRangeUnion(node.key, node.left.data.minmax);
-            }
-            else if (node.right) {
-                node.data.minmax = integerRangeUnion(node.key, node.right.data.minmax);
-            }
-            else {
-                node.data.minmax = exports.integerRangeCopy(node.key);
-            }
-        }
-    }
-}
-exports.IntegerRangeTree = IntegerRangeTree;
 const intervalComparer = (a, b) => a.compare(b);
-exports.intervalComparer = intervalComparer;
 class IntervalTree {
     constructor() {
-        this.intervals = new RedBlackTree(exports.intervalComparer, this);
-        this.diag = false;
-        this.timePut = false;
-        this.putTime = 0;
-        this.putCount = 0;
-    }
-    printTiming() {
-        console.log(`put total = ${this.putTime} avg=${(this.putTime / this.putCount).toFixed(2)}`);
+        this.intervals = new RedBlackTree(intervalComparer, this);
     }
     remove(x) {
         this.intervals.remove(x);
@@ -1019,15 +729,7 @@ class IntervalTree {
                 };
             };
         }
-        if (this.timePut) {
-            const trace = common_utils_1.Trace.start();
-            this.intervals.put(x, { minmax: x.clone() }, rbConflict);
-            this.putTime += trace.trace().duration * 1000;
-            this.putCount++;
-        }
-        else {
-            this.intervals.put(x, { minmax: x.clone() }, rbConflict);
-        }
+        this.intervals.put(x, { minmax: x.clone() }, rbConflict);
     }
     map(fn) {
         const actions = {
@@ -1066,14 +768,7 @@ class IntervalTree {
         return !!node && node.key.overlaps(key);
     }
     continueSubtree(node, key) {
-        const cont = !!node && node.data.minmax.overlaps(key);
-        if (this.diag && (!cont)) {
-            if (node) {
-                console.log(`skipping subtree of size ${node.size} key ${key.toString()}`);
-                // console.log(this.nodeToString(node));
-            }
-        }
-        return cont;
+        return !!node && node.data.minmax.overlaps(key);
     }
     update(node) {
         if (node.left && node.right) {
@@ -1222,26 +917,6 @@ class TST {
         this.collectPairs(x.mid, { text: prefix.text + x.c }, q);
         this.collectPairs(x.right, prefix, q);
     }
-    patternCollect(x, prefix, d, pattern, q) {
-        if (x === undefined) {
-            return;
-        }
-        const c = pattern.charAt(d);
-        if ((c === ".") || (c < x.c)) {
-            this.patternCollect(x.left, prefix, d, pattern, q);
-        }
-        else if ((c === ".") || (c === x.c)) {
-            if ((d === (pattern.length - 1)) && (x.val !== undefined)) {
-                q.push(prefix.text + x.c);
-            }
-            else if (d < (pattern.length - 1)) {
-                this.patternCollect(x.mid, { text: prefix.text + x.c }, d + 1, pattern, q);
-            }
-        }
-        if ((c === ".") || (c > x.c)) {
-            this.patternCollect(x.right, prefix, d, pattern, q);
-        }
-    }
     nodeProximity(x, prefix, d, pattern, distance, q) {
         if ((x === undefined) || (distance < 0)) {
             return;
@@ -1271,11 +946,6 @@ class TST {
             this.nodeProximity(x.right, prefix, d, pattern, distance, q);
         }
     }
-    match(pattern) {
-        const q = [];
-        this.patternCollect(this.root, { text: "" }, 0, pattern, q);
-        return q;
-    }
 }
 exports.TST = TST;
 //# sourceMappingURL=collections.js.map