@genome-spy/core 0.65.0 → 0.67.0

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

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

@@ -1,135 +0,0 @@
-import { expect, test } from "vitest";
-import { nodesToTrees, visitTree } from "./trees.js";
-import { describe } from "vitest";
-
-describe("NodesToTrees", () => {
-    const NULL = /** @type {any} */ (null);
-
-    test("NodesToTrees converts an array of nodes to a tree", () => {
-        const a = { parent: NULL };
-        const b = { parent: a };
-        const c = { parent: a };
-        const d = { parent: b };
-        const e = { parent: b };
-
-        const nodes = [a, b, c, d, e];
-
-        const trees = nodesToTrees(nodes);
-
-        expect(trees).toEqual([
-            {
-                ref: a,
-                children: [
-                    {
-                        ref: b,
-                        children: [
-                            {
-                                ref: d,
-                                children: [],
-                            },
-                            {
-                                ref: e,
-                                children: [],
-                            },
-                        ],
-                    },
-                    {
-                        ref: c,
-                        children: [],
-                    },
-                ],
-            },
-        ]);
-    });
-
-    test("NodesToTrees converts two disjoint node arrays to two trees", () => {
-        const a = { parent: NULL };
-        const b = { parent: a };
-
-        const c = { parent: NULL };
-        const d = { parent: c };
-
-        const nodes = [a, b, c, d];
-
-        const trees = nodesToTrees(nodes);
-
-        expect(trees).toEqual([
-            {
-                ref: a,
-                children: [
-                    {
-                        ref: b,
-                        children: [],
-                    },
-                ],
-            },
-            {
-                ref: c,
-                children: [
-                    {
-                        ref: d,
-                        children: [],
-                    },
-                ],
-            },
-        ]);
-    });
-});
-
-describe("VisitTree", () => {
-    test("VisitTree visits all nodes in a tree in correct order", () => {
-        const tree = {
-            id: "a",
-            children: [
-                {
-                    id: "b",
-                    children: [
-                        {
-                            id: "d",
-                            /** @type {any[]} */
-                            children: [],
-                        },
-                        {
-                            id: "e",
-                            children: [],
-                        },
-                    ],
-                },
-                {
-                    id: "c",
-                    children: [],
-                },
-            ],
-        };
-
-        /** @type {any[]} */
-        const visitedPre = [];
-        /** @type {any[]} */
-        const visitedPost = [];
-
-        visitTree(tree, {
-            preOrder: (node) => {
-                visitedPre.push(node);
-            },
-            postOrder: (node) => {
-                visitedPost.push(node);
-            },
-        });
-
-        expect(visitedPre.map((node) => node.id)).toEqual([
-            "a",
-            "b",
-            "d",
-            "e",
-            "c",
-        ]);
-
-        expect(visitedPost.map((node) => node.id)).toEqual([
-            "d",
-            "e",
-            "b",
-            "c",
-            "a",
-        ]);
-    });
-});

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

@@ -1,28 +0,0 @@
-import { expect, test } from "vitest";
-import { concatUrl, getDirectory } from "./url.js";
-
-test("getDirectory", () => {
-    expect(getDirectory("foo")).toBeUndefined();
-    expect(getDirectory("foo/")).toBe("foo/");
-    expect(getDirectory("foo/index")).toBe("foo/");
-    expect(getDirectory("http://example.com")).toBe("http://example.com/");
-    expect(getDirectory("http://example.com/")).toBe("http://example.com/");
-    expect(getDirectory("http://example.com/a")).toBe("http://example.com/");
-    expect(getDirectory("http://example.com/a/")).toBe("http://example.com/a/");
-});
-
-test("concatUrl", () => {
-    expect(concatUrl("http://example.com", "foo")).toEqual(
-        "http://example.com/foo"
-    );
-    expect(concatUrl(() => "http://example.com", "foo")).toEqual(
-        "http://example.com/foo"
-    );
-    expect(concatUrl("http://example.com/", "http://genomespy.app/")).toEqual(
-        "http://genomespy.app/"
-    );
-    expect(concatUrl("foo/", "bar")).toEqual("foo/bar");
-    expect(concatUrl("foo/baz", "bar")).toEqual("foo/bar");
-    expect(concatUrl(undefined, "bar")).toEqual("bar");
-    expect(concatUrl("bar", undefined)).toEqual("bar");
-});

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

@@ -1,13 +0,0 @@
-import { expect, test } from "vitest";
-import * as vt from "./variableTools.js";
-
-test("InferNumerality", () => {
-    expect(vt.inferNumeric(["0", "1", "2.2", "-4"])).toBeTruthy();
-    expect(vt.inferNumeric(["0", ...vt.NAs.values()])).toBeTruthy();
-    expect(vt.inferNumeric([])).toBeTruthy();
-
-    expect(vt.inferNumeric(["0", "x"])).toBeFalsy();
-    expect(vt.inferNumeric(["0", " "])).toBeFalsy();
-    expect(vt.inferNumeric(["0", "1,2"])).toBeFalsy();
-    expect(vt.inferNumeric(["0", "20x"])).toBeFalsy();
-});

