@genome-spy/core 0.14.0

package/src/view/scaleResolution.test.js

@@ -0,0 +1,571 @@
+import { createAndInitialize } from "./testUtils";
+import createDomain, { toRegularArray as r } from "../utils/domainArray";
+import LayerView from "./layerView";
+import UnitView from "./unitView";
+import { primaryPositionalChannels } from "../encoder/encoder";
+
+/**
+ * @typedef {import("../spec/channel").Channel} Channel
+ */
+
+// NOTE: The most of these tests don't actually test scaleResolution but the resolution algorithm.
+
+describe("Scale resolution", () => {
+    test("Channels with just values (no fields or scales) do not resolve", async () => {
+        /** @type {import("../spec/view").LayerSpec} */
+        const spec = {
+            data: { values: [] },
+
+            resolve: {
+                scale: { x: "shared" },
+            },
+
+            layer: [
+                {
+                    mark: "point",
+                    encoding: {
+                        color: { value: "red" },
+                    },
+                },
+                {
+                    mark: "point",
+                    encoding: {
+                        color: { value: "green" },
+                    },
+                },
+            ],
+        };
+        const view = await createAndInitialize(spec, LayerView);
+        expect(view.children[0].getScaleResolution("color")).toBeUndefined();
+        expect(view.children[1].getScaleResolution("color")).toBeUndefined();
+    });
+
+    test("Deeply shared scales are shared", async () => {
+        /** @type {import("../spec/view").LayerSpec} */
+        const spec = {
+            data: { values: [] },
+            encoding: {
+                x: { field: "data", type: "quantitative" },
+            },
+
+            resolve: { scale: { x: "shared" } },
+
+            layer: [
+                {
+                    resolve: { scale: { x: "shared" } },
+                    layer: [{ mark: "point" }, { mark: "point" }],
+                },
+                {
+                    resolve: { scale: { x: "shared" } },
+                    layer: [{ mark: "point" }, { mark: "point" }],
+                },
+            ],
+        };
+
+        const view = await createAndInitialize(spec, LayerView);
+
+        expect(view.children[0].children[0].getScaleResolution("x")).toBe(
+            view.children[1].children[1].getScaleResolution("x")
+        );
+    });
+
+    test("Shared branches under an independent branch works as expected", async () => {
+        /** @type {import("../spec/view").LayerSpec} */
+        const spec = {
+            data: { values: [] },
+            encoding: {
+                x: { field: "data", type: "quantitative" },
+            },
+
+            resolve: {
+                scale: { x: "independent" },
+                // TODO: Axis should be set independent implicitly
+                axis: { x: "independent" },
+            },
+
+            layer: [
+                {
+                    resolve: { scale: { x: "shared" } },
+                    layer: [{ mark: "point" }, { mark: "point" }],
+                },
+                {
+                    resolve: { scale: { x: "shared" } },
+                    layer: [{ mark: "point" }, { mark: "point" }],
+                },
+            ],
+        };
+
+        const view = await createAndInitialize(spec, LayerView);
+
+        expect(view.children[0].children[0].getScaleResolution("x")).not.toBe(
+            view.children[1].children[1].getScaleResolution("x")
+        );
+        expect(view.children[0].children[0].getScaleResolution("x")).toBe(
+            view.children[0].children[1].getScaleResolution("x")
+        );
+        expect(view.children[1].children[0].getScaleResolution("x")).toBe(
+            view.children[1].children[1].getScaleResolution("x")
+        );
+    });
+
+    test("Independent branches under a shared branch works as expected", async () => {
+        /** @type {import("../spec/view").LayerSpec} */
+        const spec = {
+            data: { values: [] },
+            encoding: {
+                x: { field: "data", type: "quantitative" },
+            },
+
+            resolve: {
+                scale: { x: "shared" },
+            },
+
+            layer: [
+                {
+                    resolve: {
+                        scale: { x: "independent" },
+                        // TODO: Axis should be set independent implicitly
+                        axis: { x: "independent" },
+                    },
+                    layer: [{ mark: "point" }, { mark: "point" }],
+                },
+                {
+                    resolve: {
+                        scale: { x: "independent" },
+                        // TODO: Axis should be set independent implicitly
+                        axis: { x: "independent" },
+                    },
+                    layer: [{ mark: "point" }, { mark: "point" }],
+                },
+            ],
+        };
+
+        const view = await createAndInitialize(spec, LayerView);
+
+        expect(view.children[0].children[0].getScaleResolution("x")).not.toBe(
+            view.children[1].children[0].getScaleResolution("x")
+        );
+        expect(view.children[0].children[1].getScaleResolution("x")).not.toBe(
+            view.children[1].children[1].getScaleResolution("x")
+        );
+        expect(view.children[0].children[0].getScaleResolution("x")).not.toBe(
+            view.children[0].children[1].getScaleResolution("x")
+        );
+        expect(view.children[1].children[0].getScaleResolution("x")).not.toBe(
+            view.children[1].children[1].getScaleResolution("x")
+        );
+    });
+
+    test("Excluded resolution is not pushed towards the root but collects from children.", async () => {
+        /** @type {import("../spec/view").LayerSpec} */
+        const spec = {
+            data: { values: [] },
+            encoding: {
+                x: { field: "data", type: "quantitative" },
+            },
+
+            resolve: {
+                scale: { x: "shared" },
+            },
+
+            layer: [
+                { mark: "point" },
+                { mark: "point" },
+                {
+                    resolve: {
+                        scale: { x: "excluded" },
+                        // TODO: Implicit
+                        axis: { x: "excluded" },
+                    },
+                    layer: [{ mark: "point" }, { mark: "point" }],
+                },
+            ],
+        };
+
+        const view = await createAndInitialize(spec, LayerView);
+
+        expect(view.children[0].getScaleResolution("x")).toBe(
+            view.children[1].getScaleResolution("x")
+        );
+
+        expect(view.children[2].children[0].getScaleResolution("x")).toBe(
+            view.children[2].children[1].getScaleResolution("x")
+        );
+
+        expect(view.children[0].getScaleResolution("x")).not.toBe(
+            view.children[2].children[0].getScaleResolution("x")
+        );
+    });
+
+    test("Default resolution is configurable", async () => {
+        /** @type {import("../spec/view").LayerSpec} */
+        const spec = {
+            data: { values: [] },
+            encoding: {
+                x: { field: "data", type: "quantitative" },
+                y: { field: "data", type: "quantitative" },
+            },
+
+            resolve: {
+                scale: {
+                    // The hard default in LayerView is "shared".
+                    default: "independent",
+                    x: "shared",
+                },
+                axis: {
+                    // TODO: Implicit
+                    default: "independent",
+                },
+            },
+
+            layer: [{ mark: "point" }, { mark: "point" }],
+        };
+
+        const view = await createAndInitialize(spec, LayerView);
+
+        expect(view.children[0].getScaleResolution("x")).toBe(
+            view.children[1].getScaleResolution("x")
+        );
+
+        expect(view.children[0].getScaleResolution("y")).not.toBe(
+            view.children[1].getScaleResolution("y")
+        );
+    });
+});
+
+describe("Domain handling", () => {
+    test("Scales are shared and explicit domains merged properly", async () => {
+        const view = await createAndInitialize(
+            {
+                data: { values: [] },
+                resolve: { scale: { default: "independent", y: "shared" } },
+                layer: [
+                    {
+                        mark: "point",
+                        encoding: {
+                            y: {
+                                field: "a",
+                                type: "quantitative",
+                                scale: { domain: [1, 2] },
+                            },
+                        },
+                    },
+                    {
+                        mark: "point",
+                        encoding: {
+                            y: {
+                                field: "b",
+                                type: "quantitative",
+                                scale: { domain: [4, 5] },
+                            },
+                        },
+                    },
+                ],
+            },
+            LayerView
+        );
+
+        /** @param {import("./view").default} view */
+        const d = (view) => view.getScaleResolution("y").getScale().domain();
+
+        expect(r(d(view))).toEqual([1, 5]);
+        expect(r(d(view.children[0]))).toEqual([1, 5]);
+        expect(r(d(view.children[1]))).toEqual([1, 5]);
+    });
+
+    test("Scales are shared and extracted domains merged properly", async () => {
+        const view = await createAndInitialize(
+            {
+                resolve: { scale: { default: "independent", y: "shared" } },
+                layer: [
+                    {
+                        data: { values: [1, 2] },
+                        mark: "point",
+                        encoding: {
+                            y: {
+                                field: "data",
+                                type: "quantitative",
+                                scale: { zero: false },
+                            },
+                        },
+                    },
+                    {
+                        data: { values: [4, 5] },
+                        mark: "point",
+                        encoding: {
+                            y: { field: "data", type: "quantitative" },
+                        },
+                    },
+                ],
+            },
+            LayerView
+        );
+
+        /** @param {import("./view").default} view */
+        const d = (view) => view.getScaleResolution("y").getScale().domain();
+
+        expect(r(d(view))).toEqual([1, 5]);
+        expect(r(d(view.children[0]))).toEqual([1, 5]);
+        expect(r(d(view.children[1]))).toEqual([1, 5]);
+    });
+
+    test("Scales of primary and secondary channels are shared and extracted domains merged properly", async () => {
+        const view = await createAndInitialize(
+            {
+                data: {
+                    values: [
+                        { a: 1, b: 4 },
+                        { a: 2, b: 5 },
+                    ],
+                },
+                mark: "point",
+                encoding: {
+                    y: {
+                        field: "a",
+                        type: "quantitative",
+                        scale: { zero: false },
+                    },
+                    y2: {
+                        field: "b",
+                    },
+                },
+            },
+            UnitView
+        );
+
+        /** @param {import("./view").default} view */
+        const d = (view) => view.getScaleResolution("y").getScale().domain();
+
+        // FAILS!!!!!!! TODO: FIX!!
+        // expect(r(d(view))).toEqual([1, 5]);
+    });
+
+    test("resolutionChannel property is respected", async () => {
+        const view = await createAndInitialize(
+            {
+                data: { values: [] },
+                resolve: { scale: { default: "independent", y: "shared" } },
+                layer: [
+                    {
+                        mark: "point",
+                        encoding: {
+                            y: {
+                                field: "a",
+                                type: "quantitative",
+                                scale: { domain: [1, 2] },
+                            },
+                        },
+                    },
+                    {
+                        mark: "point",
+                        encoding: {
+                            x: {
+                                field: "b",
+                                type: "quantitative",
+                                scale: { domain: [4, 5] },
+                                resolutionChannel: "y",
+                            },
+                        },
+                    },
+                ],
+            },
+            LayerView
+        );
+
+        /** @param {import("./view").default} view */
+        const d = (view) => view.getScaleResolution("y").getScale().domain();
+
+        expect(r(d(view))).toEqual([1, 5]);
+        expect(r(d(view.children[0]))).toEqual([1, 5]);
+        expect(r(d(view.children[1]))).toEqual([1, 5]);
+    });
+
+    test("Channels with quantitative fields include zero in their scale domain by default", async () => {
+        const view = await createAndInitialize(
+            {
+                data: { values: [2, 3] },
+                mark: "point",
+                encoding: {
+                    x: { field: "data", type: "quantitative" },
+                    y: { field: "data", type: "quantitative" },
+                },
+            },
+            UnitView
+        );
+
+        for (const channel of primaryPositionalChannels) {
+            // Extract domain from data
+            view.getScaleResolution(channel).reconfigure();
+        }
+
+        const d = /** @param {import("../spec/channel").Channel} channel*/ (
+            channel
+        ) => view.getScaleResolution(channel).getScale().domain();
+
+        expect(d("x")).toEqual([0, 3]);
+        expect(d("y")).toEqual([0, 3]);
+    });
+
+    test("Channels with quantitative fields do not include zero in their scale domain if the domain has been defined explicitly", async () => {
+        const view = await createAndInitialize(
+            {
+                data: { values: [2, 3] },
+                mark: "point",
+                encoding: {
+                    x: {
+                        field: "data",
+                        type: "quantitative",
+                        scale: { domain: [1, 4] },
+                    },
+                    y: {
+                        field: "data",
+                        type: "quantitative",
+                        scale: { domain: [1, 4] },
+                    },
+                },
+            },
+            UnitView
+        );
+
+        const d = /** @param {Channel} channel*/ (channel) =>
+            view.getScaleResolution(channel).getScale().domain();
+
+        expect(d("x")).toEqual([1, 4]);
+        expect(d("x")).toEqual([1, 4]);
+    });
+
+    test("Channels with quantitative fields do not include zero in their scale domain if zero is explicitly false", async () => {
+        const view = await createAndInitialize(
+            {
+                data: { values: [2, 3] },
+                mark: "point",
+                encoding: {
+                    x: {
+                        field: "data",
+                        type: "quantitative",
+                        scale: { zero: false },
+                    },
+                    y: {
+                        field: "data",
+                        type: "quantitative",
+                        scale: { zero: false },
+                    },
+                },
+            },
+            UnitView
+        );
+
+        for (const channel of primaryPositionalChannels) {
+            // Extract domain from data
+            view.getScaleResolution(channel).reconfigure();
+        }
+
+        const d = /** @param {Channel} channel*/ (channel) =>
+            view.getScaleResolution(channel).getScale().domain();
+
+        expect(d("x")).toEqual([2, 3]);
+        expect(d("y")).toEqual([2, 3]);
+    });
+});
+
+describe("Named scales", () => {
+    test("Resolution of shared scales with conflicting names fails with an exception", async () => {
+        return expect(
+            createAndInitialize(
+                {
+                    data: { values: [1, 2] },
+                    layer: [
+                        {
+                            mark: "point",
+                            encoding: {
+                                x: {
+                                    field: "data",
+                                    type: "quantitative",
+                                    scale: { name: "scale_1" },
+                                },
+                            },
+                        },
+                        {
+                            mark: "point",
+                            encoding: {
+                                x: {
+                                    field: "data",
+                                    type: "quantitative",
+                                    scale: { name: "scale_2" },
+                                },
+                            },
+                        },
+                    ],
+                },
+                LayerView
+            )
+        ).rejects.toThrow(/conflicting/);
+    });
+
+    test("A name is properly registered to the ScaleResolution object", async () => {
+        expect(
+            await createAndInitialize(
+                {
+                    data: { values: [1, 2] },
+                    layer: [
+                        {
+                            mark: "point",
+                            encoding: {
+                                x: {
+                                    field: "data",
+                                    type: "quantitative",
+                                    scale: { name: "scale_1" },
+                                },
+                            },
+                        },
+                        {
+                            mark: "point",
+                            encoding: {
+                                x: {
+                                    field: "data",
+                                    type: "quantitative",
+                                    scale: { name: "scale_1" },
+                                },
+                            },
+                        },
+                    ],
+                },
+                LayerView
+            ).then((view) => view.getScaleResolution("x"))
+        ).toHaveProperty("name", "scale_1");
+    });
+
+    test("The scale name must be unique among the scale resolutions", async () => {
+        return expect(
+            createAndInitialize(
+                {
+                    resolve: { scale: { x: "independent" } },
+                    data: { values: [1, 2] },
+                    layer: [
+                        {
+                            mark: "point",
+                            encoding: {
+                                x: {
+                                    field: "data",
+                                    type: "quantitative",
+                                    scale: { name: "scale_1" },
+                                },
+                            },
+                        },
+                        {
+                            mark: "point",
+                            encoding: {
+                                x: {
+                                    field: "data",
+                                    type: "quantitative",
+                                    scale: { name: "scale_1" },
+                                },
+                            },
+                        },
+                    ],
+                },
+                LayerView
+            )
+        ).rejects.toThrow(/multiple/);
+    });
+});

