@genome-spy/core 0.30.0 → 0.30.3

package/src/utils/binnedIndex.js

@@ -1,167 +0,0 @@
-import clamp from "./clamp";
-
-const MAX_INTEGER = 2 ** 31 - 1;
-const MIN_INTEGER = -(2 ** 31);
-
-/**
- * @callback Lookup
- * @param {number} start
- * @param {number} end
- * @param {[number, number]} [arr] Store the result into this array (and return it)
- * @returns {[number, number]}
- */
-
-/**
- * A binned index for (overlapping) ranges that are sorted by their start position.
- * Each indexed range is associated with respective vertex indices.
- *
- * @param {number} size Number of bins
- * @param {[number, number]} domain Domain of positions
- * @param {(datum: T) => number} accessor Accessor for range's start position
- * @param {(datum: T) => number} [accessor2] Accessor for range's end position
- * @template T
- */
-export function createBinningRangeIndexer(
-    size,
-    domain,
-    accessor,
-    accessor2 = accessor
-) {
-    const startIndices = new Int32Array(size);
-    startIndices.fill(MAX_INTEGER);
-
-    let lastIndex = MIN_INTEGER;
-    let unordered = false;
-
-    const endIndices = new Int32Array(size);
-
-    const start = domain[0];
-    const domainLength = domain[1] - domain[0];
-    const divisor = domainLength / size;
-
-    /**
-     * @param {number} pos
-     * @param {boolean} end
-     */
-    const getBin = (pos, end) => {
-        const unfloored = (pos - start) / divisor;
-        const floored = Math.floor(unfloored);
-
-        // Special handling for the end coordinate because we are using half-open ranges.
-        return clamp(
-            end && floored == unfloored ? floored - 1 : floored,
-            0,
-            size - 1
-        );
-    };
-
-    /**
-     * Indexer for point items. Those have just a single coordinate.
-     *
-     * @param {T} datum
-     * @param {number} startVertexIndex
-     * @param {number} endVertexIndex
-     */
-    function binningIndexer(datum, startVertexIndex, endVertexIndex) {
-        if (startVertexIndex > lastIndex) {
-            lastIndex = startVertexIndex;
-        } else if (!unordered) {
-            unordered = true;
-            // TODO: Contextual info like view path
-            console.debug(
-                "Items are not ordered properly. Disabling binned index."
-            );
-        }
-
-        const value = accessor(datum);
-        const bin = getBin(value, false);
-
-        if (startIndices[bin] > startVertexIndex) {
-            startIndices[bin] = startVertexIndex;
-        }
-
-        if (endIndices[bin] < endVertexIndex) {
-            endIndices[bin] = endVertexIndex;
-        }
-    }
-
-    /**
-     * Indexer for ranged items. Those have both start and end coordinates.
-     *
-     * @param {T} datum
-     * @param {number} startVertexIndex
-     * @param {number} endVertexIndex
-     */
-    function binningRangeIndexer(datum, startVertexIndex, endVertexIndex) {
-        if (startVertexIndex > lastIndex) {
-            lastIndex = startVertexIndex;
-        } else if (!unordered) {
-            unordered = true;
-            // TODO: Contextual info like view path
-            console.debug(
-                "Items are not ordered properly. Disabling binned index."
-            );
-        }
-
-        const start = accessor(datum);
-        const end = accessor2(datum);
-        const startBin = getBin(start, false);
-        const endBin = getBin(end, true);
-
-        // TODO: This loop could probably be done as a more efficient post processing
-        // step.
-        for (let bin = startBin; bin <= endBin; bin++) {
-            if (startIndices[bin] > startVertexIndex) {
-                startIndices[bin] = startVertexIndex;
-            }
-
-            if (endIndices[bin] < endVertexIndex) {
-                endIndices[bin] = endVertexIndex;
-            }
-        }
-    }
-
-    /**
-     * @type {Lookup}
-     */
-    const lookup = (start, end, arr = [0, 0]) => {
-        const startBin = getBin(start, false);
-        const endBin = getBin(end, true);
-        const startIndex = startIndices[startBin];
-        const endIndex = Math.max(endIndices[endBin], startIndex);
-
-        arr[0] = startIndex;
-        arr[1] = endIndex;
-        return arr;
-    };
-
-    const getIndex = () => {
-        for (let i = 1; i < endIndices.length; i++) {
-            if (endIndices[i] < endIndices[i - 1]) {
-                endIndices[i] = endIndices[i - 1];
-            }
-        }
-
-        let tail = true;
-
-        for (let i = startIndices.length - 1; i > 0; i--) {
-            if (tail && startIndices[i] == MAX_INTEGER) {
-                startIndices[i] = endIndices[i];
-                tail = false;
-            } else if (startIndices[i - 1] > startIndices[i]) {
-                startIndices[i - 1] = startIndices[i];
-            }
-        }
-
-        return lookup;
-    };
-
-    binningIndexer.getIndex = getIndex;
-    binningRangeIndexer.getIndex = getIndex;
-
-    if (unordered) {
-        return undefined;
-    } else {
-        return accessor == accessor2 ? binningIndexer : binningRangeIndexer;
-    }
-}

