@genome-spy/core 0.36.1 → 0.37.1

package/dist/src/utils/propertyCacher.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @param {object} host The object that uses caching
+ * @param {any} key string
+ * @param {function(key?):T} callable A function that produces a value to be cached
+ * @returns {T}
+ * @template T
+ */
+export function getCachedOrCall<T>(host: object, key: any, callable: (arg0: any | null) => T): T;
+/**
+ *
+ * @param {object} host The object that uses caching
+ * @param {string} key
+ */
+export function invalidate(host: object, key: string): void;
+/**
+ *
+ * @param {object} host The object that uses caching
+ * @param {string} keyPrefix
+ */
+export function invalidatePrefix(host: object, keyPrefix: string): void;
+/**
+ *
+ * @param {object} host The object that uses caching
+ */
+export function invalidateAll(host: object): void;
+/**
+ * @param {any} host The object that uses caching
+ */
+export function initPropertyCache(host: any): void;
+//# sourceMappingURL=propertyCacher.d.ts.map

package/dist/src/utils/propertyCacher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyCacher.d.ts","sourceRoot":"","sources":["../../../src/utils/propertyCacher.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,yCANW,MAAM,OACN,GAAG,wCAYb;AAED;;;;GAIG;AACH,iCAHW,MAAM,OACN,MAAM,QAIhB;AAED;;;;GAIG;AACH,uCAHW,MAAM,aACN,MAAM,QAUhB;AACD;;;GAGG;AACH,oCAFW,MAAM,QAIhB;AAED;;GAEG;AACH,wCAFW,GAAG,QAKb"}

package/dist/src/utils/propertyCacher.js

@@ -0,0 +1,70 @@
+const cacheMapKey = Symbol("cacheMap");
+
+/**
+ * @param {object} host The object that uses caching
+ * @param {any} key string
+ * @param {function(key?):T} callable A function that produces a value to be cached
+ * @returns {T}
+ * @template T
+ */
+export function getCachedOrCall(host, key, callable) {
+    let value = getCacheMap(host).get(key);
+    if (value === undefined) {
+        value = callable(key);
+        getCacheMap(host).set(key, value);
+    }
+    return value;
+}
+
+/**
+ *
+ * @param {object} host The object that uses caching
+ * @param {string} key
+ */
+export function invalidate(host, key) {
+    getCacheMap(host).delete(key);
+}
+
+/**
+ *
+ * @param {object} host The object that uses caching
+ * @param {string} keyPrefix
+ */
+export function invalidatePrefix(host, keyPrefix) {
+    const m = getCacheMap(host);
+    for (const key of m.keys()) {
+        if (key.startsWith(keyPrefix)) {
+            m.delete(key);
+        }
+    }
+    getCacheMap(host).delete(keyPrefix);
+}
+/**
+ *
+ * @param {object} host The object that uses caching
+ */
+export function invalidateAll(host) {
+    getCacheMap(host).clear();
+}
+
+/**
+ * @param {any} host The object that uses caching
+ */
+export function initPropertyCache(host) {
+    /** @type {Map<string, any>} */
+    host[cacheMapKey] = new Map();
+}
+
+/**
+ * @param {any} host The object that uses caching
+ * @returns {Map<string, any>}
+ */
+function getCacheMap(host) {
+    if (host[cacheMapKey]) {
+        return host[cacheMapKey];
+    }
+
+    initPropertyCache(host);
+
+    return host[cacheMapKey];
+}

package/dist/src/utils/propertyCacher.test.js

