@genome-spy/core 0.65.0 → 0.66.1

package/dist/src/genome/genome.test.js

@@ -1,268 +0,0 @@
-import { afterAll, describe, expect, test, vi } from "vitest";
-import Genome from "./genome.js";
-
-describe("Human genome, chromosome names prefixed with 'chr'", () => {
-    // Actually, the chromosomes are just named as in hg38, for example
-    const chromosomes = [
-        { name: "chr1", size: 10 },
-        { name: "chr2", size: 20 },
-        { name: "chr3", size: 30 },
-        { name: "chrX", size: 40 },
-    ];
-
-    const g = new Genome({ name: "random", contigs: chromosomes });
-
-    test("Maps chromosome names to continuous", () => {
-        expect(() => g.toContinuous("chr0", 2)).toThrow();
-        expect(g.toContinuous("chr1", 0)).toEqual(0);
-        expect(g.toContinuous("chr1", 2)).toEqual(2);
-        expect(g.toContinuous("chr2", 2)).toEqual(12);
-        expect(g.toContinuous("chrX", 2)).toEqual(62);
-        // TODO: Should this throw to alert about invalid data..?
-        // TODO: expect(m.toContinuous("chrX", 40)).toBeUndefined();
-    });
-
-    test("Maps chromosome numbers to continuous", () => {
-        expect(() => g.toContinuous(0, 2)).toThrow();
-        expect(g.toContinuous(1, 2)).toEqual(2);
-        expect(g.toContinuous(2, 2)).toEqual(12);
-        expect(g.toContinuous(4, 2)).toEqual(62);
-        expect(() => g.toContinuous(5, 2)).toThrow();
-    });
-
-    test("Maps unprefixed names to continuous", () => {
-        expect(() => g.toContinuous("0", 2)).toThrow();
-        expect(g.toContinuous("1", 2)).toEqual(2);
-        expect(g.toContinuous("2", 2)).toEqual(12);
-        expect(g.toContinuous("X", 2)).toEqual(62);
-        expect(() => g.toContinuous("Y", 2)).toThrow();
-    });
-
-    test("Maps string positions to continuous", () => {
-        expect(g.toContinuous("2", /** @type {any} */ ("2"))).toEqual(12);
-    });
-
-    test("Maps continuous to chromosome and locus", () => {
-        expect(g.toChromosomal(-1)).toBeUndefined();
-        expect(g.toChromosomal(0)).toEqual({ chrom: "chr1", pos: 0 });
-        expect(g.toChromosomal(12)).toEqual({ chrom: "chr2", pos: 2 });
-        expect(g.toChromosomal(29)).toEqual({ chrom: "chr2", pos: 19 });
-        expect(g.toChromosomal(30)).toEqual({ chrom: "chr3", pos: 0 });
-        expect(g.toChromosomal(62)).toEqual({ chrom: "chrX", pos: 2 });
-        expect(g.toChromosomal(99)).toEqual({ chrom: "chrX", pos: 39 });
-
-        // Special handling for the end of the genome. Pos 40 does not exist in chrX
-        // but we need for the endpoint of half-open interval covering the whole genome.
-        expect(g.toChromosomal(100)).toEqual({ chrom: "chrX", pos: 40 });
-        expect(g.toChromosomal(101)).toBeUndefined();
-    });
-
-    // Testing half-open intervals
-    test("Maps continuous interval to chromosomal interval", () => {
-        expect(g.toChromosomalInterval([0, 10])).toEqual([
-            { chrom: "chr1", pos: 0 },
-            { chrom: "chr1", pos: 10 },
-        ]);
-        expect(g.toChromosomalInterval([10, 100])).toEqual([
-            { chrom: "chr2", pos: 0 },
-            { chrom: "chrX", pos: 40 },
-        ]);
-        expect(g.toChromosomalInterval([0, 100])).toEqual([
-            { chrom: "chr1", pos: 0 },
-            { chrom: "chrX", pos: 40 },
-        ]);
-    });
-
-    test("Maps interval with fractional parts to chromosomal interval", () => {
-        expect(g.toChromosomalInterval([0.1, 99.9])).toEqual([
-            { chrom: "chr1", pos: 0 },
-            { chrom: "chrX", pos: 40 },
-        ]);
-        expect(g.toChromosomalInterval([0.6, 99.4])).toEqual([
-            { chrom: "chr1", pos: 1 },
-            { chrom: "chrX", pos: 39 },
-        ]);
-    });
-
-    test("Maps chromosomal interval to continuous interval", () => {
-        expect(
-            g.toContinuousInterval([
-                { chrom: "chr1", pos: 0 },
-                { chrom: "chr1", pos: 10 },
-            ])
-        ).toEqual([0, 10]);
-        expect(
-            g.toContinuousInterval([
-                { chrom: "chr1", pos: 1 },
-                { chrom: "chr1", pos: 9 },
-            ])
-        ).toEqual([1, 9]);
-        expect(
-            g.toContinuousInterval([
-                { chrom: "chr2", pos: 0 },
-                { chrom: "chrX", pos: 40 },
-            ])
-        ).toEqual([10, 100]);
-        expect(
-            g.toContinuousInterval([
-                { chrom: "chr1", pos: 0 },
-                { chrom: "chrX", pos: 40 },
-            ])
-        ).toEqual([0, 100]);
-    });
-
-    test("Maps chromosomal interval without positions to continuous interval", () => {
-        expect(
-            g.toContinuousInterval([{ chrom: "chr1" }, { chrom: "chr1" }])
-        ).toEqual([0, 10]);
-        expect(
-            g.toContinuousInterval([{ chrom: "chr2" }, { chrom: "chrX" }])
-        ).toEqual([10, 100]);
-    });
-
-    test("Returns a properly annotated chromosomes array", () => {
-        expect(g.chromosomes[1]).toEqual({
-            name: "chr2",
-            size: 20,
-            index: 1,
-            number: 2,
-            continuousStart: 10,
-            continuousEnd: 30,
-            continuousInterval: [10, 30],
-            odd: false,
-        });
-    });
-
-    test("Splits a genomic interval into discrete chromosome intervals, single chromosome", () => {
-        expect(
-            g.toDiscreteChromosomeIntervals([
-                { chrom: "chr2", pos: 5 },
-                { chrom: "chr2", pos: 15 },
-            ])
-        ).toEqual([{ chrom: "chr2", startPos: 5, endPos: 15 }]);
-    });
-
-    test("Splits a genomic interval into discrete chromosome intervals, two chromosomes", () => {
-        expect(
-            g.toDiscreteChromosomeIntervals([
-                { chrom: "chr2", pos: 5 },
-                { chrom: "chr3", pos: 15 },
-            ])
-        ).toEqual([
-            { chrom: "chr2", startPos: 5, endPos: 20 },
-            { chrom: "chr3", startPos: 0, endPos: 15 },
-        ]);
-    });
-
-    test("Splits a genomic interval into discrete chromosome intervals, three chromosomes", () => {
-        expect(
-            g.toDiscreteChromosomeIntervals([
-                { chrom: "chr2", pos: 5 },
-                { chrom: "chrX", pos: 15 },
-            ])
-        ).toEqual([
-            { chrom: "chr2", startPos: 5, endPos: 20 },
-            { chrom: "chr3", startPos: 0, endPos: 30 },
-            { chrom: "chrX", startPos: 0, endPos: 15 },
-        ]);
-    });
-});
-
-describe("C. elegans genome, chromosome names prefixed with 'chr'", () => {
-    const chromosomes = [
-        { name: "chrI", size: 15072434 },
-        { name: "chrII", size: 15279421 },
-        { name: "chrIII", size: 13783801 },
-        { name: "chrIV", size: 17493829 },
-        { name: "chrV", size: 20924180 },
-        { name: "chrX", size: 17718942 },
-        { name: "chrM", size: 13794 },
-    ];
-
-    const g = new Genome({ name: "random", contigs: chromosomes });
-
-    test("Maps chromosome names to continuous", () => {
-        expect(g.toContinuous("chrIII", 10)).toEqual(30351865);
-    });
-
-    test("Maps unprefixed names to continuous", () => {
-        expect(g.toContinuous("III", 10)).toEqual(30351865);
-    });
-});
-
-describe("Load chrom.sizes file from a URL", () => {
-    const fetchSpy = vi.spyOn(global, "fetch");
-    fetchSpy.mockImplementation((/** @type {string} */ url) => {
-        if (url !== "http://example.com/chrom.sizes") {
-            throw new Error(`Unexpected URL: ${url}`);
-        }
-        return Promise.resolve(
-            // @ts-expect-error
-            {
-                text() {
-                    return Promise.resolve(
-                        "chr1\t1000\nchr2\t2000\nchr3\t3000\nchrX\t4000"
-                    );
-                },
-                ok: true,
-            }
-        );
-    });
-
-    afterAll(() => {
-        fetchSpy.mockRestore();
-    });
-
-    test("Throw if the deprecated baseUrl property is provided", () => {
-        expect(
-            () =>
-                new Genome({
-                    name: "random",
-                    // @ts-expect-error
-                    baseUrl: "http://example.com",
-                })
-        ).toThrow(/removed/);
-    });
-
-    test("Loads and parses a genome", async () => {
-        const g = new Genome({ name: "random", url: "chrom.sizes" });
-        await g.load("http://example.com");
-
-        expect(g.parseInterval("chr2")).toEqual([1000, 3000]);
-    });
-});
-
-describe("Parse interval strings", () => {
-    const chromosomes = [
-        { name: "chr1", size: 1000 },
-        { name: "chr2", size: 2000 },
-        { name: "chr3", size: 3000 },
-        { name: "chrX", size: 4000 },
-    ];
-
-    const g = new Genome({ name: "random", contigs: chromosomes });
-
-    test("Parses a single chromosome, returns an interval spanning the chromosome", () => {
-        expect(g.parseInterval("chr2")).toEqual([1000, 3000]);
-    });
-
-    test("Returns undefined on unknown chromosome", () => {
-        expect(g.parseInterval("chrZ")).toBeUndefined();
-    });
-
-    test("Parses a single coordinate without a thousand separator", () => {
-        expect(g.parseInterval("chr2:1500")).toEqual([2499, 2500]);
-    });
-
-    test("Parses a single coordinate with a thousand separator", () => {
-        expect(g.parseInterval("chr2:1,500")).toEqual([2499, 2500]);
-    });
-
-    test("Parses an interval within a single chromosome", () => {
-        expect(g.parseInterval("chr2:1,500-1,700")).toEqual([2499, 2700]);
-    });
-
-    test("Parses an interval spanning multiple chromosomes", () => {
-        expect(g.parseInterval("chr2:1,500-chr3:1,500")).toEqual([2499, 4500]);
-    });
-});

