@genome-spy/core 0.64.0 → 0.66.1

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,QAwB9B;IAED,qDAuBC;IAED,mBAyDC;CACJ;iCA3I6D,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();
-    });
-});

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

@@ -1,125 +0,0 @@
-import { expect, test } from "vitest";
-import Collector from "../data/collector.js";
-import FlowNode from "../data/flowNode.js";
-import FilterTransform from "../data/transforms/filter.js";
-import FormulaTransform from "../data/transforms/formula.js";
-import InlineSource from "../data/sources/inlineSource.js";
-import SequenceSource from "../data/sources/sequenceSource.js";
-import { buildDataFlow } from "./flowBuilder.js";
-import { create } from "./testUtils.js";
-import CloneTransform from "../data/transforms/clone.js";
-import LayerView from "./layerView.js";
-import UnitView from "./unitView.js";
-
-/**
- *
- * @param {FlowNode} root
- * @param {number[]} path
- */
-function byPath(root, path) {
-    for (const elem of path) {
-        root = root.children[elem];
-    }
-    return root;
-}
-
-/** @type {import("../spec/mark.js").MarkProps} */
-const mark = {
-    type: "rect",
-    tooltip: null,
-};
-
-test("Trivial flow", async () => {
-    const root = await create(
-        {
-            data: { values: [3.141] },
-            transform: [
-                {
-                    type: "formula",
-                    expr: "datum.data * 2",
-                    as: "x",
-                },
-            ],
-            mark,
-        },
-        UnitView
-    );
-
-    const flow = buildDataFlow(root);
-    const dataSource = flow.dataSources[0];
-
-    expect(dataSource).toBeInstanceOf(InlineSource);
-    expect(byPath(dataSource, [0])).toBeInstanceOf(CloneTransform);
-    expect(byPath(dataSource, [0, 0])).toBeInstanceOf(FormulaTransform);
-    expect(byPath(dataSource, [0, 0, 0])).toBeInstanceOf(Collector);
-
-    expect(flow.collectors[0]).toBe(byPath(dataSource, [0, 0, 0]));
-});
-
-test("Branching flow", async () => {
-    const root = await create(
-        {
-            data: { values: [3.141] },
-            layer: [
-                {
-                    transform: [
-                        {
-                            type: "formula",
-                            expr: "datum.data * 2",
-                            as: "x",
-                        },
-                    ],
-                    mark,
-                },
-                {
-                    transform: [
-                        {
-                            type: "filter",
-                            expr: "datum.data > 4",
-                        },
-                    ],
-                    mark,
-                },
-            ],
-        },
-        LayerView
-    );
-
-    const dataSource = buildDataFlow(root).dataSources[0];
-
-    expect(dataSource).toBeInstanceOf(InlineSource);
-    // Formula transform modifies data and it should be implicitly preceded by CloneTransform
-    expect(byPath(dataSource, [0])).toBeInstanceOf(CloneTransform);
-    expect(byPath(dataSource, [0, 0])).toBeInstanceOf(FormulaTransform);
-    expect(byPath(dataSource, [0, 0, 0])).toBeInstanceOf(Collector);
-    expect(byPath(dataSource, [1])).toBeInstanceOf(FilterTransform);
-    expect(byPath(dataSource, [1, 0])).toBeInstanceOf(Collector);
-});
-
-test("Nested data sources", async () => {
-    const root = await create(
-        {
-            data: { values: [1] },
-            transform: [{ type: "filter", expr: "datum.data > 0" }],
-            layer: [
-                {
-                    data: { sequence: { start: 0, stop: 5 } },
-                    transform: [{ type: "formula", expr: "3", as: "foo" }],
-                    mark,
-                },
-            ],
-        },
-        LayerView
-    );
-
-    const dataSources = buildDataFlow(root).dataSources;
-
-    expect(dataSources[0]).toBeInstanceOf(InlineSource);
-    expect(dataSources[0].children[0]).toBeInstanceOf(FilterTransform);
-    expect(dataSources[0].children[0].children.length).toEqual(0);
-
-    expect(byPath(dataSources[1], [])).toBeInstanceOf(SequenceSource);
-    expect(byPath(dataSources[1], [0])).toBeInstanceOf(CloneTransform);
-    expect(byPath(dataSources[1], [0, 0])).toBeInstanceOf(FormulaTransform);
-    expect(byPath(dataSources[1], [0, 0, 0])).toBeInstanceOf(Collector);
-});