@genome-spy/core 0.36.0 → 0.37.0

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

@@ -0,0 +1,74 @@
+import { loader as vegaLoader, read } from "vega-loader";
+import { getFormat } from "./dataUtils";
+import DataSource from "./dataSource";
+
+/**
+ * @param {Partial<import("../../spec/data").Data>} data
+ * @returns {data is import("../../spec/data").UrlData}
+ */
+export function isUrlData(data) {
+    return "url" in data;
+}
+
+export default class UrlSource extends DataSource {
+    /**
+     * @param {import("../../spec/data").UrlData} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params, view) {
+        super();
+
+        this.params = params;
+        this.baseUrl = view?.getBaseUrl();
+    }
+
+    get identifier() {
+        return JSON.stringify({ params: this.params, baseUrl: this.baseUrl });
+    }
+
+    async load() {
+        const url = this.params.url;
+
+        /** @type {string[]} */
+        const urls = Array.isArray(url) ? url : [url];
+
+        /** @param {string} url */
+        const load = async (url) =>
+            // TODO: Support chunked loading
+            /** @type {string} */ (
+                vegaLoader({
+                    baseURL: this.baseUrl,
+                })
+                    .load(url)
+                    .catch((/** @type {Error} */ e) => {
+                        // TODO: Include baseurl in the error message. Should be normalized, however.
+                        throw new Error(
+                            `Cannot fetch: ${this.baseUrl}${url}: ${e.message}`
+                        );
+                    })
+            );
+
+        /**
+         * @param {string} text
+         * @param {string} [url]
+         */
+        const readAndParse = (text, url) => {
+            try {
+                /** @type {any[]} */
+                const data = read(text, getFormat(this.params));
+                this.beginBatch({ type: "file", url: url });
+                for (const d of data) {
+                    this._propagate(d);
+                }
+            } catch (e) {
+                throw new Error(`Cannot parse: ${url}: ${e.message}`);
+            }
+        };
+
+        this.reset();
+
+        await Promise.all(urls.map((url) => load(url).then(readAndParse)));
+
+        this.complete();
+    }
+}

package/dist/src/data/transforms/aggregate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A minimal aggregate transform that just counts grouped (by a single field) data items.
+ * Work in progress.
+ *
+ * Eventually this will implement the most of Vega's aggregate transform:
+ * https://vega.github.io/vega/docs/transforms/aggregate/
+ */
+export default class AggregateTransform extends FlowNode {
+    /**
+     * @param {import("../../spec/transform").AggregateParams} params
+     */
+    constructor(params: import("../../spec/transform").AggregateParams);
+    params: import("../../spec/transform").AggregateParams;
+    /** @type {any[]} */
+    buffer: any[];
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/src/data/transforms/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/aggregate.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH;IAKI;;OAEG;IACH,oBAFW,OAAO,sBAAsB,EAAE,eAAe,EAQxD;IAJG,uDAAoB;IAEpB,oBAAoB;IACpB,QADW,GAAG,EAAE,CACA;CAyCvB;qBAjEyC,aAAa"}

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

@@ -0,0 +1,67 @@
+import { group as d3group } from "d3-array";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+import { field } from "../../utils/field";
+import iterateNestedMaps from "../../utils/iterateNestedMaps";
+
+/**
+ * A minimal aggregate transform that just counts grouped (by a single field) data items.
+ * Work in progress.
+ *
+ * Eventually this will implement the most of Vega's aggregate transform:
+ * https://vega.github.io/vega/docs/transforms/aggregate/
+ */
+export default class AggregateTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     * @param {import("../../spec/transform").AggregateParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        /** @type {any[]} */
+        this.buffer = [];
+    }
+
+    reset() {
+        this.buffer = [];
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        this.buffer.push(datum);
+    }
+
+    complete() {
+        const params = this.params;
+
+        const groupby = params.groupby;
+
+        const groupFieldAccessors = groupby.map((f) => field(f));
+
+        // TODO: Fix case where no group fields are specified
+        // @ts-expect-error
+        const groups = d3group(this.buffer, ...groupFieldAccessors);
+
+        for (const [group, data] of iterateNestedMaps(groups)) {
+            /** @type {any} */
+            const datum = {
+                count: data.length,
+            };
+
+            for (let i = 0; i < groupby.length; i++) {
+                datum[groupby[i]] = group[i];
+            }
+
+            this._propagate(datum);
+        }
+
+        super.complete();
+    }
+}

