@genome-spy/core 0.72.0 → 0.73.0

package/dist/src/scales/scaleResolution.js

@@ -24,10 +24,19 @@ import {
 } from "./scaleResolutionConstants.js";
 
 import { getAccessorDomainKey } from "../encoder/accessor.js";
-import { isSecondaryChannel } from "../encoder/encoder.js";
+import {
+    isPrimaryPositionalChannel,
+    isSecondaryChannel,
+} from "../encoder/encoder.js";
 import { NominalDomain } from "../utils/domainArray.js";
 import { shallowArrayEquals } from "../utils/arrayUtils.js";
 import createIndexer from "../utils/indexer.js";
+import { resolveUrl } from "../utils/url.js";
+import {
+    normalizeIntervalForSelection,
+    requireIntervalSelection,
+    requireParamRuntime,
+} from "./selectionDomainUtils.js";
 
 // Register scaleLocus to Vega-Scale.
 // Loci are discrete but the scale's domain can be adjusted in a continuous manner.
@@ -111,6 +120,11 @@ export default class ScaleResolution {
 
     #categoricalIndexerExplicit = false;
 
+    /** @type {(() => void)[]} */
+    #selectionDomainParamUnsubscribers = [];
+
+    #selectionReverseSyncSuppressionDepth = 0;
+
     /**
      * @param {Channel} channel
      */
@@ -127,7 +141,7 @@ export default class ScaleResolution {
             getDataMembers: () =>
                 this.#getActiveMembers(this.#dataDomainMembers),
             getType: () => this.type,
-            getLocusExtent: () => this.#getLocusExtent(),
+            getLocusExtent: (assembly) => this.#getLocusExtent(assembly),
             fromComplexInterval: this.fromComplexInterval.bind(this),
         });
 
@@ -200,21 +214,24 @@ export default class ScaleResolution {
     }
 
     /**
+     * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {number[]}
      */
-    #getLocusExtent() {
-        return getGenomeExtent(this.#getGenomeSource());
+    #getLocusExtent(assembly) {
+        return getGenomeExtent(this.#getGenomeSource(assembly));
     }
 
     /**
+     * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {import("../genome/scaleLocus.js").GenomeSource}
      */
-    #getGenomeSource() {
+    #getGenomeSource(assembly) {
         if (this.type !== LOCUS) {
             return undefined;
         }
         return /** @type {import("../genome/scaleLocus.js").GenomeSource} */ (
-            this.#scaleManager.scale ?? this.#scaleManager.getLocusGenome()
+            this.#scaleManager.scale ??
+                this.#scaleManager.getLocusGenome(assembly)
         );
     }
 
