@genome-spy/core 0.65.0 → 0.66.1

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

package/dist/src/view/gridView/selectionRect.test.js

@@ -1,87 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import ConcatView from "../concatView.js";
-import UnitView from "../unitView.js";
-import SelectionRect from "./selectionRect.js";
-import { createTestViewContext } from "../testUtils.js";
-import { buildDataFlow } from "../flowBuilder.js";
-import { optimizeDataFlow } from "../../data/flowOptimizer.js";
-import { syncFlowHandles } from "../../data/flowInit.js";
-
-describe("SelectionRect", () => {
-    it("uses flow handles for dynamic data updates", () => {
-        const context = createTestViewContext();
-        const parent = new ConcatView(
-            { hconcat: [] },
-            context,
-            null,
-            null,
-            "p"
-        );
-
-        /** @type {import("../../spec/view.js").UnitSpec} */
-        const unitSpec = {
-            data: { values: [{ x: 0, y: 0 }] },
-            mark: "point",
-            encoding: {
-                x: { field: "x", type: "quantitative" },
-                y: { field: "y", type: "quantitative" },
-            },
-        };
-
-        const unitView = new UnitView(unitSpec, context, parent, parent, "u");
-
-        let selection = {
-            intervals: { x: [0, 1], y: [2, 3] },
-        };
-
-        /** @type {(listener: () => void) => void} */
-        const addListener = () => undefined;
-        /** @type {(listener: () => void) => void} */
-        const removeListener = () => undefined;
-        /** @type {() => void} */
-        const invalidate = () => undefined;
-
-        /** @type {import("../paramMediator.js").ExprRefFunction} */
-        const selectionExpr = Object.assign(() => selection, {
-            addListener,
-            removeListener,
-            invalidate,
-            identifier: () => "selection",
-            fields: [],
-            globals: [],
-            code: "selection",
-        });
-
-        const gridChild = /** @type {import("./gridChild.js").default} */ (
-            /** @type {unknown} */ ({
-                layoutParent: parent,
-                view: unitView,
-            })
-        );
-
-        const selectionRect = new SelectionRect(gridChild, selectionExpr);
-
-        const flow = buildDataFlow(selectionRect, context.dataFlow);
-        syncFlowHandles(selectionRect, optimizeDataFlow(flow));
-
-        const dataSource =
-            /** @type {import("../../data/sources/inlineSource.js").default} */ (
-                selectionRect.flowHandle?.dataSource
-            );
-        expect(dataSource).toBeDefined();
-
-        // Selection updates should push new interval data to the inline source.
-        const updateSpy = vi.spyOn(dataSource, "updateDynamicData");
-        selection = {
-            intervals: { x: [5, 6], y: [7, 8] },
-        };
-
-        selectionRect._selectionListener();
-
-        expect(updateSpy).toHaveBeenCalledTimes(1);
-        expect(updateSpy).toHaveBeenCalledWith([
-            { _x: 5, _x2: 6, _y: 7, _y2: 8 },
-        ]);
-    });
-});

package/dist/src/view/layout/flexLayout.test.js

