@genome-spy/core 0.36.1 → 0.37.0

package/dist/src/view/renderingContext/layoutRecorderViewRenderingContext.d.ts

@@ -0,0 +1,60 @@
+/**
+ * A Rendering context that doesn't render anything. It creates a hierarchy
+ * of view coordinates, including faceted views that are repeated multiple times.
+ * The coordinates can be used for mouse events / interactions, for example.
+ *
+ * @typedef {import("../view").default} View
+ * @typedef {import("../../utils/layout/rectangle").default} Rectangle
+ *
+ */
+export default class LayoutRecorderViewRenderingContext extends ViewRenderingContext {
+    /** @type {ViewCoords} */
+    root: ViewCoords;
+    /** @type {ViewCoords[]} */
+    stack: ViewCoords[];
+    /** @type {ViewCoords} */
+    lastAddition: ViewCoords;
+    getLayout(): ViewCoords;
+}
+/**
+ * A Rendering context that doesn't render anything. It creates a hierarchy
+ * of view coordinates, including faceted views that are repeated multiple times.
+ * The coordinates can be used for mouse events / interactions, for example.
+ */
+export type View = import("../view").default;
+/**
+ * A Rendering context that doesn't render anything. It creates a hierarchy
+ * of view coordinates, including faceted views that are repeated multiple times.
+ * The coordinates can be used for mouse events / interactions, for example.
+ */
+export type Rectangle = import("../../utils/layout/rectangle").default;
+import ViewRenderingContext from "./viewRenderingContext";
+/**
+ * Represents coordinates of view instances. Faceted views objects may have
+ * been rendered at multiple locations.
+ */
+declare class ViewCoords {
+    /**
+     * @param {View} view
+     * @param {Rectangle} coords
+     */
+    constructor(view: View, coords: Rectangle);
+    view: import("../view").default;
+    coords: import("../../utils/layout/rectangle").default;
+    /** @type {ViewCoords[]} */
+    children: ViewCoords[];
+    /**
+     *
+     * @param {ViewCoords} viewCoords
+     */
+    addChild(viewCoords: ViewCoords): void;
+    /**
+     * Broadcasts a message to views that include the given (x, y) point.
+     * This is mainly intended for mouse events.
+     *
+     * @param {import("../../utils/interactionEvent").default} event
+     */
+    dispatchInteractionEvent(event: import("../../utils/interactionEvent").default): void;
+}
+export {};
+//# sourceMappingURL=layoutRecorderViewRenderingContext.d.ts.map

package/dist/src/view/renderingContext/layoutRecorderViewRenderingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layoutRecorderViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/layoutRecorderViewRenderingContext.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH;IAOQ,yBAAyB;IACzB,MADW,UAAU,CACA;IAErB,2BAA2B;IAC3B,OADW,UAAU,EAAE,CACR;IAEf,yBAAyB;IACzB,cADW,UAAU,CACQ;IAgCjC,wBAEC;CACJ;;;;;;mBArDY,OAAO,SAAS,EAAE,OAAO;;;;;;wBACzB,OAAO,8BAA8B,EAAE,OAAO;iCAR1B,wBAAwB;AA8DzD;;;GAGG;AACH;IACI;;;OAGG;IACH,kBAHW,IAAI,UACJ,SAAS,EAOnB;IAJG,gCAAgB;IAChB,uDAAoB;IACpB,2BAA2B;IAC3B,UADW,UAAU,EAAE,CACL;IAGtB;;;OAGG;IACH,qBAFW,UAAU,QAcpB;IAED;;;;;OAKG;IACH,gCAFW,OAAO,8BAA8B,EAAE,OAAO,QAyBxD;CACJ"}

package/dist/src/view/renderingContext/layoutRecorderViewRenderingContext.js

