@genome-spy/core 0.64.0 → 0.66.1

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

@@ -1,326 +0,0 @@
-// @ts-nocheck
-
-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 * as util from "vega-util";
-import * as vs from "vega-scale";
-import createScale from "./scale.js";
-
-// Suppress warnings by default
-const scale = (params, logger) =>
-    createScale(params, logger || { warn: () => {} });
-
-test("Scale respects domain configuration", function () {
-    var s,
-        params = {
-            type: "linear",
-            domain: [1, 9.5],
-        };
-
-    // test zero inclusion
-    s = scale(params);
-    expect(s.domain()).toEqual([0, 9.5]);
-    s = scale(util.extend({ zero: true }, params));
-    expect(s.domain()).toEqual([0, 9.5]);
-    s = scale(util.extend({ zero: false }, params));
-    expect(s.domain()).toEqual([1, 9.5]);
-
-    // test nice domain
-    s = scale(util.extend({ nice: true }, params));
-    expect(s.domain()).toEqual([0, 10]);
-
-    // test domain min/max
-    s = scale(util.extend({ domainMin: -1, domainMax: 10 }, params));
-    expect(s.domain()).toEqual([-1, 10]);
-
-    // domain min overrides zero
-    s = scale(
-        util.extend({ zero: true, domainMin: 0.5, domainMax: 10 }, params)
-    );
-    expect(s.domain()).toEqual([0.5, 10]);
-
-    // test domain mid
-    s = scale(util.extend({ domainMid: 5 }, params));
-    expect(s.domain()).toEqual([0, 5, 9.5]);
-
-    // test domain raw
-    s = scale(util.extend({ domainRaw: [2, 11] }, params));
-    expect(s.domain()).toEqual([2, 11]);
-});
-
-test("Scale respects domain padding", function () {
-    var d;
-
-    // test linear scale padding
-    d = scale({
-        type: "linear",
-        domain: [5, 95],
-        range: [0, 100],
-        padding: 5,
-        zero: false,
-    }).domain();
-    expect(d).toEqual([0, 100]);
-
-    // test log scale padding
-    d = scale({
-        type: "log",
-        domain: [1, 10],
-        range: [0, 60],
-        padding: 20,
-        zero: false,
-    }).domain();
-    expect(Math.abs(d[0] - 0.1) < 1e-8).toBeTruthy();
-    expect(Math.abs(d[1] - 100) < 1e-8).toBeTruthy();
-
-    // test sqrt scale padding
-    d = scale({
-        type: "sqrt",
-        domain: [2 * 2, 3 * 3],
-        range: [0, 60],
-        padding: 20,
-        zero: false,
-    }).domain();
-    expect(Math.abs(d[0] - 1 * 1) < 1e-8).toBeTruthy();
-    expect(Math.abs(d[1] - 4 * 4) < 1e-8).toBeTruthy();
-
-    // test power scale padding
-    d = scale({
-        type: "pow",
-        exponent: 1 / 3,
-        domain: [2 * 2 * 2, 3 * 3 * 3],
-        range: [0, 60],
-        padding: 20,
-        zero: false,
-    }).domain();
-    expect(Math.abs(d[0] - 1 * 1 * 1) < 1e-8).toBeTruthy();
-    expect(Math.abs(d[1] - 4 * 4 * 4) < 1e-8).toBeTruthy();
-});
-
-test("Ordinal scale respects domainImplicit", function () {
-    var s,
-        params = {
-            type: "ordinal",
-            domain: [],
-            range: ["a", "b", "c"],
-        };
-
-    s = scale(params);
-    expect(s("foo")).toBe(undefined);
-    expect(s("bar")).toBe(undefined);
-    expect(s("foo")).toBe(undefined);
-
-    s = scale(util.extend({ domainImplicit: false }, params));
-    expect(s("foo")).toBe(undefined);
-    expect(s("bar")).toBe(undefined);
-    expect(s("foo")).toBe(undefined);
-
-    s = scale(util.extend({ domainImplicit: true }, params));
-    expect(s("foo")).toBe("a");
-    expect(s("bar")).toBe("b");
-    expect(s("foo")).toBe("a");
-});
-
-test("Scale respects range configuration", function () {
-    var s,
-        params = {
-            type: "linear",
-            domain: [0, 10],
-            range: [0, 10],
-        };
-
-    // round
-    s = scale(params);
-    expect(s(0.5)).toBe(0.5);
-    s = scale(util.extend({ round: true }, params));
-    expect(s(0.5)).toBe(1);
-
-    // reverse
-    s = scale(util.extend({ reverse: true }, params));
-    expect(s.range()).toEqual([10, 0]);
-
-    // rangeStep
-    params = {
-        type: "band",
-        domain: ["a", "b", "c"],
-        rangeStep: 20,
-        padding: 0,
-    };
-    s = scale(params);
-    expect(s.range()).toEqual([0, 60]);
-    expect(s.bandwidth()).toBe(20);
-
-    s = expect(function () {
-        scale(util.extend({}, params, { type: "linear" }));
-    }).toThrow();
-});
-
-test("Scale respects range color schemes", function () {
-    var s, u, v;
-
-    // performs scheme lookup
-    s = scale({ type: "ordinal", scheme: "category10" });
-    expect(s.range().length).toBe(10);
-
-    // throws on invalid scheme
-    expect(function () {
-        scale({ type: "ordinal", scheme: "foobarbaz" });
-    }).toThrow();
-    expect(function () {
-        scale({ type: "sequential", scheme: "foobarbaz" });
-    }).toThrow();
-
-    // handles interpolating schemes and extents
-    s = scale({ type: "sequential", scheme: "viridis" });
-    u = s.interpolator();
-    expect(typeof u).toBe("function");
-
-    s = scale({
-        type: "sequential",
-        scheme: "viridis",
-        schemeExtent: [0.2, 0.9],
-    });
-    v = s.interpolator();
-    expect(typeof v).toBe("function");
-    expect(v(0)).toBe(u(0.2));
-    expect(v(1)).toBe(u(0.9));
-
-    s = scale({
-        type: "sequential",
-        scheme: "viridis",
-        schemeExtent: [0.2, 0.9],
-        reverse: true,
-    });
-    v = s.interpolator();
-    expect(typeof v).toBe("function");
-    expect(v(0)).toBe(u(0.9));
-    expect(v(1)).toBe(u(0.2));
-
-    // generate interpolator as needed
-    s = scale({ type: "sequential", range: ["#000", "#f00"] });
-    v = s.interpolator();
-    expect(typeof v).toBe("function");
-    expect(v(0)).toBe("rgb(0, 0, 0)");
-    expect(v(1)).toBe("rgb(255, 0, 0)");
-
-    // quantize to provided scheme count
-    s = scale({ type: "quantize", scheme: "viridis", schemeCount: 3 });
-    v = s.range();
-    expect(v.length).toBe(3);
-    expect(v[0]).toBe(u(1 / 4));
-    expect(v[1]).toBe(u(2 / 4));
-    expect(v[2]).toBe(u(3 / 4));
-});
-
-test("Scale warns for zero in log domain", function () {
-    function logScale(domain) {
-        const logger = {
-            count: 0,
-            warn: function (msg) {
-                this.count++;
-            },
-        };
-
-        return function () {
-            scale({ type: "log", domain: domain }, logger);
-            if (logger.count) {
-                throw new Error();
-            }
-        };
-    }
-
-    expect(logScale([0, 1])).toThrow();
-    expect(logScale([-1, 0])).toThrow();
-    expect(logScale([-1, 1])).toThrow();
-    expect(logScale([1, 0, 2])).toThrow();
-    expect(logScale([1, 2])).not.toThrow();
-    expect(logScale([-2, -1])).not.toThrow();
-});
-
-test("Scale infers scale key from type, domain, and range", function () {
-    function key(params) {
-        return scale(params).type;
-    }
-
-    // numeric domain scales should adapt
-    [vs.Linear, vs.Log, vs.Pow, vs.Sqrt, vs.Symlog].forEach(function (st) {
-        expect(key({ type: st, domain: [0, 1], range: [0, 1] })).toBe(st);
-        expect(key({ type: st, domain: [0, 1], range: [true, false] })).toBe(
-            st
-        );
-
-        // direct color range specification
-        expect(key({ type: st, domain: [0, 1], range: ["blue", "red"] })).toBe(
-            `${vs.Sequential}-${st}`
-        );
-        expect(
-            key({ type: st, domain: [0, 1, 2], range: ["blue", "red"] })
-        ).toBe(`${vs.Diverging}-${st}`);
-        expect(
-            key({ type: st, domain: [0, 1, 2, 3], range: ["blue", "red"] })
-        ).toBe(st);
-
-        // color scheme range specification
-        expect(key({ type: st, domain: [0, 1], scheme: "blues" })).toBe(
-            `${vs.Sequential}-${st}`
-        );
-        expect(key({ type: st, domain: [0, 1, 2], scheme: "blues" })).toBe(
-            `${vs.Diverging}-${st}`
-        );
-        expect(key({ type: st, domain: [0, 1, 2, 3], scheme: "blues" })).toBe(
-            st
-        );
-    });
-
-    // temporal domain scales should not adapt
-    [vs.Time, vs.UTC].forEach(function (st) {
-        const t0 = new Date(2010, 0, 1),
-            t1 = new Date(2011, 0, 1),
-            t2 = new Date(2012, 0, 1),
-            t3 = new Date(2013, 0, 1);
-
-        expect(key({ type: st, domain: [t0, t1], range: [0, 1] })).toBe(st);
-        expect(key({ type: st, domain: [t0, t1], range: [true, false] })).toBe(
-            st
-        );
-
-        // direct color range specification
-        expect(
-            key({ type: st, domain: [t0, t1], range: ["blue", "red"] })
-        ).toBe(st);
-        expect(
-            key({ type: st, domain: [t0, t1, t2], range: ["blue", "red"] })
-        ).toBe(st);
-        expect(
-            key({ type: st, domain: [t0, t1, t2, t3], range: ["blue", "red"] })
-        ).toBe(st);
-
-        // color scheme range specification
-        expect(key({ type: st, domain: [t0, t1], scheme: "blues" })).toBe(st);
-        expect(key({ type: st, domain: [t0, t1, t2], scheme: "blues" })).toBe(
-            st
-        );
-        expect(
-            key({ type: st, domain: [t0, t1, t2, t3], scheme: "blues" })
-        ).toBe(st);
-    });
-
-    // sequential should work for backwards compatibility
-    const st = vs.Sequential;
-    expect(key({ type: st, domain: [0, 1], range: ["blue", "red"] })).toBe(
-        `${st}-${vs.Linear}`
-    );
-    expect(key({ type: st, domain: [0, 1], scheme: "blues" })).toBe(
-        `${st}-${vs.Linear}`
-    );
-});

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,
-    ]);
-});