@genome-spy/core 0.78.0 → 0.79.1

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

@@ -0,0 +1,388 @@
+import { shallowArrayEquals } from "../../../utils/arrayUtils.js";
+import createScale from "../../../scale/scale.js";
+import { tickCount, tickFormat, tickValues } from "../../../scale/ticks.js";
+import { findLegendScaleResolution } from "./legendEntriesSource.js";
+import DataSource from "../dataSource.js";
+import { registerBuiltInLazyDataSource } from "./lazyDataSourceRegistry.js";
+
+const DEFAULT_SAMPLE_COUNT = 64;
+const DEFAULT_TICK_COUNT = 5;
+
+/**
+ * @typedef {((value: number) => number) & { invert: (position: number) => number }} NormalizedPositionScale
+ * @typedef {import("../../../spec/data.js").LegendGradientData | import("../../../spec/data.js").LegendGradientTicksData} LegendGradientSourceData
+ * @typedef {import("../../../types/encoder.js").VegaScale & {
+ *     range: () => unknown[],
+ *     invertExtent: (value: unknown) => [unknown, unknown],
+ *     thresholds: () => unknown[]
+ * }} QuantizeScale
+ */
+
+/**
+ * @param {import("../../../types/encoder.js").VegaScale} scale
+ * @param {number} start
+ * @param {number} stop
+ * @returns {NormalizedPositionScale}
+ */
+function createNormalizedScale(scale, start, stop) {
+    const domain = getNumericScaleDomain(scale, start, stop);
+    const range = createNormalizedRange(domain.length);
+
+    if (
+        "copy" in scale &&
+        typeof scale.copy == "function" &&
+        "invert" in scale &&
+        typeof scale.invert == "function"
+    ) {
+        const normalizedScale = scale.copy();
+        normalizedScale.domain(domain);
+        normalizedScale.range(range);
+        return /** @type {NormalizedPositionScale} */ (normalizedScale);
+    }
+
+    const props =
+        /** @type {{ props?: import("../../../spec/scale.js").Scale }} */ (
+            scale
+        ).props;
+    const type = props?.type;
+
+    if (type) {
+        const positionProps = { ...props };
+        const extraPositionProps = /** @type {Record<string, unknown>} */ (
+            positionProps
+        );
+        delete positionProps.range;
+        delete positionProps.scheme;
+        delete extraPositionProps.domainMin;
+        delete extraPositionProps.domainMid;
+        delete extraPositionProps.domainMax;
+        delete extraPositionProps.schemeExtent;
+        delete extraPositionProps.schemeCount;
+        const positionScale = createScale({
+            ...positionProps,
+            type,
+            domain,
+            range,
+            zero: false,
+            nice: false,
+        });
+        if (
+            "invert" in positionScale &&
+            typeof positionScale.invert == "function"
+        ) {
+            return /** @type {NormalizedPositionScale} */ (positionScale);
+        }
+    }
+
+    return createLinearPositionScale(start, stop);
+}
+
+/**
+ * @param {import("../../../types/encoder.js").VegaScale} scale
+ * @param {number} start
+ * @param {number} stop
+ * @returns {number[]}
+ */
+function getNumericScaleDomain(scale, start, stop) {
+    if ("domain" in scale && typeof scale.domain == "function") {
+        const domain = scale.domain().map(finiteNumber);
+        if (domain.length >= 2) {
+            return [start, ...domain.slice(1, -1), stop];
+        }
+    }
+
+    return [start, stop];
+}
+
+/**
+ * @param {number} length
+ * @returns {number[]}
+ */
+function createNormalizedRange(length) {
+    const last = length - 1;
+    return Array.from({ length }, (_, index) => index / last);
+}
+
+/**
+ * @param {number} start
+ * @param {number} stop
+ * @returns {(position: number) => number}
+ */
+function createLinearPositionInverter(start, stop) {
+    return (position) => start + (stop - start) * position;
+}
+
+/**
+ * @param {number} start
+ * @param {number} stop
+ * @returns {NormalizedPositionScale}
+ */
+function createLinearPositionScale(start, stop) {
+    const scale = /** @type {NormalizedPositionScale} */ (
+        (/** @type {number} */ value) => (value - start) / (stop - start)
+    );
+    scale.invert = createLinearPositionInverter(start, stop);
+    return scale;
+}
+
+/**
+ * @param {number[]} domain
+ * @returns {[number, number]}
+ */
+function extendThresholdDomain(domain) {
+    const start = domain[0];
+    const stop = domain.at(-1);
+    const span = stop - start;
+    const count = domain.length - 1;
+    const adjust = count ? span / count : 0.1;
+
+    return [start - adjust, stop + adjust];
+}
+
+/**
+ * @param {import("../../../types/encoder.js").VegaScale} scale
+ * @returns {scale is QuantizeScale}
+ */
+function isQuantizeScale(scale) {
+    return (
+        scale.type == "quantize" &&
+        "range" in scale &&
+        typeof scale.range == "function" &&
+        "invertExtent" in scale &&
+        typeof scale.invertExtent == "function" &&
+        "thresholds" in scale &&
+        typeof scale.thresholds == "function"
+    );
+}
+
+/**
+ * @param {unknown} value
+ */
+function finiteNumber(value) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) {
+        throw new Error("Gradient legend boundaries must be finite numbers.");
+    }
+
+    return number;
+}
+
+class LegendGradientBaseSource extends DataSource {
+    /** @type {import("../../../spec/channel.js").Scalar[] | undefined} */
+    #domain = undefined;
+
+    /**
+     * @param {LegendGradientSourceData} params
+     * @param {import("../../../view/view.js").default} view
+     */
+    constructor(params, view) {
+        super(view);
+
+        this.params = params;
+        this.scaleResolution = findLegendScaleResolution(view, params.channel);
+        if (!this.scaleResolution) {
+            throw new Error(
+                `The gradient legend data source cannot find a resolved scale for channel "${params.channel}".`
+            );
+        }
+
+        const publish = () => this.#publishData();
+        this.scaleResolution.addEventListener("domain", publish);
+        this.view.registerDisposer(() =>
+            this.scaleResolution.removeEventListener("domain", publish)
+        );
+    }
+
+    async load() {
+        this.#domain = undefined;
+        this.#publishData();
+    }
+
+    #publishData() {
+        const domain = this.scaleResolution.getDomain();
+
+        if (!this.#domain || !shallowArrayEquals(domain, this.#domain)) {
+            const start = Number(domain[0]);
+            const stop = Number(domain.at(-1));
+            if (!Number.isFinite(start) || !Number.isFinite(stop)) {
+                throw new Error(
+                    "Gradient legends require a finite numeric scale domain."
+                );
+            }
+
+            this.#domain = domain.slice();
+            this.reset();
+            this.beginBatch({ type: "file" });
+            this.publishData(start, stop);
+            this.complete();
+        }
+    }
+
+    /**
+     * @param {number} start
+     * @param {number} stop
+     */
+    publishData(start, stop) {
+        throw new Error(
+            "Gradient legend data source must implement publishData."
+        );
+    }
+}
+
+export default class LegendGradientSource extends LegendGradientBaseSource {
+    get label() {
+        return "legendGradientSource";
+    }
+
+    /**
+     * @param {number} start
+     * @param {number} stop
+     */
+    publishData(start, stop) {
+        const scale = this.scaleResolution.getScale();
+        if (scale.type == "threshold") {
+            this.#publishThresholdGradient();
+            return;
+        } else if (isQuantizeScale(scale)) {
+            this.#publishQuantizeGradient(start, stop, scale);
+            return;
+        }
+
+        const count = this.params.count ?? DEFAULT_SAMPLE_COUNT;
+        const positionScale = createNormalizedScale(scale, start, stop);
+        const invertPosition = (/** @type {number} */ position) =>
+            positionScale.invert(position);
+
+        for (let index = 0; index < count; index++) {
+            const position0 = index / count;
+            const position1 = (index + 1) / count;
+            const position = (index + 0.5) / count;
+            this._propagate({
+                position0,
+                position1,
+                position,
+                value: invertPosition(position),
+                _legendGradientIndex: index,
+            });
+        }
+    }
+
+    /**
+     * @param {number} start
+     * @param {number} stop
+     * @param {QuantizeScale} scale
+     */
+    #publishQuantizeGradient(start, stop, scale) {
+        const positionScale = createLinearPositionScale(start, stop);
+
+        for (const [index, rangeValue] of scale.range().entries()) {
+            const [extentStart, extentStop] = scale
+                .invertExtent(rangeValue)
+                .map(finiteNumber);
+            const value = (extentStart + extentStop) / 2;
+
+            this._propagate({
+                position0: positionScale(extentStart),
+                position1: positionScale(extentStop),
+                position: positionScale(value),
+                value,
+                _legendGradientIndex: index,
+            });
+        }
+    }
+
+    #publishThresholdGradient() {
+        const domain = this.scaleResolution.getDomain().map(Number);
+        const [start, stop] = extendThresholdDomain(domain);
+        const positionScale = createLinearPositionScale(start, stop);
+        const extendedDomain = [start, ...domain, stop];
+
+        for (let index = 0; index < extendedDomain.length - 1; index++) {
+            const value0 = extendedDomain[index];
+            const value1 = extendedDomain[index + 1];
+            const value = (value0 + value1) / 2;
+            this._propagate({
+                position0: positionScale(value0),
+                position1: positionScale(value1),
+                position: positionScale(value),
+                value,
+                _legendGradientIndex: index,
+            });
+        }
+    }
+}
+
+class LegendGradientTicksSource extends LegendGradientBaseSource {
+    get label() {
+        return "legendGradientTicksSource";
+    }
+
+    /**
+     * @param {number} start
+     * @param {number} stop
+     */
+    publishData(start, stop) {
+        const scale = this.scaleResolution.getScale();
+        const positionExtent =
+            scale.type == "threshold"
+                ? extendThresholdDomain(
+                      this.scaleResolution.getDomain().map(Number)
+                  )
+                : [start, stop];
+        const positionScale = createNormalizedScale(
+            scale,
+            positionExtent[0],
+            positionExtent[1]
+        );
+        const requestedCount = this.params.count ?? DEFAULT_TICK_COUNT;
+        const count = tickCount(scale, requestedCount, undefined);
+        const format = tickFormat(scale, requestedCount, this.params.format);
+        const values = this.params.values
+            ? this.params.values.map(finiteNumber).filter((value) => {
+                  const position = positionScale(value);
+                  return (
+                      Number.isFinite(position) &&
+                      position >= 0 &&
+                      position <= 1
+                  );
+              })
+            : isQuantizeScale(scale)
+              ? scale.thresholds().map(finiteNumber)
+              : tickValues(scale, count).map(finiteNumber);
+
+        for (const value of values) {
+            const label = format(value);
+            if (!label) {
+                continue;
+            }
+
+            this._propagate({
+                value,
+                position: positionScale(value),
+                label,
+            });
+        }
+    }
+}
+
+/**
+ * @param {import("../../../spec/data.js").LazyDataParams} params
+ * @returns {params is import("../../../spec/data.js").LegendGradientData}
+ */
+function isLegendGradientSource(params) {
+    return params?.type == "legendGradient";
+}
+
+/**
+ * @param {import("../../../spec/data.js").LazyDataParams} params
+ * @returns {params is import("../../../spec/data.js").LegendGradientTicksData}
+ */
+function isLegendGradientTicksSource(params) {
+    return params?.type == "legendGradientTicks";
+}
+
+registerBuiltInLazyDataSource(isLegendGradientSource, LegendGradientSource);
+registerBuiltInLazyDataSource(
+    isLegendGradientTicksSource,
+    LegendGradientTicksSource
+);

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