package/dist/src/view/axisResolution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"axisResolution.d.ts","sourceRoot":"","sources":["../../../src/view/axisResolution.js"],"names":[],"mappings":"AAeA;;;;;;;GAOG;AACH;IACI;;;OAGG;IAEH;;OAEG;IACH,qBAFW,OAAO,oBAAoB,EAAE,wBAAwB,EAM/D;IAHG,+DAAsB;IACtB,wDAAwD;IACxD,SADW,oBAAoB,EAAE,CAChB;IAGrB,8DAEC;IAED;;;;;OAKG;IACH,qBAFW,oBAAoB,QAyB9B;IAED;;;OAGG;IACH,4DAFa,OAAO,CAUnB;IAED,qDAuBC;IAED,mBAyDC;CACJ;iCA1J6D,CAAC,SAAlD,OAAQ,oBAAoB,EAAE,iBAAkB;UAGnD,OAAO,eAAe,EAAE,OAAO;aAC/B,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB"}

package/dist/src/view/axisResolution.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"axisResolution.test.d.ts","sourceRoot":"","sources":["../../../src/view/axisResolution.test.js"],"names":[],"mappings":""}

package/dist/src/view/axisResolution.test.js

@@ -1,206 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { createAndInitialize } from "./testUtils.js";
-import UnitView from "./unitView.js";
-import View from "./view.js";
-
-/** @type {import("../spec/view.js").LayerSpec} */
-const spec = {
-    data: { values: [] },
-    layer: [
-        {
-            mark: "point",
-            encoding: {
-                x: { field: "a", type: "quantitative" },
-                y: {
-                    field: "a",
-                    type: "quantitative",
-                    scale: { domain: [1, 2] },
-                },
-                color: { value: "red" },
-            },
-        },
-        {
-            mark: "point",
-            encoding: {
-                x: { field: "a", type: "quantitative" },
-                y: {
-                    field: "b",
-                    type: "quantitative",
-                    scale: { domain: [4, 5] },
-                },
-                color: { value: "green" },
-            },
-        },
-    ],
-};
-
-describe("Axes resolve properly", () => {
-    test("Independent axes are independent", async () => {
-        const view = await createAndInitialize(
-            {
-                ...spec,
-                resolve: { scale: { y: "shared" }, axis: { y: "independent" } },
-            },
-            View
-        );
-
-        const [r0, r1] = [0, 1].map((i) =>
-            // @ts-ignore
-            view.children[i].getAxisResolution("y")
-        );
-
-        expect(r0).toBeDefined();
-        expect(r1).toBeDefined();
-        expect(r0).not.toBe(r1);
-    });
-
-    test("Shared axes have joined titles", async () => {
-        const view = await createAndInitialize(
-            {
-                ...spec,
-                resolve: { scale: { y: "shared" }, axis: { y: "shared" } },
-            },
-            View
-        );
-        // @ts-ignore
-        expect(view.children[0].getAxisResolution("y").getTitle()).toEqual(
-            "a, b"
-        );
-    });
-
-    test("Title is taken from axis title, encoding title, and field name, in that order.", async () => {
-        let view = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "point",
-                encoding: {
-                    x: { field: "a", type: "quantitative" },
-                    y: {
-                        field: "a",
-                        type: "quantitative",
-                    },
-                },
-            },
-            UnitView
-        );
-        expect(view.getAxisResolution("y").getTitle()).toEqual("a");
-
-        view = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "point",
-                encoding: {
-                    x: { field: "a", type: "quantitative" },
-                    y: {
-                        field: "a",
-                        title: "x",
-                        type: "quantitative",
-                    },
-                },
-            },
-            UnitView
-        );
-        expect(view.getAxisResolution("y").getTitle()).toEqual("x");
-
-        view = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "point",
-                encoding: {
-                    x: { field: "a", type: "quantitative" },
-                    y: {
-                        field: "a",
-                        title: "x",
-                        type: "quantitative",
-                        axis: {
-                            title: "z",
-                        },
-                    },
-                },
-            },
-            UnitView
-        );
-        expect(view.getAxisResolution("y").getTitle()).toEqual("z");
-    });
-
-    test("Primary and secondary channels are included in the title", async () => {
-        let view = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "rule",
-                encoding: {
-                    x: { field: "a", type: "quantitative" },
-                    x2: { field: "b" },
-                },
-            },
-            UnitView
-        );
-        expect(view.getAxisResolution("x").getTitle()).toEqual("a, b");
-    });
-
-    test("Secondary channel's field name is hidden if primary channel has an explicit title", async () => {
-        let view = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "rule",
-                encoding: {
-                    x: { field: "a", type: "quantitative", title: "foo" },
-                    x2: { field: "b" },
-                },
-            },
-            UnitView
-        );
-        expect(view.getAxisResolution("x").getTitle()).toEqual("foo");
-
-        let view2 = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "rule",
-                encoding: {
-                    x: {
-                        field: "a",
-                        type: "quantitative",
-                        axis: { title: "foo" },
-                    },
-                    x2: { field: "b" },
-                },
-            },
-            UnitView
-        );
-        expect(view2.getAxisResolution("x").getTitle()).toEqual("foo");
-
-        let view3 = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "rule",
-                encoding: {
-                    x: {
-                        field: "a",
-                        type: "quantitative",
-                        axis: { title: "foo" },
-                    },
-                    x2: { field: "b", title: "bar" },
-                },
-            },
-            UnitView
-        );
-        expect(view3.getAxisResolution("x").getTitle()).toEqual("foo, bar");
-
-        let view4 = await createAndInitialize(
-            {
-                data: { values: [] },
-                mark: "rule",
-                encoding: {
-                    x: {
-                        field: "a",
-                        type: "quantitative",
-                        title: null,
-                    },
-                    x2: { field: "b" },
-                },
-            },
-            UnitView
-        );
-        expect(view4.getAxisResolution("x").getTitle()).toBeNull();
-    });
-});