@genome-spy/core 0.36.1 → 0.37.0

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

@@ -0,0 +1,9 @@
+export default class ImplicitRootView extends GridView {
+    /**
+     * @param {import("../types/viewContext").default} context
+     * @param {import("./view").default} view
+     */
+    constructor(context: import("../types/viewContext").default, view: import("./view").default);
+}
+import GridView from "./gridView";
+//# sourceMappingURL=implicitRootView.d.ts.map

package/dist/src/view/implicitRootView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implicitRootView.d.ts","sourceRoot":"","sources":["../../../src/view/implicitRootView.js"],"names":[],"mappings":"AAEA;IACI;;;OAGG;IACH,qBAHW,OAAO,sBAAsB,EAAE,OAAO,QACtC,OAAO,QAAQ,EAAE,OAAO,EAgBlC;CACJ;qBAtBoB,YAAY"}

package/dist/src/view/implicitRootView.js

@@ -0,0 +1,23 @@
+import GridView from "./gridView";
+
+export default class ImplicitRootView extends GridView {
+    /**
+     * @param {import("../types/viewContext").default} context
+     * @param {import("./view").default} view
+     */
+    constructor(context, view) {
+        super(
+            { vconcat: [] },
+            context,
+            undefined,
+            undefined,
+            "implicitRoot",
+            1
+        );
+
+        view.layoutParent = this;
+        view.dataParent = this;
+
+        this.appendChild(view);
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * This is just a placeholder for custom tracks that are imported by name.
+ */
+export default class ImportView extends View {
+    /**
+     *
+     * @param {import("../spec/view").ImportSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {import("./containerView").default} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec: import("../spec/view").ImportSpec, context: import("../types/viewContext").default, layoutParent: import("./containerView").default, dataParent: import("./view").default, name: string);
+    spec: import("../spec/view").ImportSpec;
+}
+import View from "./view";
+//# sourceMappingURL=importView.d.ts.map

package/dist/src/view/importView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importView.d.ts","sourceRoot":"","sources":["../../../src/view/importView.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;IACI;;;;;;;OAOG;IACH,kBANW,OAAO,cAAc,EAAE,UAAU,WACjC,OAAO,sBAAsB,EAAE,OAAO,gBACtC,OAAO,iBAAiB,EAAE,OAAO,cACjC,OAAO,QAAQ,EAAE,OAAO,QACxB,MAAM,EAOhB;IADG,wCAAgB;CAEvB;iBArBgB,QAAQ"}

package/dist/src/view/importView.js

@@ -0,0 +1,22 @@
+import View from "./view";
+
+/**
+ * This is just a placeholder for custom tracks that are imported by name.
+ */
+// @ts-expect-error TODO: Fix typing
+export default class ImportView extends View {
+    /**
+     *
+     * @param {import("../spec/view").ImportSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {import("./containerView").default} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec, context, layoutParent, dataParent, name) {
+        // @ts-expect-error TODO: Fix typing
+        super(spec, context, layoutParent, dataParent, name);
+
+        this.spec = spec; // Set here again to keep types happy
+    }
+}

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

@@ -0,0 +1,25 @@
+export default class LayerView extends ContainerView {
+    /**
+     * @typedef {import("./view").default} View
+     */
+    /**
+     *
+     * @param {import("../spec/view").LayerSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {ContainerView} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec: import("../spec/view").LayerSpec, context: import("../types/viewContext").default, layoutParent: ContainerView, dataParent: import("./view").default, name: string);
+    spec: import("../spec/view").LayerSpec;
+    /** @type {(LayerView | import("./unitView").default)[]} */
+    children: (LayerView | import("./unitView").default)[];
+    /**
+     * @param {import("./renderingContext/viewRenderingContext").default} context
+     * @param {import("../utils/layout/rectangle").default} coords
+     * @param {import("../types/rendering").RenderingOptions} [options]
+     */
+    render(context: import("./renderingContext/viewRenderingContext").default, coords: import("../utils/layout/rectangle").default, options?: import("../types/rendering").RenderingOptions): void;
+}
+import ContainerView from "./containerView";
+//# sourceMappingURL=layerView.d.ts.map

package/dist/src/view/layerView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layerView.d.ts","sourceRoot":"","sources":["../../../src/view/layerView.js"],"names":[],"mappings":"AAGA;IACI;;OAEG;IACH;;;;;;;OAOG;IACH,kBANW,OAAO,cAAc,EAAE,SAAS,WAChC,OAAO,sBAAsB,EAAE,OAAO,gBACtC,aAAa,cACb,OAAO,QAAQ,EAAE,OAAO,QACxB,MAAM,EAoBhB;IAfG,uCAAgB;IAEhB,2DAA2D;IAE3D,UAFW,CAAC,SAAS,GAAG,OAAO,YAAY,EAAE,OAAO,CAAC,EAAE,CAUrD;IAcN;;;;OAIG;IACH,gBAJW,OAAO,yCAAyC,EAAE,OAAO,UACzD,OAAO,2BAA2B,EAAE,OAAO,YAC3C,OAAO,oBAAoB,EAAE,gBAAgB,QAcvD;CAeJ;0BA3EyB,iBAAiB"}

package/dist/src/view/layerView.js

@@ -0,0 +1,77 @@
+import { isLayerSpec, isUnitSpec } from "./viewFactory";
+import ContainerView from "./containerView";
+
+export default class LayerView extends ContainerView {
+    /**
+     * @typedef {import("./view").default} View
+     */
+    /**
+     *
+     * @param {import("../spec/view").LayerSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {ContainerView} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec, context, layoutParent, dataParent, name) {
+        super(spec, context, layoutParent, dataParent, name);
+
+        this.spec = spec;
+
+        /** @type {(LayerView | import("./unitView").default)[]} */
+        // @ts-expect-error TODO: Fix typing
+        this.children = (spec.layer || []).map((childSpec, i) => {
+            if (isLayerSpec(childSpec) || isUnitSpec(childSpec)) {
+                return context.createView(childSpec, this, this, "layer" + i);
+            } else {
+                throw new Error(
+                    "LayerView accepts only unit or layer specs as children!"
+                );
+            }
+        });
+
+        this.needsAxes = { x: true, y: true };
+    }
+
+    /**
+     * @returns {IterableIterator<View>}
+     */
+    *[Symbol.iterator]() {
+        for (const child of this.children) {
+            yield child;
+        }
+    }
+
+    /**
+     * @param {import("./renderingContext/viewRenderingContext").default} context
+     * @param {import("../utils/layout/rectangle").default} coords
+     * @param {import("../types/rendering").RenderingOptions} [options]
+     */
+    render(context, coords, options = {}) {
+        if (!this.isConfiguredVisible()) {
+            return;
+        }
+
+        context.pushView(this, coords);
+
+        for (const child of this.children) {
+            child.render(context, coords, options);
+        }
+
+        context.popView(this);
+    }
+
+    /**
+     * @param {import("../utils/interactionEvent").default} event
+     */
+    propagateInteractionEvent(event) {
+        this.handleInteractionEvent(undefined, event, true);
+        for (let i = this.children.length - 1; i >= 0; i--) {
+            this.children[i].propagateInteractionEvent(event);
+            if (event.stopped) {
+                return;
+            }
+        }
+        this.handleInteractionEvent(undefined, event, false);
+    }
+}

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

@@ -0,0 +1,30 @@
+export default class BufferedViewRenderingContext extends ViewRenderingContext {
+    /**
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     * @param {import("../../gl/webGLHelper").default} webGLHelper
+     */
+    constructor(globalOptions: import("../../types/rendering").GlobalRenderingOptions, webGLHelper: import("../../gl/webGLHelper").default);
+    webGLHelper: import("../../gl/webGLHelper").default;
+    /**
+     * @type {import("../../types/rendering").BufferedRenderingRequest[]}
+     */
+    buffer: import("../../types/rendering").BufferedRenderingRequest[];
+    /** @type {import("../../utils/layout/rectangle").default} */
+    coords: import("../../utils/layout/rectangle").default;
+    /** @type {Set<import("../view").default>} */
+    views: Set<import("../view").default>;
+    /**
+     * Renders marks in an optimized order, minimizing the number of WebGL state
+     * changes.
+     */
+    render(): void;
+    _buildBatch(): void;
+    /**
+     * Store the operations as a sequence of commands for cheap subsequent rendering.
+     *
+     * @type {(function():void)[]}
+     */
+    batch: (() => void)[];
+}
+import ViewRenderingContext from "./viewRenderingContext";
+//# sourceMappingURL=bufferedViewRenderingContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferedViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/bufferedViewRenderingContext.js"],"names":[],"mappings":"AAIA;IACI;;;OAGG;IACH,2BAHW,OAAO,uBAAuB,EAAE,sBAAsB,eACtD,OAAO,sBAAsB,EAAE,OAAO,EAiBhD;IAZG,oDAA8B;IAE9B;;OAEG;IACH,QAFU,OAAO,uBAAuB,EAAE,wBAAwB,EAAE,CAEpD;IAEhB,6DAA6D;IAC7D,QADW,OAAO,8BAA8B,EAAE,OAAO,CAClC;IAEvB,6CAA6C;IAC7C,OADW,IAAI,OAAO,SAAS,EAAE,OAAO,CAAC,CACnB;IAsC1B;;;OAGG;IACH,eA+BC;IAED,oBA2EC;IA1EG;;;;OAIG;IACH,cAFsB,IAAI,IAEX;CAsEtB;iCA5KgC,wBAAwB"}

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

@@ -0,0 +1,175 @@
+import { group } from "d3-array";
+
+import ViewRenderingContext from "./viewRenderingContext";
+
+export default class BufferedViewRenderingContext extends ViewRenderingContext {
+    /**
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     * @param {import("../../gl/webGLHelper").default} webGLHelper
+     */
+    constructor(globalOptions, webGLHelper) {
+        super(globalOptions);
+
+        this.webGLHelper = webGLHelper;
+
+        /**
+         * @type {import("../../types/rendering").BufferedRenderingRequest[]}
+         */
+        this.buffer = [];
+
+        /** @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 {import("../view").default} view
+     * @param {import("../../utils/layout/rectangle").default} coords View coordinates
+     *      inside the padding.
+     * @override
+     */
+    pushView(view, coords) {
+        this.views.add(view);
+        this.coords = coords;
+    }
+
+    /**
+     *
+     * @param {import("../../marks/mark").default} mark
+     * @param {import("../../types/rendering").RenderingOptions} options
+     * @override
+     */
+    renderMark(mark, options) {
+        if (this.globalOptions.picking && !mark.isPickingParticipant()) {
+            return;
+        }
+
+        const callback = mark.render(options);
+        if (callback) {
+            this.buffer.push({
+                mark,
+                callback,
+                coords: this.coords,
+                clipRect: options.clipRect,
+            });
+        }
+    }
+
+    /**
+     * Renders marks in an optimized order, minimizing the number of WebGL state
+     * changes.
+     */
+    render() {
+        if (!this.batch) {
+            this._buildBatch();
+        }
+
+        if (this.batch.length == 0) {
+            return;
+        }
+
+        const gl = this.webGLHelper.gl;
+        const picking = this.globalOptions.picking;
+
+        gl.bindFramebuffer(
+            gl.FRAMEBUFFER,
+            picking ? this.webGLHelper._pickingBufferInfo.framebuffer : null
+        );
+
+        this.webGLHelper.clearAll();
+
+        for (const view of this.views) {
+            view.onBeforeRender();
+        }
+
+        // Execute the batch
+        for (const op of this.batch) {
+            op();
+        }
+
+        if (picking) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        }
+    }
+
+    _buildBatch() {
+        /**
+         * Store the operations as a sequence of commands for cheap subsequent rendering.
+         *
+         * @type {(function():void)[]}
+         */
+        this.batch = [];
+
+        /**
+         * Is drawing enabled or not. As an optimization this is toggled off for invisible views.
+         */
+        let enabled = true;
+
+        let viewportVisible = true;
+
+        /**
+         * @type {function(function():void):(function():void)}
+         */
+        const ifEnabled = (op) => () => {
+            if (enabled) op();
+        };
+
+        /**
+         * @type {function(function():void):(function():void)}
+         */
+        const ifEnabledAndVisible = (op) => () => {
+            if (enabled && viewportVisible) op();
+        };
+
+        // We group by marks in order to minimize program changes.
+        // Note: by reversing the buffer, we ensure ensure that the last instance
+        // of a mark determines the order of the groups.
+        const requestByMark = group(
+            this.buffer.reverse(),
+            (request) => request.mark
+        );
+
+        // And reversing again to restore the original order
+        for (const [mark, requests] of [...requestByMark.entries()].reverse()) {
+            if (!mark.isReady()) {
+                continue;
+            }
+
+            // eslint-disable-next-line no-loop-func
+            this.batch.push(() => {
+                enabled = mark.unitView.getEffectiveOpacity() > 0;
+            });
+            // Change program, set common uniforms (mark properties, shared domains)
+            this.batch.push(
+                ...mark
+                    .prepareRender(this.globalOptions)
+                    .map((op) => ifEnabled(op))
+            );
+
+            /** @type {import("../../utils/layout/rectangle").default} */
+            let previousCoords;
+            for (const request of requests) {
+                const coords = request.coords;
+                // Render each facet
+                if (!coords.equals(previousCoords)) {
+                    this.batch.push(
+                        // eslint-disable-next-line no-loop-func
+                        ifEnabled(() => {
+                            // Suppress rendering if viewport is outside the clipRect
+                            viewportVisible = mark.setViewport(
+                                coords,
+                                request.clipRect
+                            );
+                        })
+                    );
+                }
+                this.batch.push(ifEnabledAndVisible(request.callback));
+                previousCoords = request.coords;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * @typedef {import("../view").default} View
+ */
+export default class CompositeViewRenderingContext extends ViewRenderingContext {
+    /**
+     *
+     * @param  {...ViewRenderingContext} contexts
+     */
+    constructor(...contexts: ViewRenderingContext[]);
+    contexts: ViewRenderingContext[];
+}
+export type View = import("../view").default;
+import ViewRenderingContext from "./viewRenderingContext";
+//# sourceMappingURL=compositeViewRenderingContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compositeViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/compositeViewRenderingContext.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;OAGG;IACH,yBAFe,oBAAoB,IAMlC;IADG,iCAAwB;CAqC/B;mBA/CY,OAAO,SAAS,EAAE,OAAO;iCAHL,wBAAwB"}

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

@@ -0,0 +1,51 @@
+import ViewRenderingContext from "./viewRenderingContext";
+
+/**
+ * @typedef {import("../view").default} View
+ */
+export default class CompositeViewRenderingContext extends ViewRenderingContext {
+    /**
+     *
+     * @param  {...ViewRenderingContext} contexts
+     */
+    constructor(...contexts) {
+        super({});
+
+        this.contexts = contexts;
+    }
+
+    /**
+     * 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) {
+        for (const context of this.contexts) {
+            context.pushView(view, coords);
+        }
+    }
+
+    /**
+     * Must be called when a view's render() method is being exited
+     *
+     * @param {View} view
+     */
+    popView(view) {
+        for (const context of this.contexts) {
+            context.popView(view);
+        }
+    }
+
+    /**
+     *
+     * @param {import("../../marks/mark").default} mark
+     * @param {import("../../types/rendering").RenderingOptions} options
+     */
+    renderMark(mark, options) {
+        for (const context of this.contexts) {
+            context.renderMark(mark, options);
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+/**
+ * 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 debugging or testing of the layout engine.
+ *
+ * @typedef {import("../view").default} View
+ * @typedef {import("../../utils/layout/rectangle").default} Rectangle
+ *
+ */
+export default class DebugginViewRenderingContext extends ViewRenderingContext {
+    /** @type {ViewCoords} */
+    root: ViewCoords;
+    /** @type {ViewCoords[]} */
+    stack: 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 debugging or testing of the layout engine.
+ */
+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 debugging or testing of the layout engine.
+ */
+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 {string} viewName
+     * @param {Rectangle} coords
+     */
+    constructor(viewName: string, coords: Rectangle);
+    viewName: string;
+    coords: string;
+    /** @type {ViewCoords[]} */
+    children: ViewCoords[];
+    /**
+     *
+     * @param {ViewCoords} viewCoords
+     */
+    addChild(viewCoords: ViewCoords): void;
+}
+export {};
+//# sourceMappingURL=debuggingViewRenderingContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debuggingViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/debuggingViewRenderingContext.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH;IAOQ,yBAAyB;IACzB,MADW,UAAU,CACA;IAErB,2BAA2B;IAC3B,OADW,UAAU,EAAE,CACR;IAgCnB,wBAEC;CACJ;;;;;;mBAlDY,OAAO,SAAS,EAAE,OAAO;;;;;;wBACzB,OAAO,8BAA8B,EAAE,OAAO;iCAR1B,wBAAwB;AA2DzD;;;GAGG;AACH;IACI;;;OAGG;IACH,sBAHW,MAAM,UACN,SAAS,EAOnB;IAJG,iBAAwB;IACxB,eAAsC;IACtC,2BAA2B;IAC3B,UADW,UAAU,EAAE,CACL;IAGtB;;;OAGG;IACH,qBAFW,UAAU,QAcpB;CACJ"}

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

@@ -0,0 +1,94 @@
+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 debugging or testing of the layout engine.
+ *
+ * @typedef {import("../view").default} View
+ * @typedef {import("../../utils/layout/rectangle").default} Rectangle
+ *
+ */
+export default class DebugginViewRenderingContext extends ViewRenderingContext {
+    /**
+     * @param {import("../../types/rendering").GlobalRenderingOptions} globalOptions
+     */
+    constructor(globalOptions) {
+        super(globalOptions);
+
+        /** @type {ViewCoords} */
+        this.root = undefined;
+
+        /** @type {ViewCoords[]} */
+        this.stack = [];
+    }
+
+    /**
+     * 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.name, 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 {string} viewName
+     * @param {Rectangle} coords
+     */
+    constructor(viewName, coords) {
+        this.viewName = viewName;
+        this.coords = coords.toRoundedString();
+        /** @type {ViewCoords[]} */
+        this.children = [];
+    }
+
+    /**
+     *
+     * @param {ViewCoords} viewCoords
+     */
+    addChild(viewCoords) {
+        const last = peek(this.children);
+        if (
+            last &&
+            viewCoords.viewName == last.viewName &&
+            viewCoords.coords == last.coords
+        ) {
+            // Skip extra copies of sample facets. They all have the same coords.
+            return;
+        }
+
+        this.children.push(viewCoords);
+    }
+}