@genome-spy/core 0.48.0 → 0.48.2

package/dist/schema.json

@@ -3471,8 +3471,15 @@
           "description": "The vertical padding, in pixels, when the `y2` channel is used for ranged text.\n\n**Default value:** `0`"
         },
         "segments": {
-          "description": "The number of segments in the bézier curve. Affects the rendering quality and performance. Use a higher value for a smoother curve.\n\n**Default value:* `101`",
-          "type": "number"
+          "anyOf": [
+            {
+              "type": "number"
+            },
+            {
+              "$ref": "#/definitions/ExprRef"
+            }
+          ],
+          "description": "The number of segments in the bézier curve. Affects the rendering quality and performance. Use a higher value for a smoother curve.\n\n**Default value:* `101`"
         },
         "semanticZoomFraction": {
           "anyOf": [

package/dist/src/data/collector.d.ts

@@ -12,25 +12,27 @@ export default class Collector extends FlowNode {
     params: import("../spec/transform.js").CollectParams;
     /** @type {(function(Collector):void)[]} */
     observers: ((arg0: Collector) => void)[];
-    /** @type {Map<any | any[], import("./flowNode.js").Data>} TODO: proper type for key */
-    facetBatches: Map<any | any[], import("./flowNode.js").Data>;
-    _init(): void;
-    /** @type {import("./flowNode.js").Data} */
-    _data: import("./flowNode.js").Data;
+    /** @type {Map<import("../spec/channel.js").Scalar[], Data>} TODO: proper type for key */
+    facetBatches: Map<import("../spec/channel.js").Scalar[], import("./flowNode.js").Data>;
     /**
-     * @returns {Iterable<import("./flowNode.js").Datum>}
+     * @returns {Iterable<Datum>}
      */
     getData(): Iterable<import("./flowNode.js").Datum>;
     /**
      *
-     * @param {(datum: import("./flowNode.js").Datum) => void} visitor
+     * @param {(datum: Datum) => void} visitor
      */
     visitData(visitor: (datum: import("./flowNode.js").Datum) => void): void;
     /**
      * Returns the total number of data items collected.
      */
     getItemCount(): number;
-    _checkStatus(): void;
+    /**
+     * Use an index to find a datum by its unique id.
+     *
+     * @param {number} uniqueId
+     */
+    findDatumByUniqueId(uniqueId: number): import("./flowNode.js").Datum;
     #private;
 }
 import FlowNode from "./flowNode.js";

package/dist/src/data/collector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../../src/data/collector.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH;IAKI;;OAEG;IACH,qBAFW,OAAO,sBAAsB,EAAE,aAAa,EActD;IATG,qDAA2C;IAE3C,2CAA2C;IAC3C,WADW,QAAU,SAAS,KAAE,IAAI,CAAC,EAAE,CACpB;IAEnB,uFAAuF;IACvF,cADW,IAAI,GAAG,GAAG,GAAG,EAAE,EAAE,OAAO,eAAe,EAAE,IAAI,CAAC,CAC5B;IAKjC,cAOC;IANG,2CAA2C;IAC3C,OADW,OAAO,eAAe,EAAE,IAAI,CACxB;IA6GnB;;OAEG;IACH,WAFa,SAAS,OAAO,eAAe,EAAE,KAAK,CAAC,CAuBnD;IAED;;;OAGG;IACH,2BAFmB,OAAO,eAAe,EAAE,KAAK,KAAK,IAAI,QAUxD;IAED;;OAEG;IACH,uBAMC;IAED,qBAMC;;CACJ;qBAzMyD,eAAe"}
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../../src/data/collector.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH;IA8BI;;OAEG;IACH,qBAFW,OAAO,sBAAsB,EAAE,aAAa,EAetD;IAVG,qDAA2C;IAE3C,2CAA2C;IAC3C,WADW,QAAU,SAAS,KAAE,IAAI,CAAC,EAAE,CACpB;IAGnB,yFAAyF;IACzF,cADW,IAAI,OAAO,oBAAoB,EAAE,MAAM,EAAE,+BAAO,CACN;IAuHzD;;OAEG;IACH,mDAmBC;IAED;;;OAGG;IACH,6DAF6B,IAAI,QAUhC;IAED;;OAEG;IACH,uBAMC;IA8CD;;;;OAIG;IACH,8BAFW,MAAM,iCA4BhB;;CACJ;qBA3SyD,eAAe"}

package/dist/src/data/collector.js

@@ -1,10 +1,12 @@
 import { InternMap } from "internmap";
-import { group } from "d3-array";
+import { bisector, group } from "d3-array";
 import { compare } from "vega-util";
 import iterateNestedMaps from "../utils/iterateNestedMaps.js";
 import FlowNode, { BEHAVIOR_COLLECTS, isFacetBatch } from "./flowNode.js";
 import { field } from "../utils/field.js";
 import { asArray } from "../utils/arrayUtils.js";
+import { radixSortIntoLookupArray } from "../utils/radixSort.js";
+import { UNIQUE_ID_KEY } from "./transforms/identifier.js";
 
 /**
  * Collects (materializes) the data that flows through this node.
@@ -13,6 +15,31 @@ import { asArray } from "../utils/arrayUtils.js";
  * Grouping is primarily intended for handling faceted data.
  */
 export default class Collector extends FlowNode {
+    /**
+     * @typedef {import("./flowNode.js").Datum} Datum
+     * @typedef {import("./flowNode.js").Data} Data
+     */
+
+    /**
+     * Current batch that is being collected.
+     * @type {Data}
+     */
+    #buffer = [];
+
+    #uniqueIdAccessor = field(UNIQUE_ID_KEY);
+
+    /**
+     * @type {number[]}
+     */
+    #uniqueIdIndex = [];
+
+    /**
+     * Start and end indices of all facets if they are concatenated into a single array.
+     * Used together with the uniqueIdIndex for looking up data items by their unique id.
+     * @type {{start: number, stop: number, facetId: import("../spec/channel.js").Scalar[]}[]}
+     */
+    #facetIndices;
+
     get behavior() {
         return BEHAVIOR_COLLECTS;
     }
@@ -28,32 +55,30 @@ export default class Collector extends FlowNode {
         /** @type {(function(Collector):void)[]} */
         this.observers = [];
 
-        /** @type {Map<any | any[], import("./flowNode.js").Data>} TODO: proper type for key */
-        this.facetBatches = undefined;
+        // TODO: Consider nested maps instead of InternMap
+        /** @type {Map<import("../spec/channel.js").Scalar[], Data>} TODO: proper type for key */
+        this.facetBatches = new InternMap([], JSON.stringify);
 
-        this._init();
+        this.#init();
     }
 
-    _init() {
-        /** @type {import("./flowNode.js").Data} */
-        this._data = [];
+    #init() {
+        this.#buffer = [];
 
-        // TODO: Consider nested maps
-        this.facetBatches = new InternMap([], JSON.stringify);
-        this.facetBatches.set(undefined, this._data);
+        this.facetBatches.clear();
+        this.facetBatches.set(undefined, this.#buffer);
     }
 
     reset() {
         super.reset();
-        this._init();
+        this.#init();
     }
 
     /**
-     *
-     * @param {import("./flowNode.js").Datum} datum
+     * @param {Datum} datum
      */
     handle(datum) {
-        this._data.push(datum);
+        this.#buffer.push(datum);
     }
 
     /**
@@ -61,12 +86,15 @@ export default class Collector extends FlowNode {
      */
     beginBatch(flowBatch) {
         if (isFacetBatch(flowBatch)) {
-            this._data = [];
-            this.facetBatches.set(asArray(flowBatch.facetId), this._data);
+            this.#buffer = [];
+            this.facetBatches.set(asArray(flowBatch.facetId), this.#buffer);
         }
     }
 
     complete() {
+        // Free some memory
+        this.#buffer = [];
+
         const sort = this.params?.sort;
         // Vega's "compare" function is incredibly slow (uses megamorphic field accessor)
         // TODO: Implement a replacement for static data types
@@ -84,6 +112,8 @@ export default class Collector extends FlowNode {
                 throw new Error("TODO: Support faceted data!");
             }
 
+            const data = this.facetBatches.get(undefined);
+
             const accessors = this.params.groupby.map((fieldName) =>
                 field(fieldName)
             );
@@ -91,10 +121,10 @@ export default class Collector extends FlowNode {
                 accessors.length > 1
                     ? // There's something strange in d3-array's typings
                       /** @type {Map<any, any>} */ /** @type {any} */ (
-                          group(this._data, ...accessors)
+                          group(data, ...accessors)
                       )
                     : // D3's group is SLOW!
-                      groupBy(this._data, accessors[0]);
+                      groupBy(data, accessors[0]);
 
             this.facetBatches.clear();
             for (const [key, data] of iterateNestedMaps(groups)) {
@@ -107,6 +137,7 @@ export default class Collector extends FlowNode {
             sortData(data);
         }
 
+        this.#buildUniqueIdIndex();
         this.#propagateToChildren();
 
         super.complete();
@@ -118,16 +149,16 @@ export default class Collector extends FlowNode {
 
     #propagateToChildren() {
         if (this.children.length) {
-            for (const [key, data] of this.facetBatches.entries()) {
-                if (key) {
+            for (const [facetId, data] of this.facetBatches.entries()) {
+                if (facetId) {
                     /** @type {import("../types/flowBatch.js").FacetBatch} */
-                    const facetBatch = { type: "facet", facetId: key };
+                    const facetBatch = { type: "facet", facetId };
                     for (const child of this.children) {
                         child.beginBatch(facetBatch);
                     }
                 }
-                for (const datum of data) {
-                    this._propagate(datum);
+                for (let i = 0, n = data.length; i < n; i++) {
+                    this._propagate(data[i]);
                 }
             }
         }
@@ -146,10 +177,10 @@ export default class Collector extends FlowNode {
     }
 
     /**
-     * @returns {Iterable<import("./flowNode.js").Datum>}
+     * @returns {Iterable<Datum>}
      */
     getData() {
-        this._checkStatus();
+        this.#checkStatus();
 
         switch (this.facetBatches.size) {
             case 0:
@@ -161,9 +192,7 @@ export default class Collector extends FlowNode {
                 return {
                     [Symbol.iterator]: function* generator() {
                         for (const data of groups.values()) {
-                            for (let i = 0; i < data.length; i++) {
-                                yield data[i];
-                            }
+                            yield* data;
                         }
                     },
                 };
@@ -173,10 +202,10 @@ export default class Collector extends FlowNode {
 
     /**
      *
-     * @param {(datum: import("./flowNode.js").Datum) => void} visitor
+     * @param {(datum: Datum) => void} visitor
      */
     visitData(visitor) {
-        this._checkStatus();
+        this.#checkStatus();
 
         for (const data of this.facetBatches.values()) {
             for (let i = 0; i < data.length; i++) {
@@ -196,21 +225,90 @@ export default class Collector extends FlowNode {
         return count;
     }
 
-    _checkStatus() {
+    #checkStatus() {
         if (!this.completed) {
             throw new Error(
                 "Data propagation is not completed! No data are available."
             );
         }
     }
+
+    /**
+     * Builds an index for looking up data items by their unique id.
+     * Using a sorted index and binary search for O(log n) complexity.
+     */
+    #buildUniqueIdIndex() {
+        this.#facetIndices = [];
+
+        /** @type {Datum} */
+        const obj = this.facetBatches.values().next().value?.[0];
+        if (obj == null || !(UNIQUE_ID_KEY in obj)) {
+            return; // No unique ids in the data
+        }
+
+        let cumulativePos = 0;
+
+        /** @type {number[]} */
+        const ids = [];
+
+        const a = this.#uniqueIdAccessor;
+
+        for (const [facetId, data] of this.facetBatches) {
+            this.#facetIndices.push({
+                start: cumulativePos,
+                stop: cumulativePos + data.length,
+                facetId,
+            });
+            cumulativePos += data.length;
+
+            for (let i = 0, n = data.length; i < n; i++) {
+                ids.push(a(data[i]));
+            }
+        }
+
+        this.#uniqueIdIndex = radixSortIntoLookupArray(ids);
+    }
+
+    /**
+     * Use an index to find a datum by its unique id.
+     *
+     * @param {number} uniqueId
+     */
+    findDatumByUniqueId(uniqueId) {
+        if (!this.#uniqueIdIndex.length) {
+            return;
+        }
+
+        const facetBisector = bisector((f) => f.start).right;
+        const a = this.#uniqueIdAccessor;
+        const indexBisector = bisector((i) => a(getDatum(i))).left;
+
+        const getDatum = (/** @type {number} */ i) => {
+            const fi = facetBisector(this.#facetIndices, i);
+            const facet = this.#facetIndices[fi - 1];
+            if (!facet || i >= facet.stop) {
+                return;
+            }
+            const data = this.facetBatches.get(facet.facetId);
+            return data[i - facet.start];
+        };
+
+        const index = indexBisector(this.#uniqueIdIndex, uniqueId);
+        if (index >= 0) {
+            const datum = getDatum(this.#uniqueIdIndex[index]);
+            if (datum && a(datum) === uniqueId) {
+                return datum;
+            }
+        }
+    }
 }
 
 /**
  * Like D3's group but without InternMap, which is slow.
  * TODO: Implement multi-level grouping
  *
- * @param {import("./flowNode.js").Datum[]} data
- * @param {(data: import("./flowNode.js").Datum) => import("../spec/channel.js").Scalar} accessor
+ * @param {Datum[]} data
+ * @param {(data: Datum) => import("../spec/channel.js").Scalar} accessor
  */
 function groupBy(data, accessor) {
     const groups = new Map();

package/dist/src/data/collector.test.js

@@ -1,6 +1,7 @@
-import { expect, test } from "vitest";
+import { describe, expect, test } from "vitest";
 
 import Collector from "./collector.js";
+import { UNIQUE_ID_KEY } from "./transforms/identifier.js";
 
 const data = [1, 5, 2, 4, 3].map((x) => ({ x }));
 
@@ -82,3 +83,56 @@ test("Collector throws on incomplete flow", () => {
 
     expect(() => collector.getData()).toThrow();
 });
+
+describe("Indexing unique ids", () => {
+    test("Collector builds a working index when ids are available", () => {
+        const collector = new Collector({
+            type: "collect",
+            groupby: ["a"],
+        });
+
+        const data = [
+            { a: 1, x: 1, [UNIQUE_ID_KEY]: 8 },
+            { a: 1, x: 2, [UNIQUE_ID_KEY]: 2 },
+            { a: 1, x: 3, [UNIQUE_ID_KEY]: 4 },
+            { a: 1, x: 4, [UNIQUE_ID_KEY]: 6 },
+            { a: 2, x: 5, [UNIQUE_ID_KEY]: 9 },
+            { a: 2, x: 6, [UNIQUE_ID_KEY]: 7 },
+            { a: 2, x: 7, [UNIQUE_ID_KEY]: 3 },
+            { a: 2, x: 8, [UNIQUE_ID_KEY]: 1 },
+        ];
+
+        for (const d of data) {
+            collector.handle(d);
+        }
+        collector.complete();
+
+        expect(collector.findDatumByUniqueId(8)).toEqual(data[0]);
+        expect(collector.findDatumByUniqueId(2)).toEqual(data[1]);
+        expect(collector.findDatumByUniqueId(4)).toEqual(data[2]);
+        expect(collector.findDatumByUniqueId(6)).toEqual(data[3]);
+        expect(collector.findDatumByUniqueId(9)).toEqual(data[4]);
+        expect(collector.findDatumByUniqueId(7)).toEqual(data[5]);
+        expect(collector.findDatumByUniqueId(3)).toEqual(data[6]);
+        expect(collector.findDatumByUniqueId(1)).toEqual(data[7]);
+    });
+
+    test("Collector returns undefined when ids are not available", () => {
+        const collector = new Collector({
+            type: "collect",
+            groupby: ["a"],
+        });
+
+        const data = [
+            { a: 1, x: 1 },
+            { a: 2, x: 5 },
+        ];
+
+        for (const d of data) {
+            collector.handle(d);
+        }
+        collector.complete();
+
+        expect(collector.findDatumByUniqueId(0)).toBeUndefined();
+    });
+});

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

@@ -1,4 +1,4 @@
-export const DEFAULT_AS: "_uniqueId";
+export const UNIQUE_ID_KEY: "_uniqueId";
 export const BLOCK_SIZE: 10000;
 /**
  * Assigns unique identifiers for tuples that pass through this transform.

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

@@ -1 +1 @@
-{"version":3,"file":"identifier.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/identifier.js"],"names":[],"mappings":"AAEA,qCAAsC;AAEtC,+BAAgC;AAehC;;;;;;;GAOG;AACH;IAKI;;;OAGG;IACH,oBAFW,OAAO,yBAAyB,EAAE,gBAAgB,EAuB5D;IAnBG,2DAAoB;IAEpB,WAAiC;IAEjC;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;OAEG;IACH,oBAAoB;IAEpB;;OAEG;IACH,YAAa;IAuBjB;;OAEG;IACH,WAFa,MAAM,CAOlB;IAED,oBAMC;IAED,wBAOC;CACJ;qBAzG2C,gBAAgB"}
+{"version":3,"file":"identifier.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/identifier.js"],"names":[],"mappings":"AAEA,wCAAyC;AAEzC,+BAAgC;AAehC;;;;;;;GAOG;AACH;IAKI;;;OAGG;IACH,oBAFW,OAAO,yBAAyB,EAAE,gBAAgB,EAuB5D;IAnBG,2DAAoB;IAEpB,WAAoC;IAEpC;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;OAEG;IACH,oBAAoB;IAEpB;;OAEG;IACH,YAAa;IAuBjB;;OAEG;IACH,WAFa,MAAM,CAOlB;IAED,oBAMC;IAED,wBAOC;CACJ;qBAzG2C,gBAAgB"}

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

@@ -1,6 +1,6 @@
 import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode.js";
 
-export const DEFAULT_AS = "_uniqueId";
+export const UNIQUE_ID_KEY = "_uniqueId";
 
 export const BLOCK_SIZE = 10000;
 
@@ -38,7 +38,7 @@ export default class IdentifierTransform extends FlowNode {
         super();
         this.params = params;
 
-        this.as = params.as ?? DEFAULT_AS;
+        this.as = params.as ?? UNIQUE_ID_KEY;
 
         /**
          * The block indexes reserved by this transform instance.

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

@@ -1,7 +1,10 @@
 import { expect, test } from "vitest";
 import { range } from "d3-array";
 import { processData } from "../flowTestUtils.js";
-import IdentifierTransform, { BLOCK_SIZE, DEFAULT_AS } from "./identifier.js";
+import IdentifierTransform, {
+    BLOCK_SIZE,
+    UNIQUE_ID_KEY,
+} from "./identifier.js";
 
 test("An IdentifierTransform adds identifiers correctly", () => {
     const data = range(BLOCK_SIZE * 2).map((x) => ({ data: x }));
@@ -14,15 +17,18 @@ test("An IdentifierTransform adds identifiers correctly", () => {
     // 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[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
+    expect(identifiedData[1]).toEqual({
+        data: 1,
+        [UNIQUE_ID_KEY]: firstId + 1,
+    });
     expect(identifiedData[BLOCK_SIZE]).toEqual({
         data: BLOCK_SIZE,
-        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
     });
     expect(identifiedData[BLOCK_SIZE + 1]).toEqual({
         data: BLOCK_SIZE + 1,
-        [DEFAULT_AS]: firstId + BLOCK_SIZE + 1,
+        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE + 1,
     });
 });
 
@@ -37,15 +43,18 @@ test("Another transform instance adds identifiers correctly", () => {
     // 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[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
+    expect(identifiedData[1]).toEqual({
+        data: 1,
+        [UNIQUE_ID_KEY]: firstId + 1,
+    });
     expect(identifiedData[BLOCK_SIZE]).toEqual({
         data: BLOCK_SIZE,
-        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
     });
     expect(identifiedData[BLOCK_SIZE + 1]).toEqual({
         data: BLOCK_SIZE + 1,
-        [DEFAULT_AS]: firstId + BLOCK_SIZE + 1,
+        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE + 1,
     });
 });
 
@@ -57,10 +66,10 @@ test("IdentifierTransform recycles allocated blocks", () => {
 
     let firstId = BLOCK_SIZE * 5;
 
-    expect(identifiedData[0]).toEqual({ data: 0, [DEFAULT_AS]: firstId });
+    expect(identifiedData[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
     expect(identifiedData[BLOCK_SIZE]).toEqual({
         data: BLOCK_SIZE,
-        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
     });
 
     data = range(BLOCK_SIZE * 3).map((x) => ({ data: x }));
@@ -69,15 +78,15 @@ test("IdentifierTransform recycles allocated blocks", () => {
     transform.reset();
     identifiedData = processData(transform, data);
 
-    expect(identifiedData[0]).toEqual({ data: 0, [DEFAULT_AS]: firstId });
+    expect(identifiedData[0]).toEqual({ data: 0, [UNIQUE_ID_KEY]: firstId });
     expect(identifiedData[BLOCK_SIZE]).toEqual({
         data: BLOCK_SIZE,
-        [DEFAULT_AS]: firstId + BLOCK_SIZE,
+        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE,
     });
 
     // ... and reserve one extra
     expect(identifiedData[BLOCK_SIZE * 2]).toEqual({
         data: BLOCK_SIZE * 2,
-        [DEFAULT_AS]: firstId + BLOCK_SIZE * 2,
+        [UNIQUE_ID_KEY]: firstId + BLOCK_SIZE * 2,
     });
 });

package/dist/src/genomeSpy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AA+CA;IACI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EA2FpD;IAxFG,uBAA0B;IAC1B,oDAAsB;IAItB,6BAA6B;IAC7B,uBADW,CAAC,MAAM,IAAI,CAAC,EAAE,CACM;IAE/B,sCAAsC;IACtC,wCAAgB;IAEhB,iCAA4C;IAC5C,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,QAAU,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,qEAF0B,OAAO,CAE8B;IAE/D,2CAA2C;IAC3C,mBADW,4BAA4B,CACL;IAClC,2CAA2C;IAC3C,iBADW,4BAA4B,CACP;IAEhC,oDAAoD;IACpD,6BAAgC;IAEhC;;;OAGG;IACH,eAFU;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,oBAAoB,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAEpF;IAE9B,uBAA+C;IAE/C;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAU,aAAa,KAAE,IAAI,CAAC,EAAE,CAAC,CAEpB;IAEnC;;;;;;OAMG;IACH,yCAFkC,GAAG,KAAK,IAAI,GAEd;IAEhC;;;OAGG;IACH,kDAFkC,GAAG,KAAK,IAAI,GAEL;IAEzC,oFAAoF;IACpF,iBADW,OAAO,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,2CAAyB;IAEzB;;;;OAIG;IACH;gBAF8B,OAAO,wBAAwB,EAAE,iBAAiB;iBAAW,MAAM;OAEnE;IAE9B;;OAEG;IACH,wBAFU,WAAW,CAEkB;IA2C3C;;;OAGG;IACH,2CAFkB,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAaf;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAQb;IAED;;;OAGG;IACH,iCAqDC;IA0DG,uBAQC;IAGD,mCAGE;IAOF,sCAEE;IAGF,iBAAyC;IAW7C;;OAEG;IACH,gBAuBC;IAED,sCA8MC;IAED;;;OAGG;IACH,UAFa,QAAQ,OAAO,CAAC,CA6B5B;IAED,4BAqJC;IA9He,iCAAoC;IAgIpD;;;OAGG;IACH,kBAHW,MAAM,KACN,MAAM,QAsEhB;IAED;;;;;;;OAOG;IACH,oDAHuB,QAAQ,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;IAED,sBA6CC;IAED,kBAIC;IAED,iCAOC;IAED,iCASC;IAED,qFAWC;;CACJ;;;;iCAx7BY,eAAe,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB;4BAlC7C,uBAAuB;4BA2BP,uBAAuB;qBAZ9C,qBAAqB;wBAIlB,yBAAyB;yCARR,yDAAyD;oBAYvD,oBAAoB;wBAdvC,qBAAqB;oBAXzB,uBAAuB;qBAStB,oBAAoB"}
+{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AA+CA;IACI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EA2FpD;IAxFG,uBAA0B;IAC1B,oDAAsB;IAItB,6BAA6B;IAC7B,uBADW,CAAC,MAAM,IAAI,CAAC,EAAE,CACM;IAE/B,sCAAsC;IACtC,wCAAgB;IAEhB,iCAA4C;IAC5C,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,QAAU,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,qEAF0B,OAAO,CAE8B;IAE/D,2CAA2C;IAC3C,mBADW,4BAA4B,CACL;IAClC,2CAA2C;IAC3C,iBADW,4BAA4B,CACP;IAEhC,oDAAoD;IACpD,6BAAgC;IAEhC;;;OAGG;IACH,eAFU;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,oBAAoB,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAEpF;IAE9B,uBAA+C;IAE/C;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAU,aAAa,KAAE,IAAI,CAAC,EAAE,CAAC,CAEpB;IAEnC;;;;;;OAMG;IACH,yCAFkC,GAAG,KAAK,IAAI,GAEd;IAEhC;;;OAGG;IACH,kDAFkC,GAAG,KAAK,IAAI,GAEL;IAEzC,oFAAoF;IACpF,iBADW,OAAO,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,2CAAyB;IAEzB;;;;OAIG;IACH;gBAF8B,OAAO,wBAAwB,EAAE,iBAAiB;iBAAW,MAAM;OAEnE;IAE9B;;OAEG;IACH,wBAFU,WAAW,CAEkB;IA2C3C;;;OAGG;IACH,2CAFkB,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAaf;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAQb;IAED;;;OAGG;IACH,iCAqDC;IA0DG,uBAQC;IAGD,mCAGE;IAOF,sCAEE;IAGF,iBAAyC;IAW7C;;OAEG;IACH,gBAuBC;IAED,sCA8MC;IAED;;;OAGG;IACH,UAFa,QAAQ,OAAO,CAAC,CA6B5B;IAED,4BAqJC;IA9He,iCAAoC;IAgIpD;;;OAGG;IACH,kBAHW,MAAM,KACN,MAAM,QAqEhB;IAED;;;;;;;OAOG;IACH,oDAHuB,QAAQ,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;IAED,sBA6CC;IAED,kBAIC;IAED,iCAOC;IAED,iCASC;IAED,qFAWC;;CACJ;;;;iCAv7BY,eAAe,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB;4BAlC7C,uBAAuB;4BA2BP,uBAAuB;qBAZ9C,qBAAqB;wBAIlB,yBAAyB;yCARR,yDAAyD;oBAYvD,oBAAoB;wBAdvC,qBAAqB;oBAXzB,uBAAuB;qBAStB,oBAAoB"}

package/dist/src/genomeSpy.js

@@ -822,7 +822,10 @@ export default class GenomeSpy {
         const pixelValue = this._glHelper.readPickingPixel(x, y);
 
         const uniqueId =
-            pixelValue[0] | (pixelValue[1] << 8) | (pixelValue[2] << 16);
+            pixelValue[0] |
+            (pixelValue[1] << 8) |
+            (pixelValue[2] << 16) |
+            (pixelValue[3] << 24);
 
         if (uniqueId == 0) {
             this._currentHover = null;
@@ -834,10 +837,6 @@ export default class GenomeSpy {
         }
 
         if (!this._currentHover) {
-            // We are doing an exhaustive search of the data. This is a bit slow with
-            // millions of items.
-            // TODO: Optimize by indexing or something
-
             this.viewRoot.visit((view) => {
                 if (view instanceof UnitView) {
                     if (
@@ -846,16 +845,16 @@ export default class GenomeSpy {
                             coords.containsPoint(x, y)
                         )
                     ) {
-                        const accessor = view.mark.encoders.uniqueId.accessor;
-                        view.getCollector().visitData((d) => {
-                            if (accessor(d) == uniqueId) {
-                                this._currentHover = {
-                                    mark: view.mark,
-                                    datum: d,
-                                    uniqueId,
-                                };
-                            }
-                        });
+                        const datum = view
+                            .getCollector()
+                            .findDatumByUniqueId(uniqueId);
+                        if (datum) {
+                            this._currentHover = {
+                                mark: view.mark,
+                                datum,
+                                uniqueId,
+                            };
+                        }
                     }
                     if (this._currentHover) {
                         return VISIT_STOP;

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

@@ -60,7 +60,7 @@ export class GeometryBuilder {
     addToXIndex(datum: import("../data/flowNode.js").Datum): void;
     xIndexer: {
         (datum: any, startVertexIndex: number, endVertexIndex: number): void;
-        getIndex: () => import("../utils/binnedIndex.js").Lookup;
+        getIndex: () => import("../utils/binnedIndex.js").Lookup; /** @param {Encoder} encoder */
     };
     toArrays(): {
         /** @type {Record<string, {data: Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array, numComponents: number, divisor?: number}>} */

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

@@ -1 +1 @@
-{"version":3,"file":"dataToVertices.d.ts","sourceRoot":"","sources":["../../../src/gl/dataToVertices.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH;IACI;;;OAGG;IAEH;;;;;;OAMG;IACH;;qBAJW,MAAM,EAAE;sBACR,MAAM;OA6EhB;IAzEG,gEAAwB;IAGxB;;MAKC;IAQD,0BAAoC;IAEpC,8BAAoD;IAmDpD,mBAAmB;IAEnB,yFAAyF;IACzF,UADW,IAAI,GAAG,EAAE,UAAU,CAAC,CACkB;IAGrD;;;;OAIG;IACH,mBAFW,GAAG,QAcb;IAED;;OAEG;IACH,oBAFW,IAAI,GAAG,EAAE,MAAM,EAAE,CAAC,QAM5B;IAED;;;OAGG;IACH,cAHW,GAAG,QACH,MAAM,EAAE,kCAYlB;IAED;;;;OAIG;IACH,sBAJW,OAAO,qBAAqB,EAAE,IAAI,OAClC,MAAM,OACN,MAAM,QA+DhB;IAED;;;;;OAKG;IACH,mBAFW,OAAO,qBAAqB,EAAE,KAAK,QAI7C;IA/DO;;;MAAyB;IAiEjC;QAEQ,kJAAkJ;gBAAvI,OAAO,MAAM,EAAE;YAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,CAAC;YAAC,aAAa,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAE9I,8BAA8B;;QAE9B,8CAA8C;;;MAIrD;CACJ;AAED;IACI;;;;;;OAMG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OA+BhB;IAnBG,qBAkBW;CA8BlB;AAED;IACI;;;;;;;;;OASG;IACH;;oBANW,MAAM,EAAE;gCACR,MAAM;uBAEN,MAAM,EAAE;mBACR,MAAM;OAwBhB;IARG,uBAAgC;IAEhC,8BAA8D;IAE9D,6CAA+D;IAC/D,4CAA6D;CA6CpE;AAED;IACI;;;;;;OAMG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OAShB;CACJ;AAED;IACI;;;;;OAKG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OAShB;CAYJ;AAED;IACI;;;;;;;;;OASG;IACH;;oBANW,MAAM,EAAE;qBACR,OAAO,2BAA2B,EAAE,aAAa;oBACjD,OAAO,MAAM,EAAE,GAAG,CAAC;wBACnB,MAAM;sBACN,OAAO;OA8CjB;IA/BG,4DAA2B;IAC3B,2DAA0B;IAE1B,gCAA4B;IAQ5B,qCAAqC;IACrC,sBADmB,GAAG,KAAK,MAAM,CAMf;IAElB,oDAGC;IACD,qDAGC;IAED,8CAAiE;CAgJxE;;;;;;;;YAvmBS,MAAM;;;;WACN,MAAM;YACN,OAAO,yBAAyB,EAAE,MAAM;;yBAjBzB,mBAAmB"}
+{"version":3,"file":"dataToVertices.d.ts","sourceRoot":"","sources":["../../../src/gl/dataToVertices.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH;IACI;;;OAGG;IAEH;;;;;;OAMG;IACH;;qBAJW,MAAM,EAAE;sBACR,MAAM;OAgFhB;IA5EG,gEAAwB;IAGxB;;MAKC;IAQD,0BAAoC;IAEpC,8BAAoD;IAsDpD,mBAAmB;IAEnB,yFAAyF;IACzF,UADW,IAAI,GAAG,EAAE,UAAU,CAAC,CACkB;IAGrD;;;;OAIG;IACH,mBAFW,GAAG,QAcb;IAED;;OAEG;IACH,oBAFW,IAAI,GAAG,EAAE,MAAM,EAAE,CAAC,QAM5B;IAED;;;OAGG;IACH,cAHW,GAAG,QACH,MAAM,EAAE,kCAYlB;IAED;;;;OAIG;IACH,sBAJW,OAAO,qBAAqB,EAAE,IAAI,OAClC,MAAM,OACN,MAAM,QA+DhB;IAED;;;;;OAKG;IACH,mBAFW,OAAO,qBAAqB,EAAE,KAAK,QAI7C;IA/DO;;kEAcJ,+BAA+B;MAdF;IAiEjC;QAEQ,kJAAkJ;gBAAvI,OAAO,MAAM,EAAE;YAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,CAAC;YAAC,aAAa,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAE9I,8BAA8B;;QAE9B,8CAA8C;;;MAIrD;CACJ;AAED;IACI;;;;;;OAMG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OA+BhB;IAnBG,qBAkBW;CA8BlB;AAED;IACI;;;;;;;;;OASG;IACH;;oBANW,MAAM,EAAE;gCACR,MAAM;uBAEN,MAAM,EAAE;mBACR,MAAM;OAwBhB;IARG,uBAAgC;IAEhC,8BAA8D;IAE9D,6CAA+D;IAC/D,4CAA6D;CA6CpE;AAED;IACI;;;;;;OAMG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OAShB;CACJ;AAED;IACI;;;;;OAKG;IACH;;oBAHW,MAAM,EAAE;mBACR,MAAM;OAShB;CAYJ;AAED;IACI;;;;;;;;;OASG;IACH;;oBANW,MAAM,EAAE;qBACR,OAAO,2BAA2B,EAAE,aAAa;oBACjD,OAAO,MAAM,EAAE,GAAG,CAAC;wBACnB,MAAM;sBACN,OAAO;OA8CjB;IA/BG,4DAA2B;IAC3B,2DAA0B;IAE1B,gCAA4B;IAQ5B,qCAAqC;IACrC,sBADmB,GAAG,KAAK,MAAM,CAMf;IAElB,oDAGC;IACD,qDAGC;IAED,8CAAiE;CAgJxE;;;;;;;;YA1mBS,MAAM;;;;WACN,MAAM;YACN,OAAO,yBAAyB,EAAE,MAAM;;yBAjBzB,mBAAmB"}

package/dist/src/gl/dataToVertices.js

@@ -95,11 +95,14 @@ export class GeometryBuilder {
                 f,
                 numComponents: largeHp ? 2 : 1,
                 arrayReference: largeHp ? largeHpArray : undefined,
-                targetArrayType: isDiscrete(ce.scale.type)
-                    ? Uint16Array
-                    : hp
-                    ? Uint32Array
-                    : Float32Array,
+                targetArrayType:
+                    channel == "uniqueId"
+                        ? Uint32Array
+                        : isDiscrete(ce.scale.type)
+                        ? Uint16Array
+                        : hp
+                        ? Uint32Array
+                        : Float32Array,
             });
         }
 

package/dist/src/gl/glslScaleGenerator.js

@@ -171,7 +171,7 @@ export function generateScaleGlsl(
         ? "uvec2"
         : hp
         ? "uint"
-        : discrete
+        : discrete || channel == "uniqueId"
         ? "uint"
         : "float";
 

package/dist/src/gl/includes/picking.vertex.glsl.js

@@ -1,2 +1,2 @@
-const shader = "/**Based on concepts presented at:*https:*https:*/out highp vec4 vPickingColor;/***Passes the unique id to the fragment shader as a color if picking is enabled.*Returns true if picking is enabled.*/bool setupPicking(){if(uPickingEnabled){\n#ifdef uniqueId_DEFINED\nint id=int(getScaled_uniqueId());vPickingColor=vec4(ivec4(id>>0,id>>8,id>>16,0xFF)&0xFF)/float(0xFF);\n#else\nvPickingColor=vec4(1.0);\n#endif\nreturn true;}return false;}";
+const shader = "/**Based on concepts presented at:*https:*https:*/out highp vec4 vPickingColor;/***Passes the unique id to the fragment shader as a color if picking is enabled.*Returns true if picking is enabled.*/bool setupPicking(){if(uPickingEnabled){\n#ifdef uniqueId_DEFINED\nuint id=attr_uniqueId;vPickingColor=vec4(ivec4(id>>0,id>>8,id>>16,id>>24)&0xFF)/float(0xFF);\n#else\nvPickingColor=vec4(1.0);\n#endif\nreturn true;}return false;}";
 export default shader;

package/dist/src/marks/link.common.glsl.js

@@ -1,2 +1,2 @@
-const shader = "layout(std140)uniform Mark{uniform float uArcHeightFactor;uniform float uMinArcHeight;uniform float uMinPickingSize;uniform int uShape;uniform int uOrient;uniform bool uClampApex;uniform float uMaxChordLength;uniform vec2 uArcFadingDistance;\n#pragma markUniforms\n};";
+const shader = "layout(std140)uniform Mark{uniform float uArcHeightFactor;uniform float uMinArcHeight;uniform float uMinPickingSize;uniform int uShape;uniform int uOrient;uniform bool uClampApex;uniform float uMaxChordLength;uniform vec2 uArcFadingDistance;uniform int uSegmentBreaks;\n#pragma markUniforms\n};";
 export default shader;