@genome-spy/core 0.65.0 → 0.66.1

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

@@ -1,245 +0,0 @@
-import { describe, expect, test } from "vitest";
-import UnitView from "./unitView.js";
-
-import { create, createAndInitialize } from "./testUtils.js";
-import { toRegularArray as r } from "../utils/domainArray.js";
-import ConcatView from "./concatView.js";
-import PointMark from "../marks/point.js";
-import View from "./view.js";
-import LayerView from "./layerView.js";
-
-describe("Trivial creations and initializations", () => {
-    test("Fails on empty spec", async () => {
-        // @ts-expect-error
-        await expect(create({}, View)).rejects.toThrow();
-    });
-
-    test("Parses a trivial spec", async () => {
-        await expect(create({ mark: "point" }, View)).resolves.toBeInstanceOf(
-            UnitView
-        );
-        await expect(create({ layer: [] }, View)).resolves.toBeInstanceOf(
-            LayerView
-        );
-    });
-
-    test("Parses a more comples spec", async () => {
-        const view = await create(
-            {
-                hconcat: [
-                    {
-                        layer: [{ mark: "point" }, { mark: "rect" }],
-                    },
-                    { mark: "rect" },
-                ],
-            },
-            ConcatView
-        );
-
-        expect(view).toBeInstanceOf(ConcatView);
-        expect(view.children[0]).toBeInstanceOf(LayerView);
-        // @ts-ignore
-        expect(view.children[0].children[0]).toBeInstanceOf(UnitView);
-        // @ts-ignore
-        expect(view.children[0].children[0].mark).toBeInstanceOf(PointMark);
-        expect(view.children[1]).toBeInstanceOf(UnitView);
-        expect(view.children[2]).toBeUndefined();
-    });
-
-    test("Parses and initializes a trivial spec", () =>
-        expect(
-            createAndInitialize(
-                {
-                    data: { values: [1] },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "data", type: "quantitative" },
-                        y: { field: "data", type: "quantitative" },
-                    },
-                },
-                View
-            )
-        ).resolves.toBeInstanceOf(UnitView));
-});
-
-describe("Test domain handling", () => {
-    const dataSpec = {
-        values: [
-            { a: 1, b: 3 },
-            { a: 2, b: 4 },
-            { a: 3, b: 5 },
-        ],
-    };
-
-    /** -- This should be moved to ScaleResolution's test
-    test("Uses domain from the scale properties", () => {
-        const spec = {
-            data: dataSpec,
-            mark: "point",
-            encoding: {
-                x: { field: "a", type: "quantitative" },
-                y: {
-                    field: "a",
-                    type: "quantitative",
-                    scale: { domain: [0, 1000] },
-                },
-            },
-        };
-
-        return createAndInitialize(spec, UnitView).then((view) =>
-            expect(r(view.getConfiguredDomain("y"))).toEqual([0, 1000])
-        );
-    });
-    */
-
-    test("Includes a constant in the data domain", () =>
-        createAndInitialize(
-            {
-                data: dataSpec,
-                mark: "point",
-                encoding: {
-                    x: { datum: 123, type: "quantitative" },
-                    y: { field: "a", type: "quantitative" },
-                },
-            },
-            UnitView
-        ).then((view) =>
-            expect(r(view.extractDataDomain("x", "quantitative"))).toEqual([
-                123, 123,
-            ])
-        ));
-
-    test("Extracts domain from the data", () =>
-        createAndInitialize(
-            {
-                data: dataSpec,
-                mark: "point",
-                encoding: {
-                    x: { field: "a", type: "quantitative" },
-                    y: { field: "a", type: "quantitative" },
-                },
-            },
-            UnitView
-        ).then((view) =>
-            expect(r(view.extractDataDomain("y", "quantitative"))).toEqual([
-                1, 3,
-            ])
-        ));
-
-    test("Extracts domain from conditional encoding", () =>
-        createAndInitialize(
-            {
-                params: [{ name: "p" }],
-                data: dataSpec,
-                mark: "point",
-                encoding: {
-                    size: {
-                        field: "a",
-                        type: "quantitative",
-                        condition: {
-                            param: "p",
-                            datum: 123,
-                        },
-                    },
-                },
-            },
-            UnitView
-        ).then((view) =>
-            expect(r(view.extractDataDomain("size", "quantitative"))).toEqual([
-                1, 123,
-            ])
-        ));
-});
-
-describe("Utility methods", () => {
-    test("BaseUrl is handled correctly", async () => {
-        createAndInitialize(
-            {
-                layer: [],
-            },
-            LayerView
-        ).then((view) => expect(view.getBaseUrl()).toBeUndefined());
-
-        await createAndInitialize(
-            {
-                baseUrl: "blaa",
-                layer: [],
-            },
-            LayerView
-        ).then((view) => expect(view.getBaseUrl()).toEqual("blaa/"));
-
-        await createAndInitialize(
-            {
-                baseUrl: "blaa/",
-                layer: [],
-            },
-            LayerView
-        ).then((view) => expect(view.getBaseUrl()).toEqual("blaa/"));
-
-        await createAndInitialize(
-            {
-                baseUrl: "https://site.com",
-                layer: [],
-            },
-            LayerView
-        ).then((view) =>
-            expect(view.getBaseUrl()).toEqual("https://site.com/")
-        );
-
-        await createAndInitialize(
-            {
-                baseUrl: "https://site.com",
-                layer: [
-                    {
-                        baseUrl: "blaa",
-                        layer: [],
-                    },
-                ],
-            },
-            LayerView
-        ).then((view) =>
-            expect(view.children[0].getBaseUrl()).toEqual(
-                "https://site.com/blaa/"
-            )
-        );
-
-        await createAndInitialize(
-            {
-                baseUrl: "https://site.com",
-                layer: [
-                    {
-                        baseUrl: "https://another-site.com",
-                        layer: [],
-                    },
-                ],
-            },
-            LayerView
-        ).then((view) =>
-            expect(view.children[0].getBaseUrl()).toEqual(
-                "https://another-site.com/"
-            )
-        );
-
-        await createAndInitialize(
-            {
-                baseUrl: "https://site.com",
-                layer: [
-                    {
-                        layer: [
-                            {
-                                baseUrl: "blaa",
-                                layer: [],
-                            },
-                        ],
-                    },
-                ],
-            },
-            LayerView
-        ).then((view) =>
-            // @ts-ignore
-            expect(view.children[0].children[0].getBaseUrl()).toEqual(
-                "https://site.com/blaa/"
-            )
-        );
-    });
-});

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

