@genome-spy/core 0.36.1 → 0.37.1

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

@@ -0,0 +1,35 @@
+import createFunction from "../../utils/expression";
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+
+export default class FormulaTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {import("../../spec/transform").FormulaParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        this.as = params.as;
+
+        /** @type {(datum: any) => any} */
+        this.fn = undefined;
+    }
+
+    initialize() {
+        this.fn = createFunction(this.params.expr, this.getGlobalObject());
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        datum[this.as] = this.fn(datum);
+        this._propagate(datum);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { expect, test } from "vitest";
+import { processData } from "../flowTestUtils";
+import FormulaTransform from "./formula";
+
+test("FormulaTransform", () => {
+    const data = [{ a: 2 }, { a: 3 }];
+
+    const t = new FormulaTransform({
+        type: "formula",
+        expr: "datum.a * 2",
+        as: "b",
+    });
+    t.initialize();
+
+    expect(processData(t, data)).toEqual([
+        { a: 2, b: 4 },
+        { a: 3, b: 6 },
+    ]);
+});

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

@@ -0,0 +1,40 @@
+export const DEFAULT_AS: "_uniqueId";
+export const BLOCK_SIZE: 10000;
+/**
+ * Assigns unique identifiers for tuples that pass through this transform.
+ *
+ * The identifiers are reserved in equally sized blocks, allowing for
+ * quick lookup of the IdentifierTransform instance that assigned the id.
+ * This is mainly used for creating ids that can be used for picking, i.e.,
+ * selecting rendered data items by hovering or clicking.
+ */
+export default class IdentifierTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").IdentifierParams} params
+     */
+    constructor(params: import("../../spec/transform").IdentifierParams);
+    params: import("../../spec/transform").IdentifierParams;
+    as: string;
+    /**
+     * The block indexes reserved by this transform instance.
+     * @type {number[]}
+     */
+    _blocks: number[];
+    /**
+     * The number of blocks used
+     */
+    _usedBlocks: number;
+    /**
+     * The next advancement allocates the initial block for this instance
+     */
+    _id: number;
+    /**
+     * @returns {number}
+     */
+    _nextId(): number;
+    _getBlock(): number;
+    _reserveBlock(): number;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=identifier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identifier.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/identifier.js"],"names":[],"mappings":"AAEA,qCAAsC;AAEtC,+BAAgC;AAehC;;;;;;;GAOG;AACH;IAKI;;;OAGG;IACH,oBAFW,OAAO,sBAAsB,EAAE,gBAAgB,EAuBzD;IAnBG,wDAAoB;IAEpB,WAAiC;IAEjC;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;OAEG;IACH,oBAAoB;IAEpB;;OAEG;IACH,YAAa;IAuBjB;;OAEG;IACH,WAFa,MAAM,CAOlB;IAED,oBAMC;IAED,wBAOC;CACJ;qBAzG2C,aAAa"}

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

@@ -0,0 +1,106 @@
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+
+export const DEFAULT_AS = "_uniqueId";
+
+export const BLOCK_SIZE = 10000;
+
+/**
+ * TODO: The reservation map should be bound to GenomeSpy instances.
+ * Because it's now global, there's a higher risk that we run out of ids.
+ *
+ * TODO: Identifier transforms should be removed from the reservation map
+ * when a transform is removed from the flow.
+ *
+ * The first block is reserved for "none".
+ *
+ * @type {IdentifierTransform[]}
+ */
+const reservationMap = [null];
+
+/**
+ * Assigns unique identifiers for tuples that pass through this transform.
+ *
+ * The identifiers are reserved in equally sized blocks, allowing for
+ * quick lookup of the IdentifierTransform instance that assigned the id.
+ * This is mainly used for creating ids that can be used for picking, i.e.,
+ * selecting rendered data items by hovering or clicking.
+ */
+export default class IdentifierTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {import("../../spec/transform").IdentifierParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        this.as = params.as ?? DEFAULT_AS;
+
+        /**
+         * The block indexes reserved by this transform instance.
+         * @type {number[]}
+         */
+        this._blocks = [];
+
+        /**
+         * The number of blocks used
+         */
+        this._usedBlocks = 0;
+
+        /**
+         * The next advancement allocates the initial block for this instance
+         */
+        this._id = -1;
+    }
+
+    initialize() {
+        //
+    }
+
+    reset() {
+        super.reset();
+
+        this._usedBlocks = 0;
+        this._id = -1;
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        datum[this.as] = this._nextId();
+        this._propagate(datum);
+    }
+
+    /**
+     * @returns {number}
+     */
+    _nextId() {
+        if (++this._id % BLOCK_SIZE == 0) {
+            this._id = this._getBlock() * BLOCK_SIZE;
+        }
+        return this._id;
+    }
+
+    _getBlock() {
+        if (this._usedBlocks < this._blocks.length) {
+            return this._blocks[this._usedBlocks++];
+        }
+
+        return this._reserveBlock();
+    }
+
+    _reserveBlock() {
+        const blockId = reservationMap.length;
+        reservationMap[blockId] = this;
+        this._blocks.push(blockId);
+        this._usedBlocks++;
+
+        return blockId;
+    }
+}

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

