@genome-spy/core 0.66.1 → 0.68.0

package/dist/src/scales/domainPlanner.js

@@ -0,0 +1,285 @@
+import { span } from "vega-util";
+import { isContinuous } from "vega-scale";
+
+import { LOCUS } from "./scaleResolutionConstants.js";
+import createDomain from "../utils/domainArray.js";
+import { getAccessorDomainKey, isScaleAccessor } from "../encoder/accessor.js";
+
+/**
+ * @typedef {import("../utils/domainArray.js").DomainArray} DomainArray
+ * @typedef {import("../spec/scale.js").ComplexDomain} ComplexDomain
+ * @typedef {import("../spec/scale.js").ScalarDomain} ScalarDomain
+ * @typedef {import("./scaleResolution.js").ScaleResolutionMember} ScaleResolutionMember
+ */
+
+export default class DomainPlanner {
+    /** @type {() => Set<ScaleResolutionMember>} */
+    #getMembers;
+
+    /** @type {() => Set<ScaleResolutionMember>} */
+    #getDataMembers;
+
+    /** @type {() => import("../spec/channel.js").Type} */
+    #getType;
+
+    /** @type {() => number[]} */
+    #getLocusExtent;
+
+    /** @type {(interval: ScalarDomain | ComplexDomain) => number[]} */
+    #fromComplexInterval;
+
+    /** @type {any[]} */
+    #initialDomain;
+
+    /** @type {DomainArray | undefined} */
+    #configuredDomain;
+
+    #configuredDomainDirty = true;
+
+    /** @type {WeakMap<ScaleResolutionMember, import("../types/encoder.js").ScaleAccessor[]>} */
+    #accessorsByMember = new WeakMap();
+
+    /**
+     * @param {object} options
+     * @param {() => Set<ScaleResolutionMember>} options.getMembers
+     * @param {() => Set<ScaleResolutionMember>} [options.getDataMembers]
+     * @param {() => import("../spec/channel.js").Type} options.getType
+     * @param {() => number[]} options.getLocusExtent
+     * @param {(interval: ScalarDomain | ComplexDomain) => number[]} options.fromComplexInterval
+     */
+    constructor({
+        getMembers,
+        getDataMembers,
+        getType,
+        getLocusExtent,
+        fromComplexInterval,
+    }) {
+        this.#getMembers = getMembers;
+        this.#getDataMembers = getDataMembers ?? getMembers;
+        this.#getType = getType;
+        this.#getLocusExtent = getLocusExtent;
+        this.#fromComplexInterval = fromComplexInterval;
+    }
+
+    /**
+     * @returns {any[]}
+     */
+    get initialDomainSnapshot() {
+        return this.#initialDomain;
+    }
+
+    hasConfiguredDomain() {
+        return !!this.getConfiguredDomain();
+    }
+
+    invalidateConfiguredDomain() {
+        this.#configuredDomainDirty = true;
+    }
+
+    /**
+     * Returns the configured domain or a data-derived/default domain.
+     *
+     * @param {boolean} [extractDataDomain]
+     * @returns {any[]}
+     */
+    getConfiguredOrDefaultDomain(extractDataDomain = false) {
+        // TODO: intersect the domain with zoom extent (if it's defined)
+        return (
+            this.getConfiguredDomain() ??
+            resolveDefaultDomain(
+                this.#getType(),
+                this.#getLocusExtent,
+                extractDataDomain ? this.getDataDomain() : undefined
+            )
+        );
+    }
+
+    /**
+     * Unions the configured domains of all participating views.
+     *
+     * @return {DomainArray}
+     */
+    getConfiguredDomain() {
+        if (!this.#configuredDomainDirty) {
+            return this.#configuredDomain;
+        }
+
+        const domain = resolveConfiguredDomain(
+            this.#getMembers(),
+            this.#fromComplexInterval
+        );
+        this.#configuredDomain = domain;
+        this.#configuredDomainDirty = false;
+        return domain;
+    }
+
+    /**
+     * Extracts and unions the data domains of all participating views.
+     *
+     * @return {DomainArray | undefined}
+     */
+    getDataDomain() {
+        return resolveDataDomain(
+            this.#getDataMembers(),
+            this.#getType,
+            (member) => this.#getMemberAccessors(member)
+        );
+    }
+
+    /**
+     * @param {import("../types/encoder.js").VegaScale} scale
+     * @param {boolean} domainWasInitialized
+     * @returns {boolean} true if listeners should be notified immediately
+     */
+    captureInitialDomain(scale, domainWasInitialized) {
+        if (!this.#initialDomain && isContinuous(scale.type)) {
+            const domain = scale.domain();
+            if (span(domain) > 0) {
+                this.#initialDomain = domain;
+            }
+        }
+
+        if (!domainWasInitialized) {
+            this.#initialDomain = scale.domain();
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     * @returns {import("../types/encoder.js").ScaleAccessor[]}
+     */
+    #getMemberAccessors(member) {
+        const cached = this.#accessorsByMember.get(member);
+        if (cached) {
+            return cached;
+        }
+
+        const encoders = member.view.mark.encoders;
+        if (!encoders) {
+            return [];
+        }
+
+        const encoder = encoders[member.channel];
+        if (!encoder) {
+            return [];
+        }
+
+        const accessors = encoder.accessors ?? [];
+        if (accessors.length === 0) {
+            return [];
+        }
+
+        const scaleAccessors = accessors
+            .filter(isScaleAccessor)
+            .filter((accessor) => !accessor.channelDef.domainInert);
+
+        this.#accessorsByMember.set(member, scaleAccessors);
+        return scaleAccessors;
+    }
+}
+
+/**
+ * @param {Set<ScaleResolutionMember>} members
+ * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
+ * @returns {DomainArray | undefined}
+ */
+function resolveConfiguredDomain(members, fromComplexInterval) {
+    const domains = 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)
+            )
+        );
+
+    if (domains.length > 0) {
+        return domains.reduce((acc, curr) => acc.extendAll(curr));
+    }
+}
+
+/**
+ * @param {Set<ScaleResolutionMember>} members
+ * @param {() => import("../spec/channel.js").Type} getType
+ * @param {(member: ScaleResolutionMember) => import("../types/encoder.js").ScaleAccessor[]} getAccessorsForMember
+ * @returns {DomainArray | undefined}
+ */
+function resolveDataDomain(members, getType, getAccessorsForMember) {
+    const type = getType();
+
+    /** @type {Map<import("../data/collector.js").default | null, Map<string, DomainArray>>} */
+    const domainsByCollector = new Map();
+
+    for (const member of members) {
+        if (!member.contributesToDomain) {
+            continue;
+        }
+
+        const accessors = getAccessorsForMember(member);
+        if (accessors.length === 0) {
+            continue;
+        }
+
+        const collector = member.view.getCollector();
+
+        for (const accessor of accessors) {
+            const domainKey = getAccessorDomainKey(accessor, type);
+
+            const collectorKey = collector ?? null;
+            let domainsForCollector = domainsByCollector.get(collectorKey);
+            if (!domainsForCollector) {
+                domainsForCollector = new Map();
+                domainsByCollector.set(collectorKey, domainsForCollector);
+            }
+
+            if (domainsForCollector.has(domainKey)) {
+                continue;
+            }
+
+            let domain;
+            if (collector) {
+                domain = collector.getDomain(domainKey, type, accessor);
+            } else if (accessor.constant) {
+                domain = createDomain(type);
+                domain.extend(accessor({}));
+            } else {
+                continue;
+            }
+
+            domainsForCollector.set(domainKey, domain);
+        }
+    }
+
+    if (domainsByCollector.size === 0) {
+        return undefined;
+    }
+
+    const domain = createDomain(type);
+    for (const domainsForCollector of domainsByCollector.values()) {
+        for (const memberDomain of domainsForCollector.values()) {
+            domain.extendAll(memberDomain);
+        }
+    }
+
+    return domain;
+}
+
+/**
+ * @param {import("../spec/channel.js").Type} type
+ * @param {() => number[]} getLocusExtent
+ * @param {DomainArray | undefined} dataDomain
+ * @returns {any[]}
+ */
+function resolveDefaultDomain(type, getLocusExtent, dataDomain) {
+    if (type == LOCUS) {
+        return getLocusExtent();
+    }
+    return dataDomain ?? [];
+}

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,kFALG;QAAkE,gBAAgB,EAA1E,MAAM,OAAO,0BAA0B,EAAE,OAAO;QAC5B,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;;CA6EJ"}
+{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,kFALG;QAAkE,gBAAgB,EAA1E,MAAM,OAAO,0BAA0B,EAAE,OAAO;QAC5B,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;;CAiFJ"}

package/dist/src/scales/scaleInstanceManager.js

@@ -142,12 +142,16 @@ export default class ScaleInstanceManager {
      * @returns {import("../spec/scale.js").Scale}
      */
     #stripNonScaleProps(props) {
-        if (!("assembly" in props)) {
-            return props;
-        }
         // Avoid sending non-scale properties into vega-scale.
-        const { assembly: _assembly, ...rest } = props;
+        // Strip internal runtime-only props before passing into vega-scale.
+        const propsAny = /** @type {any} */ (props);
+        const {
+            assembly: _assembly,
+            domainIndexer: _domainIndexer,
+            ...rest
+        } = propsAny;
         void _assembly;
+        void _domainIndexer;
         return rest;
     }
 

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

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

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

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

package/dist/src/scales/scaleInteractionController.js

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AA0mBA;;;;;;;;;;;;GAYG;AACH,mDAFW,OAAO,iBAAiB,EAAE,OAAO,GAAG,OAAO,iBAAiB,EAAE,OAAO,EAAE,QA4BjF;AA5mBD;;;;;;;;GAQG;AACH;;;;;;;;GAQG;AACH;IAsCI;;OAEG;IACH,2DAgCC;IA/BG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IA2CzB,2BASC;IAqBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAyED;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAQzB;IA8ED;;;;;OAKG;IACH,oBAGC;IAED;;;;OAIG;IACH,0BAKC;IAkDD;;OAEG;IACH;eAtWkC,OAAO,kBAAkB,EAAE,KAAK;MA6WjE;IAED;;;;;;OAMG;IACH;eAtXkC,OAAO,kBAAkB,EAAE,KAAK;MAwXjE;IAED;;;;OAIG;IACH;eA/XkC,OAAO,kBAAkB,EAAE,KAAK;MAwYjE;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;kCAlkB+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;sBAChD,CAAC,OAAO,+CAAkB,EAAE,IAAI,EAAE,OAAO,oBAAoB,EAAE,IAAI,kDAAgB;;sBArBtF,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}
+{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAuCA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA8CI;;OAEG;IACH,2DAkCC;IAjCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAoEzB,2BASC;IAqBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IA6ED;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAYzB;IAWD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IA4HD;;;;;OAKG;IACH,oBAUC;IAED;;;;;OAKG;IACH,0BAuBC;IAuGD;;OAEG;IACH;eA5jBkC,OAAO,kBAAkB,EAAE,KAAK;MAmkBjE;IAED;;;;;;OAMG;IACH;eA5kBkC,OAAO,kBAAkB,EAAE,KAAK;MA8kBjE;IAED;;;;OAIG;IACH;eArlBkC,OAAO,kBAAkB,EAAE,KAAK;MA8lBjE;IAED,mBAEC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CAMzC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBAGC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAK1B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCAlyB+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBAvBV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}