@genome-spy/core 0.14.0

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

@@ -0,0 +1,37 @@
+import SampleTransform from "./sample";
+import { extent } from "d3-array";
+import { createChain } from "../../view/flowBuilder";
+
+test("SampleTransform produces roughly uniform distributions", () => {
+    const size = 10;
+    const n = 20;
+    const rounds = 10000;
+
+    const freqs = [];
+    for (let i = 0; i < n; i++) {
+        freqs[i] = 0;
+    }
+
+    const { dataSource, collector } = createChain(
+        new SampleTransform({ type: "sample", size })
+    );
+
+    for (let r = 0; r < rounds; r++) {
+        for (let i = 0; i < n; i++) {
+            dataSource.handle({ data: i });
+        }
+        dataSource.complete();
+
+        for (const datum of collector.getData()) {
+            freqs[datum.data] = freqs[datum.data] + 1;
+        }
+
+        dataSource.reset();
+    }
+
+    const e = extent(freqs);
+
+    // Not a deterministic test! TODO: Come up with some sensical testing method
+    expect(e[0]).toBeGreaterThan(4800);
+    expect(e[1]).toBeLessThan(5200);
+});

package/src/data/transforms/stack.js

@@ -0,0 +1,137 @@
+import { compare } from "vega-util";
+import { groups as d3groups, sum as d3sum } from "d3-array";
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+import { field } from "../../utils/field";
+
+/**
+ * @typedef {import("../../spec/transform").StackParams} StackParams
+ */
+export default class StackTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     * @param {StackParams} 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 as = params.as || ["y0", "y1"]; // TODO: Validate
+
+        const comparator = params.sort
+            ? compare(params.sort.field, params.sort.order)
+            : undefined;
+
+        const valueAccessor = params.field ? field(params.field) : (d) => 1;
+
+        const groupFields = params.groupby.map((f) => field(f));
+
+        const groups = d3groups(this.buffer, (row) =>
+            groupFields.map((f) => f(row)).join()
+        ).map((a) => a[1]);
+
+        /** @type {(datum: any) => boolean} */
+        let inclusionPredicate = (datum) => true;
+
+        if (params.baseField) {
+            const baseAccessor = field(params.baseField);
+            inclusionPredicate = (datum) => baseAccessor(datum) !== null;
+        }
+
+        /** @type {(value: number, sum: number) => number} */
+        let offsetF;
+
+        /** @type {(values: number[], accessor: (datum: any) => number) => number} */
+        let sumF;
+
+        switch (params.offset) {
+            case "normalize":
+                offsetF = (value, sum) => value / sum;
+                sumF = (values, accessor) => d3sum(values, accessor);
+                break;
+            case "center":
+                offsetF = (value, sum) => value - sum / 2;
+                sumF = (values, accessor) => d3sum(values, accessor);
+                break;
+            case "information":
+                {
+                    // Sequence logos: a new way to display consensus sequences (Schneider and Stephens)
+                    // doi://10.1093/nar/18.20.6097
+
+                    const maxBits = Math.log2(params.cardinality ?? 4);
+                    offsetF = (value, sum) => value / sum;
+                    sumF = (values, accessor) => {
+                        const e = 0; // TODO: Correction factor for small sample sizes
+
+                        const gaps = d3sum(
+                            values,
+                            (d) => +!inclusionPredicate(d)
+                        );
+                        const total = d3sum(values, accessor);
+                        const nonGaps = total - gaps;
+
+                        let H = 0;
+                        for (let i = 0; i < values.length; i++) {
+                            const datum = values[i];
+                            if (inclusionPredicate(datum)) {
+                                const b = accessor(datum) / nonGaps;
+                                H -= b * Math.log2(b);
+                            }
+                        }
+
+                        return (
+                            (nonGaps / (maxBits - (H + e))) * (nonGaps / total)
+                        );
+                    };
+                }
+                break;
+            default:
+                offsetF = (value, sum) => value;
+                sumF = (values, accessor) => 1;
+        }
+
+        for (const group of groups) {
+            if (comparator) {
+                group.sort(comparator);
+            }
+
+            const sum = sumF(group, valueAccessor);
+
+            let prev = 0;
+            for (const datum of group) {
+                const current = prev + valueAccessor(datum);
+
+                if (inclusionPredicate(datum)) {
+                    datum[as[0]] = offsetF(prev, sum);
+                    datum[as[1]] = offsetF(current, sum);
+
+                    this._propagate(datum);
+                    prev = current;
+                }
+            }
+        }
+
+        super.complete();
+    }
+}

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

