@genome-spy/core 0.36.1 → 0.37.1

package/dist/src/scale/scale.test.js

@@ -0,0 +1,324 @@
+import { expect, test } from "vitest";
+/*!
+ * Adapted from vega-encode:
+ * https://github.com/vega/vega/blob/master/packages/vega-encode/test/scale-test.js
+ *
+ * Copyright (c) 2015-2018, University of Washington Interactive Data Lab
+ * All rights reserved.
+ *
+ * BSD-3-Clause License: https://github.com/vega/vega-lite/blob/master/LICENSE
+ */
+
+/* eslint-disable */
+
+import * as util from "vega-util";
+import * as vs from "vega-scale";
+import createScale from "./scale";
+
+// Suppress warnings by default
+const scale = (params, logger) =>
+    createScale(params, logger || { warn: () => {} });
+
+test("Scale respects domain configuration", function () {
+    var s,
+        params = {
+            type: "linear",
+            domain: [1, 9.5],
+        };
+
+    // test zero inclusion
+    s = scale(params);
+    expect(s.domain()).toEqual([0, 9.5]);
+    s = scale(util.extend({ zero: true }, params));
+    expect(s.domain()).toEqual([0, 9.5]);
+    s = scale(util.extend({ zero: false }, params));
+    expect(s.domain()).toEqual([1, 9.5]);
+
+    // test nice domain
+    s = scale(util.extend({ nice: true }, params));
+    expect(s.domain()).toEqual([0, 10]);
+
+    // test domain min/max
+    s = scale(util.extend({ domainMin: -1, domainMax: 10 }, params));
+    expect(s.domain()).toEqual([-1, 10]);
+
+    // domain min overrides zero
+    s = scale(
+        util.extend({ zero: true, domainMin: 0.5, domainMax: 10 }, params)
+    );
+    expect(s.domain()).toEqual([0.5, 10]);
+
+    // test domain mid
+    s = scale(util.extend({ domainMid: 5 }, params));
+    expect(s.domain()).toEqual([0, 5, 9.5]);
+
+    // test domain raw
+    s = scale(util.extend({ domainRaw: [2, 11] }, params));
+    expect(s.domain()).toEqual([2, 11]);
+});
+
+test("Scale respects domain padding", function () {
+    var d;
+
+    // test linear scale padding
+    d = scale({
+        type: "linear",
+        domain: [5, 95],
+        range: [0, 100],
+        padding: 5,
+        zero: false,
+    }).domain();
+    expect(d).toEqual([0, 100]);
+
+    // test log scale padding
+    d = scale({
+        type: "log",
+        domain: [1, 10],
+        range: [0, 60],
+        padding: 20,
+        zero: false,
+    }).domain();
+    expect(Math.abs(d[0] - 0.1) < 1e-8).toBeTruthy();
+    expect(Math.abs(d[1] - 100) < 1e-8).toBeTruthy();
+
+    // test sqrt scale padding
+    d = scale({
+        type: "sqrt",
+        domain: [2 * 2, 3 * 3],
+        range: [0, 60],
+        padding: 20,
+        zero: false,
+    }).domain();
+    expect(Math.abs(d[0] - 1 * 1) < 1e-8).toBeTruthy();
+    expect(Math.abs(d[1] - 4 * 4) < 1e-8).toBeTruthy();
+
+    // test power scale padding
+    d = scale({
+        type: "pow",
+        exponent: 1 / 3,
+        domain: [2 * 2 * 2, 3 * 3 * 3],
+        range: [0, 60],
+        padding: 20,
+        zero: false,
+    }).domain();
+    expect(Math.abs(d[0] - 1 * 1 * 1) < 1e-8).toBeTruthy();
+    expect(Math.abs(d[1] - 4 * 4 * 4) < 1e-8).toBeTruthy();
+});
+
+test("Ordinal scale respects domainImplicit", function () {
+    var s,
+        params = {
+            type: "ordinal",
+            domain: [],
+            range: ["a", "b", "c"],
+        };
+
+    s = scale(params);
+    expect(s("foo")).toBe(undefined);
+    expect(s("bar")).toBe(undefined);
+    expect(s("foo")).toBe(undefined);
+
+    s = scale(util.extend({ domainImplicit: false }, params));
+    expect(s("foo")).toBe(undefined);
+    expect(s("bar")).toBe(undefined);
+    expect(s("foo")).toBe(undefined);
+
+    s = scale(util.extend({ domainImplicit: true }, params));
+    expect(s("foo")).toBe("a");
+    expect(s("bar")).toBe("b");
+    expect(s("foo")).toBe("a");
+});
+
+test("Scale respects range configuration", function () {
+    var s,
+        params = {
+            type: "linear",
+            domain: [0, 10],
+            range: [0, 10],
+        };
+
+    // round
+    s = scale(params);
+    expect(s(0.5)).toBe(0.5);
+    s = scale(util.extend({ round: true }, params));
+    expect(s(0.5)).toBe(1);
+
+    // reverse
+    s = scale(util.extend({ reverse: true }, params));
+    expect(s.range()).toEqual([10, 0]);
+
+    // rangeStep
+    params = {
+        type: "band",
+        domain: ["a", "b", "c"],
+        rangeStep: 20,
+        padding: 0,
+    };
+    s = scale(params);
+    expect(s.range()).toEqual([0, 60]);
+    expect(s.bandwidth()).toBe(20);
+
+    s = expect(function () {
+        scale(util.extend({}, params, { type: "linear" }));
+    }).toThrow();
+});
+
+test("Scale respects range color schemes", function () {
+    var s, u, v;
+
+    // performs scheme lookup
+    s = scale({ type: "ordinal", scheme: "category10" });
+    expect(s.range().length).toBe(10);
+
+    // throws on invalid scheme
+    expect(function () {
+        scale({ type: "ordinal", scheme: "foobarbaz" });
+    }).toThrow();
+    expect(function () {
+        scale({ type: "sequential", scheme: "foobarbaz" });
+    }).toThrow();
+
+    // handles interpolating schemes and extents
+    s = scale({ type: "sequential", scheme: "viridis" });
+    u = s.interpolator();
+    expect(typeof u).toBe("function");
+
+    s = scale({
+        type: "sequential",
+        scheme: "viridis",
+        schemeExtent: [0.2, 0.9],
+    });
+    v = s.interpolator();
+    expect(typeof v).toBe("function");
+    expect(v(0)).toBe(u(0.2));
+    expect(v(1)).toBe(u(0.9));
+
+    s = scale({
+        type: "sequential",
+        scheme: "viridis",
+        schemeExtent: [0.2, 0.9],
+        reverse: true,
+    });
+    v = s.interpolator();
+    expect(typeof v).toBe("function");
+    expect(v(0)).toBe(u(0.9));
+    expect(v(1)).toBe(u(0.2));
+
+    // generate interpolator as needed
+    s = scale({ type: "sequential", range: ["#000", "#f00"] });
+    v = s.interpolator();
+    expect(typeof v).toBe("function");
+    expect(v(0)).toBe("rgb(0, 0, 0)");
+    expect(v(1)).toBe("rgb(255, 0, 0)");
+
+    // quantize to provided scheme count
+    s = scale({ type: "quantize", scheme: "viridis", schemeCount: 3 });
+    v = s.range();
+    expect(v.length).toBe(3);
+    expect(v[0]).toBe(u(1 / 4));
+    expect(v[1]).toBe(u(2 / 4));
+    expect(v[2]).toBe(u(3 / 4));
+});
+
+test("Scale warns for zero in log domain", function () {
+    function logScale(domain) {
+        const logger = {
+            count: 0,
+            warn: function (msg) {
+                this.count++;
+            },
+        };
+
+        return function () {
+            scale({ type: "log", domain: domain }, logger);
+            if (logger.count) {
+                throw new Error();
+            }
+        };
+    }
+
+    expect(logScale([0, 1])).toThrow();
+    expect(logScale([-1, 0])).toThrow();
+    expect(logScale([-1, 1])).toThrow();
+    expect(logScale([1, 0, 2])).toThrow();
+    expect(logScale([1, 2])).not.toThrow();
+    expect(logScale([-2, -1])).not.toThrow();
+});
+
+test("Scale infers scale key from type, domain, and range", function () {
+    function key(params) {
+        return scale(params).type;
+    }
+
+    // numeric domain scales should adapt
+    [vs.Linear, vs.Log, vs.Pow, vs.Sqrt, vs.Symlog].forEach(function (st) {
+        expect(key({ type: st, domain: [0, 1], range: [0, 1] })).toBe(st);
+        expect(key({ type: st, domain: [0, 1], range: [true, false] })).toBe(
+            st
+        );
+
+        // direct color range specification
+        expect(key({ type: st, domain: [0, 1], range: ["blue", "red"] })).toBe(
+            `${vs.Sequential}-${st}`
+        );
+        expect(
+            key({ type: st, domain: [0, 1, 2], range: ["blue", "red"] })
+        ).toBe(`${vs.Diverging}-${st}`);
+        expect(
+            key({ type: st, domain: [0, 1, 2, 3], range: ["blue", "red"] })
+        ).toBe(st);
+
+        // color scheme range specification
+        expect(key({ type: st, domain: [0, 1], scheme: "blues" })).toBe(
+            `${vs.Sequential}-${st}`
+        );
+        expect(key({ type: st, domain: [0, 1, 2], scheme: "blues" })).toBe(
+            `${vs.Diverging}-${st}`
+        );
+        expect(key({ type: st, domain: [0, 1, 2, 3], scheme: "blues" })).toBe(
+            st
+        );
+    });
+
+    // temporal domain scales should not adapt
+    [vs.Time, vs.UTC].forEach(function (st) {
+        const t0 = new Date(2010, 0, 1),
+            t1 = new Date(2011, 0, 1),
+            t2 = new Date(2012, 0, 1),
+            t3 = new Date(2013, 0, 1);
+
+        expect(key({ type: st, domain: [t0, t1], range: [0, 1] })).toBe(st);
+        expect(key({ type: st, domain: [t0, t1], range: [true, false] })).toBe(
+            st
+        );
+
+        // direct color range specification
+        expect(
+            key({ type: st, domain: [t0, t1], range: ["blue", "red"] })
+        ).toBe(st);
+        expect(
+            key({ type: st, domain: [t0, t1, t2], range: ["blue", "red"] })
+        ).toBe(st);
+        expect(
+            key({ type: st, domain: [t0, t1, t2, t3], range: ["blue", "red"] })
+        ).toBe(st);
+
+        // color scheme range specification
+        expect(key({ type: st, domain: [t0, t1], scheme: "blues" })).toBe(st);
+        expect(key({ type: st, domain: [t0, t1, t2], scheme: "blues" })).toBe(
+            st
+        );
+        expect(
+            key({ type: st, domain: [t0, t1, t2, t3], scheme: "blues" })
+        ).toBe(st);
+    });
+
+    // sequential should work for backwards compatibility
+    const st = vs.Sequential;
+    expect(key({ type: st, domain: [0, 1], range: ["blue", "red"] })).toBe(
+        `${st}-${vs.Linear}`
+    );
+    expect(key({ type: st, domain: [0, 1], scheme: "blues" })).toBe(
+        `${st}-${vs.Linear}`
+    );
+});

