@genome-spy/core 0.36.0 → 0.37.0

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

@@ -0,0 +1,166 @@
+import { BigWig } from "@gmod/bbi";
+import { RemoteFile } from "generic-filehandle";
+
+import { debounce } from "../../../utils/debounce";
+import SingleAxisLazySource from "./singleAxisLazySource";
+import windowedMixin from "./windowedMixin";
+import addBaseUrl from "../../../utils/addBaseUrl";
+
+/**
+ *
+ */
+export default class BigWigSource extends windowedMixin(SingleAxisLazySource) {
+    /** @type {number[]} */
+    reductionLevels = [];
+
+    /** Keep track of the order of the requests */
+    lastRequestId = 0;
+
+    /**
+     * @param {import("../../../spec/data").BigWigData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params, view) {
+        /** @type {import("../../../spec/data").BigWigData} */
+        const paramsWithDefaults = {
+            pixelsPerBin: 2,
+            channel: "x",
+            ...params,
+        };
+
+        super(view, paramsWithDefaults.channel);
+
+        this.params = paramsWithDefaults;
+
+        if (!this.params.url) {
+            throw new Error("No URL provided for BigWigSource");
+        }
+
+        this.bbi = new BigWig({
+            filehandle: new RemoteFile(
+                addBaseUrl(this.params.url, this.view.getBaseUrl())
+            ),
+        });
+
+        this.doDebouncedRequest = debounce(
+            this.doRequest.bind(this),
+            200,
+            false
+        );
+
+        this.headerPromise = this.bbi.getHeader();
+
+        this.headerPromise.then((header) => {
+            this.reductionLevels = /** @type {{reductionLevel: number}[]} */ (
+                header.zoomLevels
+            )
+                .map((z) => z.reductionLevel)
+                .reverse();
+
+            // Add the non-reduced level. Not sure if this is the best way to do it.
+            // Afaik, the non-reduced bin size is not available in the header.
+            this.reductionLevels.push(1);
+        });
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    async onDomainChanged(domain) {
+        // Header must be available to determine the reduction level
+        await this.headerPromise;
+
+        // TODO: Postpone the initial load until layout is computed and remove 700.
+        const length = this.getAxisLength() || 700;
+
+        const reductionLevel = findReductionLevel(
+            domain,
+            length,
+            this.reductionLevels
+        );
+
+        // The sensible minimum window size actually depends on the non-reduced data density...
+        // Using 5000 as a default to avoid too many requests.
+        const windowSize = Math.max(reductionLevel * length, 5000);
+
+        const quantizedInterval = this.quantizeInterval(domain, windowSize);
+
+        if (this.checkAndUpdateLastInterval(quantizedInterval)) {
+            this.doDebouncedRequest(quantizedInterval, reductionLevel);
+        }
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     * @param {number} reductionLevel
+     */
+    async doRequest(interval, reductionLevel) {
+        const featureResponse = await this.getFeatures(
+            interval,
+            1 / 2 / reductionLevel / this.params.pixelsPerBin
+        );
+
+        // Discard late responses
+        if (featureResponse.requestId < this.lastRequestId) {
+            return;
+        }
+
+        this.publishData(featureResponse.features);
+    }
+
+    /**
+     *
+     * @param {number[]} interval
+     * @param {number} scale
+     */
+    async getFeatures(interval, scale) {
+        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((d) =>
+                this.bbi
+                    .getFeatures(d.chrom, d.startPos, d.endPos, {
+                        scale,
+                        signal: abortController.signal,
+                    })
+                    .then((features) =>
+                        features.map((f) => ({
+                            chrom: d.chrom,
+                            start: f.start,
+                            end: f.end,
+                            score: f.score,
+                        }))
+                    )
+            )
+        );
+
+        return {
+            requestId,
+            abort: () => abortController.abort(),
+            features: featuresWithChrom.flat(), // TODO: Use batches, not flat
+        };
+    }
+}
+
+/**
+ * @param {number[]} domain
+ * @param {number} widthInPixels view width in pixels
+ * @param {number[]} reductionLevels
+ */
+function findReductionLevel(domain, widthInPixels, reductionLevels) {
+    const bpPerPixel = (domain[1] - domain[0]) / widthInPixels;
+    return (
+        reductionLevels.find((r) => r < bpPerPixel) ?? reductionLevels.at(-1)
+    );
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @extends {TabixSource<import("@gmod/gff").GFF3Feature>}
+ */
+export default class Gff3Source extends TabixSource<import("@gmod/gff").GFF3Feature> {
+    constructor(params: import("../../../spec/data").TabixData, view: import("../../../view/view").default);
+}
+import TabixSource from "./tabixSource";
+//# sourceMappingURL=gff3Source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gff3Source.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/gff3Source.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAaoF,wGAAsrC;CADzwC;wBAjBuB,eAAe"}

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

@@ -0,0 +1,19 @@
+import gff from "@gmod/gff";
+import TabixSource from "./tabixSource";
+
+/**
+ * @extends {TabixSource<import("@gmod/gff").GFF3Feature>}
+ */
+export default class Gff3Source extends TabixSource {
+    /**
+     * @param {string[]} lines
+     */
+    _parseFeatures(lines) {
+        // eslint-disable-next-line no-sync
+        const features = gff.parseStringSync(lines.join("\n"), {
+            parseSequences: false,
+        });
+
+        return features;
+    }
+}

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

@@ -0,0 +1,30 @@
+declare const IndexedFastaSource_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        lastQuantizedInterval: number[];
+        quantizeInterval(interval: number[], windowSize: number): number[];
+        checkAndUpdateLastInterval(interval: number[]): boolean;
+    };
+} & typeof SingleAxisLazySource;
+/**
+ *
+ */
+export default class IndexedFastaSource extends IndexedFastaSource_base {
+    /**
+     * @param {import("../../../spec/data").IndexedFastaData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params: import("../../../spec/data").IndexedFastaData, view: import("../../../view/view").default);
+    params: import("../../../spec/data").IndexedFastaData;
+    fasta: IndexedFasta;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    onDomainChanged(domain: number[]): Promise<void>;
+}
+import SingleAxisLazySource from "./singleAxisLazySource";
+import { IndexedFasta } from "@gmod/indexedfasta";
+export {};
+//# sourceMappingURL=indexedFastaSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexedFastaSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/indexedFastaSource.js"],"names":[],"mappings":";;;;;;;;AAcA;;GAEG;AACH;IAGI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,gBAAgB,QAC7C,OAAO,oBAAoB,EAAE,OAAO,EAyB9C;IAbG,sDAAgC;IAShC,oBAGE;IAGN;;;;OAIG;IACH,wBAFW,MAAM,EAAE,iBAgClB;CACJ;iCAjFgC,wBAAwB;6BAH5B,oBAAoB"}

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

@@ -0,0 +1,86 @@
+import { Buffer } from "buffer";
+import { IndexedFasta } from "@gmod/indexedfasta";
+import { RemoteFile } from "generic-filehandle";
+
+import SingleAxisLazySource from "./singleAxisLazySource";
+import windowedMixin from "./windowedMixin";
+import addBaseUrl from "@genome-spy/core/utils/addBaseUrl";
+
+// Hack needed by @gmod/indexedfasta
+// TODO: Submit a PR to @gmod/indexedfasta to make this unnecessary
+if (typeof window !== "undefined") {
+    window.Buffer = Buffer;
+}
+
+/**
+ *
+ */
+export default class IndexedFastaSource extends windowedMixin(
+    SingleAxisLazySource
+) {
+    /**
+     * @param {import("../../../spec/data").IndexedFastaData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params, view) {
+        /** @type {import("../../../spec/data").IndexedFastaData} */
+        const paramsWithDefaults = {
+            channel: "x",
+            windowSize: 7000,
+            ...params,
+        };
+
+        super(view, paramsWithDefaults.channel);
+
+        this.params = paramsWithDefaults;
+
+        if (!this.params.url) {
+            throw new Error("No URL provided for IndexedFastaSource");
+        }
+
+        const withBase = (/** @type {string} */ uri) =>
+            new RemoteFile(addBaseUrl(uri, this.view.getBaseUrl()));
+
+        this.fasta = new IndexedFasta({
+            fasta: withBase(this.params.url),
+            fai: withBase(this.params.indexUrl ?? this.params.url + ".fai"),
+        });
+    }
+
+    /**
+     * 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)) {
+            const discreteChromosomeIntervals =
+                this.genome.continuousToDiscreteChromosomeIntervals(
+                    quantizedInterval
+                );
+
+            // TODO: Error handling
+            const sequencesWithChrom = await Promise.all(
+                discreteChromosomeIntervals.map((d) =>
+                    this.fasta
+                        .getSequence(d.chrom, d.startPos, d.endPos)
+                        .then((sequence) => ({
+                            chrom: d.chrom,
+                            start: d.startPos,
+                            sequence,
+                        }))
+                )
+            );
+
+            this.publishData(sequencesWithChrom);
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Base class for data sources that listen a domain and propagate data lazily.
+ */
+export default class SingleAxisLazySource extends DataSource {
+    /**
+     * @param {import("../../../view/view").default} view
+     * @param {import("../../../spec/channel").PrimaryPositionalChannel} channel
+     */
+    constructor(view: import("../../../view/view").default, channel: import("../../../spec/channel").PrimaryPositionalChannel);
+    view: import("../../../view/view").default;
+    /** @type {import("../../../spec/channel").PrimaryPositionalChannel}  */
+    channel: import("../../../spec/channel").PrimaryPositionalChannel;
+    scaleResolution: import("@genome-spy/core/view/scaleResolution").default;
+    /**
+     * Returns the length of the axis in pixels. Chooses the smallest of the views.
+     * They should all be the same, but some exotic configuration might break that assumption.
+     */
+    getAxisLength(): number;
+    /**
+     * Convenience getter for genome.
+     */
+    get genome(): import("../../../genome/genome").default;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     * @param {import("../../../spec/genome").ChromosomalLocus[]} complexDomain Chrom/Pos domain
+     */
+    onDomainChanged(domain: number[], complexDomain: import("../../../spec/genome").ChromosomalLocus[]): Promise<void>;
+    /**
+     * TODO: Get rid of this method.
+     * Rendering should be requested by the collector.
+     */
+    requestRender(): void;
+    /**
+     *
+     * @param {import("../../flowNode").Datum[]} data
+     */
+    publishData(data: import("../../flowNode").Datum[]): void;
+}
+import DataSource from "../dataSource";
+//# sourceMappingURL=singleAxisLazySource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"singleAxisLazySource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/singleAxisLazySource.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;;OAGG;IACH,kBAHW,OAAO,oBAAoB,EAAE,OAAO,WACpC,OAAO,uBAAuB,EAAE,wBAAwB,EAiDlE;IA5CG,2CAAgB;IAYhB,wEAAwE;IACxE,SADW,OAAO,uBAAuB,EAAE,wBAAwB,CAC7C;IAEtB,yEAA4D;IA+BhE;;;OAGG;IACH,wBAWC;IAED;;OAEG;IACH,uDAEC;IAED;;;;;OAKG;IACH,wBAHW,MAAM,EAAE,iBACR,OAAO,sBAAsB,EAAE,gBAAgB,EAAE,iBAI3D;IAED;;;OAGG;IACH,sBAGC;IAQD;;;OAGG;IACH,kBAFW,OAAO,gBAAgB,EAAE,KAAK,EAAE,QAe1C;CACJ;uBA/HsB,eAAe"}

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

@@ -0,0 +1,129 @@
+import UnitView from "@genome-spy/core/view/unitView";
+import DataSource from "../dataSource";
+import { reconfigureScales } from "@genome-spy/core/view/scaleResolution";
+
+/**
+ * Base class for data sources that listen a domain and propagate data lazily.
+ */
+export default class SingleAxisLazySource extends DataSource {
+    /**
+     * @param {import("../../../view/view").default} view
+     * @param {import("../../../spec/channel").PrimaryPositionalChannel} channel
+     */
+    constructor(view, channel) {
+        super();
+
+        this.view = view;
+
+        if (!channel) {
+            throw new Error(
+                `No channel has been specified for the dynamic data source. Must be either "x" or "y".`
+            );
+        } else if (channel !== "x" && channel !== "y") {
+            throw new Error(
+                `Invalid channel specified for the dynamic data source: ${channel}. Must be either "x" or "y"`
+            );
+        }
+
+        /** @type {import("../../../spec/channel").PrimaryPositionalChannel}  */
+        this.channel = channel;
+
+        this.scaleResolution = this.view.getScaleResolution(channel);
+        if (!this.scaleResolution) {
+            const sentences = [
+                `The dynamic data source cannot find a resolved scale for channel "${channel}".`,
+            ];
+            if (!(this.view instanceof UnitView)) {
+                sentences.push(
+                    `Make sure the view has a "shared" scale resolution as it is not a unit view.`
+                );
+            }
+
+            throw new Error(sentences.join(" "));
+        }
+
+        const fireDomainChanged = () => {
+            if (this.view.isVisible()) {
+                this.onDomainChanged(
+                    this.scaleResolution.getDomain(),
+                    /** @type {import("../../../spec/genome").ChromosomalLocus[]} */
+                    (this.scaleResolution.getComplexDomain())
+                );
+            }
+        };
+
+        this.scaleResolution.addEventListener("domain", fireDomainChanged);
+        this.view.context.addBroadcastListener(
+            "layoutComputed",
+            fireDomainChanged
+        );
+    }
+
+    /**
+     * Returns the length of the axis in pixels. Chooses the smallest of the views.
+     * They should all be the same, but some exotic configuration might break that assumption.
+     */
+    getAxisLength() {
+        const lengths = this.scaleResolution.members
+            .map(
+                (m) =>
+                    m.view.coords?.[this.channel === "x" ? "width" : "height"]
+            )
+            .filter((len) => len > 0);
+
+        return lengths.length
+            ? lengths.reduce((a, b) => Math.min(a, b), 10000)
+            : 0;
+    }
+
+    /**
+     * Convenience getter for genome.
+     */
+    get genome() {
+        return this.scaleResolution.getGenome();
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     * @param {import("../../../spec/genome").ChromosomalLocus[]} complexDomain Chrom/Pos domain
+     */
+    async onDomainChanged(domain, complexDomain) {
+        // Override me
+    }
+
+    /**
+     * TODO: Get rid of this method.
+     * Rendering should be requested by the collector.
+     */
+    requestRender() {
+        // An awfully hacky way.
+        this.view.context.animator.requestRender();
+    }
+
+    async load() {
+        // Dummy initialization cycle. TODO: Figure out why this is needed.
+        this.reset();
+        this.complete();
+    }
+
+    /**
+     *
+     * @param {import("../../flowNode").Datum[]} data
+     */
+    publishData(data) {
+        this.reset();
+        this.beginBatch({ type: "file" });
+
+        for (const d of data) {
+            this._propagate(d);
+        }
+
+        this.complete();
+
+        reconfigureScales(this.view);
+
+        this.requestRender();
+    }
+}

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

@@ -0,0 +1,54 @@
+declare const TabixSource_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        lastQuantizedInterval: number[];
+        quantizeInterval(interval: number[], windowSize: number): number[];
+        checkAndUpdateLastInterval(interval: number[]): boolean;
+    };
+} & typeof SingleAxisLazySource;
+/**
+ * @template T
+ */
+export default class TabixSource<T> extends TabixSource_base {
+    /**
+     * @param {import("../../../spec/data").TabixData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params: import("../../../spec/data").TabixData, view: import("../../../view/view").default);
+    /** Keep track of the order of the requests */
+    lastRequestId: number;
+    /** @type {TabixIndexedFile} */
+    tbiIndex: TabixIndexedFile;
+    params: import("../../../spec/data").TabixData;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    onDomainChanged(domain: number[]): Promise<void>;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     */
+    doRequest(interval: number[]): Promise<void>;
+    /**
+     *
+     * @param {number[]} interval
+     */
+    getFeatures(interval: number[]): Promise<{
+        requestId: number;
+        abort: () => void;
+        features: T[];
+    }>;
+    /**
+     * @abstract
+     * @param {string[]} lines
+     * @returns {T[]}
+     */
+    _parseFeatures(lines: string[]): T[];
+}
+import SingleAxisLazySource from "./singleAxisLazySource";
+import { TabixIndexedFile } from "@gmod/tabix";
+export {};
+//# sourceMappingURL=tabixSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tabixSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/tabixSource.js"],"names":[],"mappings":";;;;;;;;AAQA;;GAEG;AACH;IAOI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,SAAS,QACtC,OAAO,oBAAoB,EAAE,OAAO,EAoC9C;IA5CD,8CAA8C;IAC9C,sBAAkB;IAElB,+BAA+B;IAC/B,UADW,gBAAgB,CAClB;IAiBL,+CAAgC;IAyBpC;;;;OAIG;IACH,wBAFW,MAAM,EAAE,iBAclB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,iBAWlB;IAED;;;OAGG;IACH,sBAFW,MAAM,EAAE;;;;OAkClB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,CAAC,EAAE,CAIf;CACJ;iCAxIgC,wBAAwB;iCAFxB,aAAa"}