@genome-spy/core 0.63.0 → 0.65.0

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

@@ -0,0 +1,413 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { createTestViewContext } from "../view/testUtils.js";
+import { buildDataFlow } from "../view/flowBuilder.js";
+import { optimizeDataFlow } from "./flowOptimizer.js";
+import {
+    collectNearestViewSubtreeDataSources,
+    collectViewSubtreeDataSources,
+    initializeViewSubtree,
+    loadViewSubtreeData,
+    syncFlowHandles,
+} from "./flowInit.js";
+
+describe("flowInit", () => {
+    test("syncs handles to canonical data sources after merge", async () => {
+        const context = createTestViewContext();
+        context.getNamedDataFromProvider = () => [];
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").HConcatSpec} */
+        const spec = {
+            hconcat: [
+                {
+                    data: { name: "shared" },
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+                {
+                    data: { name: "shared" },
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+            ],
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+
+        const flow = buildDataFlow(root, context.dataFlow);
+        const canonicalBySource = optimizeDataFlow(flow);
+        syncFlowHandles(root, canonicalBySource);
+
+        const concatRoot =
+            /** @type {import("../view/concatView.js").default} */ (root);
+        const left = concatRoot.children[0];
+        const right = concatRoot.children[1];
+
+        expect(left.flowHandle.dataSource).toBeDefined();
+        expect(right.flowHandle.dataSource).toBeDefined();
+        expect(left.flowHandle.dataSource).toBe(right.flowHandle.dataSource);
+
+        const sharedSources = flow.dataSources.filter(
+            (/** @type {import("./sources/dataSource.js").default} */ source) =>
+                source.identifier === "shared"
+        );
+        expect(sharedSources).toEqual([left.flowHandle.dataSource]);
+    });
+
+    test("initializeViewSubtree wires collector updates for subtree loads", async () => {
+        const context = createTestViewContext();
+        context.getNamedDataFromProvider = () => [];
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").UnitSpec} */
+        const spec = {
+            data: { values: [{ x: 1 }, { x: 2 }] },
+            mark: "point",
+            encoding: {
+                x: { field: "x", type: "quantitative" },
+            },
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        const { dataSources } = initializeViewSubtree(root, context.dataFlow);
+
+        // This guards subtree-only initialization: dynamic view rebuilds should still
+        // trigger mark updates when their local collectors complete.
+        const unitView = /** @type {import("../view/unitView.js").default} */ (
+            root
+        );
+        const initializeSpy = vi.spyOn(unitView.mark, "initializeData");
+
+        await Promise.all(
+            Array.from(dataSources).map((dataSource) => dataSource.load())
+        );
+
+        expect(initializeSpy).toHaveBeenCalledTimes(1);
+        initializeSpy.mockRestore();
+    });
+
+    test("disposeSubtree removes observers before rebuilding subtree", async () => {
+        const context = createTestViewContext();
+        context.getNamedDataFromProvider = () => [{ x: 1 }];
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").UnitSpec} */
+        const spec = {
+            data: { name: "shared" },
+            mark: "point",
+            encoding: {
+                x: { field: "x", type: "quantitative" },
+            },
+        };
+
+        const firstRoot = await context.createOrImportView(
+            spec,
+            null,
+            null,
+            "first"
+        );
+        const { dataSources: firstSources } = initializeViewSubtree(
+            firstRoot,
+            context.dataFlow
+        );
+
+        const firstUnit = /** @type {import("../view/unitView.js").default} */ (
+            firstRoot
+        );
+        const firstCollector = firstUnit.flowHandle.collector;
+        const firstInitializeSpy = vi.spyOn(firstUnit.mark, "initializeData");
+
+        await Promise.all(
+            Array.from(firstSources).map((dataSource) => dataSource.load())
+        );
+
+        expect(firstInitializeSpy).toHaveBeenCalledTimes(1);
+        firstInitializeSpy.mockRestore();
+
+        firstRoot.disposeSubtree();
+
+        // This prevents stale observers from firing after a subtree is rebuilt.
+        expect(firstCollector.observers.size).toBe(0);
+
+        const secondRoot = await context.createOrImportView(
+            spec,
+            null,
+            null,
+            "second"
+        );
+        const { dataSources: secondSources } = initializeViewSubtree(
+            secondRoot,
+            context.dataFlow
+        );
+
+        const secondUnit =
+            /** @type {import("../view/unitView.js").default} */ (secondRoot);
+        const secondInitializeSpy = vi.spyOn(secondUnit.mark, "initializeData");
+
+        await Promise.all(
+            Array.from(secondSources).map((dataSource) => dataSource.load())
+        );
+
+        expect(secondInitializeSpy).toHaveBeenCalledTimes(1);
+        secondInitializeSpy.mockRestore();
+    });
+
+    test("disposeSubtree prunes named source branches", async () => {
+        const context = createTestViewContext();
+        context.getNamedDataFromProvider = () => [{ x: 1 }];
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").UnitSpec} */
+        const spec = {
+            data: { name: "shared" },
+            mark: "point",
+            encoding: {
+                x: { field: "x", type: "quantitative" },
+            },
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        initializeViewSubtree(root, context.dataFlow);
+
+        const unitView = /** @type {import("../view/unitView.js").default} */ (
+            root
+        );
+        const dataSource = unitView.flowHandle.dataSource;
+
+        // This guards against stale flow branches when a subtree is disposed.
+        expect(context.dataFlow.dataSources).toContain(dataSource);
+        expect(dataSource.children.length).toBeGreaterThan(0);
+
+        root.disposeSubtree();
+
+        expect(dataSource.children.length).toBe(0);
+        expect(context.dataFlow.dataSources).not.toContain(dataSource);
+    });
+
+    test("collectNearestViewSubtreeDataSources stops at nested sources", async () => {
+        const context = createTestViewContext();
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").LayerSpec} */
+        const spec = {
+            data: { values: [{ x: 0 }] },
+            layer: [
+                {
+                    data: { values: [{ x: 1 }] },
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+                {
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+            ],
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        initializeViewSubtree(root, context.dataFlow);
+
+        // Nearest-source semantics: a top-level source hides deeper sources.
+        const sources = collectNearestViewSubtreeDataSources(root);
+        expect(sources.size).toBe(1);
+
+        const [rootSource] = Array.from(sources);
+        const layerRoot =
+            /** @type {import("../view/layerView.js").default} */ (root);
+        const childWithSource = layerRoot.children[0];
+
+        expect(rootSource).toBe(layerRoot.flowHandle.dataSource);
+        expect(childWithSource.flowHandle.dataSource).not.toBe(rootSource);
+    });
+
+    test("loadViewSubtreeData only loads nearest sources", async () => {
+        const context = createTestViewContext();
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").LayerSpec} */
+        const spec = {
+            data: { values: [{ x: 0 }] },
+            layer: [
+                {
+                    data: { values: [{ x: 1 }] },
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+            ],
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        initializeViewSubtree(root, context.dataFlow);
+
+        const layerRoot =
+            /** @type {import("../view/layerView.js").default} */ (root);
+        const rootSource = layerRoot.flowHandle.dataSource;
+        const childSource = layerRoot.children[0].flowHandle.dataSource;
+
+        const rootLoadSpy = vi.spyOn(rootSource, "load");
+        const childLoadSpy = vi.spyOn(childSource, "load");
+
+        // Data-ready should ignore nested sources.
+        await loadViewSubtreeData(root);
+
+        expect(rootLoadSpy).toHaveBeenCalledTimes(1);
+        expect(childLoadSpy).toHaveBeenCalledTimes(0);
+
+        rootLoadSpy.mockRestore();
+        childLoadSpy.mockRestore();
+    });
+
+    test("collectViewSubtreeDataSources includes nested sources", async () => {
+        const context = createTestViewContext();
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").LayerSpec} */
+        const spec = {
+            data: { values: [{ x: 0 }] },
+            layer: [
+                {
+                    data: { values: [{ x: 1 }] },
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+            ],
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        initializeViewSubtree(root, context.dataFlow);
+
+        // Initialization needs the full set of sources, including nested ones.
+        const sources = collectViewSubtreeDataSources(root);
+        expect(sources.size).toBe(2);
+    });
+
+    test("collectNearestViewSubtreeDataSources returns child sources when root has none", async () => {
+        const context = createTestViewContext();
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").HConcatSpec} */
+        const spec = {
+            hconcat: [
+                {
+                    data: { values: [{ x: 1 }] },
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+                {
+                    data: { values: [{ x: 2 }] },
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+            ],
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        initializeViewSubtree(root, context.dataFlow);
+
+        // Without a root source, the nearest sources include the child sources.
+        // Layout decorations may add additional sources.
+        const sources = collectNearestViewSubtreeDataSources(root);
+        const concatRoot =
+            /** @type {import("../view/concatView.js").default} */ (root);
+        expect(sources.has(concatRoot.children[0].flowHandle.dataSource)).toBe(
+            true
+        );
+        expect(sources.has(concatRoot.children[1].flowHandle.dataSource)).toBe(
+            true
+        );
+    });
+
+    test("loadViewSubtreeData emits subtree data ready broadcast", async () => {
+        const context = createTestViewContext();
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").UnitSpec} */
+        const spec = {
+            data: { values: [{ x: 1 }] },
+            mark: "point",
+            encoding: {
+                x: { field: "x", type: "quantitative" },
+            },
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        initializeViewSubtree(root, context.dataFlow);
+
+        let calls = 0;
+        root._addBroadcastHandler("subtreeDataReady", (message) => {
+            calls += 1;
+            expect(message.payload.subtreeRoot).toBe(root);
+        });
+
+        await loadViewSubtreeData(root);
+
+        expect(calls).toBe(1);
+    });
+
+    test("loadViewSubtreeData deduplicates concurrent loads", async () => {
+        const context = createTestViewContext();
+        context.getNamedDataFromProvider = () => [{ x: 1 }];
+        context.addBroadcastListener = () => undefined;
+        context.removeBroadcastListener = () => undefined;
+
+        /** @type {import("../spec/view.js").HConcatSpec} */
+        const spec = {
+            data: { name: "shared" },
+            hconcat: [
+                {
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+                {
+                    mark: "point",
+                    encoding: {
+                        x: { field: "x", type: "quantitative" },
+                    },
+                },
+            ],
+        };
+
+        const root = await context.createOrImportView(spec, null, null, "root");
+        initializeViewSubtree(root, context.dataFlow);
+
+        const dataSource = root.flowHandle.dataSource;
+        const loadSpy = vi.spyOn(dataSource, "load");
+
+        // Prevent duplicate fetches when concurrent subtrees share a source.
+        await Promise.all([
+            loadViewSubtreeData(root, new Set([dataSource])),
+            loadViewSubtreeData(root, new Set([dataSource])),
+        ]);
+
+        expect(loadSpy).toHaveBeenCalledTimes(1);
+        loadSpy.mockRestore();
+    });
+});

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/flowOptimizer.test.js

@@ -142,7 +142,7 @@ const viewStub = /** @type {any} */ (
 
 describe("Merge indentical data sources", () => {
     test("Merges correctly", () => {
-        /** @type {DataFlow<string>} */
+        /** @type {DataFlow} */
         const dataFlow = new DataFlow();
 
         const a = new UrlSource({ url: "http://genomespy.app/" }, viewStub);
@@ -157,21 +157,25 @@ describe("Merge indentical data sources", () => {
         const cc = new Collector();
         c.addChild(cc);
 
-        dataFlow.addDataSource(a, "a");
-        dataFlow.addDataSource(b, "b");
-        dataFlow.addDataSource(c, "c");
+        dataFlow.addDataSource(a);
+        dataFlow.addDataSource(b);
+        dataFlow.addDataSource(c);
 
-        dataFlow.addCollector(ac, "a");
-        dataFlow.addCollector(bc, "b");
-        dataFlow.addCollector(cc, "c");
+        dataFlow.addCollector(ac);
+        dataFlow.addCollector(bc);
+        dataFlow.addCollector(cc);
 
         combineIdenticalDataSources(dataFlow);
 
         expect(dataFlow.dataSources.length).toEqual(2);
 
-        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
-        expect(dataFlow.findDataSourceByKey("b")).toBe(a); // Merged!
-        expect(dataFlow.findDataSourceByKey("c")).toBe(c);
+        const entries = dataFlow.dataSources;
+        const sharedIdentifier = a.identifier;
+        expect(entries).toContain(a);
+        expect(entries).toContain(c);
+        expect(
+            entries.filter((source) => source.identifier == sharedIdentifier)
+        ).toEqual([a]);
 
         expect(new Set(a.children)).toEqual(new Set([ac, bc]));
         expect(c.children[0]).toBe(cc);
@@ -187,18 +191,19 @@ describe("Merge indentical data sources", () => {
     });
 
     test("Does not merge those with undefined identifier", () => {
-        /** @type {DataFlow<string>} */
+        /** @type {DataFlow} */
         const dataFlow = new DataFlow();
 
         const a = new InlineSource({ values: [1, 2, 3] }, viewStub);
         const b = new InlineSource({ values: [1, 2, 3] }, viewStub);
 
-        dataFlow.addDataSource(a, "a");
-        dataFlow.addDataSource(b, "b");
+        dataFlow.addDataSource(a);
+        dataFlow.addDataSource(b);
 
         combineIdenticalDataSources(dataFlow);
 
-        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
-        expect(dataFlow.findDataSourceByKey("b")).toBe(b);
+        const entries = dataFlow.dataSources;
+        expect(entries).toContain(a);
+        expect(entries).toContain(b);
     });
 });

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"}