package/dist/src/scale/ticks.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Determine the tick count or interval function.
+ *
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate tick values.
+ * @param {number | {step: number, interval: number}} count - The desired tick count or interval specifier.
+ * @param {number} minStep - The desired minimum step between tick values.
+ * @return {*} - The tick count or interval function.
+ */
+export function tickCount(scale: any, count: number | {
+    step: number;
+    interval: number;
+}, minStep: number): any;
+/**
+ * Filter a set of candidate tick values, ensuring that only tick values
+ * that lie within the scale range are included.
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate tick values.
+ * @param {Array<*>} ticks - The candidate tick values.
+ * @param {*} count - The tick count or interval function.
+ * @return {Array<*>} - The filtered tick values.
+ */
+export function validTicks(scale: any, ticks: Array<any>, count: any): Array<any>;
+/**
+ * Generate tick values for the given scale and approximate tick count or
+ * interval value. If the scale has a 'ticks' method, it will be used to
+ * generate the ticks, with the count argument passed as a parameter. If the
+ * scale lacks a 'ticks' method, the full scale domain will be returned.
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate tick values.
+ * @param {*} [count] - The approximate number of desired ticks.
+ * @return {any[]} - The generated tick values.
+ */
+export function tickValues(scale: any, count?: any): any[];
+/**
+ * Generate a label format function for a scale. If the scale has a
+ * 'tickFormat' method, it will be used to generate the formatter, with the
+ * count and specifier arguments passed as parameters. If the scale lacks a
+ * 'tickFormat' method, the returned formatter performs simple string coercion.
+ * If the input scale is a logarithmic scale and the format specifier does not
+ * indicate a desired decimal precision, a special variable precision formatter
+ * that automatically trims trailing zeroes will be generated.
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate the label formatter.
+ * @param {*} [count] - The approximate number of desired ticks.
+ * @param {string} [specifier] - The format specifier. Must be a legal d3
+ *   specifier string (see https://github.com/d3/d3-format#formatSpecifier).
+ * @return {function(*):string} - The generated label formatter.
+ */
+export function tickFormat(scale: any, count?: any, specifier?: string): (arg0: any) => string;
+//# sourceMappingURL=ticks.d.ts.map