@@ -242,6 +259,13 @@ export default class ScaleResolution {
      * @param {ScaleResolutionEventType} type
      */
     #notifyListeners(type) {
+        if (
+            type === "domain" &&
+            this.#selectionReverseSyncSuppressionDepth === 0
+        ) {
+            this.#syncLinkedSelectionFromDomain();
+        }
+
         for (const listener of this.#listeners[type].values()) {
             listener({
                 type,
@@ -250,14 +274,92 @@ export default class ScaleResolution {
         }
     }
 
+    /**
+     * @param {() => void} callback
+     */
+    #withSelectionReverseSyncSuppressed(callback) {
+        this.#selectionReverseSyncSuppressionDepth += 1;
+        try {
+            callback();
+        } finally {
+            this.#selectionReverseSyncSuppressionDepth -= 1;
+        }
+    }
+
+    #syncLinkedSelectionFromDomain() {
+        const linkInfo =
+            this.#domainAggregator.getSelectionConfiguredDomainInfo();
+        if (!linkInfo) {
+            return;
+        }
+
+        const shouldReverseSync =
+            linkInfo.sync === "twoWay" ||
+            (linkInfo.sync === "auto" && this.isZoomable());
+        if (!shouldReverseSync) {
+            return;
+        }
+
+        const runtime = requireParamRuntime(
+            this.#firstMemberView.paramRuntime,
+            linkInfo.param
+        );
+
+        const selection = requireIntervalSelection(
+            runtime.getValue(linkInfo.param),
+            linkInfo.param
+        );
+
+        const interval = this.#normalizeDomainIntervalForLinkedSelection(
+            this.getScale().domain()
+        );
+        if (!interval) {
+            return;
+        }
+
+        const fallbackInterval =
+            this.#normalizeDomainIntervalForLinkedSelection(
+                this.#domainAggregator.getDefaultDomain(true)
+            );
+
+        const syncedInterval =
+            fallbackInterval && shallowArrayEquals(interval, fallbackInterval)
+                ? null
+                : interval;
+
+        const previousInterval = selection.intervals[linkInfo.encoding] ?? null;
+        if (intervalsEqual(previousInterval, syncedInterval)) {
+            return;
+        }
+
+        runtime.setValue(linkInfo.param, {
+            ...selection,
+            type: "interval",
+            intervals: {
+                ...selection.intervals,
+                [linkInfo.encoding]: syncedInterval,
+            },
+        });
+    }
+
+    /**
+     * @param {any[]} domain
+     * @returns {[number, number] | undefined}
+     */
+    #normalizeDomainIntervalForLinkedSelection(domain) {
+        return normalizeIntervalForSelection(domain, this.zoomExtent);
+    }
+
     /**
      * Add a view to this resolution.
      * N.B. This is expected to be called in depth-first order
      *
      * @param {ScaleResolutionMember} newMember
+     * @returns {ScaleResolutionMember}
      */
     #addMember(newMember) {
-        const { channel, channelDef } = newMember;
+        const member = normalizeMember(newMember);
+        const { channel, channelDef } = member;
 
         // A convenience hack for cases where the new member should adapt
         // the scale type to the existing one. For example: SelectionRect
@@ -283,6 +385,20 @@ export default class ScaleResolution {
         // @ts-expect-error "sample" is not really a channel with scale
         const type = channel == "sample" ? "nominal" : channelDef.type;
         const name = channelDef?.scale?.name;
+        const explicitScaleType = channelDef.scale?.type;
+        const effectiveScaleType =
+            explicitScaleType ??
+            (type === INDEX || type === LOCUS ? type : undefined);
+
+        if (
+            effectiveScaleType &&
+            [INDEX, LOCUS].includes(effectiveScaleType) &&
+            !isPrimaryPositionalChannel(this.channel)
+        ) {
+            throw new Error(
+                `Index and locus scales are only supported on positional channels (x/y). Channel "${this.channel}" resolves to scale type "${effectiveScaleType}".`
+            );
+        }
 
         if (name) {
             if (this.name !== undefined && name != this.name) {
@@ -306,11 +422,13 @@ export default class ScaleResolution {
             }
         }
 
-        this.#members.add(newMember);
-        if (newMember.contributesToDomain) {
-            this.#dataDomainMembers.add(newMember);
+        this.#members.add(member);
+        if (member.contributesToDomain) {
+            this.#dataDomainMembers.add(member);
         }
         this.#domainAggregator.invalidateConfiguredDomain();
+        this.#refreshSelectionDomainParamSubscriptions();
+        return member;
     }
 
     /**
@@ -318,23 +436,58 @@ export default class ScaleResolution {
      * @returns {() => boolean}
      */
     registerMember(member) {
-        this.#addMember(member);
+        const registeredMember = this.#addMember(member);
         return () => {
-            const removed = this.#members.delete(member);
+            const removed = this.#members.delete(registeredMember);
             if (removed) {
-                this.#dataDomainMembers.delete(member);
+                this.#dataDomainMembers.delete(registeredMember);
                 this.#domainAggregator.invalidateConfiguredDomain();
+                this.#refreshSelectionDomainParamSubscriptions();
             }
             return removed && this.#members.size === 0;
         };
     }
 
     dispose() {
+        this.#clearSelectionDomainParamSubscriptions();
         this.#listeners.domain.clear();
         this.#listeners.range.clear();
         this.#scaleManager.dispose();
     }
 
+    #clearSelectionDomainParamSubscriptions() {
+        for (const unsubscribe of this.#selectionDomainParamUnsubscribers) {
+            unsubscribe();
+        }
+        this.#selectionDomainParamUnsubscribers = [];
+    }
+
+    #refreshSelectionDomainParamSubscriptions() {
+        this.#clearSelectionDomainParamSubscriptions();
+
+        if (this.#members.size === 0) {
+            return;
+        }
+
+        const linkInfo =
+            this.#domainAggregator.getSelectionConfiguredDomainInfo();
+        if (!linkInfo) {
+            return;
+        }
+
+        const runtime = requireParamRuntime(
+            this.#firstMemberView.paramRuntime,
+            linkInfo.param
+        );
+
+        this.#selectionDomainParamUnsubscribers.push(
+            runtime.subscribe(linkInfo.param, () => {
+                this.#domainAggregator.invalidateConfiguredDomain();
+                this.reconfigureDomain();
+            })
+        );
+    }
+
     #hasRenderedMember() {
         for (const member of this.#members) {
             if (member.view.hasRendered()) {
@@ -424,6 +577,33 @@ export default class ScaleResolution {
         });
     }
 
