@genome-spy/core 0.64.0 → 0.66.1

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

@@ -1,130 +0,0 @@
-import { describe, expect, test } from "vitest";
-import createDomain, {
-    toRegularArray as r,
-    PiecewiseDomain,
-} from "./domainArray.js";
-
-describe("Build quantitative domains", () => {
-    test("Empty domain", () => {
-        const b = createDomain("quantitative");
-        expect(r(b)).toEqual([]);
-    });
-
-    test("Extends by one value at a time", () => {
-        const b = createDomain("quantitative");
-        b.extend(2);
-        b.extend(1);
-        b.extend(null);
-        b.extend(undefined);
-        b.extend(NaN);
-        b.extend(5);
-        b.extend(4);
-        expect(r(b)).toEqual([1, 5]);
-    });
-
-    test("Extends with an iterable", () => {
-        const b = createDomain("quantitative");
-        b.extendAll([2, 1, null, undefined, NaN, 5, 4]);
-        expect(r(b)).toEqual([1, 5]);
-    });
-
-    test("Extends with an iterable and an accessor", () => {
-        const b = createDomain("quantitative");
-        b.extendAllWithAccessor(
-            [
-                { x: 2 },
-                { x: 1 },
-                { x: null },
-                { x: undefined },
-                { x: NaN },
-                { x: 5 },
-                { x: 4 },
-            ],
-            (d) => d.x
-        );
-        expect(r(b)).toEqual([1, 5]);
-    });
-
-    test("Coerces to number", () => {
-        const b = createDomain("quantitative");
-        expect(r(b.extend("123"))).toEqual([123, 123]);
-    });
-});
-
-describe("Build ordinal domains", () => {
-    // Note: nominal is an unordered abstraction of ordinal. Testing just ordinal is enough.
-
-    test("Empty domain", () => {
-        const b = createDomain("ordinal");
-        expect(r(b)).toEqual([]);
-    });
-
-    test("Extends by one value at a time, preserves order", () => {
-        const b = createDomain("ordinal");
-        b.extend("a");
-        b.extend("b");
-        b.extend("c");
-        b.extend("b");
-        b.extend(null);
-        b.extend(undefined);
-        b.extend(NaN);
-        b.extend("d");
-        expect(r(b)).toEqual(["a", "b", "c", "d"]);
-    });
-});
-
-describe("Build piecewise domains", () => {
-    test("Creates a piecewise domain", () => {
-        expect(createDomain("quantitative", [1])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(createDomain("quantitative", [1, 2, 3])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(createDomain("quantitative", [1, 2, 3, 4])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(createDomain("quantitative", [3, 2, 1])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(r(createDomain("quantitative", [3, 2, 1]))).toEqual([3, 2, 1]);
-    });
-
-    test("Throws on domain that is not stricly increasing or decreasing", () => {
-        expect(() => createDomain("quantitative", [2, 1, 3])).toThrow();
-        expect(() => createDomain("quantitative", [2, 3, 1])).toThrow();
-        expect(() => createDomain("quantitative", [3, 0, 2])).toThrow();
-        expect(() => createDomain("quantitative", [0, 3, 2])).toThrow();
-        expect(() => createDomain("quantitative", [1, 2, 2, 3])).toThrow();
-    });
-
-    test("Throws on mutation attempts", () => {
-        expect(() =>
-            createDomain("quantitative", [1, 2, 3]).extend(4)
-        ).toThrow();
-    });
-
-    test("Does not throw when extending with existing value", () => {
-        expect(r(createDomain("quantitative", [1, 2, 3]).extend(2))).toEqual([
-            1, 2, 3,
-        ]);
-    });
-});
-
-describe("Annotations", () => {
-    test("Quantitative domain is annotated", () =>
-        expect(createDomain("quantitative").type).toEqual("quantitative"));
-
-    test("Ordinal domain is annotated", () =>
-        expect(createDomain("ordinal").type).toEqual("ordinal"));
-
-    test("Nominal domain is annotated", () =>
-        expect(createDomain("nominal").type).toEqual("nominal"));
-});
-
-describe("Other stuff", () => {
-    test("Throws on extending by other type of domain array", () =>
-        expect(() =>
-            createDomain("quantitative").extendAll(createDomain("nominal"))
-        ).toThrow());
-});

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

@@ -1,49 +0,0 @@
-import { expect, test } from "vitest";
-import createIndexer from "./indexer.js";
-
-test("Index values one by one", () => {
-    const indexer = createIndexer();
-
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("b")).toEqual(1);
-    expect(indexer("c")).toEqual(2);
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("c")).toEqual(2);
-    expect(indexer("c")).toEqual(2);
-});
-
-test("Index multiple values (predefined domain)", () => {
-    const indexer = createIndexer();
-
-    indexer.addAll(["a", "b", "c"]);
-
-    expect(indexer("d")).toEqual(3);
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("b")).toEqual(1);
-    expect(indexer("c")).toEqual(2);
-    expect(indexer("d")).toEqual(3);
-});
-
-test("Indexer inverts index numbers", () => {
-    const indexer = createIndexer();
-
-    indexer.addAll(["a", "b", "c"]);
-
-    expect(indexer.invert(0)).toEqual("a");
-    expect(indexer.invert(1)).toEqual("b");
-    expect(indexer.invert(2)).toEqual("c");
-    expect(indexer.invert(3)).toBeUndefined();
-});
-
-test("Indexer return correct domain", () => {
-    const indexer = createIndexer();
-
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("b")).toEqual(1);
-    expect(indexer("c")).toEqual(2);
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("c")).toEqual(2);
-
-    expect(indexer.domain()).toEqual(["a", "b", "c"]);
-});

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

