@genome-spy/core 0.66.1 → 0.68.0

package/dist/src/data/flowNode.js

@@ -35,6 +35,9 @@ export default class FlowNode {
         first: null,
     };
 
+    /** @type {boolean} */
+    #initialized = false;
+
     /**
      * An object that provides a paramMediator. (Most likely a View)
      *
@@ -89,11 +92,26 @@ export default class FlowNode {
     /**
      * Allows for doing final initialization after the flow structure has been
      * built and optimized. Must be called before any data are to be propagated.
+     * Note: Some transforms call initialize() from reset() to rebuild internal
+     * fast paths per batch. Use initializeOnce() for graph-level init to avoid
+     * double-initialization issues.
      */
     initialize() {
         // override
     }
 
+    /**
+     * Calls initialize() once per node instance. Intended for graph-level init
+     * passes that should not rerun when reusing existing branches.
+     */
+    initializeOnce() {
+        if (this.#initialized) {
+            return;
+        }
+        this.initialize();
+        this.#initialized = true;
+    }
+
     /**
      * Dynamically updates the propagator method to allow the JavaScript engine
      * to employ optimizations such as inlining.

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

@@ -0,0 +1,18 @@
+/**
+ * Lazily builds and caches lookup indexes for `encoding.key` fields so that
+ * bookmarked point selections can be resolved back to datums efficiently.
+ *
+ * TODO: Use requestIdleCallback to warm up the index to prevent jank on first access.
+ */
+export default class KeyIndex {
+    invalidate(): void;
+    /**
+     * @param {string[]} keyFields
+     * @param {import("../spec/channel.js").Scalar[]} keyTuple
+     * @param {Iterable<Data>} facetBatches
+     * @returns {Datum | undefined}
+     */
+    findDatum(keyFields: string[], keyTuple: import("../spec/channel.js").Scalar[], facetBatches: Iterable<import("./flowNode.js").Data>): import("./flowNode.js").Datum | undefined;
+    #private;
+}
+//# sourceMappingURL=keyIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyIndex.d.ts","sourceRoot":"","sources":["../../../src/data/keyIndex.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IAeI,mBAIC;IAED;;;;;OAKG;IACH,qBALW,MAAM,EAAE,YACR,OAAO,oBAAoB,EAAE,MAAM,EAAE,gBACrC,QAAQ,8BAAM,GACZ,gCAAQ,SAAS,CAwC7B;;CAgGJ"}

package/dist/src/data/keyIndex.js

