@genome-spy/core 0.72.0 → 0.73.0

package/dist/src/scales/domainPlanner.js

@@ -2,14 +2,22 @@ import { span } from "vega-util";
 import { isContinuous } from "vega-scale";
 
 import { LOCUS } from "./scaleResolutionConstants.js";
+import { requireIntervalSelection } from "./selectionDomainUtils.js";
 import createDomain from "../utils/domainArray.js";
 import { getAccessorDomainKey, isScaleAccessor } from "../encoder/accessor.js";
+import { getPrimaryChannel } from "../encoder/encoder.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",
+ *   sync: "auto" | "oneWay" | "twoWay",
+ * }} SelectionDomainLinkInfo
  */
 
 export default class DomainPlanner {
@@ -22,7 +30,7 @@ export default class DomainPlanner {
     /** @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[]} */
@@ -34,6 +42,9 @@ export default class DomainPlanner {
     /** @type {DomainArray | undefined} */
     #configuredDomain;
 
+    /** @type {SelectionDomainLinkInfo | undefined} */
+    #selectionDomainLinkInfo = undefined;
+
     #configuredDomainDirty = true;
 
     /** @type {WeakMap<ScaleResolutionMember, import("../types/encoder.js").ScaleAccessor[]>} */
@@ -44,7 +55,7 @@ export default class DomainPlanner {
      * @param {() => Set<ScaleResolutionMember>} options.getMembers
      * @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({
@@ -72,25 +83,51 @@ export default class DomainPlanner {
         return !!this.getConfiguredDomain();
     }
 
+    hasSelectionConfiguredDomain() {
+        this.getConfiguredDomain();
+        return !!this.#selectionDomainLinkInfo;
+    }
+
+    /**
+     * @returns {SelectionDomainLinkInfo | undefined}
+     */
+    getSelectionConfiguredDomainInfo() {
+        this.getConfiguredDomain();
+        return this.#selectionDomainLinkInfo;
+    }
+
     invalidateConfiguredDomain() {
         this.#configuredDomainDirty = true;
     }
 
+    /**
+     * 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]
      * @returns {any[]}
      */
-    getConfiguredOrDefaultDomain(extractDataDomain = false) {
+    getConfiguredOrDefaultDomain(extractDataDomain = false, locusAssembly) {
         // TODO: intersect the domain with zoom extent (if it's defined)
         return (
             this.getConfiguredDomain() ??
-            resolveDefaultDomain(
-                this.#getType(),
-                this.#getLocusExtent,
-                extractDataDomain ? this.getDataDomain() : undefined
-            )
+            this.getDefaultDomain(extractDataDomain, locusAssembly)
         );
     }
 
@@ -104,13 +141,14 @@ export default class DomainPlanner {
             return this.#configuredDomain;
         }
 
-        const domain = resolveConfiguredDomain(
+        const configuredDomain = resolveConfiguredDomain(
             this.#getMembers(),
             this.#fromComplexInterval
         );
-        this.#configuredDomain = domain;
+        this.#configuredDomain = configuredDomain.domain;
+        this.#selectionDomainLinkInfo = configuredDomain.selectionRef;
         this.#configuredDomainDirty = false;
-        return domain;
+        return configuredDomain.domain;
     }
 
     /**
@@ -184,25 +222,207 @@ export default class DomainPlanner {
 /**
  * @param {Set<ScaleResolutionMember>} members
  * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
- * @returns {DomainArray | undefined}
+ * @returns {{
+ *   domain: DomainArray | undefined,
+ *   selectionRef: SelectionDomainLinkInfo | undefined,
+ * }}
  */
 function resolveConfiguredDomain(members, fromComplexInterval) {
-    const domains = Array.from(members)
+    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 {string | undefined} */
+    let selectionRefKey = undefined;
+    /** @type {string | undefined} */
+    let selectionRefDescription = undefined;
+    /** @type {"auto" | "oneWay" | "twoWay" | undefined} */
+    let selectionRefSync = 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
+            );
+
+            if (selectionRefKey && selectionRefKey !== resolved.key) {
+                throw new Error(
+                    "Conflicting selection domain references on a shared scale: " +
+                        selectionRefDescription +
+                        " vs " +
+                        resolved.description +
+                        "."
+                );
+            }
+
+            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;
+            selectionRefDescription = resolved.description;
+            selectionRef = {
+                param: resolved.param,
+                encoding: resolved.encoding,
+                sync: selectionRefSync,
+            };
+
+            if (resolved.domain) {
+                domains.push(resolved.domain);
+            }
+            continue;
+        }
+
+        if (selectionRefKey) {
+            throw new Error(
+                "Cannot mix literal configured domains with selection-driven domains on a shared scale."
+            );
+        }
+
+        hasLiteralDomain = true;
+        domains.push(
+            createDomain(member.channelDef.type, fromComplexInterval(domainDef))
         );
+    }
 
     if (domains.length > 0) {
-        return domains.reduce((acc, curr) => acc.extendAll(curr));
+        return {
+            domain: domains.reduce((acc, curr) => acc.extendAll(curr)),
+            selectionRef,
+        };
+    }
+
+    if (selectionRefKey) {
+        // 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
+ * @returns {{
+ *   domain: DomainArray | undefined,
+ *   key: string,
+ *   description: string,
+ *   param: string,
+ *   encoding: "x" | "y",
+ *   sync: "auto" | "oneWay" | "twoWay",
+ * }}
+ */
+function resolveSelectionDomain(member, domainRef, fromComplexInterval) {
+    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,
+        domainRef,
+        paramName
+    );
+
+    const paramRuntime = member.view.paramRuntime;
+    const selection = requireIntervalSelection(
+        paramRuntime?.findValue(paramName),
+        paramName
+    );
+
+    const interval = selection.intervals[resolvedChannel];
+    const key = [paramName, resolvedChannel].join("|");
+    const description = paramName + "." + resolvedChannel;
+
+    if (!interval || interval.length !== 2) {
+        return {
+            domain: undefined,
+            key,
+            description,
+            param: paramName,
+            encoding: resolvedChannel,
+            sync: syncMode,
+        };
+    }
+
+    return {
+        domain: createDomain(
+            member.channelDef.type,
+            fromComplexInterval(interval)
+        ),
+        key,
+        description,
+        param: paramName,
+        encoding: resolvedChannel,
+        sync: syncMode,
+    };
+}
+
+/**
+ * @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 +493,14 @@ 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);
     }
     return dataDomain ?? [];
 }

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

@@ -18,9 +18,10 @@ export default class ScaleInstanceManager {
         props: import("../spec/scale.js").Scale;
     };
     /**
+     * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {import("../genome/genome.js").default}
      */
-    getLocusGenome(): import("../genome/genome.js").default;
+    getLocusGenome(assembly?: import("../spec/scale.js").Scale["assembly"]): import("../genome/genome.js").default;
     /**
      * @param {import("../spec/scale.js").Scale} props
      * @returns {ScaleWithProps}

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

@@ -1 +1 @@
-{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,iFALG;QAAkH,eAAe,EAAzH,MAAM;YAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,0BAA0B,EAAE,eAAe,CAAA;SAAE;QAC5E,aAAa,EAAjC,MAAM,IAAI;QACW,cAAc,GAAnC,MAAM,IAAI;QAC6D,cAAc,GAArF,MAAM,OAAO,0BAA0B,EAAE,OAAO,GAAG,SAAS;KAA0B,EAYhG;IAED;eA1CkC,OAAO,kBAAkB,EAAE,KAAK;MA4CjE;IAED;;OAEG;IACH,kBAFa,OAAO,qBAAqB,EAAE,OAAO,CASjD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eA3DT,OAAO,kBAAkB,EAAE,KAAK;MAgFjE;IAoBD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;IAmFD,gBAGC;;CACJ"}
+{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,iFALG;QAAkH,eAAe,EAAzH,MAAM;YAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,0BAA0B,EAAE,eAAe,CAAA;SAAE;QAC5E,aAAa,EAAjC,MAAM,IAAI;QACW,cAAc,GAAnC,MAAM,IAAI;QAC6D,cAAc,GAArF,MAAM,OAAO,0BAA0B,EAAE,OAAO,GAAG,SAAS;KAA0B,EAYhG;IAED;eA1CkC,OAAO,kBAAkB,EAAE,KAAK;MA4CjE;IAED;;;OAGG;IACH,0BAHW,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAC1C,OAAO,qBAAqB,EAAE,OAAO,CAajD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eAhET,OAAO,kBAAkB,EAAE,KAAK;MAqFjE;IAcD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;IAmFD,gBAGC;;CACJ"}

package/dist/src/scales/scaleInstanceManager.js

@@ -54,15 +54,20 @@ export default class ScaleInstanceManager {
     }
 
     /**
+     * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {import("../genome/genome.js").default}
      */
-    getLocusGenome() {
+    getLocusGenome(assembly) {
         const genomeStore = this.#getGenomeStore?.();
-        const genome = genomeStore?.getGenome();
-        if (!genome) {
+        if (!genomeStore) {
             throw new Error("No genome has been defined!");
         }
-        return genome;
+
+        if (assembly) {
+            return genomeStore.getGenome(assembly);
+        }
+
+        return genomeStore.getGenome();
     }
 
     /**
@@ -98,13 +103,7 @@ export default class ScaleInstanceManager {
             return;
         }
 
-        const genomeStore = this.#getGenomeStore?.();
-        const genome = genomeStore?.getGenome(props.assembly);
-        if (!genome) {
-            throw new Error("No genome has been defined!");
-        }
-
-        scale.genome(genome);
+        scale.genome(this.getLocusGenome(props.assembly));
     }
 
     /**

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

@@ -1 +1 @@
-{"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"}
+{"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"}

package/dist/src/scales/scaleInteractionController.js

@@ -7,9 +7,6 @@ import {
     panLog,
     panPow,
     span,
-    zoomLinear,
-    zoomLog,
-    zoomPow,
 } from "vega-util";
 import { isContinuous, isDiscrete } from "vega-scale";
 import { easeCubicInOut } from "d3-ease";
@@ -17,6 +14,7 @@ import { easeCubicInOut } from "d3-ease";
 import eerp from "../utils/eerp.js";
 import { shallowArrayEquals } from "../utils/arrayUtils.js";
 import { createCancelToken } from "../utils/transition.js";
+import { zoomDomainByScaleType } from "./zoomDomainUtils.js";
 
 /**
  * @typedef {import("../spec/scale.js").NumericDomain} NumericDomain
@@ -121,7 +119,7 @@ export default class ScaleInteractionController {
     isZoomed() {
         return (
             this.isZoomingSupported() &&
-            shallowArrayEquals(
+            !shallowArrayEquals(
                 this.#getResetDomain(),
                 this.#getScale().domain()
             )
@@ -326,17 +324,14 @@ function applyZoomTransform(scale, domain, scaleFactor, scaleAnchor, pan) {
         anchor += scale.align();
     }
 
-    // TODO: symlog
     switch (scale.type) {
         case "linear":
         case "index":
         case "locus":
             newDomain = panLinear(newDomain, pan || 0);
-            newDomain = zoomLinear(newDomain, anchor, scaleFactor);
             break;
         case "log":
             newDomain = panLog(newDomain, pan || 0);
-            newDomain = zoomLog(newDomain, anchor, scaleFactor);
             break;
         case "pow":
         case "sqrt": {
@@ -345,19 +340,26 @@ function applyZoomTransform(scale, domain, scaleFactor, scaleAnchor, pan) {
                     scale
                 );
             newDomain = panPow(newDomain, pan || 0, powScale.exponent());
-            newDomain = zoomPow(
-                newDomain,
-                anchor,
-                scaleFactor,
-                powScale.exponent()
-            );
+            break;
+        }
+        case "symlog": {
+            if (pan !== 0) {
+                throw new Error(
+                    "Panning is not implemented for: " + scale.type
+                );
+            }
             break;
         }
         default:
             throw new Error("Zooming is not implemented for: " + scale.type);
     }
 
-    return newDomain;
+    return zoomDomainByScaleType(
+        scale,
+        /** @type {[number, number]} */ (newDomain),
+        anchor,
+        scaleFactor
+    );
 }
 
 /**

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

@@ -63,6 +63,22 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * @returns {() => void}
      */
     registerCollectorSubscriptions(collector: import("../data/collector.js").default, accessors: Iterable<import("../types/encoder.js").ScaleAccessor>): () => void;
+    /**
+     * 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(): {
+        assembly: import("../spec/scale.js").Scale["assembly"] | undefined;
+        needsDefaultAssembly: boolean;
+    };
     /**
      * Reconfigures the scale: updates domain and other settings.
      *

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

@@ -1 +1 @@
-{"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;IAED,gBAIC;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;eAlkBkC,OAAO,kBAAkB,EAAE,KAAK;MAykBjE;IAED;;;;;;OAMG;IACH;eAllBkC,OAAO,kBAAkB,EAAE,KAAK;MAolBjE;IAED;;;;OAIG;IACH;eA3lBkC,OAAO,kBAAkB,EAAE,KAAK;MAomBjE;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;kCAxyB+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"}
+{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAgDA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAmDI;;OAEG;IACH,2DAkCC;IAjCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAoEzB,2BASC;IAwBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAkLD;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAazB;IAED,gBAKC;IA4CD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IA2CD;;;;;;;;;;;OAWG;IACH,0BALa;QACR,QAAQ,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC;QACnE,oBAAoB,EAAE,OAAO,CAAA;KAC9B,CAeH;IAmFD;;;;;OAKG;IACH,oBAYC;IAED;;;;;OAKG;IACH,0BAyBC;IA0HD;;OAEG;IACH;eApwBkC,OAAO,kBAAkB,EAAE,KAAK;MA2wBjE;IAED;;;;;;OAMG;IACH;eApxBkC,OAAO,kBAAkB,EAAE,KAAK;MAsxBjE;IAED;;;;OAIG;IACH;eA7xBkC,OAAO,kBAAkB,EAAE,KAAK;MAsyBjE;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;kCA1+B+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBAhCV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}