@@ -0,0 +1,128 @@
+import { peek } from "../../utils/arrayUtils";
+import ViewRenderingContext from "./viewRenderingContext";
+
+/**
+ * A Rendering context that doesn't render anything. It creates a hierarchy
+ * of view coordinates, including faceted views that are repeated multiple times.
+ * The coordinates can be used for mouse events / interactions, for example.
+ *
+ * @typedef {import("../view").default} View
+ * @typedef {import("../../utils/layout/rectangle").default} Rectangle
+ *
+ */
+export default class LayoutRecorderViewRenderingContext extends ViewRenderingContext {
+    /**
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     */
+    constructor(globalOptions) {
+        super(globalOptions);
+
+        /** @type {ViewCoords} */
+        this.root = undefined;
+
+        /** @type {ViewCoords[]} */
+        this.stack = [];
+
+        /** @type {ViewCoords} */
+        this.lastAddition = undefined;
+    }
+
+    /**
+     * Must be called when a view's render() method is entered
+     *
+     * @param {View} view
+     * @param {Rectangle} coords View coordinates
+     *      inside the padding.
+     */
+    pushView(view, coords) {
+        // TODO: Facet id
+
+        const viewCoords = new ViewCoords(view, coords);
+
+        if (!this.root) {
+            this.root = viewCoords;
+        } else {
+            peek(this.stack).addChild(viewCoords);
+        }
+        this.stack.push(viewCoords);
+    }
+
+    /**
+     * Must be called when a view's render() method is being exited
+     *
+     * @param {View} view
+     */
+    popView(view) {
+        this.stack.pop();
+    }
+
+    getLayout() {
+        return this.root;
+    }
+}
+
+/**
+ * Represents coordinates of view instances. Faceted views objects may have
+ * been rendered at multiple locations.
+ */
+class ViewCoords {
+    /**
+     * @param {View} view
+     * @param {Rectangle} coords
+     */
+    constructor(view, coords) {
+        this.view = view;
+        this.coords = coords;
+        /** @type {ViewCoords[]} */
+        this.children = [];
+    }
+
+    /**
+     *
+     * @param {ViewCoords} viewCoords
+     */
+    addChild(viewCoords) {
+        const last = peek(this.children);
+        if (
+            last &&
+            viewCoords.view === last.view &&
+            viewCoords.coords.equals(last.coords)
+        ) {
+            // Skip extra copies of sample facets. They all have the same coords.
+            return;
+        }
+
+        this.children.push(viewCoords);
+    }
+
+    /**
+     * Broadcasts a message to views that include the given (x, y) point.
+     * This is mainly intended for mouse events.
+     *
+     * @param {import("../../utils/interactionEvent").default} event
+     */
+    dispatchInteractionEvent(event) {
+        if (this.coords.containsPoint(event.point.x, event.point.y)) {
+            this.view.handleInteractionEvent(this.coords, event, true);
+            if (event.stopped) {
+                return;
+            }
+
+            if (this.children.length == 0) {
+                event.target = this.view;
+            } else {
+                for (const child of this.children) {
+                    child.dispatchInteractionEvent(event);
+                    if (event.target) {
+                        break;
+                    }
+                    if (event.stopped) {
+                        return;
+                    }
+                }
+            }
+
+            this.view.handleInteractionEvent(this.coords, event, false);
+        }
+    }
+}

package/dist/src/view/renderingContext/simpleViewRenderingContext.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This class is mainly for illustrative purpose, i.e., how the rendering
+ * would be performed in the most straightforward, unoptimized way.
+ *
+ * @typedef {import("../view").default} View
+ */
+export default class SimpleViewRenderingContext extends ViewRenderingContext {
+    /** @type {import("../../utils/layout/rectangle").default} */
+    coords: import("../../utils/layout/rectangle").default;
+    /** @type {Set<import("../view").default>} */
+    views: Set<import("../view").default>;
+}
+/**
+ * This class is mainly for illustrative purpose, i.e., how the rendering
+ * would be performed in the most straightforward, unoptimized way.
+ */
+export type View = import("../view").default;
+import ViewRenderingContext from "./viewRenderingContext";
+//# sourceMappingURL=simpleViewRenderingContext.d.ts.map

