@genome-spy/core 0.65.0 → 0.67.0

package/dist/src/data/transforms/coverage.test.js

@@ -1,238 +0,0 @@
-import { describe, expect, test } from "vitest";
-import CoverageTransform from "./coverage.js";
-import { processData } from "../flowTestUtils.js";
-
-/**
- * @typedef {import("../../spec/transform.js").CoverageParams} CoverageParams
- */
-
-/**
- * @param {CoverageParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    const t = new CoverageTransform(params);
-    t.initialize();
-    return processData(t, data);
-}
-
-/**
- *
- * @param {[number, number][]} reads Start, end
- * @param {[number, number, number][]} coverageSegments Start, end, coverage
- */
-function testSimpleCoverage(reads, coverageSegments) {
-    /** @type {CoverageParams} */
-    const coverageConfig = {
-        type: "coverage",
-        start: "start",
-        end: "end",
-    };
-    expect(
-        transform(
-            coverageConfig,
-            reads.map((d) => ({
-                start: d[0],
-                end: d[1],
-            }))
-        )
-    ).toEqual(
-        coverageSegments.map((d) => ({
-            start: d[0],
-            end: d[1],
-            coverage: d[2],
-        }))
-    );
-}
-
-/**
- *
- * @param {[number, number, number][]} reads Start, end, weight
- * @param {[number, number, number][]} coverageSegments Start, end, coverage
- */
-function testWeightedCoverage(reads, coverageSegments) {
-    /** @type {CoverageParams} */
-    const coverageConfig = {
-        type: "coverage",
-        start: "start",
-        end: "end",
-        weight: "weight",
-    };
-    expect(
-        transform(
-            coverageConfig,
-            reads.map((d) => ({
-                start: d[0],
-                end: d[1],
-                weight: d[2],
-            }))
-        )
-    ).toEqual(
-        coverageSegments.map((d) => ({
-            start: d[0],
-            end: d[1],
-            coverage: d[2],
-        }))
-    );
-}
-
-describe("Coverage transform", () => {
-    test("Typical case", () =>
-        testSimpleCoverage(
-            [
-                [0, 4],
-                [1, 3],
-                [2, 6],
-                [4, 8],
-                [8, 10],
-                [11, 14],
-                [11, 13],
-                [11, 12],
-                [15, 18],
-                [16, 18],
-                [17, 18],
-            ],
-            [
-                [0, 1, 1],
-                [1, 2, 2],
-                [2, 3, 3],
-                [3, 6, 2],
-                [6, 10, 1],
-                [11, 12, 3],
-                [12, 13, 2],
-                [13, 14, 1],
-                [15, 16, 1],
-                [16, 17, 2],
-                [17, 18, 3],
-            ]
-        ));
-
-    test("Multiple identical overlapping segments", () =>
-        testSimpleCoverage(
-            [
-                [1, 2],
-                [3, 4],
-                [3, 4],
-                [5, 6],
-                [5, 6],
-                [5, 6],
-            ],
-            [
-                [1, 2, 1],
-                [3, 4, 2],
-                [5, 6, 3],
-            ]
-        ));
-
-    test("Adjacent segments with equal coverage are merged", () =>
-        testSimpleCoverage(
-            [
-                [1, 2],
-                [2, 3],
-                [3, 4],
-                [5, 6],
-                [6, 7],
-                [7, 8],
-            ],
-            [
-                [1, 4, 1],
-                [5, 8, 1],
-            ]
-        ));
-
-    test("Chromosomes pass through", () => {
-        const reads = [
-            { chrom: "chr1", start: 0, end: 1 },
-            { chrom: "chr2", start: 0, end: 1 },
-            { chrom: "chr3", start: 1, end: 3 },
-        ];
-
-        const coverageSegments = [
-            { chrom: "chr1", start: 0, end: 1, coverage: 1 },
-            { chrom: "chr2", start: 0, end: 1, coverage: 1 },
-            { chrom: "chr3", start: 1, end: 3, coverage: 1 },
-        ];
-
-        /** @type {CoverageParams} */
-        const coverageConfig = {
-            type: "coverage",
-            chrom: "chrom",
-            start: "start",
-            end: "end",
-        };
-
-        expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
-    });
-
-    test("Typical weighted coverage", () =>
-        testWeightedCoverage(
-            [
-                [0, 4, 1],
-                [1, 3, 2],
-                [2, 6, 3],
-                [8, 10, -1],
-            ],
-            [
-                [0, 1, 1],
-                [1, 2, 3],
-                [2, 3, 6],
-                [3, 4, 4],
-                [4, 6, 3],
-                [8, 10, -1],
-            ]
-        ));
-
-    test("Multiple weights at a single locus", () =>
-        testWeightedCoverage(
-            [
-                // -- Locus 1
-                [1, 2, 1],
-                [1, 2, 2],
-                [1, 2, 3],
-                [1, 2, 4],
-                [1, 2, 5],
-                // -- Locus 2
-                [2, 3, 2],
-                [2, 3, 3],
-                [2, 3, 4],
-                [2, 3, 5],
-                [2, 3, 6],
-            ],
-            [
-                // -- Locus 1
-                [1, 2, 15],
-                // -- Locus 2
-                [2, 3, 20],
-            ]
-        ));
-
-    test("Adjacent segments with different weights produce separated segments", () =>
-        testWeightedCoverage(
-            [
-                // -- Cluster 1
-                [1, 2, 2],
-                [2, 3, 1],
-                [3, 4, 1],
-                // -- Cluster 2
-                [5, 6, 1],
-                [6, 7, 2],
-                [7, 8, 1],
-                // -- Cluster 3
-                [9, 10, 1],
-                [10, 11, 1],
-                [11, 12, 2],
-            ],
-            [
-                // -- Cluster 1
-                [1, 2, 2],
-                [2, 4, 1],
-                // -- Cluster 2
-                [5, 6, 1],
-                [6, 7, 2],
-                [7, 8, 1],
-                // -- Cluster 3
-                [9, 11, 1],
-                [11, 12, 2],
-            ]
-        ));
-});