@@ -1,35 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createPrimitiveEventProxy } from "./interactionEvent.js";
-
-describe("createPrimitiveEventProxy", () => {
-    it("exposes primitive properties and hides non-primitives", () => {
-        const mock = {
-            type: "click",
-            clientX: 42,
-            meta: { foo: "bar" },
-            nested: { a: 1 },
-        };
-
-        /** @type {any} */
-        const proxy = createPrimitiveEventProxy(mock);
-
-        // allowed primitives
-        expect(proxy.type).toBe("click");
-        expect(proxy.clientX).toBe(42);
-
-        // non-primitive access throws
-        expect(() => proxy.meta).toThrow(/non-primitive/);
-
-        // keys enumeration hides non-primitives
-        const keys = Object.keys(proxy);
-        expect(keys).toContain("type");
-        expect(keys).not.toContain("meta");
-
-        // `in` operator respects the policy
-        expect("type" in proxy).toBe(true);
-        expect("meta" in proxy).toBe(false);
-
-        // prototype is hidden
-        expect(Object.getPrototypeOf(proxy)).toBeNull();
-    });
-});

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

@@ -1,33 +0,0 @@
-import { expect, test } from "vitest";
-import { group } from "d3-array";
-import iterateNestedMaps from "./iterateNestedMaps.js";
-
-const data = [
-    { name: "jim", amount: "34.0", date: "11/12/2015" },
-    { name: "carl", amount: "120.11", date: "11/12/2015" },
-    { name: "stacy", amount: "12.01", date: "01/04/2016" },
-    { name: "stacy", amount: "34.05", date: "01/04/2016" },
-    { name: "stacy", amount: "1.5", date: "02/04/2016" },
-];
-
-const groups = group(
-    data,
-    (d) => d.name,
-    (d) => d.date
-);
-
-test("iterateNestedMaps iterates correctly", () => {
-    const expected = [
-        [["jim", "11/12/2015"], [data[0]]],
-        [["carl", "11/12/2015"], [data[1]]],
-        [
-            ["stacy", "01/04/2016"],
-            [data[2], data[3]],
-        ],
-        [["stacy", "02/04/2016"], [data[4]]],
-    ];
-
-    const result = [...iterateNestedMaps(groups)];
-
-    expect(result).toEqual(expected);
-});

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