package/dist/src/view/renderingContext/simpleViewRenderingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/simpleViewRenderingContext.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAMQ,6DAA6D;IAC7D,QADW,OAAO,8BAA8B,EAAE,OAAO,CAClC;IAEvB,6CAA6C;IAC7C,OADW,IAAI,OAAO,SAAS,EAAE,OAAO,CAAC,CACnB;CA6C7B;;;;;mBAzDY,OAAO,SAAS,EAAE,OAAO;iCANL,wBAAwB"}

package/dist/src/view/renderingContext/simpleViewRenderingContext.js

@@ -0,0 +1,64 @@
+import ViewRenderingContext from "./viewRenderingContext";
+
+/**
+ * This class is mainly for illustrative purpose, i.e., how the rendering
+ * would be performed in the most straightforward, unoptimized way.
+ *
+ * @typedef {import("../view").default} View
+ */
+export default class SimpleViewRenderingContext extends ViewRenderingContext {
+    /**
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     */
+    constructor(globalOptions) {
+        super(globalOptions);
+        /** @type {import("../../utils/layout/rectangle").default} */
+        this.coords = undefined;
+
+        /** @type {Set<import("../view").default>} */
+        this.views = new Set();
+    }
+
+    /**
+     * Must be called when a view's render() method is entered
+     *
+     * @param {View} view
+     * @param {import("../../utils/layout/rectangle").default} coords View coordinates
+     *      inside the padding.
+     */
+    pushView(view, coords) {
+        if (!this.views.has(view)) {
+            // Ensure that the method is called only once, even when rendering facets.
+            view.onBeforeRender();
+            this.views.add(view);
+        }
+
+        this.coords = coords;
+    }
+
+    /**
+     * Must be called when a view's render() method is being exited
+     *
+     * @param {View} view
+     */
+    popView(view) {
+        //
+    }
+
+    /**
+     *
+     * @param {import("../../marks/mark").default} mark
+     * @param {import("../../types/rendering").RenderingOptions} options
+     */
+    renderMark(mark, options) {
+        if (this.globalOptions.picking && !mark.isPickingParticipant()) {
+            return;
+        }
+
+        for (const op of mark.prepareRender(this.globalOptions)) {
+            op();
+        }
+        mark.setViewport(this.coords, options.clipRect);
+        mark.render(options)();
+    }
+}

package/dist/src/view/renderingContext/svgViewRenderingContext.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A trivial proof-of-concept SVG rendering context. Doesn't render any
+ * marks at this point, only placeholders.
+ *
+ * @typedef {import("../view").default} View
+ */
+export default class SvgViewRenderingContext extends ViewRenderingContext {
+    /** @type {import("../../utils/layout/rectangle").default} */
+    coords: import("../../utils/layout/rectangle").default;
+    svg: SVGSVGElement;
+    /** @type {SVGElement[]} */
+    nodeStack: SVGElement[];
+    getSvg(): SVGSVGElement;
+    get _currentNode(): SVGElement;
+}
+/**
+ * A trivial proof-of-concept SVG rendering context. Doesn't render any
+ * marks at this point, only placeholders.
+ */
+export type View = import("../view").default;
+import ViewRenderingContext from "./viewRenderingContext";
+//# sourceMappingURL=svgViewRenderingContext.d.ts.map

package/dist/src/view/renderingContext/svgViewRenderingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svgViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/svgViewRenderingContext.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;IAQQ,6DAA6D;IAC7D,QADW,OAAO,8BAA8B,EAAE,OAAO,CAClC;IAEvB,mBAGC;IAED,2BAA2B;IAC3B,WADW,UAAU,EAAE,CACI;IAwE/B,wBAEC;IAED,+BAEC;CACJ;;;;;mBAlGY,OAAO,SAAS,EAAE,OAAO;iCANL,wBAAwB"}

package/dist/src/view/renderingContext/svgViewRenderingContext.js

