@genome-spy/core 0.36.0 → 0.37.0

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

@@ -0,0 +1,226 @@
+import { describe, expect, test } from "vitest";
+import Genome from "./genome";
+
+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("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/genomeStore.d.ts

@@ -0,0 +1,20 @@
+export default class GenomeStore {
+    /**
+     * @param {string} baseUrl
+     */
+    constructor(baseUrl: string);
+    /** @type {Map<string, Genome>} */
+    genomes: Map<string, Genome>;
+    baseUrl: string;
+    /**
+     * @param {import("../spec/genome").GenomeConfig} genomeConfig
+     */
+    initialize(genomeConfig: import("../spec/genome").GenomeConfig): Promise<void[]>;
+    /**
+     * @param {string} [name] If not given, a default genome is returned.
+     * @returns {Genome}
+     */
+    getGenome(name?: string): Genome;
+}
+import Genome from "./genome";
+//# sourceMappingURL=genomeStore.d.ts.map

package/dist/src/genome/genomeStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genomeStore.d.ts","sourceRoot":"","sources":["../../../src/genome/genomeStore.js"],"names":[],"mappings":"AAEA;IACI;;OAEG;IACH,qBAFW,MAAM,EAMhB;IAHG,kCAAkC;IAClC,SADW,IAAI,MAAM,EAAE,MAAM,CAAC,CACN;IACxB,gBAAsB;IAG1B;;OAEG;IAEH,yBAHW,OAAO,gBAAgB,EAAE,YAAY,mBAY/C;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAuBlB;CACJ;mBArDkB,UAAU"}

package/dist/src/genome/genomeStore.js

@@ -0,0 +1,54 @@
+import Genome from "./genome";
+
+export default class GenomeStore {
+    /**
+     * @param {string} baseUrl
+     */
+    constructor(baseUrl) {
+        /** @type {Map<string, Genome>} */
+        this.genomes = new Map();
+        this.baseUrl = baseUrl;
+    }
+
+    /**
+     * @param {import("../spec/genome").GenomeConfig} genomeConfig
+     */
+    // eslint-disable-next-line require-await
+    async initialize(genomeConfig) {
+        const genome = new Genome(genomeConfig);
+        this.genomes.set(genome.name, genome);
+
+        return Promise.all(
+            [...this.genomes.values()].map((genome) =>
+                genome.load(this.baseUrl)
+            )
+        );
+    }
+
+    /**
+     * @param {string} [name] If not given, a default genome is returned.
+     * @returns {Genome}
+     */
+    getGenome(name) {
+        if (!this.genomes.size) {
+            throw new Error("No genomes have been configured!");
+        }
+
+        if (name) {
+            const genome = this.genomes.get(name);
+            if (!genome) {
+                throw new Error(
+                    `No genome with the name ${name} has been configured!`
+                );
+            }
+            return genome;
+        } else {
+            if (this.genomes.size > 1) {
+                throw new Error(
+                    "Cannot pick a default genome! More than one have been configured!"
+                );
+            }
+            return this.genomes.values().next().value;
+        }
+    }
+}

package/dist/src/genome/locusFormat.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {import("../spec/genome").ChromosomalLocus} locus
+ */
+export function formatLocus(locus: import("../spec/genome").ChromosomalLocus): string;
+/**
+ * @param {number | import("../spec/genome").ChromosomalLocus} locus
+ */
+export function locusOrNumberToString(locus: number | import("../spec/genome").ChromosomalLocus): string;
+/**
+ * @param {import("../spec/genome").ChromosomalLocus} begin
+ * @param {import("../spec/genome").ChromosomalLocus} end
+ */
+export function formatRange(begin: import("../spec/genome").ChromosomalLocus, end: import("../spec/genome").ChromosomalLocus): string;
+//# sourceMappingURL=locusFormat.d.ts.map

package/dist/src/genome/locusFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locusFormat.d.ts","sourceRoot":"","sources":["../../../src/genome/locusFormat.js"],"names":[],"mappings":"AAKA;;GAEG;AACH,mCAFW,OAAO,gBAAgB,EAAE,gBAAgB,UAInD;AAED;;GAEG;AACH,6CAFW,MAAM,GAAG,OAAO,gBAAgB,EAAE,gBAAgB,UAM5D;AAED;;;GAGG;AACH,mCAHW,OAAO,gBAAgB,EAAE,gBAAgB,OACzC,OAAO,gBAAgB,EAAE,gBAAgB,UAWnD"}

package/dist/src/genome/locusFormat.js

@@ -0,0 +1,37 @@
+import { format as d3format } from "d3-format";
+import { isNumber } from "vega-util";
+
+const numberFormat = d3format(",d");
+
+/**
+ * @param {import("../spec/genome").ChromosomalLocus} locus
+ */
+export function formatLocus(locus) {
+    return locus.chrom + ":" + numberFormat(Math.floor(locus.pos + 1));
+}
+
+/**
+ * @param {number | import("../spec/genome").ChromosomalLocus} locus
+ */
+export function locusOrNumberToString(locus) {
+    return !isNumber(locus) && "chrom" in locus
+        ? formatLocus(locus)
+        : "" + locus;
+}
+
+/**
+ * @param {import("../spec/genome").ChromosomalLocus} begin
+ * @param {import("../spec/genome").ChromosomalLocus} end
+ */
+export function formatRange(begin, end) {
+    return (
+        begin.chrom +
+        ":" +
+        numberFormat(Math.floor(begin.pos + 1)) +
+        "-" +
+        (begin.chrom != end.chrom ? end.chrom + ":" : "") +
+        numberFormat(Math.ceil(end.pos))
+    );
+}
+
+// TODO: parseLocus, parseRange

package/dist/src/genome/scaleIndex.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a "index" scale, which works similarly to d3's band scale but the domain
+ * consists of integer indexes.
+ */
+export default function scaleIndex(): import("./scaleIndex").ScaleIndex;
+//# sourceMappingURL=scaleIndex.d.ts.map

package/dist/src/genome/scaleIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaleIndex.d.ts","sourceRoot":"","sources":["../../../src/genome/scaleIndex.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wEA2JC"}

package/dist/src/genome/scaleIndex.js

@@ -0,0 +1,165 @@
+import { ticks as d3ticks, tickStep, extent } from "d3-array";
+import { format as d3format } from "d3-format";
+
+const minimumDomainSpan = 1;
+
+/**
+ * Creates a "index" scale, which works similarly to d3's band scale but the domain
+ * consists of integer indexes.
+ */
+export default function scaleIndex() {
+    let domain = [0, 1];
+    let range = [0, 1];
+
+    let domainSpan = 1;
+    let rangeSpan = 1;
+
+    let paddingInner = 0;
+    let paddingOuter = 0;
+    let align = 0.5;
+
+    /** The number of the first element. This affects the generated ticks and their labels. */
+    let numberingOffset = 0;
+
+    const scaleFunction = (/** @type {number} */ x) =>
+        ((x + align - domain[0]) / domainSpan) * rangeSpan + range[0];
+
+    /**
+     * In principle, the domain consists of integer indices. However,
+     * we accept real numbers so that items can be centered inside a band.
+     *
+     * @type {import("./scaleIndex").ScaleIndex}
+     */
+    const scale = /** @type {any} */ (scaleFunction);
+
+    scale.invert = (y) =>
+        ((y - range[0]) / rangeSpan) * domainSpan + domain[0] - align;
+
+    // @ts-expect-error
+    scale.domain = function (_) {
+        if (arguments.length) {
+            domain = extent(_);
+            domainSpan = domain[1] - domain[0];
+            const uninitializedDomain = domain[0] === 0 && domain[0] === 0;
+
+            if (domainSpan < minimumDomainSpan && !uninitializedDomain) {
+                domainSpan = minimumDomainSpan;
+                const centroid = (domain[0] + domain[1]) / 2;
+                domain[0] = centroid - domainSpan / 2;
+                domain[1] = centroid + domainSpan / 2;
+            }
+
+            return scale;
+        } else {
+            return domain.slice();
+        }
+    };
+
+    // @ts-expect-error
+    scale.range = function (_) {
+        if (arguments.length) {
+            range = [..._];
+            rangeSpan = range[1] - range[0];
+            return scale;
+        } else {
+            return range;
+        }
+    };
+
+    // @ts-expect-error
+    scale.numberingOffset = function (_) {
+        if (arguments.length) {
+            numberingOffset = _;
+            return scale;
+        } else {
+            return numberingOffset;
+        }
+    };
+
+    // @ts-expect-error
+    scale.padding = function (_) {
+        if (arguments.length) {
+            paddingOuter = _;
+            paddingInner = Math.min(1, _);
+            return scale;
+        } else {
+            return paddingInner;
+        }
+    };
+
+    // @ts-expect-error
+    scale.paddingInner = function (_) {
+        if (arguments.length) {
+            paddingInner = Math.min(1, _);
+            return scale;
+        } else {
+            return paddingInner;
+        }
+    };
+
+    // @ts-expect-error
+    scale.paddingOuter = function (_) {
+        if (arguments.length) {
+            paddingOuter = _;
+            return scale;
+        } else {
+            return paddingOuter;
+        }
+    };
+
+    // @ts-expect-error
+    scale.align = function (_) {
+        if (arguments.length) {
+            align = Math.max(0, Math.min(1, _));
+            return scale;
+        } else {
+            return align;
+        }
+    };
+
+    scale.step = () => rangeSpan / domainSpan;
+
+    scale.bandwidth = () => scale.step();
+
+    scale.ticks = (count) => {
+        const align = /** @type {number} */ (scale.align());
+        const offset = /** @type {number} */ (scale.numberingOffset());
+        return d3ticks(
+            domain[0] - align + offset,
+            domain[1] - align + offset,
+            Math.min(count, Math.ceil(domainSpan))
+        )
+            .filter(Number.isInteger)
+            .map((x) => x - numberingOffset);
+    };
+
+    scale.tickFormat = (count, specifier) => {
+        if (specifier) {
+            throw new Error(
+                "Index scale's tickFormat does not support a specifier!"
+            );
+        }
+
+        const step = tickStep(
+            domain[0],
+            domain[1],
+            Math.min(count, Math.ceil(domainSpan))
+        );
+        // Use higher display precision for smaller spans
+        // TODO: max absolute value should be taken into account too. 2.00M vs 200M
+        const numberFormat = step < 100000 ? d3format(",") : d3format(".3s");
+
+        return /** @param {number} x */ (x) =>
+            numberFormat(x + numberingOffset);
+    };
+
+    scale.copy = () =>
+        scaleIndex()
+            .domain(domain)
+            .range(range)
+            .paddingInner(paddingInner)
+            .paddingOuter(paddingOuter)
+            .numberingOffset(numberingOffset);
+
+    return scale;
+}

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

@@ -0,0 +1,78 @@
+import { expect, test } from "vitest";
+import scaleIndex from "./scaleIndex";
+
+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.d.ts

@@ -0,0 +1,3 @@
+export default function scaleLocus(): import("./scaleLocus").ScaleLocus;
+export function isScaleLocus(scale: any): scale is import("./scaleLocus").ScaleLocus;
+//# sourceMappingURL=scaleLocus.d.ts.map

package/dist/src/genome/scaleLocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaleLocus.d.ts","sourceRoot":"","sources":["../../../src/genome/scaleLocus.js"],"names":[],"mappings":"AAIA,wEAyFC;AAlFU,qFAEM"}