@@ -1,30 +0,0 @@
-import { expect, test } from "vitest";
-import kWayMerge from "./kWayMerge.js";
-
-test("k-way merge merges multiple sorted arrays", () => {
-    /** @type {{a: number}[][]} */
-    const arrays = [];
-
-    for (let a = 0; a < 20; a++) {
-        /** @type {{a: number}[]} */
-        const array = [];
-        arrays.push(array);
-
-        let x = 0;
-        for (let i = 0; i < a; i++) {
-            x += Math.floor(Math.random() * 10);
-            array.push({ a: x });
-        }
-    }
-
-    const sorted = arrays.flat().sort((a, b) => a.a - b.a);
-
-    /** @type {function(any):number} */
-    const accessor = (d) => d.a;
-
-    /** @type {{a: number}[]} */
-    const result = [];
-    kWayMerge(arrays, (d) => result.push(d), accessor);
-
-    expect(result).toEqual(sorted);
-});

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

@@ -1,42 +0,0 @@
-import { expect, test } from "vitest";
-import mergeObjects from "./mergeObjects.js";
-
-test("Merges non-conflicting properties", () => {
-    expect(mergeObjects([{ a: 1 }, { b: 2 }], "test")).toEqual({ a: 1, b: 2 });
-
-    expect(mergeObjects([{ a: [0, 1] }, { b: [2, 3] }], "test")).toEqual({
-        a: [0, 1],
-        b: [2, 3],
-    });
-});
-
-test("Skips conflicting properties", () => {
-    expect(
-        mergeObjects(
-            [
-                { a: 1, b: 2, c: 3 },
-                { b: 5, d: 4 },
-            ],
-            "test"
-        )
-    ).toEqual({ a: 1, b: 2, c: 3, d: 4 });
-});
-
-test("Null is handled correctly", () => {
-    expect(mergeObjects([null, null, null], "test")).toBeNull();
-    expect(() => mergeObjects([{ a: 1 }, null, { b: 2 }], "test")).toThrow();
-});
-
-test("Nested objects are merged", () => {
-    expect(
-        mergeObjects([{ nested: { a: 1 } }, { nested: { b: 2 } }], "test")
-    ).toEqual({ nested: { a: 1, b: 2 } });
-
-    expect(
-        mergeObjects([{ nested: { a: 1 } }, { nested: true }], "test")
-    ).toEqual({ nested: { a: 1 } });
-
-    expect(
-        mergeObjects([{ nested: true }, { nested: { a: 1 } }], "test")
-    ).toEqual({ nested: { a: 1 } });
-});

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

@@ -1,6 +0,0 @@
-import { expect, test } from "vitest";
-import numberExtractor from "./numberExtractor.js";
-
-test("NumberExtractor parses delimited integers", () => {
-    expect([...numberExtractor("23,12345,2345")]).toEqual([23, 12345, 2345]);
-});

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

@@ -1,89 +0,0 @@
-import { expect, test } from "vitest";
-import {
-    getCachedOrCall,
-    invalidate,
-    invalidateAll,
-} from "./propertyCacher.js";
-
-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.test.js