@@ -0,0 +1,125 @@
+import { peek } from "../../utils/arrayUtils";
+import ViewRenderingContext from "./viewRenderingContext";
+
+/**
+ * A trivial proof-of-concept SVG rendering context. Doesn't render any
+ * marks at this point, only placeholders.
+ *
+ * @typedef {import("../view").default} View
+ */
+export default class SvgViewRenderingContext extends ViewRenderingContext {
+    /**
+     *
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     */
+    constructor(globalOptions) {
+        super(globalOptions);
+
+        /** @type {import("../../utils/layout/rectangle").default} */
+        this.coords = undefined;
+
+        this.svg = document.createElementNS(
+            "http://www.w3.org/2000/svg",
+            "svg"
+        );
+
+        /** @type {SVGElement[]} */
+        this.nodeStack = [this.svg];
+    }
+
+    /**
+     * Must be called when a view's render() method is entered
+     *
+     * @param {View} view
+     * @param {import("../../utils/layout/rectangle").default} coords View coordinates
+     *      inside the padding.
+     */
+    pushView(view, coords) {
+        view.onBeforeRender();
+        this.coords = coords;
+
+        if (this._currentNode === this.svg) {
+            const viewBox = coords.expand(view.getPadding());
+            this.svg.setAttributeNS(
+                null,
+                "viewBox",
+                [viewBox.x, viewBox.y, viewBox.width, viewBox.height].join(" ")
+            );
+        }
+
+        const group = createNode("g");
+        const title = createNode("title");
+        title.textContent = view.name;
+        group.appendChild(title);
+
+        this._currentNode.appendChild(group);
+        this.nodeStack.push(group);
+    }
+
+    /**
+     * Must be called when a view's render() method is being exited
+     *
+     * @param {View} view
+     */
+    popView(view) {
+        this.nodeStack.pop();
+    }
+
+    /**
+     *
+     * @param {import("../../marks/mark").default} mark
+     * @param {import("../../types/rendering").RenderingOptions} options
+     */
+    renderMark(mark, options) {
+        const current = this._currentNode;
+
+        const rect = createNode("rect", {
+            x: this.coords.x,
+            y: this.coords.y,
+            width: this.coords.width,
+            height: this.coords.height,
+            fill: "transparent",
+            stroke: "black",
+            "stroke-width": 1,
+        });
+
+        const name = createNode("text", {
+            x: this.coords.x + this.coords.width / 2,
+            y: this.coords.y + this.coords.height / 2,
+            "dominant-baseline": "middle",
+            "text-anchor": "middle",
+        });
+
+        name.textContent = mark.getType();
+
+        current.appendChild(rect);
+        current.appendChild(name);
+    }
+
+    getSvg() {
+        return this.svg;
+    }
+
+    get _currentNode() {
+        return peek(this.nodeStack);
+    }
+}
+
+/**
+ * Adapted from: https://stackoverflow.com/a/37411738/1547896
+ *
+ * @param {string} name
+ * @param {Record<string, any>} [attributes]
+ */
+function createNode(name, attributes) {
+    const element = document.createElementNS(
+        "http://www.w3.org/2000/svg",
+        name
+    );
+    if (attributes) {
+        for (const [k, v] of Object.entries(attributes)) {
+            element.setAttributeNS(null, k, v);
+        }
+    }
+    return element;
+}

package/dist/src/view/renderingContext/viewRenderingContext.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @typedef {import("../view").default} View
+ */
+export default class ViewRenderingContext {
+    /**
+     *
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     */
+    constructor(globalOptions: import("../../types/rendering").GlobalRenderingOptions);
+    globalOptions: import("../../types/rendering").GlobalRenderingOptions;
+    /**
+     * Must be called when a view's render() method is entered
+     *
+     * @param {View} view
+     * @param {import("../../utils/layout/rectangle").default} coords View coordinates
+     *      inside the padding.
+     */
+    pushView(view: View, coords: import("../../utils/layout/rectangle").default): void;
+    /**
+     * Must be called when a view's render() method is being exited
+     *
+     * @param {View} view
+     */
+    popView(view: View): void;
+    /**
+     *
+     * @param {import("../../marks/mark").default} mark
+     * @param {import("../../types/rendering").RenderingOptions} options
+     */
+    renderMark(mark: import("../../marks/mark").default, options: import("../../types/rendering").RenderingOptions): void;
+}
+export type View = import("../view").default;
+//# sourceMappingURL=viewRenderingContext.d.ts.map

