@genome-spy/core 0.67.0 → 0.68.0

package/dist/src/scale/scale.js

@@ -11,8 +11,20 @@
 /* eslint-disable */
 // @ts-nocheck
 
-// This file is a mess
-// TODO: Fix types, etc.
+/*
+ * Rewrite rationale (non-perf):
+ * - This module mixes spec-level policy, vega-scale helpers, and D3 scale
+ *   mutability. The combination works but is clunky to maintain and hard to
+ *   integrate with higher-level orchestration like ScaleResolution.
+ * - Side-effectful configuration and implicit defaults make the data flow
+ *   difficult to reason about and to test in isolation.
+ *
+ * Why not rewrite yet:
+ * - Behavior is subtle and well-tested; a rewrite is risky without a clear
+ *   contract for the pure inputs/outputs and their callers.
+ * - It depends on D3 scale semantics (copy, unknown, interpolate, etc.), so any
+ *   refactor must preserve those semantics explicitly.
+ */
 
 import { tickCount } from "./ticks.js";
 import {
@@ -128,11 +140,15 @@ export function configureScale(_, scale, logger) {
         }
     }
 
-    configureRange(
-        scale,
-        _,
-        configureBins(scale, _, configureDomain(scale, _, logger))
-    );
+    const domainConfig = configureDomain(scale, _, logger);
+    if (domainConfig.domain) {
+        scale.domain(domainConfig.domain);
+    }
+    if (domainConfig.applyOrdinalUnknown) {
+        scale.unknown(domainConfig.ordinalUnknown);
+    }
+
+    configureRange(scale, _, configureBins(scale, _, domainConfig.count));
 }
 
 /**
@@ -191,24 +207,62 @@ function isContinuousColor(_) {
     );
 }
 
+function copyScaleForDomain(scale) {
+    if (!scale.copy) {
+        return scale;
+    }
+
+    const copy = scale.copy();
+    if (copy.type == null && scale.type != null) {
+        copy.type = scale.type;
+    }
+    return copy;
+}
+
 export function configureDomain(scale, _, logger) {
     if (!scale.domain) {
-        return 0;
+        return {
+            domain: null,
+            count: 0,
+            ordinalUnknown: undefined,
+            applyOrdinalUnknown: false,
+        };
     }
 
     logger = ensureLogger(logger);
 
+    const workingScale = copyScaleForDomain(scale);
+
     // check raw domain, if provided use that and exit early
-    var raw = rawDomain(scale, _.domainRaw, logger);
-    if (raw > -1) return raw;
+    var raw = rawDomain(workingScale, _.domainRaw, logger);
+    if (raw > -1) {
+        return {
+            domain: workingScale.domain(),
+            count: raw,
+            ordinalUnknown:
+                workingScale.type === Ordinal
+                    ? _.domainImplicit
+                        ? scaleImplicit
+                        : undefined
+                    : undefined,
+            applyOrdinalUnknown: false,
+        };
+    }
 
     var domain = _.domain,
-        type = scale.type,
-        zero = _.zero || (_.zero === undefined && includeZero(scale)),
+        type = workingScale.type,
+        zero = _.zero || (_.zero === undefined && includeZero(workingScale)),
         n,
         mid;
 
-    if (!domain) return 0;
+    if (!domain) {
+        return {
+            domain: null,
+            count: 0,
+            ordinalUnknown: undefined,
+            applyOrdinalUnknown: false,
+        };
+    }
 
     // adjust continuous domain for minimum pixel padding
     if (includePad(type) && _.padding && domain[0] !== peek(domain)) {
@@ -247,21 +301,27 @@ export function configureDomain(scale, _, logger) {
     }
 
     // set the scale domain
-    scale.domain(domainCheck(type, domain, logger));
-
-    // if ordinal scale domain is defined, prevent implicit
-    // domain construction as side-effect of scale lookup
-    if (type === Ordinal) {
-        scale.unknown(_.domainImplicit ? scaleImplicit : undefined);
-    }
+    workingScale.domain(domainCheck(type, domain, logger));
 
     // perform 'nice' adjustment as requested
-    if (_.nice && scale.nice) {
-        scale.nice((_.nice !== true && tickCount(scale, _.nice)) || null);
+    if (_.nice && workingScale.nice) {
+        workingScale.nice(
+            (_.nice !== true && tickCount(workingScale, _.nice)) || null
+        );
     }
 
     // return the cardinality of the domain
-    return domain.length;
+    return {
+        domain: workingScale.domain(),
+        count: domain.length,
+        ordinalUnknown:
+            type === Ordinal
+                ? _.domainImplicit
+                    ? scaleImplicit
+                    : undefined
+                : undefined,
+        applyOrdinalUnknown: type === Ordinal,
+    };
 }
 
 function rawDomain(scale, raw, logger) {

package/dist/src/scales/axisResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axisResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/axisResolution.js"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH;IASI;;OAEG;IACH,qBAFW,OAAO,oBAAoB,EAAE,wBAAwB,EAI/D;IADG,+DAAsB;IAG1B,2BAGC;IAiCD;;;OAGG;IACH,uBAHW,oBAAoB,GAClB,MAAM,OAAO,CAQzB;IAED;;;OAGG;IACH,qBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED,qDAuBC;IAED,mBAyDC;;CACJ;iCAtK6D,CAAC,SAAlD,OAAQ,oBAAoB,EAAE,iBAAkB;UAGnD,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB"}
+{"version":3,"file":"axisResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/axisResolution.js"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH;IASI;;OAEG;IACH,qBAFW,OAAO,oBAAoB,EAAE,wBAAwB,EAI/D;IADG,+DAAsB;IAG1B,2BAGC;IAiCD;;;OAGG;IACH,uBAHW,oBAAoB,GAClB,MAAM,OAAO,CAQzB;IAED;;;OAGG;IACH,qBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED,qDAuBC;IAED,mBAmEC;;CACJ;iCAhL6D,CAAC,SAAlD,OAAQ,oBAAoB,EAAE,iBAAkB;UAGnD,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB"}

package/dist/src/scales/axisResolution.js

@@ -137,6 +137,9 @@ export default class AxisResolution {
 
             return {
                 member,
+                axisTitle:
+                    // TODO: Proper type guard
+                    "axis" in channelDef ? channelDef.axis?.title : undefined,
                 explicitTitle: coalesce(
                     // TODO: Proper type guard
                     "axis" in channelDef ? channelDef.axis?.title : undefined,
@@ -150,6 +153,13 @@ export default class AxisResolution {
         };
 
         const titles = Array.from(this.#members).map(computeTitle);
+        const explicitAxisTitle = titles
+            .map((title) => title.axisTitle)
+            .find((title) => title !== undefined);
+
+        if (explicitAxisTitle !== undefined) {
+            return explicitAxisTitle;
+        }
 
         // Skip implicit secondary channel titles if the primary channel has an explicit title
         const filteredTitles = titles.filter((title) => {

package/dist/src/scales/{scaleDomainAggregator.d.ts → domainPlanner.d.ts}

@@ -4,16 +4,18 @@
  * @typedef {import("../spec/scale.js").ScalarDomain} ScalarDomain
  * @typedef {import("./scaleResolution.js").ScaleResolutionMember} ScaleResolutionMember
  */
