@genome-spy/core 0.64.0 → 0.66.1

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();
-});

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

@@ -1,70 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-
-import RegexExtractTransform from "./regexExtract.js";
-
-/**
- * @param {import("../../spec/transform.js").RegexExtractParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new RegexExtractTransform(params), data);
-}
-
-describe("RegexExtractTransform", () => {
-    /**
-     * @typedef {import("../../spec/transform.js").RegexExtractParams} RegexExtractParams
-     */
-    const rows = [{ a: "12-34" }, { a: "23-45" }];
-
-    /** @type {RegexExtractParams} */
-    const params = {
-        type: "regexExtract",
-        regex: "^(\\d+)-(\\d+)$",
-        field: "a",
-        as: ["b", "c"],
-    };
-
-    test("Valid config and input", () => {
-        expect(transform(params, rows)).toEqual([
-            { a: "12-34", b: "12", c: "34" },
-            { a: "23-45", b: "23", c: "45" },
-        ]);
-    });
-
-    test("Invalid config", () => {
-        /** @type {RegexExtractParams} */
-        const config2 = {
-            type: "regexExtract",
-            regex: "^(\\d+)-(\\d+)$",
-            field: "a",
-            as: ["b", "c", "d"],
-        };
-
-        expect(() => transform(config2, rows)).toThrow();
-    });
-
-    test("Invalid data", () => {
-        const rows2 = [{ a: "12--34" }];
-
-        expect(() => transform(params, rows2)).toThrow();
-    });
-
-    test("Invalid, non-string data", () => {
-        const rows2 = [{ a: 123 }];
-
-        expect(() => transform(params, rows2)).toThrow();
-    });
-
-    test("Skip invalid or non-string data", () => {
-        const rows2 = [{ a: 123 }, { a: "xyzzy" }, { a: "12-34" }];
-
-        expect(transform({ ...params, skipInvalidInput: true }, rows2)).toEqual(
-            [
-                { a: 123, b: undefined, c: undefined },
-                { a: "xyzzy", b: undefined, c: undefined },
-                { a: "12-34", b: "12", c: "34" },
-            ]
-        );
-    });
-});

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

@@ -1,201 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import RegexFoldTransform from "./regexFold.js";
-
-describe("RegexFold", () => {
-    test("Throws error if the number of capture groups in columnRegex != 1", () => {
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^.+_a$",
-            asValue: "a",
-        };
-
-        expect(() => new RegexFoldTransform(singleGatherConfig)).toThrowError(
-            `Regex /^.+_a$/ must have exactly one capturing group!`
-        );
-    });
-
-    test("Transform single variable", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^(.*)_a$",
-            asValue: "a",
-        };
-
-        const result = processData(
-            new RegexFoldTransform(singleGatherConfig),
-            sampleData
-        );
-
-        expect(result).toEqual([
-            {
-                row: 1,
-                sample: "sample1",
-                a: "r1s1a",
-            },
-            {
-                row: 1,
-                sample: "sample2",
-                a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample: "sample1",
-                a: "r2s1a",
-            },
-            {
-                row: 2,
-                sample: "sample2",
-                a: "r2s2a",
-            },
-        ]);
-    });
-
-    test("Transform single variable and skip specific columns", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^(.*)_a$",
-            asValue: "a",
-            skipRegex: "^row$",
-        };
-
-        const result = processData(
-            new RegexFoldTransform(singleGatherConfig),
-            sampleData
-        );
-
-        expect(result).toEqual([
-            {
-                sample: "sample1",
-                a: "r1s1a",
-            },
-            {
-                sample: "sample2",
-                a: "r1s2a",
-            },
-            {
-                sample: "sample1",
-                a: "r2s1a",
-            },
-            {
-                sample: "sample2",
-                a: "r2s2a",
-            },
-        ]);
-    });
-
-    test("Transform multiple variables", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-                sample1_b: "r1s1b",
-                sample2_b: "r1s2b",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-                sample1_b: "r2s1b",
-                sample2_b: "r2s2b",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: ["^(.*)_a$", "^(.*)_b$"],
-            asValue: ["a", "b"],
-        };
-
-        const result = processData(
-            new RegexFoldTransform(singleGatherConfig),
-            sampleData
-        );
-
-        expect(result).toEqual([
-            {
-                row: 1,
-                sample: "sample1",
-                a: "r1s1a",
-                b: "r1s1b",
-            },
-            {
-                row: 1,
-                sample: "sample2",
-                a: "r1s2a",
-                b: "r1s2b",
-            },
-            {
-                row: 2,
-                sample: "sample1",
-                a: "r2s1a",
-                b: "r2s1b",
-            },
-            {
-                row: 2,
-                sample: "sample2",
-                a: "r2s2a",
-                b: "r2s2b",
-            },
-        ]);
-    });
-
-    test("Throws error if no columns match the regex", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^(.*)_c$",
-            asValue: "a",
-        };
-
-        expect(() =>
-            processData(new RegexFoldTransform(singleGatherConfig), sampleData)
-        ).toThrowError(
-            "No columns matching the regex /^(.*)_c$/ found in the data!"
-        );
-    });
-});

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