package/dist/src/genome/genomes.test.js

@@ -1,8 +0,0 @@
-import { expect, test } from "vitest";
-import { getContigs } from "./genomes.js";
-
-test("getContigs", () => {
-    expect(getContigs("mm10")[0]).toEqual({ name: "chr1", size: 195471971 });
-    expect(getContigs("mm10")[5]).toEqual({ name: "chr6", size: 149736546 });
-    expect(getContigs("hg38")[19]).toEqual({ name: "chr20", size: 64444167 });
-});

package/dist/src/genome/scaleIndex.test.js

@@ -1,78 +0,0 @@
-import { expect, test } from "vitest";
-import scaleIndex from "./scaleIndex.js";
-
-test("Scale with defaults works as expected", () => {
-    const scale = scaleIndex();
-
-    // Align is 0.5 by default
-    expect(scale(-1)).toEqual(-0.5);
-    expect(scale(0)).toEqual(0.5);
-    expect(scale(1)).toEqual(1.5);
-    expect(scale(2)).toEqual(2.5);
-});
-
-test("Scale scales correctly with custom domain and range", () => {
-    const scale = scaleIndex().domain([0, 10]).range([100, 200]).align(0.0);
-
-    expect(scale(0)).toEqual(100);
-    expect(scale(10)).toEqual(200);
-});
-
-test("Invert works as expected", () => {
-    const scale = scaleIndex().domain([0, 10]).range([100, 200]).align(0.0);
-
-    expect(scale.invert(scale(0))).toEqual(0);
-    expect(scale.invert(scale(5))).toEqual(5);
-    expect(scale.invert(scale(10))).toEqual(10);
-});
-
-test("Scale scales correctly with custom domain, range, and align", () => {
-    const scale = scaleIndex().domain([0, 10]).range([100, 200]).align(0.5);
-
-    expect(scale(0)).toEqual(105);
-    expect(scale(10)).toEqual(205);
-});
-
-test("Invert works as expected with align", () => {
-    const scale = scaleIndex().domain([0, 10]).range([100, 200]).align(0.5);
-
-    expect(scale.invert(scale(0))).toEqual(0);
-    expect(scale.invert(scale(5))).toEqual(5);
-    expect(scale.invert(scale(10))).toEqual(10);
-});
-
-test("domain() accepts numeric ordinal domain and computes its extent", () => {
-    const scale = scaleIndex().domain([7, 3, 5, 9, 8]);
-    expect(scale.domain()).toEqual([3, 9]);
-});
-
-test("domain() clamps the minimum domain span to one", () => {
-    const scale = scaleIndex().domain([1.25, 1.75]);
-    expect(scale.domain()).toEqual([1, 2]);
-
-    scale.domain([1.75, 2.25]);
-    expect(scale.domain()).toEqual([1.5, 2.5]);
-});
-
-test("ticks() produces integer values", () => {
-    const scale = scaleIndex().domain([0, 5]).numberingOffset(0);
-
-    expect(scale.ticks(5)).toEqual([0, 1, 2, 3, 4]);
-    expect(scale.ticks(100)).toEqual([0, 1, 2, 3, 4]);
-});
-
-test("ticks() take numberingOffset into account", () => {
-    const scale = scaleIndex().domain([10, 15]).numberingOffset(1);
-
-    // The ticks have been offset so that nice labels can be generated (5, 10, 15, ...)
-    expect(scale.ticks(5)).toEqual([10, 11, 12, 13, 14]);
-});
-
-test("tickFormat() takes numberingOffset into account", () => {
-    const scale = scaleIndex().domain([10, 15]).numberingOffset(1);
-
-    const format = scale.tickFormat(5);
-
-    // Although the ticks have been offset, the labels should be nice
-    expect(scale.ticks(5).map(format)).toEqual(["11", "12", "13", "14", "15"]);
-});

package/dist/src/genome/scaleLocus.test.js

@@ -1,4 +0,0 @@
-import { test } from "vitest";
-import scaleLocus from "./scaleLocus.js";
-
-test.todo("Write some tests!");

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

@@ -1,326 +0,0 @@
-// @ts-nocheck
-
-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.js";
-
-// 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}`
-    );
-});