@genome-spy/core 0.65.0 → 0.66.1

package/dist/src/scale/ticks.test.js

@@ -1,46 +0,0 @@
-import { expect, test } from "vitest";
-/*!
- * Adapted from vega-encode:
- * https://github.com/vega/vega/blob/master/packages/vega-encode/test/scale-test.js
- *
- * Copyright (c) 2015-2018, University of Washington Interactive Data Lab
- * All rights reserved.
- *
- * BSD-3-Clause License: https://github.com/vega/vega-lite/blob/master/LICENSE
- */
-
-/* eslint-disable */
-
-import { validTicks } from "./ticks.js";
-
-test("validTicks uses count correctly", function () {
-    var data = [0, 1, 2, 3, 4, 5, 6, 7];
-
-    /**
-     *
-     * @param {T} x
-     * @returns {T}
-     * @template T
-     */
-    var identity = function (x) {
-        return x;
-    };
-    identity.range = function () {
-        return [0, 10];
-    };
-
-    var t1 = validTicks(identity, data, 5);
-    expect(t1).toEqual([0, 2, 4, 6]);
-
-    // don't change ticks if count is large
-    var t2 = validTicks(identity, data, 100);
-    expect(t2).toEqual(data);
-
-    // special case for low number of ticks
-    var t3 = validTicks(identity, data, 3);
-    expect(t3).toEqual([0, 7]);
-
-    // single tick should pass through
-    var t5 = validTicks(identity, [1], 5);
-    expect(t5).toEqual([1]);
-});

package/dist/src/selection/selection.test.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { asEventConfig } from "./selection.js";
-
-describe("asEventSpec", () => {
-    it("parses a simple string event type", () => {
-        const res = asEventConfig("click");
-        expect(res).toEqual({ type: "click" });
-    });
-
-    it("parses a string event type with bracket filter", () => {
-        const res = asEventConfig("click[event.shiftKey]");
-        expect(res).toEqual({ type: "click", filter: "event.shiftKey" });
-    });
-});

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

@@ -1,30 +0,0 @@
-import { expect, test } from "vitest";
-import addBaseUrl, { endWithSlash } from "./addBaseUrl.js";
-
-test("addBaseUrl adds baseUrl when needed", () => {
-    expect(addBaseUrl("foo.html", "https://site.com/")).toEqual(
-        "https://site.com/foo.html"
-    );
-    expect(addBaseUrl("foo.html", "https://site.com")).toEqual(
-        "https://site.com/foo.html"
-    );
-    expect(addBaseUrl("bar/foo.html", "https://site.com/")).toEqual(
-        "https://site.com/bar/foo.html"
-    );
-    expect(addBaseUrl("../foo.html", "https://site.com/bar/")).toEqual(
-        "https://site.com/bar/../foo.html"
-    );
-});
-
-test("addBaseUrl doesn't add baseUrl when not needed", () => {
-    expect(addBaseUrl("/foo.html", "https://site.com/")).toEqual("/foo.html");
-    expect(addBaseUrl("foo.html", undefined)).toEqual("foo.html");
-});
-
-test("endWithSlash adds slash when needed", () => {
-    expect(endWithSlash(null)).toBeNull();
-    expect(endWithSlash("https://site.com")).toEqual("https://site.com/");
-    expect(endWithSlash("https://site.com/")).toEqual("https://site.com/");
-    expect(() => endWithSlash("https://site.com/foo?bar")).toThrow();
-    expect(() => endWithSlash("https://site.com/foo#bar")).toThrow();
-});

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

@@ -1,201 +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]);
-    });
-
-    test("Unordered ranges disable the index", () => {
-        const items = [
-            [10, 30],
-            [25, 50],
-
-            [112, 139],
-            [102, 129], // <- Unordered!
-            [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();
-
-        expect(index).toBeUndefined();
-    });
-
-    test("Inverted ranges disable the index", () => {
-        const items = [
-            [10, 30],
-            [25, 50],
-
-            [102, 129],
-            [139, 112], // <- Inverted!
-            [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();
-
-        expect(index).toBeUndefined();
-    });
-});

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

@@ -1,35 +0,0 @@
-import { expect, test } from "vitest";
-import createCloner, { getAllProperties } from "./cloner.js";
-
-const template = {
-    1: "iddqd",
-    a: 1,
-    c: "xyzzy",
-    b: "idclip",
-};
-
-test("Cloner clones object properly", () => {
-    const makeClone = createCloner(template);
-
-    expect(makeClone(template)).toEqual(template);
-    expect(makeClone(template)).not.toBe(template);
-
-    const another = {
-        1: "hello",
-        a: 2,
-        c: "idkfa",
-        b: "idclip",
-    };
-
-    expect(makeClone(another)).toEqual(another);
-    expect(makeClone(another)).not.toBe(another);
-});
-
-test("getAllProperties", () => {
-    expect(getAllProperties(template)).toEqual(["1", "a", "c", "b"]);
-
-    const obj = Object.create(template);
-    obj.d = 42;
-
-    expect(getAllProperties(obj)).toEqual(["d", "1", "a", "c", "b"]);
-});

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

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

@@ -1,8 +0,0 @@
-import { expect, test } from "vitest";
-import concatIterables from "./concatIterables.js";
-
-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/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]);
-});