@@ -0,0 +1,85 @@
+import { expect, test } from "vitest";
+import { getCachedOrCall, invalidate, invalidateAll } from "./propertyCacher";
+
+class TestClass {
+    constructor() {
+        /** @type {number} */
+        this._x;
+        /** @type {number} */
+        this._y;
+
+        this._xCalls = 0;
+        this._yCalls = 0;
+
+        this.resetAll();
+    }
+
+    get x() {
+        return getCachedOrCall(this, "x", () => {
+            this._xCalls++;
+            return this._x;
+        });
+    }
+
+    set x(x) {
+        this._x = x;
+        invalidate(this, "x");
+    }
+
+    get y() {
+        return getCachedOrCall(this, "y", () => {
+            this._yCalls++;
+            return this._y;
+        });
+    }
+
+    set y(y) {
+        this._y = y;
+        invalidate(this, "y");
+    }
+
+    resetAll() {
+        this._x = 10;
+        this._y = 20;
+        invalidateAll(this);
+    }
+}
+
+test("Initial cached get returns correct values and calls callable only once", () => {
+    const instance = new TestClass();
+
+    expect(instance._xCalls).toEqual(0);
+    expect(instance.x).toEqual(10);
+    expect(instance._xCalls).toEqual(1);
+    expect(instance.x).toEqual(10);
+    expect(instance._xCalls).toEqual(1);
+});
+
+test("Invalidate invalidates", () => {
+    const instance = new TestClass();
+
+    expect(instance._xCalls).toEqual(0);
+    expect(instance.x).toEqual(10);
+    expect(instance._xCalls).toEqual(1);
+
+    instance.x = 123;
+    expect(instance._xCalls).toEqual(1);
+
+    expect(instance.x).toEqual(123);
+    expect(instance._xCalls).toEqual(2);
+});
+
+test("InvalidateAll invalidates everything", () => {
+    const instance = new TestClass();
+
+    instance.x = 123;
+    instance.y = 321;
+
+    expect(instance.x).toEqual(123);
+    expect(instance.y).toEqual(321);
+
+    instance.resetAll();
+
+    expect(instance.x).toEqual(10);
+    expect(instance.y).toEqual(20);
+});

package/dist/src/utils/propertyCoalescer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Coalesces properties. Allows for creating chains of defaults without
+ * using object destructuring, which may generate piles of garbage for GC.
+ *
+ * Still WIP.
+ * TODO: Efficient computed defaults.
+ * TODO: Make sense of the types
+ *
+ * @param  {...function():T} sources
+ * @returns {T}
+ *
+ * @template {Record<string | symbol, any>} [T=object]
+ */
+export default function coalesceProperties<T extends Record<string | symbol, any> = object>(...sources: (() => T)[]): T;
+//# sourceMappingURL=propertyCoalescer.d.ts.map

package/dist/src/utils/propertyCoalescer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyCoalescer.d.ts","sourceRoot":"","sources":["../../../src/utils/propertyCoalescer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wHA4BC"}

package/dist/src/utils/propertyCoalescer.js

