@genome-spy/core 0.29.0 → 0.30.2

package/src/utils/ui/tooltip.js

@@ -1,189 +0,0 @@
-import clientPoint from "../point";
-import { html, render } from "lit-html";
-import { peek } from "../arrayUtils";
-
-export const SUPPRESS_TOOLTIP_CLASS_NAME = "gs-suppress-tooltip";
-
-export default class Tooltip {
-    /**
-     * @param {HTMLElement} container
-     */
-    constructor(container) {
-        this.container = container;
-
-        this.element = document.createElement("div");
-        this.element.className = "tooltip";
-        this._visible = true;
-        this.container.appendChild(this.element);
-
-        /** @type {any} */
-        this._previousTooltipDatum = undefined;
-
-        this.enabledStack = [true];
-
-        this._penaltyUntil = 0;
-        /** @type {[number, number]} */
-        this._lastCoords = undefined;
-
-        this._previousMove = 0;
-
-        this.clear();
-    }
-
-    /**
-     * @param {boolean} visible
-     */
-    set visible(visible) {
-        if (visible != this._visible) {
-            this.element.style.display = visible ? null : "none";
-            this._visible = visible;
-        }
-    }
-
-    get visible() {
-        return this._visible;
-    }
-
-    get enabled() {
-        return peek(this.enabledStack) ?? true;
-    }
-
-    /**
-     * @param {boolean} enabled True if tooltip is enabled (allowed to be shown)
-     */
-    pushEnabledState(enabled) {
-        this.enabledStack.push(enabled);
-        if (!enabled) {
-            this.visible = false;
-        }
-    }
-
-    popEnabledState() {
-        this.enabledStack.pop();
-    }
-
-    /**
-     * @param {MouseEvent} mouseEvent
-     */
-    handleMouseMove(mouseEvent) {
-        this.mouseCoords = clientPoint(this.container, mouseEvent);
-
-        const now = performance.now();
-
-        // Prevent the tooltip from flashing briefly before it becomes penalized
-        // because of a quickly moving mouse pointer
-        if (
-            !this.visible &&
-            !this._isPenalty() &&
-            now - this._previousMove > 500
-        ) {
-            this._penaltyUntil = now + 70;
-        }
-
-        // Disable the tooltip for a while if the mouse is being moved very quickly.
-        // Makes the tooltip less annoying.
-        // TODO: Should calculate speed: pixels per millisecond or something
-        if (
-            this._lastCoords &&
-            distance(this.mouseCoords, this._lastCoords) > 20
-        ) {
-            this._penaltyUntil = now + 400;
-        }
-
-        this._lastCoords = this.mouseCoords;
-
-        if (this.visible) {
-            this.updatePlacement();
-        }
-
-        this._previousMove = now;
-    }
-
-    updatePlacement() {
-        /** Space between pointer and tooltip box */
-        const spacing = 20;
-
-        const [mouseX, mouseY] = this.mouseCoords;
-
-        let x = mouseX + spacing;
-        if (x > this.container.clientWidth - this.element.offsetWidth) {
-            x = mouseX - spacing - this.element.offsetWidth;
-        }
-        this.element.style.left = x + "px";
-
-        this.element.style.top =
-            Math.min(
-                mouseY + spacing,
-                this.container.clientHeight - this.element.offsetHeight
-            ) + "px";
-    }
-
-    /**
-     * @param {string | import("lit").TemplateResult | HTMLElement} content
-     */
-    setContent(content) {
-        if (!content || !this.enabled || this._isPenalty()) {
-            if (this.visible) {
-                render("", this.element);
-                this.visible = false;
-            }
-            this._previousTooltipDatum = undefined;
-            return;
-        }
-
-        render(content, this.element);
-
-        this.visible = true;
-
-        this.updatePlacement();
-    }
-
-    clear() {
-        this._previousTooltipDatum = undefined;
-        this.setContent(undefined);
-    }
-
-    /**
-     * Updates the tooltip if the provided datum differs from the previous one.
-     * Otherwise this is nop.
-     *
-     * @param {T} datum
-     * @param {function(T):Promise<string | HTMLElement | import("lit").TemplateResult>} [converter]
-     * @template T
-     */
-    updateWithDatum(datum, converter) {
-        if (datum !== this._previousTooltipDatum) {
-            this._previousTooltipDatum = datum;
-            if (!converter) {
-                converter = (d) =>
-                    Promise.resolve(html` ${JSON.stringify(d)} `);
-            }
-
-            converter(datum)
-                .then((result) => this.setContent(result))
-                .catch((error) => {
-                    if (error !== "debounced") {
-                        throw error;
-                    }
-                });
-        }
-    }
-
-    _isPenalty() {
-        return this._penaltyUntil && this._penaltyUntil > performance.now();
-    }
-}
-
-/**
- * Calculate euclidean distance
- *
- * @param {number[]} a
- * @param {number[]} b
- */
-function distance(a, b) {
-    let sum = 0;
-    for (let i = 0; i < a.length; i++) {
-        sum += (a[i] - b[i]) ** 2;
-    }
-    return Math.sqrt(sum);
-}

package/src/utils/url.js

@@ -1,22 +0,0 @@
-const protoRe = /^([A-Za-z]+:)?\/\//;
-
-/**
- * Append a relative or absolute url to a base url.
- * The base part is omitted if the append part is absolute.
- *
- * @param {function():string} baseAccessor
- * @param {string} append
- */
-export function appendToBaseUrl(baseAccessor, append) {
-    if (append && protoRe.test(append)) {
-        return append;
-    }
-
-    const base = baseAccessor();
-
-    if (base && append) {
-        return base.endsWith("/") ? base + append : base + "/" + append;
-    }
-
-    return base ?? append;
-}

package/src/utils/variableTools.js

@@ -1,24 +0,0 @@
-import { isBoolean, isNumber, isString } from "vega-util";
-
-/** A set of typical NA values */
-export const NAs = new Set(["", "NA", ".", "-"]);
-
-/**
- * Tests whether the given array of strings can be interpreted as a numeric vector
- *
- * @param {string[]} values
- */
-export function inferNumeric(values) {
-    return values
-        .filter((value) => typeof value == "string")
-        .filter((value) => !NAs.has(value))
-        .every((value) => /^[+-]?\d+(\.\d*)?$/.test(value));
-}
-
-/**
- * @param {any} value
- * @returns {value is string | number | boolean}
- */
-export function isScalar(value) {
-    return isString(value) || isNumber(value) || isBoolean(value);
-}

package/src/utils/variableTools.test.js

@@ -1,13 +0,0 @@
-import { expect, test } from "vitest";
-import * as vt from "./variableTools";
-
-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/src/view/axisResolution.js

@@ -1,140 +0,0 @@
-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";
-
-/**
- *
- * @typedef { import("./unitView").default} UnitView
- */
-export default class AxisResolution {
-    /**
-     * @param {import("../spec/channel").Channel} 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").Axis} */ (
-                    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(
-                    channelDef.axis?.title,
-                    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/src/view/axisResolution.test.js

@@ -1,201 +0,0 @@
-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();
-    });
-});