@genome-spy/core 0.29.0 → 0.30.2

package/src/utils/propertyCacher.js

@@ -1,70 +0,0 @@
-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/src/utils/propertyCacher.test.js

@@ -1,85 +0,0 @@
-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/src/utils/propertyCoalescer.js

@@ -1,42 +0,0 @@
-/**
- * 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/src/utils/propertyCoalescer.test.js

@@ -1,22 +0,0 @@
-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/src/utils/reservationMap.js

@@ -1,103 +0,0 @@
-/**
- * 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/src/utils/reservationMap.test.js

@@ -1,20 +0,0 @@
-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/src/utils/scaleNull.js

@@ -1,19 +0,0 @@
-/**
- * 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 = () => {
-        //
-    };
-
-    return scale;
-}

package/src/utils/setOperations.js

@@ -1,75 +0,0 @@
-/*
- * 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/src/utils/smoothstep.js

@@ -1,10 +0,0 @@
-/**
- * @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/src/utils/throttle.js

@@ -1,34 +0,0 @@
-/* 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));
-        }
-    };
-}

package/src/utils/topK.js

@@ -1,76 +0,0 @@
-import FlatQueue from "flatqueue";
-
-/**
- * Finds the top k
- *
- * Based on ideas at https://lemire.me/blog/2017/06/21/top-speed-for-top-k-queries/
- *
- * @param {T[]} data
- * @param {number} k
- * @param {(datum: T) => number} priorityAccessor
- * @template T
- */
-export function topK(data, k, priorityAccessor) {
-    /** @type {FlatQueue<number>} */
-    const queue = new FlatQueue();
-
-    let i;
-    for (i = 0; i < k && i < data.length; i++) {
-        queue.push(i, priorityAccessor(data[i]));
-    }
-
-    for (; i < data.length; i++) {
-        const p = priorityAccessor(data[i]);
-        if (p >= queue.peekValue()) {
-            queue.push(i, p);
-            queue.pop();
-        }
-    }
-
-    const result = [];
-
-    let index;
-    while ((index = queue.pop()) !== undefined) {
-        result.push(data[index]);
-    }
-
-    return result.reverse();
-}
-
-/**
- * Takes an array of priorities and returns the top k indices from the
- * specified slice
- *
- * @param {number[]} priorities An array of priorities
- * @param {number} k
- * @param {number} [start] Default: 0
- * @param {number} [end] Exclusive. Default: priorities.length
- */
-export function topKSlice(priorities, k, start = 0, end = priorities.length) {
-    /** @type {FlatQueue<number>} */
-    const queue = new FlatQueue();
-
-    const sliceLength = end - start;
-
-    let i;
-    for (i = 0; i < k && i < sliceLength; i++) {
-        queue.push(i, priorities[start + i]);
-    }
-
-    for (; i < sliceLength; i++) {
-        const p = priorities[start + i];
-        if (p >= queue.peekValue()) {
-            queue.push(i, p);
-            queue.pop();
-        }
-    }
-
-    const result = [];
-
-    let index;
-    while ((index = queue.pop()) !== undefined) {
-        result.push(start + index);
-    }
-
-    return result.reverse();
-}

package/src/utils/topK.test.js

