@genome-spy/core 0.36.1 → 0.37.0

package/dist/src/img/genomespy-favicon.svg

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 64 64" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:1.5;">
+    <g transform="matrix(0.10221,0.00683825,-0.0067136,0.100347,-8.03424,-13.2222)">
+        <path d="M208.629,548.17C208.629,548.17 219.768,594.389 239.814,619.222C259.86,644.055 319.119,680.831 319.119,680.831C319.119,680.831 385.557,622.915 437.87,498.346C437.87,498.346 456.021,499.236 473.808,486.446C491.594,473.656 490.239,478.534 494.883,461.62C494.883,461.62 551.848,467.937 625.826,451.863C667.634,442.778 710.238,425.649 747.382,393.142C747.382,393.142 721.992,360.244 689.422,291.45C677.029,265.275 647.518,257.098 590.747,203.309L438.083,391.273L208.629,548.17Z" style="fill-opacity:0.11;"/>
+    </g>
+    <g transform="matrix(0.081985,-0.0582493,0.0582493,0.081985,-40.4754,34.7668)">
+        <path d="M561.588,349.155C561.588,349.155 516.297,271.341 328.841,252.044C328.841,252.044 302.342,325.189 307.686,368.056C313.031,410.922 303.001,456.147 329.132,501.174C329.132,501.174 443.114,506.743 554.649,428.469L629.204,432.112C629.204,432.112 673.755,534.351 856.964,554.375C856.964,554.375 886.717,491.768 879.193,417.478C871.211,338.673 871.716,293.443 871.716,293.443C871.716,293.443 775.485,283.928 635.418,361.795L561.588,349.155Z" style="fill:rgb(127,187,221);"/>
+        <clipPath id="_clip1">
+            <path d="M561.588,349.155C561.588,349.155 516.297,271.341 328.841,252.044C328.841,252.044 302.342,325.189 307.686,368.056C313.031,410.922 303.001,456.147 329.132,501.174C329.132,501.174 443.114,506.743 554.649,428.469L629.204,432.112C629.204,432.112 673.755,534.351 856.964,554.375C856.964,554.375 886.717,491.768 879.193,417.478C871.211,338.673 871.716,293.443 871.716,293.443C871.716,293.443 775.485,283.928 635.418,361.795L561.588,349.155Z"/>
+        </clipPath>
+        <g clip-path="url(#_clip1)">
+            <g transform="matrix(0.758637,0.45892,-0.45892,0.758637,425.635,-121.213)">
+                <path d="M386.873,397.241C371.345,383.628 335.138,374.782 290.644,380.543C246.149,386.304 196.827,402.266 178.802,412.065C168.202,417.828 151.494,429.354 150.682,439.334C149.527,453.528 153.593,477.066 165.625,491.284C171.69,498.451 179.927,503.445 193.838,505.423C211.701,507.963 252.714,480.627 275.399,469.22C299.332,457.187 313.981,454.56 338.386,447.014C338.386,447.014 291.346,478.587 270.205,494.393C239.61,517.268 218.575,522.444 212.859,539.897C209.766,549.34 212.237,567.767 220.354,577.538C229.427,588.461 233.197,595.069 254.591,597.624C267.303,599.143 276.685,598.802 314.37,568.95C336.06,551.767 370.297,509.817 381.412,494.616C397.581,472.506 405.165,451.462 402.656,435.04C399.045,411.391 394.259,403.716 386.873,397.241Z" style="fill:white;"/>
+            </g>
+            <g transform="matrix(0.752145,0.454993,-0.454993,0.752145,468.36,-108.293)">
+                <path d="M484.733,378.934C479.33,367.886 467.092,350.452 483.886,325.205C502.172,297.717 514.898,280.938 528.117,264.632C541.335,248.326 574.793,218.447 587.739,212.53C600.684,206.613 621.026,203.852 631.889,212.841C642.874,221.93 648.416,233.377 654.92,245.478C662.331,259.267 667.318,274.808 656.518,288.278C641.093,307.515 622.242,305.294 594.912,319.844C567.244,334.573 552.644,342.943 539.244,355.703C539.244,355.703 591.431,334.114 621.229,324.474C651.027,314.833 680.952,304.461 695.995,315.975C711.038,327.49 710.631,331.463 714.425,347.187C719.107,366.59 707.231,385.165 694.294,395.838C681.356,406.51 659.958,411.756 636.875,416.852C606.42,423.576 540.278,431.917 512.819,419.366C485.361,406.815 488.488,386.613 484.733,378.934Z" style="fill:white;"/>
+            </g>
+        </g>
+        <path d="M561.588,349.155C561.588,349.155 516.297,271.341 328.841,252.044C328.841,252.044 302.342,325.189 307.686,368.056C313.031,410.922 303.001,456.147 329.132,501.174C329.132,501.174 443.114,506.743 554.649,428.469L629.204,432.112C629.204,432.112 673.755,534.351 856.964,554.375C856.964,554.375 886.717,491.768 879.193,417.478C871.211,338.673 871.716,293.443 871.716,293.443C871.716,293.443 775.485,283.928 635.418,361.795L561.588,349.155Z" style="fill:none;stroke:black;stroke-width:16.57px;"/>
+    </g>
+    <g transform="matrix(0.100298,-0.00740488,0.00740488,0.100298,-15.7457,-5.17528)">
+        <path d="M384.916,385.459C384.916,385.459 430.781,347.868 450.027,350.093C471.685,352.596 490.49,407.747 490.208,424.416C489.927,441.085 442.948,469.866 422.537,466.24C422.537,466.24 425.525,442.129 412.114,413.335C398.702,384.54 384.916,385.459 384.916,385.459Z" style="fill:rgb(127,187,221);"/>
+        <clipPath id="_clip2">
+            <path d="M384.916,385.459C384.916,385.459 430.781,347.868 450.027,350.093C471.685,352.596 490.49,407.747 490.208,424.416C489.927,441.085 442.948,469.866 422.537,466.24C422.537,466.24 425.525,442.129 412.114,413.335C398.702,384.54 384.916,385.459 384.916,385.459Z"/>
+        </clipPath>
+        <g clip-path="url(#_clip2)">
+            <g transform="matrix(0.909069,3.67641e-17,-3.79818e-17,0.85852,37.051,52.1829)">
+                <path d="M413.282,402.697C430.77,421.58 423.307,448.426 441.683,446.137C463.409,443.431 472.604,430.356 473.316,413.402C474.028,396.448 472.245,393.911 466.172,375.321C460.099,356.731 447.953,352.176 422.842,357.179C401.957,361.339 405.039,360.215 398.735,367.228C392.43,374.242 384.315,393.182 384.315,393.182C384.315,393.182 392.715,380.492 413.282,402.697Z" style="fill:white;"/>
+            </g>
+        </g>
+        <path d="M384.916,385.459C384.916,385.459 430.781,347.868 450.027,350.093C471.685,352.596 490.49,407.747 490.208,424.416C489.927,441.085 442.948,469.866 422.537,466.24C422.537,466.24 425.525,442.129 412.114,413.335C398.702,384.54 384.916,385.459 384.916,385.459Z" style="fill:none;stroke:black;stroke-width:16.57px;"/>
+    </g>
+</svg>