@@ -0,0 +1,83 @@
+import { expect, test } from "vitest";
+import { range } from "d3-array";
+import { processData } from "../flowTestUtils";
+import IdentifierTransform, { BLOCK_SIZE, DEFAULT_AS } from "./identifier";
+
+test("An IdentifierTransform adds identifiers correctly", () => {
+    const data = range(BLOCK_SIZE * 2).map((x) => ({ data: x }));
+
+    const identifiedData = processData(
+        new IdentifierTransform({ type: "identifier" }),
+        data
+    );
+
+    // The fist block is skipped
+    const firstId = BLOCK_SIZE;
+
+    expect(identifiedData[0]).toEqual({ data: 0, [DEFAULT_AS]: firstId });
+    expect(identifiedData[1]).toEqual({ data: 1, [DEFAULT_AS]: firstId + 1 });
+    expect(identifiedData[BLOCK_SIZE]).toEqual({
+        data: BLOCK_SIZE,
+        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+    });
+    expect(identifiedData[BLOCK_SIZE + 1]).toEqual({
+        data: BLOCK_SIZE + 1,
+        [DEFAULT_AS]: firstId + BLOCK_SIZE + 1,
+    });
+});
+
+test("Another transform instance adds identifiers correctly", () => {
+    const data = range(BLOCK_SIZE * 2).map((x) => ({ data: x }));
+    // Another instance
+    const identifiedData = processData(
+        new IdentifierTransform({ type: "identifier" }),
+        data
+    );
+
+    // The fist block was skipped and the previous test case consumed two blocks
+    const firstId = BLOCK_SIZE * 3;
+
+    expect(identifiedData[0]).toEqual({ data: 0, [DEFAULT_AS]: firstId });
+    expect(identifiedData[1]).toEqual({ data: 1, [DEFAULT_AS]: firstId + 1 });
+    expect(identifiedData[BLOCK_SIZE]).toEqual({
+        data: BLOCK_SIZE,
+        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+    });
+    expect(identifiedData[BLOCK_SIZE + 1]).toEqual({
+        data: BLOCK_SIZE + 1,
+        [DEFAULT_AS]: firstId + BLOCK_SIZE + 1,
+    });
+});
+
+test("IdentifierTransform recycles allocated blocks", () => {
+    let data = range(BLOCK_SIZE * 2).map((x) => ({ data: x }));
+
+    const transform = new IdentifierTransform({ type: "identifier" });
+    let identifiedData = processData(transform, data);
+
+    let firstId = BLOCK_SIZE * 5;
+
+    expect(identifiedData[0]).toEqual({ data: 0, [DEFAULT_AS]: firstId });
+    expect(identifiedData[BLOCK_SIZE]).toEqual({
+        data: BLOCK_SIZE,
+        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+    });
+
+    data = range(BLOCK_SIZE * 3).map((x) => ({ data: x }));
+
+    // Resetting the transform. It should now reuse the allocated blocks.
+    transform.reset();
+    identifiedData = processData(transform, data);
+
+    expect(identifiedData[0]).toEqual({ data: 0, [DEFAULT_AS]: firstId });
+    expect(identifiedData[BLOCK_SIZE]).toEqual({
+        data: BLOCK_SIZE,
+        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+    });
+
+    // ... and reserve one extra
+    expect(identifiedData[BLOCK_SIZE * 2]).toEqual({
+        data: BLOCK_SIZE * 2,
+        [DEFAULT_AS]: firstId + BLOCK_SIZE * 2,
+    });
+});

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