@@ -1,323 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-    mapToPixelCoords,
-    getMinimumSize,
-    getLargestSize,
-    isStretching,
-    parseSizeDef,
-    sumSizeDefs,
-} from "./flexLayout.js";
-
-test("parseSize", () => {
-    expect(parseSizeDef(10)).toEqual({ px: 10, grow: 0 });
-    expect(parseSizeDef({ px: 20, grow: 2 })).toEqual({ px: 20, grow: 2 });
-    expect(parseSizeDef(undefined)).toEqual({ px: 0, grow: 1 });
-    expect(parseSizeDef(null)).toEqual({ px: 0, grow: 1 });
-    expect(parseSizeDef("container")).toEqual({ px: 0, grow: 1 });
-    expect(() => parseSizeDef({})).toThrow();
-});
-
-describe("Basic flex functionality", () => {
-    test("Absolute sizes", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 10, size: 30 });
-        expect(mapped[2]).toEqual({ location: 40, size: 20 });
-    });
-
-    test("Absolute sizes with spacing", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 20, size: 30 });
-        expect(mapped[2]).toEqual({ location: 60, size: 20 });
-    });
-
-    test("Absolute sizes with spacing, reversed", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 50, size: 30 });
-        expect(mapped[2]).toEqual({ location: 20, size: 20 });
-    });
-
-    test("Absolute sizes with spacing, reversed and insufficient containerSize", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 0;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 70, size: 10 });
-        expect(mapped[1]).toEqual({ location: 30, size: 30 });
-        expect(mapped[2]).toEqual({ location: 0, size: 20 });
-    });
-
-    test("Growing sizes", () => {
-        const items = [10, 20, 70].map((x) => ({ grow: x }));
-        const containerSize = 200;
-
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 20 });
-        expect(mapped[1]).toEqual({ location: 20, size: 40 });
-        expect(mapped[2]).toEqual({ location: 60, size: 140 });
-    });
-
-    test("Growing sizes with spacing", () => {
-        const items = [10, 20, 70].map((x) => ({ grow: x }));
-        const containerSize = 220;
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 20 });
-        expect(mapped[1]).toEqual({ location: 30, size: 40 });
-        expect(mapped[2]).toEqual({ location: 80, size: 140 });
-    });
-
-    test("Mixed absolute and relative sizes", () => {
-        const items = [{ px: 100 }, { grow: 1 }, { grow: 9 }, { px: 200 }];
-        const containerSize = 1100;
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 100 });
-        expect(mapped[1]).toEqual({ location: 100, size: 80 });
-        expect(mapped[2]).toEqual({ location: 180, size: 720 });
-        expect(mapped[3]).toEqual({ location: 900, size: 200 });
-    });
-
-    test("Sizes having both absolute and growing components", () => {
-        const items = [
-            { px: 1 },
-            { px: 2 },
-            { px: 3, grow: 2 },
-            { px: 4, grow: 1 },
-        ];
-        const containerSize = 16;
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 1 });
-        expect(mapped[1]).toEqual({ location: 1, size: 2 });
-        expect(mapped[2]).toEqual({ location: 3, size: 7 });
-        expect(mapped[3]).toEqual({ location: 10, size: 6 });
-    });
-
-    test("Zero sizes return zero coords", () => {
-        const items = [{ grow: 0 }, { grow: 0 }];
-
-        const mapped = mapToPixelCoords(items, 0);
-        expect(mapped[0]).toEqual({ location: 0, size: 0 });
-        expect(mapped[1]).toEqual({ location: 0, size: 0 });
-
-        const mapped2 = mapToPixelCoords(items, 1);
-        expect(mapped2[0]).toEqual({ location: 0, size: 0 });
-        expect(mapped2[1]).toEqual({ location: 0, size: 0 });
-    });
-
-    test("Offset is added", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { offset: 5 });
-
-        expect(mapped[0]).toEqual({ location: 5, size: 10 });
-        expect(mapped[1]).toEqual({ location: 15, size: 30 });
-        expect(mapped[2]).toEqual({ location: 45, size: 20 });
-    });
-});
-
-describe("Collapse gaps when items have zero px and grow", () => {
-    test("Zero as first", () => {
-        const items = [0, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 0 });
-        expect(mapped[1]).toEqual({ location: 0, size: 30 });
-        expect(mapped[2]).toEqual({ location: 40, size: 20 });
-    });
-
-    test("Zero in the middle", () => {
-        const items = [10, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 15, size: 0 });
-        expect(mapped[2]).toEqual({ location: 20, size: 20 });
-    });
-
-    test("Multiple zeroes in the middle", () => {
-        const items = [10, 0, 0, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 12.5, size: 0 });
-        expect(mapped[2]).toEqual({ location: 15, size: 0 });
-        expect(mapped[3]).toEqual({ location: 17.5, size: 0 });
-        expect(mapped[4]).toEqual({ location: 20, size: 20 });
-    });
-
-    test("Zero as last", () => {
-        const items = [10, 30, 0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 20, size: 30 });
-        expect(mapped[2]).toEqual({ location: 50, size: 0 });
-    });
-
-    test("Only a zero", () => {
-        const items = [0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 0 });
-    });
-});
-
-describe("Collapse gaps when items have zero px and grow, reversed", () => {
-    test("Zero as first", () => {
-        const items = [0, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 100, size: 0 });
-        expect(mapped[1]).toEqual({ location: 70, size: 30 });
-        expect(mapped[2]).toEqual({ location: 40, size: 20 });
-    });
-
-    test("Zero in the middle", () => {
-        const items = [10, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 85, size: 0 });
-        expect(mapped[2]).toEqual({ location: 60, size: 20 });
-    });
-
-    test("Multiple zeroes in the middle", () => {
-        const items = [10, 0, 0, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 87.5, size: 0 });
-        expect(mapped[2]).toEqual({ location: 85, size: 0 });
-        expect(mapped[3]).toEqual({ location: 82.5, size: 0 });
-        expect(mapped[4]).toEqual({ location: 60, size: 20 });
-    });
-
-    test("Zero as last", () => {
-        const items = [10, 30, 0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 50, size: 30 });
-        expect(mapped[2]).toEqual({ location: 50, size: 0 });
-    });
-
-    test("Only a zero", () => {
-        const items = [0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 100, size: 0 });
-    });
-});
-
-describe("Utility fuctions", () => {
-    test("sumSizeDefs", () => {
-        const items = [
-            { px: 100 },
-            { px: 10, grow: 1 },
-            { grow: 9 },
-            { px: 200 },
-        ];
-
-        expect(sumSizeDefs(items)).toEqual({ px: 310, grow: 10 });
-    });
-
-    test("getMinimumSize", () => {
-        const items = [{ px: 100 }, { grow: 1 }, { grow: 9 }, { px: 200 }];
-
-        expect(getMinimumSize(items)).toEqual(300);
-
-        expect(getMinimumSize(items, { spacing: 10 })).toEqual(330);
-    });
-
-    test("getMinimumSize, items include zeroes", () => {
-        const items = [
-            { px: 100 },
-            { px: 0, grow: 0 },
-            { grow: 1 },
-            { grow: 9 },
-            { px: 200 },
-        ];
-
-        expect(getMinimumSize(items)).toEqual(300);
-
-        expect(getMinimumSize(items, { spacing: 10 })).toEqual(330);
-    });
-
-    test("getLargestSize", () => {
-        const items = [
-            { px: 100 },
-            { px: 0, grow: 0 },
-            { grow: 1 },
-            { grow: 9 },
-            { px: 200 },
-            { px: 50 },
-        ];
-
-        expect(getLargestSize(items)).toEqual({ px: 200, grow: 9 });
-    });
-
-    test("isStretching", () => {
-        expect(isStretching([{ grow: 1 }])).toBeTruthy();
-        expect(isStretching([{ px: 1 }])).toBeFalsy();
-    });
-});

