@genome-spy/core 0.43.0 → 0.43.2

package/dist/src/data/sources/lazy/bigBedSource.d.ts

@@ -8,6 +8,12 @@ export default class BigBedSource extends SingleAxisWindowedSource {
     parser: import("@gmod/bed").default;
     /** @type {import("@gmod/bbi").BigBed} */
     bbi: import("@gmod/bbi").BigBed;
+    /** @type {(chrom: string, fields: { start: number, end: number, rest?: string }) => Record<string, any>} */
+    parseLine: (chrom: string, fields: {
+        start: number;
+        end: number;
+        rest?: string;
+    }) => Record<string, any>;
     params: import("../../../spec/data.js").BigBedData;
     initializedPromise: Promise<any>;
 }

package/dist/src/data/sources/lazy/bigBedSource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bigBedSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/bigBedSource.js"],"names":[],"mappings":"AAGA;IAOI;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,UAAU,QAC1C,OAAO,uBAAuB,EAAE,OAAO,EA4CjD;IApDD,0CAA0C;IAC1C,QADW,OAAO,WAAW,EAAE,OAAO,CAC/B;IAEP,yCAAyC;IACzC,KADW,OAAO,WAAW,EAAE,MAAM,CACjC;IAkBA,mDAAgC;IAQhC,iCAqBE;CA4BT;qCAlFoC,+BAA+B"}
+{"version":3,"file":"bigBedSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/bigBedSource.js"],"names":[],"mappings":"AAGA;IAUI;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,UAAU,QAC1C,OAAO,uBAAuB,EAAE,OAAO,EAsDjD;IAjED,0CAA0C;IAC1C,QADW,OAAO,WAAW,EAAE,OAAO,CAC/B;IAEP,yCAAyC;IACzC,KADW,OAAO,WAAW,EAAE,MAAM,CACjC;IAEJ,4GAA4G;IAC5G,mBADmB,MAAM,UAAU;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,MAAM,EAAE,GAAG,CAAC,CAC9F;IAkBN,mDAAgC;IAQhC,iCA+BE;CAuBT;qCA1FoC,+BAA+B"}

package/dist/src/data/sources/lazy/bigBedSource.js