@@ -0,0 +1,10 @@
+export default class LinearizeGenomicCoordinate extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").LinearizeGenomicCoordinateParams} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params: import("../../spec/transform").LinearizeGenomicCoordinateParams, view: import("../../view/view").default);
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=linearizeGenomicCoordinate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linearizeGenomicCoordinate.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/linearizeGenomicCoordinate.js"],"names":[],"mappings":"AAIA;IAKI;;;;OAIG;IACH,oBAHW,OAAO,sBAAsB,EAAE,gCAAgC,QAC/D,OAAO,iBAAiB,EAAE,OAAO,EAmF3C;CACJ;qBA9F2C,aAAa"}

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

@@ -0,0 +1,97 @@
+import { asArray } from "../../utils/arrayUtils";
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+
+export default class LinearizeGenomicCoordinate extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {import("../../spec/transform").LinearizeGenomicCoordinateParams} params
+     * @param {import("../../view/view").default} view
+     */
+    constructor(params, view) {
+        super();
+
+        const channel = params.channel ?? "x";
+
+        if (!["x", "y"].includes(channel)) {
+            throw new Error("Invalid channel: " + channel);
+        }
+
+        const genome = view.getScaleResolution(channel).getGenome();
+        if (!genome) {
+            throw new Error(
+                "LinearizeGenomicCoordinate transform requires a locus scale!"
+            );
+        }
+
+        const chromAccessor = field(params.chrom);
+        const posAccessors = asArray(params.pos).map((pos) => field(pos));
+        const as = asArray(params.as);
+
+        if (posAccessors.length != as.length) {
+            throw new Error(
+                'The number of "pos" and "as" elements must be equal!'
+            );
+        }
+
+        const offsetParam = asArray(params.offset);
+
+        /** @type {number[]} */
+        let posOffsets;
+
+        if (offsetParam.length == 0) {
+            posOffsets = new Array(posAccessors.length).fill(0);
+        } else if (offsetParam.length == 1) {
+            posOffsets = new Array(posAccessors.length).fill(offsetParam[0]);
+        } else if (offsetParam.length == posAccessors.length) {
+            posOffsets = offsetParam;
+        } else {
+            throw new Error(
+                `Invalid "offset" parameter: ${JSON.stringify(params.offset)}!`
+            );
+        }
+
+        const setter = new Function(
+            "datum",
+            "chromOffset",
+            "posAccessors",
+            as
+                .map(
+                    (a, i) =>
+                        `datum[${JSON.stringify(
+                            a
+                        )}] = chromOffset + +posAccessors[${i}](datum) - ${
+                            posOffsets[i]
+                        };`
+                )
+                .join("\n")
+        );
+
+        /** @type {any} */
+        let lastChrom;
+        let chromOffset = 0;
+
+        /** @param {string | number} chrom */
+        const getChromOffset = (chrom) => {
+            if (chrom !== lastChrom) {
+                chromOffset = genome.cumulativeChromPositions.get(chrom);
+                if (chromOffset === undefined) {
+                    throw new Error("Unknown chromosome/contig: " + chrom);
+                }
+                lastChrom = chrom;
+            }
+
+            return chromOffset;
+        };
+
+        /** @param {Record<string, any>} datum */
+        this.handle = (datum) => {
+            setter(datum, getChromOffset(chromAccessor(datum)), posAccessors);
+            this._propagate(datum);
+        };
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Measures text length. This is mainly intended for reading-direction arrows
+ * in gene annotations.
+ */
+export default class MeasureTextTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").MeasureTextParams} config
+     */
+    constructor(config: import("../../spec/transform").MeasureTextParams);
+    /**
+     *
+     * @param {any} datum
+     */
+    handle: (datum: any) => void;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=measureText.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measureText.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/measureText.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;IAKI;;;OAGG;IACH,oBAFW,OAAO,sBAAsB,EAAE,iBAAiB,EAwB1D;IAbG;;;OAGG;IACH,gBAFW,GAAG,UAUb;CAER;qBAzC2C,aAAa"}

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

@@ -0,0 +1,42 @@
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+import fontMetadata from "../../fonts/Lato-Regular.json";
+import getMetrics from "../../fonts/bmFontMetrics";
+import { field } from "../../utils/field";
+
+/**
+ * Measures text length. This is mainly intended for reading-direction arrows
+ * in gene annotations.
+ */
+export default class MeasureTextTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {import("../../spec/transform").MeasureTextParams} config
+     */
+    constructor(config) {
+        super();
+
+        const metrics = getMetrics(fontMetadata);
+        const accessor = field(config.field);
+        const as = config.as;
+        // TODO: Support custom fonts.
+        const size = config.fontSize;
+
+        /**
+         *
+         * @param {any} datum
+         */
+        this.handle = (datum) => {
+            const text = accessor(datum);
+            if (text !== undefined) {
+                datum[as] = metrics.measureWidth(text, size);
+            } else {
+                datum[as] = 0;
+            }
+            this._propagate(datum);
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+export default class PileupTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").PileupParams} params
+     */
+    constructor(params: import("../../spec/transform").PileupParams);
+    params: import("../../spec/transform").PileupParams;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=pileup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pileup.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/pileup.js"],"names":[],"mappings":"AAQA;IAKI;;;OAGG;IACH,oBAFW,OAAO,sBAAsB,EAAE,YAAY,EAMrD;IADG,oDAAoB;CAyG3B;qBAzH2C,aAAa"}

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

@@ -0,0 +1,126 @@
+/* eslint-disable no-unmodified-loop-condition */
+import FlatQueue from "flatqueue";
+import { isNumber } from "vega-util";
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+
+const maxDepth = 65536;
+
+export default class PileupTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {import("../../spec/transform").PileupParams} params
+     */
+    constructor(params) {
+        super();
+
+        this.params = params;
+    }
+
+    reset() {
+        super.reset();
+        this.initialize();
+    }
+
+    initialize() {
+        const params = this.params;
+
+        const laneField = params.as || "lane";
+        const spacing = isNumber(params.spacing) ? params.spacing : 1;
+        const startAccessor = field(params.start);
+        const endAccessor = field(params.end);
+
+        // We choose the implementation based on the need of order preference.
+        // The preference-aware algorithm has a lousy O(n^2) time complexity but
+        // it's acceptable for finding lanes for genes based on their strands.
+
+        // Both implementations expect the items to be sorted by their start
+        // coordinates.
+
+        if (!params.preference !== !params.preferredOrder) {
+            throw new Error(
+                `Must specify both "preference" and "preferredOrder"`
+            );
+        } else if (params.preference) {
+            const freeLaneMap = new Float64Array(maxDepth);
+
+            const preferenceAccessor = field(params.preference);
+            /** @type {any[]} */
+            const preferredOrder = params.preferredOrder;
+
+            let lastStart = Infinity;
+
+            /** @param {Record<string, any>} datum */
+            this.handle = (datum) => {
+                const start = startAccessor(datum);
+                if (start < lastStart) {
+                    // Reset if encountered a new chromosome...
+                    freeLaneMap.fill(-Infinity);
+                }
+                lastStart = start;
+
+                // Linear search, but the number of preferences is likely be low
+                const preferredLane = preferredOrder.indexOf(
+                    preferenceAccessor(datum)
+                );
+                let lane = -1;
+                if (preferredLane >= 0 && freeLaneMap[preferredLane] < start) {
+                    lane = preferredLane;
+                } else {
+                    const start = startAccessor(datum);
+                    for (lane = 0; lane < freeLaneMap.length; lane++) {
+                        if (freeLaneMap[lane] < start) {
+                            break;
+                        }
+                    }
+                    if (lane >= freeLaneMap.length) {
+                        throw new Error("Out of lanes!");
+                    }
+                }
+                freeLaneMap[lane] = endAccessor(datum) + spacing;
+                datum[laneField] = lane;
+                this._propagate(datum);
+            };
+        } else {
+            /** @type {FlatQueue<number>} */
+            const ends = new FlatQueue();
+
+            /** @type {FlatQueue<number>} */
+            const freeLanes = new FlatQueue();
+
+            // Keep track of the last processed element. Flush the queues if the start
+            // pos suddenly decreases. This happens when piling up consecutive chromosomes.
+            let lastStart = -Infinity;
+
+            let maxLane = 0;
+
+            /** @param {Record<string, any>} datum */
+            this.handle = (datum) => {
+                const start = startAccessor(datum);
+                while (
+                    ends.length &&
+                    (ends.peekValue() <= start || start < lastStart)
+                ) {
+                    const freeLane = ends.pop();
+                    freeLanes.push(freeLane, freeLane);
+                }
+                lastStart = start;
+
+                let lane = freeLanes.pop();
+                if (lane === undefined) {
+                    lane = maxLane++;
+                }
+
+                datum[laneField] = lane;
+
+                this._propagate(datum);
+
+                ends.push(lane, endAccessor(datum) + spacing);
+            };
+        }
+    }
+}

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

@@ -0,0 +1,70 @@
+import { expect, test } from "vitest";
+import PileupTransform from "./pileup";
+import { processData } from "../flowTestUtils";
+
+// TODO: Test for lane preferences
+
+/**
+ * @typedef {import("../../spec/transform").PileupParams} PileupParams
+ */
+
+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 lanes = [0, 1, 2, 1, 0, 0, 1, 2, 0, 1, 2];
+
+/** @type {PileupParams} */
+const params = {
+    type: "pileup",
+    start: "start",
+    end: "end",
+};
+
+/**
+ * @param {PileupParams} params
+ * @param {any[]} data
+ */
+function pileupTransform(params, data) {
+    const t = new PileupTransform(params);
+    t.initialize();
+    return processData(t, data);
+}
+
+test("Pileup transform produces correct pileup", () => {
+    const piledUp = lanes.map((d, i) => ({
+        ...reads[i],
+        lane: d,
+    }));
+
+    expect(pileupTransform(params, reads)).toEqual(piledUp);
+});
+
+test("Pileup transform produces correct pileup with consecutive contigs", () => {
+    // Simulate data having multiple chromosomes, sorted by [chrom, pos].
+    // Piling should handle suddenly decreasing start positions by freeing all
+    // reserved lanes.
+
+    const repeatedReads = [...reads, ...reads];
+    const repeatedLanes = [...lanes, ...lanes];
+
+    const piledUp = repeatedLanes.map((d, i) => ({
+        ...repeatedReads[i],
+        lane: d,
+    }));
+
+    expect(pileupTransform(params, repeatedReads)).toEqual(piledUp);
+});