@genome-spy/core 0.65.0 → 0.67.0

package/dist/src/data/flowNode.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FlowNode from "./flowNode.js";
-import { validateLinks } from "./flowOptimizer.js";
-
-describe("Flow mutation", () => {
-    test("Excise a terminal node", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-
-        a.addChild(b);
-        b.excise();
-
-        expect(a.children[0]).toBeUndefined();
-        expect(b.parent).toBeUndefined();
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-
-    test("Excise a node in the middle", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-        const c = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        b.excise();
-
-        expect(a.children[0]).toBe(c);
-        expect(c.parent).toBe(a);
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-
-    test("Insert as parent", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-        const c = new FlowNode();
-        const d = new FlowNode();
-
-        a.addChild(c);
-        a.addChild(d);
-        c.insertAsParent(b);
-
-        expect(a.children[0]).toBe(b);
-        expect(a.children[1]).toBe(d);
-        expect(a.children[0].children[0]).toBe(c);
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-});

package/dist/src/data/flowOptimizer.test.js

@@ -1,209 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FlowNode, { BEHAVIOR_CLONES } from "./flowNode.js";
-import {
-    removeRedundantCloneTransforms,
-    validateLinks,
-} from "./flowOptimizer.js";
-import CloneTransform from "./transforms/clone.js";
-import Collector from "./collector.js";
-import DataFlow from "./dataFlow.js";
-import { combineIdenticalDataSources } from "./flowOptimizer.js";
-import InlineSource from "./sources/inlineSource.js";
-import UrlSource from "./sources/urlSource.js";
-import { makeParamMediatorProvider } from "./flowTestUtils.js";
-
-test("validateLinks() detects broken graph", () => {
-    const root = new FlowNode();
-    const a = new FlowNode();
-    const b = new FlowNode();
-    const c = new FlowNode();
-
-    root.addChild(a);
-    root.addChild(b);
-    root.addChild(c);
-
-    expect(validateLinks(root)).toBeTruthy();
-
-    // Break it!
-    b.parent = undefined;
-
-    expect(validateLinks(root)).toBeFalsy();
-
-    // Check handling of root
-
-    const rootWithParent = new FlowNode();
-    // Break it!
-    rootWithParent.parent = new FlowNode();
-
-    expect(validateLinks(rootWithParent)).toBeFalsy();
-});
-
-describe("removeRedundantCloneTransforms", () => {
-    test("Removes redundancy from linear graph #1", () => {
-        const a = new FlowNode();
-        const b = new CloneTransform();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new CloneTransform();
-        const f = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-        e.addChild(f);
-
-        removeRedundantCloneTransforms(a);
-
-        expect(a.children[0]).toBe(c);
-        expect(c.children[0]).toBe(f);
-    });
-
-    test("Removes redundancy from linear graph #2", () => {
-        const a = new FlowNode();
-        const b = new CloneTransform();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new CloneTransform();
-        const f = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-        e.addChild(f);
-
-        // First CloneTransform should be retained
-        removeRedundantCloneTransforms(a, true);
-
-        expect(a.children[0]).toBe(b);
-        expect(b.children[0]).toBe(c);
-        expect(c.children[0]).toBe(f);
-    });
-
-    test("Node with cloning behavior satisfies cloning requirement", () => {
-        class CloningFlowNode extends FlowNode {
-            get behavior() {
-                return BEHAVIOR_CLONES;
-            }
-        }
-
-        const a = new FlowNode();
-        const b = new CloningFlowNode();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-
-        removeRedundantCloneTransforms(a, true);
-
-        expect(a.children[0]).toBe(b);
-        expect(b.children[0]).toBe(c);
-        expect(c.children[0]).toBe(e);
-    });
-
-    test("Removes redundancy from a branching graph", () => {
-        const root = new FlowNode();
-        const branching = new FlowNode();
-        const a = new CloneTransform();
-        const al = new FlowNode();
-        const b = new CloneTransform();
-        const bl = new FlowNode();
-        const c = new CloneTransform();
-        const cl = new FlowNode();
-
-        root.addChild(branching);
-        branching.addChild(a);
-        branching.addChild(b);
-        branching.addChild(c);
-        a.addChild(al);
-        b.addChild(bl);
-        c.addChild(cl);
-
-        removeRedundantCloneTransforms(root);
-
-        // All but the last branch needs cloning
-        expect(branching.children[0]).toBe(a);
-        expect(branching.children[1]).toBe(b);
-        expect(branching.children[2]).toBe(c);
-    });
-});
-
-/** @type {import("../view/view.js").default} */
-const viewStub = /** @type {any} */ (
-    Object.assign(makeParamMediatorProvider(), {
-        getBaseUrl: () => "",
-    })
-);
-
-describe("Merge indentical data sources", () => {
-    test("Merges correctly", () => {
-        /** @type {DataFlow} */
-        const dataFlow = new DataFlow();
-
-        const a = new UrlSource({ url: "http://genomespy.app/" }, viewStub);
-        const ac = new Collector();
-        a.addChild(ac);
-
-        const b = new UrlSource({ url: "http://genomespy.app/" }, viewStub);
-        const bc = new Collector();
-        b.addChild(bc);
-
-        const c = new UrlSource({ url: "http://helsinki.fi/" }, viewStub);
-        const cc = new Collector();
-        c.addChild(cc);
-
-        dataFlow.addDataSource(a);
-        dataFlow.addDataSource(b);
-        dataFlow.addDataSource(c);
-
-        dataFlow.addCollector(ac);
-        dataFlow.addCollector(bc);
-        dataFlow.addCollector(cc);
-
-        combineIdenticalDataSources(dataFlow);
-
-        expect(dataFlow.dataSources.length).toEqual(2);
-
-        const entries = dataFlow.dataSources;
-        const sharedIdentifier = a.identifier;
-        expect(entries).toContain(a);
-        expect(entries).toContain(c);
-        expect(
-            entries.filter((source) => source.identifier == sharedIdentifier)
-        ).toEqual([a]);
-
-        expect(new Set(a.children)).toEqual(new Set([ac, bc]));
-        expect(c.children[0]).toBe(cc);
-
-        for (const dataSource of dataFlow.dataSources) {
-            // Cheat that we loaded something
-            dataSource.complete();
-        }
-
-        expect(ac.completed).toBeTruthy();
-        expect(bc.completed).toBeTruthy();
-        expect(cc.completed).toBeTruthy();
-    });
-
-    test("Does not merge those with undefined identifier", () => {
-        /** @type {DataFlow} */
-        const dataFlow = new DataFlow();
-
-        const a = new InlineSource({ values: [1, 2, 3] }, viewStub);
-        const b = new InlineSource({ values: [1, 2, 3] }, viewStub);
-
-        dataFlow.addDataSource(a);
-        dataFlow.addDataSource(b);
-
-        combineIdenticalDataSources(dataFlow);
-
-        const entries = dataFlow.dataSources;
-        expect(entries).toContain(a);
-        expect(entries).toContain(b);
-    });
-});

package/dist/src/data/formats/fasta.test.js

@@ -1,27 +0,0 @@
-import { expect, test } from "vitest";
-import fasta from "./fasta.js";
-
-test("fasta", () => {
-    const fileContent = `>A stuff
---------------------------AGAGTTTGATCCTGGCTCAGGGTGAACGCTGGCG
-GCGTGC----TTAAGACATGCAAGTCGAACGG-CCT------TCTTCG-G-AAGGC-AGT
----------------------------------
->B other stuff
---------------------------AGAGTTTGATCATGGCTCAGGGTGAACGCTGGCG
-GCGTGC----TTAAGACATGCAAGTCGGACGA-TCG------GCTTCG---GCCGGTAGT
----------------------------------
-`;
-
-    expect(fasta(fileContent)).toEqual([
-        {
-            identifier: "A",
-            sequence:
-                "--------------------------AGAGTTTGATCCTGGCTCAGGGTGAACGCTGGCGGCGTGC----TTAAGACATGCAAGTCGAACGG-CCT------TCTTCG-G-AAGGC-AGT---------------------------------",
-        },
-        {
-            identifier: "B",
-            sequence:
-                "--------------------------AGAGTTTGATCATGGCTCAGGGTGAACGCTGGCGGCGTGC----TTAAGACATGCAAGTCGGACGA-TCG------GCTTCG---GCCGGTAGT---------------------------------",
-        },
-    ]);
-});

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

@@ -1,63 +0,0 @@
-import { expect, test } from "vitest";
-import Collector from "../collector.js";
-import InlineSource from "./inlineSource.js";
-
-/**
- * @param {InlineSource} source
- */
-async function collectSource(source) {
-    const collector = new Collector();
-    source.addChild(collector);
-
-    await source.load();
-
-    return [...collector.getData()];
-}
-
-test("InlineSource propagates an object", async () => {
-    expect(
-        await collectSource(new InlineSource({ values: { x: 1 } }, undefined))
-    ).toEqual([{ x: 1 }]);
-});
-
-test("InlineSource propagates an array of objects", async () => {
-    expect(
-        await collectSource(
-            new InlineSource({ values: [{ x: 1 }, { x: 2 }] }, undefined)
-        )
-    ).toEqual([{ x: 1 }, { x: 2 }]);
-});
-
-test("InlineSource wraps scalars to objects", async () => {
-    expect(
-        await collectSource(new InlineSource({ values: [1, 2] }, undefined))
-    ).toEqual([{ data: 1 }, { data: 2 }]);
-});
-
-test("InlineSource parses a string", async () => {
-    expect(
-        await collectSource(
-            new InlineSource(
-                {
-                    values: "a\n1\n2\n3",
-                    format: {
-                        type: "csv",
-                    },
-                },
-                undefined
-            )
-        )
-    ).toEqual([{ a: 1 }, { a: 2 }, { a: 3 }]);
-});
-
-test("InlineSource throws on a string and a missing format specifier", () => {
-    expect(
-        () =>
-            new InlineSource(
-                {
-                    values: "a\n1\n2\n3",
-                },
-                undefined
-            )
-    ).toThrow();
-});

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