@@ -8,6 +8,9 @@ export default class BigBedSource extends SingleAxisWindowedSource {
     /** @type {import("@gmod/bbi").BigBed} */
     bbi;
 
+    /** @type {(chrom: string, fields: { start: number, end: number, rest?: string }) => Record<string, any>} */
+    parseLine;
+
     /**
      * @param {import("../../../spec/data.js").BigBedData} params
      * @param {import("../../../view/view.js").default} view
@@ -49,6 +52,16 @@ export default class BigBedSource extends SingleAxisWindowedSource {
                 this.bbi.getHeader().then(async (header) => {
                     // @ts-ignore TODO: Fix
                     this.parser = new BED({ autoSql: header.autoSql });
+                    try {
+                        const fastParser = makeFastParser(this.parser);
+                        this.parseLine = (chrom, f) =>
+                            fastParser(chrom, f.start, f.end, f.rest);
+                    } catch (e) {
+                        this.parseLine = (chrom, f) =>
+                            this.parser.parseLine(
+                                `${chrom}\t${f.start}\t${f.end}\t${f.rest}`
+                            );
+                    }
 
                     resolve();
                 });
@@ -68,12 +81,7 @@ export default class BigBedSource extends SingleAxisWindowedSource {
                         signal,
                     })
                     .then((features) =>
-                        features.map((f) =>
-                            this.parser.parseLine(
-                                `${d.chrom}\t${f.start}\t${f.end}\t${f.rest}`,
-                                { uniqueId: f.uniqueId }
-                            )
-                        )
+                        features.map((f) => this.parseLine(d.chrom, f))
                     )
         );
 
@@ -82,3 +90,138 @@ export default class BigBedSource extends SingleAxisWindowedSource {
         }
     }
 }
+
+/**
+ * A specific optimization for Hautaniemi Lab's Methylation project, where
+ * we have hundreds of columns having small integers (0-100).
+ * This parser avoids generating piles of garbage to be collected by the GC.
+ * We don't split the line into an array of strings, but instead parse the
+ * integer fields directly from the original string.
+ * This parser doesn't support arrays, etc. at the moment. This could, however,
+ * be extended into a fully-featured parser.
+ *
+ * @param {import("@gmod/bed").default} bed
+ */
+function makeFastParser(bed) {
+    // Skip the first three fields: chrom, chromStart, chromEnd
+    const fields = bed.autoSql.fields.filter((field) => field.type).slice(3);
+
+    let i = 0;
+    let currentLine = "";
+    let lineLength = 0;
+
+    /** @type {Record<string, any>} */
+    let currentObject = {};
+
+    const delimiter = "\t";
+    const delimiterCode = delimiter.charCodeAt(0);
+    const zero = "0".charCodeAt(0);
+    const minusCode = "-".charCodeAt(0);
+
+    function parseString() {
+        let end = currentLine.indexOf(delimiter, i);
+        if (end < 0) {
+            end = lineLength;
+        }
+        const str = currentLine.substring(i, end);
+        i = end + 1;
+        return str;
+    }
+
+    function parseInt() {
+        let value = 0;
+
+        let charCode = currentLine.charCodeAt(i);
+        let sign = 1;
+
+        if (charCode === minusCode) {
+            sign = -1;
+            i++;
+            charCode = currentLine.charCodeAt(i);
+        }
+
+        do {
+            if (charCode === delimiterCode) {
+                i++;
+                break;
+            }
+            value = value * 10 + charCode - zero;
+            charCode = currentLine.charCodeAt(++i);
+        } while (i < lineLength);
+
+        return value * sign;
+    }
+
+    const fieldParsers = fields.map((field) => {
+        const { name, type } = field;
+
+        if (["ubyte", "int", "uint"].includes(type)) {
+            return () => {
+                currentObject[name] = parseInt();
+            };
+        } else if (field.isNumeric) {
+            return () => {
+                currentObject[name] = Number(parseString());
+            };
+        } else if (["char", "string", "lstring"].includes(type)) {
+            return () => {
+                currentObject[name] = parseString();
+            };
+        } else {
+            throw new Error("Unsupported type: " + type);
+        }
+    });
+
+    const templateFields = fields.map(
+        (field) => `"${field.name}": ${field.isNumeric ? "0" : "emptyString"}`
+    );
+
+    /**
+     * Make a template object with all fields to avoid the JavaScript VM's
+     * hidden class to be changed after each property assignment. Transitions
+     * between hidden classes generate plenty of garbage to be collected.
+     *
+     * Ideally, the parsed values would be assigned directly in this function,
+     * but for some reason, it results in abysmally slow performance on Chrome,
+     * but not on Firefox, where it would be super fast.
+     */
+    const makeTemplate = new Function(`
+        const emptyString = "";
+        return function makeTemplate(chrom, chromStart, chromEnd) {
+            return {
+                chrom,
+                chromStart,
+                chromEnd,
+                ${templateFields.join(",\n")}
+            }
+        };`)();
+
+    /**
+     * @param {string} line
+     */
+    function setLine(line) {
+        currentLine = line;
+        lineLength = line.length;
+        i = 0;
+    }
+
+    /**
+     * @param {string} chrom
+     * @param {number} chromStart
+     * @param {number} chromEnd
+     * @param {string} rest
+     */
+    function parseLine(chrom, chromStart, chromEnd, rest) {
+        setLine(rest);
+
+        currentObject = makeTemplate(chrom, chromStart, chromEnd);
+
+        for (let j = 0, n = fieldParsers.length; j < n; j++) {
+            fieldParsers[j]();
+        }
+
+        return currentObject;
+    }
+
+    return parseLine;
+}

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

@@ -2,7 +2,10 @@
 /**
  * Computes coverage for sorted segments
  *
- * TODO: Binned coverage
+ * TODO: Binned coverage, e.g., don't emit a new segment for every
+ * coverage change, but only every n bases or so. The most straightforward
+ * way to implement it is a separate transform that bins the coverage
+ * segments and calculates weighted averages.
  */
 export default class CoverageTransform extends FlowNode {
     /**
@@ -23,7 +26,12 @@ export default class CoverageTransform extends FlowNode {
         chrom: string;
     };
     createSegment: Function;
-    ends: FlatQueue<any>;
+    /**
+     * End pos as priority, weight as value
+     *
+     * @type {FlatQueue<number>}
+     */
+    ends: FlatQueue<number>;
 }
 import FlowNode from "../flowNode.js";
 import FlatQueue from "flatqueue";

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

@@ -1 +1 @@
-{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/coverage.js"],"names":[],"mappings":";AAKA;;;;GAIG;AACH;IAKI;;OAEG;IACH,oBAFW,OAAO,yBAAyB,EAAE,cAAc,EA4C1D;IAxCG,yDAAoB;IAEpB,mDAAwC;IACxC,iDAAoC;IAEpC,mCAAmC;IACnC,sBADoB,GAAG,KAAE,MAAM,CAGT;IACtB,mCAAmC;IACnC,uBADoB,GAAG,KAAE,MAAM,CACsC;IAErE;;;;;MAKC;IAGD,wBAgBC;IAGD,qBAA2B;CA2HlC;qBAnLyC,gBAAgB;sBAHpC,WAAW"}
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/coverage.js"],"names":[],"mappings":";AAKA;;;;;;;GAOG;AACH;IAKI;;OAEG;IACH,oBAFW,OAAO,yBAAyB,EAAE,cAAc,EAgD1D;IA5CG,yDAAoB;IAEpB,mDAAwC;IACxC,iDAAoC;IAEpC,mCAAmC;IACnC,sBADoB,GAAG,KAAE,MAAM,CAGT;IACtB,mCAAmC;IACnC,uBADoB,GAAG,KAAE,MAAM,CACsC;IAErE;;;;;MAKC;IAGD,wBAgBC;IAED;;;;OAIG;IACH,MAFU,UAAU,MAAM,CAAC,CAEA;CAiIlC;qBAhMyC,gBAAgB;sBAHpC,WAAW"}

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

@@ -6,7 +6,10 @@ import FlowNode, { BEHAVIOR_CLONES } from "../flowNode.js";
 /**
  * Computes coverage for sorted segments
  *
- * TODO: Binned coverage
+ * TODO: Binned coverage, e.g., don't emit a new segment for every
+ * coverage change, but only every n bases or so. The most straightforward
+ * way to implement it is a separate transform that bins the coverage
+ * segments and calculates weighted averages.
  */
 export default class CoverageTransform extends FlowNode {
     get behavior() {
@@ -56,7 +59,11 @@ export default class CoverageTransform extends FlowNode {
             )
         );
 
-        // End pos as priority, weight as value
+        /**
+         * End pos as priority, weight as value
+         *
+         * @type {FlatQueue<number>}
+         */
         this.ends = new FlatQueue();
     }
 
@@ -75,7 +82,7 @@ export default class CoverageTransform extends FlowNode {
         const chromAccessor = this.chromAccessor;
         const weightAccessor = this.weightAccessor;
 
-        /** @type {Record<string, number|string>} used for merging adjacent segment */
+        /** @type {import("../flowNode.js").Datum} used for merging adjacent segment */
         let bufferedSegment;
 
         /** @type {string} */
@@ -91,7 +98,7 @@ export default class CoverageTransform extends FlowNode {
         /** @type {number} */
         let prevEdge;
 
-        // End pos as priority, weight as value
+        /** End pos as priority, weight as value */
         const ends = this.ends;
         ends.clear();
 
@@ -127,9 +134,7 @@ export default class CoverageTransform extends FlowNode {
         };
 
         const flushQueue = () => {
-            // Flush queue
-            /** @type {number} */
-            let edge;
+            let edge = 0;
             while ((edge = ends.peekValue()) !== undefined) {
                 pushSegment(prevEdge, edge, coverage);
                 prevEdge = edge;
@@ -147,8 +152,7 @@ export default class CoverageTransform extends FlowNode {
         this.handle = (datum) => {
             const start = startAccessor(datum);
 
-            /** @type {number} */
-            let edge;
+            let edge = 0;
             while ((edge = ends.peekValue()) !== undefined && edge < start) {
                 pushSegment(prevEdge, edge, coverage);
                 prevEdge = edge;
@@ -179,5 +183,14 @@ export default class CoverageTransform extends FlowNode {
             flushQueue();
             super.complete();
         };
+
+        /**
+         * @param {import("../../types/flowBatch.js").FlowBatch} flowBatch
+         */
+        this.beginBatch = (flowBatch) => {
+            flushQueue();
+            prevChrom = undefined;
+            super.beginBatch(flowBatch);
+        };
     }
 }

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

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { describe, expect, test } from "vitest";
 import CoverageTransform from "./coverage.js";
 import { processData } from "../flowTestUtils.js";
 
@@ -16,108 +16,223 @@ function transform(params, data) {
     return processData(t, data);
 }
 
-test("Coverage transform produces correct coverage segments", () => {
-    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 coverageSegments = [
-        [0, 1, 1],
-        [1, 2, 2],
-        [2, 3, 3],
-        [3, 6, 2],
-        [6, 10, 1],
-        [11, 12, 3],
-        [12, 13, 2],
-        [13, 14, 1],
-        [15, 16, 1],
-        [16, 17, 2],
-        [17, 18, 3],
-    ].map((d) => ({
-        start: d[0],
-        end: d[1],
-        coverage: d[2],
-    }));
-
+/**
+ *
+ * @param {[number, number][]} reads Start, end
+ * @param {[number, number, number][]} coverageSegments Start, end, coverage
+ */
+function testSimpleCoverage(reads, coverageSegments) {
     /** @type {CoverageParams} */
     const coverageConfig = {
         type: "coverage",
         start: "start",
         end: "end",
     };
-    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
-});
-
-test("Coverage transform handles chromosomes", () => {
-    const reads = [
-        { chrom: "chr1", start: 0, end: 1 },
-        { chrom: "chr2", start: 0, end: 1 },
-        { chrom: "chr3", start: 1, end: 3 },
-    ];
-
-    const coverageSegments = [
-        { chrom: "chr1", start: 0, end: 1, coverage: 1 },
-        { chrom: "chr2", start: 0, end: 1, coverage: 1 },
-        { chrom: "chr3", start: 1, end: 3, coverage: 1 },
-    ];
+    expect(
+        transform(
+            coverageConfig,
+            reads.map((d) => ({
+                start: d[0],
+                end: d[1],
+            }))
+        )
+    ).toEqual(
+        coverageSegments.map((d) => ({
+            start: d[0],
+            end: d[1],
+            coverage: d[2],
+        }))
+    );
+}
 
+/**
+ *
+ * @param {[number, number, number][]} reads Start, end, weight
+ * @param {[number, number, number][]} coverageSemgments Start, end, coverage
+ */
+function testWeightedCoverage(reads, coverageSegments) {
     /** @type {CoverageParams} */
     const coverageConfig = {
         type: "coverage",
-        chrom: "chrom",
         start: "start",
         end: "end",
+        weight: "weight",
     };
+    expect(
+        transform(
+            coverageConfig,
+            reads.map((d) => ({
+                start: d[0],
+                end: d[1],
+                weight: d[2],
+            }))
+        )
+    ).toEqual(
+        coverageSegments.map((d) => ({
+            start: d[0],
+            end: d[1],
+            coverage: d[2],
+        }))
+    );
+}
 
-    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
-});
+describe("Coverage transform", () => {
+    test("Typical case", () =>
+        testSimpleCoverage(
+            [
+                [0, 4],
+                [1, 3],
+                [2, 6],
+                [4, 8],
+                [8, 10],
+                [11, 14],
+                [11, 13],
+                [11, 12],
+                [15, 18],
+                [16, 18],
+                [17, 18],
+            ],
+            [
+                [0, 1, 1],
+                [1, 2, 2],
+                [2, 3, 3],
+                [3, 6, 2],
+                [6, 10, 1],
+                [11, 12, 3],
+                [12, 13, 2],
+                [13, 14, 1],
+                [15, 16, 1],
+                [16, 17, 2],
+                [17, 18, 3],
+            ]
+        ));
 
-test("Coverage transform handles weights", () => {
-    const reads = [
-        [0, 4, 1],
-        [1, 3, 2],
-        [2, 6, 3],
-        [8, 10, -1],
-    ].map((d) => ({
-        start: d[0],
-        end: d[1],
-        weight: d[2],
-    }));
+    test("Multiple identical overlapping segments", () =>
+        testSimpleCoverage(
+            [
+                [1, 2],
+                [3, 4],
+                [3, 4],
+                [5, 6],
+                [5, 6],
+                [5, 6],
+            ],
+            [
+                [1, 2, 1],
+                [3, 4, 2],
+                [5, 6, 3],
+            ]
+        ));
 
-    const coverageSegments = [
-        [0, 1, 1],
-        [1, 2, 3],
-        [2, 3, 6],
-        [3, 4, 4],
-        [4, 6, 3],
-        [8, 10, -1],
-    ].map((d) => ({
-        start: d[0],
-        end: d[1],
-        coverage: d[2],
-    }));
+    test("Adjacent segments with equal coverage are merged", () =>
+        testSimpleCoverage(
+            [
+                [1, 2],
+                [2, 3],
+                [3, 4],
+                [5, 6],
+                [6, 7],
+                [7, 8],
+            ],
+            [
+                [1, 4, 1],
+                [5, 8, 1],
+            ]
+        ));
 
-    /** @type {CoverageParams} */
-    const coverageConfig = {
-        type: "coverage",
-        chrom: "chrom",
-        start: "start",
-        end: "end",
-        weight: "weight",
-    };
+    test("Chromosomes pass through", () => {
+        const reads = [
+            { chrom: "chr1", start: 0, end: 1 },
+            { chrom: "chr2", start: 0, end: 1 },
+            { chrom: "chr3", start: 1, end: 3 },
+        ];
+
+        const coverageSegments = [
+            { chrom: "chr1", start: 0, end: 1, coverage: 1 },
+            { chrom: "chr2", start: 0, end: 1, coverage: 1 },
+            { chrom: "chr3", start: 1, end: 3, coverage: 1 },
+        ];
+
+        /** @type {CoverageParams} */
+        const coverageConfig = {
+            type: "coverage",
+            chrom: "chrom",
+            start: "start",
+            end: "end",
+        };
+
+        expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
+    });
+
+    test("Typical weighted coverage", () =>
+        testWeightedCoverage(
+            [
+                [0, 4, 1],
+                [1, 3, 2],
+                [2, 6, 3],
+                [8, 10, -1],
+            ],
+            [
+                [0, 1, 1],
+                [1, 2, 3],
+                [2, 3, 6],
+                [3, 4, 4],
+                [4, 6, 3],
+                [8, 10, -1],
+            ]
+        ));
+
+    test("Multiple weights at a single locus", () =>
+        testWeightedCoverage(
+            [
+                // -- Locus 1
+                [1, 2, 1],
+                [1, 2, 2],
+                [1, 2, 3],
+                [1, 2, 4],
+                [1, 2, 5],
+                // -- Locus 2
+                [2, 3, 2],
+                [2, 3, 3],
+                [2, 3, 4],
+                [2, 3, 5],
+                [2, 3, 6],
+            ],
+            [
+                // -- Locus 1
+                [1, 2, 15],
+                // -- Locus 2
+                [2, 3, 20],
+            ]
+        ));
 
-    expect(transform(coverageConfig, reads)).toEqual(coverageSegments);
+    test("Adjacent segments with different weights produce separated segments", () =>
+        testWeightedCoverage(
+            [
+                // -- Cluster 1
+                [1, 2, 2],
+                [2, 3, 1],
+                [3, 4, 1],
+                // -- Cluster 2
+                [5, 6, 1],
+                [6, 7, 2],
+                [7, 8, 1],
+                // -- Cluster 3
+                [9, 10, 1],
+                [10, 11, 1],
+                [11, 12, 2],
+            ],
+            [
+                // -- Cluster 1
+                [1, 2, 2],
+                [2, 4, 1],
+                // -- Cluster 2
+                [5, 6, 1],
+                [6, 7, 2],
+                [7, 8, 1],
+                // -- Cluster 3
+                [9, 11, 1],
+                [11, 12, 2],
+            ]
+        ));
 });

package/dist/src/gl/arrayBuilder.d.ts

@@ -5,6 +5,7 @@
  * @prop {function(object):any} f The converter
  * @prop {number[]} [arrayReference] An optimization for fp64 mainly
  * @prop {number} [numComponents]
+ * @prop {typeof Uint16Array | typeof Int16Array | typeof Uint32Array | typeof Int32Array | typeof Float32Array} [targetArrayType] Defaults to Float32Array
  */
 export default class ArrayBuilder {
     /**
@@ -13,10 +14,10 @@ export default class ArrayBuilder {
      */
     constructor(size: number);
     size: number;
-    /** @type {Object.<string, {data: number[] | Float32Array, numComponents: number, divisor?: number}>} */
+    /** @type {Object.<string, {data: Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array, numComponents: number, divisor?: number}>} */
     arrays: {
         [x: string]: {
-            data: number[] | Float32Array;
+            data: Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array;
             numComponents: number;
             divisor?: number;
         };
@@ -26,6 +27,7 @@ export default class ArrayBuilder {
     /** @type {(function(any):void)[]} */
     dataUpdaters: ((arg0: any) => void)[];
     vertexCount: number;
+    configure(): void;
     /**
      *
      * @param {string} attribute
@@ -36,13 +38,13 @@ export default class ArrayBuilder {
      *
      * @param {string} attributeName
      * @param {number} numComponents
+     * @param {typeof Uint16Array | typeof Int16Array | typeof Uint32Array | typeof Int32Array | typeof Float32Array} [targetArrayType]
      * @param {number[]} [arrayReference]
      * @return {function(number|number[])}
      */
-    createUpdater(attributeName: string, numComponents: number, arrayReference?: number[]): (arg0: number | number[]) => any;
+    createUpdater(attributeName: string, numComponents: number, targetArrayType?: typeof Uint16Array | typeof Int16Array | typeof Uint32Array | typeof Int32Array | typeof Float32Array, arrayReference?: number[]): (arg0: number | number[]) => any;
     pushAll(): void;
     /**
-     *
      * @param {object} datum
      */
     updateFromDatum(datum: object): void;
@@ -51,6 +53,7 @@ export default class ArrayBuilder {
      * @param {object} datum
      */
     pushFromDatum(datum: object): void;
+    #private;
 }
 /**
  * A function that extracts a raw attribute from a datum (optionally) converts
@@ -66,5 +69,9 @@ export type ConverterMetadata = {
      */
     arrayReference?: number[];
     numComponents?: number;
+    /**
+     * Defaults to Float32Array
+     */
+    targetArrayType?: typeof Uint16Array | typeof Int16Array | typeof Uint32Array | typeof Int32Array | typeof Float32Array;
 };
 //# sourceMappingURL=arrayBuilder.d.ts.map