@genome-spy/core 0.73.0 → 0.74.0

package/dist/src/scales/domainPlanner.js

@@ -1,11 +1,22 @@
 import { span } from "vega-util";
 import { isContinuous } from "vega-scale";
 
-import { LOCUS } from "./scaleResolutionConstants.js";
-import { requireIntervalSelection } from "./selectionDomainUtils.js";
+import { INDEX, LOCUS } from "./scaleResolutionConstants.js";
+import {
+    toInternalIndexLikeDataDomain,
+    toInternalIndexLikeInterval,
+} from "./indexLikeDomainUtils.js";
+import {
+    hasIntervalSelectionBindingInScope,
+    resolveIntervalSelectionBinding,
+} from "./selectionDomainUtils.js";
 import createDomain from "../utils/domainArray.js";
 import { getAccessorDomainKey, isScaleAccessor } from "../encoder/accessor.js";
-import { getPrimaryChannel } from "../encoder/encoder.js";
+import { getEncoderAccessors, getPrimaryChannel } from "../encoder/encoder.js";
+import {
+    hasExplicitLocusUpperBound,
+    isChromosomalLocusInterval,
+} from "../genome/genome.js";
 
 /**
  * @typedef {import("../utils/domainArray.js").DomainArray} DomainArray
@@ -16,7 +27,8 @@ import { getPrimaryChannel } from "../encoder/encoder.js";
  * @typedef {{
  *   param: string,
  *   encoding: "x" | "y",
- *   sync: "auto" | "oneWay" | "twoWay",
+ *   hasInitial: boolean,
+ *   runtime: any,
  * }} SelectionDomainLinkInfo
  */
 
