@genome-spy/core 0.71.0 → 0.73.0

package/dist/src/view/dataReadiness.js

@@ -1,4 +1,5 @@
 import DataSource from "../data/sources/dataSource.js";
+import SingleAxisLazySource from "../data/sources/lazy/singleAxisLazySource.js";
 import UnitView from "./unitView.js";
 
 /**
@@ -95,54 +96,14 @@ export function isSubtreeReady(subtreeRoot, readinessRequest, 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);
-    });
+    const dataSources = collectLazyDataSources(subtreeRoot, viewFilter);
 
     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)) {
+        if (!isLazySourceReady(dataSource, readinessRequest)) {
             return false;
         }
     }
@@ -156,7 +117,7 @@ export function isSubtreeLazyReady(subtreeRoot, readinessRequest, viewFilter) {
  *
  * @param {import("../types/viewContext.js").default} context
  * @param {View} subtreeRoot
- * @param {DataReadinessRequest} readinessRequest
+ * @param {DataReadinessRequest | undefined} readinessRequest
  * @param {AbortSignal} [signal]
  * @param {(view: View) => boolean} [viewFilter]
  * @returns {Promise<void>}
@@ -172,21 +133,6 @@ export function awaitSubtreeLazyReady(
         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();
@@ -265,3 +211,62 @@ export function awaitSubtreeLazyReady(
         }
     });
 }
+
+/**
+ * @param {View} subtreeRoot
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {Set<SingleAxisLazySource>}
+ */
+function collectLazyDataSources(subtreeRoot, viewFilter) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    /** @type {Set<SingleAxisLazySource>} */
+    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 (!(dataSource instanceof SingleAxisLazySource)) {
+            return;
+        }
+
+        dataSources.add(dataSource);
+    });
+
+    return dataSources;
+}
+
+/**
+ * @param {SingleAxisLazySource} dataSource
+ * @param {DataReadinessRequest | undefined} readinessRequest
+ */
+function isLazySourceReady(dataSource, readinessRequest) {
+    const request =
+        readinessRequest ??
+        ({
+            [dataSource.channel]: Array.from(dataSource.scaleResolution.getDomain()),
+        });
+
+    return dataSource.isDataReadyForDomain(request);
+}

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

@@ -48,7 +48,7 @@ export default class FacetView extends ContainerView<import("../spec/view.js").C
     getAccessor(channel: "row" | "column"): any;
     updateFacets(): void;
     updateLabels(): void;