package/dist/src/data/transforms/clone.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Clones the data objects that pass through.
+ */
+export default class CloneTransform extends FlowNode {
+    /** @param {any} datum */
+    handle: (datum: any) => void;
+    /**
+     * Signals that a new batch of data will be propagated.
+     *
+     * @param {import("../../types/flowBatch").FlowBatch} [flowBatch]
+     */
+    beginBatch: (flowBatch?: import("../../types/flowBatch").FlowBatch) => void;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=clone.d.ts.map

package/dist/src/data/transforms/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/clone.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAYY,yBAAyB;IACzB,gBALQ,GAAG,UAK2C;IAO1D;;;;OAIG;IACH,yBAFW,OAAO,uBAAuB,EAAE,SAAS,UAQnD;CAER;qBAtCsD,aAAa"}

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

@@ -0,0 +1,40 @@
+import createCloner from "../../utils/cloner";
+import FlowNode, { BEHAVIOR_CLONES, isFileBatch } from "../flowNode";
+
+/**
+ * Clones the data objects that pass through.
+ */
+export default class CloneTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    constructor() {
+        super();
+
+        /** @param {any} datum */
+        const setupCloner = (datum) => {
+            const clone = createCloner(datum);
+
+            /** @param {any} datum */
+            this.handle = (datum) => this._propagate(clone(datum));
+
+            this.handle(datum);
+        };
+
+        this.handle = setupCloner;
+
+        /**
+         * Signals that a new batch of data will be propagated.
+         *
+         * @param {import("../../types/flowBatch").FlowBatch} [flowBatch]
+         */
+        this.beginBatch = (flowBatch) => {
+            if (isFileBatch(flowBatch)) {
+                // TODO: Only create new cloner if the props change
+                this.handle = setupCloner;
+            }
+            super.beginBatch(flowBatch);
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+import { expect, test } from "vitest";
+import { processData } from "../flowTestUtils";
+import CloneTransform from "./clone";
+
+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.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="external-typings/flatqueue" />
+/**
+ * Computes coverage for sorted segments
+ *
+ * TODO: Binned coverage
+ */
+export default class CoverageTransform extends FlowNode {
+    /**
+     * @param {import("../../spec/transform").CoverageParams} params
+     */
+    constructor(params: import("../../spec/transform").CoverageParams);
+    params: import("../../spec/transform").CoverageParams;
+    startAccessor: import("vega-util").AccessorFn<any>;
+    endAccessor: import("vega-util").AccessorFn<any>;
+    /** @type {function(any):string} */
+    chromAccessor: (arg0: any) => string;
+    /** @type {function(any):number} */
+    weightAccessor: (arg0: any) => number;
+    as: {
+        coverage: string;
+        start: string;
+        end: string;
+        chrom: string;
+    };
+    createSegment: Function;
+    ends: FlatQueue<any>;
+}
+import FlowNode from "../flowNode";
+import FlatQueue from "flatqueue";
+//# sourceMappingURL=coverage.d.ts.map

package/dist/src/data/transforms/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/coverage.js"],"names":[],"mappings":";AAKA;;;;GAIG;AACH;IAKI;;OAEG;IACH,oBAFW,OAAO,sBAAsB,EAAE,cAAc,EA4CvD;IAxCG,sDAAoB;IAEpB,mDAAwC;IACxC,iDAAoC;IAEpC,mCAAmC;IACnC,sBADoB,GAAG,KAAE,MAAM,CAGT;IACtB,mCAAmC;IACnC,uBADoB,GAAG,KAAE,MAAM,CACsC;IAErE;;;;;MAKC;IAGD,wBAgBC;IAGD,qBAA2B;CA2HlC;qBAnLyC,aAAa;sBAHjC,WAAW"}

package/dist/src/data/transforms/coverage.js

@@ -0,0 +1,183 @@
+import FlatQueue from "flatqueue";
+
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+/**
+ * Computes coverage for sorted segments
+ *
+ * TODO: Binned coverage
+ */
+export default class CoverageTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     * @param {import("../../spec/transform").CoverageParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        this.startAccessor = field(params.start);
+        this.endAccessor = field(params.end);
+
+        /** @type {function(any):string} */
+        this.chromAccessor = params.chrom
+            ? field(params.chrom)
+            : (d) => undefined;
+        /** @type {function(any):number} */
+        this.weightAccessor = params.weight ? field(params.weight) : (d) => 1;
+
+        this.as = {
+            coverage: params.as || "coverage",
+            start: params.asStart || params.start,
+            end: params.asEnd || params.end,
+            chrom: params.asChrom || params.chrom,
+        };
+
+        // eslint-disable-next-line no-new-func
+        this.createSegment = /** @type {function} */ (
+            new Function(
+                "start",
+                "end",
+                "coverage",
+                "chrom",
+                "return {" +
+                    Object.entries(this.as)
+                        .filter(([param, prop]) => prop)
+                        .map(
+                            ([param, prop]) =>
+                                `${JSON.stringify(prop)}: ${param}`
+                        )
+                        .join(", ") +
+                    "};"
+            )
+        );
+
+        // End pos as priority, weight as value
+        this.ends = new FlatQueue();
+    }
+
+    reset() {
+        super.reset();
+        this.initialize();
+    }
+
+    initialize() {
+        const asCoverage = this.as.coverage;
+        const asEnd = this.as.end;
+        const asChrom = this.as.chrom;
+
+        const startAccessor = this.startAccessor;
+        const endAccessor = this.endAccessor;
+        const chromAccessor = this.chromAccessor;
+        const weightAccessor = this.weightAccessor;
+
+        /** @type {Record<string, number|string>} used for merging adjacent segment */
+        let bufferedSegment;
+
+        /** @type {string} */
+        let prevChrom;
+
+        /** @type {string} */
+        let chrom;
+
+        // TODO: Whattabout cumulative error when float weights are used?
+        // Howabout https://github.com/d3/d3-array#fsum ?
+        let coverage = 0;
+
+        /** @type {number} */
+        let prevEdge;
+
+        // End pos as priority, weight as value
+        const ends = this.ends;
+        ends.clear();
+
+        /**
+         * @param {number} start
+         * @param {number} end
+         * @param {number} coverage
+         */
+        const pushSegment = (start, end, coverage) => {
+            if (start == end) {
+                return;
+            }
+
+            let extended = false;
+            if (bufferedSegment) {
+                if (bufferedSegment[asCoverage] === coverage) {
+                    // Extend it
+                    bufferedSegment[asEnd] = end;
+                    extended = true;
+                } else if (bufferedSegment[asCoverage] != 0) {
+                    this._propagate(bufferedSegment);
+                }
+            }
+
+            if (!extended) {
+                bufferedSegment = this.createSegment(
+                    start,
+                    end,
+                    coverage,
+                    chrom
+                );
+            }
+        };
+
+        const flushQueue = () => {
+            // Flush queue
+            /** @type {number} */
+            let edge;
+            while ((edge = ends.peekValue()) !== undefined) {
+                pushSegment(prevEdge, edge, coverage);
+                prevEdge = edge;
+                coverage -= ends.pop();
+            }
+            prevEdge = undefined;
+
+            if (bufferedSegment) {
+                this._propagate(bufferedSegment);
+                bufferedSegment = undefined;
+            }
+        };
+
+        /** @param {Record<string, any>} datum */
+        this.handle = (datum) => {
+            const start = startAccessor(datum);
+
+            /** @type {number} */
+            let edge;
+            while ((edge = ends.peekValue()) !== undefined && edge < start) {
+                pushSegment(prevEdge, edge, coverage);
+                prevEdge = edge;
+                coverage -= ends.pop();
+            }
+
+            if (asChrom) {
+                let newChrom = chromAccessor(datum);
+                if (newChrom !== prevChrom) {
+                    flushQueue();
+                    chrom = newChrom;
+                    prevChrom = chrom;
+                }
+            }
+
+            if (prevEdge !== undefined) {
+                pushSegment(prevEdge, start, coverage);
+            }
+            prevEdge = start;
+
+            const weight = weightAccessor(datum);
+            coverage += weight;
+
+            ends.push(weight, endAccessor(datum));
+        };
+
+        this.complete = () => {
+            flushQueue();
+            super.complete();
+        };
+    }
+}

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

@@ -0,0 +1,123 @@
+import { expect, test } from "vitest";
+import CoverageTransform from "./coverage";
+import { processData } from "../flowTestUtils";
+
+/**
+ * @typedef {import("../../spec/transform").CoverageParams} CoverageParams
+ */
+
+/**
+ * @param {CoverageParams} params
+ * @param {any[]} data
+ */
+function transform(params, data) {
+    const t = new CoverageTransform(params);
+    t.initialize();
+    return processData(t, data);
+}
+
+test("Coverage transform produces correct coverage segments", () => {
+    const reads = [
+        [0, 4],
+        [1, 3],
+        [2, 6],
+        [4, 8],
+        [8, 10],
+        [11, 14],
+        [11, 13],
+        [11, 12],
+        [15, 18],
+        [16, 18],
+        [17, 18],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+    }));
+
+    const coverageSegments = [
+        [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],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+        coverage: d[2],
+    }));
+
+    /** @type {CoverageParams} */
+    const coverageConfig = {
+        type: "coverage",
+        start: "start",
+        end: "end",
+    };
+    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
+});
+
+test("Coverage transform handles chromosomes", () => {
+    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("Coverage transform handles weights", () => {
+    const reads = [
+        [0, 4, 1],
+        [1, 3, 2],
+        [2, 6, 3],
+        [8, 10, -1],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+        weight: d[2],
+    }));
+
+    const coverageSegments = [
+        [0, 1, 1],
+        [1, 2, 3],
+        [2, 3, 6],
+        [3, 4, 4],
+        [4, 6, 3],
+        [8, 10, -1],
+    ].map((d) => ({
+        start: d[0],
+        end: d[1],
+        coverage: d[2],
+    }));
+
+    /** @type {CoverageParams} */
+    const coverageConfig = {
+        type: "coverage",
+        chrom: "chrom",
+        start: "start",
+        end: "end",
+        weight: "weight",
+    };
+
+    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
+});