@@ -1,110 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import ConcatView from "./concatView.js";
-import DataSource from "../data/sources/dataSource.js";
-import UnitView from "./unitView.js";
-import View from "./view.js";
-import { create, createTestViewContext } from "./testUtils.js";
-
-class DisposableView extends View {
-    /** @type {boolean} */
-    disposed = false;
-
-    /**
-     * @param {string} name
-     * @param {import("../types/viewContext.js").default} context
-     * @param {import("./containerView.js").default} layoutParent
-     * @param {import("./view.js").default} dataParent
-     */
-    constructor(name, context, layoutParent, dataParent) {
-        /** @type {import("../spec/view.js").LayerSpec} */
-        const spec = { name, layer: [] };
-        super(spec, context, layoutParent, dataParent, name);
-    }
-
-    dispose() {
-        super.dispose();
-        this.disposed = true;
-    }
-}
-
-describe("View disposal", () => {
-    test("removes scale and axis resolutions for disposed unit views", async () => {
-        /** @type {import("../spec/view.js").UnitSpec} */
-        const spec = {
-            data: {
-                values: [
-                    {
-                        x: 1,
-                        y: 2,
-                    },
-                ],
-            },
-            mark: "point",
-            encoding: {
-                x: { field: "x", type: "quantitative" },
-                y: { field: "y", type: "quantitative" },
-            },
-        };
-
-        const view = await create(spec, UnitView);
-
-        expect(view.getScaleResolution("x")).toBeDefined();
-        expect(view.getAxisResolution("x")).toBeDefined();
-
-        view.disposeSubtree();
-
-        expect(view.getScaleResolution("x")).toBeUndefined();
-        expect(view.getAxisResolution("x")).toBeUndefined();
-    });
-
-    test("disposes replaced grid children", () => {
-        const context = createTestViewContext();
-        const parent = new ConcatView(
-            { hconcat: [] },
-            context,
-            null,
-            null,
-            "c"
-        );
-
-        const childA = new DisposableView("a", context, parent, parent);
-        const childB = new DisposableView("b", context, parent, parent);
-        parent.setChildren([childA, childB]);
-
-        const childC = new DisposableView("c", context, parent, parent);
-        parent.setChildren([childC]);
-
-        expect(childA.disposed).toBe(true);
-        expect(childB.disposed).toBe(true);
-        expect(childC.disposed).toBe(false);
-
-        const childD = new DisposableView("d", context, parent, parent);
-        parent.replaceChild(childC, childD);
-
-        expect(childC.disposed).toBe(true);
-        expect(childD.disposed).toBe(false);
-    });
-
-    test("removes dataflow hosts on dispose", () => {
-        const context = createTestViewContext();
-        const parent = new ConcatView(
-            { hconcat: [] },
-            context,
-            null,
-            null,
-            "c"
-        );
-        const child = new DisposableView("a", context, parent, parent);
-
-        const dataSource = new DataSource(child);
-        context.dataFlow.addDataSource(dataSource);
-        child.flowHandle = { dataSource };
-
-        expect(child.flowHandle.dataSource).toBe(dataSource);
-
-        child.disposeSubtree();
-
-        expect(child.flowHandle).toBeUndefined();
-    });
-});

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