@@ -24,6 +36,9 @@ export default class DomainPlanner {
     /** @type {() => Set<ScaleResolutionMember>} */
     #getMembers;
 
+    /** @type {() => Set<ScaleResolutionMember>} */
+    #getAllMembers;
+
     /** @type {() => Set<ScaleResolutionMember>} */
     #getDataMembers;
 
@@ -39,20 +54,21 @@ export default class DomainPlanner {
     /** @type {any[]} */
     #initialDomain;
 
-    /** @type {DomainArray | undefined} */
-    #configuredDomain;
-
     /** @type {SelectionDomainLinkInfo | undefined} */
     #selectionDomainLinkInfo = undefined;
 
     #configuredDomainDirty = true;
 
+    /** @type {Map<boolean, DomainArray | undefined>} */
+    #configuredDomainsByInitialMode = new Map();
+
     /** @type {WeakMap<ScaleResolutionMember, import("../types/encoder.js").ScaleAccessor[]>} */
     #accessorsByMember = new WeakMap();
 
     /**
      * @param {object} options
      * @param {() => Set<ScaleResolutionMember>} options.getMembers
+     * @param {() => Set<ScaleResolutionMember>} [options.getAllMembers]
      * @param {() => Set<ScaleResolutionMember>} [options.getDataMembers]
      * @param {() => import("../spec/channel.js").Type} options.getType
      * @param {(assembly: import("../spec/scale.js").Scale["assembly"] | undefined) => number[]} options.getLocusExtent
@@ -60,12 +76,14 @@ export default class DomainPlanner {
      */
     constructor({
         getMembers,
+        getAllMembers,
         getDataMembers,
         getType,
         getLocusExtent,
         fromComplexInterval,
     }) {
         this.#getMembers = getMembers;
+        this.#getAllMembers = getAllMembers ?? getMembers;
         this.#getDataMembers = getDataMembers ?? getMembers;
         this.#getType = getType;
         this.#getLocusExtent = getLocusExtent;
@@ -79,25 +97,46 @@ export default class DomainPlanner {
         return this.#initialDomain;
     }
 
-    hasConfiguredDomain() {
-        return !!this.getConfiguredDomain();
+    /**
+     * @param {{ includeSelectionInitial?: boolean }} [options]
+     */
+    hasConfiguredDomain(options = {}) {
+        return !!this.getConfiguredDomain(options);
     }
 
     hasSelectionConfiguredDomain() {
-        this.getConfiguredDomain();
+        this.getSelectionConfiguredDomainBindingInfo();
         return !!this.#selectionDomainLinkInfo;
     }
 
     /**
      * @returns {SelectionDomainLinkInfo | undefined}
      */
-    getSelectionConfiguredDomainInfo() {
+    getSelectionConfiguredDomainBindingInfo() {
+        if (this.#selectionDomainLinkInfo || !this.#configuredDomainDirty) {
+            return this.#selectionDomainLinkInfo;
+        }
+
         this.getConfiguredDomain();
         return this.#selectionDomainLinkInfo;
     }
 
+    getSelectionConfiguredDomainInfo() {
+        const bindingInfo = this.getSelectionConfiguredDomainBindingInfo();
+        if (!bindingInfo) {
+            return;
+        }
+
+        return {
+            param: bindingInfo.param,
+            encoding: bindingInfo.encoding,
+        };
+    }
+
     invalidateConfiguredDomain() {
         this.#configuredDomainDirty = true;
+        this.#selectionDomainLinkInfo = undefined;
+        this.#configuredDomainsByInitialMode.clear();
     }
 
     /**
@@ -121,12 +160,17 @@ export default class DomainPlanner {
      *
      * @param {boolean} [extractDataDomain]
      * @param {import("../spec/scale.js").Scale["assembly"]} [locusAssembly]
+     * @param {{ includeSelectionInitial?: boolean }} [options]
      * @returns {any[]}
      */
-    getConfiguredOrDefaultDomain(extractDataDomain = false, locusAssembly) {
+    getConfiguredOrDefaultDomain(
+        extractDataDomain = false,
+        locusAssembly,
+        options = {}
+    ) {
         // TODO: intersect the domain with zoom extent (if it's defined)
         return (
-            this.getConfiguredDomain() ??
+            this.getConfiguredDomain(options) ??
             this.getDefaultDomain(extractDataDomain, locusAssembly)
         );
     }
@@ -134,19 +178,35 @@ export default class DomainPlanner {
     /**
      * Unions the configured domains of all participating views.
      *
+     * @param {{ includeSelectionInitial?: boolean }} [options]
      * @return {DomainArray}
      */
-    getConfiguredDomain() {
-        if (!this.#configuredDomainDirty) {
-            return this.#configuredDomain;
+    getConfiguredDomain(options = {}) {
+        const includeSelectionInitial = options.includeSelectionInitial ?? true;
+
+        if (
+            !this.#configuredDomainDirty &&
+            this.#configuredDomainsByInitialMode.has(includeSelectionInitial)
+        ) {
+            return this.#configuredDomainsByInitialMode.get(
+                includeSelectionInitial
+            );
         }
 
         const configuredDomain = resolveConfiguredDomain(
             this.#getMembers(),
-            this.#fromComplexInterval
+            this.#fromComplexInterval,
+            includeSelectionInitial
+        );
+        validateSharedSelectionDomain(
+            this.#getAllMembers(),
+            configuredDomain.selectionRef
         );
-        this.#configuredDomain = configuredDomain.domain;
         this.#selectionDomainLinkInfo = configuredDomain.selectionRef;
+        this.#configuredDomainsByInitialMode.set(
+            includeSelectionInitial,
+            configuredDomain.domain
+        );
         this.#configuredDomainDirty = false;
         return configuredDomain.domain;
     }
@@ -167,18 +227,19 @@ export default class DomainPlanner {
     /**
      * @param {import("../types/encoder.js").VegaScale} scale
      * @param {boolean} domainWasInitialized
+     * @param {any[]} [snapshotDomain]
      * @returns {boolean} true if listeners should be notified immediately
      */
-    captureInitialDomain(scale, domainWasInitialized) {
+    captureInitialDomain(scale, domainWasInitialized, snapshotDomain) {
         if (!this.#initialDomain && isContinuous(scale.type)) {
-            const domain = scale.domain();
+            const domain = snapshotDomain ?? scale.domain();
             if (span(domain) > 0) {
                 this.#initialDomain = domain;
             }
         }
 
         if (!domainWasInitialized) {
-            this.#initialDomain = scale.domain();
+            this.#initialDomain = snapshotDomain ?? scale.domain();
             return true;
         }
 
@@ -205,7 +266,7 @@ export default class DomainPlanner {
             return [];
         }
 
-        const accessors = encoder.accessors ?? [];
+        const accessors = getEncoderAccessors(encoder);
         if (accessors.length === 0) {
             return [];
         }
@@ -222,12 +283,17 @@ export default class DomainPlanner {
 /**
  * @param {Set<ScaleResolutionMember>} members
  * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
+ * @param {boolean} includeSelectionInitial
  * @returns {{
  *   domain: DomainArray | undefined,
  *   selectionRef: SelectionDomainLinkInfo | undefined,
  * }}
  */
-function resolveConfiguredDomain(members, fromComplexInterval) {
+function resolveConfiguredDomain(
+    members,
+    fromComplexInterval,
+    includeSelectionInitial
+) {
     const domainMembers = Array.from(members)
         .filter((member) => member.contributesToDomain)
         .filter((member) => member.channelDef.scale?.domain);
@@ -235,12 +301,10 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
     /** @type {DomainArray[]} */
     const domains = [];
 
-    /** @type {string | undefined} */
-    let selectionRefKey = undefined;
+    /** @type {any} */
+    let selectionRefRuntime = undefined;
     /** @type {string | undefined} */
     let selectionRefDescription = undefined;
-    /** @type {"auto" | "oneWay" | "twoWay" | undefined} */
-    let selectionRefSync = undefined;
     /** @type {SelectionDomainLinkInfo | undefined} */
     let selectionRef = undefined;
     let hasLiteralDomain = false;
@@ -257,10 +321,16 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
             const resolved = resolveSelectionDomain(
                 member,
                 domainDef,
-                fromComplexInterval
+                fromComplexInterval,
+                includeSelectionInitial
             );
 
-            if (selectionRefKey && selectionRefKey !== resolved.key) {
+            if (
+                selectionRef &&
+                (selectionRef.runtime !== resolved.runtime ||
+                    selectionRef.param !== resolved.param ||
+                    selectionRef.encoding !== resolved.encoding)
+            ) {
                 throw new Error(
                     "Conflicting selection domain references on a shared scale: " +
                         selectionRefDescription +
@@ -270,28 +340,14 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
                 );
             }
 
-            if (!selectionRefSync) {
-                selectionRefSync = resolved.sync;
-            } else if (selectionRefSync === "auto") {
-                selectionRefSync = resolved.sync;
-            } else if (resolved.sync !== "auto") {
-                if (selectionRefSync !== resolved.sync) {
-                    throw new Error(
-                        "Conflicting selection domain sync modes on a shared scale: " +
-                            selectionRefSync +
-                            " vs " +
-                            resolved.sync +
-                            "."
-                    );
-                }
-            }
-
-            selectionRefKey = resolved.key;
+            selectionRefRuntime = resolved.runtime;
             selectionRefDescription = resolved.description;
             selectionRef = {
                 param: resolved.param,
                 encoding: resolved.encoding,
-                sync: selectionRefSync,
+                hasInitial:
+                    (selectionRef?.hasInitial ?? false) || resolved.hasInitial,
+                runtime: resolved.runtime,
             };
 
             if (resolved.domain) {
@@ -300,7 +356,7 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
             continue;
         }
 
-        if (selectionRefKey) {
+        if (selectionRefRuntime) {
             throw new Error(
                 "Cannot mix literal configured domains with selection-driven domains on a shared scale."
             );
@@ -308,7 +364,11 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
 
         hasLiteralDomain = true;
         domains.push(
-            createDomain(member.channelDef.type, fromComplexInterval(domainDef))
+            resolveConfiguredIntervalDomain(
+                member.channelDef.type,
+                domainDef,
+                fromComplexInterval
+            )
         );
     }
 
@@ -319,7 +379,7 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
         };
     }
 
-    if (selectionRefKey) {
+    if (selectionRefRuntime) {
         // Selection refs are still the source of truth even when the
         // selection interval currently resolves to no domain.
         return { domain: undefined, selectionRef };
@@ -332,24 +392,23 @@ function resolveConfiguredDomain(members, fromComplexInterval) {
  * @param {ScaleResolutionMember} member
  * @param {SelectionDomainRef} domainRef
  * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
+ * @param {boolean} includeSelectionInitial
  * @returns {{
  *   domain: DomainArray | undefined,
- *   key: string,
  *   description: string,
  *   param: string,
  *   encoding: "x" | "y",
- *   sync: "auto" | "oneWay" | "twoWay",
+ *   hasInitial: boolean,
+ *   runtime: any,
  * }}
  */
-function resolveSelectionDomain(member, domainRef, fromComplexInterval) {
+function resolveSelectionDomain(
+    member,
+    domainRef,
+    fromComplexInterval,
+    includeSelectionInitial
+) {
     const paramName = domainRef.param;
-    const syncMode = domainRef.sync ?? "auto";
-
-    if (syncMode !== "auto" && syncMode !== "oneWay" && syncMode !== "twoWay") {
-        throw new Error(
-            `Invalid selection domain sync mode "${syncMode}" for parameter "${paramName}".`
-        );
-    }
 
     const resolvedChannel = resolveSelectionDomainChannel(
         member.channel,
@@ -357,40 +416,112 @@ function resolveSelectionDomain(member, domainRef, fromComplexInterval) {
         paramName
     );
 
-    const paramRuntime = member.view.paramRuntime;
-    const selection = requireIntervalSelection(
-        paramRuntime?.findValue(paramName),
-        paramName
+    const binding = resolveIntervalSelectionBinding(
+        member.view,
+        paramName,
+        resolvedChannel
     );
-
-    const interval = selection.intervals[resolvedChannel];
-    const key = [paramName, resolvedChannel].join("|");
+    const hasInitial = domainRef.initial !== undefined;
+    const interval = binding.selection.intervals[resolvedChannel];
     const description = paramName + "." + resolvedChannel;
-
     if (!interval || interval.length !== 2) {
+        const initialDomain = includeSelectionInitial
+            ? domainRef.initial
+                ? resolveConfiguredIntervalDomain(
+                      member.channelDef.type,
+                      domainRef.initial,
+                      fromComplexInterval
+                  )
+                : undefined
+            : undefined;
         return {
-            domain: undefined,
-            key,
+            domain: initialDomain,
             description,
             param: paramName,
             encoding: resolvedChannel,
-            sync: syncMode,
+            hasInitial,
+            runtime: binding.runtime,
         };
     }
 
     return {
+        // Selection intervals already use internal scale-domain coordinates.
         domain: createDomain(
             member.channelDef.type,
             fromComplexInterval(interval)
         ),
-        key,
         description,
         param: paramName,
         encoding: resolvedChannel,
-        sync: syncMode,
+        hasInitial,
+        runtime: binding.runtime,
     };
 }
 
+/**
+ * @param {import("../spec/channel.js").Type} type
+ * @param {ScalarDomain | ComplexDomain} interval
+ * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
+ * @returns {DomainArray}
+ */
+function resolveConfiguredIntervalDomain(type, interval, fromComplexInterval) {
+    const numericDomain = fromComplexInterval(interval);
+    const internalDomain =
+        type === LOCUS &&
+        isChromosomalLocusInterval(interval) &&
+        !hasExplicitLocusUpperBound(interval)
+            ? numericDomain
+            : toInternalIndexLikeInterval(type, numericDomain);
+
+    return createDomain(type, internalDomain);
+}
+
+/**
+ * Fails fast when a selection-driven scale domain ends up sharing the same
+ * scale resolution as the interval selection that drives it. This typically
+ * happens when an overview/detail spec forgets to make the linked positional
+ * scale independent.
+ *
+ * @param {Set<ScaleResolutionMember>} members
+ * @param {SelectionDomainLinkInfo | undefined} selectionRef
+ */
+function validateSharedSelectionDomain(members, selectionRef) {
+    if (
+        !selectionRef ||
+        members.size < 2 ||
+        !Array.from(members).some((member) =>
+            hasIntervalSelectionBindingInScope(
+                member.view,
+                selectionRef.runtime,
+                selectionRef.param,
+                selectionRef.encoding
+            )
+        )
+    ) {
+        return;
+    }
+
+    const viewPaths = Array.from(
+        new Set(
+            Array.from(members)
+                .filter((member) => member.contributesToDomain)
+                .map(
+                    (member) =>
+                        member.view.getPathString?.() ??
+                        member.view.name ??
+                        "(unknown)"
+                )
+        )
+    );
+
+    throw new Error(
+        `Selection domain reference "${selectionRef.param}.${selectionRef.encoding}" cannot use a shared ${selectionRef.encoding} scale when the same interval selection is defined in that shared view group (${viewPaths.join(", ")}). ` +
+            `This creates a feedback loop between brushing and the scale domain. ` +
+            `Make the linked ${selectionRef.encoding} scale independent, for example with ` +
+            `"resolve": { "scale": { "${selectionRef.encoding}": "independent" } } on the common ancestor.`
+    );
+}
+
 /**
  * @param {import("../spec/channel.js").ChannelWithScale} channel
  * @param {SelectionDomainRef} domainRef
@@ -502,5 +633,8 @@ function resolveDefaultDomain(type, getLocusExtent, dataDomain, locusAssembly) {
     if (type == LOCUS) {
         return getLocusExtent(locusAssembly);
     }
+    if (type == INDEX) {
+        return toInternalIndexLikeDataDomain(type, dataDomain) ?? [];
+    }
     return dataDomain ?? [];
 }

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

@@ -0,0 +1,29 @@
+/**
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @returns {boolean}
+ */
+export function isIndexLikeDomainType(type: import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType): boolean;
+/**
+ * Converts a numeric user-facing inclusive interval into the internal half-open
+ * form used by index-like scales.
+ *
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @param {number[]} interval
+ * @returns {number[]}
+ */
+export function toInternalIndexLikeInterval(type: import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType, interval: number[]): number[];
+/**
+ * Converts an internal half-open interval into a user-facing inclusive form.
+ *
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @param {number[]} interval
+ * @returns {number[]}
+ */
+export function toExternalIndexLikeInterval(type: import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType, interval: number[]): number[];
+/**
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @param {number[] | undefined} interval
+ * @returns {number[] | undefined}
+ */
+export function toInternalIndexLikeDataDomain(type: import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType, interval: number[] | undefined): number[] | undefined;
+//# sourceMappingURL=indexLikeDomainUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexLikeDomainUtils.d.ts","sourceRoot":"","sources":["../../../src/scales/indexLikeDomainUtils.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,IAAI,GAAG,OAAO,kBAAkB,EAAE,SAAS,GACtE,OAAO,CAInB;AAED;;;;;;;GAOG;AACH,kDAJW,OAAO,oBAAoB,EAAE,IAAI,GAAG,OAAO,kBAAkB,EAAE,SAAS,YACxE,MAAM,EAAE,GACN,MAAM,EAAE,CAIpB;AAED;;;;;;GAMG;AACH,kDAJW,OAAO,oBAAoB,EAAE,IAAI,GAAG,OAAO,kBAAkB,EAAE,SAAS,YACxE,MAAM,EAAE,GACN,MAAM,EAAE,CAIpB;AAED;;;;GAIG;AACH,oDAJW,OAAO,oBAAoB,EAAE,IAAI,GAAG,OAAO,kBAAkB,EAAE,SAAS,YACxE,MAAM,EAAE,GAAG,SAAS,GAClB,MAAM,EAAE,GAAG,SAAS,CAMhC"}

package/dist/src/scales/indexLikeDomainUtils.js

@@ -0,0 +1,67 @@
+import { INDEX, LOCUS } from "./scaleResolutionConstants.js";
+
+/**
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @returns {boolean}
+ */
+export function isIndexLikeDomainType(type) {
+    return type === INDEX || type === LOCUS;
+}
+
+/**
+ * Converts a numeric user-facing inclusive interval into the internal half-open
+ * form used by index-like scales.
+ *
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @param {number[]} interval
+ * @returns {number[]}
+ */
+export function toInternalIndexLikeInterval(type, interval) {
+    return isIndexLikeDomainType(type) ? expandUpperBound(interval) : interval;
+}
+
+/**
+ * Converts an internal half-open interval into a user-facing inclusive form.
+ *
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @param {number[]} interval
+ * @returns {number[]}
+ */
+export function toExternalIndexLikeInterval(type, interval) {
+    return isIndexLikeDomainType(type) ? shrinkUpperBound(interval) : interval;
+}
+
+/**
+ * @param {import("../spec/channel.js").Type | import("../spec/scale.js").ScaleType} type
+ * @param {number[] | undefined} interval
+ * @returns {number[] | undefined}
+ */
+export function toInternalIndexLikeDataDomain(type, interval) {
+    return interval && isIndexLikeDomainType(type)
+        ? expandUpperBound(interval)
+        : interval;
+}
+
+/**
+ * @param {number[]} interval
+ * @returns {number[]}
+ */
+function expandUpperBound(interval) {
+    return [interval[0], interval[1] + getDirection(interval)];
+}
+
+/**
+ * @param {number[]} interval
+ * @returns {number[]}
+ */
+function shrinkUpperBound(interval) {
+    return [interval[0], interval[1] - getDirection(interval)];
+}
+
+/**
+ * @param {number[]} interval
+ * @returns {1 | -1}
+ */
+function getDirection(interval) {
+    return interval[1] >= interval[0] ? 1 : -1;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Stable ordering for resolution members so merge behavior does not depend on
+ * registration order.
+ *
+ * @template {{ view: { getPathString(): string }, channel?: string }} T
+ * @param {Set<T> | Iterable<T>} members
+ * @returns {T[]}
+ */
+export function orderResolutionMembers<T extends {
+    view: {
+        getPathString(): string;
+    };
+    channel?: string;
+}>(members: Set<T> | Iterable<T>): T[];
+//# sourceMappingURL=resolutionMemberOrder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolutionMemberOrder.d.ts","sourceRoot":"","sources":["../../../src/scales/resolutionMemberOrder.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,uCAJuE,CAAC,SAA3D;IAAG,IAAI,EAAE;QAAE,aAAa,IAAI,MAAM,CAAA;KAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAG,WAC3D,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAClB,CAAC,EAAE,CAMf"}

package/dist/src/scales/resolutionMemberOrder.js

@@ -0,0 +1,22 @@
+/**
+ * @param {{ view: { getPathString(): string }, channel?: string }} member
+ */
+function memberKey(member) {
+    const path = member.view.getPathString();
+    const channel = member.channel ?? "";
+    return path + "|" + channel;
+}
+
+/**
+ * Stable ordering for resolution members so merge behavior does not depend on
+ * registration order.
+ *
+ * @template {{ view: { getPathString(): string }, channel?: string }} T
+ * @param {Set<T> | Iterable<T>} members
+ * @returns {T[]}
+ */
+export function orderResolutionMembers(members) {
+    return Array.from(members).sort((a, b) =>
+        memberKey(a).localeCompare(memberKey(b))
+    );
+}

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

@@ -1 +1 @@
-{"version":3,"file":"scaleInteractionController.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInteractionController.js"],"names":[],"mappings":"AAkBA;;;;;;;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"}
+{"version":3,"file":"scaleInteractionController.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInteractionController.js"],"names":[],"mappings":"AAuBA;;;;;;;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,iBAkE1B;IASD;;;;OAIG;IACH,qBAcC;IAED;;OAEG;IACH,uBAOC;;CACJ;4BA/PY,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"}