@genome-spy/core 0.64.0 → 0.66.1

package/dist/src/encoder/accessor.test.js

@@ -1,162 +0,0 @@
-import { describe, expect, test } from "vitest";
-import ParamMediator from "../view/paramMediator.js";
-import { createAccessor, createConditionalAccessors } from "./accessor.js";
-import { UNIQUE_ID_KEY } from "../data/transforms/identifier.js";
-import { createSinglePointSelection } from "../selection/selection.js";
-
-const datum = {
-    a: 1,
-    b: 2,
-    "x.c": 3,
-};
-
-describe("Accessors for different encoding types", () => {
-    test("Creates a field accessor", () => {
-        const a = createAccessor("x", { field: "a" }, new ParamMediator());
-        expect(a(datum)).toEqual(1);
-        expect(a.constant).toBeFalsy();
-        expect(a.fields).toEqual(["a"]);
-    });
-
-    test("Creates an expression accessor", () => {
-        const a = createAccessor(
-            "x",
-            { expr: `datum.b + datum['x\.c']` },
-            new ParamMediator()
-        );
-        expect(a(datum)).toEqual(5);
-        expect(a.constant).toBeFalsy();
-        expect(a.fields.sort()).toEqual(["b", "x.c"].sort());
-    });
-
-    test("Creates a constant accessor", () => {
-        const a = createAccessor("x", { datum: 0 }, new ParamMediator());
-        expect(a(datum)).toEqual(0);
-        expect(a.constant).toBeTruthy();
-        expect(a.fields).toEqual([]);
-    });
-
-    test("Creates a value accessor", () => {
-        const a = createAccessor("x", { value: 123 }, new ParamMediator());
-        expect(a(datum)).toEqual(123);
-        expect(a.constant).toBeTruthy();
-        expect(a.fields).toEqual([]);
-    });
-});
-
-test("Throws on incomplete encoding spec", () => {
-    expect(() => createAccessor("x", {}, new ParamMediator())).toThrow();
-});
-
-// TODO: Refactor and fix conditional accessors
-describe.skip("createConditionalAccessors", () => {
-    const data = [
-        { a: 1, b: 2, [UNIQUE_ID_KEY]: 0 },
-        { a: 3, b: 4, [UNIQUE_ID_KEY]: 1 },
-    ];
-
-    const paramMediator = new ParamMediator();
-    paramMediator.allocateSetter("p", createSinglePointSelection(data[0]));
-
-    const a = createConditionalAccessors(
-        "x",
-        {
-            field: "a",
-            type: "quantitative",
-            condition: { param: "p", value: 123 },
-        },
-        paramMediator
-    );
-
-    const b = createConditionalAccessors(
-        "x",
-        {
-            field: "a",
-            type: "quantitative",
-            condition: [
-                { param: "p", value: 123 },
-                { param: "p", value: 234 },
-            ],
-        },
-        paramMediator
-    );
-
-    const c = createConditionalAccessors(
-        "x",
-        {
-            value: 123,
-            condition: {
-                param: "p",
-                field: "a",
-                type: "quantitative",
-            },
-        },
-        paramMediator
-    );
-
-    // TODO: Add more combinations of datum, field, expr, etc
-
-    test("Creates a correct number of accessors", () => {
-        expect(a.length).toBe(2);
-        expect(b.length).toBe(3);
-        expect(c.length).toBe(2);
-    });
-
-    // Conditional accessor
-    test("Conditional accessor accesses the correct field", () => {
-        expect(a[0](data[0])).toEqual(123);
-        expect(a[0].predicate.param).toEqual("p");
-    });
-
-    test("Conditional predicate is true only for the selected datum", () => {
-        expect(a[0].predicate(data[0])).toBeTruthy();
-        expect(a[0].predicate(data[1])).toBeFalsy();
-    });
-
-    // Default accessor
-    test("Default accessor accesses the correct field", () => {
-        expect(a[1](data[0])).toEqual(1);
-        expect(a[1].predicate.param).toBeFalsy();
-    });
-
-    test("Default predicate is true for all data", () => {
-        expect(a[1].predicate(data[0])).toBeTruthy();
-        expect(a[1].predicate(data[1])).toBeTruthy();
-    });
-
-    test("Throws if multiple non-constant accessors are used", () => {
-        expect(() =>
-            createConditionalAccessors(
-                "x",
-                {
-                    field: "a",
-                    type: "quantitative",
-                    condition: {
-                        param: "p",
-                        // @ts-expect-error
-                        field: "b",
-                        type: "quantitative",
-                    },
-                },
-                paramMediator
-            )
-        ).toThrow();
-
-        expect(() =>
-            createConditionalAccessors(
-                "x",
-                {
-                    field: "a",
-                    type: "quantitative",
-                    condition: {
-                        param: "p",
-                        // @ts-expect-error
-                        expr: "datum.b",
-                        type: "quantitative",
-                    },
-                },
-                paramMediator
-            )
-        ).toThrow();
-    });
-});

