@genome-spy/core 0.30.0 → 0.30.2

package/src/data/transforms/aggregate.js

@@ -1,70 +0,0 @@
-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/
- *
- * @typedef {import("../../spec/transform").AggregateParams} AggregateParams
- */
-
-export default class AggregateTransform extends FlowNode {
-    get behavior() {
-        return BEHAVIOR_CLONES;
-    }
-
-    /**
-     * @param {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/src/data/transforms/clone.js

@@ -1,40 +0,0 @@
-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("../flowNode").FlowBatch} [flowBatch]
-         */
-        this.beginBatch = (flowBatch) => {
-            if (isFileBatch(flowBatch)) {
-                // TODO: Only create new cloner if the props change
-                this.handle = setupCloner;
-            }
-            super.beginBatch(flowBatch);
-        };
-    }
-}

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

@@ -1,11 +0,0 @@
-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/src/data/transforms/coverage.js

@@ -1,187 +0,0 @@
-import FlatQueue from "flatqueue";
-
-import { field } from "../../utils/field";
-import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
-
-/**
- * @typedef {import("../../spec/transform").CoverageParams} CoverageParams
- */
-
-/**
- * Computes coverage for sorted segments
- *
- * TODO: Binned coverage
- */
-export default class CoverageTransform extends FlowNode {
-    get behavior() {
-        return BEHAVIOR_CLONES;
-    }
-
-    /**
-     * @param {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/src/data/transforms/coverage.test.js

@@ -1,123 +0,0 @@
-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/src/data/transforms/filter.js

@@ -1,37 +0,0 @@
-import createFunction from "../../utils/expression";
-import FlowNode from "../flowNode";
-
-/**
- * @typedef {import("../../spec/transform").FilterParams} FilterParams
- */
-
-export default class FilterTransform extends FlowNode {
-    /**
-     *
-     * @param {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/src/data/transforms/filter.test.js

@@ -1,18 +0,0 @@
-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/src/data/transforms/filterScoredLabels.js

@@ -1,134 +0,0 @@
-import { bisector } from "d3-array";
-import FlowNode from "../flowNode";
-import { topKSlice } from "../../utils/topK";
-import ReservationMap from "../../utils/reservationMap";
-import { field } from "../../utils/field";
-
-/**
- * @typedef {import("../../spec/transform").FilterScoredLabelsParams} Params
- * @typedef {import("../../view/view").default} View
- */
-export default class FilterScoredLabelsTransform extends FlowNode {
-    /**
-     *
-     * @param {Params} params
-     * @param {View} view
-     */
-    constructor(params, view) {
-        super();
-
-        this.params = params;
-
-        /** @type {any[]} */
-        this._data = [];
-
-        this.channel = params.channel ?? "x";
-
-        if (!["x", "y"].includes(this.channel)) {
-            throw new Error("Invalid channel: " + this.channel);
-        }
-
-        this.posAccessor = field(this.params.pos);
-        this.posBisector = bisector(this.posAccessor);
-        this.scoreAccessor = field(this.params.score);
-        this.widthAccessor = field(this.params.width);
-        /** @type {function(any):any} */
-        this.laneAccessor = this.params.lane
-            ? field(this.params.lane)
-            : (d) => 0;
-        this.padding = this.params.padding ?? 0;
-
-        /** @type {Map<any, ReservationMap>} */
-        this.reservationMaps = new Map();
-
-        this.resolution = view.getScaleResolution(this.channel);
-
-        // Synchronize propagation with rendering because we need both the domain and the range (length of the axis).
-        const callback = () => this._filterAndPropagate();
-        this.schedule = () => view.context.animator.requestTransition(callback);
-
-        // Propagate when the domain changes
-        this.resolution.addEventListener("domain", (scale) => this.schedule());
-
-        // Propagate when layout changes. Abusing a "private" method.
-        // TODO: Provide another attachment point, in view context for example
-        view._addBroadcastHandler("layoutComputed", () => this.schedule());
-
-        // TODO: Remove observers when this FlowNode is thrown away.
-    }
-
-    complete() {
-        const posAccessor = this.posAccessor;
-        this._data.sort((a, b) => posAccessor(a) - posAccessor(b));
-
-        this._scores = this._data.map(this.scoreAccessor);
-
-        for (const lane of new Set(this._data.map(this.laneAccessor))) {
-            this.reservationMaps.set(lane, new ReservationMap(200));
-        }
-
-        this.schedule();
-
-        super.complete();
-    }
-
-    _filterAndPropagate() {
-        super.reset();
-
-        const scale = this.resolution.getScale();
-        const rangeSpan =
-            this.resolution.members[0].view.coords?.[
-                this.channel == "x" ? "width" : "height"
-            ];
-        if (!rangeSpan) {
-            // The view size is not (yet) available
-            return;
-        }
-
-        for (const reservationMap of this.reservationMaps.values()) {
-            reservationMap.reset();
-        }
-
-        const domain = scale.domain();
-        const k = 70; // TODO: Configurable
-
-        // Find the maximum of k elements from the visible domain in priority order
-        const topIndices = topKSlice(
-            this._scores,
-            k,
-            this.posBisector.left(this._data, domain[0]),
-            this.posBisector.right(this._data, domain[1])
-        );
-
-        // Try to fit the elements on the available lanes and propagate if there was room
-        for (const i of topIndices) {
-            const datum = this._data[i];
-            const pos = scale(this.posAccessor(datum)) * rangeSpan;
-            const halfWidth = this.widthAccessor(datum) / 2 + this.padding;
-
-            if (
-                this.reservationMaps
-                    .get(this.laneAccessor(datum))
-                    .reserve(pos - halfWidth, pos + halfWidth)
-            ) {
-                this._propagate(datum);
-            }
-        }
-
-        super.complete();
-    }
-
-    reset() {
-        super.reset();
-        this._data = [];
-        this.groups = new Map();
-    }
-
-    /**
-     *
-     * @param {import("../flowNode").Datum} datum
-     */
-    handle(datum) {
-        this._data.push(datum);
-    }
-}

package/src/data/transforms/flattenCompressedExons.js

@@ -1,57 +0,0 @@
-import { field } from "../../utils/field";
-import numberExtractor from "../../utils/numberExtractor";
-import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
-
-/**
- * @typedef {import("../../spec/transform").FlattenCompressedExonsParams} FlattenCompressedExonsParams
- */
-
-/**
- * Flattens "run-length encoded" exons. The transforms inputs the start
- * coordinate of the gene body and a comma-delimited string of alternating
- * intron and exon lengths. A new datum is created for each exon.
- */
-export default class FlattenCompressedExonsTransform extends FlowNode {
-    get behavior() {
-        return BEHAVIOR_CLONES;
-    }
-
-    /**
-     *
-     * @param {FlattenCompressedExonsParams} params
-     */
-    constructor(params) {
-        super();
-
-        const exonsAccessor = field(params.exons ?? "exons");
-        const startAccessor = field(params.start ?? "start");
-        const [exonStart, exonEnd] = params.as || ["exonStart", "exonEnd"];
-
-        /**
-         *
-         * @param {any} datum
-         */
-        this.handle = (datum) => {
-            let upper = startAccessor(datum);
-            let lower = upper;
-
-            let inExon = true;
-            const exons = exonsAccessor(datum);
-            for (const token of numberExtractor(exons)) {
-                if (inExon) {
-                    lower = upper + token;
-                } else {
-                    upper = lower + token;
-
-                    const newRow = Object.assign({}, datum);
-                    newRow[exonStart] = lower;
-                    newRow[exonEnd] = upper;
-
-                    this._propagate(newRow);
-                }
-
-                inExon = !inExon;
-            }
-        };
-    }
-}