@genome-spy/core 0.36.1 → 0.37.0

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

@@ -0,0 +1,193 @@
+import { describe, expect, test } from "vitest";
+import FlowNode, { BEHAVIOR_CLONES } from "./flowNode";
+import { removeRedundantCloneTransforms, validateLinks } from "./flowOptimizer";
+import CloneTransform from "./transforms/clone";
+import Collector from "./collector";
+import DataFlow from "./dataFlow";
+import { combineIdenticalDataSources } from "./flowOptimizer";
+import InlineSource from "./sources/inlineSource";
+import UrlSource from "./sources/urlSource";
+
+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);
+    });
+});
+
+describe("Merge indentical data sources", () => {
+    test("Merges correctly", () => {
+        /** @type {DataFlow<string>} */
+        const dataFlow = new DataFlow();
+
+        const a = new UrlSource({ url: "http://genomespy.app/" });
+        const ac = new Collector();
+        a.addChild(ac);
+
+        const b = new UrlSource({ url: "http://genomespy.app/" });
+        const bc = new Collector();
+        b.addChild(bc);
+
+        const c = new UrlSource({ url: "http://helsinki.fi/" });
+        const cc = new Collector();
+        c.addChild(cc);
+
+        dataFlow.addDataSource(a, "a");
+        dataFlow.addDataSource(b, "b");
+        dataFlow.addDataSource(c, "c");
+
+        dataFlow.addCollector(ac, "a");
+        dataFlow.addCollector(bc, "b");
+        dataFlow.addCollector(cc, "c");
+
+        combineIdenticalDataSources(dataFlow);
+
+        expect(dataFlow.dataSources.length).toEqual(2);
+
+        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
+        expect(dataFlow.findDataSourceByKey("b")).toBe(a); // Merged!
+        expect(dataFlow.findDataSourceByKey("c")).toBe(c);
+
+        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<string>} */
+        const dataFlow = new DataFlow();
+
+        const a = new InlineSource({ values: [1, 2, 3] });
+        const b = new InlineSource({ values: [1, 2, 3] });
+
+        dataFlow.addDataSource(a, "a");
+        dataFlow.addDataSource(b, "b");
+
+        combineIdenticalDataSources(dataFlow);
+
+        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
+        expect(dataFlow.findDataSourceByKey("b")).toBe(b);
+    });
+});

package/dist/src/data/flowTestUtils.d.ts

@@ -0,0 +1,30 @@
+/**
+ *
+ * @param {import("./flowNode").default} flowNode
+ * @param {any[]} data
+ */
+export function processData(flowNode: import("./flowNode").default, data: any[]): import("./flowNode").Datum[];
+/**
+ * For testing
+ */
+export class SynchronousSource extends FlowNode {
+    /**
+     *
+     * @param {any[]} data
+     */
+    constructor(data: any[]);
+    data: any[];
+    dispatch(): void;
+}
+/**
+ * For testing
+ */
+export class SynchronousSequenceSource extends SynchronousSource {
+    /**
+     *
+     * @param {number} n number of elements
+     */
+    constructor(n: number);
+}
+import FlowNode from "./flowNode";
+//# sourceMappingURL=flowTestUtils.d.ts.map

package/dist/src/data/flowTestUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowTestUtils.d.ts","sourceRoot":"","sources":["../../../src/data/flowTestUtils.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,sCAHW,OAAO,YAAY,EAAE,OAAO,QAC5B,GAAG,EAAE,gCAcf;AAED;;GAEG;AACH;IACI;;;OAGG;IACH,kBAFW,GAAG,EAAE,EAKf;IADG,YAAgB;IAGpB,iBAMC;CACJ;AAED;;GAEG;AACH;IACI;;;OAGG;IACH,eAFW,MAAM,EAWhB;CACJ;qBA7DoB,YAAY"}

package/dist/src/data/flowTestUtils.js