package/dist/src/view/renderingContext/viewRenderingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/viewRenderingContext.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IACI;;;OAGG;IACH,2BAFW,OAAO,uBAAuB,EAAE,sBAAsB,EAIhE;IADG,sEAAkC;IAGtC;;;;;;OAMG;IACH,eAJW,IAAI,UACJ,OAAO,8BAA8B,EAAE,OAAO,QAKxD;IAED;;;;OAIG;IACH,cAFW,IAAI,QAId;IAED;;;;OAIG;IACH,iBAHW,OAAO,kBAAkB,EAAE,OAAO,WAClC,OAAO,uBAAuB,EAAE,gBAAgB,QAI1D;CACJ;mBAvCY,OAAO,SAAS,EAAE,OAAO"}

package/dist/src/view/renderingContext/viewRenderingContext.js

@@ -0,0 +1,41 @@
+/**
+ * @typedef {import("../view").default} View
+ */
+export default class ViewRenderingContext {
+    /**
+     *
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     */
+    constructor(globalOptions) {
+        this.globalOptions = globalOptions;
+    }
+
+    /**
+     * Must be called when a view's render() method is entered
+     *
+     * @param {View} view
+     * @param {import("../../utils/layout/rectangle").default} coords View coordinates
+     *      inside the padding.
+     */
+    pushView(view, coords) {
+        //
+    }
+
+    /**
+     * Must be called when a view's render() method is being exited
+     *
+     * @param {View} view
+     */
+    popView(view) {
+        //
+    }
+
+    /**
+     *
+     * @param {import("../../marks/mark").default} mark
+     * @param {import("../../types/rendering").RenderingOptions} options
+     */
+    renderMark(mark, options) {
+        //
+    }
+}

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

