@genome-spy/core 0.72.0 → 0.74.0

package/dist/src/scales/domainPlanner.js

@@ -1,28 +1,51 @@
 import { span } from "vega-util";
 import { isContinuous } from "vega-scale";
 
-import { LOCUS } from "./scaleResolutionConstants.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 { getEncoderAccessors, getPrimaryChannel } from "../encoder/encoder.js";
+import {
+    hasExplicitLocusUpperBound,
+    isChromosomalLocusInterval,
+} from "../genome/genome.js";
 
 /**
  * @typedef {import("../utils/domainArray.js").DomainArray} DomainArray
  * @typedef {import("../spec/scale.js").ComplexDomain} ComplexDomain
  * @typedef {import("../spec/scale.js").ScalarDomain} ScalarDomain
+ * @typedef {import("../spec/scale.js").SelectionDomainRef} SelectionDomainRef
  * @typedef {import("./scaleResolution.js").ScaleResolutionMember} ScaleResolutionMember
+ * @typedef {{
+ *   param: string,
+ *   encoding: "x" | "y",
+ *   hasInitial: boolean,
+ *   runtime: any,
+ * }} SelectionDomainLinkInfo
  */
 
 export default class DomainPlanner {
     /** @type {() => Set<ScaleResolutionMember>} */
     #getMembers;
 
+    /** @type {() => Set<ScaleResolutionMember>} */
+    #getAllMembers;
+
     /** @type {() => Set<ScaleResolutionMember>} */
     #getDataMembers;
 
     /** @type {() => import("../spec/channel.js").Type} */
     #getType;
 
-    /** @type {() => number[]} */
+    /** @type {(assembly: import("../spec/scale.js").Scale["assembly"] | undefined) => number[]} */
     #getLocusExtent;
 
     /** @type {(interval: ScalarDomain | ComplexDomain) => number[]} */
@@ -31,30 +54,36 @@ 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 {() => number[]} options.getLocusExtent
+     * @param {(assembly: import("../spec/scale.js").Scale["assembly"] | undefined) => number[]} options.getLocusExtent
      * @param {(interval: ScalarDomain | ComplexDomain) => number[]} options.fromComplexInterval
      */
     constructor({
         getMembers,
+        getAllMembers,
         getDataMembers,
         getType,
         getLocusExtent,
         fromComplexInterval,
     }) {
         this.#getMembers = getMembers;
+        this.#getAllMembers = getAllMembers ?? getMembers;
         this.#getDataMembers = getDataMembers ?? getMembers;
         this.#getType = getType;
         this.#getLocusExtent = getLocusExtent;
@@ -68,49 +97,118 @@ export default class DomainPlanner {
         return this.#initialDomain;
     }
 
-    hasConfiguredDomain() {
-        return !!this.getConfiguredDomain();
+    /**
+     * @param {{ includeSelectionInitial?: boolean }} [options]
+     */
+    hasConfiguredDomain(options = {}) {
+        return !!this.getConfiguredDomain(options);
+    }
+
+    hasSelectionConfiguredDomain() {
+        this.getSelectionConfiguredDomainBindingInfo();
+        return !!this.#selectionDomainLinkInfo;
+    }
+
+    /**
+     * @returns {SelectionDomainLinkInfo | undefined}
+     */
+    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();
+    }
+
+    /**
+     * Returns the default domain without considering configured domains.
+     *
+     * @param {boolean} [extractDataDomain]
+     * @param {import("../spec/scale.js").Scale["assembly"]} [locusAssembly]
+     * @returns {any[]}
+     */
+    getDefaultDomain(extractDataDomain = false, locusAssembly) {
+        return resolveDefaultDomain(
+            this.#getType(),
+            this.#getLocusExtent,
+            extractDataDomain ? this.getDataDomain() : undefined,
+            locusAssembly
+        );
     }
 
     /**
      * Returns the configured domain or a data-derived/default domain.
      *
      * @param {boolean} [extractDataDomain]
+     * @param {import("../spec/scale.js").Scale["assembly"]} [locusAssembly]
+     * @param {{ includeSelectionInitial?: boolean }} [options]
      * @returns {any[]}
      */
-    getConfiguredOrDefaultDomain(extractDataDomain = false) {
+    getConfiguredOrDefaultDomain(
+        extractDataDomain = false,
+        locusAssembly,
+        options = {}
+    ) {
         // TODO: intersect the domain with zoom extent (if it's defined)
         return (
-            this.getConfiguredDomain() ??
-            resolveDefaultDomain(
-                this.#getType(),
-                this.#getLocusExtent,
-                extractDataDomain ? this.getDataDomain() : undefined
-            )
+            this.getConfiguredDomain(options) ??
+            this.getDefaultDomain(extractDataDomain, locusAssembly)
         );
     }
 
     /**
      * 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 domain = resolveConfiguredDomain(
+        const configuredDomain = resolveConfiguredDomain(
             this.#getMembers(),
-            this.#fromComplexInterval
+            this.#fromComplexInterval,
+            includeSelectionInitial
+        );
+        validateSharedSelectionDomain(
+            this.#getAllMembers(),
+            configuredDomain.selectionRef
+        );
+        this.#selectionDomainLinkInfo = configuredDomain.selectionRef;
+        this.#configuredDomainsByInitialMode.set(
+            includeSelectionInitial,
+            configuredDomain.domain
         );
-        this.#configuredDomain = domain;
         this.#configuredDomainDirty = false;
-        return domain;
+        return configuredDomain.domain;
     }
 
     /**
@@ -129,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;
         }
 
@@ -167,7 +266,7 @@ export default class DomainPlanner {
             return [];
         }
 
-        const accessors = encoder.accessors ?? [];
+        const accessors = getEncoderAccessors(encoder);
         if (accessors.length === 0) {
             return [];
         }
@@ -184,25 +283,277 @@ export default class DomainPlanner {
 /**
  * @param {Set<ScaleResolutionMember>} members
  * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
- * @returns {DomainArray | undefined}
+ * @param {boolean} includeSelectionInitial
+ * @returns {{
+ *   domain: DomainArray | undefined,
+ *   selectionRef: SelectionDomainLinkInfo | undefined,
+ * }}
  */
-function resolveConfiguredDomain(members, fromComplexInterval) {
-    const domains = Array.from(members)
+function resolveConfiguredDomain(
+    members,
+    fromComplexInterval,
+    includeSelectionInitial
+) {
+    const domainMembers = Array.from(members)
         .filter((member) => member.contributesToDomain)
-        .map((member) => member.channelDef)
-        .filter((channelDef) => channelDef.scale?.domain)
-        .map((channelDef) =>
-            // TODO: Handle ExprRefs and Param in domain
-            createDomain(
-                channelDef.type,
-                // Chrom/pos must be linearized first
-                fromComplexInterval(channelDef.scale.domain)
+        .filter((member) => member.channelDef.scale?.domain);
+
+    /** @type {DomainArray[]} */
+    const domains = [];
+
+    /** @type {any} */
+    let selectionRefRuntime = undefined;
+    /** @type {string | undefined} */
+    let selectionRefDescription = undefined;
+    /** @type {SelectionDomainLinkInfo | undefined} */
+    let selectionRef = undefined;
+    let hasLiteralDomain = false;
+
+    for (const member of domainMembers) {
+        const domainDef = member.channelDef.scale.domain;
+        if (isSelectionDomainRef(domainDef)) {
+            if (hasLiteralDomain) {
+                throw new Error(
+                    "Cannot mix selection-driven and literal configured domains on a shared scale."
+                );
+            }
+
+            const resolved = resolveSelectionDomain(
+                member,
+                domainDef,
+                fromComplexInterval,
+                includeSelectionInitial
+            );
+
+            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 +
+                        " vs " +
+                        resolved.description +
+                        "."
+                );
+            }
+
+            selectionRefRuntime = resolved.runtime;
+            selectionRefDescription = resolved.description;
+            selectionRef = {
+                param: resolved.param,
+                encoding: resolved.encoding,
+                hasInitial:
+                    (selectionRef?.hasInitial ?? false) || resolved.hasInitial,
+                runtime: resolved.runtime,
+            };
+
+            if (resolved.domain) {
+                domains.push(resolved.domain);
+            }
+            continue;
+        }
+
+        if (selectionRefRuntime) {
+            throw new Error(
+                "Cannot mix literal configured domains with selection-driven domains on a shared scale."
+            );
+        }
+
+        hasLiteralDomain = true;
+        domains.push(
+            resolveConfiguredIntervalDomain(
+                member.channelDef.type,
+                domainDef,
+                fromComplexInterval
             )
         );
+    }
 
     if (domains.length > 0) {
-        return domains.reduce((acc, curr) => acc.extendAll(curr));
+        return {
+            domain: domains.reduce((acc, curr) => acc.extendAll(curr)),
+            selectionRef,
+        };
+    }
+
+    if (selectionRefRuntime) {
+        // Selection refs are still the source of truth even when the
+        // selection interval currently resolves to no domain.
+        return { domain: undefined, selectionRef };
+    }
+
+    return { domain: undefined, selectionRef: undefined };
+}
+
+/**
+ * @param {ScaleResolutionMember} member
+ * @param {SelectionDomainRef} domainRef
+ * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
+ * @param {boolean} includeSelectionInitial
+ * @returns {{
+ *   domain: DomainArray | undefined,
+ *   description: string,
+ *   param: string,
+ *   encoding: "x" | "y",
+ *   hasInitial: boolean,
+ *   runtime: any,
+ * }}
+ */
+function resolveSelectionDomain(
+    member,
+    domainRef,
+    fromComplexInterval,
+    includeSelectionInitial
+) {
+    const paramName = domainRef.param;
+
+    const resolvedChannel = resolveSelectionDomainChannel(
+        member.channel,
+        domainRef,
+        paramName
+    );
+
+    const binding = resolveIntervalSelectionBinding(
+        member.view,
+        paramName,
+        resolvedChannel
+    );
+    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: initialDomain,
+            description,
+            param: paramName,
+            encoding: resolvedChannel,
+            hasInitial,
+            runtime: binding.runtime,
+        };
+    }
+
+    return {
+        // Selection intervals already use internal scale-domain coordinates.
+        domain: createDomain(
+            member.channelDef.type,
+            fromComplexInterval(interval)
+        ),
+        description,
+        param: paramName,
+        encoding: resolvedChannel,
+        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
+ * @param {string} paramName
+ * @returns {"x" | "y"}
+ */
+function resolveSelectionDomainChannel(channel, domainRef, paramName) {
+    if (domainRef.encoding) {
+        return domainRef.encoding;
+    }
+
+    const primaryChannel = getPrimaryChannel(channel);
+    if (primaryChannel === "x" || primaryChannel === "y") {
+        return primaryChannel;
+    }
+
+    throw new Error(
+        `Selection domain reference "${paramName}" on channel "${channel}" requires an explicit "encoding" ("x" or "y").`
+    );
+}
+
+/**
+ * @param {any} domain
+ * @returns {domain is SelectionDomainRef}
+ */
+export function isSelectionDomainRef(domain) {
+    return (
+        typeof domain === "object" &&
+        domain !== null &&
+        !Array.isArray(domain) &&
+        typeof domain.param === "string"
+    );
 }
 
 /**
@@ -273,13 +624,17 @@ function resolveDataDomain(members, getType, getAccessorsForMember) {
 
 /**
  * @param {import("../spec/channel.js").Type} type
- * @param {() => number[]} getLocusExtent
+ * @param {(assembly: import("../spec/scale.js").Scale["assembly"] | undefined) => number[]} getLocusExtent
  * @param {DomainArray | undefined} dataDomain
+ * @param {import("../spec/scale.js").Scale["assembly"] | undefined} locusAssembly
  * @returns {any[]}
  */
-function resolveDefaultDomain(type, getLocusExtent, dataDomain) {
+function resolveDefaultDomain(type, getLocusExtent, dataDomain, locusAssembly) {
     if (type == LOCUS) {
-        return getLocusExtent();
+        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"}