@@ -0,0 +1,63 @@
+import Collector from "./collector";
+import FlowNode from "./flowNode";
+
+/**
+ *
+ * @param {import("./flowNode").default} flowNode
+ * @param {any[]} data
+ */
+export function processData(flowNode, data) {
+    const collector = new Collector();
+    flowNode.addChild(collector);
+
+    for (const d of data) {
+        flowNode.handle(d);
+    }
+    flowNode.complete();
+
+    flowNode.removeChild(collector);
+
+    return [...collector.getData()];
+}
+
+/**
+ * For testing
+ */
+export class SynchronousSource extends FlowNode {
+    /**
+     *
+     * @param {any[]} data
+     */
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+
+    dispatch() {
+        for (const d of this.data) {
+            this._propagate(d);
+        }
+
+        this.complete();
+    }
+}
+
+/**
+ * For testing
+ */
+export class SynchronousSequenceSource extends SynchronousSource {
+    /**
+     *
+     * @param {number} n number of elements
+     */
+    constructor(n) {
+        n = n || 10;
+
+        const data = [];
+        for (let i = 0; i < n; i++) {
+            data.push({ data: i });
+        }
+
+        super(data);
+    }
+}

package/dist/src/data/formats/fasta.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A bare-bones FASTA-parser
+ *
+ * @typedef {object} SequenceEntry
+ * @prop {string} identifier
+ * @prop {string} sequence
+ *
+ * @param {string} data
+ * @param {any} options
+ * @returns {SequenceEntry[]}
+ */
+export default function fasta(data: string, options: any): SequenceEntry[];
+/**
+ * A bare-bones FASTA-parser
+ */
+export type SequenceEntry = {
+    identifier: string;
+    sequence: string;
+};
+//# sourceMappingURL=fasta.d.ts.map

package/dist/src/data/formats/fasta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fasta.d.ts","sourceRoot":"","sources":["../../../../src/data/formats/fasta.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,oCAJW,MAAM,WACN,GAAG,GACD,aAAa,EAAE,CAsB3B;;;;;gBA3BS,MAAM;cACN,MAAM"}

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

@@ -0,0 +1,32 @@
+/**
+ * A bare-bones FASTA-parser
+ *
+ * @typedef {object} SequenceEntry
+ * @prop {string} identifier
+ * @prop {string} sequence
+ *
+ * @param {string} data
+ * @param {any} options
+ * @returns {SequenceEntry[]}
+ */
+export default function fasta(data, options) {
+    /** @type {SequenceEntry[]} */
+    const sequences = [];
+
+    /** @type {SequenceEntry} */
+    let currentEntry;
+
+    for (const line of data.split("\n")) {
+        if (line.startsWith(">")) {
+            const identifier = line.match(/>(\S+)/)[1];
+            currentEntry = { identifier, sequence: "" };
+            sequences.push(currentEntry);
+        } else if (currentEntry) {
+            currentEntry.sequence += line.trim();
+        } else {
+            throw new Error("Invalid fasta file!");
+        }
+    }
+
+    return sequences;
+}

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

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+import fasta from "./fasta";
+
+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/dataSource.d.ts