package/dist/src/encoder/encoder.test.js

@@ -1,105 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { createAccessor, createConditionalAccessors } from "./accessor.js";
-import ParamMediator from "../view/paramMediator.js";
-import { createEncoder, createSimpleOrConditionalEncoder } from "./encoder.js";
-import { UNIQUE_ID_KEY } from "../data/transforms/identifier.js";
-import { createSinglePointSelection } from "../selection/selection.js";
-import { isArray } from "vega-util";
-import { scaleLinear } from "d3-scale";
-
-/** @type {import("../spec/channel.js").Encoding} */
-const encoding = {
-    x: { value: 42 },
-    y: {
-        field: "a",
-        type: "quantitative",
-        scale: { domain: [0, 100], range: [0, 1] },
-    },
-    size: {
-        field: "a",
-        type: "quantitative",
-        scale: { domain: [0, 100], range: [0, 10] },
-        condition: {
-            param: "p",
-            empty: false,
-            value: 5000,
-        },
-    },
-};
-
-const scaleSource = (
-    /** @type {import("../spec/channel.js").ChannelWithScale} */ channel
-) => {
-    // @ts-ignore
-    const props = encoding[channel].scale ?? encoding[channel].condition?.scale;
-
-    return Object.assign(
-        scaleLinear().domain(props.domain).range(props.range),
-        {
-            type: "linear",
-        }
-    );
-};
-
-const datum = {
-    a: 100,
-    b: 6,
-    c: "Pink Floyd",
-    [UNIQUE_ID_KEY]: 1234,
-};
-
-describe("Encoder", () => {
-    const pm = new ParamMediator();
-    /** @type {Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>} */
-    const e = Object.fromEntries(
-        Object.entries(encoding).map(([channel, channelDef]) => {
-            const accessor = createAccessor(channel, channelDef, pm);
-            return [channel, createEncoder(accessor, scaleSource)];
-        })
-    );
-
-    test("has a single accessors", () => {
-        expect(e.x.accessors?.length).toBe(1);
-    });
-
-    test("provides a data accessor for a FieldDef", () =>
-        expect(e.y.dataAccessor.fields).toContain("a"));
-
-    test("doesn't provide a data accessor for a ValueDef", () =>
-        expect(e.x.dataAccessor).toBeUndefined());
-
-    test("returns a value", () => expect(e.x(datum)).toEqual(42));
-
-    test("accesses a field and uses a scale", () => expect(e.y(datum)).toBe(1));
-
-    // TODO: Text ExprRef
-});
-
-// TODO: Refactor and fix conditional encoders
-describe.skip("Conditional encoder with a field and a conditional value", () => {
-    const pm = new ParamMediator();
-    const setter = pm.allocateSetter("p", createSinglePointSelection(null));
-
-    const e = createSimpleOrConditionalEncoder(
-        createConditionalAccessors("size", encoding.size, pm),
-        scaleSource
-    );
-
-    test("has multiple accessors", () => {
-        expect(e.accessors.length).toBe(2);
-    });
-
-    test("accesses the field using the dataAccessor", () =>
-        expect(e.dataAccessor(datum)).toBe(100));
-
-    test("encodes the default when a predicate is false", () => {
-        setter(createSinglePointSelection(null));
-        expect(e(datum)).toBe(10);
-    });
-
-    test("encodes the conditional value when a predicate is true", () => {
-        setter(createSinglePointSelection(datum));
-        expect(e(datum)).toBe(5000);
-    });
-});

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!");