package/dist/src/data/transforms/filter.d.ts

@@ -0,0 +1,12 @@
+export default class FilterTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").FilterParams} params
+     */
+    constructor(params: import("../../spec/transform").FilterParams);
+    params: import("../../spec/transform").FilterParams;
+    /** @type {(datum: any) => boolean} */
+    predicate: (datum: any) => boolean;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=filter.d.ts.map

package/dist/src/data/transforms/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/filter.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,oBAFW,OAAO,sBAAsB,EAAE,YAAY,EAQrD;IAJG,oDAAoB;IAEpB,sCAAsC;IACtC,mBADmB,GAAG,KAAK,OAAO,CACR;CAmBjC;qBA/BoB,aAAa"}

package/dist/src/data/transforms/filter.js

@@ -0,0 +1,33 @@
+import createFunction from "../../utils/expression";
+import FlowNode from "../flowNode";
+
+export default class FilterTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").FilterParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        /** @type {(datum: any) => boolean} */
+        this.predicate = undefined;
+    }
+
+    initialize() {
+        this.predicate = createFunction(
+            this.params.expr,
+            this.getGlobalObject()
+        );
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        if (this.predicate(datum)) {
+            this._propagate(datum);
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { expect, test } from "vitest";
+import { processData } from "../flowTestUtils";
+import FilterTransform from "./filter";
+
+test("FilterTransform filter rows", () => {
+    const data = [1, 2, 3, 4, 5, 6].map((x) => ({ x }));
+
+    /** @type {import("../../spec/transform").FilterParams} */
+    const filterParams = {
+        type: "filter",
+        expr: "datum.x > 3 && datum.x != 5",
+    };
+
+    const t = new FilterTransform(filterParams);
+    t.initialize();
+
+    expect(processData(t, data)).toEqual([4, 6].map((x) => ({ x })));
+});

package/dist/src/data/transforms/filterScoredLabels.d.ts

@@ -0,0 +1,29 @@
+export default class FilterScoredLabelsTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").FilterScoredLabelsParams} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params: import("../../spec/transform").FilterScoredLabelsParams, view: import("../../view/view").default);
+    params: import("../../spec/transform").FilterScoredLabelsParams;
+    /** @type {any[]} */
+    _data: any[];
+    channel: "x" | "y";
+    posAccessor: import("vega-util").AccessorFn<any>;
+    posBisector: import("d3-array").Bisector<any, any>;
+    scoreAccessor: import("vega-util").AccessorFn<any>;
+    widthAccessor: import("vega-util").AccessorFn<any>;
+    /** @type {function(any):any} */
+    laneAccessor: (arg0: any) => any;
+    padding: number;
+    /** @type {Map<any, ReservationMap>} */
+    reservationMaps: Map<any, ReservationMap>;
+    resolution: import("../../view/scaleResolution").default;
+    schedule: () => void;
+    _scores: any[];
+    _filterAndPropagate(): void;
+    groups: Map<any, any>;
+}
+import FlowNode from "../flowNode";
+import ReservationMap from "../../utils/reservationMap";
+//# sourceMappingURL=filterScoredLabels.d.ts.map

package/dist/src/data/transforms/filterScoredLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterScoredLabels.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/filterScoredLabels.js"],"names":[],"mappings":"AAMA;IAKI;;;;OAIG;IACH,oBAHW,OAAO,sBAAsB,EAAE,wBAAwB,QACvD,OAAO,iBAAiB,EAAE,OAAO,EA2C3C;IAtCG,gEAAoB;IAEpB,oBAAoB;IACpB,OADW,GAAG,EAAE,CACD;IAEf,mBAAoC;IAMpC,iDAAyC;IACzC,mDAA6C;IAC7C,mDAA6C;IAC7C,mDAA6C;IAC7C,gCAAgC;IAChC,qBADoB,GAAG,KAAE,GAAG,CAGd;IACd,gBAAuC;IAEvC,uCAAuC;IACvC,iBADW,IAAI,GAAG,EAAE,cAAc,CAAC,CACH;IAEhC,yDAAuD;IAIvD,qBAAuE;IAgBvE,eAAiD;IAWrD,4BA4CC;IAKG,sBAAuB;CAU9B;qBApI2C,aAAa;2BAE9B,4BAA4B"}