package/dist/src/scale/ticks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticks.d.ts","sourceRoot":"","sources":["../../../src/scale/ticks.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,6CAJW,MAAM,GAAG;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,WACzC,MAAM,OAgBhB;AAED;;;;;;;GAOG;AACH,8CAJW,UAAQ,eAEP,UAAQ,CA+BnB;AAED;;;;;;;;GAQG;AACH,qDAFY,GAAG,EAAE,CAQhB;AAmBD;;;;;;;;;;;;;GAaG;AACH,gEAJW,MAAM,kBAEO,MAAM,CAe7B"}

package/dist/src/scale/ticks.js

@@ -0,0 +1,203 @@
+/*!
+ * Adapted from vega-encode:
+ * https://github.com/vega/vega/blob/master/packages/vega-encode/src/ticks.js
+ *
+ * Copyright (c) 2015-2018, University of Washington Interactive Data Lab
+ * All rights reserved.
+ *
+ * BSD-3-Clause License: https://github.com/vega/vega-lite/blob/master/LICENSE
+ */
+
+/* eslint-disable */
+// @ts-nocheck
+
+// This file is a mess
+// TODO: Fix types, etc.
+
+import { isLogarithmic } from "vega-scale";
+import { error, isNumber, isObject, isString, peek, span } from "vega-util";
+import { format as numberFormat, formatSpecifier } from "d3-format";
+
+/**
+ * Determine the tick count or interval function.
+ *
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate tick values.
+ * @param {number | {step: number, interval: number}} count - The desired tick count or interval specifier.
+ * @param {number} minStep - The desired minimum step between tick values.
+ * @return {*} - The tick count or interval function.
+ */
+export function tickCount(scale, count, minStep) {
+    var step;
+
+    if (isNumber(count) && minStep != null) {
+        count = Math.min(count, ~~(span(scale.domain()) / minStep) || 1);
+    }
+
+    if (isObject(count)) {
+        step = count.step;
+        count = count.interval;
+    }
+
+    return count;
+}
+
+/**
+ * Filter a set of candidate tick values, ensuring that only tick values
+ * that lie within the scale range are included.
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate tick values.
+ * @param {Array<*>} ticks - The candidate tick values.
+ * @param {*} count - The tick count or interval function.
+ * @return {Array<*>} - The filtered tick values.
+ */
+export function validTicks(scale, ticks, count) {
+    var range = scale.range(),
+        lo = Math.floor(range[0]),
+        hi = Math.ceil(peek(range));
+
+    if (lo > hi) {
+        range = hi;
+        hi = lo;
+        lo = range;
+    }
+
+    ticks = ticks.filter(function (v) {
+        v = scale(v);
+        return lo <= v && v <= hi;
+    });
+
+    if (count > 0 && ticks.length > 1) {
+        var endpoints = [ticks[0], peek(ticks)];
+        while (ticks.length > count && ticks.length >= 3) {
+            ticks = ticks.filter(function (_, i) {
+                return !(i % 2);
+            });
+        }
+        if (ticks.length < 3) {
+            ticks = endpoints;
+        }
+    }
+
+    return ticks;
+}
+
+/**
+ * Generate tick values for the given scale and approximate tick count or
+ * interval value. If the scale has a 'ticks' method, it will be used to
+ * generate the ticks, with the count argument passed as a parameter. If the
+ * scale lacks a 'ticks' method, the full scale domain will be returned.
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate tick values.
+ * @param {*} [count] - The approximate number of desired ticks.
+ * @return {any[]} - The generated tick values.
+ */
+export function tickValues(scale, count) {
+    return scale.bins
+        ? validTicks(scale, binValues(scale.bins, count))
+        : scale.ticks
+        ? scale.ticks(count)
+        : scale.domain();
+}
+
+/**
+ * Generate tick values for an array of bin values.
+ * @param {Array<*>} bins - An array of bin boundaries.
+ * @param {Number} [count] - The approximate number of desired ticks.
+ * @return {Array<*>} - The generated tick values.
+ */
+function binValues(bins, count) {
+    var n = bins.length,
+        stride = ~~(n / (count || n));
+
+    return stride < 2
+        ? bins.slice()
+        : bins.filter(function (x, i) {
+              return !(i % stride);
+          });
+}
+
+/**
+ * Generate a label format function for a scale. If the scale has a
+ * 'tickFormat' method, it will be used to generate the formatter, with the
+ * count and specifier arguments passed as parameters. If the scale lacks a
+ * 'tickFormat' method, the returned formatter performs simple string coercion.
+ * If the input scale is a logarithmic scale and the format specifier does not
+ * indicate a desired decimal precision, a special variable precision formatter
+ * that automatically trims trailing zeroes will be generated.
+ * @param {import("../encoder/encoder").VegaScale} scale - The scale for which to generate the label formatter.
+ * @param {*} [count] - The approximate number of desired ticks.
+ * @param {string} [specifier] - The format specifier. Must be a legal d3
+ *   specifier string (see https://github.com/d3/d3-format#formatSpecifier).
+ * @return {function(*):string} - The generated label formatter.
+ */
+export function tickFormat(scale, count, specifier) {
+    var format = scale.tickFormat
+        ? scale.tickFormat(count, specifier)
+        : specifier
+        ? numberFormat(specifier)
+        : String;
+
+    if (isLogarithmic(scale.type)) {
+        var logfmt = variablePrecision(specifier);
+        format = scale.bins ? logfmt : filter(format, logfmt);
+    }
+
+    return format;
+}
+
+function filter(sourceFormat, targetFormat) {
+    return function (_) {
+        return sourceFormat(_) ? targetFormat(_) : "";
+    };
+}
+
+function variablePrecision(specifier) {
+    var s = formatSpecifier(specifier || ",");
+
+    if (s.precision == null) {
+        s.precision = 12;
+        switch (s.type) {
+            case "%":
+                s.precision -= 2;
+                break;
+            case "e":
+                s.precision -= 1;
+                break;
+        }
+        return trimZeroes(
+            numberFormat(s), // number format
+            numberFormat(".1f")(1)[1] // decimal point character
+        );
+    } else {
+        return numberFormat(s);
+    }
+}
+
+function trimZeroes(format, decimalChar) {
+    return function (x) {
+        var str = format(x),
+            dec = str.indexOf(decimalChar),
+            idx,
+            end;
+
+        if (dec < 0) return str;
+
+        idx = rightmostDigit(str, dec);
+        end = idx < str.length ? str.slice(idx) : "";
+        while (--idx > dec)
+            if (str[idx] !== "0") {
+                ++idx;
+                break;
+            }
+
+        return str.slice(0, idx) + end;
+    };
+}
+
+function rightmostDigit(str, dec) {
+    var i = str.lastIndexOf("e"),
+        c;
+    if (i > 0) return i;
+    for (i = str.length; --i > dec; ) {
+        c = str.charCodeAt(i);
+        if (c >= 48 && c <= 57) return i + 1; // is digit
+    }
+}