-export default class ScaleDomainAggregator {
+export default class DomainPlanner {
     /**
      * @param {object} options
      * @param {() => Set<ScaleResolutionMember>} options.getMembers
+     * @param {() => Set<ScaleResolutionMember>} [options.getDataMembers]
      * @param {() => import("../spec/channel.js").Type} options.getType
      * @param {() => number[]} options.getLocusExtent
      * @param {(interval: ScalarDomain | ComplexDomain) => number[]} options.fromComplexInterval
      */
-    constructor({ getMembers, getType, getLocusExtent, fromComplexInterval }: {
+    constructor({ getMembers, getDataMembers, getType, getLocusExtent, fromComplexInterval, }: {
         getMembers: () => Set<ScaleResolutionMember>;
+        getDataMembers?: () => Set<ScaleResolutionMember>;
         getType: () => import("../spec/channel.js").Type;
         getLocusExtent: () => number[];
         fromComplexInterval: (interval: ScalarDomain | ComplexDomain) => number[];
@@ -23,6 +25,7 @@ export default class ScaleDomainAggregator {
      */
     get initialDomainSnapshot(): any[];
     hasConfiguredDomain(): boolean;
+    invalidateConfiguredDomain(): void;
     /**
      * Returns the configured domain or a data-derived/default domain.
      *
@@ -54,4 +57,4 @@ export type DomainArray = import("../utils/domainArray.js").DomainArray;
 export type ComplexDomain = import("../spec/scale.js").ComplexDomain;
 export type ScalarDomain = import("../spec/scale.js").ScalarDomain;
 export type ScaleResolutionMember = import("./scaleResolution.js").ScaleResolutionMember;
-//# sourceMappingURL=scaleDomainAggregator.d.ts.map
+//# sourceMappingURL=domainPlanner.d.ts.map

package/dist/src/scales/domainPlanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domainPlanner.d.ts","sourceRoot":"","sources":["../../../src/scales/domainPlanner.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH;IA2BI;;;;;;;OAOG;IACH,2FANG;QAAkD,UAAU,EAApD,MAAM,GAAG,CAAC,qBAAqB,CAAC;QACW,cAAc,GAAzD,MAAM,GAAG,CAAC,qBAAqB,CAAC;QACiB,OAAO,EAAxD,MAAM,OAAO,oBAAoB,EAAE,IAAI;QACf,cAAc,EAAtC,MAAM,MAAM,EAAE;QACgD,mBAAmB,EAAjF,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,KAAK,MAAM,EAAE;KAC9D,EAaA;IAED;;OAEG;IACH,6BAFa,GAAG,EAAE,CAIjB;IAED,+BAEC;IAED,mCAEC;IAED;;;;;OAKG;IACH,iDAHW,OAAO,GACL,GAAG,EAAE,CAYjB;IAED;;;;OAIG;IACH,uBAFY,WAAW,CActB;IAED;;;;OAIG;IACH,iBAFY,WAAW,GAAG,SAAS,CAQlC;IAED;;;;OAIG;IACH,4BAJW,OAAO,qBAAqB,EAAE,SAAS,wBACvC,OAAO,GACL,OAAO,CAgBnB;;CAkCJ;0BA7KY,OAAO,yBAAyB,EAAE,WAAW;4BAC7C,OAAO,kBAAkB,EAAE,aAAa;2BACxC,OAAO,kBAAkB,EAAE,YAAY;oCACvC,OAAO,sBAAsB,EAAE,qBAAqB"}

package/dist/src/scales/{scaleDomainAggregator.js → domainPlanner.js}

@@ -3,6 +3,7 @@ import { isContinuous } from "vega-scale";
 
 import { LOCUS } from "./scaleResolutionConstants.js";
 import createDomain from "../utils/domainArray.js";
+import { getAccessorDomainKey, isScaleAccessor } from "../encoder/accessor.js";
 
 /**
  * @typedef {import("../utils/domainArray.js").DomainArray} DomainArray
@@ -11,10 +12,13 @@ import createDomain from "../utils/domainArray.js";
  * @typedef {import("./scaleResolution.js").ScaleResolutionMember} ScaleResolutionMember
  */
 
-export default class ScaleDomainAggregator {
+export default class DomainPlanner {
     /** @type {() => Set<ScaleResolutionMember>} */
     #getMembers;
 
+    /** @type {() => Set<ScaleResolutionMember>} */
+    #getDataMembers;
+
     /** @type {() => import("../spec/channel.js").Type} */
     #getType;
 
@@ -27,15 +31,31 @@ export default class ScaleDomainAggregator {
     /** @type {any[]} */
     #initialDomain;
 
+    /** @type {DomainArray | undefined} */
+    #configuredDomain;
+
+    #configuredDomainDirty = true;
+
+    /** @type {WeakMap<ScaleResolutionMember, import("../types/encoder.js").ScaleAccessor[]>} */
+    #accessorsByMember = new WeakMap();
+
     /**
      * @param {object} options
      * @param {() => Set<ScaleResolutionMember>} options.getMembers
+     * @param {() => Set<ScaleResolutionMember>} [options.getDataMembers]
      * @param {() => import("../spec/channel.js").Type} options.getType
      * @param {() => number[]} options.getLocusExtent
      * @param {(interval: ScalarDomain | ComplexDomain) => number[]} options.fromComplexInterval
      */
-    constructor({ getMembers, getType, getLocusExtent, fromComplexInterval }) {
+    constructor({
+        getMembers,
+        getDataMembers,
+        getType,
+        getLocusExtent,
+        fromComplexInterval,
+    }) {
         this.#getMembers = getMembers;
+        this.#getDataMembers = getDataMembers ?? getMembers;
         this.#getType = getType;
         this.#getLocusExtent = getLocusExtent;
         this.#fromComplexInterval = fromComplexInterval;
@@ -52,6 +72,10 @@ export default class ScaleDomainAggregator {
         return !!this.getConfiguredDomain();
     }
 
+    invalidateConfiguredDomain() {
+        this.#configuredDomainDirty = true;
+    }
+
     /**
      * Returns the configured domain or a data-derived/default domain.
      *
@@ -76,10 +100,17 @@ export default class ScaleDomainAggregator {
      * @return {DomainArray}
      */
     getConfiguredDomain() {
-        return resolveConfiguredDomain(
+        if (!this.#configuredDomainDirty) {
+            return this.#configuredDomain;
+        }
+
+        const domain = resolveConfiguredDomain(
             this.#getMembers(),
             this.#fromComplexInterval
         );
+        this.#configuredDomain = domain;
+        this.#configuredDomainDirty = false;
+        return domain;
     }
 
     /**
@@ -88,7 +119,11 @@ export default class ScaleDomainAggregator {
      * @return {DomainArray | undefined}
      */
     getDataDomain() {
-        return resolveDataDomain(this.#getMembers(), this.#getType);
+        return resolveDataDomain(
+            this.#getDataMembers(),
+            this.#getType,
+            (member) => this.#getMemberAccessors(member)
+        );
     }
 
     /**
@@ -111,6 +146,39 @@ export default class ScaleDomainAggregator {
 
         return false;
     }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     * @returns {import("../types/encoder.js").ScaleAccessor[]}
+     */
+    #getMemberAccessors(member) {
+        const cached = this.#accessorsByMember.get(member);
+        if (cached) {
+            return cached;
+        }
+
+        const encoders = member.view.mark.encoders;
+        if (!encoders) {
+            return [];
+        }
+
+        const encoder = encoders[member.channel];
+        if (!encoder) {
+            return [];
+        }
+
+        const accessors = encoder.accessors ?? [];
+        if (accessors.length === 0) {
+            return [];
+        }
+
+        const scaleAccessors = accessors
+            .filter(isScaleAccessor)
+            .filter((accessor) => !accessor.channelDef.domainInert);
+
+        this.#accessorsByMember.set(member, scaleAccessors);
+        return scaleAccessors;
+    }
 }
 
 /**
@@ -120,6 +188,7 @@ export default class ScaleDomainAggregator {
  */
 function resolveConfiguredDomain(members, fromComplexInterval) {
     const domains = Array.from(members)
+        .filter((member) => member.contributesToDomain)
         .map((member) => member.channelDef)
         .filter((channelDef) => channelDef.scale?.domain)
         .map((channelDef) =>
@@ -139,18 +208,67 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
 /**
  * @param {Set<ScaleResolutionMember>} members
  * @param {() => import("../spec/channel.js").Type} getType
+ * @param {(member: ScaleResolutionMember) => import("../types/encoder.js").ScaleAccessor[]} getAccessorsForMember
  * @returns {DomainArray | undefined}
  */
-function resolveDataDomain(members, getType) {
-    const domains = Array.from(members)
-        .map((member) => member.dataDomainSource?.(member.channel, getType()))
-        .filter((domain) => !!domain);
+function resolveDataDomain(members, getType, getAccessorsForMember) {
+    const type = getType();
+
+    /** @type {Map<import("../data/collector.js").default | null, Map<string, DomainArray>>} */
+    const domainsByCollector = new Map();
+
+    for (const member of members) {
+        if (!member.contributesToDomain) {
+            continue;
+        }
+
+        const accessors = getAccessorsForMember(member);
+        if (accessors.length === 0) {
+            continue;
+        }
+
+        const collector = member.view.getCollector();
+
+        for (const accessor of accessors) {
+            const domainKey = getAccessorDomainKey(accessor, type);
+
+            const collectorKey = collector ?? null;
+            let domainsForCollector = domainsByCollector.get(collectorKey);
+            if (!domainsForCollector) {
+                domainsForCollector = new Map();
+                domainsByCollector.set(collectorKey, domainsForCollector);
+            }
 
-    if (domains.length === 0) {
+            if (domainsForCollector.has(domainKey)) {
+                continue;
+            }
+
+            let domain;
+            if (collector) {
+                domain = collector.getDomain(domainKey, type, accessor);
+            } else if (accessor.constant) {
+                domain = createDomain(type);
+                domain.extend(accessor({}));
+            } else {
+                continue;
+            }
+
+            domainsForCollector.set(domainKey, domain);
+        }
+    }
+
+    if (domainsByCollector.size === 0) {
         return undefined;
     }
 
-    return domains.reduce((acc, curr) => acc.extendAll(curr));
+    const domain = createDomain(type);
+    for (const domainsForCollector of domainsByCollector.values()) {
+        for (const memberDomain of domainsForCollector.values()) {
+            domain.extendAll(memberDomain);
+        }
+    }
+
+    return domain;
 }
 
 /**

package/dist/src/scales/domainPlanner.test.d.ts

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

package/dist/src/scales/domainPlanner.test.d.ts.map

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

package/dist/src/scales/scaleInteractionController.d.ts

@@ -27,6 +27,12 @@ export default class ScaleInteractionController {
     getZoomExtent(): number[];
     isZoomable(): boolean;
     isZoomingSupported(): boolean;
+    /**
+     * @param {number[]} previousDomain
+     * @param {number[]} newDomain
+     * @returns {"restore" | "animate" | "notify" | "none"}
+     */
+    getDomainChangeAction(previousDomain: number[], newDomain: number[]): "restore" | "animate" | "notify" | "none";
     /**
      * Return true if the scale is zoomable and the current domain differs from the initial domain.
      *

package/dist/src/scales/scaleInteractionController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleInteractionController.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInteractionController.js"],"names":[],"mappings":"AAmBA;;;;;;;GAOG;AAEH;IAmBI;;;;;;;;OAQG;IACH,wHAPG;QAAsC,QAAQ,EAAtC,MAAM,cAAc;QACkC,WAAW,EAAjE,MAAM,OAAO,sBAAsB,EAAE,OAAO;QACpB,wBAAwB,EAAhD,MAAM,MAAM,EAAE;QACU,cAAc,EAAtC,MAAM,MAAM,EAAE;QAC8C,mBAAmB,EAA/E,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,KAAK,MAAM,EAAE;QAC1B,eAAe,EAAvC,MAAM,MAAM,EAAE;KACxB,EAeA;IAED,0BAUC;IAED,sBAEC;IAED,8BAEC;IAED;;;;OAIG;IACH,oBAQC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CA2BnB;IAED;;;;;;OAMG;IACH,eAJW,aAAa,GAAG,aAAa,aAC7B,OAAO,GAAG,MAAM,iBAuD1B;IAED;;;;OAIG;IACH,qBAcC;IAED;;OAEG;IACH,uBAOC;;CACJ;4BAvNY,OAAO,kBAAkB,EAAE,aAAa;2BACxC,OAAO,kBAAkB,EAAE,YAAY;4BACvC,OAAO,kBAAkB,EAAE,aAAa;yBACxC,OAAO,kBAAkB,EAAE,UAAU;wBACrC,OAAO,qBAAqB,EAAE,SAAS;6BACvC,SAAS,GAAG;IAAE,KAAK,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAA;CAAE"}
+{"version":3,"file":"scaleInteractionController.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInteractionController.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AAEH;IAsBI;;;;;;;;OAQG;IACH,wHAPG;QAAsC,QAAQ,EAAtC,MAAM,cAAc;QACkC,WAAW,EAAjE,MAAM,OAAO,sBAAsB,EAAE,OAAO;QACpB,wBAAwB,EAAhD,MAAM,MAAM,EAAE;QACU,cAAc,EAAtC,MAAM,MAAM,EAAE;QAC8C,mBAAmB,EAA/E,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,KAAK,MAAM,EAAE;QAC1B,eAAe,EAAvC,MAAM,MAAM,EAAE;KACxB,EAeA;IAED,0BAUC;IAED,sBAEC;IAED,8BAGC;IAED;;;;OAIG;IACH,sCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAarD;IAED;;;;OAIG;IACH,oBAQC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CA2BnB;IAED;;;;;;OAMG;IACH,eAJW,aAAa,GAAG,aAAa,aAC7B,OAAO,GAAG,MAAM,iBA+D1B;IASD;;;;OAIG;IACH,qBAcC;IAED;;OAEG;IACH,uBAOC;;CACJ;4BA5PY,OAAO,kBAAkB,EAAE,aAAa;2BACxC,OAAO,kBAAkB,EAAE,YAAY;4BACvC,OAAO,kBAAkB,EAAE,aAAa;yBACxC,OAAO,kBAAkB,EAAE,UAAU;wBACrC,OAAO,qBAAqB,EAAE,SAAS;6BACvC,SAAS,GAAG;IAAE,KAAK,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAA;CAAE"}

package/dist/src/scales/scaleInteractionController.js

@@ -11,11 +11,12 @@ import {
     zoomLog,
     zoomPow,
 } from "vega-util";
-import { isContinuous } from "vega-scale";
+import { isContinuous, isDiscrete } from "vega-scale";
 import { easeCubicInOut } from "d3-ease";
 
 import eerp from "../utils/eerp.js";
 import { shallowArrayEquals } from "../utils/arrayUtils.js";
+import { createCancelToken } from "../utils/transition.js";
 
 /**
  * @typedef {import("../spec/scale.js").NumericDomain} NumericDomain
@@ -45,6 +46,9 @@ export default class ScaleInteractionController {
     /** @type {() => number[]} */
     #getGenomeExtent;
 
+    /** @type {{ canceled: boolean } | null} */
+    #zoomTransitionToken = null;
+
     /**
      * @param {object} options
      * @param {() => ScaleWithProps} options.getScale
@@ -87,7 +91,26 @@ export default class ScaleInteractionController {
     }
 
     isZoomingSupported() {
-        return isContinuous(this.#getScale().type);
+        const type = this.#getScale().type;
+        return isContinuous(type) && !isDiscrete(type);
+    }
+
+    /**
+     * @param {number[]} previousDomain
+     * @param {number[]} newDomain
+     * @returns {"restore" | "animate" | "notify" | "none"}
+     */
+    getDomainChangeAction(previousDomain, newDomain) {
+        if (shallowArrayEquals(newDomain, previousDomain)) {
+            return "none";
+        }
+        if (this.isZoomable()) {
+            return "restore";
+        }
+        if (this.isZoomingSupported()) {
+            return "animate";
+        }
+        return "notify";
     }
 
     /**
@@ -178,10 +201,14 @@ export default class ScaleInteractionController {
             const ac = from[0] == to[0];
             const bc = from[1] == to[1];
 
-            // TODO: Abort possible previous transition
+            this.#cancelZoomTransition();
+            const cancelToken = createCancelToken();
+            this.#zoomTransitionToken = cancelToken;
+
             await animator.transition({
                 duration,
                 easingFunction: easeCubicInOut,
+                cancelToken,
                 onUpdate: (t) => {
                     const w = eerp(fw, tw, t);
                     const wt = fw == tw ? t : (fw - w) / (fw - tw);
@@ -194,13 +221,24 @@ export default class ScaleInteractionController {
                 },
             });
 
+            if (this.#zoomTransitionToken === cancelToken) {
+                this.#zoomTransitionToken = null;
+            }
             scale.domain(to);
         } else {
+            this.#cancelZoomTransition();
             scale.domain(to);
             animator?.requestRender();
         }
     }
 
+    #cancelZoomTransition() {
+        if (this.#zoomTransitionToken) {
+            this.#zoomTransitionToken.canceled = true;
+            this.#zoomTransitionToken = null;
+        }
+    }
+
     /**
      * Resets the current domain to the initial one
      *

package/dist/src/scales/scaleResolution.d.ts

@@ -1,18 +1,3 @@
-/**
- * Reconfigures scale domains for resolutions used by the given view(s).
- *
- * Use this for data-driven updates where only domains need refreshing.
- *
- * TODO: This should be made unnecessary. Collectors should trigger the reconfiguration
- * for those views that get their data from the collector.
- *
- * TODO: This may reconfigure channels that are not affected by the change.
- * Causes performance issues with domains that are extracted from data.
- *
- * @param {import("../view/view.js").default | import("../view/view.js").default[]} fromViews
- * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
- */
-export function reconfigureScaleDomains(fromViews: import("../view/view.js").default | import("../view/view.js").default[], viewFilter?: (view: import("../view/view.js").default) => boolean): void;
 /**
  * @template {ChannelWithScale}[T=ChannelWithScale]
  *
@@ -20,7 +5,7 @@ export function reconfigureScaleDomains(fromViews: import("../view/view.js").def
  * @prop {import("../view/unitView.js").default} view TODO: Get rid of the view reference
  * @prop {T} channel
  * @prop {import("../spec/channel.js").ChannelDefWithScale} channelDef
- * @prop {(channel: ChannelWithScale, type: import("../spec/channel.js").Type) => DomainArray} dataDomainSource
+ * @prop {boolean} contributesToDomain
  */
 /**
  * Resolves a shared scale for a channel by merging scale properties and domains
@@ -29,6 +14,16 @@ export function reconfigureScaleDomains(fromViews: import("../view/view.js").def
  * notifications, while delegating domain aggregation, scale instance setup, and
  * interaction logic to focused helpers.
  *
+ * Documentation overview of current concerns this class (and its helpers) deal with:
+ * - Resolution membership and rules (shared/independent/forced/excluded, visibility, registration).
+ * - Scale property aggregation (merge props, channel overrides, unique scale names).
+ * - Domain computation and caching (configured/data unions, defaults, indexer stability, subscriptions).
+ * - Scale instance lifecycle (create, reconfigure props, apply domains, notify changes).
+ * - Interaction and zoom (zoom/pan/reset coordination, snapshots, zoom extents).
+ * - Rendering integration (range textures, axis sizing/positioning).
+ * - Locus-specific conversions (complex intervals, genome extent bindings).
+ * - Diagnostics and edge cases (ordinal unknown, nice/zero/padding, log warnings).
+ *
  * @implements {ScaleResolutionApi}
  */
 export default class ScaleResolution implements ScaleResolutionApi {
@@ -61,6 +56,12 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * @returns {() => boolean}
      */
     registerMember(member: ScaleResolutionMember): () => boolean;
+    /**
+     * @param {import("../data/collector.js").default} collector
+     * @param {Iterable<import("../types/encoder.js").ScaleAccessor>} accessors
+     * @returns {() => void}
+     */
+    registerCollectorSubscriptions(collector: import("../data/collector.js").default, accessors: Iterable<import("../types/encoder.js").ScaleAccessor>): () => void;
     /**
      * Reconfigures the scale: updates domain and other settings.
      *
@@ -72,6 +73,7 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * Reconfigures only the effective domain (configured + data-derived).
      *
      * Use this when data changes but the scale membership and properties are stable.
+     *
      */
     reconfigureDomain(): void;
     /**
@@ -188,7 +190,7 @@ export type ScaleResolutionMember<T extends import("../spec/channel.js").Channel
     view: import("../view/unitView.js").default;
     channel: T;
     channelDef: import("../spec/channel.js").ChannelDefWithScale;
-    dataDomainSource: (channel: import("../spec/channel.js").ChannelWithScale, type: import("../spec/channel.js").Type) => import("../utils/domainArray.js").DomainArray;
+    contributesToDomain: boolean;
 };
 import { INDEX } from "./scaleResolutionConstants.js";
 import { LOCUS } from "./scaleResolutionConstants.js";

package/dist/src/scales/scaleResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAmrBA;;;;;;;;;;;;;GAaG;AACH,mDAHW,OAAO,iBAAiB,EAAE,OAAO,GAAG,OAAO,iBAAiB,EAAE,OAAO,EAAE,eACvE,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,KAAK,OAAO,QA4B9D;AAprBD;;;;;;;;GAQG;AACH;;;;;;;;GAQG;AACH;IA2CI;;OAEG;IACH,2DAgCC;IA/BG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IA+DzB,2BASC;IAqBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAyED;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAQzB;IA4HD;;;;;OAKG;IACH,oBAGC;IAED;;;;OAIG;IACH,0BAKC;IAkDD;;OAEG;IACH;eA7akC,OAAO,kBAAkB,EAAE,KAAK;MAobjE;IAED;;;;;;OAMG;IACH;eA7bkC,OAAO,kBAAkB,EAAE,KAAK;MA+bjE;IAED;;;;OAIG;IACH;eAtckC,OAAO,kBAAkB,EAAE,KAAK;MA+cjE;IAED,mBAEC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CAMzC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBAGC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAK1B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCAzoB+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;sBAChD,CAAC,OAAO,+CAAkB,EAAE,IAAI,EAAE,OAAO,oBAAoB,EAAE,IAAI,kDAAgB;;sBAvBtF,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}
+{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAuCA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA8CI;;OAEG;IACH,2DAkCC;IAjCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAoEzB,2BASC;IAqBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IA6ED;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAYzB;IAWD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IA4HD;;;;;OAKG;IACH,oBAUC;IAED;;;;;OAKG;IACH,0BAuBC;IAuGD;;OAEG;IACH;eA5jBkC,OAAO,kBAAkB,EAAE,KAAK;MAmkBjE;IAED;;;;;;OAMG;IACH;eA5kBkC,OAAO,kBAAkB,EAAE,KAAK;MA8kBjE;IAED;;;;OAIG;IACH;eArlBkC,OAAO,kBAAkB,EAAE,KAAK;MA8lBjE;IAED,mBAEC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CAMzC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBAGC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAK1B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCAlyB+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBAvBV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}