@@ -4,18 +4,20 @@
  */
 export default class MockLazySource extends SingleAxisLazySource {
     /**
-     * @param {{ channel?: import("../../../spec/channel.js").PrimaryPositionalChannel, delay?: number, data?: import("../../flowNode.js").Datum[] }} params
+     * @param {{ channel?: import("../../../spec/channel.js").PrimaryPositionalChannel, delay?: number, data?: import("../../flowNode.js").Datum[], url?: any }} params
      * @param {import("../../../view/view.js").default} view
      */
     constructor(params: {
         channel?: import("../../../spec/channel.js").PrimaryPositionalChannel;
         delay?: number;
         data?: import("../../flowNode.js").Datum[];
+        url?: any;
     }, view: import("../../../view/view.js").default);
     params: {
         channel?: import("../../../spec/channel.js").PrimaryPositionalChannel;
         delay?: number;
         data?: import("../../flowNode.js").Datum[];
+        url?: any;
     };
     delay: number;
     /** @type {ReturnType<typeof setTimeout> | undefined} */
@@ -24,6 +26,7 @@ export default class MockLazySource extends SingleAxisLazySource {
      * @override
      */
     override onDomainChanged(): void;
+    #private;
 }
 import SingleAxisLazySource from "./singleAxisLazySource.js";
 //# sourceMappingURL=mockLazySource.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mockLazySource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/mockLazySource.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACI;;;OAGG;IACH,oBAHW;QAAE,OAAO,CAAC,EAAE,OAAO,0BAA0B,EAAE,wBAAwB,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,mBAAmB,EAAE,KAAK,EAAE,CAAA;KAAE,QACrI,OAAO,uBAAuB,EAAE,OAAO,EAgBjD;IAXG;kBANmB,OAAO,0BAA0B,EAAE,wBAAwB;gBAAU,MAAM;eAAS,OAAO,mBAAmB,EAAE,KAAK,EAAE;MAMtH;IACpB,cAA8B;IAC9B,wDAAwD;IACxD,cADW,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS,CACvB;IAUjC;;OAEG;IACH,iCAYC;CACJ;iCA3CgC,2BAA2B"}
+{"version":3,"file":"mockLazySource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/mockLazySource.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACI;;;OAGG;IACH,oBAHW;QAAE,OAAO,CAAC,EAAE,OAAO,0BAA0B,EAAE,wBAAwB,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,mBAAmB,EAAE,KAAK,EAAE,CAAC;QAAC,GAAG,CAAC,EAAE,GAAG,CAAA;KAAE,QAChJ,OAAO,uBAAuB,EAAE,OAAO,EA4BjD;IAvBG;kBANmB,OAAO,0BAA0B,EAAE,wBAAwB;gBAAU,MAAM;eAAS,OAAO,mBAAmB,EAAE,KAAK,EAAE;cAAQ,GAAG;MAMjI;IACpB,cAA8B;IAC9B,wDAAwD;IACxD,cADW,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS,CACvB;IAsBjC;;OAEG;IACH,iCAoBC;;CAqBJ;iCAxFgC,2BAA2B"}

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

@@ -1,4 +1,9 @@
 import SingleAxisLazySource from "./singleAxisLazySource.js";
+import {
+    createDescriptorFieldAttacher,
+    normalizeUrlDescriptors,
+    watchUrlDescriptorExpressions,
+} from "../urlDescriptor.js";
 
 /**
  * Testing-only lazy data source that delays data publishing.
@@ -6,7 +11,7 @@ import SingleAxisLazySource from "./singleAxisLazySource.js";
  */
 export default class MockLazySource extends SingleAxisLazySource {
     /**
-     * @param {{ channel?: import("../../../spec/channel.js").PrimaryPositionalChannel, delay?: number, data?: import("../../flowNode.js").Datum[] }} params
+     * @param {{ channel?: import("../../../spec/channel.js").PrimaryPositionalChannel, delay?: number, data?: import("../../flowNode.js").Datum[], url?: any }} params
      * @param {import("../../../view/view.js").default} view
      */
     constructor(params, view) {
@@ -23,6 +28,18 @@ export default class MockLazySource extends SingleAxisLazySource {
                 this.pendingTimer = undefined;
             }
         });
+
+        if (params.url && typeof params.url == "object") {
+            watchUrlDescriptorExpressions({
+                url: params.url,
+                paramRuntime: view.paramRuntime,
+                listener: () => {
+                    this._lastLoadedDomain = undefined;
+                    this.onDomainChanged();
+                },
+                registerDisposer: (disposer) => this.registerDisposer(disposer),
+            });
+        }
     }
 
     /**
@@ -34,11 +51,39 @@ export default class MockLazySource extends SingleAxisLazySource {
             this.pendingTimer = undefined;
         }
 
-        const data = this.params.data ?? [];
+        this.setLoadingStatus("loading");
         this.pendingTimer = setTimeout(() => {
             this.pendingTimer = undefined;
-            this.publishData([data]);
-            this.requestRender();
+            this.#resolveData()
+                .then((data) => {
+                    this.publishData([data]);
+                    this.setLoadingStatus("complete");
+                    this.requestRender();
+                })
+                .catch((e) => {
+                    this.load();
+                    this.setLoadingStatus("error", e.message);
+                });
         }, this.delay);
     }
+
+    async #resolveData() {
+        if (!this.params.url) {
+            return this.params.data ?? [];
+        }
+
+        const descriptors = await normalizeUrlDescriptors({
+            url: this.params.url,
+            baseUrl: this.view.getBaseUrl(),
+            paramRuntime: this.view.paramRuntime,
+        });
+
+        return descriptors.flatMap((descriptor, i) => {
+            const rows = this.params.data ?? [{ x: i, value: descriptor.url }];
+            const attachFields = createDescriptorFieldAttacher(
+                descriptor.fields
+            );
+            return rows.map((datum) => attachFields({ ...datum }));
+        });
+    }
 }

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

@@ -1,2 +1,4 @@
 import "./axisTickSource.js";
 import "./axisGenomeSource.js";
+import "./legendEntriesSource.js";
+import "./legendGradientSource.js";

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;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;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;IAeD;;;;;OAKG;IACH,iCAHW,MAAM,EAAE,iBAKlB;IArBD;;OAEG;IACH,mCAQC;IAyBD;;;;;;;;;;OAUG;IACH,4BAHa,CAAC,YAHH,MAAM,EAAE,UACR,sBAAsB,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,GACrD,OAAO,CAAC,CAAC,EAAE,CAAC,CAiDvB;IAED;;;;;;OAMG;IACH,yCALW,MAAM,EAAE,cACR,MAAM,YACN,CAAS,IAAQ,EAAR,MAAM,EAAE,KAAE,IAAI,QAyBjC;;CACJ;mCAhNY,CAAC,IACD,CAAC,gBAAgB,EAAE,OAAO,mCAAmC,EAAE,0BAA0B,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;oCAI7H,CAAC;UAEJ,sBAAsB,CAAC,CAAC,CAAC;gBACzB,CAAC,iBAAiB,EAAE,OAAO,mCAAmC,EAAE,0BAA0B,EAAE,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;;iCAX3G,2BAA2B"}
+{"version":3,"file":"singleAxisWindowedSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/singleAxisWindowedSource.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;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;IAyBD;;;;;;;;;;OAUG;IACH,4BAHa,CAAC,YAHH,MAAM,EAAE,UACR,sBAAsB,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,GACrD,OAAO,CAAC,CAAC,EAAE,CAAC,CAiDvB;IAED;;;;;;OAMG;IACH,yCALW,MAAM,EAAE,cACR,MAAM,YACN,CAAS,IAAQ,EAAR,MAAM,EAAE,KAAE,IAAI,QAyBjC;;CACJ;mCA/MY,CAAC,IACD,CAAC,gBAAgB,EAAE,OAAO,mCAAmC,EAAE,0BAA0B,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;oCAI7H,CAAC;UAEJ,sBAAsB,CAAC,CAAC,CAAC;gBACzB,CAAC,iBAAiB,EAAE,OAAO,mCAAmC,EAAE,0BAA0B,EAAE,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;;iCAX3G,2BAA2B"}

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

@@ -26,8 +26,8 @@ export default class SingleAxisWindowedSource extends SingleAxisLazySource {
     /** @type {number[]} */
     #lastQuantizedInterval = [0, 0];
 
