@genome-spy/core 0.29.0 → 0.30.2

package/src/scale/scale.test.js

@@ -1,324 +0,0 @@
-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/src/scale/ticks.js

@@ -1,203 +0,0 @@
-/*!
- * 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/src/scale/ticks.test.js

@@ -1,40 +0,0 @@
-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/src/singlePageApp.js

@@ -1,13 +0,0 @@
-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>`;
-}