@genome-spy/core 0.36.0 → 0.37.0

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

@@ -0,0 +1,134 @@
+import { bisector } from "d3-array";
+import FlowNode, { BEHAVIOR_COLLECTS } from "../flowNode";
+import { topKSlice } from "../../utils/topK";
+import ReservationMap from "../../utils/reservationMap";
+import { field } from "../../utils/field";
+
+export default class FilterScoredLabelsTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_COLLECTS;
+    }
+
+    /**
+     *
+     * @param {import("../../spec/transform").FilterScoredLabelsParams} params
+     * @param {import("../../view/view").default} 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/dist/src/data/transforms/flatten.d.ts

@@ -0,0 +1,10 @@
+export default class FlattenTransform extends FlowNode {
+    /**
+     * @param {import("../../spec/transform").FlattenParams} params
+     */
+    constructor(params: import("../../spec/transform").FlattenParams);
+    /** @param {any[]} datum */
+    handle: (datum: any[]) => void;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=flatten.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/flatten.js"],"names":[],"mappings":"AAIA;IAKI;;OAEG;IACH,oBAFW,OAAO,sBAAsB,EAAE,aAAa,EAwDtD;IAvCO,2BAA2B;IAC3B,gBADY,GAAG,EAAE,UAwBhB;CAgBZ;qBAjEyC,aAAa"}

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

@@ -0,0 +1,68 @@
+import { asArray } from "../../utils/arrayUtils";
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+export default class FlattenTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     * @param {import("../../spec/transform").FlattenParams} params
+     */
+    constructor(params) {
+        super();
+
+        const indexField = params.index;
+
+        if (params.fields) {
+            const accessors = asArray(params.fields).map((f) => field(f));
+            const as = asArray(params.as || params.fields);
+
+            if (accessors.length !== as.length) {
+                throw new Error(
+                    `Lengths of "fields" (${accessors.length}), and "as" (${as.length}) do not match!`
+                );
+            }
+
+            /** @param {any[]} datum */
+            this.handle = (datum) => {
+                // TODO: Check that the field contains an array
+                const accessedFields = accessors.map(
+                    (accessor, i) => accessor(datum) ?? []
+                );
+
+                const maxLen = accessedFields[0].length;
+
+                for (let ri = 0; ri < maxLen; ri++) {
+                    // TODO: use objectCloner for extra performance
+                    /** @type {import("../flowNode").Datum} */
+                    const newRow = Object.assign({}, datum);
+                    for (let fi = 0; fi < accessors.length; fi++) {
+                        newRow[as[fi]] =
+                            ri < accessedFields[fi].length
+                                ? accessedFields[fi][ri]
+                                : null;
+                    }
+                    if (indexField) {
+                        newRow[indexField] = ri;
+                    }
+                    this._propagate(newRow);
+                }
+            };
+        } else {
+            /** @param {any[]} datum */
+            this.handle = (datum) => {
+                // TODO: Check that the object is an array
+                for (let i = 0; i < datum.length; i++) {
+                    /** @type {import("../flowNode").Datum} */
+                    const newRow = Object.assign({}, datum[i]);
+                    if (indexField) {
+                        newRow[indexField] = i;
+                    }
+                    this._propagate(newRow);
+                }
+            };
+        }
+    }
+}

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

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "vitest";
+import { processData } from "../flowTestUtils";
+import FlattenTransform from "./flatten";
+
+/**
+ * @param {import("./flatten").FlattenParams} params
+ * @param {any[]} data
+ */
+function transform(params, data) {
+    return processData(new FlattenTransform(params), data);
+}
+
+describe("Flatten transform", () => {
+    test("With a single field", () => {
+        /** @type {import("./flattenDelimited").FlattenParams} */
+        const params = { type: "flatten", fields: ["foo"] };
+
+        const input = [
+            { name: "alpha", data: 123, foo: [1, 2] },
+            { name: "beta", data: 456, foo: [3, 4, 5] },
+        ];
+
+        expect(transform(params, input)).toEqual([
+            { name: "alpha", data: 123, foo: 1 },
+            { name: "alpha", data: 123, foo: 2 },
+            { name: "beta", data: 456, foo: 3 },
+            { name: "beta", data: 456, foo: 4 },
+            { name: "beta", data: 456, foo: 5 },
+        ]);
+    });
+
+    test("With an index field", () => {
+        /** @type {import("./flattenDelimited").FlattenParams} */
+        const params = { type: "flatten", fields: ["foo"], index: "idx" };
+
+        const input = [
+            { name: "alpha", data: 123, foo: [1, 2] },
+            { name: "beta", data: 456, foo: [3, 4, 5] },
+        ];
+
+        expect(transform(params, input)).toEqual([
+            { name: "alpha", data: 123, foo: 1, idx: 0 },
+            { name: "alpha", data: 123, foo: 2, idx: 1 },
+            { name: "beta", data: 456, foo: 3, idx: 0 },
+            { name: "beta", data: 456, foo: 4, idx: 1 },
+            { name: "beta", data: 456, foo: 5, idx: 2 },
+        ]);
+    });
+
+    test("With multiple fields", () => {
+        /** @type {import("./flattenDelimited").FlattenParams} */
+        const params = { type: "flatten", fields: ["foo", "bar"] };
+
+        const input = [
+            { key: "alpha", foo: [1, 2], bar: ["A", "B"] },
+            { key: "beta", foo: [3, 4, 5], bar: ["C", "D"] },
+        ];
+
+        expect(transform(params, input)).toEqual([
+            { key: "alpha", foo: 1, bar: "A" },
+            { key: "alpha", foo: 2, bar: "B" },
+            { key: "beta", foo: 3, bar: "C" },
+            { key: "beta", foo: 4, bar: "D" },
+            { key: "beta", foo: 5, bar: null },
+        ]);
+    });
+
+    test("Throws on mismatching spec lengths", () => {
+        /** @type {import("./flattenDelimited").FlattenParams} */
+        const params = {
+            type: "flatten",
+            fields: ["a", "b"],
+            as: ["a"],
+        };
+
+        expect(() => transform(params, sampleData)).toThrow();
+    });
+
+    test("Missing fields property treats the input object as an array", () => {
+        /** @type {import("./flattenDelimited").FlattenParams} */
+        const params = {
+            type: "flatten",
+        };
+
+        const input = [[{ a: 1 }], [{ a: 2 }, { a: 3 }]];
+
+        expect(transform(params, input)).toEqual([
+            { a: 1 },
+            { a: 2 },
+            { a: 3 },
+        ]);
+    });
+});

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