+    /**
+     * Returns locus assembly requirements without initializing the scale.
+     *
+     * This is intentionally side-effect free: it only inspects merged scale
+     * properties from registered members and does not touch default domains or
+     * instantiate scale instances.
+     *
+     * @returns {{
+     *   assembly: import("../spec/scale.js").Scale["assembly"] | undefined,
+     *   needsDefaultAssembly: boolean
+     * }}
+     */
+    getAssemblyRequirement() {
+        const props = this.#getMergedScaleProps();
+        if (props === null || props.type === "null" || props.type !== LOCUS) {
+            return {
+                assembly: undefined,
+                needsDefaultAssembly: false,
+            };
+        }
+
+        return {
+            assembly: props.assembly,
+            needsDefaultAssembly: props.assembly === undefined,
+        };
+    }
+
     /**
      * Returns the merged scale properties supplemented with inferred properties
      * and domain.
@@ -439,10 +619,10 @@ export default class ScaleResolution {
             return { type: "null" };
         }
 
-        const domain =
-            this.#domainAggregator.getConfiguredOrDefaultDomain(
-                extractDataDomain
-            );
+        const domain = this.#domainAggregator.getConfiguredOrDefaultDomain(
+            extractDataDomain,
+            props.type === LOCUS ? props.assembly : undefined
+        );
 
         if (isDiscrete(props.type)) {
             const isExplicit = this.#isExplicitDomain();
@@ -512,15 +692,17 @@ export default class ScaleResolution {
      * or when scale properties are otherwise re-resolved from the view hierarchy.
      */
     reconfigure() {
-        this.#domainAggregator.invalidateConfiguredDomain();
-        const state = this.#computeScaleState(true);
-        if (!state) {
-            return;
-        }
-        this.#applyReconfigure(state, (scale, props) =>
-            this.#scaleManager.reconfigureScale(props)
-        );
-        this.#finalizeReconfigure(state);
+        this.#withSelectionReverseSyncSuppressed(() => {
+            this.#domainAggregator.invalidateConfiguredDomain();
+            const state = this.#computeScaleState(true);
+            if (!state) {
+                return;
+            }
+            this.#applyReconfigure(state, (scale, props) =>
+                this.#scaleManager.reconfigureScale(props)
+            );
+            this.#finalizeReconfigure(state);
+        });
     }
 
     /**
@@ -530,28 +712,30 @@ export default class ScaleResolution {
      *
      */
     reconfigureDomain() {
-        const state = this.#computeScaleState(true, true);
-        if (!state) {
-            return;
-        }
-        const { domainConfig, targetDomain } = state;
-        const domainMatches =
-            targetDomain != null &&
-            shallowArrayEquals(targetDomain, state.scale.domain());
-
-        if (targetDomain != null && !domainMatches) {
-            this.#applyReconfigure(state, (scale) => {
-                scale.domain(targetDomain);
-                if (domainConfig.applyOrdinalUnknown) {
-                    // Keep ordinal unknown handling close to the domain write so
-                    // domainImplicit semantics stay aligned with the applied domain.
-                    /** @type {any} */ (scale).unknown(
-                        domainConfig.ordinalUnknown
-                    );
-                }
-            });
-        }
-        this.#finalizeReconfigure(state);
+        this.#withSelectionReverseSyncSuppressed(() => {
+            const state = this.#computeScaleState(true, true);
+            if (!state) {
+                return;
+            }
+            const { domainConfig, targetDomain } = state;
+            const domainMatches =
+                targetDomain != null &&
+                shallowArrayEquals(targetDomain, state.scale.domain());
+
+            if (targetDomain != null && !domainMatches) {
+                this.#applyReconfigure(state, (scale) => {
+                    scale.domain(targetDomain);
+                    if (domainConfig.applyOrdinalUnknown) {
+                        // Keep ordinal unknown handling close to the domain write so
+                        // domainImplicit semantics stay aligned with the applied domain.
+                        /** @type {any} */ (scale).unknown(
+                            domainConfig.ordinalUnknown
+                        );
+                    }
+                });
+            }
+            this.#finalizeReconfigure(state);
+        });
     }
 
     /**
@@ -562,6 +746,7 @@ export default class ScaleResolution {
      *     props: import("../spec/scale.js").Scale,
      *     previousDomain: any[],
      *     domainWasInitialized: boolean,
+     *     hasSelectionConfiguredDomain: boolean,
      *     domainConfig?: ReturnType<typeof configureDomain>,
      *     targetDomain?: any[] | null,
      * } | undefined}
@@ -578,6 +763,8 @@ export default class ScaleResolution {
             props: this.#getScaleProps(extractDataDomain),
             previousDomain: scale.domain(),
             domainWasInitialized: this.#isDomainInitialized(),
+            hasSelectionConfiguredDomain:
+                this.#domainAggregator.hasSelectionConfiguredDomain(),
         };
 
         if (includeDomainConfig) {
@@ -610,10 +797,16 @@ export default class ScaleResolution {
      *     scale: ScaleWithProps,
      *     previousDomain: any[],
      *     domainWasInitialized: boolean,
+     *     hasSelectionConfiguredDomain: boolean,
      * }} inputs
      */
     #finalizeReconfigure(inputs) {