@@ -1,25 +0,0 @@
-import { expect, test } from "vitest";
-import { ViewFactory } from "./viewFactory.js";
-
-test("isViewSpec", () => {
-    const factory = new ViewFactory();
-
-    // @ts-ignore
-    expect(factory.isViewSpec({})).toBeFalsy();
-
-    expect(factory.isViewSpec({ mark: "rect" })).toBeTruthy();
-    expect(factory.isViewSpec({ layer: [] })).toBeTruthy();
-    expect(factory.isViewSpec({ hconcat: [] })).toBeTruthy();
-    expect(factory.isViewSpec({ vconcat: [] })).toBeTruthy();
-    expect(factory.isViewSpec({ concat: [], columns: 1 })).toBeTruthy();
-
-    expect(() => factory.isViewSpec({ mark: "rect", layer: [] })).toThrow();
-});
-
-test("Throws if importing is not allowed", async () => {
-    const factory = new ViewFactory({ allowImport: false });
-
-    await expect(() =>
-        factory.createOrImportView({ import: { url: "" } }, undefined)
-    ).rejects.toThrow();
-});

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

@@ -1,87 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-
-import { createTestViewContext } from "./testUtils.js";
-import { finalizeSubtreeGraphics } from "./viewUtils.js";
-import { initializeViewSubtree } from "../data/flowInit.js";
-
-describe("initializeViewSubtree", () => {
-    test("initializes data flow for a subtree only", async () => {
-        const context = createTestViewContext();
-
-        /** @type {import("../spec/view.js").HConcatSpec} */
-        const spec = {
-            hconcat: [
-                {
-                    data: {
-                        values: [{ x: 1 }],
-                    },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-                {
-                    data: {
-                        values: [{ x: 2 }],
-                    },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-            ],
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        const concatRoot = /** @type {import("./concatView.js").default} */ (
-            root
-        );
-        const child = concatRoot.children[0];
-        const otherChild = concatRoot.children[1];
-
-        const { dataSources, graphicsPromises, unitViews } =
-            initializeViewSubtree(child, context.dataFlow);
-
-        expect(dataSources.size).toBe(1);
-        expect(unitViews.length).toBe(1);
-        expect(graphicsPromises.length).toBe(0);
-
-        expect(child.flowHandle?.dataSource).toBeDefined();
-        expect(otherChild.flowHandle?.dataSource).toBeUndefined();
-    });
-});
-
-describe("finalizeSubtreeGraphics", () => {
-    test("finalizes marks when allowed", async () => {
-        const markA = /** @type {import("../marks/mark.js").default} */ (
-            /** @type {unknown} */ ({
-                finalizeGraphicsInitialization: vi.fn(),
-            })
-        );
-        const markB = /** @type {import("../marks/mark.js").default} */ (
-            /** @type {unknown} */ ({
-                finalizeGraphicsInitialization: vi.fn(),
-            })
-        );
-
-        await finalizeSubtreeGraphics([
-            Promise.resolve(markA),
-            Promise.resolve(markB),
-        ]);
-
-        expect(markA.finalizeGraphicsInitialization).toHaveBeenCalledTimes(1);
-        expect(markB.finalizeGraphicsInitialization).toHaveBeenCalledTimes(1);
-    });
-
-    test("skips finalization when predicate is false", async () => {
-        const mark = /** @type {import("../marks/mark.js").default} */ (
-            /** @type {unknown} */ ({
-                finalizeGraphicsInitialization: vi.fn(),
-            })
-        );
-
-        await finalizeSubtreeGraphics([Promise.resolve(mark)], () => false);
-
-        expect(mark.finalizeGraphicsInitialization).not.toHaveBeenCalled();
-    });
-});