@@ -0,0 +1,241 @@
+import { field } from "../utils/field.js";
+
+const MULTI_KEY_SEPARATOR = "|";
+const MULTI_KEY_ESCAPE = "\\";
+
+/**
+ * Lazily builds and caches lookup indexes for `encoding.key` fields so that
+ * bookmarked point selections can be resolved back to datums efficiently.
+ *
+ * TODO: Use requestIdleCallback to warm up the index to prevent jank on first access.
+ */
+export default class KeyIndex {
+    /**
+     * @typedef {import("./flowNode.js").Datum} Datum
+     * @typedef {import("./flowNode.js").Data} Data
+     */
+
+    /** @type {Map<import("../spec/channel.js").Scalar | string, Datum> | null} */
+    #index = null;
+
+    /** @type {string[] | null} */
+    #keyFields = null;
+
+    /** @type {boolean} */
+    #usesCompositeKey = false;
+
+    invalidate() {
+        this.#index = null;
+        this.#keyFields = null;
+        this.#usesCompositeKey = false;
+    }
+
+    /**
+     * @param {string[]} keyFields
+     * @param {import("../spec/channel.js").Scalar[]} keyTuple
+     * @param {Iterable<Data>} facetBatches
+     * @returns {Datum | undefined}
+     */
+    findDatum(keyFields, keyTuple, facetBatches) {
+        if (!keyFields || keyFields.length === 0) {
+            return;
+        }
+
+        const fieldList = keyFields.join(", ");
+        if (keyFields.length !== keyTuple.length) {
+            throw new Error(
+                `Key tuple length ${keyTuple.length} does not match fields [${fieldList}]`
+            );
+        }
+
+        if (!this.#index || !this.#matchesKeyFields(keyFields)) {
+            this.#buildIndex(keyFields, facetBatches);
+        }
+
+        const canonicalFields = /** @type {string[]} */ (this.#keyFields);
+        /** @type {import("../spec/channel.js").Scalar | string} */
+        let key;
+        if (!this.#usesCompositeKey) {
+            const fieldName = canonicalFields[0];
+            key = validateKeyComponent(keyTuple[0], fieldName);
+        } else {
+            let compositeKey = "";
+            for (let i = 0; i < keyTuple.length; i++) {
+                if (i > 0) {
+                    compositeKey += MULTI_KEY_SEPARATOR;
+                }
+
+                const fieldName = canonicalFields[i];
+                const value = validateKeyComponent(keyTuple[i], fieldName);
+
+                compositeKey += encodeKeyPart(value);
+            }
+            key = compositeKey;
+        }
+
+        return this.#index.get(key);
+    }
+
+    /**
+     * @param {string[]} keyFields
+     * @param {Iterable<Data>} facetBatches
+     */
+    #buildIndex(keyFields, facetBatches) {
+        /** @type {Array<(datum: Datum) => import("../spec/channel.js").Scalar>} */
+        const accessors = keyFields.map((fieldName) => field(fieldName));
+        /** @type {Map<import("../spec/channel.js").Scalar | string, Datum>} */
+        const index = new Map();
+        const fieldList = keyFields.join(", ");
+
+        const usesCompositeKey = keyFields.length !== 1;
+
+        if (!usesCompositeKey) {
+            const accessor = accessors[0];
+            const fieldName = keyFields[0];
+            for (const data of facetBatches) {
+                for (let i = 0, n = data.length; i < n; i++) {
+                    const datum = data[i];
+                    const key = validateKeyComponent(
+                        accessor(datum),
+                        fieldName
+                    );
+
+                    const previous = index.get(key);
+                    if (previous !== undefined) {
+                        throw new Error(
+                            `Duplicate key detected for fields [${fieldList}]: ${JSON.stringify(key)}`
+                        );
+                    }
+
+                    index.set(key, datum);
+                }
+            }
+        } else {
+            for (const data of facetBatches) {
+                for (let i = 0, n = data.length; i < n; i++) {
+                    const datum = data[i];
+                    let compositeKey = "";
+                    for (let j = 0; j < accessors.length; j++) {
+                        if (j > 0) {
+                            compositeKey += MULTI_KEY_SEPARATOR;
+                        }
+
+                        const fieldName = keyFields[j];
+                        const value = validateKeyComponent(
+                            accessors[j](datum),
+                            fieldName
+                        );
+
+                        compositeKey += encodeKeyPart(value);
+                    }
+
+                    const previous = index.get(compositeKey);
+                    if (previous !== undefined) {
+                        const duplicateTuple = accessors.map((accessor) =>
+                            accessor(datum)
+                        );
+                        throw new Error(
+                            `Duplicate key detected for fields [${fieldList}]: ${JSON.stringify(duplicateTuple)}`
+                        );
+                    }
+
+                    index.set(compositeKey, datum);
+                }
+            }
+        }
+
+        this.#index = index;
+        this.#keyFields = [...keyFields];
+        this.#usesCompositeKey = usesCompositeKey;
+    }
+
+    /**
+     * @param {string[]} keyFields
+     * @returns {boolean}
+     */
+    #matchesKeyFields(keyFields) {
+        if (!this.#keyFields) {
+            return false;
+        }
+
+        if (this.#keyFields.length !== keyFields.length) {
+            return false;
+        }
+
+        for (let i = 0; i < keyFields.length; i++) {
+            if (this.#keyFields[i] !== keyFields[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} fieldName
+ * @returns {import("../spec/channel.js").Scalar}
+ */
+function validateKeyComponent(value, fieldName) {
+    if (value === undefined) {
+        throw new Error(
+            `Key field "${fieldName}" is undefined. Ensure all key fields are present in the data.`
+        );
+    }
+
+    if (value === null) {
+        throw new Error(
+            `Key field "${fieldName}" is null. Ensure all key fields are present in the data.`
+        );
+    }
+
+    if (
+        typeof value !== "string" &&
+        typeof value !== "number" &&
+        typeof value !== "boolean"
+    ) {
+        throw new Error(
+            `Key field "${fieldName}" must be a scalar value (string, number, or boolean).`
+        );
+    }
+
+    return value;
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeKeyString(value) {
+    const needsEscaping =
+        value.indexOf(MULTI_KEY_ESCAPE) !== -1 ||
+        value.indexOf(MULTI_KEY_SEPARATOR) !== -1;
+
+    if (!needsEscaping) {
+        return value;
+    }
+
+    let escaped = "";
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (char === MULTI_KEY_ESCAPE || char === MULTI_KEY_SEPARATOR) {
+            escaped += MULTI_KEY_ESCAPE;
+        }
+        escaped += char;
+    }
+
+    return escaped;
+}
+
+/**
+ * @param {import("../spec/channel.js").Scalar} scalar
+ * @returns {string}
+ */
+function encodeKeyPart(scalar) {
+    if (typeof scalar === "string") {
+        return escapeKeyString(scalar);
+    }
+
+    return String(scalar);
+}

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

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

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

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

package/dist/src/data/sources/dataSource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataSource.js"],"names":[],"mappings":"AAEA;IAMI;;OAEG;IACH,kBAFW,OAAO,oBAAoB,EAAE,OAAO,EAM9C;IAZD;;OAEG;IACH,MAFU,OAAO,oBAAoB,EAAE,OAAO,CAEzC;IAWL;;;;;OAKG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,mCAJW,OAAO,4BAA4B,EAAE,iBAAiB,WACtD,MAAM,QAKhB;IAcD,sBAEC;CAKJ;qBAzDoB,gBAAgB"}
+{"version":3,"file":"dataSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataSource.js"],"names":[],"mappings":"AAEA;IAMI;;OAEG;IACH,kBAFW,OAAO,oBAAoB,EAAE,OAAO,EAM9C;IAZD;;OAEG;IACH,MAFU,OAAO,oBAAoB,EAAE,OAAO,CAEzC;IAWL;;;;;OAKG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,mCAJW,OAAO,4BAA4B,EAAE,iBAAiB,WACtD,MAAM,QAShB;IAcD,sBAEC;CAKJ;qBA7DoB,gBAAgB"}

package/dist/src/data/sources/dataSource.js

@@ -33,7 +33,11 @@ export default class DataSource extends FlowNode {
      * @protected
      */
     setLoadingStatus(status, detail) {
-        this.view.context.setDataLoadingStatus(this.view, status, detail);
+        this.view.context.dataFlow.loadingStatusRegistry.set(
+            this.view,
+            status,
+            detail
+        );
     }
 
     get paramMediator() {

package/dist/src/data/sources/dataSourceFactory.d.ts

@@ -1,17 +1,19 @@
+/**
+ * Registers a lazy data source for a custom type.
+ *
+ * @template {import("../../spec/data.js").LazyDataParams} P
+ * @param {LazySourceEntry<P>["guard"]} guard
+ * @param {LazySourceEntry<P>["Source"]} Source
+ * @returns {() => void}
+ */
+export function registerLazyDataSource<P extends import("../../spec/data.js").LazyDataParams>(guard: LazySourceEntry<P>["guard"], Source: LazySourceEntry<P>["Source"]): () => void;
 /**
  * @param {Partial<import("../../spec/data.js").Data>} params
  * @param {import("../../view/view.js").default} view
  */
-export default function createDataSource(params: Partial<import("../../spec/data.js").Data>, view: import("../../view/view.js").default): InlineSource | UrlSource | SequenceSource | AxisTickSource | AxisGenomeSource | IndexedFastaSource | BigWigSource | BigBedSource | BamSource | Gff3Source | VcfSource;
-import InlineSource from "./inlineSource.js";
-import UrlSource from "./urlSource.js";
-import SequenceSource from "./sequenceSource.js";
-import AxisTickSource from "./lazy/axisTickSource.js";
-import AxisGenomeSource from "./lazy/axisGenomeSource.js";
-import IndexedFastaSource from "./lazy/indexedFastaSource.js";
-import BigWigSource from "./lazy/bigWigSource.js";
-import BigBedSource from "./lazy/bigBedSource.js";
-import BamSource from "./lazy/bamSource.js";
-import Gff3Source from "./lazy/gff3Source.js";
-import VcfSource from "./lazy/vcfSource.js";
+export default function createDataSource(params: Partial<import("../../spec/data.js").Data>, view: import("../../view/view.js").default): import("./dataSource.js").default;
+export type LazySourceEntry<P extends import("../../spec/data.js").LazyDataParams> = {
+    guard: (params: import("../../spec/data.js").LazyDataParams) => params is P;
+    Source: new (params: P, view: import("../../view/view.js").default) => import("./dataSource.js").default;
+};
 //# sourceMappingURL=dataSourceFactory.d.ts.map

package/dist/src/data/sources/dataSourceFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataSourceFactory.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataSourceFactory.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,iDAHW,OAAO,CAAC,OAAO,oBAAoB,EAAE,IAAI,CAAC,QAC1C,OAAO,oBAAoB,EAAE,OAAO,yKAgB9C;yBA9B0C,mBAAmB;sBACzB,gBAAgB;2BACD,qBAAqB;2BAC9C,0BAA0B;6BACxB,4BAA4B;+BAC1B,8BAA8B;yBACpC,wBAAwB;yBACxB,wBAAwB;sBAC3B,qBAAqB;uBACpB,sBAAsB;sBACvB,qBAAqB"}
+{"version":3,"file":"dataSourceFactory.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataSourceFactory.js"],"names":[],"mappings":"AAuBA;;;;;;;GAOG;AACH,uCAL2D,CAAC,SAA/C,OAAQ,oBAAoB,EAAE,cAAe,SAC/C,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,UAC3B,eAAe,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAC1B,MAAM,IAAI,CAYtB;AAED;;;GAGG;AACH,iDAHW,OAAO,CAAC,OAAO,oBAAoB,EAAE,IAAI,CAAC,QAC1C,OAAO,oBAAoB,EAAE,OAAO,qCAgB9C;4BAhD0D,CAAC,SAA/C,OAAQ,oBAAoB,EAAE,cAAe,IAC7C;IACR,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,oBAAoB,EAAE,cAAc,KAAK,MAAM,IAAI,CAAC,CAAC;IAC5E,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,oBAAoB,EAAE,OAAO,KAAK,OAAO,iBAAiB,EAAE,OAAO,CAAA;CACzG"}

package/dist/src/data/sources/dataSourceFactory.js

@@ -10,6 +10,37 @@ import BamSource from "./lazy/bamSource.js";
 import Gff3Source from "./lazy/gff3Source.js";
 import VcfSource from "./lazy/vcfSource.js";
 
+/**
+ * @template {import("../../spec/data.js").LazyDataParams} P
+ * @typedef {{
+ *   guard: (params: import("../../spec/data.js").LazyDataParams) => params is P,
+ *   Source: new (params: P, view: import("../../view/view.js").default) => import("./dataSource.js").default
+ * }} LazySourceEntry
+ */
+
+/** @type {LazySourceEntry<any>[]} */
+const customLazySources = [];
+
+/**
+ * Registers a lazy data source for a custom type.
+ *
+ * @template {import("../../spec/data.js").LazyDataParams} P
+ * @param {LazySourceEntry<P>["guard"]} guard
+ * @param {LazySourceEntry<P>["Source"]} Source
+ * @returns {() => void}
+ */
+export function registerLazyDataSource(guard, Source) {
+    /** @type {LazySourceEntry<any>} */
+    const entry = { guard, Source };
+    customLazySources.push(entry);
+    return () => {
+        const index = customLazySources.indexOf(entry);
+        if (index >= 0) {
+            customLazySources.splice(index, 1);
+        }
+    };
+}
+
 /**
  * @param {Partial<import("../../spec/data.js").Data>} params
  * @param {import("../../view/view.js").default} view
@@ -109,27 +140,32 @@ function isVcfSource(params) {
     return params?.type == "vcf";
 }
 
+/** @type {LazySourceEntry<any>[]} */
+const builtinLazySources = [
+    { guard: isAxisTickSource, Source: AxisTickSource },
+    { guard: isAxisGenomeSource, Source: AxisGenomeSource },
+    { guard: isIndexedFastaSource, Source: IndexedFastaSource },
+    { guard: isBigWigSource, Source: BigWigSource },
+    { guard: isBigBedSource, Source: BigBedSource },
+    { guard: isBamSource, Source: BamSource },
+    { guard: isGff3Source, Source: Gff3Source },
+    { guard: isVcfSource, Source: VcfSource },
+];
+
 /**
  * @param {import("../../spec/data.js").LazyDataParams} params
  * @param {import("../../view/view.js").default} view
  */
 function createLazyDataSource(params, view) {
-    if (isAxisTickSource(params)) {
-        return new AxisTickSource(params, view);
-    } else if (isAxisGenomeSource(params)) {
-        return new AxisGenomeSource(params, view);
-    } else if (isIndexedFastaSource(params)) {
-        return new IndexedFastaSource(params, view);
-    } else if (isBigWigSource(params)) {
-        return new BigWigSource(params, view);
-    } else if (isBigBedSource(params)) {
-        return new BigBedSource(params, view);
-    } else if (isBamSource(params)) {
-        return new BamSource(params, view);
-    } else if (isGff3Source(params)) {
-        return new Gff3Source(params, view);
-    } else if (isVcfSource(params)) {
-        return new VcfSource(params, view);
+    for (const entry of customLazySources) {
+        if (entry.guard(params)) {
+            return new entry.Source(/** @type {any} */ (params), view);
+        }
+    }
+    for (const entry of builtinLazySources) {
+        if (entry.guard(params)) {
+            return new entry.Source(/** @type {any} */ (params), view);
+        }
     }
 
     throw new Error(

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

@@ -0,0 +1,29 @@
+/**
+ * Testing-only lazy data source that delays data publishing.
+ * Register via registerLazyDataSource in tests to avoid production exposure.
+ */
+export default class MockLazySource extends SingleAxisLazySource {
+    /**
+     * @param {{ channel?: import("../../../spec/channel.js").PrimaryPositionalChannel, delay?: number, data?: import("../../flowNode.js").Datum[] }} params
+     * @param {import("../../../view/view.js").default} view
+     */
+    constructor(params: {
+        channel?: import("../../../spec/channel.js").PrimaryPositionalChannel;
+        delay?: number;
+        data?: import("../../flowNode.js").Datum[];
+    }, view: import("../../../view/view.js").default);
+    params: {
+        channel?: import("../../../spec/channel.js").PrimaryPositionalChannel;
+        delay?: number;
+        data?: import("../../flowNode.js").Datum[];
+    };
+    delay: number;
+    /** @type {ReturnType<typeof setTimeout> | undefined} */
+    pendingTimer: ReturnType<typeof setTimeout> | undefined;
+    /**
+     * @override
+     */
+    override onDomainChanged(): void;
+}
+import SingleAxisLazySource from "./singleAxisLazySource.js";
+//# sourceMappingURL=mockLazySource.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,44 @@
+import SingleAxisLazySource from "./singleAxisLazySource.js";
+
+/**
+ * Testing-only lazy data source that delays data publishing.
+ * Register via registerLazyDataSource in tests to avoid production exposure.
+ */
+export default class MockLazySource extends SingleAxisLazySource {
+    /**
+     * @param {{ channel?: import("../../../spec/channel.js").PrimaryPositionalChannel, delay?: number, data?: import("../../flowNode.js").Datum[] }} params
+     * @param {import("../../../view/view.js").default} view
+     */
+    constructor(params, view) {
+        super(view, params.channel ?? "x");
+
+        this.params = params;
+        this.delay = params.delay ?? 0;
+        /** @type {ReturnType<typeof setTimeout> | undefined} */
+        this.pendingTimer = undefined;
+
+        this.view.registerDisposer(() => {
+            if (this.pendingTimer) {
+                clearTimeout(this.pendingTimer);
+                this.pendingTimer = undefined;
+            }
+        });
+    }
+
+    /**
+     * @override
+     */
+    onDomainChanged() {
+        if (this.pendingTimer) {
+            clearTimeout(this.pendingTimer);
+            this.pendingTimer = undefined;
+        }
+
+        const data = this.params.data ?? [];
+        this.pendingTimer = setTimeout(() => {
+            this.pendingTimer = undefined;
+            this.publishData([data]);
+            this.requestRender();
+        }, this.delay);
+    }
+}

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

@@ -1,9 +1,16 @@
+/**
+ * @typedef {Partial<Record<import("../../../spec/channel.js").PrimaryPositionalChannel, number[]>>} DataReadinessRequest
+ */
+/**
+ * @typedef {{isDataReadyForDomain: (request: DataReadinessRequest) => boolean}} DataReadinessCheckable
+ */
 /**
  * Base class for data sources that listen a domain and propagate data lazily.
  *
  * @abstract
+ * @implements {DataReadinessCheckable}
  */
-export default class SingleAxisLazySource extends DataSource {
+export default class SingleAxisLazySource extends DataSource implements DataReadinessCheckable {
     /**
      * @param {import("../../../view/view.js").default} view
      * @param {import("../../../spec/channel.js").PrimaryPositionalChannel} channel
@@ -14,6 +21,11 @@ export default class SingleAxisLazySource extends DataSource {
      * @protected
      */
     protected initializedPromise: Promise<void>;
+    /**
+     * @type {number[] | undefined}
+     * @protected
+     */
+    protected _lastLoadedDomain: number[] | undefined;
     /** @type {import("../../../spec/channel.js").PrimaryPositionalChannel}  */
     channel: import("../../../spec/channel.js").PrimaryPositionalChannel;
     scaleResolution: import("../../../scales/scaleResolution.js").default;
@@ -48,6 +60,15 @@ export default class SingleAxisLazySource extends DataSource {
      * @protected
      */
     protected publishData(chunks: import("../../flowNode.js").Datum[][]): void;
+    /**
+     * @param {DataReadinessRequest} request
+     * @returns {boolean}
+     */
+    isDataReadyForDomain(request: DataReadinessRequest): boolean;
 }
+export type DataReadinessRequest = Partial<Record<import("../../../spec/channel.js").PrimaryPositionalChannel, number[]>>;
+export type DataReadinessCheckable = {
+    isDataReadyForDomain: (request: DataReadinessRequest) => boolean;
+};
 import DataSource from "../dataSource.js";
 //# sourceMappingURL=singleAxisLazySource.d.ts.map

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,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"}
+{"version":3,"file":"singleAxisLazySource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/lazy/singleAxisLazySource.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;GAEG;AAEH;;;;;GAKG;AACH,wEAFgB,sBAAsB;IAelC;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,WACvC,OAAO,0BAA0B,EAAE,wBAAwB,EA+CrE;IA7DD;;;OAGG;IACH,4CAAuC;IAEvC;;;OAGG;IACH,6BAHU,MAAM,EAAE,GAAG,SAAS,CAGZ;IAmBd,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,QAe/C;IAED;;;OAGG;IACH,8BAHW,oBAAoB,GAClB,OAAO,CAenB;CACJ;mCAlKY,OAAO,CAAC,MAAM,CAAC,OAAO,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,EAAE,CAAC,CAAC;qCAItF;IAAC,oBAAoB,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAA;CAAC;uBAPxD,kBAAkB"}

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

@@ -1,11 +1,19 @@
 import UnitView from "../../../view/unitView.js";
 import DataSource from "../dataSource.js";
-import { reconfigureScaleDomains } from "../../../scales/scaleResolution.js";
+
+/**
+ * @typedef {Partial<Record<import("../../../spec/channel.js").PrimaryPositionalChannel, number[]>>} DataReadinessRequest
+ */
+
+/**
+ * @typedef {{isDataReadyForDomain: (request: DataReadinessRequest) => boolean}} DataReadinessCheckable
+ */
 
 /**
  * Base class for data sources that listen a domain and propagate data lazily.
  *
  * @abstract
+ * @implements {DataReadinessCheckable}
  */
 export default class SingleAxisLazySource extends DataSource {
     /**
@@ -14,6 +22,12 @@ export default class SingleAxisLazySource extends DataSource {
      */
     initializedPromise = Promise.resolve();
 
+    /**
+     * @type {number[] | undefined}
+     * @protected
+     */
+    _lastLoadedDomain;
+
     /**
      * @param {import("../../../view/view.js").default} view
      * @param {import("../../../spec/channel.js").PrimaryPositionalChannel} channel
@@ -119,6 +133,7 @@ export default class SingleAxisLazySource extends DataSource {
      * @protected
      */
     publishData(chunks) {
+        this._lastLoadedDomain = Array.from(this.scaleResolution.getDomain());
         this.reset();
         this.beginBatch({ type: "file" });
 
@@ -129,7 +144,24 @@ export default class SingleAxisLazySource extends DataSource {
         }
 
         this.complete();
+    }
+
+    /**
+     * @param {DataReadinessRequest} request
+     * @returns {boolean}
+     */
+    isDataReadyForDomain(request) {
+        const domain = request[this.channel];
+        if (!domain || !this._lastLoadedDomain) {
+            return false;
+        }
 
-        reconfigureScaleDomains(this.view);
+        const [min, max] =
+            domain[0] <= domain[1] ? domain : [domain[1], domain[0]];
+        const [loadedMin, loadedMax] =
+            this._lastLoadedDomain[0] <= this._lastLoadedDomain[1]
+                ? this._lastLoadedDomain
+                : [this._lastLoadedDomain[1], this._lastLoadedDomain[0]];
+        return min >= loadedMin && max <= loadedMax;
     }
 }

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,CAwCvB;IAED;;;;;;OAMG;IACH,yCALW,MAAM,EAAE,cACR,MAAM,YACN,CAAS,IAAQ,EAAR,MAAM,EAAE,KAAE,IAAI,QAyBjC;;CACJ;iCA/KgC,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;IAeD;;;;;OAKG;IACH,iCAHW,MAAM,EAAE,iBAKlB;IArBD;;OAEG;IACH,mCAQC;IAyBD;;;;;;;;;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,CAyCvB;IAED;;;;;;OAMG;IACH,yCALW,MAAM,EAAE,cACR,MAAM,YACN,CAAS,IAAQ,EAAR,MAAM,EAAE,KAAE,IAAI,QAyBjC;;CACJ;iCA9LgC,2BAA2B"}