@@ -0,0 +1,90 @@
+import { processData } from "../flowTestUtils";
+import StackTransform from "./stack";
+
+const sampleData = [
+    { group: "a", choice: "q", value: 1 },
+    { group: "b", choice: "x", value: 1 },
+    { group: "b", choice: "y", value: 3 },
+];
+
+/** @type {import("./stack").StackParams} */
+const baseConf = {
+    type: "stack",
+    field: "value",
+    groupby: ["group"],
+    sort: {
+        field: "value",
+        order: "ascending",
+    },
+    offset: "zero",
+    as: ["z0", "z1"],
+};
+
+/**
+ *
+ * @param {import("./stack").StackParams} params
+ * @param {any[]} data
+ */
+function transform(params, data) {
+    return processData(new StackTransform(params), data);
+}
+
+describe("Stack transform", () => {
+    test("No field", () => {
+        const conf = Object.assign({}, baseConf, {
+            field: undefined,
+        });
+
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "y", value: 3, z0: 1, z1: 2 },
+        ]);
+    });
+
+    test("Zero offset", () => {
+        expect(transform(baseConf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "y", value: 3, z0: 1, z1: 4 },
+        ]);
+    });
+
+    test("Normalize offset", () => {
+        const conf = Object.assign({}, baseConf, {
+            offset: "normalize",
+        });
+
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "x", value: 1, z0: 0, z1: 0.25 },
+            { group: "b", choice: "y", value: 3, z0: 0.25, z1: 1 },
+        ]);
+    });
+
+    test("Center offset", () => {
+        const conf = Object.assign({}, baseConf, {
+            offset: "center",
+        });
+
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: -0.5, z1: 0.5 },
+            { group: "b", choice: "x", value: 1, z0: -2, z1: -1 },
+            { group: "b", choice: "y", value: 3, z0: -1, z1: 2 },
+        ]);
+    });
+
+    test("Descending sort", () => {
+        const conf = Object.assign({}, baseConf, {
+            sort: {
+                field: "value",
+                order: "descending",
+            },
+        });
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "y", value: 3, z0: 0, z1: 3 },
+            { group: "b", choice: "x", value: 1, z0: 3, z1: 4 },
+        ]);
+    });
+});

package/src/data/transforms/transformFactory.js

@@ -0,0 +1,60 @@
+import Collector from "../collector";
+import CoverageTransform from "./coverage";
+import FilterScoredLabelsTransform from "./filterScoredLabels";
+import FilterTransform from "./filter";
+import FlattenCompressedExonsTransform from "./flattenCompressedExons";
+import FlattenDelimitedTransform from "./flattenDelimited";
+import FormulaTransform from "./formula";
+import LinearizeGenomicCoordinate from "./linearizeGenomicCoordinate";
+import MeasureTextTransform from "./measureText";
+import PileupTransform from "./pileup";
+import ProjectTransform from "./project";
+import RegexExtractTransform from "./regexExtract";
+import RegexFoldTransform from "./regexFold";
+import SampleTransform from "./sample";
+import StackTransform from "./stack";
+import FlattenSequenceTransform from "./flattenSequence";
+import AggregateTransform from "./aggregate";
+import IdentifierTransform from "./identifier";
+
+/**
+ * TODO: Make this dynamic
+ *
+ * @typedef {import("../../view/view").default} View
+ * @typedef {import("../flowNode").default} FlowNode
+ *
+ * @type {Record<string, new (params: any, view?: View) => FlowNode>}
+ */
+export const transforms = {
+    aggregate: AggregateTransform,
+    collect: Collector,
+    coverage: CoverageTransform,
+    filterScoredLabels: FilterScoredLabelsTransform,
+    filter: FilterTransform,
+    flattenCompressedExons: FlattenCompressedExonsTransform,
+    flattenDelimited: FlattenDelimitedTransform,
+    flattenSequence: FlattenSequenceTransform,
+    formula: FormulaTransform,
+    identifier: IdentifierTransform,
+    linearizeGenomicCoordinate: LinearizeGenomicCoordinate,
+    measureText: MeasureTextTransform,
+    pileup: PileupTransform,
+    project: ProjectTransform,
+    regexExtract: RegexExtractTransform,
+    regexFold: RegexFoldTransform,
+    sample: SampleTransform,
+    stack: StackTransform,
+};
+
+/**
+ * @param {import("../../spec/transform").TransformParamsBase} params
+ * @param {View} [view]
+ */
+export default function createTransform(params, view) {
+    const Transform = transforms[params.type];
+    if (Transform) {
+        return new Transform(params, view);
+    } else {
+        throw new Error("Unknown transform: " + params.type);
+    }
+}

