@genome-spy/core 0.36.1 → 0.37.0

package/dist/src/data/sources/dynamic/tabixSource.js

@@ -0,0 +1,140 @@
+import { RemoteFile } from "generic-filehandle";
+import { TabixIndexedFile } from "@gmod/tabix";
+
+import SingleAxisLazySource from "./singleAxisLazySource";
+import windowedMixin from "./windowedMixin";
+import { debounce } from "../../../utils/debounce";
+import addBaseUrl from "@genome-spy/core/utils/addBaseUrl";
+
+/**
+ * @template T
+ */
+export default class TabixSource extends windowedMixin(SingleAxisLazySource) {
+    /** Keep track of the order of the requests */
+    lastRequestId = 0;
+
+    /** @type {TabixIndexedFile} */
+    tbiIndex;
+
+    /**
+     * @param {import("../../../spec/data").TabixData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params, view) {
+        /** @type {import("../../../spec/data").TabixData} */
+        const paramsWithDefaults = {
+            channel: "x",
+            windowSize: 3_000_000,
+            debounceDomainChange: 200,
+            ...params,
+        };
+
+        super(view, paramsWithDefaults.channel);
+
+        this.params = paramsWithDefaults;
+
+        if (!this.params.url) {
+            throw new Error("No URL provided for TabixSource");
+        }
+
+        const withBase = (/** @type {string} */ uri) =>
+            new RemoteFile(addBaseUrl(uri, this.view.getBaseUrl()));
+
+        this.tbiIndex = new TabixIndexedFile({
+            filehandle: withBase(this.params.url),
+            tbiFilehandle: withBase(
+                this.params.indexUrl ?? this.params.url + ".tbi"
+            ),
+        });
+
+        if (this.params.debounceDomainChange > 0) {
+            this.onDomainChanged = debounce(
+                this.onDomainChanged.bind(this),
+                this.params.debounceDomainChange,
+                false
+            );
+        }
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    async onDomainChanged(domain) {
+        const windowSize = this.params.windowSize;
+
+        if (domain[1] - domain[0] > windowSize) {
+            return;
+        }
+
+        const quantizedInterval = this.quantizeInterval(domain, windowSize);
+
+        if (this.checkAndUpdateLastInterval(quantizedInterval)) {
+            this.doRequest(quantizedInterval);
+        }
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     */
+    async doRequest(interval) {
+        const featureResponse = await this.getFeatures(interval);
+
+        // Discard late responses
+        if (featureResponse.requestId < this.lastRequestId) {
+            return;
+        }
+
+        this.publishData(featureResponse.features);
+    }
+
+    /**
+     *
+     * @param {number[]} interval
+     */
+    async getFeatures(interval) {
+        let requestId = ++this.lastRequestId;
+
+        // TODO: Abort previous requests
+        const abortController = new AbortController();
+
+        const discreteChromosomeIntervals =
+            this.genome.continuousToDiscreteChromosomeIntervals(interval);
+
+        // TODO: Error handling
+        const featuresWithChrom = await Promise.all(
+            discreteChromosomeIntervals.map(async (d) => {
+                /** @type {string[]} */
+                const lines = [];
+
+                await this.tbiIndex.getLines(d.chrom, d.startPos, d.endPos, {
+                    lineCallback: (line) => {
+                        lines.push(line);
+                    },
+                    signal: abortController.signal,
+                });
+
+                // Hmm. It's silly that we have to first collect individual lines and then join them.
+                return this._parseFeatures(lines);
+            })
+        );
+
+        return {
+            requestId,
+            abort: () => abortController.abort(),
+            features: featuresWithChrom.flat(), // TODO: Use batches, not flat
+        };
+    }
+
+    /**
+     * @abstract
+     * @param {string[]} lines
+     * @returns {T[]}
+     */
+    _parseFeatures(lines) {
+        return [];
+    }
+}

package/dist/src/data/sources/dynamic/windowedMixin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Utils for handling data sources that are fetched in chunks.
+ *
+ * @template {!Constructor} T
+ * @param {T} superclass - The class to extend
+ */
+export default function windowedMixin<T extends Constructor>(superclass: T): {
+    new (...args: any[]): {
+        [x: string]: any;
+        /**
+         * @type {number[]}
+         */
+        lastQuantizedInterval: number[];
+        /**
+         * Returns three consecutive windows. The idea is to immediately have some data
+         * to show to the user when they pan the view.
+         *
+         * @param {number[]} interval
+         * @param {number} windowSize
+         * @returns
+         */
+        quantizeInterval(interval: number[], windowSize: number): number[];
+        /**
+         *
+         * @param {number[]} interval
+         * @returns
+         */
+        checkAndUpdateLastInterval(interval: number[]): boolean;
+    };
+} & T;
+export type Constructor = new (...args: any[]) => any;
+//# sourceMappingURL=windowedMixin.d.ts.map

package/dist/src/data/sources/dynamic/windowedMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"windowedMixin.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/windowedMixin.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;kBAV4B,GAAG,EAAE;;QAYzB;;WAEG;+BADO,MAAM,EAAE;QAIlB;;;;;;;WAOG;mCAHQ,MAAM,EAAE,cACR,MAAM;QAgBjB;;;;WAIG;6CAFQ,MAAM,EAAE;;MAY1B;wCApD2B,GAAG,EAAE,KAAK,GAAG"}

