@genome-spy/core 0.64.0 → 0.66.1

package/dist/src/data/flowInit.js

@@ -0,0 +1,238 @@
+import UnitView from "../view/unitView.js";
+import { buildDataFlow } from "../view/flowBuilder.js";
+import { optimizeDataFlow } from "./flowOptimizer.js";
+import { VISIT_SKIP } from "../view/view.js";
+import { reconfigureScaleDomains } from "../scales/scaleResolution.js";
+
+/** @type {WeakMap<import("./sources/dataSource.js").default, Promise<void>>} */
+const inFlightLoads = new WeakMap();
+
+/**
+ * Deduplicate concurrent loads for shared sources without changing propagation.
+ *
+ * Data sources still propagate rows immediately during `load()`/`loadSynchronously`
+ * and do not retain data. This helper only prevents overlapping `load()` calls
+ * from running twice; collectors remain the sole in-memory cache. Once the load
+ * promise settles, the source may be loaded again later as usual.
+ *
+ * @param {import("./sources/dataSource.js").default} dataSource
+ * @returns {Promise<void>}
+ */
+function loadDataSourceOnce(dataSource) {
+    const existing = inFlightLoads.get(dataSource);
+    if (existing) {
+        return existing;
+    }
+
+    const loadPromise = Promise.resolve()
+        .then(() => dataSource.load())
+        .finally(() => {
+            inFlightLoads.delete(dataSource);
+        });
+
+    inFlightLoads.set(dataSource, loadPromise);
+    return loadPromise;
+}
+
+/**
+ * Synchronize flow handles after data flow optimization.
+ *
+ * @param {import("../view/view.js").default} root
+ * @param {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>} canonicalBySource
+ */
+export function syncFlowHandles(root, canonicalBySource) {
+    for (const view of root.getDescendants()) {
+        const handle = view.flowHandle;
+        if (!handle) {
+            continue;
+        }
+
+        const dataSource = handle.dataSource;
+        if (dataSource) {
+            handle.dataSource = canonicalBySource.get(dataSource) ?? dataSource;
+        }
+    }
+}
+
+/**
+ * Initializes data flow and mark wiring for a subtree without rebuilding the
+ * entire view hierarchy. This is the primary entry point for dynamic view
+ * insertion: build the subtree fully, call this, then attach the subtree to
+ * the live hierarchy.
+ *
+ * What it does:
+ * - builds/extends the dataflow graph for the subtree
+ * - runs flow optimization and syncs flow handles to canonical data sources
+ * - discovers the nearest data sources for views in the subtree
+ * - initializes dataflow nodes (initialize) for those sources
+ * - initializes mark encoders for unit views
+ * - queues graphics initialization (if a GL context exists)
+ * - wires collector observers so marks update on data arrival
+ *
+ * How to use it:
+ * - call after the subtree is fully constructed (post-order build)
+ * - do not attach the subtree to the live hierarchy until after this call
+ * - dispose the old subtree before replacing it to prevent observer leaks
+ * - follow up with finalizeSubtreeGraphics(...) once graphics promises resolve
+ * - reconfigure scales for the subtree when data loads complete
+ *
+ * Considerations:
+ * - this does not trigger data loading; callers decide when to load
+ * - data sources are derived by walking to the nearest ancestor source; nested
+ *   sources should be treated as boundaries (do not walk past them)
+ * - only call updateGraphicsData when graphics are initialized or a GL context
+ *   is available; headless/test contexts must avoid WebGL usage
+ * - loadViewSubtreeData emits a subtree-scoped "subtreeDataReady" broadcast
+ *
+ * TODO:
+ * - promote in-flight load caching to a persistent load-state per source
+ * - replace global dataLoaded usage with subtree-scoped readiness
+ * - integrate with async font readiness for text marks
+ * - unify observer wiring via a disposable registry across view types
+ *
+ * @param {import("../view/view.js").default} subtreeRoot
+ * @param {import("./dataFlow.js").default} flow
+ * @returns {{
+ *     dataFlow: import("./dataFlow.js").default,
+ *     unitViews: UnitView[],
+ *     dataSources: Set<import("./sources/dataSource.js").default>,
+ *     graphicsPromises: Promise<import("../marks/mark.js").default>[]
+ * }}
+ */
+export function initializeViewSubtree(subtreeRoot, flow) {
+    const dataFlow = buildDataFlow(subtreeRoot, flow);
+    const canonicalBySource = optimizeDataFlow(dataFlow);
+    syncFlowHandles(subtreeRoot, canonicalBySource);
+    const subtreeViews = subtreeRoot.getDescendants();
+    const dataSources = collectViewSubtreeDataSources(subtreeViews);
+
+    // Initialize flow nodes for the sources that belong to this subtree.
+    for (const dataSource of dataSources) {
+        dataSource.visit((node) => node.initialize());
+    }
+
+    /** @type {UnitView[]} */
+    const unitViews = subtreeViews.filter((view) => view instanceof UnitView);
+
+    /** @type {Promise<import("../marks/mark.js").default>[]} */
+    const graphicsPromises = [];
+
+    const canInitializeGraphics = !!subtreeRoot.context.glHelper;
+
+    for (const view of unitViews) {
+        const mark = view.mark;
+        // Encoders can be initialized immediately; graphics need a GL context.
+        mark.initializeEncoders();
+        if (canInitializeGraphics) {
+            graphicsPromises.push(mark.initializeGraphics().then(() => mark));
+        }
+
+        // Wire collector completion to mark data/graphics updates.
+        const observer = (
+            /** @type {import("./collector.js").default} */ _collector
+        ) => {
+            mark.initializeData(); // does faceting
+            if (canInitializeGraphics) {
+                try {
+                    mark.updateGraphicsData();
+                } catch (e) {
+                    e.view = view;
+                    throw e;
+                }
+            }
+            view.context.animator.requestRender();
+        };
+        view.registerDisposer(view.flowHandle.collector.observe(observer));
+    }
+
+    return {
+        dataFlow,
+        unitViews,
+        dataSources,
+        graphicsPromises,
+    };
+}
+
+/**
+ * Collects data sources needed to initialize all views in the subtree.
+ * This includes sources that are overridden deeper in the hierarchy.
+ *
+ * @param {import("../view/view.js").default | import("../view/view.js").default[]} subtreeRoot
+ * @returns {Set<import("./sources/dataSource.js").default>}
+ */
+export function collectViewSubtreeDataSources(subtreeRoot) {
+    const subtreeViews = Array.isArray(subtreeRoot)
+        ? subtreeRoot
+        : subtreeRoot.getDescendants();
+    /** @type {Set<import("./sources/dataSource.js").default>} */
+    const dataSources = new Set();
+    for (const view of subtreeViews) {
+        // Walk up to the nearest view that owns a data source.
+        let current = view;
+        while (current && !current.flowHandle?.dataSource) {
+            current = current.dataParent;
+        }
+        if (current?.flowHandle?.dataSource) {
+            dataSources.add(current.flowHandle.dataSource);
+        }
+    }
+    return dataSources;
+}
+
+/**
+ * Collects the nearest data sources under a subtree root.
+ * These sources define data-ready boundaries for subtree-level loading.
+ *
+ * @param {import("../view/view.js").default} subtreeRoot
+ * @returns {Set<import("./sources/dataSource.js").default>}
+ */
+export function collectNearestViewSubtreeDataSources(subtreeRoot) {
+    /** @type {Set<import("./sources/dataSource.js").default>} */
+    const dataSources = new Set();
+    subtreeRoot.visit((view) => {
+        if (view.flowHandle?.dataSource) {
+            dataSources.add(view.flowHandle.dataSource);
+            return VISIT_SKIP;
+        }
+    });
+    return dataSources;
+}
+
+/**
+ * Loads the nearest data sources for a subtree.
+ * Use the returned promise as a subtree-level "data ready" signal.
+ *
+ * @param {import("../view/view.js").default} subtreeRoot
+ * @param {Set<import("./sources/dataSource.js").default>} [dataSources]
+ * @returns {Promise<void[]>}
+ */
+export function loadViewSubtreeData(
+    subtreeRoot,
+    dataSources = collectNearestViewSubtreeDataSources(subtreeRoot)
+) {
+    return Promise.all(
+        Array.from(dataSources).map((dataSource) =>
+            loadDataSourceOnce(dataSource)
+        )
+    ).then((results) => {
+        reconfigureScaleDomains(subtreeRoot);
+        broadcastSubtreeDataReady(subtreeRoot);
+        return results;
+    });
+}
+
+/**
+ * Broadcasts a subtree-scoped data-ready event to views within the subtree.
+ *
+ * @param {import("../view/view.js").default} subtreeRoot
+ */
+function broadcastSubtreeDataReady(subtreeRoot) {
+    /** @type {import("../view/view.js").BroadcastMessage} */
+    const message = {
+        type: /** @type {import("../genomeSpy.js").BroadcastEventType} */ (
+            "subtreeDataReady"
+        ),
+        payload: { subtreeRoot },
+    };
+    subtreeRoot.visit((view) => view.handleBroadcast(message));
+}