package/src/encoder/accessor.js

@@ -0,0 +1,82 @@
+import createFunction from "../utils/expression";
+
+import { accessorFields, constant } from "vega-util";
+import { isDatumDef, isExprDef, isFieldDef } from "./encoder";
+import { field } from "../utils/field";
+
+/**
+ * @typedef {Object} AccessorMetadata
+ * @prop {boolean} constant True if the accessor returns the same value for all objects
+ * @prop {string[]} fields The fields that the return value is based on (if any)
+ *
+ * @typedef {(function(any):any) & AccessorMetadata} Accessor
+ *
+ * @typedef {import("../view/viewUtils").ChannelDef} ChannelDef
+ */
+export default class AccessorFactory {
+    constructor() {
+        /** @type {(function(ChannelDef):Accessor)[]} */
+        this.accessorCreators = [];
+
+        this.register((channelDef) => {
+            if (isFieldDef(channelDef)) {
+                try {
+                    /** @type {Accessor} */
+                    const accessor = field(channelDef.field);
+                    accessor.constant = false;
+                    accessor.fields = accessorFields(accessor);
+                    return accessor;
+                } catch (e) {
+                    throw new Error(`Invalid field definition: ${e.message}`);
+                }
+            }
+        });
+
+        this.register((channelDef) =>
+            isExprDef(channelDef)
+                ? createExpressionAccessor(channelDef.expr)
+                : undefined
+        );
+
+        this.register((channelDef) => {
+            if (isDatumDef(channelDef)) {
+                /** @type {Accessor} */
+                const accessor = constant(channelDef.datum);
+                accessor.constant = true; // Can be optimized downstream
+                accessor.fields = [];
+                return accessor;
+            }
+        });
+    }
+
+    /**
+     *
+     * @param {function(ChannelDef):Accessor} creator
+     */
+    register(creator) {
+        this.accessorCreators.push(creator);
+    }
+
+    /**
+     *
+     * @param {ChannelDef} encoding
+     */
+    createAccessor(encoding) {
+        for (const creator of this.accessorCreators) {
+            const accessor = creator(encoding);
+            if (accessor) {
+                return accessor;
+            }
+        }
+    }
+}
+
+/**
+ * @param {string} expr
+ */
+function createExpressionAccessor(expr) {
+    /** @type {Accessor} */
+    const accessor = createFunction(expr);
+    accessor.constant = accessor.fields.length == 0; // Not bulletproof, eh
+    return accessor;
+}

package/src/encoder/accessor.test.js

@@ -0,0 +1,46 @@
+import AccessorFactory from "./accessor";
+
+const af = new AccessorFactory();
+
+const datum = {
+    a: 1,
+    b: 2,
+    "x.c": 3,
+};
+
+test("Creates a field accessor", () => {
+    const a = af.createAccessor({ field: "a" });
+    expect(a(datum)).toEqual(1);
+    expect(a.constant).toBeFalsy();
+    expect(a.fields).toEqual(["a"]);
+});
+
+test("Creates an expression accessor", () => {
+    const a = af.createAccessor({ expr: `datum.b + datum['x\.c']` });
+    expect(a(datum)).toEqual(5);
+    expect(a.constant).toBeFalsy();
+    expect(a.fields.sort()).toEqual(["b", "x.c"].sort());
+});
+
+test("Creates a constant accessor", () => {
+    const a = af.createAccessor({ datum: 0 });
+    expect(a(datum)).toEqual(0);
+    expect(a.constant).toBeTruthy();
+    expect(a.fields).toEqual([]);
+});
+
+test("Returns undefined on incomplete encoding spec", () => {
+    expect(af.createAccessor({})).toBeUndefined();
+});
+
+test("Registers and creates a custom accessor", () => {
+    const af = new AccessorFactory();
+    af.register((encoding) => {
+        if (encoding.iddqd && encoding.idkfa) {
+            return (datum) =>
+                `${datum[encoding.iddqd]}-${datum[encoding.idkfa]}`;
+        }
+    });
+
+    expect(af.createAccessor({ iddqd: "a", idkfa: "b" })(datum)).toEqual("1-2");
+});