package/src/utils/binnedIndex.test.js

@@ -1,155 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { createBinningRangeIndexer } from "./binnedIndex.js";
-
-describe("Binning Indexer", () => {
-    test("Single point is binned correctly", () => {
-        const items = [25];
-        const indexer = createBinningRangeIndexer(10, [0, 100], (x) => x);
-
-        // Each item uses two vertices
-        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
-
-        const index = indexer.getIndex();
-
-        expect(index(1, 4)).toEqual([0, 0]);
-        expect(index(23, 27)).toEqual([0, 2]);
-        expect(index(13, 37)).toEqual([0, 2]);
-        // TODO: MAX_INT could be replaced with the actual maximum vertex number
-        expect(index(40, 42)).toEqual([2147483647, 2147483647]);
-    });
-
-    test("Multiple points are binned correctly", () => {
-        const items = [0, 1, 4, 10, 35, 35, 36, 80];
-        const indexer = createBinningRangeIndexer(10, [0, 100], (x) => x);
-
-        // Each item uses two vertices
-        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
-
-        const index = indexer.getIndex();
-
-        expect(index(0, 0)).toEqual([0, 6]);
-        expect(index(0, 1)).toEqual([0, 6]);
-        expect(index(1, 2)).toEqual([0, 6]);
-        expect(index(1, 15)).toEqual([0, 8]);
-        expect(index(3, 6)).toEqual([0, 6]);
-        expect(index(10, 15)).toEqual([6, 8]);
-        expect(index(11, 38)).toEqual([6, 14]);
-        expect(index(11, 45)).toEqual([6, 14]);
-        expect(index(34, 36)).toEqual([8, 14]);
-        expect(index(35.5, 36.5)).toEqual([8, 14]);
-        expect(index(40, 50)).toEqual([14, 14]);
-        expect(index(40, 85)).toEqual([14, 16]);
-        expect(index(90, 100)).toEqual([16, 16]);
-
-        expect(index(0, 100)).toEqual([0, 16]);
-        expect(index(-1, 100)).toEqual([0, 16]);
-        expect(index(0, 101)).toEqual([0, 16]);
-    });
-
-    test("Non-overlapping ranges are binned correctly", () => {
-        const items = [
-            [0, 5],
-            [25, 48],
-            [50, 55],
-            [64, 67],
-            [72, 75],
-            [75, 78],
-            [86, 90],
-            [90, 93],
-        ];
-        const indexer = createBinningRangeIndexer(
-            10,
-            [0, 100],
-            (x) => x[0],
-            (x) => x[1]
-        );
-
-        // Each item uses two vertices
-        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
-
-        const index = indexer.getIndex();
-
-        expect(index(0, 1)).toEqual([0, 2]);
-        expect(index(3, 40)).toEqual([0, 4]);
-        expect(index(6, 40)).toEqual([0, 4]);
-        expect(index(15, 30)).toEqual([2, 4]);
-        expect(index(50, 57)).toEqual([4, 6]);
-        expect(index(62, 69)).toEqual([6, 8]);
-        expect(index(69, 71)).toEqual([6, 12]);
-        expect(index(69, 79)).toEqual([6, 12]);
-
-        expect(index(80, 90)).toEqual([12, 14]);
-        expect(index(90, 100)).toEqual([14, 16]);
-
-        expect(index(0, 99)).toEqual([0, 16]);
-        expect(index(0, 100)).toEqual([0, 16]);
-    });
-
-    test("Overlapping ranges with the same start coordinate are binned correctly", () => {
-        const items = [
-            // Increasing lengths
-            [0, 5],
-            [0, 64],
-            [0, 80],
-            // Decreasing lengths
-            [100, 191],
-            [100, 167],
-            [100, 123],
-        ];
-        const indexer = createBinningRangeIndexer(
-            100,
-            [0, 1000],
-            (x) => x[0],
-            (x) => x[1]
-        );
-
-        // Each item uses two vertices
-        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
-
-        const index = indexer.getIndex();
-
-        expect(index(0, 1)).toEqual([0, 6]);
-        expect(index(3, 40)).toEqual([0, 6]);
-        expect(index(0, 100)).toEqual([0, 6]);
-        expect(index(77, 78)).toEqual([4, 6]);
-
-        expect(index(90, 205)).toEqual([6, 12]);
-        expect(index(111, 115)).toEqual([6, 12]);
-        // Not optimal. Should be [6, 8], but [6, 12] is not wrong
-        expect(index(180, 190)).toEqual([6, 12]);
-    });
-
-    test("Overlapping ranges are binned correctly", () => {
-        const items = [
-            [10, 30],
-            [25, 50],
-
-            [102, 129],
-            [112, 139],
-            [121, 149],
-        ];
-        const indexer = createBinningRangeIndexer(
-            100,
-            [0, 1000],
-            (x) => x[0],
-            (x) => x[1]
-        );
-
-        items.forEach((x, i) => indexer(x, i * 2, (i + 1) * 2));
-
-        const index = indexer.getIndex();
-
-        // TODO: More tests
-
-        expect(index(0, 5)).toEqual([0, 0]);
-        expect(index(0, 15)).toEqual([0, 2]);
-        expect(index(27, 40)).toEqual([0, 4]);
-        expect(index(40, 50)).toEqual([2, 4]);
-        expect(index(40, 80)).toEqual([2, 4]);
-        expect(index(10, 29)).toEqual([0, 4]);
-
-        expect(index(90, 160)).toEqual([4, 10]);
-        expect(index(115, 116)).toEqual([4, 8]);
-        expect(index(135, 145)).toEqual([6, 10]);
-    });
-});

