@genome-spy/core 0.14.0

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

@@ -0,0 +1,86 @@
+import { processData } from "../flowTestUtils";
+import FlattenDelimitedTransform from "./flattenDelimited";
+
+const sampleData = [
+    { id: 1, a: "q, w, e", b: "a-s-d" },
+    { id: 2, a: "r, t, y", b: "f-g-h" },
+    { id: 3, a: "u", b: "j" },
+];
+
+/**
+ * @param {import("./flattenDelimited").FlattenDelimitedParams} params
+ * @param {any[]} data
+ */
+function transform(params, data) {
+    return processData(new FlattenDelimitedTransform(params), data);
+}
+
+describe("FlattenDelimited transform", () => {
+    test("With a single field", () => {
+        /** @type {import("./flattenDelimited").FlattenDelimitedParams} */
+        const config = {
+            type: "flattenDelimited",
+            field: "a",
+            separator: ", ",
+        };
+
+        expect(transform(config, sampleData)).toEqual([
+            { id: 1, a: "q", b: "a-s-d" },
+            { id: 1, a: "w", b: "a-s-d" },
+            { id: 1, a: "e", b: "a-s-d" },
+            { id: 2, a: "r", b: "f-g-h" },
+            { id: 2, a: "t", b: "f-g-h" },
+            { id: 2, a: "y", b: "f-g-h" },
+            { id: 3, a: "u", b: "j" },
+        ]);
+    });
+
+    test("With two fields", () => {
+        /** @type {import("./flattenDelimited").FlattenDelimitedParams} */
+        const config = {
+            type: "flattenDelimited",
+            field: ["a", "b"],
+            as: ["a", "c"],
+            separator: [", ", "-"],
+        };
+
+        expect(transform(config, sampleData)).toEqual([
+            { id: 1, a: "q", b: "a-s-d", c: "a" },
+            { id: 1, a: "w", b: "a-s-d", c: "s" },
+            { id: 1, a: "e", b: "a-s-d", c: "d" },
+            { id: 2, a: "r", b: "f-g-h", c: "f" },
+            { id: 2, a: "t", b: "f-g-h", c: "g" },
+            { id: 2, a: "y", b: "f-g-h", c: "h" },
+            { id: 3, a: "u", b: "j", c: "j" },
+        ]);
+    });
+
+    test("Throws on differing field lengths", () => {
+        const data = [
+            {
+                a: "1-2",
+                b: "1-2-3",
+            },
+        ];
+
+        /** @type {import("./flattenDelimited").FlattenDelimitedParams} */
+        const config = {
+            type: "flattenDelimited",
+            field: ["a", "b"],
+            separator: ["-", "-"],
+        };
+
+        expect(() => transform(config, data)).toThrow();
+    });
+
+    test("Throws on mismatching spec lengths", () => {
+        /** @type {import("./flattenDelimited").FlattenDelimitedParams} */
+        const config = {
+            type: "flattenDelimited",
+            field: ["a", "b"],
+            separator: ["a"],
+        };
+
+        expect(() => transform(config, sampleData)).toThrow();
+    });
+});

package/src/data/transforms/flattenSequence.js

@@ -0,0 +1,39 @@
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+/**
+ * @typedef {import("../../spec/transform").FlattenSequenceParams} FlattenSequenceParams
+ */
+
+export default class FlattenSequenceTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     *
+     * @param {FlattenSequenceParams} params
+     */
+    constructor(params) {
+        super();
+
+        const accessor = field(params.field ?? "sequence");
+        const [asPos, asSequence] = params.as ?? ["pos", "sequence"];
+
+        /** @param {any[]} datum */
+        this.handle = (datum) => {
+            // TODO: Use code generation
+            const template = Object.assign({}, datum, {
+                [asSequence]: "",
+                [asPos]: 0,
+            });
+            const sequence = /** @type {string} */ (accessor(datum));
+            for (let i = 0; i < sequence.length; i++) {
+                const newObject = Object.assign({}, template);
+                newObject[asPos] = i;
+                newObject[asSequence] = sequence.charAt(i);
+                this._propagate(newObject);
+            }
+        };
+    }
+}

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

@@ -0,0 +1,33 @@
+import { processData } from "../flowTestUtils";
+import FlattenSequenceTransform from "./flattenSequence";
+
+/**
+ * @param {import("./flattenSequence").FlattenSequenceParams} params
+ * @param {any[]} data
+ */
+function transform(params, data) {
+    return processData(new FlattenSequenceTransform(params), data);
+}
+
+test("FlattenSequenece", () => {
+    expect(
+        transform(
+            {
+                type: "flattenSequence",
+                field: "seq",
+                as: ["p", "seq"],
+            },
+            [
+                { identifier: "A", seq: "TCG" },
+                { identifier: "B", seq: "AAT" },
+            ]
+        )
+    ).toEqual([
+        { identifier: "A", seq: "T", p: 0 },
+        { identifier: "A", seq: "C", p: 1 },
+        { identifier: "A", seq: "G", p: 2 },
+        { identifier: "B", seq: "A", p: 0 },
+        { identifier: "B", seq: "A", p: 1 },
+        { identifier: "B", seq: "T", p: 2 },
+    ]);
+});

package/src/data/transforms/formula.js

@@ -0,0 +1,39 @@
+import createFunction from "../../utils/expression";
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+
+/**
+ * @typedef {import("../../spec/transform").FormulaParams} FormulaParams
+ */
+
+export default class FormulaTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {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/src/data/transforms/formula.test.js

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

@@ -0,0 +1,108 @@
+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.
+ *
+ * @typedef {import("../../spec/transform").IdentifierParams} IdentifierParams
+ */
+export default class IdentifierTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {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/src/data/transforms/identifier.test.js

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

@@ -0,0 +1,101 @@
+import { asArray } from "../../utils/arrayUtils";
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+
+/**
+ * @typedef {import("../../spec/transform").LinearizeGenomicCoordinateParams} LinearizeGenomicCoordinateParams
+ * @typedef {import("../../view/view").default} View
+ */
+export default class LinearizeGenomicCoordinate extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {LinearizeGenomicCoordinateParams} params
+     * @param {View} 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/src/data/transforms/measureText.js

@@ -0,0 +1,44 @@
+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.
+ *
+ * @typedef {import("../../spec/transform").MeasureTextParams} MeasureTextParams
+ */
+export default class MeasureTextTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {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/src/data/transforms/pileup.js

@@ -0,0 +1,128 @@
+/* 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;
+
+/**
+ * @typedef {import("../../spec/transform").PileupParams} PileupParams
+ */
+export default class PileupTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     *
+     * @param {PileupParams} params
+     */
+    constructor(params) {
+        super();
+
+        this.params = params;
+    }
+
+    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);
+            };
+        }
+    }
+}