@@ -1,64 +0,0 @@
-import { expect, test } from "vitest";
-import { range } from "d3-array";
-import { topK, topKSlice } from "./topK";
-
-test("topK returns top k numbers in priority order", () => {
-    /** @param {number} x */
-    const priorityAccessor = (x) => x;
-
-    expect(topK([1, 2, 3], 3, priorityAccessor)).toEqual([3, 2, 1]);
-    expect(topK([1, 2, 3], 1, priorityAccessor)).toEqual([3]);
-    expect(topK([1, 2, 3], 6, priorityAccessor)).toEqual([3, 2, 1]);
-    expect(topK([1, 2, 3, 4, 5, 6], 3, priorityAccessor)).toEqual([6, 5, 4]);
-    expect(topK([0, 9, 1, 8, 2, 7, 3, 6, 4, 5], 3, priorityAccessor)).toEqual([
-        9, 8, 7,
-    ]);
-    expect(topK([1, 1, 1], 3, priorityAccessor)).toEqual([1, 1, 1]);
-});
-
-test("topK returns top k objects in priority order", () => {
-    /** @param {{priority: number}} d */
-    const priorityAccessor = (d) => d.priority;
-
-    expect(
-        topK(
-            [0, 9, 1, 8, 2, 7, 3, 6, 4, 5].map((x) => ({ priority: x })),
-            3,
-            priorityAccessor
-        )
-    ).toEqual([9, 8, 7].map((x) => ({ priority: x })));
-});
-
-test("topK returns top k objects in priority order with large datasets", () => {
-    /** @param {number} x */
-    const priorityAccessor = (x) => x;
-
-    const n = 10000;
-    const bigArray = range(n).map((x) => Math.floor(Math.random() * 100));
-    const sortedBigArray = bigArray.slice().sort((a, b) => b - a);
-
-    for (let k = 0; k < 13000; k += 1000) {
-        expect(topK(bigArray, k, priorityAccessor)).toEqual(
-            sortedBigArray.slice(0, k)
-        );
-    }
-});
-
-test("topKSlice returns top k indexes in priority order", () => {
-    expect(topKSlice([0, 1, 2], 3)).toEqual([2, 1, 0]);
-    expect(topKSlice([1, 2, 3], 3)).toEqual([2, 1, 0]);
-    expect(topKSlice([0, 1, 2], 1)).toEqual([2]);
-    expect(topKSlice([0, 1, 2], 6)).toEqual([2, 1, 0]);
-    expect(topKSlice([0, 1, 2, 3, 4, 5], 3)).toEqual([5, 4, 3]);
-    expect(topKSlice([0, 9, 1, 8, 2, 7, 3, 6, 4, 5], 3)).toEqual([1, 3, 5]);
-    expect(new Set(topKSlice([1, 1, 1, 2, 2, 2], 3))).toEqual(
-        new Set([3, 4, 5])
-    );
-});
-
-test("topKSlice returns top k indexes from a slice in priority order", () => {
-    expect(topKSlice([0, 1, 2, 3, 4, 5], 2, 1, 5)).toEqual([4, 3]);
-    expect(topKSlice([0, 9, 1, 8, 2, 7, 3, 6, 4, 5], 3, 1, 5)).toEqual([
-        1, 3, 4,
-    ]);
-});

package/src/utils/transition.js

@@ -1,74 +0,0 @@
-/** @param {number} ms */
-const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-/**
- * @param {TransitionOptions} options
- *
- * @typedef {Object} TransitionOptions
- * @prop {number} [from] default: 0
- * @prop {number} [to] default: 1
- * @prop {number} [duration] in milliseconds, default: 1000
- * @prop {number} [delay] milliseconds to wait before the transition starts, default: 0
- * @prop {function(number):void} onUpdate
- * @prop {function(number):number} [easingFunction] default: linear
- * @prop {function(function(number):void):void} [requestAnimationFrame]
- *      default: window.requestAnimationFrame
- * @prop {AbortSignal} [signal]
- */
-export default function transition(options) {
-    const requestAnimationFrame =
-        options.requestAnimationFrame || window.requestAnimationFrame;
-
-    const signal = options.signal;
-
-    const makePromise = () =>
-        new Promise((resolve, reject) => {
-            if (signal?.aborted) {
-                return reject("aborted");
-            }
-
-            const beginTimestamp = performance.now();
-            const endTimestamp = beginTimestamp + (options.duration || 1000);
-
-            const from = typeof options.from == "number" ? options.from : 0;
-            const to = typeof options.to == "number" ? options.to : 1;
-            const ease = options.easingFunction || ((x) => x);
-
-            /** @param {number} x */
-            const toUnit = (x) =>
-                (x - beginTimestamp) / (endTimestamp - beginTimestamp);
-
-            /** @param {number} x */
-            const toRange = (x) => x * (to - from) + from;
-
-            /** @param {number} x */
-            const clamp = (x) => Math.max(0, Math.min(1, x));
-
-            /** @param {number} stamp */
-            const step = (stamp) => {
-                if (signal?.aborted) {
-                    reject("aborted");
-                } else {
-                    options.onUpdate(toRange(ease(clamp(toUnit(stamp)))));
-                    if (stamp < endTimestamp) {
-                        requestAnimationFrame(step);
-                    } else {
-                        options.onUpdate(toRange(ease(1)));
-                        resolve();
-                    }
-                }
-            };
-
-            requestAnimationFrame(step);
-        });
-
-    if (options.delay) {
-        if (signal?.aborted) {
-            return Promise.reject("aborted");
-        }
-
-        return wait(options.delay).then(makePromise);
-    } else {
-        return makePromise();
-    }
-}