@@ -0,0 +1,42 @@
+/**
+ * Coalesces properties. Allows for creating chains of defaults without
+ * using object destructuring, which may generate piles of garbage for GC.
+ *
+ * Still WIP.
+ * TODO: Efficient computed defaults.
+ * TODO: Make sense of the types
+ *
+ * @param  {...function():T} sources
+ * @returns {T}
+ *
+ * @template {Record<string | symbol, any>} [T=object]
+ */
+export default function coalesceProperties(...sources) {
+    /** @type {ProxyHandler<T>} */
+    const handler = {
+        get(_target, prop, _receiver) {
+            for (const source of sources) {
+                const props = source();
+                const value = props[prop];
+                if (value !== undefined) {
+                    return value;
+                }
+            }
+            return undefined;
+        },
+
+        // @ts-ignore
+        has(target, prop, _receiver) {
+            for (const source of sources) {
+                const props = source();
+                if (prop in props) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    };
+
+    // @ts-ignore
+    return new Proxy({}, handler);
+}

package/dist/src/utils/propertyCoalescer.test.js

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import coalesceProperties from "./propertyCoalescer";
+
+test("CoalesceProperties works as expected", () => {
+    const defaults = { a: 10, b: 11 };
+    const props = { a: 1, c: 2 };
+
+    const coalesced = coalesceProperties(
+        () => props,
+        () => defaults
+    );
+
+    expect(coalesced.a).toEqual(1);
+    expect(coalesced.b).toEqual(11);
+    expect(coalesced.c).toEqual(2);
+    expect(coalesced.undef).toBeUndefined();
+
+    expect("a" in coalesced).toBeTruthy();
+    expect("b" in coalesced).toBeTruthy();
+    expect("c" in coalesced).toBeTruthy();
+    expect("undef" in coalesced).toBeFalsy();
+});

package/dist/src/utils/reservationMap.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A simple data structure for keeping track of unreserved space in one dimension.
+ * Doesn't do any balancing, reservations must be done in random order.
+ * Uses arrays to minimize object allocation and burden on GC.
+ *
+ * Note: this data structure appears to have some similarities to "Segment Tree".
+ * TODO: Balancing ideas: https://cp-algorithms.com/data_structures/segment_tree.html
+ */
+export default class ReservationMap {
+    /**
+     *
+     * @param {number} maxSize Max number of free slots that can be tracked
+     * @param {number} [lowerLimit]
+     * @param {number} [upperLimit]
+     */
+    constructor(maxSize: number, lowerLimit?: number, upperLimit?: number);
+    maxSize: number;
+    lowerLimit: number;
+    upperLimit: number;
+    lowerLimits: Float64Array;
+    upperLimits: Float64Array;
+    lowerChildren: Int32Array;
+    upperChildren: Int32Array;
+    reset(): void;
+    n: number;
+    /**
+     *
+     * @param {number} lower
+     * @param {number} upper
+     * @param {number} i
+     * @returns {number} Node index or -1 if not found
+     */
+    _findSlot(lower: number, upper: number, i?: number): number;
+    /**
+     *
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {boolean} true if reservation succeeded
+     */
+    reserve(lower: number, upper: number): boolean;
+}
+//# sourceMappingURL=reservationMap.d.ts.map

package/dist/src/utils/reservationMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reservationMap.d.ts","sourceRoot":"","sources":["../../../src/utils/reservationMap.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;IACI;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,eACN,MAAM,EAehB;IAZG,gBAAsB;IACtB,mBAA4B;IAC5B,mBAA4B;IAI5B,0BAA0C;IAC1C,0BAA0C;IAC1C,0BAA0C;IAC1C,0BAA0C;IAK9C,cAUC;IAHG,UAAU;IAKd;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,MACN,MAAM,GACJ,MAAM,CAkBlB;IAED;;;;;OAKG;IACH,eAJW,MAAM,SACN,MAAM,GACJ,OAAO,CA8BnB;CACJ"}

package/dist/src/utils/reservationMap.js

@@ -0,0 +1,103 @@
+/**
+ * A simple data structure for keeping track of unreserved space in one dimension.
+ * Doesn't do any balancing, reservations must be done in random order.
+ * Uses arrays to minimize object allocation and burden on GC.
+ *
+ * Note: this data structure appears to have some similarities to "Segment Tree".
+ * TODO: Balancing ideas: https://cp-algorithms.com/data_structures/segment_tree.html
+ */
+export default class ReservationMap {
+    /**
+     *
+     * @param {number} maxSize Max number of free slots that can be tracked
+     * @param {number} [lowerLimit]
+     * @param {number} [upperLimit]
+     */
+    constructor(maxSize, lowerLimit = -Infinity, upperLimit = Infinity) {
+        this.maxSize = maxSize;
+        this.lowerLimit = lowerLimit;
+        this.upperLimit = upperLimit;
+
+        const count = this.maxSize * 2 + 1; // TODO: The factor could be lower
+
+        this.lowerLimits = new Float64Array(count);
+        this.upperLimits = new Float64Array(count);
+        this.lowerChildren = new Int32Array(count);
+        this.upperChildren = new Int32Array(count);
+
+        this.reset();
+    }
+
+    reset() {
+        this.lowerLimits.fill(0);
+        this.upperLimits.fill(0);
+        this.lowerChildren.fill(0);
+        this.upperChildren.fill(0);
+
+        // Initial node
+        this.n = 1;
+        this.lowerLimits[0] = this.lowerLimit;
+        this.upperLimits[0] = this.upperLimit;
+    }
+
+    /**
+     *
+     * @param {number} lower
+     * @param {number} upper
+     * @param {number} i
+     * @returns {number} Node index or -1 if not found
+     */
+    _findSlot(lower, upper, i = 0) {
+        if (lower >= this.lowerLimits[i] && upper <= this.upperLimits[i]) {
+            const lowerChild = this.lowerChildren[i];
+            if (!lowerChild) {
+                // Node has no children, found a free slot
+                return i;
+            } else {
+                const lowerResult = this._findSlot(lower, upper, lowerChild);
+                if (lowerResult >= 0) {
+                    return lowerResult;
+                }
+                return this._findSlot(lower, upper, this.upperChildren[i]);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     *
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {boolean} true if reservation succeeded
+     */
+    reserve(lower, upper) {
+        if (upper - lower <= 0) {
+            throw new Error("Cannot reserve an empty or negative-size slot!");
+        }
+
+        if (this.n + 1 > this.lowerLimits.length) {
+            return false;
+        }
+
+        const i = this._findSlot(lower, upper);
+        if (i < 0) {
+            return false;
+        }
+
+        // TODO: if the requested range is connected to an edge of the free slot,
+        // adjust the found slot instead
+
+        const lowerIndex = this.n++;
+        const upperIndex = this.n++;
+
+        this.lowerLimits[lowerIndex] = this.lowerLimits[i];
+        this.upperLimits[lowerIndex] = lower;
+        this.lowerLimits[upperIndex] = upper;
+        this.upperLimits[upperIndex] = this.upperLimits[i];
+        this.lowerChildren[i] = lowerIndex;
+        this.upperChildren[i] = upperIndex;
+
+        return true;
+    }
+}

package/dist/src/utils/reservationMap.test.js

@@ -0,0 +1,20 @@
+import { expect, test } from "vitest";
+import ReservationMap from "./reservationMap";
+
+test("ReservationMap works correctly", () => {
+    const m = new ReservationMap(20);
+
+    expect(m.reserve(0, 3)).toBeTruthy();
+    expect(m.reserve(15, 17)).toBeTruthy();
+    expect(m.reserve(5, 11)).toBeTruthy();
+    expect(m.reserve(19, 22)).toBeTruthy();
+    expect(m.reserve(23, 26)).toBeTruthy();
+    expect(m.reserve(12, 13)).toBeTruthy();
+    expect(m.reserve(13, 14)).toBeTruthy();
+    expect(m.reserve(4, 5)).toBeTruthy();
+
+    expect(m.reserve(6, 8)).toBeFalsy();
+    expect(m.reserve(10, 13)).toBeFalsy();
+    expect(m.reserve(-2, 1)).toBeFalsy();
+    expect(m.reserve(25, 28)).toBeFalsy();
+});

package/dist/src/utils/scaleNull.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Like scaleIdentity but passes everything thru. Doesn't support domains or ranges or anything.
+ */
+export default function scaleNull(): {
+    (x: any): any;
+    /** @param {any} x */
+    invert(x: any): any;
+    copy: typeof scaleNull;
+    /** Keep vega-scale happy */
+    invertRange(): void;
+    type: string;
+};
+//# sourceMappingURL=scaleNull.d.ts.map

package/dist/src/utils/scaleNull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaleNull.d.ts","sourceRoot":"","sources":["../../../src/utils/scaleNull.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;QACgB,GAAG;IAGf,qBAAqB;cAAT,GAAG;;IAKf,4BAA4B;;;EAQ/B"}

package/dist/src/utils/scaleNull.js

@@ -0,0 +1,21 @@
+/**
+ * Like scaleIdentity but passes everything thru. Doesn't support domains or ranges or anything.
+ */
+export default function scaleNull() {
+    /** @param {any} x */
+    const scale = (x) => x;
+
+    /** @param {any} x */
+    scale.invert = (x) => x;
+
+    scale.copy = scaleNull;
+
+    /** Keep vega-scale happy */
+    scale.invertRange = () => {
+        //
+    };
+
+    scale.type = "null";
+
+    return scale;
+}

package/dist/src/utils/setOperations.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {Set<T>} set
+ * @param {Set<T>} subset
+ * @template T
+ */
+export function isSuperset<T>(set: Set<T>, subset: Set<T>): boolean;
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function union<T>(setA: Set<T>, setB: Set<T>): Set<T>;
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function intersection<T>(setA: Set<T>, setB: Set<T>): Set<any>;
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function symmetricDifference<T>(setA: Set<T>, setB: Set<T>): Set<T>;
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function difference<T>(setA: Set<T>, setB: Set<T>): Set<T>;
+//# sourceMappingURL=setOperations.d.ts.map

package/dist/src/utils/setOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setOperations.d.ts","sourceRoot":"","sources":["../../../src/utils/setOperations.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oEAOC;AAED;;;;GAIG;AACH,6DAMC;AAED;;;;GAIG;AACH,sEAQC;AAED;;;;GAIG;AACH,2EAUC;AAED;;;;GAIG;AACH,kEAMC"}

package/dist/src/utils/setOperations.js

@@ -0,0 +1,75 @@
+/*
+ * Adapted from: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#implementing_basic_set_operations
+ */
+
+/**
+ * @param {Set<T>} set
+ * @param {Set<T>} subset
+ * @template T
+ */
+export function isSuperset(set, subset) {
+    for (let elem of subset) {
+        if (!set.has(elem)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function union(setA, setB) {
+    let _union = new Set(setA);
+    for (let elem of setB) {
+        _union.add(elem);
+    }
+    return _union;
+}
+
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function intersection(setA, setB) {
+    let _intersection = new Set();
+    for (let elem of setB) {
+        if (setA.has(elem)) {
+            _intersection.add(elem);
+        }
+    }
+    return _intersection;
+}
+
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function symmetricDifference(setA, setB) {
+    let _difference = new Set(setA);
+    for (let elem of setB) {
+        if (_difference.has(elem)) {
+            _difference.delete(elem);
+        } else {
+            _difference.add(elem);
+        }
+    }
+    return _difference;
+}
+
+/**
+ * @param {Set<T>} setA
+ * @param {Set<T>} setB
+ * @template T
+ */
+export function difference(setA, setB) {
+    let _difference = new Set(setA);
+    for (let elem of setB) {
+        _difference.delete(elem);
+    }
+    return _difference;
+}

package/dist/src/utils/smoothstep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {number} edge0
+ * @param {number} edge1
+ * @param {number} x
+ */
+export default function smoothstep(edge0: number, edge1: number, x: number): number;
+//# sourceMappingURL=smoothstep.d.ts.map

package/dist/src/utils/smoothstep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoothstep.d.ts","sourceRoot":"","sources":["../../../src/utils/smoothstep.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,0CAJW,MAAM,SACN,MAAM,KACN,MAAM,UAMhB"}

package/dist/src/utils/smoothstep.js

@@ -0,0 +1,10 @@
+/**
+ * @param {number} edge0
+ * @param {number} edge1
+ * @param {number} x
+ */
+export default function smoothstep(edge0, edge1, x) {
+    x = (x - edge0) / (edge1 - edge0);
+    x = Math.max(0, Math.min(1, x));
+    return x * x * (3 - 2 * x);
+}

package/dist/src/utils/throttle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * https://codeburst.io/throttling-and-debouncing-in-javascript-b01cad5c8edf
+ *
+ * @param {function} func
+ * @param {number} limit
+ */
+export default function throttle(func: Function, limit: number): (...args: any[]) => void;
+//# sourceMappingURL=throttle.d.ts.map

package/dist/src/utils/throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../../src/utils/throttle.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wDAFW,MAAM,4BA2BhB"}

package/dist/src/utils/throttle.js

@@ -0,0 +1,34 @@
+/* eslint-disable consistent-this */
+
+/**
+ * https://codeburst.io/throttling-and-debouncing-in-javascript-b01cad5c8edf
+ *
+ * @param {function} func
+ * @param {number} limit
+ */
+export default function throttle(func, limit) {
+    /** @type {number} */
+    let lastFunc;
+
+    /** @type {number} */
+    let lastRan;
+
+    return function () {
+        // eslint-disable-next-line no-invalid-this
+        const context = this;
+        // eslint-disable-next-line prefer-rest-params
+        const args = arguments;
+        if (!lastRan) {
+            func.apply(context, args);
+            lastRan = Date.now();
+        } else {
+            clearTimeout(lastFunc);
+            lastFunc = window.setTimeout(function () {
+                if (Date.now() - lastRan >= limit) {
+                    func.apply(context, args);
+                    lastRan = Date.now();
+                }
+            }, limit - (Date.now() - lastRan));
+        }
+    };
+}