@genome-spy/core 0.64.0 → 0.66.1

package/dist/src/data/sources/sequenceSource.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, test } from "vitest";
-import Collector from "../collector.js";
-import SequenceSource from "./sequenceSource.js";
-import { makeParamMediatorProvider } from "../flowTestUtils.js";
-
-/**
- * @param {SequenceSource} source
- */
-async function collectSource(source) {
-    const collector = new Collector();
-    source.addChild(collector);
-
-    await source.load();
-
-    return [...collector.getData()];
-}
-
-describe("SequenceSource", () => {
-    /** @type {import("../../view/view.js").default} */
-    const viewStub = /** @type {any} */ (makeParamMediatorProvider());
-
-    test("generates a sequence", () =>
-        expect(
-            collectSource(
-                new SequenceSource(
-                    { sequence: { start: 0, stop: 3 } },
-                    viewStub
-                )
-            )
-        ).resolves.toEqual([{ data: 0 }, { data: 1 }, { data: 2 }]));
-
-    test("generates a sequence with a custom step", () =>
-        expect(
-            collectSource(
-                new SequenceSource(
-                    { sequence: { start: 0, stop: 5, step: 2 } },
-                    viewStub
-                )
-            )
-        ).resolves.toEqual([{ data: 0 }, { data: 2 }, { data: 4 }]));
-
-    test("generates a sequence with a custom field name", () =>
-        expect(
-            collectSource(
-                new SequenceSource(
-                    { sequence: { start: 0, stop: 3, as: "x" } },
-                    viewStub
-                )
-            )
-        ).resolves.toEqual([{ x: 0 }, { x: 1 }, { x: 2 }]));
-
-    test("accepts ExprRef parameters", async () =>
-        expect(
-            collectSource(
-                new SequenceSource(
-                    {
-                        sequence: {
-                            start: { expr: "0" },
-                            stop: { expr: "1 + 2" },
-                            step: { expr: "1" },
-                            as: "x",
-                        },
-                    },
-                    viewStub
-                )
-            )
-            // TODO: Test that the sequence is regenerated when the parameters change
-        ).resolves.toEqual([{ x: 0 }, { x: 1 }, { x: 2 }]));
-
-    test("throws on missing 'start' parameter", () =>
-        expect(
-            // @ts-expect-error
-            () => new SequenceSource({ sequence: { stop: 3 } }, viewStub)
-        ).toThrow());
-
-    test("throws on missing 'stop' parameter", () =>
-        expect(
-            // @ts-expect-error
-            () => new SequenceSource({ sequence: { start: 0 } }, viewStub)
-        ).toThrow());
-});

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

@@ -1,134 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import AggregateTransform from "./aggregate.js";
-
-/**
- * @param {import("../../spec/transform.js").AggregateParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new AggregateTransform(params), data);
-}
-
-describe("Aggregate transform", () => {
-    test("Default to count when no data fields or group-by fields are specified", () => {
-        const input = [
-            { name: "alpha", data: 123 },
-            { name: "beta", data: 456 },
-            { name: "beta", data: 789 },
-        ];
-
-        expect(transform({ type: "aggregate" }, input)).toEqual([{ count: 3 }]);
-    });
-
-    test("Default to count when no data fields fields are specified", () => {
-        const input = [
-            { name: "alpha", data: 123 },
-            { name: "beta", data: 456 },
-            { name: "beta", data: 789 },
-        ];
-
-        expect(
-            transform({ type: "aggregate", groupby: ["name"] }, input)
-        ).toEqual([
-            { name: "alpha", count: 1 },
-            { name: "beta", count: 2 },
-        ]);
-    });
-
-    test("Compute count, sum, min, max, and mean for groups. Use default output field names.", () => {
-        const input = [
-            { name: "alpha", data: 123 },
-            { name: "beta", data: 456 },
-            { name: "beta", data: 789 },
-        ];
-
-        expect(
-            transform(
-                {
-                    type: "aggregate",
-                    groupby: ["name"],
-                    fields: ["data", "data", "data", "data", "data"],
-                    ops: ["count", "sum", "min", "max", "mean"],
-                },
-                input
-            )
-        ).toEqual([
-            {
-                name: "alpha",
-                count_data: 1,
-                sum_data: 123,
-                min_data: 123,
-                max_data: 123,
-                mean_data: 123,
-            },
-            {
-                name: "beta",
-                count_data: 2,
-                sum_data: 1245,
-                min_data: 456,
-                max_data: 789,
-                mean_data: 622.5,
-            },
-        ]);
-    });
-
-    test("Allow custom output field names", () => {
-        const input = [
-            { name: "alpha", data: 123 },
-            { name: "beta", data: 456 },
-            { name: "beta", data: 789 },
-        ];
-
-        expect(
-            transform(
-                {
-                    type: "aggregate",
-                    fields: ["data", "data", "data", "data", "data"],
-                    ops: ["count", "sum", "min", "max", "mean"],
-                    as: ["count", "total", "min", "max", "average"],
-                },
-                input
-            )
-        ).toEqual([
-            {
-                count: 3,
-                total: 1368,
-                min: 123,
-                max: 789,
-                average: 456,
-            },
-        ]);
-    });
-
-    test("Throw if the length of fields and ops does not match", () => {
-        const input = [{ name: "beta", data: 789 }];
-
-        expect(() =>
-            transform(
-                {
-                    type: "aggregate",
-                    fields: ["data", "data", "data", "data"],
-                    ops: ["count", "sum", "min", "max", "mean"],
-                },
-                input
-            )
-        ).toThrow();
-    });
-
-    test("Throw if the length of fields and as does not match", () => {
-        const input = [{ name: "beta", data: 789 }];
-
-        expect(() =>
-            transform(
-                {
-                    type: "aggregate",
-                    fields: ["data"],
-                    ops: ["count"],
-                    as: ["count", "total"],
-                },
-                input
-            )
-        ).toThrow();
-    });
-});

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

@@ -1,11 +0,0 @@
-import { expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import CloneTransform from "./clone.js";
-
-test("CloneTransform clones the data objects", () => {
-    const data = [{ x: 1 }, { x: 2 }];
-    const clonedData = processData(new CloneTransform(), data);
-
-    expect(clonedData).toEqual(data);
-    expect(clonedData[0]).not.toBe(data[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();
-    });
-});