@@ -0,0 +1,12 @@
+export default class DataSource extends FlowNode {
+    /**
+     * Returns a string that identifies a data source. Data sources with the
+     * same identifier can be merged.
+     *
+     * @return {string}
+     */
+    get identifier(): string;
+    load(): Promise<void>;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=dataSource.d.ts.map

package/dist/src/data/sources/dataSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataSource.js"],"names":[],"mappings":"AAEA;IACI;;;;;OAKG;IACH,yBAEC;IAUD,sBAEC;CACJ;qBAxBoB,aAAa"}

package/dist/src/data/sources/dataSource.js

@@ -0,0 +1,25 @@
+import FlowNode from "../flowNode";
+
+export default class DataSource extends FlowNode {
+    /**
+     * Returns a string that identifies a data source. Data sources with the
+     * same identifier can be merged.
+     *
+     * @return {string}
+     */
+    get identifier() {
+        return undefined;
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        throw new Error("Source does not handle incoming data!");
+    }
+
+    async load() {
+        // override
+    }
+}

package/dist/src/data/sources/dataSourceFactory.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {Partial<import("../../spec/data").Data>} params
+ * @param {import("../../view/view").default} view
+ */
+export default function createDataSource(params: Partial<import("../../spec/data").Data>, view: import("../../view/view").default): InlineSource | UrlSource | SequenceSource | AxisTickSource | AxisGenomeSource | IndexedFastaSource | BigWigSource | BigBedSource | BamSource | Gff3Source;
+import InlineSource from "./inlineSource";
+import UrlSource from "./urlSource";
+import SequenceSource from "./sequenceSource";
+import AxisTickSource from "./dynamic/axisTickSource";
+import AxisGenomeSource from "./dynamic/axisGenomeSource";
+import IndexedFastaSource from "./dynamic/indexedFastaSource";
+import BigWigSource from "./dynamic/bigWigSource";
+import BigBedSource from "./dynamic/bigBedSource";
+import BamSource from "./dynamic/bamSource";
+import Gff3Source from "./dynamic/gff3Source";
+//# sourceMappingURL=dataSourceFactory.d.ts.map

package/dist/src/data/sources/dataSourceFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataSourceFactory.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataSourceFactory.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,iDAHW,QAAQ,OAAO,iBAAiB,EAAE,IAAI,CAAC,QACvC,OAAO,iBAAiB,EAAE,OAAO,6JAgB3C;yBA7B0C,gBAAgB;sBACtB,aAAa;2BACE,kBAAkB;2BAC3C,0BAA0B;6BACxB,4BAA4B;+BAC1B,8BAA8B;yBACpC,wBAAwB;yBACxB,wBAAwB;sBAC3B,qBAAqB;uBACpB,sBAAsB"}

package/dist/src/data/sources/dataSourceFactory.js

@@ -0,0 +1,127 @@
+import InlineSource, { isInlineData } from "./inlineSource";
+import UrlSource, { isUrlData } from "./urlSource";
+import SequenceSource, { isSequenceGenerator } from "./sequenceSource";
+import AxisTickSource from "./dynamic/axisTickSource";
+import AxisGenomeSource from "./dynamic/axisGenomeSource";
+import IndexedFastaSource from "./dynamic/indexedFastaSource";
+import BigWigSource from "./dynamic/bigWigSource";
+import BigBedSource from "./dynamic/bigBedSource";
+import BamSource from "./dynamic/bamSource";
+import Gff3Source from "./dynamic/gff3Source";
+
+/**
+ * @param {Partial<import("../../spec/data").Data>} params
+ * @param {import("../../view/view").default} view
+ */
+export default function createDataSource(params, view) {
+    if (isInlineData(params)) {
+        return new InlineSource(params, view);
+    } else if (isUrlData(params)) {
+        return new UrlSource(params, view);
+    } else if (isSequenceGenerator(params)) {
+        return new SequenceSource(params, view);
+    } else if (isLazyData(params)) {
+        return createDynamicDataSource(params.lazy, view);
+    }
+
+    throw new Error(
+        "Cannot figure out the data source type: " + JSON.stringify(params)
+    );
+}
+
+/**
+ *
+ * @param {Partial<import("../../spec/data").Data>} params
+ * @returns {params is import("../../spec/data").LazyData}
+ */
+function isLazyData(params) {
+    return "lazy" in params;
+}
+
+/**
+ *
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @returns {params is import("../../spec/data").AxisTicksData}
+ */
+function isAxisTickSource(params) {
+    return params?.type == "axisTicks";
+}
+
+/**
+ *
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @returns {params is import("../../spec/data").AxisGenomeData}
+ */
+function isAxisGenomeSource(params) {
+    return params?.type == "axisGenome";
+}
+
+/**
+ *
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @returns {params is import("../../spec/data").IndexedFastaData}
+ */
+function isIndexedFastaSource(params) {
+    return params?.type == "indexedFasta";
+}
+
+/**
+ *
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @returns {params is import("../../spec/data").BigWigData}
+ */
+function isBigWigSource(params) {
+    return params?.type == "bigwig";
+}
+
+/**
+ *
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @returns {params is import("../../spec/data").BigBedData}
+ */
+function isBigBedSource(params) {
+    return params?.type == "bigbed";
+}
+
+/**
+ *
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @returns {params is import("../../spec/data").BamData}
+ */
+function isBamSource(params) {
+    return params?.type == "bam";
+}
+
+/**
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @returns {params is import("../../spec/data").Gff3Data}
+ */
+function isGff3Source(params) {
+    return params?.type == "gff3";
+}
+
+/**
+ * @param {import("../../spec/data").LazyDataParams} params
+ * @param {import("../../view/view").default} view
+ */
+function createDynamicDataSource(params, view) {
+    if (isAxisTickSource(params)) {
+        return new AxisTickSource(params, view);
+    } else if (isAxisGenomeSource(params)) {
+        return new AxisGenomeSource(params, view);
+    } else if (isIndexedFastaSource(params)) {
+        return new IndexedFastaSource(params, view);
+    } else if (isBigWigSource(params)) {
+        return new BigWigSource(params, view);
+    } else if (isBigBedSource(params)) {
+        return new BigBedSource(params, view);
+    } else if (isBamSource(params)) {
+        return new BamSource(params, view);
+    } else if (isGff3Source(params)) {
+        return new Gff3Source(params, view);
+    }
+
+    throw new Error(
+        "Cannot figure out the data source type: " + JSON.stringify(params)
+    );
+}

package/dist/src/data/sources/dataUtils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Validates data source params, infers format if not specified explicitly,
+ * returns a complete DataSource params object.
+ *
+ * @param {import("../../spec/data").DataSource} params
+ *      DataSource parameters
+ */
+export function getFormat(params: import("../../spec/data").DataSource): {
+    type?: "csv" | "tsv";
+    parse?: import("../../spec/data").Parse;
+} | {
+    type?: "dsv";
+    delimiter: string;
+    parse?: import("../../spec/data").Parse;
+} | {
+    type?: "json";
+    property?: string;
+    parse?: import("../../spec/data").Parse;
+} | {
+    type: string;
+};
+/**
+ * @param {string | string[]} url
+ */
+export function extractTypeFromUrl(url: string | string[]): string;
+/**
+ * @param {import("../../spec/data").DataFormat} dataFormat
+ * @return {dataFormat is import("../../spec/data").CsvDataFormat}
+ */
+export function isCsvDataFormat(dataFormat: import("../../spec/data").DataFormat): dataFormat is import("../../spec/data").CsvDataFormat;
+/**
+ * @param {import("../../spec/data").DataFormat} dataFormat
+ * @return {dataFormat is import("../../spec/data").DsvDataFormat}
+ */
+export function isDsvDataFormat(dataFormat: import("../../spec/data").DataFormat): dataFormat is import("../../spec/data").DsvDataFormat;
+/**
+ * @param {import("../../spec/data").DataFormat} dataFormat
+ * @return {dataFormat is import("../../spec/data").JsonDataFormat}
+ */
+export function isJsonDataFormat(dataFormat: import("../../spec/data").DataFormat): dataFormat is import("../../spec/data").JsonDataFormat;
+/**
+ *
+ * @param {import("../../spec/data").DataSource} dataSource
+ * @return {dataSource is import("../../spec/data").UrlData}
+ */
+export function isUrlData(dataSource: import("../../spec/data").DataSource): dataSource is import("../../spec/data").UrlData;
+export function makeWrapper(d: any): ((x: import("@genome-spy/core/spec/channel").Scalar) => {
+    data: import("@genome-spy/core/spec/channel").Scalar;
+}) | ((x: import("../flowNode").Datum) => import("../flowNode").Datum);
+//# sourceMappingURL=dataUtils.d.ts.map

package/dist/src/data/sources/dataUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataUtils.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataUtils.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,kCAHW,OAAO,iBAAiB,EAAE,UAAU;;;;;;;;;;;;;EAqB9C;AAED;;GAEG;AACH,wCAFW,MAAM,GAAG,MAAM,EAAE,UAU3B;AAWD;;;GAGG;AACH,4CAHW,OAAO,iBAAiB,EAAE,UAAU,yDAK9C;AAED;;;GAGG;AACH,4CAHW,OAAO,iBAAiB,EAAE,UAAU,yDAK9C;AAED;;;GAGG;AACH,6CAHW,OAAO,iBAAiB,EAAE,UAAU,0DAK9C;AAED;;;;GAIG;AACH,sCAHW,OAAO,iBAAiB,EAAE,UAAU,mDAK9C;AAxCM,+BAAgC,GAAG,QAI3B,OAAO,+BAA+B,EAAE,MAAM;;UAG9B,OAAO,aAAa,EAAE,KAAK,kCANL"}