@genome-spy/core 0.29.0 → 0.30.2

package/src/genome/scaleIndex.js

@@ -1,166 +0,0 @@
-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.
- *
- * @returns {import("./scaleIndex").ScaleIndex}
- */
-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];
-
-            if (domainSpan < minimumDomainSpan) {
-                domainSpan = minimumDomainSpan;
-                const centroid = (domain[0] + domain[1]) / 2;
-                domain[0] = centroid - domainSpan / 2;
-                domain[1] = centroid + domainSpan / 2;
-            }
-
-            return scale;
-        } else {
-            return domain;
-        }
-    };
-
-    // @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/src/genome/scaleIndex.test.js

@@ -1,78 +0,0 @@
-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/src/genome/scaleLocus.d.ts

@@ -1,11 +0,0 @@
-import Genome from "./genome";
-import { ScaleIndex } from "./scaleIndex";
-
-export default function scaleLocus(): ScaleLocus;
-
-export interface ScaleLocus extends ScaleIndex {
-    genome(): Genome;
-    genome(genome: Genome): this;
-}
-
-export function isScaleLocus(scale: any): scale is ScaleLocus;

package/src/genome/scaleLocus.js

@@ -1,108 +0,0 @@
-import { tickStep } from "d3-array";
-import { format as d3format } from "d3-format";
-import scaleIndex from "./scaleIndex.js";
-
-/**
- * Creates a "locus" scale, which works similarly to band scale but the domain
- * consists of integer indexes.
- *
- * @typedef {import("./genome").default} Genome
- * @returns {import("./scaleLocus").ScaleLocus}
- */
-export default function scaleLocus() {
-    /** @type {import("./scaleLocus").ScaleLocus} */
-    const scale = /** @type {any} */ (scaleIndex().numberingOffset(1));
-
-    /** @type {Genome} */
-    let genome;
-
-    // @ts-expect-error
-    scale.genome = function (_) {
-        if (arguments.length) {
-            genome = _;
-            return scale;
-        } else {
-            return genome;
-        }
-    };
-
-    scale.ticks = (count) => {
-        if (!genome) {
-            return [];
-        }
-
-        const domain = scale.domain();
-        const numberingOffset = scale.numberingOffset();
-
-        const [minChrom, maxChrom] = [
-            Math.max(domain[0], 0),
-            Math.min(domain[1], genome.totalSize - 1),
-        ].map((x) => genome.toChromosome(x));
-
-        const step = Math.max(1, tickStep(domain[0], domain[1], count));
-
-        const ticks = [];
-
-        for (let i = minChrom.index; i <= maxChrom.index; i++) {
-            const chrom = genome.chromosomes[i];
-
-            const from = Math.max(
-                chrom.continuousStart + step,
-                domain[0] - ((domain[0] - chrom.continuousStart) % step)
-            );
-            const to = Math.min(chrom.continuousEnd - step / 4, domain[1] + 1);
-            for (let pos = from; pos <= to; pos += step) {
-                const tick = pos - numberingOffset;
-                if (tick >= domain[0] && tick < domain[1]) {
-                    ticks.push(tick);
-                }
-            }
-        }
-
-        return ticks;
-    };
-
-    scale.tickFormat = (count, specifier) => {
-        if (!genome) {
-            return;
-        }
-
-        if (specifier) {
-            throw new Error(
-                "Locus scale's tickFormat does not support a specifier!"
-            );
-        }
-
-        const domain = scale.domain();
-        const domainSpan = domain[1] - domain[0];
-        const numberingOffset = scale.numberingOffset();
-
-        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 < 1e6 ? d3format(",") : d3format(".3s");
-
-        /** @type {function(number):number} */
-        const fixer = (x) => x - genome.toChromosome(x).continuousStart;
-
-        return /** @param {number} x */ (x) =>
-            numberFormat(fixer(x) + numberingOffset);
-    };
-
-    const originalCopy = scale.copy;
-
-    scale.copy = () => originalCopy().genome(genome);
-
-    return scale;
-}
-
-/**
- * @type {import("./scaleLocus").isScaleLocus}
- */
-export function isScaleLocus(scale) {
-    return scale.type == "locus";
-}

package/src/genome/scaleLocus.test.js

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