package/dist/src/data/flowInit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flowInit.test.d.ts.map

package/dist/src/data/flowInit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowInit.test.d.ts","sourceRoot":"","sources":["../../../src/data/flowInit.test.js"],"names":[],"mappings":""}

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

@@ -12,16 +12,18 @@ export function removeRedundantCloneTransforms(node: import("./flowNode.js").def
 export function removeRedundantCollectors(): void;
 export function combineAndPullCollectorsUp(): void;
 /**
- * @param {import("./dataFlow.js").default<any>} dataFlow
+ * @param {import("./dataFlow.js").default} dataFlow
+ * @returns {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>}
  */
-export function combineIdenticalDataSources(dataFlow: import("./dataFlow.js").default<any>): void;
+export function combineIdenticalDataSources(dataFlow: import("./dataFlow.js").default): Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>;
 /**
  *
  * @param {import("./flowNode.js").default} root
  */
 export function optimizeFlowGraph(root: import("./flowNode.js").default): void;
 /**
- * @param {import("./dataFlow.js").default<any>} dataFlow
+ * @param {import("./dataFlow.js").default} dataFlow
+ * @returns {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>}
  */
-export function optimizeDataFlow(dataFlow: import("./dataFlow.js").default<any>): void;
+export function optimizeDataFlow(dataFlow: import("./dataFlow.js").default): Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>;
 //# sourceMappingURL=flowOptimizer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"flowOptimizer.d.ts","sourceRoot":"","sources":["../../../src/data/flowOptimizer.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,oCAHW,OAAO,eAAe,EAAE,OAAO,WAC/B,OAAO,eAAe,EAAE,OAAO,WAczC;AAED;;;;GAIG;AACH,qDAFW,OAAO,eAAe,EAAE,OAAO,iCAgCzC;AAED,kDAEC;AAED,mDAEC;AAmBD;;GAEG;AACH,sDAFW,OAAO,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,QAwB9C;AAED;;;GAGG;AACH,wCAFW,OAAO,eAAe,EAAE,OAAO,QASzC;AAED;;GAEG;AACH,2CAFW,OAAO,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,QAO9C"}
+{"version":3,"file":"flowOptimizer.d.ts","sourceRoot":"","sources":["../../../src/data/flowOptimizer.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,oCAHW,OAAO,eAAe,EAAE,OAAO,WAC/B,OAAO,eAAe,EAAE,OAAO,WAczC;AAED;;;;GAIG;AACH,qDAFW,OAAO,eAAe,EAAE,OAAO,iCAgCzC;AAED,kDAEC;AAED,mDAEC;AAmBD;;;GAGG;AACH,sDAHW,OAAO,eAAe,EAAE,OAAO,GAC7B,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAoCrG;AAED;;;GAGG;AACH,wCAFW,OAAO,eAAe,EAAE,OAAO,QASzC;AAED;;;GAGG;AACH,2CAHW,OAAO,eAAe,EAAE,OAAO,GAC7B,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAQrG"}

package/dist/src/data/flowOptimizer.js

@@ -82,30 +82,43 @@ export function combineAndPullCollectorsUp() {
 //      --F--G
 
 /**
- * @param {import("./dataFlow.js").default<any>} dataFlow
+ * @param {import("./dataFlow.js").default} dataFlow
+ * @returns {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>}
  */
 export function combineIdenticalDataSources(dataFlow) {
-    const dataSourceEntries = [...dataFlow._dataSourcesByHost.entries()];
+    const dataSources = dataFlow.dataSources;
 
     /** @type {Map<string, import("./sources/dataSource.js").default>} */
     const sourcesByIdentifiers = new Map();
-    for (const e of dataSourceEntries) {
-        const ds = e[1];
+    for (const ds of dataSources) {
         if (ds.identifier && !sourcesByIdentifiers.has(ds.identifier)) {
             sourcesByIdentifiers.set(ds.identifier, ds);
         }
     }
 
-    dataFlow._dataSourcesByHost.clear();
-
-    for (let [key, dataSource] of dataSourceEntries) {
-        const target = sourcesByIdentifiers.get(dataSource.identifier);
-        if (target) {
-            target.adoptChildrenOf(dataSource);
-            dataSource = target;
+    /** @type {Set<import("./sources/dataSource.js").default>} */
+    const mergedSources = new Set();
+    /** @type {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>} */
+    const canonicalBySource = new Map();
+
+    for (const dataSource of dataSources) {
+        if (dataSource.identifier) {
+            const target = sourcesByIdentifiers.get(dataSource.identifier);
+            if (target) {
+                if (target !== dataSource) {
+                    target.adoptChildrenOf(dataSource);
+                }
+                mergedSources.add(target);
+                canonicalBySource.set(dataSource, target);
+            }
+        } else {
+            mergedSources.add(dataSource);
+            canonicalBySource.set(dataSource, dataSource);
         }
-        dataFlow.addDataSource(dataSource, key);
     }
+
+    dataFlow.replaceDataSources(mergedSources);
+    return canonicalBySource;
 }
 
 /**
@@ -122,11 +135,13 @@ export function optimizeFlowGraph(root) {
 }
 
 /**
- * @param {import("./dataFlow.js").default<any>} dataFlow
+ * @param {import("./dataFlow.js").default} dataFlow
+ * @returns {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>}
  */
 export function optimizeDataFlow(dataFlow) {
-    combineIdenticalDataSources(dataFlow);
+    const canonicalBySource = combineIdenticalDataSources(dataFlow);
     for (const dataSource of dataFlow.dataSources) {
         optimizeFlowGraph(dataSource);
     }
+    return canonicalBySource;
 }

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

@@ -50,7 +50,7 @@ export default class AxisTickSource extends SingleAxisLazySource {
         // Note, although this function is async, it is not awaited. Data are updated
         // synchronously to ensure that the new ticks are available before the next frame is drawn.
 
-        const scale = this.scaleResolution.scale;
+        const scale = this.scaleResolution.getScale();
         const axisLength = this.scaleResolution.getAxisLength();
         const axisParams = this.params.axis;
 

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

@@ -43,7 +43,7 @@ export default class BamSource extends SingleAxisWindowedSource {
         this.initializedPromise = new Promise((resolve) => {
             Promise.all([
                 import("@gmod/bam"),
-                import("generic-filehandle"),
+                import("generic-filehandle2"),
             ]).then(([{ BamFile }, { RemoteFile }]) => {
                 const withBase = (/** @type {string} */ uri) =>
                     new RemoteFile(addBaseUrl(uri, this.view.getBaseUrl()));

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

@@ -63,7 +63,7 @@ export default class BigBedSource extends SingleAxisWindowedSource {
             Promise.all([
                 import("@gmod/bed"),
                 import("@gmod/bbi"),
-                import("generic-filehandle"),
+                import("generic-filehandle2"),
             ]).then(([bed, { BigBed }, { RemoteFile }]) => {
                 const BED = bed.default;
 

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

@@ -62,7 +62,7 @@ export default class BigWigSource extends SingleAxisWindowedSource {
         this.initializedPromise = new Promise((resolve, reject) => {
             Promise.all([
                 import("@gmod/bbi"),
-                import("generic-filehandle"),
+                import("generic-filehandle2"),
             ]).then(([{ BigWig }, { RemoteFile }]) => {
                 this.#bbi = new BigWig({
                     filehandle: new RemoteFile(

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

@@ -1,12 +1,8 @@
 /**
- * @extends {TabixSource<import("@gmod/gff").GFF3Feature>}
+ * @extends {TabixSource<import("gff-nostream").GFF3Feature>}
  */
-export default class Gff3Source extends TabixSource<import("@gmod/gff").GFF3Feature> {
+export default class Gff3Source extends TabixSource<import("gff-nostream").GFF3Feature> {
     constructor(params: import("../../../spec/data.js").TabixData, view: import("../../../view/view.js").default);
-    /**
-     * @param {string[]} lines
-     */
-    _parseFeatures(lines: string[]): any;
     #private;
 }
 import TabixSource from "./tabixSource.js";

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

@@ -1 +1 @@
-{"version":3,"file":"gff3Source.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/gff3Source.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;;IAeI;;OAEG;IACH,sBAFW,MAAM,EAAE,OAUlB;;CACJ;wBAhCuB,kBAAkB"}
+{"version":3,"file":"gff3Source.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/gff3Source.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;;;CAuBC;wBA5BuB,kBAAkB"}

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

@@ -1,10 +1,10 @@
 import TabixSource from "./tabixSource.js";
 
 /**
- * @extends {TabixSource<import("@gmod/gff").GFF3Feature>}
+ * @extends {TabixSource<import("gff-nostream").GFF3Feature>}
  */
 export default class Gff3Source extends TabixSource {
-    /** @type {import("@gmod/gff").default} */
+    /** @type {import("gff-nostream")} */
     #gff;
 
     get label() {
@@ -15,18 +15,14 @@ export default class Gff3Source extends TabixSource {
      * @param {string} header
      */
     async _handleHeader(header) {
-        this.#gff = (await import("@gmod/gff")).default;
+        this.#gff = await import("gff-nostream");
     }
 
     /**
      * @param {string[]} lines
      */
     _parseFeatures(lines) {
-        // Hmm. It's silly that we have to first collect individual lines and then join them.
-        // eslint-disable-next-line no-sync
-        const features = this.#gff?.parseStringSync(lines.join("\n"), {
-            parseSequences: false,
-        });
+        const features = this.#gff?.parseArraySync(lines);
 
         return features;
     }

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

@@ -1 +1 @@
-{"version":3,"file":"indexedFastaSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/indexedFastaSource.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,gBAAgB,QAChD,OAAO,uBAAuB,EAAE,OAAO,EA+CjD;IAjCG,yDAAgC;IAQhC,iCAwBE;IATM,iDAKE;CAiCjB;qCAhFoC,+BAA+B"}
+{"version":3,"file":"indexedFastaSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/indexedFastaSource.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,gBAAgB,QAChD,OAAO,uBAAuB,EAAE,OAAO,EAwCjD;IA1BG,yDAAgC;IAQhC,iCAiBE;IATM,iDAKE;CAwCjB;qCAhFoC,+BAA+B"}

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

@@ -28,16 +28,9 @@ export default class IndexedFastaSource extends SingleAxisWindowedSource {
 
         this.initializedPromise = new Promise((resolve) => {
             Promise.all([
-                import("buffer"),
                 import("@gmod/indexedfasta"),
-                import("generic-filehandle"),
-            ]).then(([{ Buffer }, { IndexedFasta }, { RemoteFile }]) => {
-                // Hack needed by @gmod/indexedfasta
-                // TODO: Submit a PR to @gmod/indexedfasta to make this unnecessary
-                if (typeof window !== "undefined") {
-                    window.Buffer ??= Buffer;
-                }
-
+                import("generic-filehandle2"),
+            ]).then(([{ IndexedFasta }, { RemoteFile }]) => {
                 const withBase = (/** @type {string} */ uri) =>
                     new RemoteFile(addBaseUrl(uri, this.view.getBaseUrl()));
 
@@ -68,15 +61,22 @@ export default class IndexedFastaSource extends SingleAxisWindowedSource {
                     .getSequence(d.chrom, d.startPos, d.endPos, {
                         signal,
                     })
-                    .then((sequence) => ({
-                        chrom: d.chrom,
-                        start: d.startPos,
-                        sequence,
-                    }))
+                    .then((sequence) => {
+                        if (sequence != undefined) {
+                            return {
+                                chrom: d.chrom,
+                                start: d.startPos,
+                                sequence,
+                            };
+                        } else {
+                            console.log(
+                                `No sequence found for interval ${d.chrom}:${d.startPos}-${d.endPos}`
+                            );
+                            return undefined;
+                        }
+                    })
         );
 
-        if (features) {
-            this.publishData([features]);
-        }
+        this.publishData([features.filter((f) => f !== undefined)]);
     }
 }

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

@@ -16,7 +16,7 @@ export default class SingleAxisLazySource extends DataSource {
     protected initializedPromise: Promise<void>;
     /** @type {import("../../../spec/channel.js").PrimaryPositionalChannel}  */
     channel: import("../../../spec/channel.js").PrimaryPositionalChannel;
-    scaleResolution: import("../../../view/scaleResolution.js").default;
+    scaleResolution: import("../../../scales/scaleResolution.js").default;
     /**
      * Convenience getter for genome.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"singleAxisLazySource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/singleAxisLazySource.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IAOI;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,WACvC,OAAO,0BAA0B,EAAE,wBAAwB,EA+CrE;IAvDD;;;OAGG;IACH,4CAAuC;IAmBnC,2EAA2E;IAC3E,SADW,OAAO,0BAA0B,EAAE,wBAAwB,CAChD;IAEtB,oEAA4D;IA+BhE;;;;OAIG;IACH,oEAEC;IAED;;;;;;OAMG;IACH,wBAJW,MAAM,EAAE,iBACR,OAAO,yBAAyB,EAAE,gBAAgB,EAAE,QAK9D;IAED;;;;;OAKG;IACH,gCAGC;IAQD;;;;;;;;OAQG;IACH,8BAHW,OAAO,mBAAmB,EAAE,KAAK,EAAE,EAAE,QAgB/C;CACJ;uBA9HsB,kBAAkB"}
+{"version":3,"file":"singleAxisLazySource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/singleAxisLazySource.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IAOI;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,WACvC,OAAO,0BAA0B,EAAE,wBAAwB,EA+CrE;IAvDD;;;OAGG;IACH,4CAAuC;IAmBnC,2EAA2E;IAC3E,SADW,OAAO,0BAA0B,EAAE,wBAAwB,CAChD;IAEtB,sEAA4D;IA+BhE;;;;OAIG;IACH,oEASC;IAED;;;;;;OAMG;IACH,wBAJW,MAAM,EAAE,iBACR,OAAO,yBAAyB,EAAE,gBAAgB,EAAE,QAK9D;IAED;;;;;OAKG;IACH,gCAGC;IAQD;;;;;;;;OAQG;IACH,8BAHW,OAAO,mBAAmB,EAAE,KAAK,EAAE,EAAE,QAgB/C;CACJ;uBArIsB,kBAAkB"}

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

@@ -1,6 +1,6 @@
 import UnitView from "../../../view/unitView.js";
 import DataSource from "../dataSource.js";
-import { reconfigureScales } from "../../../view/scaleResolution.js";
+import { reconfigureScaleDomains } from "../../../scales/scaleResolution.js";
 
 /**
  * Base class for data sources that listen a domain and propagate data lazily.
@@ -71,7 +71,14 @@ export default class SingleAxisLazySource extends DataSource {
      * @protected
      */
     get genome() {
-        return this.scaleResolution.getGenome();
+        const scale = this.scaleResolution.getScale();
+        if ("genome" in scale) {
+            const genome = scale.genome();
+            if (genome) {
+                return genome;
+            }
+        }
+        throw new Error("No genome has been defined!");
     }
 
     /**
@@ -123,6 +130,6 @@ export default class SingleAxisLazySource extends DataSource {
 
         this.complete();
 
-        reconfigureScales(this.view);
+        reconfigureScaleDomains(this.view);
     }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"singleAxisWindowedSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/singleAxisWindowedSource.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IAWI;;;OAGG;IACH,kBAHU;QAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,4BAA4B,EAAE,OAAO,CAAA;KAAC,CAGvE;IAEP;;;OAGG;IACH,0CAHW,OAAO,uBAAuB,EAAE,aAAa,QAqBvD;IAED;;;;OAIG;IACH,wBAFW,MAAM,EAAE,QAqBlB;IAcD;;;;;OAKG;IACH,iCAHW,MAAM,EAAE,iBAKlB;IApBD;;OAEG;IACH,mCAOC;IAYD;;;;;;;;;OASG;IACH,4BAHa,CAAC,YAHH,MAAM,EAAE,UACR,CAAC,eAAe,EAAE,OAAO,mCAAmC,EAAE,0BAA0B,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3H,OAAO,CAAC,CAAC,EAAE,CAAC,CAoCvB;IAED;;;;;;OAMG;IACH,yCALW,MAAM,EAAE,cACR,MAAM,YACN,CAAS,IAAQ,EAAR,MAAM,EAAE,KAAE,IAAI,QAyBjC;;CACJ;iCA3KgC,2BAA2B"}
+{"version":3,"file":"singleAxisWindowedSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/singleAxisWindowedSource.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IAWI;;;OAGG;IACH,kBAHU;QAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,4BAA4B,EAAE,OAAO,CAAA;KAAC,CAGvE;IAEP;;;OAGG;IACH,0CAHW,OAAO,uBAAuB,EAAE,aAAa,QAqBvD;IAED;;;;OAIG;IACH,wBAFW,MAAM,EAAE,QAqBlB;IAcD;;;;;OAKG;IACH,iCAHW,MAAM,EAAE,iBAKlB;IApBD;;OAEG;IACH,mCAOC;IAYD;;;;;;;;;OASG;IACH,4BAHa,CAAC,YAHH,MAAM,EAAE,UACR,CAAC,eAAe,EAAE,OAAO,mCAAmC,EAAE,0BAA0B,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3H,OAAO,CAAC,CAAC,EAAE,CAAC,CAwCvB;IAED;;;;;;OAMG;IACH,yCALW,MAAM,EAAE,cACR,MAAM,YACN,CAAS,IAAQ,EAAR,MAAM,EAAE,KAAE,IAAI,QAyBjC;;CACJ;iCA/KgC,2BAA2B"}

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

@@ -125,7 +125,11 @@ export default class SingleAxisWindowedSource extends SingleAxisLazySource {
 
         try {
             const resultByChrom = await Promise.all(
-                discreteChromosomeIntervals.map(async (d) => loader(d, signal))
+                discreteChromosomeIntervals.map(
+                    async (
+                        /** @type {import("@genome-spy/core/genome/genome.js").DiscreteChromosomeInterval} */ d
+                    ) => loader(d, signal)
+                )
             );
 
             if (!signal.aborted) {

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

@@ -37,7 +37,7 @@ export default class TabixSource extends SingleAxisWindowedSource {
         this.initializedPromise = new Promise((resolve) => {
             Promise.all([
                 import("@gmod/tabix"),
-                import("generic-filehandle"),
+                import("generic-filehandle2"),
             ]).then(async ([{ TabixIndexedFile }, { RemoteFile }]) => {
                 const withBase = (/** @type {string} */ uri) =>
                     new RemoteFile(addBaseUrl(uri, this.view.getBaseUrl()));

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

@@ -20,7 +20,7 @@ export default class FilterScoredLabelsTransform extends Transform {
     padding: number;
     /** @type {Map<any, ReservationMap>} */
     reservationMaps: Map<any, ReservationMap>;
-    resolution: import("../../view/scaleResolution.js").default;
+    resolution: import("../../scales/scaleResolution.js").default;
     schedule: () => void;
     _filterAndPropagate(): void;
     groups: Map<any, any>;

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

@@ -1 +1 @@
-{"version":3,"file":"filterScoredLabels.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/filterScoredLabels.js"],"names":[],"mappings":"AAOA;IAKI;;;;OAIG;IACH,oBAHW,OAAO,yBAAyB,EAAE,wBAAwB,QAC1D,OAAO,oBAAoB,EAAE,OAAO,EA6C9C;IAxCG,mEAAoB;IAEpB,oBAAoB;IACpB,OADW,GAAG,EAAE,CACD;IAEf,mBAAoC;IAMpC,sDAA8C;IAC9C,oDAAgE;IAChE,wDAAuD;IACvD,sDAAmD;IACnD,mDAA6C;IAC7C,mDAA6C;IAC7C,gCAAgC;IAChC,cADW,CAAS,IAAG,EAAH,GAAG,KAAE,GAAG,CAGd;IACd,gBAAuC;IAEvC,uCAAuC;IACvC,iBADW,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CACH;IAEhC,4DAAuD;IAIvD,qBAAuE;IAyB3E,4BAsEC;IAKG,sBAAuB;CAU9B;sBA3JqB,gBAAgB;2BAFX,+BAA+B"}
+{"version":3,"file":"filterScoredLabels.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/filterScoredLabels.js"],"names":[],"mappings":"AAOA;IAKI;;;;OAIG;IACH,oBAHW,OAAO,yBAAyB,EAAE,wBAAwB,QAC1D,OAAO,oBAAoB,EAAE,OAAO,EA6C9C;IAxCG,mEAAoB;IAEpB,oBAAoB;IACpB,OADW,GAAG,EAAE,CACD;IAEf,mBAAoC;IAMpC,sDAA8C;IAC9C,oDAAgE;IAChE,wDAAuD;IACvD,sDAAmD;IACnD,mDAA6C;IAC7C,mDAA6C;IAC7C,gCAAgC;IAChC,cADW,CAAS,IAAG,EAAH,GAAG,KAAE,GAAG,CAGd;IACd,gBAAuC;IAEvC,uCAAuC;IACvC,iBADW,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CACH;IAEhC,8DAAuD;IAIvD,qBAAuE;IAyB3E,4BAsEC;IAKG,sBAAuB;CAU9B;sBA3JqB,gBAAgB;2BAFX,+BAA+B"}

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

@@ -76,7 +76,7 @@ export default class FilterScoredLabelsTransform extends Transform {
     _filterAndPropagate() {
         super.reset();
 
-        const scale = this.resolution.scale;
+        const scale = this.resolution.getScale();
         const rangeSpan = this.resolution.getAxisLength();
         if (!rangeSpan) {
             // The view size is not (yet) available

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

@@ -1 +1 @@
-{"version":3,"file":"linearizeGenomicCoordinate.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/linearizeGenomicCoordinate.js"],"names":[],"mappings":"AAKA;IAKI;;;;OAIG;IACH,oBAHW,OAAO,yBAAyB,EAAE,gCAAgC,QAClE,OAAO,oBAAoB,EAAE,OAAO,EAgG9C;IAvFG,2EAAoB;CAwF3B;sBA3GqB,gBAAgB"}
+{"version":3,"file":"linearizeGenomicCoordinate.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/linearizeGenomicCoordinate.js"],"names":[],"mappings":"AAKA;IAKI;;;;OAIG;IACH,oBAHW,OAAO,yBAAyB,EAAE,gCAAgC,QAClE,OAAO,oBAAoB,EAAE,OAAO,EAiG9C;IAxFG,2EAAoB;CAyF3B;sBA5GqB,gBAAgB"}

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

@@ -28,7 +28,8 @@ export default class LinearizeGenomicCoordinate extends Transform {
             throw new Error("Invalid channel: " + channel);
         }
 
-        const genome = view.getScaleResolution(channel).getGenome();
+        const scale = view.getScaleResolution(channel).getScale();
+        const genome = "genome" in scale ? scale.genome() : undefined;
         if (!genome) {
             throw new Error(
                 "LinearizeGenomicCoordinate transform requires a locus scale!"

package/dist/src/encoder/encoder.d.ts

@@ -109,7 +109,7 @@ export function getPrimaryChannel(channel: import("../spec/channel.js").Channel)
  *
  * @param {import("../spec/channel.js").Channel} channel
  */
-export function getChannelWithSecondarys(channel: import("../spec/channel.js").Channel): ("search" | "fill" | "stroke" | "angle" | "sample" | "color" | "fillOpacity" | "opacity" | "strokeOpacity" | "strokeWidth" | "x" | "y" | "text" | "size" | "x2" | "y2" | "shape" | "dx" | "dy" | "uniqueId" | "facetIndex" | "semanticScore")[];
+export function getChannelWithSecondarys(channel: import("../spec/channel.js").Channel): import("../spec/channel.js").Channel[];
 /**
  * @param {import("../spec/channel.js").Channel} channel
  */