package/src/view/scaleResolutionApi.d.ts

@@ -0,0 +1,40 @@
+import { ComplexDomain, NumericDomain } from "../spec/scale";
+import ScaleResolution from "./scaleResolution";
+
+export interface ScaleResolutionEvent {
+    type: "domain";
+
+    scaleResolution: ScaleResolution;
+}
+
+export type ScaleResolutionListener = (event: ScaleResolutionEvent) => void;
+
+/**
+ * A public API for ScaleResolution
+ */
+export interface ScaleResolutionApi {
+    addEventListener(type: "domain", listener: ScaleResolutionListener): void;
+
+    removeEventListener(
+        type: "domain",
+        listener: ScaleResolutionListener
+    ): void;
+
+    /**
+     * Returns the current, possible zoomed domain.
+     */
+    getDomain(): any[];
+
+    /**
+     * Returns the current, possible zoomed domain converted into complex objects
+     * such as genomic coordinates.
+     */
+    getComplexDomain(): NumericDomain | ComplexDomain;
+
+    isZoomable(): boolean;
+
+    zoomTo(
+        domain: number[] | ComplexDomain,
+        duration?: boolean | number
+    ): Promise<void>;
+}

package/src/view/testUtils.js

@@ -0,0 +1,48 @@
+/**
+ * Utils for Jest tests
+ * TODO: Find a better place and convention
+ *
+ * @typedef {import("./view").default} View
+ * @typedef {import("../spec/view").ViewSpec} ViewSpec
+ * @typedef {import("./viewContext").default} ViewContext
+ */
+
+import { resolveScalesAndAxes, initializeData } from "./viewUtils";
+import AccessorFactory from "../encoder/accessor";
+import DataFlow from "../data/dataFlow";
+import { ViewFactory } from "./viewFactory";
+
+/** @type {<V extends View>(spec: ViewSpec, viewClass: { new(...args: any[]): V }, context?: ViewContext) => V} */
+export function create(spec, viewClass, context = undefined) {
+    const viewTypeRegistry = new ViewFactory();
+    /** @type {ViewContext} */
+    const c = {
+        ...(context || {}),
+        accessorFactory: new AccessorFactory(),
+
+        createView: function (spec, parent, defaultName) {
+            return viewTypeRegistry.createView(spec, c, parent, defaultName);
+        },
+    };
+
+    const view = c.createView(spec, null, "root");
+
+    if (!(view instanceof viewClass)) {
+        throw new Error("ViewClass and the spec do not match!");
+    }
+
+    return view;
+}
+
+/** @type {<V extends View>(spec: ViewSpec, viewClass: { new(...args: any[]): V }, context?: ViewContext) => Promise<V>} */
+export async function createAndInitialize(
+    spec,
+    viewClass,
+    context = undefined
+) {
+    context = { ...(context || {}), dataFlow: new DataFlow() };
+    const view = create(spec, viewClass, context);
+    resolveScalesAndAxes(view);
+    await initializeData(view, context.dataFlow);
+    return view;
+}