@genome-spy/core 0.36.0 → 0.37.0

package/dist/src/utils/binnedIndex.js

@@ -0,0 +1,167 @@
+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/dist/src/utils/binnedIndex.test.js

@@ -0,0 +1,155 @@
+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/dist/src/utils/clamp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {number} value
+ * @param {number} [min]
+ * @param {number} [max]
+ */
+export default function clamp(value: number, min?: number, max?: number): number;
+//# sourceMappingURL=clamp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.d.ts","sourceRoot":"","sources":["../../../src/utils/clamp.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qCAJW,MAAM,QACN,MAAM,QACN,MAAM,UAIhB"}

package/dist/src/utils/clamp.js

@@ -0,0 +1,8 @@
+/**
+ * @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/dist/src/utils/cloner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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<T>(template: T): ((arg0: T) => T) & {
+    properties: string[];
+};
+//# sourceMappingURL=cloner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloner.d.ts","sourceRoot":"","sources":["../../../src/utils/cloner.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH;gBAH6C,MAAM,EAAE;EAwBpD"}

package/dist/src/utils/cloner.js

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

@@ -0,0 +1,24 @@
+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/dist/src/utils/coalesce.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {any[]} candidates
+ */
+export default function coalesce(...candidates: any[]): any;
+//# sourceMappingURL=coalesce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["../../../src/utils/coalesce.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,gDAFW,GAAG,EAAE,OAQf"}

package/dist/src/utils/coalesce.js

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

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

@@ -0,0 +1,16 @@
+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/dist/src/utils/concatIterables.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param  {...Iterable<T>} iterables
+ * @template T
+ */
+export default function concatIterables<T>(...iterables: Iterable<T>[]): {
+    [Symbol.iterator](): Generator<T, void, unknown>;
+};
+//# sourceMappingURL=concatIterables.d.ts.map

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

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

package/dist/src/utils/concatIterables.js

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

@@ -0,0 +1,8 @@
+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/dist/src/utils/debounce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {(...args:T) => R} func
+ * @param {number} wait
+ * @template {any[]} T
+ * @template R
+ */
+export function debounce<T extends any[], R>(func: (...args: T) => R, wait: number, rejectOnDebounce?: boolean): (...args: T) => Promise<R>;
+//# sourceMappingURL=debounce.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../src/utils/debounce.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,4EAJW,MAAM,0DAkChB"}

package/dist/src/utils/debounce.js

@@ -0,0 +1,37 @@
+/**
+ * @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 = window.setTimeout(later, wait);
+        });
+    };
+
+    return debouncer;
+}

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

@@ -0,0 +1,61 @@
+/**
+ *
+ * @param {string} type
+ * @param {scalar[]} [initialDomain]
+ */
+export default function createDomain(type: string, initialDomain?: scalar[]): DomainArray;
+/**
+ * For unit tests
+ *
+ * @param {DomainArray | any[]} domainArray
+ */
+export function toRegularArray(domainArray: DomainArray | any[]): any[];
+/**
+ * @typedef {boolean | number | string} scalar
+ */
+export class DomainArray extends Array<any> {
+    constructor();
+    /** @type {string} */
+    type: string;
+    /**
+     *
+     * @param {scalar} value
+     * @returns {DomainArray}
+     */
+    extend(value: scalar): DomainArray;
+    /**
+     *
+     * @param {Iterable<scalar>} values
+     * @returns {DomainArray}
+     */
+    extendAll(values: Iterable<scalar>): DomainArray;
+    /**
+     * @param {Iterable<T>} values
+     * @param {function(T):scalar} [accessor]
+     * @returns {DomainArray}
+     * @template T
+     */
+    extendAllWithAccessor<T>(values: Iterable<T>, accessor?: (arg0: T) => scalar): DomainArray;
+}
+export class QuantitativeDomain extends DomainArray {
+    0: number;
+    1: number;
+}
+/**
+ * Builder that tries to preserve the order
+ */
+export class OrdinalDomain extends DomainArray {
+    /** @type {Set<scalar>} */
+    uniqueValues: Set<scalar>;
+}
+export class NominalDomain extends OrdinalDomain {
+}
+export class PiecewiseDomain extends DomainArray {
+    /**
+     *
+     * @param {number[]} initialDomain
+     */
+    constructor(initialDomain: number[]);
+}
+export type scalar = boolean | number | string;
+//# sourceMappingURL=domainArray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"domainArray.d.ts","sourceRoot":"","sources":["../../../src/utils/domainArray.js"],"names":[],"mappings":"AA8KA;;;;GAIG;AACH,2CAHW,MAAM,kBACN,MAAM,EAAE,eAiBlB;AAED;;;;GAIG;AACH,4CAFW,WAAW,GAAG,GAAG,EAAE,SAI7B;AA3MD;;GAEG;AAEH;IACI,cAIC;IAFG,qBAAqB;IACrB,MADW,MAAM,CACI;IAGzB;;;;OAIG;IACH,cAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;;OAIG;IACH,kBAHW,SAAS,MAAM,CAAC,GACd,WAAW,CAcvB;IAED;;;;;OAKG;IACH,sEAJuB,MAAM,GAChB,WAAW,CASvB;CACJ;AAED;IAoBgB,UAAe;IAEf,UAAe;CAS9B;AAED;;GAEG;AACH;IAKQ,0BAA0B;IAC1B,cADW,IAAI,MAAM,CAAC,CACO;CAoBpC;AAED;CAKC;AAED;IACI;;;OAGG;IACH,2BAFW,MAAM,EAAE,EAiBlB;CAgBJ;qBAhKY,OAAO,GAAG,MAAM,GAAG,MAAM"}