package/dist/src/data/sources/dynamic/windowedMixin.js

@@ -0,0 +1,53 @@
+/** @typedef {new (...args: any[]) => any} Constructor */
+
+import { shallowArrayEquals } from "../../../utils/arrayUtils";
+
+/**
+ * Utils for handling data sources that are fetched in chunks.
+ *
+ * @template {!Constructor} T
+ * @param {T} superclass - The class to extend
+ */
+export default function windowedMixin(superclass) {
+    return class FormControl extends superclass {
+        /**
+         * @type {number[]}
+         */
+        lastQuantizedInterval = [0, 0];
+
+        /**
+         * Returns three consecutive windows. The idea is to immediately have some data
+         * to show to the user when they pan the view.
+         *
+         * @param {number[]} interval
+         * @param {number} windowSize
+         * @returns
+         */
+        quantizeInterval(interval, windowSize) {
+            return [
+                Math.max(
+                    Math.floor(interval[0] / windowSize - 1) * windowSize,
+                    0
+                ),
+                Math.min(
+                    Math.ceil(interval[1] / windowSize + 1) * windowSize,
+                    this.genome.totalSize
+                ),
+            ];
+        }
+
+        /**
+         *
+         * @param {number[]} interval
+         * @returns
+         */
+        checkAndUpdateLastInterval(interval) {
+            if (shallowArrayEquals(this.lastQuantizedInterval, interval)) {
+                return false;
+            }
+
+            this.lastQuantizedInterval = interval;
+            return true;
+        }
+    };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").InlineData}
+ */
+export function isInlineData(data: Partial<import("../../spec/data").Data>): data is import("../../spec/data").InlineData;
+export default class InlineSource extends DataSource {
+    /**
+     * @param {import("../../spec/data").InlineData} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params: import("../../spec/data").InlineData, view: import("../../view/view").default);
+    params: import("../../spec/data").InlineData;
+    loadSynchronously(): void;
+}
+import DataSource from "./dataSource";
+//# sourceMappingURL=inlineSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inlineSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/inlineSource.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,mCAHW,QAAQ,OAAO,iBAAiB,EAAE,IAAI,CAAC,gDAKjD;AAED;IACI;;;OAGG;IACH,oBAHW,OAAO,iBAAiB,EAAE,UAAU,QACpC,OAAO,iBAAiB,EAAE,OAAO,EAY3C;IAPG,6CAAoB;IASxB,0BAiCC;CAKJ;uBAjEsB,cAAc"}

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

@@ -0,0 +1,68 @@
+import { read } from "vega-loader";
+import { getFormat, makeWrapper } from "./dataUtils";
+import DataSource from "./dataSource";
+
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").InlineData}
+ */
+export function isInlineData(data) {
+    return "values" in data;
+}
+
+export default class InlineSource extends DataSource {
+    /**
+     * @param {import("../../spec/data").InlineData} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params, view) {
+        super();
+
+        this.params = params;
+
+        if (typeof params.values == "string" && !params?.format?.type) {
+            throw new Error(
+                "Data format type (csv, dsv, ...) must be specified if a string is provided!"
+            );
+        }
+    }
+
+    loadSynchronously() {
+        const values = this.params.values;
+
+        let data = [];
+
+        /** @type {(x: any) => import("../flowNode").Datum} */
+        let wrap = (x) => x;
+
+        if (Array.isArray(values)) {
+            if (values.length > 0) {
+                data = values;
+                // TODO: Should check the whole array and abort if types are heterogeneous
+                wrap = makeWrapper(values[0]);
+            }
+        } else if (typeof values == "object") {
+            data = [values];
+        } else if (typeof values == "string") {
+            // It's a string that needs to be parsed
+            data = read(values, getFormat(this.params));
+        } else {
+            throw new Error(
+                '"values" in data configuration is not an array, object, or a string!'
+            );
+        }
+
+        this.reset();
+        this.beginBatch({ type: "file" });
+
+        for (const d of data) {
+            this._propagate(wrap(d));
+        }
+
+        this.complete();
+    }
+
+    async load() {
+        this.loadSynchronously();
+    }
+}

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

@@ -0,0 +1,56 @@
+import { expect, test } from "vitest";
+import Collector from "../collector";
+import InlineSource from "./inlineSource";
+
+/**
+ * @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 } }))).toEqual(
+        [{ x: 1 }]
+    );
+});
+
+test("InlineSource propagates an array of objects", async () => {
+    expect(
+        await collectSource(new InlineSource({ values: [{ x: 1 }, { x: 2 }] }))
+    ).toEqual([{ x: 1 }, { x: 2 }]);
+});
+
+test("InlineSource wraps scalars to objects", async () => {
+    expect(await collectSource(new InlineSource({ values: [1, 2] }))).toEqual([
+        { data: 1 },
+        { data: 2 },
+    ]);
+});
+
+test("InlineSource parses a string", async () => {
+    expect(
+        await collectSource(
+            new InlineSource({
+                values: "a\n1\n2\n3",
+                format: {
+                    type: "csv",
+                },
+            })
+        )
+    ).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",
+            })
+    ).toThrow();
+});

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

@@ -0,0 +1,25 @@
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").NamedData}
+ */
+export function isNamedData(data: Partial<import("../../spec/data").Data>): data is import("../../spec/data").NamedData;
+export default class NamedSource extends DataSource {
+    /**
+     * @param {import("../../spec/data").NamedData} params
+     * @param {import("../../view/view").default} view
+     * @param {function(string):any[]} provider Function that retrieves a dataset using a name
+     */
+    constructor(params: import("../../spec/data").NamedData, view: import("../../view/view").default, provider: (arg0: string) => any[]);
+    provider: (arg0: string) => any[];
+    params: import("../../spec/data").NamedData;
+    /**
+     * Update the named data. If data is omitted, a data provider is used instead.
+     *
+     * @param {import("../flowNode").Datum[]} [data]
+     */
+    updateDynamicData(data?: import("../flowNode").Datum[]): void;
+    loadSynchronously(): void;
+    #private;
+}
+import DataSource from "./dataSource";
+//# sourceMappingURL=namedSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"namedSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/namedSource.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,kCAHW,QAAQ,OAAO,iBAAiB,EAAE,IAAI,CAAC,+CAKjD;AAED;IAOI;;;;OAIG;IACH,oBAJW,OAAO,iBAAiB,EAAE,SAAS,QACnC,OAAO,iBAAiB,EAAE,OAAO,mBACxB,MAAM,KAAE,GAAG,EAAE,EAOhC;IAFG,iBALgB,MAAM,KAAE,GAAG,EAAE,CAKL;IACxB,4CAAoB;IAUxB;;;;OAIG;IACH,yBAFW,OAAO,aAAa,EAAE,KAAK,EAAE,QAMvC;IAED,0BA0BC;;CAKJ;uBA/EsB,cAAc"}

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

@@ -0,0 +1,80 @@
+import DataSource from "./dataSource";
+import { makeWrapper } from "./dataUtils";
+
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").NamedData}
+ */
+export function isNamedData(data) {
+    return "name" in data;
+}
+
+export default class NamedSource extends DataSource {
+    /**
+     * Data that has been provided explicitly using the updateDynamicData method
+     * @type {any[]}
+     */
+    #explicitData;
+
+    /**
+     * @param {import("../../spec/data").NamedData} params
+     * @param {import("../../view/view").default} view
+     * @param {function(string):any[]} provider Function that retrieves a dataset using a name
+     */
+    constructor(params, view, provider) {
+        super();
+
+        this.provider = provider;
+        this.params = params;
+    }
+
+    /**
+     * @return {string}
+     */
+    get identifier() {
+        return this.params.name;
+    }
+
+    /**
+     * Update the named data. If data is omitted, a data provider is used instead.
+     *
+     * @param {import("../flowNode").Datum[]} [data]
+     */
+    updateDynamicData(data) {
+        // TODO: Throw is data is undefined and the provider is unable to provide any data
+        this.#explicitData = data;
+        this.loadSynchronously();
+    }
+
+    loadSynchronously() {
+        const data =
+            this.#explicitData ?? this.provider(this.params.name) ?? [];
+
+        /** @type {(x: any) => import("../flowNode").Datum} */
+        let wrap = (x) => x;
+
+        if (Array.isArray(data)) {
+            if (data.length > 0) {
+                // TODO: Should check the whole array and abort if types are heterogeneous
+                wrap = makeWrapper(data[0]);
+            }
+        } else {
+            throw new Error(
+                `Named data "${this.params.name}" is not an array!`
+            );
+        }
+
+        this.reset();
+        this.beginBatch({ type: "file" });
+
+        for (const d of data) {
+            this._propagate(wrap(d));
+        }
+
+        this.complete();
+    }
+
+    async load() {
+        this.loadSynchronously();
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").SequenceGenerator}
+ */
+export function isSequenceGenerator(data: Partial<import("../../spec/data").Data>): data is import("../../spec/data").SequenceGenerator;
+export default class SequenceSource extends DataSource {
+    /**
+     *
+     * @param {import("../../spec/data").SequenceGenerator} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params: import("../../spec/data").SequenceGenerator, view: import("../../view/view").default);
+    sequence: import("../../spec/data").SequenceParams;
+    loadSynchronously(): void;
+}
+import DataSource from "./dataSource";
+//# sourceMappingURL=sequenceSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/sequenceSource.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,0CAHW,QAAQ,OAAO,iBAAiB,EAAE,IAAI,CAAC,uDAKjD;AAED;IACI;;;;OAIG;IACH,oBAHW,OAAO,iBAAiB,EAAE,iBAAiB,QAC3C,OAAO,iBAAiB,EAAE,OAAO,EAY3C;IARG,mDAA+B;IAUnC,0BAaC;CAKJ;uBA9CsB,cAAc"}

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

@@ -0,0 +1,47 @@
+import DataSource from "./dataSource";
+
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").SequenceGenerator}
+ */
+export function isSequenceGenerator(data) {
+    return "sequence" in data;
+}
+
+export default class SequenceSource extends DataSource {
+    /**
+     *
+     * @param {import("../../spec/data").SequenceGenerator} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params, view) {
+        super();
+        this.sequence = params.sequence;
+
+        if (!("start" in this.sequence)) {
+            throw new Error("'start' is missing from sequence parameters!");
+        }
+        if (!("stop" in this.sequence)) {
+            throw new Error("'stop' is missing from sequence parameters!");
+        }
+    }
+
+    loadSynchronously() {
+        const as = this.sequence.as || "data";
+        const step = this.sequence.step || 1;
+        const stop = this.sequence.stop;
+
+        this.reset();
+        this.beginBatch({ type: "file" });
+
+        for (let x = this.sequence.start; x < stop; x += step) {
+            this._propagate({ [as]: x });
+        }
+
+        this.complete();
+    }
+
+    async load() {
+        this.loadSynchronously();
+    }
+}

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

@@ -0,0 +1,46 @@
+import { expect, test } from "vitest";
+import Collector from "../collector";
+import SequenceSource from "./sequenceSource";
+
+/**
+ * @param {SequenceSource} source
+ */
+async function collectSource(source) {
+    const collector = new Collector();
+    source.addChild(collector);
+
+    await source.load();
+
+    return [...collector.getData()];
+}
+
+test("SequenceSource generates a sequence", async () => {
+    expect(
+        await collectSource(
+            new SequenceSource({ sequence: { start: 0, stop: 3 } })
+        )
+    ).toEqual([{ data: 0 }, { data: 1 }, { data: 2 }]);
+});
+
+test("SequenceSource generates a sequence with a custom step", async () => {
+    expect(
+        await collectSource(
+            new SequenceSource({ sequence: { start: 0, stop: 5, step: 2 } })
+        )
+    ).toEqual([{ data: 0 }, { data: 2 }, { data: 4 }]);
+});
+
+test("SequenceSource generates a sequence with a custom field name", async () => {
+    expect(
+        await collectSource(
+            new SequenceSource({ sequence: { start: 0, stop: 3, as: "x" } })
+        )
+    ).toEqual([{ x: 0 }, { x: 1 }, { x: 2 }]);
+});
+
+test("SequenceSource throws on missing 'start' parameter", () => {
+    expect(() => new SequenceSource({ sequence: { stop: 3 } })).toThrow();
+});
+test("SequenceSource throws on missing 'stop' parameter", () => {
+    expect(() => new SequenceSource({ sequence: { start: 0 } })).toThrow();
+});

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

@@ -0,0 +1,16 @@
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").UrlData}
+ */
+export function isUrlData(data: Partial<import("../../spec/data").Data>): data is import("../../spec/data").UrlData;
+export default class UrlSource extends DataSource {
+    /**
+     * @param {import("../../spec/data").UrlData} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params: import("../../spec/data").UrlData, view: import("../../view/view").default);
+    params: import("../../spec/data").UrlData;
+    baseUrl: string;
+}
+import DataSource from "./dataSource";
+//# sourceMappingURL=urlSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"urlSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/urlSource.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,gCAHW,QAAQ,OAAO,iBAAiB,EAAE,IAAI,CAAC,6CAKjD;AAED;IACI;;;OAGG;IACH,oBAHW,OAAO,iBAAiB,EAAE,OAAO,QACjC,OAAO,iBAAiB,EAAE,OAAO,EAO3C;IAFG,0CAAoB;IACpB,gBAAiC;CAoDxC;uBAvEsB,cAAc"}