-        const { scale, previousDomain, domainWasInitialized } = inputs;
+        const {
+            scale,
+            previousDomain,
+            domainWasInitialized,
+            hasSelectionConfiguredDomain,
+        } = inputs;
 
         if (
             this.#domainAggregator.captureInitialDomain(
@@ -633,12 +826,22 @@ export default class ScaleResolution {
         );
 
         if (action === "restore") {
-            // Don't mess with zoomed views, restore the previous domain
-            this.#scaleManager.withDomainNotificationsSuppressed(() => {
-                scale.domain(previousDomain);
-            });
+            if (hasSelectionConfiguredDomain) {
+                // Selection-linked domains are the source of truth and must not
+                // be overridden by previously zoomed domains.
+                this.#notifyListeners("domain");
+            } else {
+                // Don't mess with zoomed views, restore the previous domain
+                this.#scaleManager.withDomainNotificationsSuppressed(() => {
+                    scale.domain(previousDomain);
+                });
+            }
         } else if (action === "animate") {
-            if (this.#hasRenderedMember()) {
+            if (hasSelectionConfiguredDomain) {
+                // Linked domains can update continuously (e.g., brushing), so
+                // skip zoomTo transitions and apply domain updates directly.
+                this.#notifyListeners("domain");
+            } else if (this.#hasRenderedMember()) {
                 // It can be zoomed, so lets make a smooth transition.
                 // Restore the previous domain and zoom smoothly to the new domain.
                 this.#scaleManager.withDomainNotificationsSuppressed(() => {
@@ -847,3 +1050,60 @@ export default class ScaleResolution {
         return /** @type {number[]} */ (interval);
     }
 }
+
+/**
+ * @param {number[] | null} a
+ * @param {number[] | null} b
+ * @returns {boolean}
+ */
+function intervalsEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+
+    if (!a || !b) {
+        return false;
+    }
+
+    return a.length === b.length && shallowArrayEquals(a, b);
+}
+
+/**
+ * Normalizes member-specific scale URLs so that inline `scale.assembly.url`
+ * values resolve against the member view's base URL before scale props are
+ * merged.
+ *
+ * @template {ChannelWithScale}[T=ChannelWithScale]
+ * @param {ScaleResolutionMember<T>} member
+ * @returns {ScaleResolutionMember<T>}
+ */
+function normalizeMember(member) {
+    const scale = member.channelDef.scale;
+    const assembly = scale?.assembly;
+    if (!scale || !assembly || typeof assembly !== "object") {
+        return member;
+    }
+
+    if (!("url" in assembly)) {
+        return member;
+    }
+
+    const resolvedUrl = resolveUrl(member.view.getBaseUrl(), assembly.url);
+    if (resolvedUrl === assembly.url) {
+        return member;
+    }
+
+    return {
+        ...member,
+        channelDef: {
+            ...member.channelDef,
+            scale: {
+                ...scale,
+                assembly: {
+                    ...assembly,
+                    url: resolvedUrl,
+                },
+            },
+        },
+    };
+}

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

@@ -0,0 +1,21 @@
+/**
+ * @param {import("../spec/view.js").ViewSpec} spec
+ * @param {{ new(...args: any[]): import("../view/view.js").default }} [viewType]
+ * @returns {Promise<import("../view/view.js").default>}
+ */
+export function initView(spec: import("../spec/view.js").ViewSpec, viewType?: {
+    new (...args: any[]): import("../view/view.js").default;
+}): Promise<import("../view/view.js").default>;
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {import("./scaleResolution.js").default}
+ */
+export function getRequiredScaleResolution(view: import("../view/view.js").default, channel: import("../spec/channel.js").ChannelWithScale): import("./scaleResolution.js").default;
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {any[]}
+ */
+export function getScaleDomain(view: import("../view/view.js").default, channel: import("../spec/channel.js").ChannelWithScale): any[];
+//# sourceMappingURL=scaleResolutionTestUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scaleResolutionTestUtils.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolutionTestUtils.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,+BAJW,OAAO,iBAAiB,EAAE,QAAQ,aAClC;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,iBAAiB,EAAE,OAAO,CAAA;CAAE,GACxD,OAAO,CAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC,CAItD;AAED;;;;GAIG;AACH,iDAJW,OAAO,iBAAiB,EAAE,OAAO,WACjC,OAAO,oBAAoB,EAAE,gBAAgB,GAC3C,OAAO,sBAAsB,EAAE,OAAO,CAQlD;AAED;;;;GAIG;AACH,qCAJW,OAAO,iBAAiB,EAAE,OAAO,WACjC,OAAO,oBAAoB,EAAE,gBAAgB,GAC3C,GAAG,EAAE,CAIjB"}

package/dist/src/scales/scaleResolutionTestUtils.js

@@ -0,0 +1,33 @@
+import { createAndInitialize } from "../view/testUtils.js";
+import UnitView from "../view/unitView.js";
+
+/**
+ * @param {import("../spec/view.js").ViewSpec} spec
+ * @param {{ new(...args: any[]): import("../view/view.js").default }} [viewType]
+ * @returns {Promise<import("../view/view.js").default>}
+ */
+export async function initView(spec, viewType = UnitView) {
+    return createAndInitialize(spec, viewType);
+}
+
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {import("./scaleResolution.js").default}
+ */
+export function getRequiredScaleResolution(view, channel) {
+    const resolution = view.getScaleResolution(channel);
+    if (!resolution) {
+        throw new Error(`Expected ${channel} scale resolution.`);
+    }
+    return resolution;
+}
+
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {any[]}
+ */
+export function getScaleDomain(view, channel) {
+    return getRequiredScaleResolution(view, channel).scale.domain();
+}

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

@@ -0,0 +1,22 @@
+/**
+ * @param {{ findRuntimeForParam: (name: string) => any }} paramRuntime
+ * @param {string} paramName
+ */
+export function requireParamRuntime(paramRuntime: {
+    findRuntimeForParam: (name: string) => any;
+}, paramName: string): any;
+/**
+ * @param {any} selection
+ * @param {string} paramName
+ */
+export function requireIntervalSelection(selection: any, paramName: string): import("../types/selectionTypes.js").IntervalSelection;
+/**
+ * @param {number[]} interval
+ * @param {number[]} zoomExtent
+ * @param {{ roundToIntegers?: boolean }} [options]
+ * @returns {[number, number] | undefined}
+ */
+export function normalizeIntervalForSelection(interval: number[], zoomExtent: number[], options?: {
+    roundToIntegers?: boolean;
+}): [number, number] | undefined;
+//# sourceMappingURL=selectionDomainUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectionDomainUtils.d.ts","sourceRoot":"","sources":["../../../src/scales/selectionDomainUtils.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,kDAHW;IAAE,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,CAAA;CAAE,aAC9C,MAAM,OAUhB;AAED;;;GAGG;AACH,oDAHW,GAAG,aACH,MAAM,0DAgBhB;AAED;;;;;GAKG;AACH,wDALW,MAAM,EAAE,cACR,MAAM,EAAE,YACR;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3B,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAsCxC"}

package/dist/src/scales/selectionDomainUtils.js

@@ -0,0 +1,79 @@
+import { isIntervalSelection } from "../selection/selection.js";
+
+/**
+ * @param {{ findRuntimeForParam: (name: string) => any }} paramRuntime
+ * @param {string} paramName
+ */
+export function requireParamRuntime(paramRuntime, paramName) {
+    const runtime = paramRuntime.findRuntimeForParam(paramName);
+    if (!runtime) {
+        throw new Error(
+            `Selection domain parameter "${paramName}" was not found.`
+        );
+    }
+    return runtime;
+}
+
+/**
+ * @param {any} selection
+ * @param {string} paramName
+ */
+export function requireIntervalSelection(selection, paramName) {
+    if (!selection) {
+        throw new Error(
+            `Selection domain parameter "${paramName}" was not found.`
+        );
+    }
+
+    if (!isIntervalSelection(selection)) {
+        throw new Error(
+            `Selection domain parameter "${paramName}" must be an interval selection.`
+        );
+    }
+
+    return selection;
+}
+
+/**
+ * @param {number[]} interval
+ * @param {number[]} zoomExtent
+ * @param {{ roundToIntegers?: boolean }} [options]
+ * @returns {[number, number] | undefined}
+ */
+export function normalizeIntervalForSelection(
+    interval,
+    zoomExtent,
+    options = {}
+) {
+    if (!interval || interval.length !== 2) {
+        return;
+    }
+
+    const a = Number(interval[0]);
+    const b = Number(interval[1]);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        return;
+    }
+
+    let min = Math.min(a, b);
+    let max = Math.max(a, b);
+
+    min = Math.max(zoomExtent[0], min);
+    max = Math.min(zoomExtent[1], max);
+
+    if (min > max) {
+        return;
+    }
+
+    if (options.roundToIntegers) {
+        min = Math.ceil(min);
+        max = Math.ceil(max);
+        min = Math.max(zoomExtent[0], min);
+        max = Math.min(zoomExtent[1], max);
+        if (min > max) {
+            return;
+        }
+    }
+
+    return [min, max];
+}