-    /** @type {number[]} */
-    #lastDomain = [0, 0];
+    /** @type {number[] | undefined} */
+    #lastDomain;
 
     #lastWindowSize = 0;
 
@@ -91,9 +91,8 @@ export default class SingleAxisWindowedSource extends SingleAxisLazySource {
      * @protected
      */
     reloadLastDomain() {
-        const domain = this.#lastDomain;
+        const domain = this.#lastDomain ?? this.scaleResolution.getDomain();
 
-        this.#lastDomain = [0, 0];
         this.#lastQuantizedInterval = [0, 0];
         this._lastLoadedDomain = undefined;
 

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

@@ -1,8 +1,9 @@
 /**
  * @template T
+ * @template P
  * @abstract
  */
-export default class TabixSource<T> extends SingleAxisWindowedSource {
+export default class TabixSource<T, P> extends SingleAxisWindowedSource {
     /**
      * @param {import("../../../spec/data.js").TabixData} params
      * @param {import("../../../view/view.js").default} view
@@ -11,23 +12,27 @@ export default class TabixSource<T> extends SingleAxisWindowedSource {
     params: import("../../../spec/data.js").TabixData;
     /**
      * @param {string} header
+     * @param {import("@gmod/tabix").TabixIndexedFile} tbiIndex
      * @protected
+     * @returns {Promise<P>}
      */
-    protected _handleHeader(header: string): Promise<void>;
+    protected _createParser(header: string, tbiIndex: import("@gmod/tabix").TabixIndexedFile): Promise<P>;
     /**
      * Read a prefix of the Tabix file and decode it as text.
      *
+     * @param {import("@gmod/tabix").TabixIndexedFile} tbiIndex
      * @returns {Promise<string>}
      * @protected
      */
-    protected _readFilePrefix(): Promise<string>;
+    protected _readFilePrefix(tbiIndex: import("@gmod/tabix").TabixIndexedFile): Promise<string>;
     /**
      * @abstract
      * @protected
      * @param {string[]} lines
+     * @param {P} parserContext
      * @returns {T[]}
      */
-    protected _parseFeatures(lines: string[]): T[];
+    protected _parseFeatures(lines: string[], parserContext: P): T[];
     #private;
 }
 import SingleAxisWindowedSource from "./singleAxisWindowedSource.js";

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

@@ -1 +1 @@
-{"version":3,"file":"tabixSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/tabixSource.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,iCAHa,CAAC;IAOV;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,SAAS,QACzC,OAAO,uBAAuB,EAAE,OAAO,EAyCjD;IAzBG,kDAgBC;IA0FL;;;OAGG;IACH,gCAHW,MAAM,iBAKhB;IAED;;;;;OAKG;IACH,6BAHa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;OAKG;IACH,gCAHW,MAAM,EAAE,GACN,CAAC,EAAE,CAKf;;CACJ;qCAzKoC,+BAA+B"}
+{"version":3,"file":"tabixSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/tabixSource.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,iCAJa,CAAC,EACD,CAAC;IAkBV;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,SAAS,QACzC,OAAO,uBAAuB,EAAE,OAAO,EA+CjD;IA/BG,kDAgBC;IA0JL;;;;;OAKG;IACH,gCALW,MAAM,YACN,OAAO,aAAa,EAAE,gBAAgB,GAEpC,OAAO,CAAC,CAAC,CAAC,CAItB;IAED;;;;;;OAMG;IACH,oCAJW,OAAO,aAAa,EAAE,gBAAgB,GACpC,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;OAMG;IACH,gCAJW,MAAM,EAAE,iBACR,CAAC,GACC,CAAC,EAAE,CAKf;;CAwCJ;qCAhSoC,+BAA+B"}