package/dist/src/data/transforms/filter.test.js

@@ -1,20 +0,0 @@
-import { expect, test } from "vitest";
-import { makeParamMediatorProvider, processData } from "../flowTestUtils.js";
-import FilterTransform from "./filter.js";
-
-test.todo("Implement stub for ParamMediator");
-
-test("FilterTransform filter rows", () => {
-    const data = [1, 2, 3, 4, 5, 6].map((x) => ({ x }));
-
-    /** @type {import("../../spec/transform.js").FilterParams} */
-    const filterParams = {
-        type: "filter",
-        expr: "datum.x > 3 && datum.x != 5",
-    };
-
-    const t = new FilterTransform(filterParams, makeParamMediatorProvider());
-    t.initialize();
-
-    expect(processData(t, data)).toEqual([4, 6].map((x) => ({ x })));
-});

package/dist/src/data/transforms/flatten.test.js

@@ -1,96 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import FlattenTransform from "./flatten.js";
-
-/**
- * @param {import("../../spec/transform.js").FlattenParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new FlattenTransform(params), data);
-}
-
-describe("Flatten transform", () => {
-    /**
-     * @typedef {import("../../spec/transform.js").FlattenParams} FlattenParams
-     */
-    test("With a single field", () => {
-        /** @type {FlattenParams} */
-        const params = { type: "flatten", fields: ["foo"] };
-
-        const input = [
-            { name: "alpha", data: 123, foo: [1, 2] },
-            { name: "beta", data: 456, foo: [3, 4, 5] },
-        ];
-
-        expect(transform(params, input)).toEqual([
-            { name: "alpha", data: 123, foo: 1 },
-            { name: "alpha", data: 123, foo: 2 },
-            { name: "beta", data: 456, foo: 3 },
-            { name: "beta", data: 456, foo: 4 },
-            { name: "beta", data: 456, foo: 5 },
-        ]);
-    });
-
-    test("With an index field", () => {
-        /** @type {FlattenParams} */
-        const params = { type: "flatten", fields: ["foo"], index: "idx" };
-
-        const input = [
-            { name: "alpha", data: 123, foo: [1, 2] },
-            { name: "beta", data: 456, foo: [3, 4, 5] },
-        ];
-
-        expect(transform(params, input)).toEqual([
-            { name: "alpha", data: 123, foo: 1, idx: 0 },
-            { name: "alpha", data: 123, foo: 2, idx: 1 },
-            { name: "beta", data: 456, foo: 3, idx: 0 },
-            { name: "beta", data: 456, foo: 4, idx: 1 },
-            { name: "beta", data: 456, foo: 5, idx: 2 },
-        ]);
-    });
-
-    test("With multiple fields", () => {
-        /** @type {FlattenParams} */
-        const params = { type: "flatten", fields: ["foo", "bar"] };
-
-        const input = [
-            { key: "alpha", foo: [1, 2], bar: ["A", "B"] },
-            { key: "beta", foo: [3, 4, 5], bar: ["C", "D"] },
-        ];
-
-        expect(transform(params, input)).toEqual([
-            { key: "alpha", foo: 1, bar: "A" },
-            { key: "alpha", foo: 2, bar: "B" },
-            { key: "beta", foo: 3, bar: "C" },
-            { key: "beta", foo: 4, bar: "D" },
-            { key: "beta", foo: 5, bar: null },
-        ]);
-    });
-
-    test("Throws on mismatching spec lengths", () => {
-        /** @type {FlattenParams} */
-        const params = {
-            type: "flatten",
-            fields: ["a", "b"],
-            as: ["a"],
-        };
-
-        expect(() => transform(params, [])).toThrow();
-    });
-
-    test("Missing fields property treats the input object as an array", () => {
-        /** @type {FlattenParams} */
-        const params = {
-            type: "flatten",
-        };
-
-        const input = [[{ a: 1 }], [{ a: 2 }, { a: 3 }]];
-
-        expect(transform(params, input)).toEqual([
-            { a: 1 },
-            { a: 2 },
-            { a: 3 },
-        ]);
-    });
-});