@@ -1,38 +0,0 @@
-import { expect, test } from "vitest";
-import SampleTransform from "./sample.js";
-import { extent } from "d3-array";
-import { createChain } from "../../view/flowBuilder.js";
-
-test("SampleTransform produces roughly uniform distributions", () => {
-    const size = 10;
-    const n = 20;
-    const rounds = 10000;
-
-    const freqs = [];
-    for (let i = 0; i < n; i++) {
-        freqs[i] = 0;
-    }
-
-    const { dataSource, collector } = createChain(
-        new SampleTransform({ type: "sample", size })
-    );
-
-    for (let r = 0; r < rounds; r++) {
-        for (let i = 0; i < n; i++) {
-            dataSource.handle({ data: i });
-        }
-        dataSource.complete();
-
-        for (const datum of collector.getData()) {
-            freqs[datum.data] = freqs[datum.data] + 1;
-        }
-
-        dataSource.reset();
-    }
-
-    const e = extent(freqs);
-
-    // Not a deterministic test! TODO: Come up with some sensical testing method
-    expect(e[0]).toBeGreaterThan(4800);
-    expect(e[1]).toBeLessThan(5200);
-});

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

@@ -1,91 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import StackTransform from "./stack.js";
-
-const sampleData = [
-    { group: "a", choice: "q", value: 1 },
-    { group: "b", choice: "x", value: 1 },
-    { group: "b", choice: "y", value: 3 },
-];
-
-/** @type {import("../../spec/transform.js").StackParams} */
-const baseParams = {
-    type: "stack",
-    field: "value",
-    groupby: ["group"],
-    sort: {
-        field: "value",
-        order: "ascending",
-    },
-    offset: "zero",
-    as: ["z0", "z1"],
-};
-
-/**
- *
- * @param {import("../../spec/transform.js").StackParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new StackTransform(params), data);
-}
-
-describe("Stack transform", () => {
-    test("No field", () => {
-        const conf = Object.assign({}, baseParams, {
-            field: undefined,
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 1, z1: 2 },
-        ]);
-    });
-
-    test("Zero offset", () => {
-        expect(transform(baseParams, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 1, z1: 4 },
-        ]);
-    });
-
-    test("Normalize offset", () => {
-        const conf = Object.assign({}, baseParams, {
-            offset: "normalize",
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 0.25 },
-            { group: "b", choice: "y", value: 3, z0: 0.25, z1: 1 },
-        ]);
-    });
-
-    test("Center offset", () => {
-        const conf = Object.assign({}, baseParams, {
-            offset: "center",
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: -0.5, z1: 0.5 },
-            { group: "b", choice: "x", value: 1, z0: -2, z1: -1 },
-            { group: "b", choice: "y", value: 3, z0: -1, z1: 2 },
-        ]);
-    });
-
-    test("Descending sort", () => {
-        const conf = Object.assign({}, baseParams, {
-            sort: {
-                field: "value",
-                order: "descending",
-            },
-        });
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 0, z1: 3 },
-            { group: "b", choice: "x", value: 1, z0: 3, z1: 4 },
-        ]);
-    });
-});