@@ -0,0 +1,170 @@
+/**
+ * Reconfigures scales, starting from the given view.
+ *
+ * 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").default | import("./view").default[]} fromViews
+ */
+export function reconfigureScales(fromViews: import("./view").default | import("./view").default[]): void;
+export const QUANTITATIVE: "quantitative";
+export const ORDINAL: "ordinal";
+export const NOMINAL: "nominal";
+export const LOCUS: "locus";
+export const INDEX: "index";
+/**
+ * @template {ChannelWithScale}[T=ChannelWithScale]
+ * @typedef {{view: import("./unitView").default, channel: T}} ResolutionMember
+ *
+ */
+/**
+ * Resolution takes care of merging domains and scales from multiple views.
+ * This class also provides some utility methods for zooming the scales etc..
+ *
+ * TODO: This has grown a bit too fat. Consider splitting.
+ *
+ * @implements {ScaleResolutionApi}
+ */
+export default class ScaleResolution implements ScaleResolutionApi {
+    /**
+     * @param {Channel} channel
+     */
+    constructor(channel: import("../spec/channel").Channel);
+    channel: import("../spec/channel").Channel;
+    /** @type {ResolutionMember[]} The involved views */
+    members: ResolutionMember<import("../spec/channel").ChannelWithScale>[];
+    /** @type {string} Data type (quantitative, nominal, etc...) */
+    type: string;
+    /** @type {string} An optional unique identifier for the scale */
+    name: string;
+    /**
+     * Adds a listener that is called when the scale domain is changed,
+     * e.g., zoomed. The call is synchronous and happens before the views
+     * are rendered.
+     *
+     * @param {"domain"} type
+     * @param {ScaleResolutionListener} listener function
+     */
+    addEventListener(type: "domain", listener: import("../types/scaleResolutionApi").ScaleResolutionListener): void;
+    /**
+     * @param {"domain"} type
+     * @param {ScaleResolutionListener} listener function
+     */
+    removeEventListener(type: "domain", listener: import("../types/scaleResolutionApi").ScaleResolutionListener): void;
+    /**
+     * Add a view to this resolution.
+     * N.B. This is expected to be called in depth-first order
+     *
+     * @param {UnitView} view
+     * @param {ChannelWithScale} channel
+     */
+    pushUnitView(view: import("./unitView").default, channel: import("../spec/channel").ChannelWithScale): void;
+    /**
+     * Returns true if the domain has been defined explicitly, i.e. not extracted from the data.
+     */
+    isExplicitDomain(): boolean;
+    isDomainInitialized(): boolean;
+    /**
+     * Returns the merged scale properties supplemented with inferred properties
+     * and domain.
+     *
+     * @returns {import("../spec/scale").Scale}
+     */
+    getScaleProps(): import("../spec/scale").Scale;
+    /**
+     * Unions the configured domains of all participating views.
+     *
+     * @return { DomainArray }
+     */
+    getConfiguredDomain(): import("../utils/domainArray").DomainArray;
+    /**
+     * Extracts and unions the data domains of all participating views.
+     *
+     * @return { DomainArray }
+     */
+    getDataDomain(): import("../utils/domainArray").DomainArray;
+    /**
+     * Reconfigures the scale: updates domain and other settings
+     */
+    reconfigure(): void;
+    /**
+     * @returns {VegaScale}
+     */
+    getScale(): import("../types/encoder").VegaScale;
+    getDomain(): any[];
+    /**
+     * @returns {NumericDomain | ComplexDomain}
+     */
+    getComplexDomain(): import("../spec/scale").NumericDomain | import("../spec/scale").ComplexDomain;
+    /**
+     * Return true if the scale is zoomable and the current domain differs from the initial domain.
+     *
+     * @returns true if zoomed
+     */
+    isZoomed(): boolean;
+    /**
+     * Returns true if zooming is supported and allowed in view spec.
+     */
+    isZoomable(): boolean;
+    /**
+     * Pans (translates) and zooms using a specified scale factor.
+     *
+     * @param {number} scaleFactor
+     * @param {number} scaleAnchor
+     * @param {number} pan
+     * @returns {boolean} true if the scale was zoomed
+     */
+    zoom(scaleFactor: number, scaleAnchor: number, pan: number): boolean;
+    /**
+     * Immediately zooms to the given interval.
+     *
+     * @param {NumericDomain | ComplexDomain} domain
+     * @param {boolean | number} [duration] an approximate duration for transition.
+     *      Zero duration zooms immediately. Boolean `true` indicates a default duration.
+     */
+    zoomTo(domain: import("../spec/scale").NumericDomain | import("../spec/scale").ComplexDomain, duration?: boolean | number): Promise<void>;
+    /**
+     * Resets the current domain to the initial one
+     *
+     * @returns true if the domain was changed
+     */
+    resetZoom(): boolean;
+    /**
+     * Returns the zoom level with respect to the reference domain span (the original domain).
+     *
+     * In principle, this is highly specific to positional channels. However, zooming can
+     * be generalized to other quantitative channels such as color, opacity, size, etc.
+     */
+    getZoomLevel(): number;
+    getGenome(): import("../genome/genome").default;
+    /**
+     * Inverts a value in range to a value on domain. Returns an object in
+     * case of locus scale.
+     *
+     * @param {number} value
+     */
+    invertToComplex(value: number): number | import("../spec/genome").ChromosomalLocus;
+    /**
+     * @param {number} value
+     */
+    toComplex(value: number): number | import("../spec/genome").ChromosomalLocus;
+    /**
+     * @param {number | ChromosomalLocus} complex
+     * @returns {number}
+     */
+    fromComplex(complex: number | import("../spec/genome").ChromosomalLocus): number;
+    /**
+     * @param {ScalarDomain | ComplexDomain} interval
+     * @returns {number[]}
+     */
+    fromComplexInterval(interval: import("../spec/scale").ScalarDomain | import("../spec/scale").ComplexDomain): number[];
+    #private;
+}
+export type ResolutionMember<T extends import("../spec/channel").ChannelWithScale = import("../spec/channel").ChannelWithScale> = {
+    view: import("./unitView").default;
+    channel: T;
+};
+//# sourceMappingURL=scaleResolution.d.ts.map