package/dist/src/data/transforms/flattenDelimited.test.js

@@ -1,90 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import FlattenDelimitedTransform from "./flattenDelimited.js";
-
-const sampleData = [
-    { id: 1, a: "q, w, e", b: "a-s-d" },
-    { id: 2, a: "r, t, y", b: "f-g-h" },
-    { id: 3, a: "u", b: "j" },
-];
-
-/**
- * @param {import("../../spec/transform.js").FlattenDelimitedParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new FlattenDelimitedTransform(params), data);
-}
-
-describe("FlattenDelimited transform", () => {
-    /**
-     * @typedef {import("../../spec/transform.js").FlattenDelimitedParams} FlattenDelimitedParams
-     */
-    test("With a single field", () => {
-        /** @type {FlattenDelimitedParams} */
-        const params = {
-            type: "flattenDelimited",
-            field: "a",
-            separator: ", ",
-        };
-
-        expect(transform(params, sampleData)).toEqual([
-            { id: 1, a: "q", b: "a-s-d" },
-            { id: 1, a: "w", b: "a-s-d" },
-            { id: 1, a: "e", b: "a-s-d" },
-            { id: 2, a: "r", b: "f-g-h" },
-            { id: 2, a: "t", b: "f-g-h" },
-            { id: 2, a: "y", b: "f-g-h" },
-            { id: 3, a: "u", b: "j" },
-        ]);
-    });
-
-    test("With two fields", () => {
-        /** @type {FlattenDelimitedParams} */
-        const params = {
-            type: "flattenDelimited",
-            field: ["a", "b"],
-            as: ["a", "c"],
-            separator: [", ", "-"],
-        };
-
-        expect(transform(params, sampleData)).toEqual([
-            { id: 1, a: "q", b: "a-s-d", c: "a" },
-            { id: 1, a: "w", b: "a-s-d", c: "s" },
-            { id: 1, a: "e", b: "a-s-d", c: "d" },
-            { id: 2, a: "r", b: "f-g-h", c: "f" },
-            { id: 2, a: "t", b: "f-g-h", c: "g" },
-            { id: 2, a: "y", b: "f-g-h", c: "h" },
-            { id: 3, a: "u", b: "j", c: "j" },
-        ]);
-    });
-
-    test("Throws on differing field lengths", () => {
-        const data = [
-            {
-                a: "1-2",
-                b: "1-2-3",
-            },
-        ];
-
-        /** @type {FlattenDelimitedParams} */
-        const params = {
-            type: "flattenDelimited",
-            field: ["a", "b"],
-            separator: ["-", "-"],
-        };
-
-        expect(() => transform(params, data)).toThrow();
-    });
-
-    test("Throws on mismatching spec lengths", () => {
-        /** @type {FlattenDelimitedParams} */
-        const params = {
-            type: "flattenDelimited",
-            field: ["a", "b"],
-            separator: ["a"],
-        };
-
-        expect(() => transform(params, sampleData)).toThrow();
-    });
-});