package/dist/src/index.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="external-typings/filetypes.js" />
+export function embed(el: string | HTMLElement, spec: string | import("./spec/root.js").RootSpec, options?: import("./types/embedApi.js").EmbedOptions): import("./types/embedApi.js").EmbedResult;
+/**
+ * Loads the spec from the given url and sets the baseUrl if it is not
+ * defined in the spec.
+ *
+ * @param {string} url
+ */
+export function loadSpec(url: string): Promise<any>;
+import GenomeSpy from "./genomeSpy.js";
+import { html } from "lit-html";
+import icon from "./img/bowtie.svg";
+import favIcon from "./img/genomespy-favicon.svg";
+export { GenomeSpy, html, icon, favIcon };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";AAaU,mMACkD;AA2F5D;;;;;GAKG;AACH,8BAFW,MAAM,gBAmBhB;sBA5HqB,gBAAgB;qBAFjB,UAAU;iBAGd,kBAAkB;oBACf,6BAA6B"}

package/dist/src/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>GenomeSpy</title>
+  </head>
+  <body>
+    <script type="module" src="/singlePageApp.js"></script>
+  </body>
+</html>

package/dist/src/index.js

@@ -0,0 +1,129 @@
+import { isObject, isString } from "vega-util";
+import { loader as vegaLoader } from "vega-loader";
+import { html } from "lit-html";
+
+import GenomeSpy from "./genomeSpy.js";
+import icon from "./img/bowtie.svg";
+import favIcon from "./img/genomespy-favicon.svg";
+
+export { GenomeSpy, html, icon, favIcon };
+
+/**
+ * Embeds GenomeSpy into the DOM
+ *
+ * @type {import("./types/embedApi.js").EmbedFunction}
+ * @returns {Promise<import("./types/embedApi.js").EmbedResult>}
+ */
+export async function embed(el, spec, options = {}) {
+    /** @type {HTMLElement} */
+    let element;
+
+    if (isString(el)) {
+        element = document.querySelector(el);
+        if (!element) {
+            throw new Error(`No such element: ${el}`);
+        }
+    } else if (el instanceof HTMLElement) {
+        element = el;
+    } else {
+        throw new Error(`Invalid element: ${el}`);
+    }
+
+    /** @type {GenomeSpy} */
+    let genomeSpy;
+
+    try {
+        const specObject = isObject(spec) ? spec : await loadSpec(spec);
+
+        specObject.baseUrl ??= "";
+        specObject.width ??= "container";
+        specObject.padding ??= 10;
+
+        if (element == document.body) {
+            // Need to add a wrapper to make sizing behavior more stable
+            const wrapper = document.createElement("div");
+            wrapper.style.position = "fixed";
+            wrapper.style.inset = "0";
+            wrapper.style.overflow = "hidden";
+            element.appendChild(wrapper);
+            element = wrapper;
+        }
+
+        genomeSpy = new GenomeSpy(element, specObject, options);
+        applyOptions(genomeSpy, options);
+        await genomeSpy.launch();
+    } catch (e) {
+        // eslint-disable-next-line require-atomic-updates
+        element.innerText = e.toString();
+        console.error(e);
+    }
+
+    return {
+        finalize() {
+            genomeSpy.destroy();
+            while (element.firstChild) {
+                element.firstChild.remove();
+            }
+        },
+
+        addEventListener(type, listener) {
+            const listenersByType = genomeSpy._eventListeners;
+
+            let listeners = listenersByType.get(type);
+            if (!listeners) {
+                listeners = new Set();
+                listenersByType.set(type, listeners);
+            }
+
+            listeners.add(listener);
+        },
+
+        removeEventListener(type, listener) {
+            const listenersByType = genomeSpy._eventListeners;
+
+            listenersByType.get(type)?.delete(listener);
+        },
+
+        getScaleResolutionByName(name) {
+            return genomeSpy.getNamedScaleResolutions().get(name);
+        },
+
+        updateNamedData: genomeSpy.updateNamedData.bind(genomeSpy),
+    };
+}
+
+/**
+ *
+ * @param {import("./genomeSpy").default} genomeSpy
+ * @param {import("./types/embedApi.js").EmbedOptions} options options
+ */
+function applyOptions(genomeSpy, options) {
+    if (options.namedDataProvider) {
+        genomeSpy.registerNamedDataProvider(options.namedDataProvider);
+    }
+}
+
+/**
+ * Loads the spec from the given url and sets the baseUrl if it is not
+ * defined in the spec.
+ *
+ * @param {string} url
+ */
+export async function loadSpec(url) {
+    let spec;
+
+    try {
+        spec = JSON.parse(await vegaLoader().load(url));
+    } catch (e) {
+        throw new Error(
+            `Could not load or parse configuration: ${url}, reason: ${e.message}`
+        );
+    }
+
+    if (!spec.baseUrl) {
+        const m = url.match(/^[^?#]*\//);
+        spec.baseUrl = (m && m[0]) || "./";
+    }
+
+    return spec;
+}

package/dist/src/marks/link.d.ts

@@ -0,0 +1,11 @@
+export default class LinkMark extends Mark {
+    arrays: {
+        [k: string]: {
+            data: any;
+            numComponents: number;
+            divisor?: number;
+        };
+    };
+}
+import Mark from "./mark";
+//# sourceMappingURL=link.d.ts.map

package/dist/src/marks/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../src/marks/link.js"],"names":[],"mappings":"AAOA;IAqGQ;;;;;;MAKC;CAkDR;iBA9JgB,QAAQ"}

package/dist/src/marks/link.js

@@ -0,0 +1,175 @@
+import { drawBufferInfo, setBuffersAndAttributes, setUniforms } from "twgl.js";
+import VERTEX_SHADER from "../gl/link.vertex.glsl.js";
+import FRAGMENT_SHADER from "../gl/link.fragment.glsl.js";
+import { ConnectionVertexBuilder } from "../gl/dataToVertices";
+
+import Mark from "./mark";
+
+export default class LinkMark extends Mark {
+    /**
+     * @param {import("../view/unitView").default} unitView
+     */
+    constructor(unitView) {
+        super(unitView);
+
+        Object.defineProperties(
+            this.defaultProperties,
+            Object.getOwnPropertyDescriptors({
+                x: 0.0,
+                x2: undefined,
+                y: 0.0,
+                y2: undefined,
+                size: 1.0,
+                color: "black",
+                opacity: 1.0,
+
+                segments: 101, // Performance is affected more by the fill rate, i.e. number of pixels
+                sagittaScaleFactor: 1.0,
+                minSagittaLength: 1.5,
+            })
+        );
+    }
+
+    getAttributes() {
+        return [
+            "uniqueId",
+            "facetIndex",
+            "x",
+            "x2",
+            "y",
+            "y2",
+            "size",
+            "height",
+            "color",
+            "opacity",
+        ];
+    }
+
+    /** @return {import("../spec/channel").Channel[]} */
+    getSupportedChannels() {
+        return [...super.getSupportedChannels(), "x2", "y2", "size"];
+    }
+
+    /**
+     * @param {import("../spec/channel").Encoding} encoding
+     * @returns {import("../spec/channel").Encoding}
+     */
+    fixEncoding(encoding) {
+        if (!encoding.x) {
+            encoding.x2 = encoding.x;
+        }
+
+        if (!encoding.y2) {
+            encoding.y2 = encoding.y;
+        }
+
+        return encoding;
+    }
+
+    async initializeGraphics() {
+        await super.initializeGraphics();
+
+        this.createAndLinkShaders(VERTEX_SHADER, FRAGMENT_SHADER);
+    }
+
+    finalizeGraphicsInitialization() {
+        super.finalizeGraphicsInitialization();
+        this.gl.useProgram(this.programInfo.program);
+
+        const props = this.properties;
+
+        // TODO: Use uniform block.
+        setUniforms(this.programInfo, {
+            uSagittaScaleFactor: props.sagittaScaleFactor,
+            uMinSagittaLength: props.minSagittaLength,
+        });
+    }
+
+    updateGraphicsData() {
+        const collector = this.unitView.getCollector();
+        const itemCount = collector.getItemCount();
+
+        const builder = new ConnectionVertexBuilder({
+            encoders: this.encoders,
+            attributes: this.getAttributes(),
+            numItems: itemCount,
+        });
+
+        builder.addBatches(collector.facetBatches);
+
+        const vertexData = builder.toArrays();
+
+        vertexData.arrays.strip = {
+            data: createStrip(this.properties.segments),
+            numComponents: 2,
+        };
+
+        this.rangeMap.migrateEntries(vertexData.rangeMap);
+
+        this.arrays = Object.fromEntries(
+            Object.entries(vertexData.arrays).map(([k, v]) => [
+                k,
+                { ...v, data: undefined },
+            ])
+        );
+
+        this.updateBufferInfo(vertexData);
+    }
+
+    /**
+     * @param {import("./mark").MarkRenderingOptions} options
+     */
+    render(options) {
+        const gl = this.gl;
+
+        // TODO: Vertical clipping in faceted view
+
+        return this.createRenderCallback((offset, count) => {
+            // We are using instanced drawing here.
+            // However, WebGL does not provide glDrawArraysInstancedBaseInstance and thus,
+            // we have to hack with offsets in vertexAttribPointer
+            // TODO: Use VAOs more intelligently to reduce WebGL calls
+            // TODO: Explore multiDrawArraysInstancedWEBGL
+            // There's also a promising extension draft:
+            // https://www.khronos.org/registry/webgl/extensions/WEBGL_draw_instanced_base_vertex_base_instance/
+            // (and https://www.khronos.org/registry/webgl/extensions/WEBGL_multi_draw_instanced_base_vertex_base_instance/)
+
+            this.gl.bindVertexArray(this.vertexArrayInfo.vertexArrayObject);
+
+            for (const attribInfoObject of Object.entries(
+                this.bufferInfo.attribs
+            )) {
+                const [attribute, attribInfo] = attribInfoObject;
+                if (
+                    attribInfo.buffer &&
+                    attribInfo.numComponents &&
+                    attribInfo.divisor
+                ) {
+                    attribInfo.offset =
+                        offset * this.arrays[attribute].numComponents * 4; // gl.FLOAT in bytes
+                }
+            }
+            setBuffersAndAttributes(gl, this.programInfo, this.bufferInfo);
+
+            drawBufferInfo(
+                gl,
+                this.bufferInfo,
+                gl.TRIANGLE_STRIP,
+                (this.properties.segments + 1) * 2, // number of vertices in a triangle strip
+                0,
+                count
+            );
+        }, options);
+    }
+}
+
+function createStrip(/** @type number */ segments) {
+    let i = 0;
+    const coords = [];
+
+    for (; i <= segments; i++) {
+        coords.push(i / segments, 0.5);
+        coords.push(i / segments, -0.5);
+    }
+    return coords;
+}

package/dist/src/marks/mark.d.ts

@@ -0,0 +1,226 @@
+/// <reference types="external-typings/internmap" />
+export const SAMPLE_FACET_UNIFORM: "SAMPLE_FACET_UNIFORM";
+export const SAMPLE_FACET_TEXTURE: "SAMPLE_FACET_TEXTURE";
+/**
+ *
+ * @typedef {import("../types/rendering").RenderingOptions} RenderingOptions
+ * @typedef {object} _MarkRenderingOptions
+ * @prop {boolean} [skipViewportSetup] Don't configure viewport. Allows for
+ *      optimized faceted rendering
+ * @typedef {RenderingOptions & _MarkRenderingOptions} MarkRenderingOptions
+ *
+ * @callback DrawFunction
+ * @param {number} offset
+ * @param {number} count
+ *
+ */
+export default class Mark {
+    /**
+     * @typedef {import("../spec/mark").MarkConfig} MarkConfig
+     * @typedef {import("../spec/channel").Channel} Channel
+     * @typedef {import("../spec/channel").Encoding} Encoding
+     * @typedef {import("../spec/channel").ValueDef} ValueDef
+     */
+    /**
+     * @param {import("../view/unitView").default} unitView
+     */
+    constructor(unitView: import("../view/unitView").default);
+    unitView: import("../view/unitView").default;
+    /** @type {Record<string, import("../types/encoder").Encoder>} */
+    encoders: Record<string, import("../types/encoder").Encoder>;
+    /** @type {import("twgl.js").BufferInfo & { allocatedVertices?: number }} WebGL buffers */
+    bufferInfo: import("twgl.js").BufferInfo & {
+        allocatedVertices?: number;
+    };
+    /** @type {import("twgl.js").ProgramInfo} WebGL buffers */
+    programInfo: import("twgl.js").ProgramInfo;
+    /** @type {import("twgl.js").VertexArrayInfo} WebGL buffers */
+    vertexArrayInfo: import("twgl.js").VertexArrayInfo;
+    /** @type {import("twgl.js").UniformBlockInfo} WebGL buffers */
+    domainUniformInfo: import("twgl.js").UniformBlockInfo;
+    /** @type {import("twgl.js").UniformBlockInfo} WebGL buffers */
+    viewUniformInfo: import("twgl.js").UniformBlockInfo;
+    /** @type {RangeMap<any>} keep track of facet locations within the vertex array */
+    rangeMap: RangeMap<any>;
+    /** @type {MarkConfig} */
+    defaultProperties: import("../spec/mark").MarkConfig;
+    /**
+     * A properties object that contains the configured mark properties or
+     * default values as fallback.
+     *
+     * TODO: Proper and comprehensive typings for mark properties
+     *
+     * @type {Partial<MarkConfig>}
+     * @readonly
+     */
+    readonly properties: Partial<import("../spec/mark").MarkConfig>;
+    get opaque(): boolean;
+    /**
+     * Returns attribute info for WebGL attributes that match visual channels.
+     *
+     * Note: attributes and channels do not necessarily match.
+     * For example, rectangles have x, y, x2, and y2 channels but only x and y as attributes.
+     *
+     * @returns {string[]}
+     */
+    getAttributes(): string[];
+    /**
+     * @returns {Channel[]}
+     */
+    getSupportedChannels(): import("../spec/channel").Channel[];
+    /**
+     * @returns {Encoding}
+     */
+    getDefaultEncoding(): import("../spec/channel").Encoding<string>;
+    /**
+     * Adds intelligent defaults etc to the encoding.
+     *
+     * @param {Encoding} encoding
+     * @returns {Encoding}
+     */
+    fixEncoding(encoding: import("../spec/channel").Encoding<string>): import("../spec/channel").Encoding<string>;
+    /**
+     * Returns the encoding spec supplemented with mark's default encodings
+     *
+     * @returns {Encoding}
+     */
+    get encoding(): import("../spec/channel").Encoding<string>;
+    getContext(): import("../types/viewContext").default;
+    getType(): import("../spec/mark").MarkType;
+    initializeData(): void;
+    /**
+     * Initialize encoders that encode fields of the data (or constants) to
+     * the ranges of the visual channels.
+     */
+    initializeEncoders(): void;
+    /**
+     * Initialize shaders etc.
+     */
+    initializeGraphics(): Promise<void>;
+    /**
+     * Update WebGL buffers from the data
+     */
+    updateGraphicsData(): void;
+    getSampleFacetMode(): "SAMPLE_FACET_TEXTURE" | "SAMPLE_FACET_UNIFORM";
+    /**
+     *
+     * @param {string} vertexShader
+     * @param {string} fragmentShader
+     * @param {string[]} [extraHeaders]
+     */
+    createAndLinkShaders(vertexShader: string, fragmentShader: string, extraHeaders?: string[]): void;
+    /** @type {string[]} */
+    domainUniforms: string[];
+    programStatus: {
+        program: WebGLProgram;
+        getProgramErrors: () => {
+            message: string;
+            detail: string;
+        };
+    };
+    /**
+     * Check WebGL shader/program compilation/linking status and finalize
+     * initialization.
+     */
+    finalizeGraphicsInitialization(): void;
+    _setDatums(): void;
+    /**
+     * Delete WebGL buffers etc.
+     */
+    deleteGraphicsData(): void;
+    /**
+     *
+     * @param {any} vertexData TODO: Extract type from VertexBuilder
+     */
+    updateBufferInfo(vertexData: any): void;
+    /** Convenience method */
+    get glHelper(): import("../gl/webGLHelper").default;
+    /** Convenience method */
+    get gl(): WebGL2RenderingContext;
+    onBeforeSampleAnimation(): void;
+    onAfterSampleAnimation(): void;
+    isReady(): import("twgl.js").ProgramInfo;
+    /**
+     * Returns true if this mark instance participates in picking.
+     *
+     * TODO: Check if tooltip is enabled,
+     * TODO: Check if selection (when it's implemented) is enabled
+     */
+    isPickingParticipant(): boolean;
+    /**
+     * Configures the WebGL state for rendering the mark instances.
+     * A separate preparation stage allows for efficient rendering of faceted
+     * views, i.e., multiple views share the uniforms (such as mark properties
+     * and scales) and buffers.
+     *
+     * @param {import("../types/rendering").GlobalRenderingOptions} options
+     * @returns {(() => void)[]}
+     */
+    prepareRender(options: import("../types/rendering").GlobalRenderingOptions): (() => void)[];
+    /**
+     * Prepares rendering of a single sample facet.
+     *
+     * @param {MarkRenderingOptions} options
+     * @returns {boolean} true if rendering should proceed,
+     *      false if it should be skipped
+     */
+    prepareSampleFacetRendering(options: MarkRenderingOptions): boolean;
+    /**
+     * Returns a callback function that the ViewRenderingContext calls to
+     * perform the actual rendering either immediately or at a later time.
+     *
+     * @param {MarkRenderingOptions} options
+     * @returns {function():void} A function that renderingContext calls to
+     *      trigger the actual rendering
+     */
+    render(options: MarkRenderingOptions): () => void;
+    /**
+     * @param {DrawFunction} draw A function that draws a range of vertices
+     * @param {import("./mark").MarkRenderingOptions} options
+     */
+    createRenderCallback(draw: DrawFunction, options: import("./mark").MarkRenderingOptions): () => void;
+    /**
+     * Sets viewport, clipping, and uniforms related to scaling and translation
+     *
+     * @param {import("../utils/layout/rectangle").default} coords
+     * @param {import("../utils/layout/rectangle").default} [clipRect]
+     * @returns {boolean} true if the viewport is renderable (size > 0)
+     */
+    setViewport(coords: import("../utils/layout/rectangle").default, clipRect?: import("../utils/layout/rectangle").default): boolean;
+    /**
+     * Finds a datum that overlaps the given value on the x domain.
+     * The result is unspecified if multiple data are found.
+     *
+     * This is highly specific to SampleView and its sorting/filtering functionality.
+     *
+     * @param {string} facetId
+     * @param {import("../spec/channel").Scalar} x value on the x domain
+     * @returns {any}
+     */
+    findDatumAt(facetId: string, x: import("../spec/channel").Scalar): any;
+}
+export type RenderingOptions = import("../types/rendering").RenderingOptions;
+export type _MarkRenderingOptions = {
+    /**
+     * Don't configure viewport. Allows for
+     * optimized faceted rendering
+     */
+    skipViewportSetup?: boolean;
+};
+export type MarkRenderingOptions = RenderingOptions & _MarkRenderingOptions;
+export type DrawFunction = (offset: number, count: number) => any;
+/**
+ * @augments {InternMap<K, import("../gl/dataToVertices").RangeEntry>}
+ * @template K
+ */
+declare class RangeMap<K> extends InternMap<K, import("../gl/dataToVertices").RangeEntry> {
+    constructor();
+    /**
+     *
+     * @param {Map<K, import("../gl/dataToVertices").RangeEntry>} anotherMap
+     */
+    migrateEntries(anotherMap: Map<K, import("../gl/dataToVertices").RangeEntry>): void;
+}
+import { InternMap } from "internmap";
+export {};
+//# sourceMappingURL=mark.d.ts.map

package/dist/src/marks/mark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark.d.ts","sourceRoot":"","sources":["../../../src/marks/mark.js"],"names":[],"mappings":";AAuCA,0DAA2D;AAC3D,0DAA2D;AAE3D;;;;;;;;;;;;GAYG;AACH;IACI;;;;;OAKG;IAEH;;OAEG;IACH,sBAFW,OAAO,kBAAkB,EAAE,OAAO,EAoE5C;IAjEG,6CAAwB;IAExB,iEAAiE;IACjE,UADW,OAAO,MAAM,EAAE,OAAO,kBAAkB,EAAE,OAAO,CAAC,CACpC;IAIzB,0FAA0F;IAC1F;4BADgE,MAAM;MAC3C;IAE3B,0DAA0D;IAC1D,aADW,OAAO,SAAS,EAAE,WAAW,CACZ;IAE5B,8DAA8D;IAC9D,iBADW,OAAO,SAAS,EAAE,eAAe,CACZ;IAEhC,+DAA+D;IAC/D,mBADW,OAAO,SAAS,EAAE,gBAAgB,CACX;IAElC,+DAA+D;IAC/D,iBADW,OAAO,SAAS,EAAE,gBAAgB,CACb;IAEhC,kFAAkF;IAClF,UADW,SAAS,GAAG,CAAC,CACM;IAG9B,yBAAyB;IACzB,qDAqBC;IAED;;;;;;;;OAQG;IACH,gEAKC;IAGL,sBAEC;IAED;;;;;;;OAOG;IACH,iBAFa,MAAM,EAAE,CAKpB;IAED;;OAEG;IACH,4DAWC;IAED;;OAEG;IACH,iEAcC;IAED;;;;;OAKG;IACH,8GAEC;IAED;;;;OAIG;IACH,2DAyCC;IAED,qDAEC;IAED,2CAEC;IAED,uBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;OAEG;IACH,oCAEC;IAED;;OAEG;IACH,2BAEC;IAED,sEAeC;IAED;;;;;OAKG;IACH,mCAJW,MAAM,kBACN,MAAM,iBACN,MAAM,EAAE,QA+FlB;IAtFG,uBAAuB;IACvB,gBADW,MAAM,EAAE,CACK;IAgFxB;;;;;;MAIC;IAGL;;;OAGG;IACH,uCA2CC;IAED,mBAgBC;IAED;;OAEG;IACH,2BAiBC;IAED;;;OAGG;IACH,6BAFW,GAAG,QAoCb;IAED,yBAAyB;IACzB,oDAEC;IAED,yBAAyB;IACzB,iCAEC;IAED,gCAEC;IAED,+BAEC;IAED,yCAEC;IAED;;;;;OAKG;IACH,gCAcC;IAED;;;;;;;;OAQG;IAEH,uBAJW,OAAO,oBAAoB,EAAE,sBAAsB,GACjD,CAAC,MAAM,IAAI,CAAC,EAAE,CA+H1B;IAED;;;;;;OAMG;IACH,qCAJW,oBAAoB,GAClB,OAAO,CAqCnB;IAED;;;;;;;OAOG;IACH,gBAJW,oBAAoB,SACP,IAAI,CAM3B;IAED;;;OAGG;IACH,2BAHW,YAAY,WACZ,OAAO,QAAQ,EAAE,oBAAoB,cAmE/C;IAED;;;;;;OAMG;IACH,oBAJW,OAAO,2BAA2B,EAAE,OAAO,aAC3C,OAAO,2BAA2B,EAAE,OAAO,GACzC,OAAO,CAmHnB;IAED;;;;;;;;;OASG;IACH,qBAJW,MAAM,KACN,OAAO,iBAAiB,EAAE,MAAM,GAC9B,GAAG,CAIf;CACJ;+BA35BY,OAAO,oBAAoB,EAAE,gBAAgB;;;;;;wBAEhD,OAAO;;mCAEJ,gBAAgB,GAAG,qBAAqB;oCAG1C,MAAM,SACN,MAAM;AAq5BjB;;;GAGG;AACH;IACI,cAEC;IAkBD;;;OAGG;IACH,2BAFW,IAAI,CAAC,EAAE,OAAO,sBAAsB,EAAE,UAAU,CAAC,QAM3D;CACJ;0BAv8ByB,WAAW"}