-    getFacetGroups(): string[] | number[] | boolean[];
+    getFacetGroups(): number[] | boolean[] | string[];
     /**
      * @param {import("./renderingContext/viewRenderingContext.js").default} context
      * @param {import("./layout/rectangle.js").default} coords

package/dist/src/view/facetView.js

@@ -354,7 +354,7 @@ export default class FacetView extends ContainerView {
                 coords[channel == "column" ? "width" : "height"],
                 {
                     spacing,
-                    devicePixelRatio: window.devicePixelRatio,
+                    devicePixelRatio: context.getDevicePixelRatio(),
                 }
             );
         };

package/dist/src/view/gridView/gridChild.d.ts

@@ -1,3 +1,10 @@
+/**
+ * @param {import("../../spec/parameter.js").IntervalSelectionConfig["zoom"]} zoom
+ * @param {boolean} hasZoomableChannel
+ * @param {string} paramName
+ * @returns {import("../../spec/parameter.js").EventConfig | undefined}
+ */
+export function resolveIntervalZoomEventConfig(zoom: import("../../spec/parameter.js").IntervalSelectionConfig["zoom"], hasZoomableChannel: boolean, paramName: string): import("../../spec/parameter.js").EventConfig | undefined;
 /**
  * @param {import("../../spec/view.js").ViewBackground} viewBackground
  * @returns {import("../../spec/view.js").UnitSpec}

package/dist/src/view/gridView/gridChild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gridChild.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridChild.js"],"names":[],"mappings":"AAysBA;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA6BjD;AAED;;;GAGG;AACH,uDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA4CjD;AApwBD;IACI;;;;;;OAMG;IAEH;;;;OAIG;IACH,kBAJW,OAAO,YAAY,EAAE,OAAO,gBAC5B,OAAO,qBAAqB,EAAE,OAAO,UACrC,MAAM,EAgGhB;IA7FG,gGAAgC;IAChC,0EAAgB;IAChB,eAAoB;IAEpB,uBAAuB;IACvB,YADW,QAAQ,CACQ;IAE3B,uBAAuB;IACvB,kBADW,QAAQ,CACc;IAEjC,sFAAsF;IACtF,MADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAC/D;IAEd,+FAA+F;IAC/F,WADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAC9D;IAEnB,mFAAmF;IACnF,YADW,OAAO,CAAC,MAAM,CAAC,OAAO,gBAAgB,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC,CAC3D;IAEpB,4BAA4B;IAC5B,eADW,aAAa,CACM;IAE9B,uBAAuB;IACvB,OADW,QAAQ,CACG;IAEtB,wBAAwB;IACxB,QADW,SAAS,CACQ;IAgahC,6GAiBC;IAED;;OAEG;IACH,4BAwKC;IAED;;OAEG;IACH,yBAWC;IAED,uBAqBC;IAED,iCAEC;;CACJ;qBAxrBoB,gBAAgB;qBANK,gBAAgB;yBADjC,oBAAoB;sBASvB,gBAAgB;0BACZ,oBAAoB;sBALxB,wBAAwB;oBAF1B,sBAAsB"}
+{"version":3,"file":"gridChild.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridChild.js"],"names":[],"mappings":"AAu0BA;;;;;GAKG;AACH,qDALW,OAAO,yBAAyB,EAAE,uBAAuB,CAAC,MAAM,CAAC,sBACjE,OAAO,aACP,MAAM,GACJ,OAAO,yBAAyB,EAAE,WAAW,GAAG,SAAS,CAyBrE;AAcD;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA6BjD;AAED;;;GAGG;AACH,uDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA4CjD;AAx6BD;IACI;;;;;;OAMG;IAEH;;;;OAIG;IACH,kBAJW,OAAO,YAAY,EAAE,OAAO,gBAC5B,OAAO,qBAAqB,EAAE,OAAO,UACrC,MAAM,EAgGhB;IA7FG,gGAAgC;IAChC,0EAAgB;IAChB,eAAoB;IAEpB,uBAAuB;IACvB,YADW,QAAQ,CACQ;IAE3B,uBAAuB;IACvB,kBADW,QAAQ,CACc;IAEjC,sFAAsF;IACtF,MADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAC/D;IAEd,+FAA+F;IAC/F,WADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAC9D;IAEnB,mFAAmF;IACnF,YADW,OAAO,CAAC,MAAM,CAAC,OAAO,gBAAgB,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC,CAC3D;IAEpB,4BAA4B;IAC5B,eADW,aAAa,CACM;IAE9B,uBAAuB;IACvB,OADW,QAAQ,CACG;IAEtB,wBAAwB;IACxB,QADW,SAAS,CACQ;IAyhBhC,6GAiBC;IAED;;OAEG;IACH,4BAwKC;IAED;;OAEG;IACH,yBAWC;IAED,uBAqBC;IAED,iCAEC;;CACJ;qBApzBoB,gBAAgB;qBANK,gBAAgB;yBADjC,oBAAoB;sBASvB,gBAAgB;0BACZ,oBAAoB;sBALxB,wBAAwB;oBAF1B,sBAAsB"}

package/dist/src/view/gridView/gridChild.js

@@ -1,11 +1,13 @@
 import { isContinuous } from "vega-scale";
 import {
+    asEventConfig,
     asSelectionConfig,
     createIntervalSelection,
     isActiveIntervalSelection,
     isIntervalSelectionConfig,
     selectionContainsPoint,
 } from "../../selection/selection.js";
+import { createPrimitiveEventProxy } from "../../utils/interactionEvent.js";
 import AxisGridView from "../axisGridView.js";
 import AxisView, { CHANNEL_ORIENTS } from "../axisView.js";
 import LayerView from "../layerView.js";
@@ -17,6 +19,9 @@ import UnitView from "../unitView.js";
 import { markViewAsNonAddressable } from "../viewSelectors.js";
 import Scrollbar from "./scrollbar.js";
 import SelectionRect from "./selectionRect.js";
+import { normalizeIntervalForSelection } from "../../scales/selectionDomainUtils.js";
+import { zoomDomainByScaleType } from "../../scales/zoomDomainUtils.js";
+import { createEventFilterFunction } from "../../utils/expression.js";
 
 export default class GridChild {
     /**
@@ -164,6 +169,42 @@ export default class GridChild {
                 })
             );
 
+            const requiresShiftToBrush = channels.some((channel) =>
+                scaleResolutions[channel].isZoomable()
+            );
+
+            const eventConfig =
+                /** @type {import("../../spec/parameter.js").EventConfig} */ (
+                    select.on ??
+                        (requiresShiftToBrush
+                            ? {
+                                  type: "mousedown",
+                                  filter: "event.shiftKey",
+                              }
+                            : {
+                                  type: "mousedown",
+                              })
+                );
+
+            if (eventConfig.type !== "mousedown") {
+                throw new Error(
+                    `Interval selection param "${name}" currently supports only "mousedown" in "on".`
+                );
+            }
+
+            const eventPredicate = eventConfig.filter
+                ? createEventFilterFunction(eventConfig.filter)
+                : () => true;
+
+            const zoomEventConfig = resolveIntervalZoomEventConfig(
+                select.zoom,
+                requiresShiftToBrush,
+                name
+            );
+            const zoomEventPredicate = zoomEventConfig?.filter
+                ? createEventFilterFunction(zoomEventConfig.filter)
+                : () => true;
+
             if (this.selectionRect) {
                 throw new Error(
                     "Only one interval selection per container is currently allowed!"
@@ -304,7 +345,9 @@ export default class GridChild {
                         preventNextClickPropagation = true;
                     }
 
-                    const startSelection = event.mouseEvent.shiftKey;
+                    const startSelection = eventPredicate(
+                        event.proxiedMouseEvent
+                    );
 
                     if (startSelection) {
                         clearSelection();
@@ -373,15 +416,9 @@ export default class GridChild {
 
                     for (const channel of channels) {
                         const scaleResolution = scaleResolutions[channel];
-                        const { zoomExtent, scale } = scaleResolution;
+                        const { zoomExtent } = scaleResolution;
                         const interval = intervals[channel];
 
-                        if (["index", "locus"].includes(scale.type)) {
-                            // These scales use integer values. Need to round them.
-                            interval[0] = Math.ceil(interval[0]);
-                            interval[1] = Math.ceil(interval[1]);
-                        }
-
                         if (translatedRectangle) {
                             // When dragging, clamp the interval so that the size stays the same and the interval doesn't exceed zoomExtent
                             const size = interval[1] - interval[0];
@@ -398,11 +435,20 @@ export default class GridChild {
                                 interval[1] = max;
                                 interval[0] = max - size;
                             }
+                        }
+
+                        const normalized = normalizeIntervalForChannel(
+                            scaleResolution,
+                            interval
+                        );
+
+                        if (!normalized) {
+                            interval[0] = zoomExtent[0];
+                            interval[1] = zoomExtent[0];
                         } else {
-                            interval[0] = Math.max(zoomExtent[0], interval[0]);
-                            interval[1] = Math.min(zoomExtent[1], interval[1]);
+                            interval[0] = normalized[0];
+                            interval[1] = normalized[1];
                         }
-                        interval[1] = Math.min(zoomExtent[1], interval[1]);
                     }
 
                     setter({ type: "interval", intervals });
@@ -454,6 +500,86 @@ export default class GridChild {
                 true
             );
 
+            view.addInteractionEventListener("wheel", (coords, event) => {
+                const wheelEvent = event.uiEvent;
+                if (!(wheelEvent instanceof WheelEvent)) {
+                    return;
+                }
+
+                if (
+                    !zoomEventConfig ||
+                    !zoomEventPredicate(createPrimitiveEventProxy(wheelEvent))
+                ) {
+                    return;
+                }
+
+                if (
+                    Math.abs(wheelEvent.deltaX) >= Math.abs(wheelEvent.deltaY)
+                ) {
+                    return;
+                }
+                if (!isPointInsideSelection(event.point)) {
+                    return;
+                }
+
+                const selection = selectionExpr();
+                if (!isActiveIntervalSelection(selection)) {
+                    return;
+                }
+
+                const wheelMultiplier = wheelEvent.deltaMode ? 120 : 1;
+                const scaleFactor =
+                    2 ** ((wheelEvent.deltaY * wheelMultiplier) / 300);
+
+                const anchor = invertPoint(event.point);
+                /** @type {typeof selection.intervals} */
+                const intervals = { ...selection.intervals };
+                let changed = false;
+
+                for (const channel of channels) {
+                    const currentInterval = intervals[channel];
+                    if (!currentInterval || currentInterval.length !== 2) {
+                        continue;
+                    }
+
+                    const scaleResolution = scaleResolutions[channel];
+                    const scale = scaleResolution.getScale();
+                    const zoomed = zoomDomainByScaleType(
+                        scale,
+                        /** @type {[number, number]} */ ([...currentInterval]),
+                        anchor[channel],
+                        scaleFactor,
+                        { onUnsupported: "identity" }
+                    );
+
+                    const normalized = normalizeIntervalForChannel(
+                        scaleResolution,
+                        zoomed
+                    );
+                    if (!normalized) {
+                        continue;
+                    }
+
+                    if (
+                        normalized[0] !== currentInterval[0] ||
+                        normalized[1] !== currentInterval[1]
+                    ) {
+                        intervals[channel] = normalized;
+                        changed = true;
+                    }
+                }
+
+                if (changed) {
+                    setter({
+                        ...selection,
+                        type: "interval",
+                        intervals,
+                    });
+                    wheelEvent.preventDefault();
+                    event.stopPropagation();
+                }
+            });
+
             // Handle mouse cursor changes
             view.addInteractionEventListener("mousemove", (coords, event) => {
                 if (isPointInsideSelection(event.point)) {
@@ -711,6 +837,49 @@ export default class GridChild {
     }
 }
 
+/**
+ * @param {import("../../spec/parameter.js").IntervalSelectionConfig["zoom"]} zoom
+ * @param {boolean} hasZoomableChannel
+ * @param {string} paramName
+ * @returns {import("../../spec/parameter.js").EventConfig | undefined}
+ */
+export function resolveIntervalZoomEventConfig(
+    zoom,
+    hasZoomableChannel,
+    paramName
+) {
+    const defaultEnabled = !hasZoomableChannel;
+    const resolved = zoom === undefined ? defaultEnabled : zoom;
+    if (resolved === false) {
+        return;
+    }
+
+    if (resolved === true) {
+        return { type: "wheel" };
+    }
+
+    const eventConfig = asEventConfig(resolved);
+    if (eventConfig.type !== "wheel") {
+        throw new Error(
+            `Interval selection param "${paramName}" currently supports only "wheel" in "zoom".`
+        );
+    }
+
+    return eventConfig;
+}
+
+/**
+ * @param {import("../../scales/scaleResolution.js").default} scaleResolution
+ * @param {[number, number]} interval
+ * @returns {[number, number] | undefined}
+ */
+function normalizeIntervalForChannel(scaleResolution, interval) {
+    const scale = scaleResolution.getScale();
+    return normalizeIntervalForSelection(interval, scaleResolution.zoomExtent, {
+        roundToIntegers: scale.type === "index" || scale.type === "locus",
+    });
+}
+
 /**
  * @param {import("../../spec/view.js").ViewBackground} viewBackground
  * @returns {import("../../spec/view.js").UnitSpec}

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

@@ -1 +1 @@
-{"version":3,"file":"gridView.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridView.js"],"names":[],"mappings":"AAu8BA;;GAEG;AACH,sHAUC;AAmBD;;;;;GAKG;AACH,4CAJW,OAAO,wBAAwB,EAAE,OAAO,UACxC,OAAO,oBAAoB,EAAE,UAAU,YACvC,QAAQ,aAmBlB;AAx+BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAH2D,KAAK,SAAnD,OAAQ,oBAAoB,EAAE,aAAc;IA6CrD;;;;;;;;;OASG;IACH,kBARW,KAAK,WACL,OAAO,4BAA4B,EAAE,OAAO,gBAC5C,aAAa,yFAEb,MAAM,WACN,MAAM,YACN,OAAO,YAAY,EAAE,WAAW,EAyC1C;IAtBG,uBAA0B;IAwB9B;;OAEG;IACH,6FAEC;IAED;;;;;;OAMG;IACH,4FAFa,SAAS,CAIrB;IAED;;;;;;;OAOG;IACH,oGAHW,MAAM,GACJ,SAAS,CASrB;IAED;;;;;OAKG;IACH,iGAQC;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAUhB;IAeD;;OAEG;IACH,mBAFW,qEAAM,QAWhB;IAYD;;OAEG;IACH,sFAEC;IAED,yBAEC;IAED;;OAEG;IACH,sCAKC;IAED;;;;OAIG;IACH,gCAqCC;;CAwpBJ;qBAz7B0D,gBAAgB;sBADrD,wBAAwB;0BAEpB,qBAAqB;sBAIzB,gBAAgB"}
+{"version":3,"file":"gridView.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridView.js"],"names":[],"mappings":"AAi+BA;;GAEG;AACH,sHAUC;AAoCD;;;;;GAKG;AACH,4CAJW,OAAO,wBAAwB,EAAE,OAAO,UACxC,OAAO,oBAAoB,EAAE,UAAU,YACvC,QAAQ,aAmBlB;AAnhCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAH2D,KAAK,SAAnD,OAAQ,oBAAoB,EAAE,aAAc;IA6CrD;;;;;;;;;OASG;IACH,kBARW,KAAK,WACL,OAAO,4BAA4B,EAAE,OAAO,gBAC5C,aAAa,yFAEb,MAAM,WACN,MAAM,YACN,OAAO,YAAY,EAAE,WAAW,EAyC1C;IAtBG,uBAA0B;IAwB9B;;OAEG;IACH,6FAEC;IAED;;;;;;OAMG;IACH,4FAFa,SAAS,CAIrB;IAED;;;;;;;OAOG;IACH,oGAHW,MAAM,GACJ,SAAS,CASrB;IAED;;;;;OAKG;IACH,iGAQC;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAUhB;IAeD;;OAEG;IACH,mBAFW,qEAAM,QAWhB;IAYD;;OAEG;IACH,sFAEC;IAED,yBAEC;IAED;;OAEG;IACH,sCAKC;IAED;;;;OAIG;IACH,gCAqCC;;CAkrBJ;qBAn9B0D,gBAAgB;sBADrD,wBAAwB;0BAEpB,qBAAqB;sBAIzB,gBAAgB"}

package/dist/src/view/gridView/gridView.js

@@ -871,6 +871,26 @@ export default class GridView extends ContainerView {
         const pointedChild = this.#visibleChildren.find((gridChild) =>
             gridChild.coords.containsPoint(event.point.x, event.point.y)
         );
+        const pointedView = pointedChild?.view;
+
+        if (event.type === "wheelclaimprobe") {
+            // Probe path: claim wheel ownership without executing regular wheel
+            // behavior. InteractionController uses this to decide whether native
+            // wheel should be preventDefault()'ed before inertia kicks in.
+            if (!pointedView) {
+                return;
+            }
+
+            if (isZoomInteractionView(pointedView)) {
+                if (hasZoomableResolutions(pointedView)) {
+                    event.claimWheel();
+                }
+            } else {
+                pointedView.propagateInteractionEvent(event);
+            }
+            return;
+        }
+
         this.#keyboardZoomController?.handlePointerEvent(pointedChild, event);
 
         for (const scrollbar of Object.values(pointedChild?.scrollbars ?? {})) {
@@ -882,7 +902,6 @@ export default class GridView extends ContainerView {
             }
         }
 
-        const pointedView = pointedChild?.view;
         if (pointedView) {
             pointedView.propagateInteractionEvent(event);
 
@@ -892,10 +911,7 @@ export default class GridView extends ContainerView {
 
             // Hmm, maybe this should be registered when needed and not include
             // as a hardcoded interaction?
-            if (
-                pointedView instanceof UnitView ||
-                pointedView instanceof LayerView
-            ) {
+            if (isZoomInteractionView(pointedView)) {
                 interactionToZoom(
                     event,
                     pointedChild.coords,
@@ -923,8 +939,22 @@ export default class GridView extends ContainerView {
      * @param {import("../layout/rectangle.js").default} coords Coordinates
      * @param {View} view
      * @param {import("../zoom.js").ZoomEvent} zoomEvent
+     * @returns {boolean} `true` when there was at least one zoomable resolution
      */
     #handleZoom(coords, view, zoomEvent) {
+        let zoomable = false;
+        let changed = false;
+
+        const p = coords.normalizePoint(zoomEvent.x, zoomEvent.y);
+        const tp = coords.normalizePoint(
+            zoomEvent.x + zoomEvent.xDelta,
+            zoomEvent.y + zoomEvent.yDelta
+        );
+        const delta = {
+            x: tp.x - p.x,
+            y: tp.y - p.y,
+        };
+
         for (const [channel, resolutionSet] of Object.entries(
             getZoomableResolutions(view)
         )) {
@@ -932,27 +962,23 @@ export default class GridView extends ContainerView {
                 continue;
             }
 
-            const p = coords.normalizePoint(zoomEvent.x, zoomEvent.y);
-            const tp = coords.normalizePoint(
-                zoomEvent.x + zoomEvent.xDelta,
-                zoomEvent.y + zoomEvent.yDelta
-            );
-
-            const delta = {
-                x: tp.x - p.x,
-                y: tp.y - p.y,
-            };
+            zoomable = true;
 
             for (const resolution of resolutionSet) {
-                resolution.zoom(
+                const resolutionChanged = resolution.zoom(
                     2 ** zoomEvent.zDelta,
                     channel == "y" ? 1 - p[channel] : p[channel],
                     channel == "x" ? delta.x : -delta.y
                 );
+                changed = resolutionChanged || changed;
             }
         }
 
-        this.context.animator.requestRender();
+        if (changed) {
+            this.context.animator.requestRender();
+        }
+
+        return zoomable;
     }
 
     /**
@@ -980,6 +1006,23 @@ export function isClippedChildren(view) {
     return clipped;
 }
 
+/**
+ * @param {View} view
+ * @returns {boolean}
+ */
+function hasZoomableResolutions(view) {
+    const zoomableResolutions = getZoomableResolutions(view);
+    return zoomableResolutions.x.size > 0 || zoomableResolutions.y.size > 0;
+}
+
+/**
+ * @param {View} view
+ * @returns {view is UnitView | LayerView}
+ */
+function isZoomInteractionView(view) {
+    return view instanceof UnitView || view instanceof LayerView;
+}
+
 /**
  * @param {import("../../spec/view.js").AnyConcatSpec} spec
  * @returns {("horizontal" | "vertical")[]}

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

@@ -21,7 +21,7 @@ export default class UnitView<TSpec extends import("../spec/view.js").UnitSpec =
     constructor(spec: TSpec, context: import("../types/viewContext.js").default, layoutParent: import("./containerView.js").default, dataParent: import("./view.js").default, name: string, options?: import("./view.js").ViewOptions);
     /** @type {import("../marks/mark.js").default} */
     mark: import("../marks/mark.js").default;
-    getMarkType(): "link" | "rect" | "text" | "point" | "rule";
+    getMarkType(): "link" | "point" | "text" | "rect" | "rule";
     /**
      * Pulls scales and axes up in the view hierarcy according to the resolution rules, using dataParents.
      * TODO: legends

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

@@ -3,11 +3,11 @@ export function isStillZooming(): boolean;
 /**
  * @param {import("../utils/interactionEvent.js").default} event
  * @param {import("./layout/rectangle.js").default} coords
- * @param {(zoomEvent: ZoomEvent) => void} handleZoom
+ * @param {(zoomEvent: ZoomEvent) => boolean | void} handleZoom
  * @param {import("../types/viewContext.js").Hover} [hover]
  * @param {import("../utils/animator.js").default} [animator]
  */
-export function interactionToZoom(event: import("../utils/interactionEvent.js").default, coords: import("./layout/rectangle.js").default, handleZoom: (zoomEvent: ZoomEvent) => void, hover?: import("../types/viewContext.js").Hover, animator?: import("../utils/animator.js").default): void;
+export function interactionToZoom(event: import("../utils/interactionEvent.js").default, coords: import("./layout/rectangle.js").default, handleZoom: (zoomEvent: ZoomEvent) => boolean | void, hover?: import("../types/viewContext.js").Hover, animator?: import("../utils/animator.js").default): void;
 export type ZoomEvent = {
     x: number;
     y: number;
@@ -15,4 +15,16 @@ export type ZoomEvent = {
     yDelta: number;
     zDelta: number;
 };
+export type ZoomInteractionState = {
+    smoother: ReturnType<typeof makeLerpSmoother>;
+    touchPanEventBuffer: RingBuffer<{
+        point: Point;
+        timestamp: number;
+    }>;
+    touchPanLastPoint: Point | undefined;
+    touchPanPointerCount: 0 | 1 | 2;
+};
+import { makeLerpSmoother } from "../utils/animator.js";
+import RingBuffer from "../utils/ringBuffer.js";
+import Point from "./layout/point.js";
 //# sourceMappingURL=zoom.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"zoom.d.ts","sourceRoot":"","sources":["../../../src/view/zoom.js"],"names":[],"mappings":"AAkBA,yCAEC;AAED,0CAGC;AAgBD;;;;;;GAMG;AACH,yCANW,OAAO,8BAA8B,EAAE,OAAO,UAC9C,OAAO,uBAAuB,EAAE,OAAO,cACvC,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,UAC9B,OAAO,yBAAyB,EAAE,KAAK,aACvC,OAAO,sBAAsB,EAAE,OAAO,QA+IhD;;OA3LS,MAAM;OACN,MAAM;YACN,MAAM;YACN,MAAM;YACN,MAAM"}
+{"version":3,"file":"zoom.d.ts","sourceRoot":"","sources":["../../../src/view/zoom.js"],"names":[],"mappings":"AAgCA,yCAEC;AAED,0CAGC;AAgBD;;;;;;GAMG;AACH,yCANW,OAAO,8BAA8B,EAAE,OAAO,UAC9C,OAAO,uBAAuB,EAAE,OAAO,cACvC,CAAC,SAAS,EAAE,SAAS,KAAK,OAAO,GAAG,IAAI,UACxC,OAAO,yBAAyB,EAAE,KAAK,aACvC,OAAO,sBAAsB,EAAE,OAAO,QA8LhD;;OAxPS,MAAM;OACN,MAAM;YACN,MAAM;YACN,MAAM;YACN,MAAM;;;cAUN,UAAU,CAAC,OAAO,gBAAgB,CAAC;yBACnC,UAAU,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAC;uBAC7C,KAAK,GAAG,SAAS;0BACjB,CAAC,GAAG,CAAC,GAAG,CAAC;;iCAVc,sBAAsB;uBAChC,wBAAwB;kBAE7B,mBAAmB"}