@genome-spy/core 0.36.0 → 0.37.0

package/dist/src/view/axisResolution.js

@@ -0,0 +1,141 @@
+import { isString } from "vega-util";
+import {
+    getChannelDefWithScale,
+    getPrimaryChannel,
+    isExprDef,
+    isFieldDef,
+    isSecondaryChannel,
+    isValueDef,
+} from "../encoder/encoder";
+import { peek } from "../utils/arrayUtils";
+import coalesce from "../utils/coalesce";
+
+import mergeObjects from "../utils/mergeObjects";
+import { getCachedOrCall } from "../utils/propertyCacher";
+
+export default class AxisResolution {
+    /**
+     * @typedef { import("./unitView").default} UnitView
+     */
+
+    /**
+     * @param {import("../spec/channel").PrimaryPositionalChannel} channel
+     */
+    constructor(channel) {
+        this.channel = channel;
+        /** @type {import("./scaleResolution").ResolutionMember<import("../spec/channel").PositionalChannel>[]} The involved views */
+        this.members = [];
+    }
+
+    get scaleResolution() {
+        return peek(this.members)?.view.getScaleResolution(this.channel);
+    }
+
+    /**
+     * N.B. This is expected to be called in depth-first order, AFTER the
+     * scales have been resolved.
+     *
+     * @param {UnitView} view
+     * @param {import("../spec/channel").PositionalChannel} channel TODO: Do something for this
+     */
+    pushUnitView(view, channel) {
+        const newScaleResolution = view.getScaleResolution(this.channel);
+
+        if (!newScaleResolution) {
+            throw new Error("Cannot find a scale resolution!");
+        }
+
+        if (
+            this.scaleResolution &&
+            newScaleResolution !== this.scaleResolution
+        ) {
+            throw new Error("Shared axes must have a shared scale!");
+        }
+
+        this.members.push({ view, channel });
+    }
+
+    getAxisProps() {
+        return getCachedOrCall(this, "axisProps", () => {
+            const propArray = this.members.map((member) => {
+                const channelDef = member.view.mark.encoding[member.channel];
+                return "axis" in channelDef && channelDef.axis;
+            });
+
+            if (
+                propArray.length > 0 &&
+                propArray.some((props) => props === null)
+            ) {
+                // No axis whatsoever is wanted
+                return null;
+            } else {
+                return /** @type { import("../spec/axis").GenomeAxis} */ (
+                    mergeObjects(
+                        propArray.filter((props) => props !== undefined),
+                        "axis",
+                        ["title"]
+                    )
+                );
+            }
+        });
+    }
+
+    getTitle() {
+        /** @param {import("./scaleResolution").ResolutionMember} member} */
+        const computeTitle = (member) => {
+            const channelDef = getChannelDefWithScale(
+                member.view,
+                member.channel
+            );
+
+            if (isValueDef(channelDef)) {
+                return undefined;
+            }
+
+            // Retain nulls as they indicate that no title should be shown
+
+            return {
+                member,
+                explicitTitle: coalesce(
+                    // TODO: Proper type guard
+                    "axis" in channelDef ? channelDef.axis?.title : undefined,
+                    channelDef.title
+                ),
+                implicitTitle: coalesce(
+                    isFieldDef(channelDef) ? channelDef.field : undefined,
+                    isExprDef(channelDef) ? channelDef.expr : undefined
+                ),
+            };
+        };
+
+        const titles = this.members.map(computeTitle);
+
+        // Skip implicit secondary channel titles if the primary channel has an explicit title
+        const filteredTitles = titles.filter((title) => {
+            if (
+                isSecondaryChannel(title.member.channel) &&
+                !title.explicitTitle
+            ) {
+                const primaryChannel = getPrimaryChannel(title.member.channel);
+                return (
+                    titles.find(
+                        (title2) =>
+                            title2.member.view == title.member.view &&
+                            title2.member.channel == primaryChannel
+                    )?.explicitTitle === undefined
+                );
+            }
+            return true;
+        });
+
+        const uniqueTitles = new Set(
+            filteredTitles
+                .map((title) =>
+                    coalesce(title.explicitTitle, title.implicitTitle)
+                )
+                .filter(isString)
+        );
+
+        return uniqueTitles.size ? [...uniqueTitles].join(", ") : null;
+    }
+}

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

