@genome-spy/core 0.74.0 → 0.76.0

package/dist/src/gl/glslScaleGenerator.js

@@ -676,7 +676,9 @@ export function getAttributeAndArrayTypes(scale, channel) {
               : { attributeType: "float", arrayConstructor: Float32Array };
 
     return Object.assign(props, {
-        numComponents: +(props.attributeType.match(/^vec([234])$/)?.[1] ?? 1),
+        numComponents: +(
+            props.attributeType.match(/^(?:u)?vec([234])$/)?.[1] ?? 1
+        ),
         discrete,
         hp,
         largeHp,
@@ -701,9 +703,9 @@ export function isLargeGenome(domain) {
     return domain[1] > 2 ** 32;
 }
 
-const LOW_BITS = 12;
-const BS = 2 ** LOW_BITS;
-const BM = BS - 1;
+export const HIGH_PRECISION_SPLIT_BITS = 12;
+export const HIGH_PRECISION_SPLIT_BASE = 2 ** HIGH_PRECISION_SPLIT_BITS;
+export const HIGH_PRECISION_SPLIT_MASK = HIGH_PRECISION_SPLIT_BASE - 1;
 
 /**
  * @param {number} x Must be an integer
@@ -712,7 +714,7 @@ const BM = BS - 1;
 export function splitHighPrecision(x, arr = []) {
     // Using a bitmask is MUCH faster than using modulo (at least on Chrome 112)
     // https://www.wikiwand.com/en/Modulo#Performance_issues
-    const lo = x & BM;
+    const lo = x & HIGH_PRECISION_SPLIT_MASK;
     const hi = x - lo;
 
     arr[0] = hi;
@@ -726,8 +728,8 @@ export function splitHighPrecision(x, arr = []) {
  * @param {number[]} [arr]
  */
 export function splitLargeHighPrecision(x, arr = []) {
-    const lo = x % BS;
-    const hi = (x - lo) / BS;
+    const lo = x % HIGH_PRECISION_SPLIT_BASE;
+    const hi = (x - lo) / HIGH_PRECISION_SPLIT_BASE;
 
     arr[0] = hi;
     arr[1] = lo;
@@ -739,7 +741,7 @@ export function splitLargeHighPrecision(x, arr = []) {
  * @param {number} x
  */
 function exactSplitHighPrecision(x) {
-    const lo = x % BS;
+    const lo = x % HIGH_PRECISION_SPLIT_BASE;
     const hi = x - lo;
 
     return [hi, lo];

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

@@ -0,0 +1,23 @@
+/**
+ * @callback VertexReader
+ * @param {number} vertexIndex
+ * @returns {number}
+ */
+/**
+ * A binned index for vertex ranges that are already emitted into typed arrays.
+ * The readers operate on vertices, not source datums.
+ *
+ * The scan is run-based: consecutive vertices with the same effective x
+ * interval are collapsed into one range before binning.
+ *
+ * @param {number} size Number of bins
+ * @param {[number, number]} domain Domain of positions
+ * @param {VertexReader} readStart Reader for the start x value at a vertex
+ * @param {VertexReader} [readEnd=readStart] Reader for the end x value at a vertex
+ * @param {number} [startVertexIndex=0] First vertex index in the scanned range
+ * @param {number} [endVertexIndex=startVertexIndex] One past the last vertex index
+ * @returns {import("../utils/binnedIndex.js").Lookup | undefined}
+ */
+export function createVertexRangeIndexer(size: number, domain: [number, number], readStart: VertexReader, readEnd?: VertexReader, startVertexIndex?: number, endVertexIndex?: number): import("../utils/binnedIndex.js").Lookup | undefined;
+export type VertexReader = (vertexIndex: number) => number;
+//# sourceMappingURL=vertexRangeIndex.d.ts.map

package/dist/src/gl/vertexRangeIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertexRangeIndex.d.ts","sourceRoot":"","sources":["../../../src/gl/vertexRangeIndex.js"],"names":[],"mappings":"AAKA;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AACH,+CARW,MAAM,UACN,CAAC,MAAM,EAAE,MAAM,CAAC,aAChB,YAAY,YACZ,YAAY,qBACZ,MAAM,mBACN,MAAM,GACJ,OAAO,yBAAyB,EAAE,MAAM,GAAG,SAAS,CA6HhE;yCA9IU,MAAM,KACJ,MAAM"}

package/dist/src/gl/vertexRangeIndex.js

@@ -0,0 +1,150 @@
+import clamp from "../utils/clamp.js";
+
+const MAX_INTEGER = 2 ** 31 - 1;
+const MIN_INTEGER = -(2 ** 31);
+
+/**
+ * @callback VertexReader
+ * @param {number} vertexIndex
+ * @returns {number}
+ */
+
+/**
+ * A binned index for vertex ranges that are already emitted into typed arrays.
+ * The readers operate on vertices, not source datums.
+ *
+ * The scan is run-based: consecutive vertices with the same effective x
+ * interval are collapsed into one range before binning.
+ *
+ * @param {number} size Number of bins
+ * @param {[number, number]} domain Domain of positions
+ * @param {VertexReader} readStart Reader for the start x value at a vertex
+ * @param {VertexReader} [readEnd=readStart] Reader for the end x value at a vertex
+ * @param {number} [startVertexIndex=0] First vertex index in the scanned range
+ * @param {number} [endVertexIndex=startVertexIndex] One past the last vertex index
+ * @returns {import("../utils/binnedIndex.js").Lookup | undefined}
+ */
+export function createVertexRangeIndexer(
+    size,
+    domain,
+    readStart,
+    readEnd = readStart,
+    startVertexIndex = 0,
+    endVertexIndex = startVertexIndex
+) {
+    if (endVertexIndex <= startVertexIndex) {
+        return undefined;
+    }
+
+    if (domain[1] <= domain[0]) {
+        return undefined;
+    }
+
+    const startIndices = new Array(size);
+    startIndices.fill(MAX_INTEGER);
+
+    const endIndices = new Array(size);
+    endIndices.fill(0);
+
+    const start = domain[0];
+    const domainLength = domain[1] - domain[0];
+    const divisor = domainLength / size;
+
+    /**
+     * @param {number} pos
+     * @param {boolean} end
+     */
+    const getBin = (pos, end) => {
+        const unfloored = (pos - start) / divisor;
+        const floored = Math.floor(unfloored);
+
+        // Special handling for the end coordinate because we are using half-open ranges.
+        return clamp(
+            end && floored == unfloored ? floored - 1 : floored,
+            0,
+            size - 1
+        );
+    };
+
+    let lastIndex = MIN_INTEGER;
+    let lastStart = -Infinity;
+    let unordered = false;
+
+    /**
+     * @type {import("../utils/binnedIndex.js").Lookup}
+     */
+    const lookup = (queryStart, queryEnd, arr = [0, 0]) => {
+        const startBin = getBin(queryStart, false);
+        const endBin = getBin(queryEnd, true);
+        const startIndex = startIndices[startBin];
+        const endIndex = Math.max(endIndices[endBin], startIndex);
+
+        arr[0] = startIndex;
+        arr[1] = endIndex;
+        return arr;
+    };
+
+    for (let i = startVertexIndex; i < endVertexIndex; ) {
+        const runStart = i;
+        const runX = readStart(i);
+        const runX2 = readEnd(i);
+
+        i += 1;
+        while (
+            i < endVertexIndex &&
+            readStart(i) === runX &&
+            readEnd(i) === runX2
+        ) {
+            i += 1;
+        }
+
+        if (runStart > lastIndex) {
+            lastIndex = runStart;
+        } else {
+            unordered = true;
+            break;
+        }
+
+        if (runX < lastStart || runX2 < runX) {
+            unordered = true;
+            break;
+        }
+        lastStart = runX;
+
+        const startBin = getBin(runX, false);
+        const endBin = getBin(runX2, true);
+
+        for (let bin = startBin; bin <= endBin; bin++) {
+            if (startIndices[bin] > runStart) {
+                startIndices[bin] = runStart;
+            }
+
+            if (endIndices[bin] < i) {
+                endIndices[bin] = i;
+            }
+        }
+    }
+
+    if (unordered) {
+        return undefined;
+    }
+
+    for (let i = 1; i < endIndices.length; i++) {
+        if (endIndices[i] < endIndices[i - 1]) {
+            endIndices[i] = endIndices[i - 1];
+        }
+    }
+
+    let tail = true;
+
+    for (let i = startIndices.length - 1; i > 0; i--) {
+        if (tail && startIndices[i] == MAX_INTEGER) {
+            startIndices[i] = endIndices[i];
+            tail = false;
+        } else if (startIndices[i - 1] > startIndices[i]) {
+            startIndices[i - 1] = startIndices[i];
+        }
+    }
+
+    return lookup;
+}

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

@@ -40,11 +40,12 @@ export default class WebGLHelper {
      *      A function that returns the content size. If a dimension is undefined,
      *      the canvas fills the container, otherwise the canvas is adjusted to the content size.
      * @param {WebGLContextAttributes} [webglContextAttributes]
+     * @param {() => void} [onCanvasResize]
      */
     constructor(container: HTMLElement, sizeSource?: () => {
         width: number;
         height: number;
-    }, webglContextAttributes?: WebGLContextAttributes);
+    }, webglContextAttributes?: WebGLContextAttributes, onCanvasResize?: () => void);
     /**
      * @type {CanvasSizeHelper}
      */
@@ -58,6 +59,8 @@ export default class WebGLHelper {
         physicalWidth: number;
         physicalHeight: number;
     } | undefined;
+    /** @type {() => void} */
+    _onCanvasResize: () => void;
     /** @type {Map<string, WebGLShader>} */
     _shaderCache: Map<string, WebGLShader>;
     /** @type {WeakMap<import("../types/encoder.js").VegaScale, WebGLTexture>} */
@@ -79,7 +82,7 @@ export default class WebGLHelper {
      * @param {string | string[]} glsl
      */
     compileShader(type: number, glsl: string | string[]): WebGLShader;
-    adjustGl(): void;
+    adjustGl(): boolean;
     finalize(): void;
     /**
      * Returns the canvas size in true display pixels

package/dist/src/gl/webGLHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webGLHelper.d.ts","sourceRoot":"","sources":["../../../src/gl/webGLHelper.js"],"names":[],"mappings":"AAybA;;;;GAIG;AACH,kCAJW,sBAAsB,gBACtB,WAAW,kBACX,WAAW;;;;;;EA8CrB;AAED;;;;;GAKG;AACH,0CALW,qBAAqB,WACrB,IAAI,CAAC,OAAO,SAAS,EAAE,cAAc,EAAE,KAAK,CAAC,OAC7C,MAAM,EAAE,GAAG,eAAe,YAC1B,YAAY,gBAYtB;AAED;;;;;;GAMG;AACH,qCALW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,KACjC,MAAM,KACN,MAAM,2BAWhB;AAED;;;;;GAKG;AACH,yCAJW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,SACjC,MAAM,UA4BhB;AA7gBD;IACI;;;;;;;OAOG;IACH,uBANW,WAAW,eACX,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,2BAGrC,sBAAsB,EAsGhC;IA5FG;;OAEG;IACH,mBAFU,gBAAgB,CAEQ;IAElC;;OAEG;IACH,oBAFU;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAEjF;IAEnC,uCAAuC;IACvC,cADW,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CACN;IAE7B,6EAA6E;IAC7E,eADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,SAAS,EAAE,YAAY,CAAC,CACvC;IAElC;;OAEG;IACH,mBAFU,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAEnD;IA8CtC,0BAAoB;IACpB,2BAAY;IAGZ,oDAAoD;IACpD,2BADW,OAAO,SAAS,EAAE,iBAAiB,EAAE,CAQ/C;IACD,sDAGC;IAaL,uBAGC;IAED;;;;;OAKG;IACH,oBAHW,MAAM,QACN,MAAM,GAAG,MAAM,EAAE,eA2B3B;IAED,iBAgCC;IAED,iBAGC;IAED;;;;OAIG;IACH,oCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;;;MAI3C;IAED;;;;OAIG;IACH,kCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,UAI3C;IAED;;;OAGG;IACH;;;MAEC;IAED;;;;;;;;;OASG;IACH,+BAHW,OAAO,8BAA8B,EAAE,OAAO,WAC9C,OAAO,QA2GjB;IAED;;OAEG;IACH,kCAFW,OAAO,4BAA4B,EAAE,mBAAmB,0BAwClE;CACJ;6BAvX4B,uBAAuB"}
+{"version":3,"file":"webGLHelper.d.ts","sourceRoot":"","sources":["../../../src/gl/webGLHelper.js"],"names":[],"mappings":"AA0cA;;;;GAIG;AACH,kCAJW,sBAAsB,gBACtB,WAAW,kBACX,WAAW;;;;;;EA8CrB;AAED;;;;;GAKG;AACH,0CALW,qBAAqB,WACrB,IAAI,CAAC,OAAO,SAAS,EAAE,cAAc,EAAE,KAAK,CAAC,OAC7C,MAAM,EAAE,GAAG,eAAe,YAC1B,YAAY,gBAYtB;AAED;;;;;;GAMG;AACH,qCALW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,KACjC,MAAM,KACN,MAAM,2BAWhB;AAED;;;;;GAKG;AACH,yCAJW,sBAAsB,mBACtB,OAAO,SAAS,EAAE,eAAe,SACjC,MAAM,UA4BhB;AA9hBD;IACI;;;;;;;;OAQG;IACH,uBAPW,WAAW,eACX,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,2BAGrC,sBAAsB,mBACtB,MAAM,IAAI,EAoHpB;IArGG;;OAEG;IACH,mBAFU,gBAAgB,CAEQ;IAElC;;OAEG;IACH,oBAFU;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAEjF;IAEnC,yBAAyB;IACzB,iBADW,MAAM,IAAI,CAC8B;IAEnD,uCAAuC;IACvC,cADW,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CACN;IAE7B,6EAA6E;IAC7E,eADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,SAAS,EAAE,YAAY,CAAC,CACvC;IAElC;;OAEG;IACH,mBAFU,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAEnD;IA8CtC,0BAAoB;IACpB,2BAAY;IAGZ,oDAAoD;IACpD,2BADW,OAAO,SAAS,EAAE,iBAAiB,EAAE,CAQ/C;IACD,sDAGC;IAmBL,uBAGC;IAED;;;;;OAKG;IACH,oBAHW,MAAM,QACN,MAAM,GAAG,MAAM,EAAE,eA2B3B;IAED,oBAkCC;IAED,iBAGC;IAED;;;;OAIG;IACH,oCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;;;MAI3C;IAED;;;;OAIG;IACH,kCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,UAI3C;IAED;;;OAGG;IACH;;;MAEC;IAED;;;;;;;;;OASG;IACH,+BAHW,OAAO,8BAA8B,EAAE,OAAO,WAC9C,OAAO,QA2GjB;IAED;;OAEG;IACH,kCAFW,OAAO,4BAA4B,EAAE,mBAAmB,0BAwClE;CACJ;6BAxY4B,uBAAuB"}

package/dist/src/gl/webGLHelper.js

@@ -41,8 +41,14 @@ export default class WebGLHelper {
      *      A function that returns the content size. If a dimension is undefined,
      *      the canvas fills the container, otherwise the canvas is adjusted to the content size.
      * @param {WebGLContextAttributes} [webglContextAttributes]
+     * @param {() => void} [onCanvasResize]
      */
-    constructor(container, sizeSource, webglContextAttributes = {}) {
+    constructor(
+        container,
+        sizeSource,
+        webglContextAttributes = {},
+        onCanvasResize
+    ) {
         const resolvedSizeSource =
             sizeSource ??
             (() => ({
@@ -60,6 +66,9 @@ export default class WebGLHelper {
          */
         this._appliedCanvasSize = undefined;
 
+        /** @type {() => void} */
+        this._onCanvasResize = onCanvasResize ?? (() => {});
+
         /** @type {Map<string, WebGLShader>} */
         this._shaderCache = new Map();
 
@@ -138,7 +147,13 @@ export default class WebGLHelper {
             container,
             canvas,
             resolvedSizeSource,
-            () => this.adjustGl()
+            () => {
+                // Assigning canvas.width/height clears the WebGL drawing buffer.
+                // The observer may fire after layout/render, so repaint immediately.
+                if (this.adjustGl()) {
+                    this._onCanvasResize();
+                }
+            }
         );
 
         this.adjustGl();
@@ -193,7 +208,7 @@ export default class WebGLHelper {
             this._appliedCanvasSize.physicalWidth == physicalSize.width &&
             this._appliedCanvasSize.physicalHeight == physicalSize.height
         ) {
-            return;
+            return false;
         }
 
         this.canvas.style.width = `${logicalSize.width}px`;
@@ -214,6 +229,8 @@ export default class WebGLHelper {
             physicalWidth: physicalSize.width,
             physicalHeight: physicalSize.height,
         };
+
+        return true;
     }
 
     finalize() {