package/dist/src/view/layout/grid.test.js

@@ -1,71 +0,0 @@
-import { expect, test, describe } from "vitest";
-
-import Grid from "./grid.js";
-
-describe("Grid indexing", () => {
-    test("Single row", () => {
-        const g = new Grid(3);
-
-        expect(g.maxCols).toEqual(Infinity);
-        expect(g.nCols).toEqual(3);
-        expect(g.nRows).toEqual(1);
-        expect(g.colIndices).toEqual([[0], [1], [2]]);
-        expect(g.rowIndices).toEqual([[0, 1, 2]]);
-        expect(g.getCellIndex(1, 0)).toEqual(1);
-        expect(g.getCellIndex(1, 1)).toBeUndefined();
-        expect(g.getCellCoords(1)).toEqual([1, 0]);
-        expect(g.getCellCoords(-1)).toBeUndefined();
-        expect(g.getCellCoords(3)).toBeUndefined();
-    });
-
-    test("Single column", () => {
-        const g = new Grid(3, 1);
-
-        expect(g.maxCols).toEqual(1);
-        expect(g.nCols).toEqual(1);
-        expect(g.nRows).toEqual(3);
-        expect(g.colIndices).toEqual([[0, 1, 2]]);
-        expect(g.rowIndices).toEqual([[0], [1], [2]]);
-        expect(g.getCellIndex(0, 1)).toEqual(1);
-        expect(g.getCellIndex(1, 1)).toBeUndefined();
-        expect(g.getCellCoords(1)).toEqual([0, 1]);
-    });
-
-    test("Two columns", () => {
-        const g = new Grid(6, 2);
-
-        expect(g.maxCols).toEqual(2);
-        expect(g.nCols).toEqual(2);
-        expect(g.nRows).toEqual(3);
-        expect(g.colIndices).toEqual([
-            [0, 2, 4],
-            [1, 3, 5],
-        ]);
-        expect(g.rowIndices).toEqual([
-            [0, 1],
-            [2, 3],
-            [4, 5],
-        ]);
-        expect(g.getCellIndex(1, 0)).toEqual(1);
-        expect(g.getCellIndex(0, 1)).toEqual(2);
-        expect(g.getCellIndex(1, 1)).toEqual(3);
-        expect(g.getCellCoords(3)).toEqual([1, 1]);
-    });
-
-    test("Two columns, second is partial", () => {
-        const g = new Grid(5, 2);
-
-        expect(g.maxCols).toEqual(2);
-        expect(g.nCols).toEqual(2);
-        expect(g.nRows).toEqual(3);
-        expect(g.colIndices).toEqual([
-            [0, 2, 4],
-            [1, 3],
-        ]);
-        expect(g.rowIndices).toEqual([[0, 1], [2, 3], [4]]);
-        expect(g.getCellIndex(1, 0)).toEqual(1);
-        expect(g.getCellIndex(0, 1)).toEqual(2);
-        expect(g.getCellIndex(1, 2)).toBeUndefined();
-        expect(g.getCellCoords(3)).toEqual([1, 1]);
-    });
-});