@@ -0,0 +1,201 @@
+import { describe, expect, test } from "vitest";
+import { createAndInitialize } from "./testUtils";
+import UnitView from "./unitView";
+import View from "./view";
+
+/** @type {import("../spec/view").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", () => {
+    const sharedSpec = {
+        ...spec,
+        resolve: { scale: { y: "shared" }, axis: { y: "shared" } },
+    };
+
+    test("Independent axes are independent", async () => {
+        const independentSpec = {
+            ...spec,
+            resolve: { scale: { y: "shared" }, axis: { y: "independent" } },
+        };
+
+        const view = await createAndInitialize(independentSpec, View);
+        const [r0, r1] = [0, 1].map((i) =>
+            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(sharedSpec, View);
+        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/axisView.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @param {AxisOrient} slot
+ */
+export function orient2channel(slot: import("../spec/axis").AxisOrient): import("../spec/channel").PrimaryPositionalChannel;
+/**
+ * @param {GenomeAxis} axisProps
+ * @param {string} type
+ * @returns {LayerSpec}
+ */
+export function createGenomeAxis(axisProps: import("../spec/axis").GenomeAxis, type: string): import("../spec/view").LayerSpec;
+/**
+ * @type {Record<import("../spec/channel").PrimaryPositionalChannel, AxisOrient[]>}
+ */
+export const CHANNEL_ORIENTS: Record<import("../spec/channel").PrimaryPositionalChannel, import("../spec/axis").AxisOrient[]>;
+/**
+ * @type {Record<AxisOrient, import("../spec/channel").PrimaryPositionalChannel>}
+ */
+export const ORIENT_CHANNELS: Record<import("../spec/axis").AxisOrient, import("../spec/channel").PrimaryPositionalChannel>;
+/**
+ * An internal view that renders an axis.
+ *
+ * TODO: Implement grid
+ *
+ */
+export default class AxisView extends LayerView {
+    /**
+     *
+     * @typedef {import("../spec/view").LayerSpec} LayerSpec
+     * @typedef {import("./view").default} View
+     * @typedef {import("../spec/axis").Axis} Axis
+     * @typedef {import("../spec/axis").GenomeAxis} GenomeAxis
+     * @typedef {import("../spec/axis").AxisOrient} AxisOrient
+     * @typedef {import("../utils/layout/flexLayout").SizeDef} SizeDef
+     *
+     * @typedef {Axis & { extent: number }} AugmentedAxis
+     */
+    /**
+     * @param {Axis} axisProps
+     * @param {import("../types/viewContext").default} context
+     * @param {string} type Data type (quantitative, ..., locus)
+     * @param {import("./containerView").default} layoutParent
+     * @param {import("./view").default} dataParent
+     */
+    constructor(axisProps: import("../spec/axis").Axis, type: string, context: import("../types/viewContext").default, layoutParent: import("./containerView").default, dataParent: import("./view").default);
+    axisProps: import("../spec/axis").GenomeAxis | import("../spec/axis").Axis;
+    getPerpendicularSize(): number;
+}
+import LayerView from "./layerView";
+//# sourceMappingURL=axisView.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axisView.d.ts","sourceRoot":"","sources":["../../../src/view/axisView.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH,4HAEC;AA8XD;;;;GAIG;AACH,qFAHW,MAAM,oCA2MhB;AAjmBD;;GAEG;AACH,8HAGE;AAEF;;GAEG;AACH,4HAIE;AASF;;;;;GAKG;AACH;IACI;;;;;;;;;;OAUG;IAEH;;;;;;OAMG;IACH,0DAJW,MAAM,WADN,OAAO,sBAAsB,EAAE,OAAO,gBAEtC,OAAO,iBAAiB,EAAE,OAAO,cACjC,OAAO,QAAQ,EAAE,OAAO,EA8BlC;IAHG,2EAA8B;IAmBlC,+BAEC;CAKJ;sBAxHqB,aAAa"}