dubc-ds-tmap 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# dubc-ds-tmap
+
+Observable sorted map based on a weighted binary search tree.

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+import { Base } from "dubc-ds-base";
+import { Pair, Pairs } from "dubc-ds-pairs";
+export interface Include {
+    start: boolean;
+    end: boolean;
+}
+export declare const IN_IN: {
+    start: boolean;
+    end: boolean;
+};
+export declare const IN_EX: {
+    start: boolean;
+    end: boolean;
+};
+export declare const EX_IN: {
+    start: boolean;
+    end: boolean;
+};
+export declare const EX_EX: {
+    start: boolean;
+    end: boolean;
+};
+type N<K extends {}, V> = Node<K, V> | undefined;
+declare class Node<K extends {}, V> {
+    readonly key: K;
+    value: V;
+    weight: number;
+    parent: N<K, V>;
+    left: N<K, V>;
+    right: N<K, V>;
+    constructor(key: K, value: V);
+    private weigh;
+    index(): number;
+    next(): N<K, V>;
+    prev(): N<K, V>;
+    rotateLeft(): N<K, V>;
+    rotateRight(): N<K, V>;
+}
+export interface Conf<K extends {}, V> {
+    readonly unique: boolean;
+    readonly compare: (a: K, b: K) => number;
+    readonly valueEq: (a: V, b: V) => boolean;
+}
+export declare class TMap<K extends {}, V> extends Base<Pair<K, V>> {
+    private root;
+    private _compare;
+    protected conf: Conf<K, V>;
+    constructor(input: Pairs<K, V>, c: Conf<K, V>);
+    static of<K extends {}, V>(compare: (a: K, b: K) => number, ...pairs: Pair<K, V>[] | [K, V][]): TMap<K, V>;
+    toEmpty(): TMap<K, V>;
+    get size(): number;
+    clear(): void;
+    replace(i: Pairs<K, V>): void;
+    drop(f: (pair: Pair<K, V>) => boolean): void;
+    get compare(): (a: K, b: K) => number;
+    set compare(cmp: (a: K, b: K) => number);
+    get keyEq(): (a: K, b: K) => boolean;
+    get unique(): boolean;
+    at(i: number): Pair<K, V>;
+    get only(): Pair<K, V>;
+    get first(): Pair<K, V> | undefined;
+    get last(): Pair<K, V> | undefined;
+    [Symbol.iterator](): Generator<Node<K, V>, void, unknown>;
+    private keys2;
+    get keys(): Iterable<K>;
+    private values2;
+    get values(): Iterable<V>;
+    reversed(): Generator<Pair<K, V>, void, unknown>;
+    range(startKey: K, endKey: K, inc?: Include): Generator<Pair<K, V>, void, unknown>;
+    private find;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    from(key: K): Pair<K, V> | undefined;
+    to(key: K): Pair<K, V> | undefined;
+    after(key: K): Pair<K, V> | undefined;
+    before(key: K): Pair<K, V> | undefined;
+    rank(key: K): number | undefined;
+    protected rawPut(key: K, value: V): {
+        node: Node<K, V>;
+        old?: V;
+    };
+    set(key: K, value: V): V | undefined;
+    setAll(entries: Pairs<K, V>): number;
+    delete(key: K): V | undefined;
+    private remove;
+    private weigh;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,433 @@
+import { Base } from "dubc-ds-base";
+import { forEach } from "dubc-ds-pairs";
+export const IN_IN = { start: true, end: true };
+export const IN_EX = { start: true, end: false };
+export const EX_IN = { start: false, end: true };
+export const EX_EX = { start: false, end: false };
+class Node {
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+        this.weight = 1;
+    }
+    weigh() {
+        var _a, _b, _c, _d;
+        this.weight = 1 + ((_b = (_a = this.left) === null || _a === void 0 ? void 0 : _a.weight) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = this.right) === null || _c === void 0 ? void 0 : _c.weight) !== null && _d !== void 0 ? _d : 0);
+    }
+    index() {
+        let i = -1;
+        let node = this;
+        let prev = node.right;
+        while (node) {
+            if (node.right === prev) {
+                i += node.left ? node.left.weight + 1 : 1;
+            }
+            prev = node;
+            node = node.parent;
+        }
+        return i;
+    }
+    next() {
+        let node = this;
+        let child = node.right;
+        if (child !== undefined)
+            while (child !== undefined) {
+                node = child;
+                child = child.left;
+            }
+        else
+            while (node !== undefined && node.right === child) {
+                child = node;
+                node = node.parent;
+            }
+        return node;
+    }
+    prev() {
+        let node = this;
+        let child = node.left;
+        if (child !== undefined)
+            while (child !== undefined) {
+                node = child;
+                child = child.right;
+            }
+        else
+            while (node !== undefined && node.left === child) {
+                child = node;
+                node = node.parent;
+            }
+        return node;
+    }
+    rotateLeft() {
+        let a = this;
+        let b = a.right;
+        let r = b === null || b === void 0 ? void 0 : b.left;
+        b.parent = a.parent;
+        b.left = a;
+        a.parent = b;
+        a.right = r;
+        if (r)
+            r.parent = a;
+        a.weigh();
+        b === null || b === void 0 ? void 0 : b.weigh();
+        return b;
+    }
+    rotateRight() {
+        let a = this;
+        let b = a.left;
+        let l = b === null || b === void 0 ? void 0 : b.right;
+        b.parent = a.parent;
+        b.right = a;
+        a.parent = b;
+        a.left = l;
+        if (l)
+            l.parent = a;
+        a.weigh();
+        b === null || b === void 0 ? void 0 : b.weigh();
+        return b;
+    }
+}
+const EQ = { lset: false, rset: false, eset: true, eright: false };
+//const EG:Op = { lset:false, rset:false, eset:true,  eright:true   }
+const LT = { lset: true, rset: false, eset: false, eright: false };
+const LE = { lset: true, rset: false, eset: true, eright: true };
+const GT = { lset: false, rset: true, eset: false, eright: true };
+const GE = { lset: false, rset: true, eset: true, eright: false };
+export class TMap extends Base {
+    constructor(input, c) {
+        super();
+        this._compare = c.compare;
+        this.conf = c;
+        this.setAll(input);
+    }
+    static of(compare, ...pairs) {
+        const conf = { compare, valueEq: Object.is, unique: true };
+        return new TMap(pairs, conf);
+    }
+    toEmpty() {
+        const conf2 = {
+            unique: this.conf.unique,
+            valueEq: this.conf.valueEq,
+            compare: this._compare,
+        };
+        const r = new TMap(this, conf2);
+        return r;
+    }
+    get size() { var _a, _b; return (_b = (_a = this.root) === null || _a === void 0 ? void 0 : _a.weight) !== null && _b !== void 0 ? _b : 0; }
+    clear() {
+        const sz = this.size;
+        this.root = undefined;
+        if (sz > 0)
+            this.fire({ cleared: sz });
+    }
+    replace(i) {
+        const sz = this.size;
+        this.root = undefined;
+        forEach(i, (k, v) => { this.rawPut(k, v); });
+        if (sz > 0) {
+            if (this.root === undefined)
+                this.fire({ cleared: sz });
+            else
+                this.fire({ cleared: sz, added: { items: this, at: 0 } });
+        }
+        else if (this.root !== undefined)
+            this.fire({ added: { items: this, at: 0 } });
+    }
+    drop(f) {
+        let n = this.first;
+        let at = 0;
+        while (n !== undefined) {
+            const x = n;
+            n = n.next();
+            if (f(x)) {
+                this.remove(x);
+                this.fire({ deleted: { items: [x], at: at } });
+            }
+            else
+                at++;
+        }
+    }
+    get compare() { return this._compare; }
+    set compare(cmp) {
+        this._compare = cmp;
+        let n = this.first;
+        if (n === undefined)
+            return;
+        this.root = undefined;
+        while (n !== undefined) {
+            this.rawPut(n.key, n.value);
+            n = n.next();
+        }
+        this.fire({ cleared: this.size, added: { items: this, at: 0 } });
+    }
+    get keyEq() { return (a, b) => this._compare(a, b) === 0; }
+    get unique() { return this.conf.unique; }
+    at(i) {
+        var _a;
+        let node = this.root;
+        let weight = this.size;
+        // if (i < 0) i += weight // TODO
+        if (i < 0 || i >= weight)
+            throw new TypeError("bounds");
+        while (true) {
+            const left = node === null || node === void 0 ? void 0 : node.left;
+            const lw = (_a = left === null || left === void 0 ? void 0 : left.weight) !== null && _a !== void 0 ? _a : 0;
+            if (i > lw) {
+                i -= lw + 1;
+                node = node === null || node === void 0 ? void 0 : node.right;
+            }
+            else if (i < lw) {
+                node = left;
+            }
+            else
+                break;
+        }
+        return node;
+    }
+    get only() {
+        if (this.size !== 1)
+            throw new Error("size isn't 1");
+        return this.root;
+    }
+    get first() {
+        let current = this.root;
+        let previous;
+        while (current) {
+            previous = current;
+            current = current.left;
+        }
+        return previous;
+    }
+    get last() {
+        let current = this.root;
+        let previous;
+        while (current) {
+            previous = current;
+            current = current.right;
+        }
+        return previous;
+    }
+    *[Symbol.iterator]() {
+        let n = this.first;
+        while (n) {
+            yield n;
+            n = n.next();
+        }
+    }
+    *keys2() {
+        for (const x of this)
+            yield x.key;
+    }
+    get keys() {
+        return this.keys2();
+    }
+    *values2() {
+        for (const x of this)
+            yield x.value;
+    }
+    get values() {
+        return this.values2();
+    }
+    *reversed() {
+        let n = this.last;
+        while (n) {
+            yield n;
+            n = n.prev();
+        }
+    }
+    *range(startKey, endKey, inc = IN_EX) {
+        const start = this.find(startKey, inc.start ? GE : GT);
+        const cmp = this.compare;
+        if (inc.end)
+            for (let n = start; n !== undefined && cmp(n.key, endKey) <= 0; n = n.next()) {
+                yield n;
+            }
+        else
+            for (let n = start; n !== undefined && cmp(n.key, endKey) < 0; n = n.next()) {
+                yield n;
+            }
+    }
+    find(key, op = EQ) {
+        let node = this.root;
+        let ret;
+        const unique = this.unique;
+        const cmp = this.compare;
+        while (node) {
+            const c = cmp(node.key, key);
+            if (c < 0) {
+                if (op.lset)
+                    ret = node;
+                node = node.right;
+            }
+            else if (c > 0) {
+                if (op.rset)
+                    ret = node;
+                node = node.left;
+            }
+            else {
+                if (op.eset) {
+                    if (unique)
+                        return node;
+                    else
+                        ret = node;
+                }
+                node = op.eright ? node.right : node.left;
+            }
+        }
+        return ret;
+    }
+    get(key) { var _a; return (_a = this.find(key, EQ)) === null || _a === void 0 ? void 0 : _a.value; }
+    has(key) { return this.find(key, EQ) !== undefined; }
+    from(key) { return this.find(key, GE); }
+    to(key) { return this.find(key, LE); }
+    after(key) { return this.find(key, GT); }
+    before(key) { return this.find(key, LT); }
+    rank(key) {
+        var _a;
+        return (_a = this.find(key, EQ)) === null || _a === void 0 ? void 0 : _a.index();
+    }
+    rawPut(key, value) {
+        let previous = undefined, node = this.root;
+        let unique = this.unique ? 0 : undefined;
+        let c = 0, cmp = this.compare;
+        while (node) {
+            c = cmp(node.key, key);
+            if (c === unique) {
+                const old = node.value;
+                node.value = value;
+                return { node, old };
+            }
+            previous = node;
+            if (c <= 0)
+                node = node.right;
+            else
+                node = node.left;
+        }
+        node = new Node(key, value);
+        node.parent = previous;
+        if (previous === undefined)
+            this.root = node;
+        else {
+            if (c <= 0)
+                previous.right = node;
+            else
+                previous.left = node;
+            this.weigh(previous);
+        }
+        return { node, old: undefined };
+    }
+    set(key, value) {
+        const r = this.rawPut(key, value);
+        if (r.old === undefined) {
+            const at = r.node.index();
+            this.fire({ added: { items: [{ key, value }], at } });
+            return;
+        }
+        if (this.conf.valueEq(r.old, value))
+            return r.old;
+        const at = r.node.index();
+        this.fire({
+            deleted: { items: [{ key, value: r.old }], at },
+            added: { items: [{ key, value }], at }
+        });
+        return r.old;
+    }
+    setAll(entries) {
+        let sz = this.size;
+        if (sz > 0) {
+            forEach(entries, (k, v) => { this.set(k, v); });
+            return this.size - sz;
+        }
+        forEach(entries, (k, v) => { this.rawPut(k, v); });
+        const changed = this.size - sz;
+        if (changed > 0)
+            this.fire({ added: { items: this, at: 0 } });
+        return changed;
+    }
+    delete(key) {
+        const node = this.find(key);
+        if (node === undefined)
+            return undefined;
+        const at = node.index();
+        this.remove(node);
+        this.fire({ deleted: { items: [node], at } });
+        return node.value;
+    }
+    remove(node) {
+        const p = node.parent;
+        let left = node.left, right = node.right;
+        let bal;
+        let next;
+        if (right === undefined) {
+            bal = p;
+            next = left;
+            left = undefined;
+        }
+        else if (right.left) {
+            next = right;
+            while (next.left) {
+                bal = next;
+                next = next.left;
+            }
+            const c = next.right;
+            bal.left = c;
+            if (c)
+                c.parent = bal;
+        }
+        else {
+            bal = right;
+            next = right;
+            right = undefined;
+        }
+        if (p === undefined)
+            this.root = next;
+        else if (p.left === node)
+            p.left = next;
+        else
+            p.right = next;
+        if (next) {
+            next.parent = p;
+            if (left) {
+                next.left = left, left.parent = next;
+            }
+            if (right) {
+                next.right = right, right.parent = next;
+            }
+        }
+        this.weigh(bal);
+    }
+    weigh(n) {
+        let next = n;
+        while (next) {
+            let node = next, orig = next;
+            next = node.parent;
+            let left = node.left, right = node.right;
+            let lw = weight(left);
+            let rw = weight(right);
+            if (rw * 5 + 2 < lw * 2) {
+                if (weight(left === null || left === void 0 ? void 0 : left.left) * 5 < lw * 2)
+                    node.left = left === null || left === void 0 ? void 0 : left.rotateLeft();
+                node = node.rotateRight();
+            }
+            else if (lw * 5 + 2 < rw * 2) {
+                if (weight(right === null || right === void 0 ? void 0 : right.right) * 5 < rw * 2)
+                    node.right = right === null || right === void 0 ? void 0 : right.rotateRight();
+                node = node.rotateLeft();
+            }
+            else {
+                node.weight = lw + rw + 1;
+                continue;
+            }
+            if (next === undefined)
+                this.root = node;
+            else if (next.left === orig)
+                next.left = node;
+            else
+                next.right = node;
+        }
+    }
+}
+function weight(n) {
+    var _a;
+    return (_a = n === null || n === void 0 ? void 0 : n.weight) !== null && _a !== void 0 ? _a : 0;
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "dubc-ds-tmap",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "Observable map based on a weighted binary search tree.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "README.md",
+    "dist/index.js",
+    "dist/index.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "test": "vitest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/p-jack/dubc.git"
+  },
+  "author": "Paul Jack",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/p-jack/dubc/issues"
+  },
+  "homepage": "https://github.com/p-jack/dubc#readme",
+  "dependencies": {
+    "dubc-ds-base": "^1.0.2",
+    "dubc-ds-pairs": "^1.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^3.2.4",
+    "dubc-ds-test": "^1.0.1",
+    "jsdom": "^27.0.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}