package/src/utils/clamp.js

@@ -1,8 +0,0 @@
-/**
- * @param {number} value
- * @param {number} [min]
- * @param {number} [max]
- */
-export default function clamp(value, min = 0, max = 1) {
-    return Math.max(min, Math.min(max, value));
-}

package/src/utils/cloner.js

@@ -1,34 +0,0 @@
-/**
- * Creates a shallow-cloner function that ensures (hopefully) that the properties
- * end up into the in-object storage. Offers better performance than Object.assign
- * and saves memory.
- *
- * Read more at:
- * https://mrale.ph/blog/2014/07/30/constructor-vs-objectcreate.html
- *
- * @param {T} template The template object that
- * @returns {(function(T):T) & { properties: string[] }}
- * @template T
- */
-export default function createCloner(template) {
-    // TODO: Check that only properties, not methods get cloned
-    const properties = /** @type {string[]} */ (
-        Object.keys(template).filter((k) => typeof k == "string")
-    );
-
-    const cloner = /** @type {(function(T):T) & { properties: string[] }} */ (
-        new Function(
-            "source",
-            "return { " +
-                properties
-                    .map((prop) => JSON.stringify(prop))
-                    .map((prop) => `${prop}: source[${prop}]`)
-                    .join(",\n") +
-                " };"
-        )
-    );
-
-    cloner.properties = properties;
-
-    return cloner;
-}