package/dist/src/data/transforms/flattenSequence.test.js

@@ -1,34 +0,0 @@
-import { expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import FlattenSequenceTransform from "./flattenSequence.js";
-
-/**
- * @param {import("../../spec/transform.js").FlattenSequenceParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new FlattenSequenceTransform(params), data);
-}
-
-test("FlattenSequenece", () => {
-    expect(
-        transform(
-            {
-                type: "flattenSequence",
-                field: "seq",
-                as: ["p", "seq"],
-            },
-            [
-                { identifier: "A", seq: "TCG" },
-                { identifier: "B", seq: "AAT" },
-            ]
-        )
-    ).toEqual([
-        { identifier: "A", seq: "T", p: 0 },
-        { identifier: "A", seq: "C", p: 1 },
-        { identifier: "A", seq: "G", p: 2 },
-        { identifier: "B", seq: "A", p: 0 },
-        { identifier: "B", seq: "A", p: 1 },
-        { identifier: "B", seq: "T", p: 2 },
-    ]);
-});

package/dist/src/data/transforms/formula.test.js

@@ -1,25 +0,0 @@
-import { expect, test } from "vitest";
-import { makeParamMediatorProvider, processData } from "../flowTestUtils.js";
-import FormulaTransform from "./formula.js";
-
-test.todo("Implement stub for ParamMediator");
-
-test("FormulaTransform", () => {
-    const data = [{ a: 2 }, { a: 3 }];
-
-    const t = new FormulaTransform(
-        {
-            type: "formula",
-            expr: "datum.a * 2",
-            as: "b",
-        },
-        makeParamMediatorProvider()
-    );
-
-    t.initialize();
-
-    expect(processData(t, data)).toEqual([
-        { a: 2, b: 4 },
-        { a: 3, b: 6 },
-    ]);
-});

package/dist/src/data/transforms/identifier.test.js

@@ -1,92 +0,0 @@
-import { expect, test } from "vitest";
-import { range } from "d3-array";
-import { processData } from "../flowTestUtils.js";
-import IdentifierTransform, {
-    BLOCK_SIZE,
-    UNIQUE_ID_KEY,
-} from "./identifier.js";
-
-test("An IdentifierTransform adds identifiers correctly", () => {
-    const data = range(BLOCK_SIZE * 2).map((x) => ({ data: x }));
-
-    const identifiedData = processData(
-        new IdentifierTransform({ type: "identifier" }),
-        data
-    );
-
-    // The fist block is skipped
-    const firstId = BLOCK_SIZE;
-
-    expect(identifiedData[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
-    expect(identifiedData[1]).toEqual({
-        data: 1,
-        [UNIQUE_ID_KEY]: firstId + 1,
-    });
-    expect(identifiedData[BLOCK_SIZE]).toEqual({
-        data: BLOCK_SIZE,
-        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
-    });
-    expect(identifiedData[BLOCK_SIZE + 1]).toEqual({
-        data: BLOCK_SIZE + 1,
-        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE + 1,
-    });
-});
-
-test("Another transform instance adds identifiers correctly", () => {
-    const data = range(BLOCK_SIZE * 2).map((x) => ({ data: x }));
-    // Another instance
-    const identifiedData = processData(
-        new IdentifierTransform({ type: "identifier" }),
-        data
-    );
-
-    // The fist block was skipped and the previous test case consumed two blocks
-    const firstId = BLOCK_SIZE * 3;
-
-    expect(identifiedData[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
-    expect(identifiedData[1]).toEqual({
-        data: 1,
-        [UNIQUE_ID_KEY]: firstId + 1,
-    });
-    expect(identifiedData[BLOCK_SIZE]).toEqual({
-        data: BLOCK_SIZE,
-        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
-    });
-    expect(identifiedData[BLOCK_SIZE + 1]).toEqual({
-        data: BLOCK_SIZE + 1,
-        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE + 1,
-    });
-});
-
-test("IdentifierTransform recycles allocated blocks", () => {
-    let data = range(BLOCK_SIZE * 2).map((x) => ({ data: x }));
-
-    const transform = new IdentifierTransform({ type: "identifier" });
-    let identifiedData = processData(transform, data);
-
-    let firstId = BLOCK_SIZE * 5;
-
-    expect(identifiedData[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
-    expect(identifiedData[BLOCK_SIZE]).toEqual({
-        data: BLOCK_SIZE,
-        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
-    });
-
-    data = range(BLOCK_SIZE * 3).map((x) => ({ data: x }));
-
-    // Resetting the transform. It should now reuse the allocated blocks.
-    transform.reset();
-    identifiedData = processData(transform, data);
-
-    expect(identifiedData[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
-    expect(identifiedData[BLOCK_SIZE]).toEqual({
-        data: BLOCK_SIZE,
-        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
-    });
-
-    // ... and reserve one extra
-    expect(identifiedData[BLOCK_SIZE * 2]).toEqual({
-        data: BLOCK_SIZE * 2,
-        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE * 2,
-    });
-});

package/dist/src/data/transforms/pileup.test.js

@@ -1,70 +0,0 @@
-import { expect, test } from "vitest";
-import PileupTransform from "./pileup.js";
-import { processData } from "../flowTestUtils.js";
-
-// TODO: Test for lane preferences
-
-/**
- * @typedef {import("../../spec/transform.js").PileupParams} PileupParams
- */
-
-const reads = [
-    [0, 4],
-    [1, 3],
-    [2, 6],
-    [4, 8],
-    [8, 10],
-    [11, 14],
-    [11, 13],
-    [11, 12],
-    [15, 18],
-    [16, 18],
-    [17, 18],
-].map((d) => ({
-    start: d[0],
-    end: d[1],
-}));
-
-const lanes = [0, 1, 2, 1, 0, 0, 1, 2, 0, 1, 2];
-
-/** @type {PileupParams} */
-const params = {
-    type: "pileup",
-    start: "start",
-    end: "end",
-};
-
-/**
- * @param {PileupParams} params
- * @param {any[]} data
- */
-function pileupTransform(params, data) {
-    const t = new PileupTransform(params);
-    t.initialize();
-    return processData(t, data);
-}
-
-test("Pileup transform produces correct pileup", () => {
-    const piledUp = lanes.map((d, i) => ({
-        ...reads[i],
-        lane: d,
-    }));
-
-    expect(pileupTransform(params, reads)).toEqual(piledUp);
-});
-
-test("Pileup transform produces correct pileup with consecutive contigs", () => {
-    // Simulate data having multiple chromosomes, sorted by [chrom, pos].
-    // Piling should handle suddenly decreasing start positions by freeing all
-    // reserved lanes.
-
-    const repeatedReads = [...reads, ...reads];
-    const repeatedLanes = [...lanes, ...lanes];
-
-    const piledUp = repeatedLanes.map((d, i) => ({
-        ...repeatedReads[i],
-        lane: d,
-    }));
-
-    expect(pileupTransform(params, repeatedReads)).toEqual(piledUp);
-});

package/dist/src/data/transforms/project.test.js

@@ -1,32 +0,0 @@
-import { expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import ProjectTransform from "./project.js";
-
-test("Project", () => {
-    const data = [
-        {
-            foo: "FOO",
-            bar: "BAR",
-            baz: { a: "A" },
-        },
-    ];
-
-    /** @param {import("../../spec/transform.js").ProjectParams} params */
-    const p = (params) => processData(new ProjectTransform(params), data);
-
-    expect(p({ type: "project", fields: ["bar"] })).toEqual([{ bar: "BAR" }]);
-
-    expect(
-        p({ type: "project", fields: ["bar", "foo"], as: ["xBar", "xFoo"] })
-    ).toEqual([{ xBar: "BAR", xFoo: "FOO" }]);
-
-    expect(p({ type: "project", fields: ["baz.a"] })).toEqual([
-        { "baz.a": "A" },
-    ]);
-
-    expect(p({ type: "project", fields: ["baz.a"], as: ["a"] })).toEqual([
-        { a: "A" },
-    ]);
-
-    expect(() => p({ type: "project", fields: ["bar"], as: [] })).toThrow();
-});