@genome-spy/core 0.30.0 → 0.30.2

package/src/data/transforms/flattenDelimited.js

@@ -1,74 +0,0 @@
-import { asArray } from "../../utils/arrayUtils";
-import { field } from "../../utils/field";
-import FlowNode, { BEHAVIOR_CLONES } from "../flowNode";
-
-/**
- * @typedef {import("../../spec/transform").FlattenDelimitedParams} FlattenDelimitedParams
- * @prop {string[]} separators
- * @prop {string[]} fields
- * @prop {string[]} [as]
- */
-
-export default class FlattenDelimitedTransform extends FlowNode {
-    get behavior() {
-        return BEHAVIOR_CLONES;
-    }
-
-    /**
-     *
-     * @param {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/src/data/transforms/flattenDelimited.test.js

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

@@ -1,39 +0,0 @@
-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

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

@@ -1,39 +0,0 @@
-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

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

@@ -1,108 +0,0 @@
-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

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

@@ -1,101 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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);
-        };
-    }
-}