@@ -1,25 +0,0 @@
-import { expect, test } from "vitest";
-import coalesceProperties from "./propertyCoalescer.js";
-
-test("CoalesceProperties works as expected", () => {
-    const defaults = { a: 10, b: 11 };
-    const props = { a: 1, c: 2 };
-
-    const coalesced = coalesceProperties(
-        () => props,
-        // @ts-expect-error
-        () => defaults
-    );
-
-    expect(coalesced.a).toEqual(1);
-    // @ts-expect-error
-    expect(coalesced.b).toEqual(11);
-    expect(coalesced.c).toEqual(2);
-    // @ts-expect-error
-    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/radixSort.test.js

@@ -1,51 +0,0 @@
-import { expect, test } from "vitest";
-import radixSort, { radixSortIntoLookupArray } from "./radixSort.js";
-
-/**
- * Checks that numbers in an array are in ascending order.
-
- * @param {number[]} arr An array of unsigned integers
- */
-function isSorted(arr) {
-    for (let i = 1; i < arr.length; i++) {
-        if (arr[i - 1] > arr[i]) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Generates a random array of unsigned integers.
- *
- * @param {number} length
- */
-function generateArray(length) {
-    const arr = new Array(length);
-
-    for (let i = 0; i < length; i++) {
-        arr[i] = Math.floor(Math.random() * 10_000_000_000);
-    }
-
-    return arr;
-}
-
-test("Radix Sort correctly sorts numbers", () => {
-    expect(isSorted(radixSort([1, 2, 3]))).toBeTruthy();
-    expect(isSorted(radixSort([3, 2, 1]))).toBeTruthy();
-    expect(isSorted(radixSort([123, 1234567, 12, 1, 1234]))).toBeTruthy();
-    expect(isSorted(radixSort(generateArray(1_000_000)))).toBeTruthy();
-});
-
-test("Lookup", () => {
-    expect(radixSortIntoLookupArray([1, 2, 3])).toEqual([0, 1, 2]);
-    expect(radixSortIntoLookupArray([3, 2, 1])).toEqual([2, 1, 0]);
-    expect(radixSortIntoLookupArray([10000, 100, 1000, 10, 1])).toEqual([
-        4, 3, 1, 2, 0,
-    ]);
-
-    const arr = generateArray(1_000_000);
-    const lookup = radixSortIntoLookupArray(arr);
-    expect(isSorted(arr.map((_, i) => arr[lookup[i]]))).toBeTruthy();
-});

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

@@ -1,20 +0,0 @@
-import { expect, test } from "vitest";
-import ReservationMap from "./reservationMap.js";
-
-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/ringBuffer.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "vitest";
-import RingBuffer from "./ringBuffer.js";
-
-describe("ringBuffer", () => {
-    test("Empty buffer", () => {
-        const buffer = new RingBuffer(10);
-        expect(buffer.length).toBe(0);
-        expect(buffer.get()).toEqual([]);
-    });
-
-    test("Partially filled buffer", () => {
-        const buffer = new RingBuffer(10);
-        buffer.push(1);
-        buffer.push(2);
-        buffer.push(3);
-        expect(buffer.length).toBe(3);
-        expect(buffer.get()).toEqual([1, 2, 3]);
-    });
-
-    test("Full buffer", () => {
-        const buffer = new RingBuffer(3);
-        buffer.push(1);
-        buffer.push(2);
-        buffer.push(3);
-        expect(buffer.length).toBe(3);
-        expect(buffer.get()).toEqual([1, 2, 3]);
-    });
-
-    test("Overfilled buffer", () => {
-        const buffer = new RingBuffer(3);
-        buffer.push(1);
-        buffer.push(2);
-        buffer.push(3);
-        buffer.push(4);
-        buffer.push(5);
-        expect(buffer.length).toBe(3);
-        expect(buffer.get()).toEqual([3, 4, 5]);
-    });
-});

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

@@ -1,54 +0,0 @@
-import { expect, test } from "vitest";
-import { topK } from "./topK.js";
-
-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 within a start-end range", () => {
-    const arr = [0, 9, 1, 8, 2, 7, 3, 6, 4, 5].map((x) => ({ priority: x }));
-    const priorityAccessor = (/** @type {{priority: number}} */ d) =>
-        d.priority;
-
-    // Range: indices 2 to 8 (1,8,2,7,3,6)
-    expect(topK(arr, 2, priorityAccessor, 2, 8)).toEqual([
-        { priority: 8 },
-        { priority: 7 },
-    ]);
-
-    // Range: indices 4 to 10 (2,7,3,6,4,5)
-    expect(topK(arr, 3, priorityAccessor, 4, 10)).toEqual([
-        { priority: 7 },
-        { priority: 6 },
-        { priority: 5 },
-    ]);
-
-    // Range: indices 0 to 3 (0,9,1)
-    expect(topK(arr, 2, priorityAccessor, 0, 3)).toEqual([
-        { priority: 9 },
-        { priority: 1 },
-    ]);
-});
-
-test("topK returns empty array if start >= end", () => {
-    const arr = [1, 2, 3, 4, 5];
-    expect(topK(arr, 3, (x) => x, 4, 4)).toEqual([]);
-    expect(topK(arr, 3, (x) => x, 5, 5)).toEqual([]);
-    expect(topK(arr, 3, (x) => x, 6, 6)).toEqual([]);
-});
-
-test("topK works with negative and zero priorities in a range", () => {
-    const arr = [-10, 0, 5, -2, 3, 0, -1];
-    expect(topK(arr, 2, (x) => x, 1, 6)).toEqual([5, 3]);
-    expect(topK(arr, 3, (x) => x, 0, 4)).toEqual([5, 0, -2]);
-});