@@ -0,0 +1,19 @@
+/**
+ * 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 {
+    /**
+     *
+     * @param {import("../../spec/transform").FlattenCompressedExonsParams} params
+     */
+    constructor(params: import("../../spec/transform").FlattenCompressedExonsParams);
+    /**
+     *
+     * @param {any} datum
+     */
+    handle: (datum: any) => void;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=flattenCompressedExons.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flattenCompressedExons.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/flattenCompressedExons.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IAKI;;;OAGG;IACH,oBAFW,OAAO,sBAAsB,EAAE,4BAA4B,EAmCrE;IA1BG;;;OAGG;IACH,gBAFW,GAAG,UAuBb;CAER;qBAlDyC,aAAa"}

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

@@ -0,0 +1,53 @@
+import { field } from "../../utils/field";
+import numberExtractor from "../../utils/numberExtractor";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+/**
+ * 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 {import("../../spec/transform").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;
+            }
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+export default class FlattenDelimitedTransform extends FlowNode {
+    /**
+     * @param {import("../../spec/transform").FlattenDelimitedParams} params
+     */
+    constructor(params: import("../../spec/transform").FlattenDelimitedParams);
+    /** @param {any[]} datum */
+    handle: (datum: any[]) => void;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=flattenDelimited.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flattenDelimited.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/flattenDelimited.js"],"names":[],"mappings":"AAIA;IAKI;;OAEG;IACH,oBAFW,OAAO,sBAAsB,EAAE,sBAAsB,EAuC/D;IAnBG,2BAA2B;IAC3B,gBADY,GAAG,EAAE,UAkBhB;CAER;qBAhDyC,aAAa"}

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