package/dist/src/scale/ticks.test.js

@@ -0,0 +1,40 @@
+import { expect, test } from "vitest";
+/*!
+ * Adapted from vega-encode:
+ * https://github.com/vega/vega/blob/master/packages/vega-encode/test/scale-test.js
+ *
+ * Copyright (c) 2015-2018, University of Washington Interactive Data Lab
+ * All rights reserved.
+ *
+ * BSD-3-Clause License: https://github.com/vega/vega-lite/blob/master/LICENSE
+ */
+
+/* eslint-disable */
+
+import { validTicks } from "./ticks";
+
+test("validTicks uses count correctly", function () {
+    var data = [0, 1, 2, 3, 4, 5, 6, 7];
+
+    var identity = function (x) {
+        return x;
+    };
+    identity.range = function () {
+        return [0, 10];
+    };
+
+    var t1 = validTicks(identity, data, 5);
+    expect(t1).toEqual([0, 2, 4, 6]);
+
+    // don't change ticks if count is large
+    var t2 = validTicks(identity, data, 100);
+    expect(t2).toEqual(data);
+
+    // special case for low number of ticks
+    var t3 = validTicks(identity, data, 3);
+    expect(t3).toEqual([0, 7]);
+
+    // single tick should pass through
+    var t5 = validTicks(identity, [1], 5);
+    expect(t5).toEqual([1]);
+});

package/dist/src/singlePageApp.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=singlePageApp.d.ts.map

package/dist/src/singlePageApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singlePageApp.d.ts","sourceRoot":"","sources":["../../src/singlePageApp.js"],"names":[],"mappings":""}

package/dist/src/singlePageApp.js

@@ -0,0 +1,13 @@
+import { embed } from "./index";
+
+// This is for development purposes. Use "npm start" to launch.
+
+const specUrl = new URLSearchParams(window.location.search).get("spec");
+if (specUrl) {
+    embed(document.body, specUrl);
+} else {
+    document.body.innerHTML = `
+        <p style="color: firebrick">No 'spec' url parameter defined!</p>
+        <p>Try this one from the "static" folder, for example:
+        <a href="?spec=examples/first.json">examples/first.json</a></p>`;
+}