package/src/utils/cloner.test.js

@@ -1,24 +0,0 @@
-import { expect, test } from "vitest";
-import createCloner from "./cloner";
-
-const template = {
-    a: 1,
-    b: "xyzzy",
-    3: "iddqd",
-};
-
-test("Cloner clones object properly", () => {
-    const makeClone = createCloner(template);
-
-    expect(makeClone(template)).toEqual(template);
-    expect(makeClone(template)).not.toBe(template);
-
-    const another = {
-        a: 2,
-        b: "idkfa",
-        3: "hello",
-    };
-
-    expect(makeClone(another)).toEqual(another);
-    expect(makeClone(another)).not.toBe(another);
-});

package/src/utils/coalesce.js

@@ -1,11 +0,0 @@
-/**
- *
- * @param {any[]} candidates
- */
-export default function coalesce(...candidates) {
-    for (const candidate of candidates) {
-        if (candidate !== undefined) {
-            return candidate;
-        }
-    }
-}

package/src/utils/coalesce.test.js

@@ -1,16 +0,0 @@
-import { expect, test } from "vitest";
-import coalesce from "./coalesce";
-
-test("Coalesce returns first defined value", () => {
-    expect(coalesce(0, 1, 2, 3)).toEqual(0);
-    expect(coalesce(undefined, 1, 2, 3)).toEqual(1);
-    expect(coalesce(undefined, undefined, 2, 3)).toEqual(2);
-});
-
-test("Coalesce returns undefined if input is all-undefined", () => {
-    expect(coalesce(undefined, undefined)).toBeUndefined();
-});
-
-test("Coalesce returns undefined on empty input", () => {
-    expect(coalesce()).toBeUndefined();
-});

package/src/utils/concatIterables.js

@@ -1,26 +0,0 @@
-/**
- * @param  {...Iterable<T>} iterables
- * @template T
- */
-export default function concatIterables(...iterables) {
-    if (iterables.length <= 0) {
-        return {
-            *[Symbol.iterator]() {
-                //
-            },
-        };
-    }
-
-    let currentIterable = iterables.shift();
-
-    return {
-        *[Symbol.iterator]() {
-            do {
-                for (const value of currentIterable) {
-                    yield value;
-                }
-                currentIterable = iterables.shift();
-            } while (currentIterable);
-        },
-    };
-}

package/src/utils/concatIterables.test.js

@@ -1,8 +0,0 @@
-import { expect, test } from "vitest";
-import concatIterables from "./concatIterables";
-
-test("ConcatIterables yields all elements in the correct order", () => {
-    expect([...concatIterables([1, 2], [3, 4], [5, 6, 7], [-1000])]).toEqual([
-        1, 2, 3, 4, 5, 6, 7, -1000,
-    ]);
-});

package/src/utils/debounce.js

@@ -1,37 +0,0 @@
-/**
- * @param {(...args:T) => R} func
- * @param {number} wait
- * @template {any[]} T
- * @template R
- */
-export function debounce(func, wait, rejectOnDebounce = true) {
-    /** @type {number} */
-    let timeout;
-
-    /** @type {(reason?: any) => void} */
-    let rejectPrevious = (_) => undefined;
-
-    /**
-     * @param {T} args
-     * @return {Promise<R>} */
-    const debouncer = function debouncer(...args) {
-        return new Promise((resolve, reject) => {
-            const later = () => {
-                clearTimeout(timeout);
-                rejectPrevious = (_) => undefined;
-
-                resolve(func(...args));
-            };
-
-            if (rejectOnDebounce) {
-                rejectPrevious("debounced");
-            }
-            clearTimeout(timeout);
-
-            rejectPrevious = reject;
-            timeout = setTimeout(later, wait);
-        });
-    };
-
-    return debouncer;
-}