@@ -0,0 +1,66 @@
+import { asArray } from "../../utils/arrayUtils";
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+export default class FlattenDelimitedTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     * @param {import("../../spec/transform").FlattenDelimitedParams} params
+     */
+    constructor(params) {
+        super();
+
+        // TODO: Validate config. string elements, etc...
+
+        const accessors = asArray(params.field).map((f) => field(f));
+        const separators = asArray(params.separator);
+        const as = asArray(params.as || params.field);
+
+        if (
+            accessors.length !== separators.length ||
+            accessors.length !== as.length
+        ) {
+            throw new Error(
+                `Lengths of "separator" (${separators.length}), "fields" (${accessors.length}), and "as" (${as.length}) do not match!`
+            );
+        }
+
+        /** @param {any[]} datum */
+        this.handle = (datum) => {
+            if (accessors.some((a) => !a(datum))) return;
+
+            const splitFields = accessors.map((accessor, i) =>
+                accessor(datum).split(separators[i])
+            );
+            validateSplit(splitFields, datum);
+            const flatLen = splitFields[0].length;
+
+            for (let ri = 0; ri < flatLen; ri++) {
+                /** @type {import("../flowNode").Datum} */
+                const newRow = Object.assign({}, datum);
+                for (let fi = 0; fi < accessors.length; fi++) {
+                    newRow[as[fi]] = splitFields[fi][ri];
+                }
+                this._propagate(newRow);
+            }
+        };
+    }
+}
+
+/**
+ *
+ * @param {any[]} splitFields
+ * @param {unknown} row
+ */
+function validateSplit(splitFields, row) {
+    const splitLengths = splitFields.map((f) => f.length);
+    if (!splitLengths.every((x) => x == splitLengths[0])) {
+        throw new Error(
+            "Mismatching number of elements in the fields to be split: " +
+                JSON.stringify(row)
+        );
+    }
+}

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

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "vitest";
+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/dist/src/data/transforms/flattenSequence.d.ts

@@ -0,0 +1,11 @@
+export default class FlattenSequenceTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").FlattenSequenceParams} params
+     */
+    constructor(params: import("../../spec/transform").FlattenSequenceParams);
+    /** @param {any[]} datum */
+    handle: (datum: any[]) => void;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=flattenSequence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flattenSequence.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/flattenSequence.js"],"names":[],"mappings":"AAGA;IAKI;;;OAGG;IACH,oBAFW,OAAO,sBAAsB,EAAE,qBAAqB,EAuB9D;IAfG,2BAA2B;IAC3B,gBADY,GAAG,EAAE,UAchB;CAER;qBAjCyC,aAAa"}

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

@@ -0,0 +1,35 @@
+import { field } from "../../utils/field";
+import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
+
+export default class FlattenSequenceTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_CLONES;
+    }
+
+    /**
+     *
+     * @param {import("../../spec/transform").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/dist/src/data/transforms/flattenSequence.test.js

@@ -0,0 +1,34 @@
+import { expect, test } from "vitest";
+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/dist/src/data/transforms/formula.d.ts

@@ -0,0 +1,13 @@
+export default class FormulaTransform extends FlowNode {
+    /**
+     *
+     * @param {import("../../spec/transform").FormulaParams} params
+     */
+    constructor(params: import("../../spec/transform").FormulaParams);
+    params: import("../../spec/transform").FormulaParams;
+    as: string;
+    /** @type {(datum: any) => any} */
+    fn: (datum: any) => any;
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=formula.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formula.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/formula.js"],"names":[],"mappings":"AAGA;IAKI;;;OAGG;IACH,oBAFW,OAAO,sBAAsB,EAAE,aAAa,EAUtD;IANG,qDAAoB;IAEpB,WAAmB;IAEnB,kCAAkC;IAClC,YADmB,GAAG,KAAK,GAAG,CACX;CAe1B;qBAjC2C,aAAa"}