@genome-spy/core 0.67.0 → 0.68.0

package/dist/src/utils/ui/tooltip.js

@@ -191,8 +191,14 @@ export default class Tooltip {
                     Promise.resolve(html` ${JSON.stringify(d)} `);
             }
 
+            const requestedDatum = datum;
             converter(datum)
-                .then((result) => this.setContent(result))
+                .then((result) => {
+                    if (this.#previousTooltipDatum !== requestedDatum) {
+                        return;
+                    }
+                    this.setContent(result);
+                })
                 .catch((error) => {
                     if (error !== "debounced") {
                         throw error;

package/dist/src/utils/ui/tooltip.test.d.ts

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

package/dist/src/utils/ui/tooltip.test.d.ts.map

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

package/dist/src/view/axisGridView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axisGridView.d.ts","sourceRoot":"","sources":["../../../src/view/axisGridView.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;GAMG;AACH;IACI;;;;;;;OAOG;IACH,uBAPW,IAAI,QAEJ,MAAM,WADN,OAAO,yBAAyB,EAAE,OAAO,gBAEzC,OAAO,oBAAoB,EAAE,OAAO,cACpC,OAAO,WAAW,EAAE,OAAO,YAC3B,OAAO,WAAW,EAAE,WAAW,EA4BzC;IADG,iFAA8B;IAGlC,kDAEC;CAKJ;gCAvDY,OAAO,oBAAoB,EAAE,wBAAwB;iCACrD,OAAO,iBAAiB,EAAE,kBAAkB;;;;mBAM5C,OAAO,WAAW,EAAE,OAAO;;;;mBAC3B,OAAO,iBAAiB,EAAE,IAAI;;;;yBAC9B,OAAO,iBAAiB,EAAE,UAAU;sBAb3B,gBAAgB"}
+{"version":3,"file":"axisGridView.d.ts","sourceRoot":"","sources":["../../../src/view/axisGridView.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;GAMG;AACH;IACI;;;;;;;OAOG;IACH,uBAPW,IAAI,QAEJ,MAAM,WADN,OAAO,yBAAyB,EAAE,OAAO,gBAEzC,OAAO,oBAAoB,EAAE,OAAO,cACpC,OAAO,WAAW,EAAE,OAAO,YAC3B,OAAO,WAAW,EAAE,WAAW,EA6BzC;IAHG,iFAA8B;IAKlC,kDAEC;CAKJ;gCAxDY,OAAO,oBAAoB,EAAE,wBAAwB;iCACrD,OAAO,iBAAiB,EAAE,kBAAkB;;;;mBAM5C,OAAO,WAAW,EAAE,OAAO;;;;mBAC3B,OAAO,iBAAiB,EAAE,IAAI;;;;yBAC9B,OAAO,iBAAiB,EAAE,UAAU;sBAd3B,gBAAgB"}

package/dist/src/view/axisGridView.js

@@ -1,5 +1,6 @@
 import LayerView from "./layerView.js";
 import { orient2channel } from "./axisView.js";
+import { markViewAsNonAddressable } from "./viewSelectors.js";
 
 /**
  * @typedef {import("../spec/channel.js").PrimaryPositionalChannel} PositionalChannel
@@ -42,12 +43,13 @@ export default class AxisGridView extends LayerView {
             `axisGrid_${axisProps.orient}`,
             {
                 blockEncodingInheritance: true,
-                contributesToScaleDomain: false,
                 ...options,
             }
         );
 
         this.axisProps = fullAxisProps;
+
+        markViewAsNonAddressable(this, { skipSubtree: true });
     }
 
     getOrient() {
@@ -121,7 +123,10 @@ function createRegularAxisGrid(axisProps, type) {
             minBufferSize: 300,
         },
         encoding: {
-            [channel]: { field: "value", type },
+            [channel]: {
+                field: "value",
+                type,
+            },
         },
     };
 }
@@ -153,7 +158,11 @@ function createChromAxisGrid(axisProps, type) {
         },
         encoding: {
             // TODO: { chrom: "name", type: "locus" } // without pos = pos is 0
-            [channel]: { field: "continuousStart", type, band: 0 },
+            [channel]: {
+                field: "continuousStart",
+                type,
+                band: 0,
+            },
         },
     };
 }
@@ -180,8 +189,15 @@ function createChromAxisFill(axisProps, type) {
         },
         encoding: {
             // TODO: { chrom: "name", type: "locus" } // without pos = pos is 0
-            [channel]: { field: "continuousStart", type, band: 0 },
-            [channel + "2"]: { field: "continuousEnd", band: 0 },
+            [channel]: {
+                field: "continuousStart",
+                type,
+                band: 0,
+            },
+            [channel + "2"]: {
+                field: "continuousEnd",
+                band: 0,
+            },
             fill: {
                 field: "odd",
                 type: "nominal",
@@ -245,6 +261,7 @@ function createAxisGrid(axisProps, type) {
                 opacity: "independent",
             },
         },
+        domainInert: true,
         layer: layers,
     };
 }

package/dist/src/view/axisView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axisView.d.ts","sourceRoot":"","sources":["../../../src/view/axisView.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH,kIAEC;AAkYD;;;;GAIG;AACH,wFAHW,MAAM,uCA2MhB;AArmBD;;GAEG;AACH,8BAFU,MAAM,CAAC,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,sCAAY,CAAC,CAKnF;AAEF;;GAEG;AACH,8BAFU,MAAM,uCAAa,OAAO,oBAAoB,EAAE,wBAAwB,CAAC,CAMjF;AASF;;;;;GAKG;AACH;IACI;;;;;;;;;;OAUG;IAEH;;;;;;;OAOG;IACH,6DALW,MAAM,WADN,OAAO,yBAAyB,EAAE,OAAO,gBAEzC,OAAO,oBAAoB,EAAE,OAAO,cACpC,OAAO,WAAW,EAAE,OAAO,YAC3B,OAAO,WAAW,EAAE,WAAW,EAiCzC;IADG,iFAA8B;IAiBlC,+BAEC;CAKJ;sBA5HqB,gBAAgB"}
+{"version":3,"file":"axisView.d.ts","sourceRoot":"","sources":["../../../src/view/axisView.js"],"names":[],"mappings":"AAqCA;;GAEG;AACH,kIAEC;AAyYD;;;;GAIG;AACH,wFAHW,MAAM,uCAkNhB;AAnnBD;;GAEG;AACH,8BAFU,MAAM,CAAC,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,sCAAY,CAAC,CAKnF;AAEF;;GAEG;AACH,8BAFU,MAAM,uCAAa,OAAO,oBAAoB,EAAE,wBAAwB,CAAC,CAMjF;AASF;;;;;GAKG;AACH;IACI;;;;;;;;;;OAUG;IAEH;;;;;;;OAOG;IACH,6DALW,MAAM,WADN,OAAO,yBAAyB,EAAE,OAAO,gBAEzC,OAAO,oBAAoB,EAAE,OAAO,cACpC,OAAO,WAAW,EAAE,OAAO,YAC3B,OAAO,WAAW,EAAE,WAAW,EAkCzC;IAHG,iFAA8B;IAmBlC,+BAEC;CAKJ;sBA9HqB,gBAAgB"}

package/dist/src/view/axisView.js

@@ -1,5 +1,6 @@
 import LayerView from "./layerView.js";
 import { FlexDimensions } from "./layout/flexLayout.js";
+import { markViewAsNonAddressable } from "./viewSelectors.js";
 
 const CHROM_LAYER_NAME = "chromosome_ticks_and_labels";
 
@@ -93,12 +94,13 @@ export default class AxisView extends LayerView {
             `axis_${axisProps.orient}`,
             {
                 blockEncodingInheritance: true,
-                contributesToScaleDomain: false,
                 ...options,
             }
         );
 
         this.axisProps = fullAxisProps;
+
+        markViewAsNonAddressable(this, { skipSubtree: true });
     }
 
     getSize() {
@@ -266,6 +268,11 @@ function createAxis(axisProps, type) {
 
     const anchor = ap.orient == "bottom" || ap.orient == "left" ? 1 : 0;
 
+    const makeMainDomainDef = () => ({
+        field: "value",
+        type,
+    });
+
     /**
      * @return {import("../spec/view.js").UnitSpec}
      */
@@ -302,7 +309,7 @@ function createAxis(axisProps, type) {
             minBufferSize: 1500, // to prevent GPU buffer reallocation when zooming
         },
         encoding: {
-            [main]: { field: "value", type },
+            [main]: makeMainDomainDef(),
             text: { field: "label" },
         },
     });
@@ -358,7 +365,7 @@ function createAxis(axisProps, type) {
         const spec = {
             name: "ticks_and_labels",
             encoding: {
-                [main]: { field: "value", type },
+                [main]: makeMainDomainDef(),
             },
             layer: [],
         };
@@ -378,6 +385,7 @@ function createAxis(axisProps, type) {
     const axisSpec = {
         // Force the resolution towards the parent view even if it has "independent" behavior
         resolve: { scale: { [main]: "forced" } },
+        domainInert: true,
         [CHANNEL_DIMENSIONS[getPerpendicularChannel(main)]]: ap.extent,
         data: {
             lazy: {
@@ -527,7 +535,10 @@ export function createGenomeAxis(axisProps, type) {
                 ...chromLabelMarkProps,
             },
             encoding: {
-                [main + "2"]: { field: "continuousEnd", type },
+                [main + "2"]: {
+                    field: "continuousEnd",
+                    type,
+                },
                 text: { field: "name" },
             },
         };
@@ -582,7 +593,11 @@ export function createGenomeAxis(axisProps, type) {
             },
             encoding: {
                 // TODO: { chrom: "name", type: "locus" } // without pos = pos is 0
-                [main]: { field: "continuousStart", type, band: 0 },
+                [main]: {
+                    field: "continuousStart",
+                    type,
+                    band: 0,
+                },
             },
             layer: [],
         };

package/dist/src/view/concatView.js

@@ -44,12 +44,12 @@ export default class ConcatView extends GridView {
 
         this.setChildren(
             await Promise.all(
-                childSpecs.map((childSpec, i) =>
+                childSpecs.map((childSpec) =>
                     this.context.createOrImportView(
                         childSpec,
                         this,
                         this,
-                        "grid" + i
+                        this.getNextAutoName("grid")
                     )
                 )
             )
@@ -151,7 +151,7 @@ export default class ConcatView extends GridView {
             afterRemove: async () => {
                 await this.syncSharedAxes();
             },
-            defaultName: (_index) => "grid" + this.childCount,
+            defaultName: () => this.getNextAutoName("grid"),
         });
     }
 }

package/dist/src/view/containerMutationHelper.js

@@ -55,7 +55,7 @@ export default class ContainerMutationHelper {
         const insertIndex = index ?? specs.length;
         const name =
             this.options.defaultName?.(insertIndex, childSpec) ??
-            "child" + specs.length;
+            this.container.getNextAutoName("child");
 
         const childView = await this.container.context.createOrImportView(
             childSpec,

package/dist/src/view/containerView.d.ts

@@ -14,16 +14,19 @@ export default class ContainerView extends View {
     constructor(spec: import("../spec/view.js").ContainerSpec, context: import("../types/viewContext.js").default, layoutParent: ContainerView, dataParent: import("./view.js").default, name: string, options?: import("./view.js").ViewOptions);
     spec: import("../spec/view.js").ContainerSpec;
     initializeChildren(): Promise<void>;
+    /**
+     * Generates an auto name that is guaranteed to be unique within this container
+     * for the given prefix. Intended for debugging-only default names.
+     *
+     * @param {string} prefix
+     * @returns {string}
+     */
+    getNextAutoName(prefix: string): string;
     /**
      * @param {string[]} path An array of view names
      * @returns {View}
      */
     findDescendantByPath(path: string[]): View;
-    /**
-     *
-     * @param {string} name
-     */
-    findChildByName(name: string): View;
     /**
      *
      * @param {string} name
@@ -33,6 +36,7 @@ export default class ContainerView extends View {
      * @returns {IterableIterator<View>}
      */
     [Symbol.iterator](): IterableIterator<View>;
+    #private;
 }
 import View from "./view.js";
 //# sourceMappingURL=containerView.d.ts.map

package/dist/src/view/containerView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"containerView.d.ts","sourceRoot":"","sources":["../../../src/view/containerView.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;;;;;;OAQG;IACH,kBAPW,OAAO,iBAAiB,EAAE,aAAa,WACvC,OAAO,yBAAyB,EAAE,OAAO,gBACzC,aAAa,cACb,OAAO,WAAW,EAAE,OAAO,QAC3B,MAAM,YACN,OAAO,WAAW,EAAE,WAAW,EAMzC;IADG,8CAAgB;IAGpB,oCAEC;IAsDD;;;OAGG;IACH,2BAHW,MAAM,EAAE,GACN,IAAI,CAYhB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAchB;IAhGD;;OAEG;IACH,qBAFa,gBAAgB,CAAC,IAAI,CAAC,CAIlC;CAqGJ;iBAnI4C,WAAW"}
+{"version":3,"file":"containerView.d.ts","sourceRoot":"","sources":["../../../src/view/containerView.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAII;;;;;;;;OAQG;IACH,kBAPW,OAAO,iBAAiB,EAAE,aAAa,WACvC,OAAO,yBAAyB,EAAE,OAAO,gBACzC,aAAa,cACb,OAAO,WAAW,EAAE,OAAO,QAC3B,MAAM,YACN,OAAO,WAAW,EAAE,WAAW,EAMzC;IADG,8CAAgB;IAGpB,oCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAMlB;IAsDD;;;OAGG;IACH,2BAHW,MAAM,EAAE,GACN,IAAI,CAsBhB;IAaD;;;OAGG;IACH,2BAFW,MAAM,QAchB;IAzGD;;OAEG;IACH,qBAFa,gBAAgB,CAAC,IAAI,CAAC,CAIlC;;CA8GJ;iBA5J4C,WAAW"}

package/dist/src/view/containerView.js

@@ -4,6 +4,9 @@ import View, { VISIT_STOP, VISIT_SKIP } from "./view.js";
  * Compositor view represents a non-leaf node in the view hierarchy.
  */
 export default class ContainerView extends View {
+    /** @type {Map<string, number>} */
+    #autoNameCounters = new Map();
+
     /**
      *
      * @param {import("../spec/view.js").ContainerSpec} spec
@@ -23,6 +26,19 @@ export default class ContainerView extends View {
         // override
     }
 
+    /**
+     * Generates an auto name that is guaranteed to be unique within this container
+     * for the given prefix. Intended for debugging-only default names.
+     *
+     * @param {string} prefix
+     * @returns {string}
+     */
+    getNextAutoName(prefix) {
+        const counter = this.#autoNameCounters.get(prefix) ?? 0;
+        this.#autoNameCounters.set(prefix, counter + 1);
+        return prefix + counter;
+    }
+
     /**
      * @returns {IterableIterator<View>}
      */
@@ -80,22 +96,31 @@ export default class ContainerView extends View {
      * @returns {View}
      */
     findDescendantByPath(path) {
-        for (const child of this) {
-            if (child.name === path[0]) {
-                if (path.length == 1) {
-                    return child;
-                } else if (child instanceof ContainerView) {
-                    return child.findDescendantByPath(path.slice(1));
-                }
+        /** @type {View | ContainerView} */
+        let current = this;
+
+        for (let i = 0; i < path.length; i++) {
+            if (!(current instanceof ContainerView)) {
+                return;
+            }
+
+            const next = current.#findImmediateChildByName(path[i]);
+            if (!next) {
+                return;
             }
+
+            if (i === path.length - 1) {
+                return next;
+            }
+
+            current = next;
         }
     }
 
     /**
-     *
      * @param {string} name
      */
-    findChildByName(name) {
+    #findImmediateChildByName(name) {
         for (const child of this) {
             if (child.name === name) {
                 return child;

package/dist/src/view/dataReadiness.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {import("../view/view.js").default} View
+ * @typedef {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessRequest} DataReadinessRequest
+ */
+/**
+ * Builds a readiness request for the provided channels.
+ *
+ * @param {View} view
+ * @param {import("../spec/channel.js").PrimaryPositionalChannel[]} channels
+ * @returns {DataReadinessRequest | undefined}
+ */
+export function buildReadinessRequest(view: View, channels: import("../spec/channel.js").PrimaryPositionalChannel[]): DataReadinessRequest | undefined;
+/**
+ * Checks whether all data sources under the subtree report readiness.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeReady(subtreeRoot: View, readinessRequest: DataReadinessRequest, viewFilter?: (view: View) => boolean): boolean;
+/**
+ * Checks readiness for lazy data sources under the subtree. Non-lazy sources
+ * are ignored so they do not block readiness checks.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest | undefined} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeLazyReady(subtreeRoot: View, readinessRequest: DataReadinessRequest | undefined, viewFilter?: (view: View) => boolean): boolean;
+/**
+ * Waits until lazy data sources under the subtree satisfy the readiness request.
+ * Non-lazy sources are ignored so they do not block readiness checks.
+ *
+ * @param {import("../types/viewContext.js").default} context
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {AbortSignal} [signal]
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {Promise<void>}
+ */
+export function awaitSubtreeLazyReady(context: import("../types/viewContext.js").default, subtreeRoot: View, readinessRequest: DataReadinessRequest, signal?: AbortSignal, viewFilter?: (view: View) => boolean): Promise<void>;
+export type View = import("../view/view.js").default;
+export type DataReadinessRequest = import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessRequest;
+//# sourceMappingURL=dataReadiness.d.ts.map

package/dist/src/view/dataReadiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataReadiness.d.ts","sourceRoot":"","sources":["../../../src/view/dataReadiness.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;GAMG;AACH,4CAJW,IAAI,YACJ,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,GACrD,oBAAoB,GAAG,SAAS,CAe5C;AAED;;;;;;;GAOG;AACH,4CALW,IAAI,oBACJ,oBAAoB,eACpB,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACrB,OAAO,CAiDnB;AAED;;;;;;;;GAQG;AACH,gDALW,IAAI,oBACJ,oBAAoB,GAAG,SAAS,eAChC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACrB,OAAO,CAwDnB;AAED;;;;;;;;;;GAUG;AACH,+CAPW,OAAO,yBAAyB,EAAE,OAAO,eACzC,IAAI,oBACJ,oBAAoB,WACpB,WAAW,eACX,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACrB,OAAO,CAAC,IAAI,CAAC,CAyGzB;mBAtQY,OAAO,iBAAiB,EAAE,OAAO;mCACjC,OAAO,8CAA8C,EAAE,oBAAoB"}

package/dist/src/view/dataReadiness.js

@@ -0,0 +1,267 @@
+import DataSource from "../data/sources/dataSource.js";
+import UnitView from "./unitView.js";
+
+/**
+ * @typedef {import("../view/view.js").default} View
+ * @typedef {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessRequest} DataReadinessRequest
+ */
+
+/**
+ * Builds a readiness request for the provided channels.
+ *
+ * @param {View} view
+ * @param {import("../spec/channel.js").PrimaryPositionalChannel[]} channels
+ * @returns {DataReadinessRequest | undefined}
+ */
+export function buildReadinessRequest(view, channels) {
+    /** @type {DataReadinessRequest} */
+    const request = {};
+
+    for (const channel of channels) {
+        const resolution = view.getScaleResolution(channel);
+        if (!resolution) {
+            continue;
+        }
+        request[channel] = Array.from(resolution.getDomain());
+    }
+
+    return Object.keys(request).length ? request : undefined;
+}
+
+/**
+ * Checks whether all data sources under the subtree report readiness.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeReady(subtreeRoot, readinessRequest, viewFilter) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    const unitViews = subtreeRoot
+        .getDescendants()
+        .filter((view) => view instanceof UnitView && shouldConsiderView(view));
+
+    if (unitViews.length === 0) {
+        return subtreeRoot.isDataInitialized();
+    }
+
+    for (const view of unitViews) {
+        /** @type {import("../data/collector.js").default | undefined} */
+        const collector = view.flowHandle?.collector;
+        if (!collector || !collector.completed) {
+            return false;
+        }
+
+        /** @type {import("../data/flowNode.js").default | undefined} */
+        let node = collector;
+        while (node && !(node instanceof DataSource)) {
+            node = node.parent;
+        }
+
+        const dataSource = /** @type {DataSource | undefined} */ (node);
+        if (!dataSource) {
+            return false;
+        }
+
+        if ("isDataReadyForDomain" in dataSource) {
+            // It's available in SingleAxisLazySource and its subclasses
+            const checkableSource =
+                /** @type {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessCheckable} */ (
+                    dataSource
+                );
+            if (
+                !readinessRequest ||
+                !checkableSource.isDataReadyForDomain(readinessRequest)
+            ) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Checks readiness for lazy data sources under the subtree. Non-lazy sources
+ * are ignored so they do not block readiness checks.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest | undefined} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeLazyReady(subtreeRoot, readinessRequest, viewFilter) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    /** @type {Set<DataSource>} */
+    const dataSources = new Set();
+
+    subtreeRoot.visit((view) => {
+        if (!(view instanceof UnitView)) {
+            return;
+        }
+        if (!shouldConsiderView(view)) {
+            return;
+        }
+
+        /** @type {View | null} */
+        let current = view;
+        while (current) {
+            if (current.flowHandle && current.flowHandle.dataSource) {
+                break;
+            }
+            current = current.dataParent;
+        }
+
+        if (!current || !current.flowHandle) {
+            return;
+        }
+        const dataSource = current.flowHandle.dataSource;
+        if (!("isDataReadyForDomain" in dataSource)) {
+            return;
+        }
+        dataSources.add(dataSource);
+    });
+
+    if (!dataSources.size) {
+        return true;
+    }
+
+    if (!readinessRequest) {
+        return false;
+    }
+
+    for (const dataSource of dataSources) {
+        const checkReady =
+            /** @type {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessCheckable["isDataReadyForDomain"]} */ (
+                /** @type {any} */ (dataSource).isDataReadyForDomain
+            );
+        if (!checkReady.call(dataSource, readinessRequest)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Waits until lazy data sources under the subtree satisfy the readiness request.
+ * Non-lazy sources are ignored so they do not block readiness checks.
+ *
+ * @param {import("../types/viewContext.js").default} context
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {AbortSignal} [signal]
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {Promise<void>}
+ */
+export function awaitSubtreeLazyReady(
+    context,
+    subtreeRoot,
+    readinessRequest,
+    signal,
+    viewFilter
+) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    if (!readinessRequest) {
+        if (
+            isSubtreeLazyReady(
+                subtreeRoot,
+                readinessRequest,
+                shouldConsiderView
+            )
+        ) {
+            return Promise.resolve();
+        }
+        return Promise.reject(
+            new Error("Lazy subtree readiness requires a readiness request.")
+        );
+    }
+
+    return new Promise((resolve, reject) => {
+        /** @type {Set<() => void>} */
+        const unregisters = new Set();
+        /** @type {Set<import("../data/collector.js").default>} */
+        const observedCollectors = new Set();
+
+        /** @type {(message: import("./view.js").BroadcastMessage) => void} */
+        const broadcastListener = () => {
+            attachCollectors();
+            checkReady();
+        };
+
+        const cleanup = () => {
+            for (const unregister of unregisters) {
+                unregister();
+            }
+            unregisters.clear();
+            context.removeBroadcastListener(
+                "subtreeDataReady",
+                broadcastListener
+            );
+            if (signal) {
+                signal.removeEventListener("abort", abortHandler);
+            }
+        };
+
+        const checkReady = () => {
+            if (
+                isSubtreeLazyReady(
+                    subtreeRoot,
+                    readinessRequest,
+                    shouldConsiderView
+                )
+            ) {
+                cleanup();
+                resolve();
+            }
+        };
+
+        const attachCollectors = () => {
+            subtreeRoot.visit((view) => {
+                if (!(view instanceof UnitView)) {
+                    return;
+                }
+                if (!shouldConsiderView(view)) {
+                    return;
+                }
+                const collector = view.flowHandle?.collector;
+                if (!collector) {
+                    return;
+                }
+                if (observedCollectors.has(collector)) {
+                    return;
+                }
+                observedCollectors.add(collector);
+                unregisters.add(collector.observe(checkReady));
+            });
+        };
+
+        const abortHandler = () => {
+            cleanup();
+            reject(new Error("Lazy subtree readiness was aborted."));
+        };
+
+        attachCollectors();
+        checkReady();
+
+        context.addBroadcastListener("subtreeDataReady", broadcastListener);
+
+        if (signal) {
+            if (signal.aborted) {
+                abortHandler();
+                return;
+            }
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
+    });
+}

package/dist/src/view/dataReadiness.test.d.ts

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

package/dist/src/view/dataReadiness.test.d.ts.map

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

package/dist/src/view/facetView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facetView.d.ts","sourceRoot":"","sources":["../../../src/view/facetView.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;;;OAOG;IACH;;;;;;OAMG;IACH,kBALW,OAAO,gBAAgB,EAAE,SAAS,WAClC,OAAO,gBAAgB,EAAE,WAAW,UACpC,aAAa,QACb,MAAM,EA8BhB;IAzBG,UAAgB;IAEhB,WAEC;IAED;;;;OAIG;IACH,aAFU,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAYvC;IAED,oDAAoD;IACpD,kBADY,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CACa;IAajE,sBAIC;IAED;;;OAGG;IACH,qBAFW,KAAK,GAAG,QAAQ,OAwB1B;IAED,qBAyCC;IAED,qBASC;IA6BD,kDAgBC;IAOD;;;;OAIG;IACH,gBAJW,OAAO,4CAA4C,EAAE,OAAO,UAC5D,OAAO,uBAAuB,EAAE,OAAO,YACvC,OAAO,WAAW,EAAE,gBAAgB,QA2L9C;IA3KO,wBAA0B;CA4KrC;2BAjbY,QAAQ,GAAG,KAAK;;;;;;aA4CnB,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;0BA1Df,oBAAoB;qBACzB,eAAe"}
+{"version":3,"file":"facetView.d.ts","sourceRoot":"","sources":["../../../src/view/facetView.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;;;OAOG;IACH;;;;;;OAMG;IACH,kBALW,OAAO,gBAAgB,EAAE,SAAS,WAClC,OAAO,gBAAgB,EAAE,WAAW,UACpC,aAAa,QACb,MAAM,EA+BhB;IA1BG,UAAgB;IAEhB,WAEC;IAED;;;;OAIG;IACH,aAFU,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAavC;IAED,oDAAoD;IACpD,kBADY,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CACa;IAajE,sBAIC;IAED;;;OAGG;IACH,qBAFW,KAAK,GAAG,QAAQ,OAwB1B;IAED,qBAyCC;IAED,qBASC;IA6BD,kDAgBC;IAOD;;;;OAIG;IACH,gBAJW,OAAO,4CAA4C,EAAE,OAAO,UAC5D,OAAO,uBAAuB,EAAE,OAAO,YACvC,OAAO,WAAW,EAAE,gBAAgB,QA2L9C;IA3KO,wBAA0B;CA4KrC;2BAlbY,QAAQ,GAAG,KAAK;;;;;;aA4CnB,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;0BA3Df,oBAAoB;qBACzB,eAAe"}