@genome-spy/core 0.73.0 → 0.74.0

package/dist/src/genomeSpy/interactionController.js

@@ -1,11 +1,13 @@
 import UnitView from "../view/unitView.js";
 import { VISIT_STOP } from "../view/view.js";
 import { readPickingPixel } from "../gl/webGLHelper.js";
-import InteractionEvent from "../utils/interactionEvent.js";
 import Inertia, { makeEventTemplate } from "../utils/inertia.js";
 import Point from "../view/layout/point.js";
 import { isStillZooming } from "../view/zoom.js";
 import createTooltipContext from "../tooltip/tooltipContext.js";
+import { FREEZE_INTERACTION_CLASS_NAME } from "../utils/ui/tooltip.js";
+import InteractionDispatcher from "./interactionDispatcher.js";
+import CursorManager from "./cursorManager.js";
 
 export default class InteractionController {
     /** @type {import("../view/view.js").default} */
@@ -24,6 +26,10 @@ export default class InteractionController {
     #renderPickingFramebuffer;
     /** @type {() => number} */
     #getDevicePixelRatio;
+    /** @type {InteractionDispatcher} */
+    #interactionDispatcher;
+    /** @type {CursorManager} */
+    #cursorManager;
     /**
      * @type {{ mark: import("../marks/mark.js").default, datum: import("../data/flowNode.js").Datum, uniqueId: number }}
      */
@@ -32,8 +38,14 @@ export default class InteractionController {
     #wheelInertia;
     /** @type {Point} */
     #mouseDownCoords;
+    /** @type {Point | undefined} */
+    #lastPointerPoint;
     /** @type {boolean} */
     #tooltipUpdateRequested;
+    /** @type {number} */
+    #hoverTrackingSuspensionCount;
+    /** @type {boolean} */
+    #postRenderHoverRefreshRequested;
     /**
      * @param {object} options
      * @param {import("../view/view.js").default} options.viewRoot
@@ -63,6 +75,8 @@ export default class InteractionController {
         this.#tooltipHandlers = tooltipHandlers;
         this.#renderPickingFramebuffer = renderPickingFramebuffer;
         this.#getDevicePixelRatio = getDevicePixelRatio;
+        this.#interactionDispatcher = new InteractionDispatcher({ viewRoot });
+        this.#cursorManager = new CursorManager({ canvas: glHelper.canvas });
 
         /**
          * Currently hovered mark and datum
@@ -74,14 +88,72 @@ export default class InteractionController {
 
         /** @type {Point} */
         this.#mouseDownCoords = undefined;
+        this.#lastPointerPoint = undefined;
 
         this.#tooltipUpdateRequested = false;
+        this.#hoverTrackingSuspensionCount = 0;
+        this.#postRenderHoverRefreshRequested = false;
     }
 
     getCurrentHover() {
         return this.#currentHover;
     }
 
+    suspendHoverTracking() {
+        this.#hoverTrackingSuspensionCount++;
+        this.#tooltip.clear();
+        this.#tooltipUpdateRequested = false;
+    }
+
+    /**
+     * @param {MouseEvent} [mouseEvent]
+     */
+    resumeHoverTracking(mouseEvent) {
+        if (this.#hoverTrackingSuspensionCount <= 0) {
+            return;
+        }
+
+        this.#hoverTrackingSuspensionCount--;
+        if (this.#hoverTrackingSuspensionCount > 0) {
+            return;
+        }
+
+        this.#tooltip.clear();
+        this.#tooltipUpdateRequested = false;
+
+        if (this.#isInteractionFrozen()) {
+            return;
+        }
+
+        if (mouseEvent) {
+            const point = this.#toCanvasPoint(mouseEvent);
+            this.#lastPointerPoint = point;
+            if (this.#isInsideCanvas(point)) {
+                this.#refreshHover(point);
+                this.#cursorManager.update({
+                    target: this.#interactionDispatcher.getCurrentTarget(),
+                    hover: this.#currentHover,
+                });
+                return;
+            }
+
+            this.#interactionDispatcher.handlePointerLeave(mouseEvent);
+        } else if (
+            this.#lastPointerPoint &&
+            this.#isInsideCanvas(this.#lastPointerPoint)
+        ) {
+            this.#refreshHover(this.#lastPointerPoint);
+            this.#cursorManager.update({
+                target: this.#interactionDispatcher.getCurrentTarget(),
+                hover: this.#currentHover,
+            });
+            return;
+        }
+
+        this.#currentHover = null;
+        this.#cursorManager.clear();
+    }
+
     registerInteractionEvents() {
         const canvas = this.#glHelper.canvas;
 
@@ -93,17 +165,26 @@ export default class InteractionController {
         /**
          * @param {Point} point
          * @param {import("../utils/interactionEvent.js").InteractionUiEvent} uiEvent
-         * @returns {InteractionEvent}
+         * @returns {import("../utils/interaction.js").default}
          */
-        const dispatchInteractionEvent = (point, uiEvent) => {
-            const interactionEvent = new InteractionEvent(point, uiEvent);
-            this.#viewRoot.propagateInteractionEvent(interactionEvent);
+        const dispatchInteraction = (point, uiEvent) => {
+            const interaction = this.#interactionDispatcher.dispatch(
+                point,
+                uiEvent
+            );
 
             if (!this.#tooltipUpdateRequested) {
                 this.#tooltip.clear();
             }
 
-            return interactionEvent;
+            if (uiEvent instanceof MouseEvent && uiEvent.type !== "mouseout") {
+                this.#cursorManager.update({
+                    target: interaction.target,
+                    hover: this.#currentHover,
+                });
+            }
+
+            return interaction;
         };
 
         /** @param {Event} event */
@@ -112,13 +193,21 @@ export default class InteractionController {
             const wheeling = now - lastWheelEvent < 200;
 
             if (event instanceof MouseEvent) {
-                const rect = canvas.getBoundingClientRect();
-                const point = new Point(
-                    event.clientX - rect.left - canvas.clientLeft,
-                    event.clientY - rect.top - canvas.clientTop
-                );
+                if (
+                    event.type !== "contextmenu" &&
+                    this.#isInteractionFrozen()
+                ) {
+                    return;
+                }
 
-                if (event.type == "mousemove" && !wheeling) {
+                const point = this.#toCanvasPoint(event);
+                this.#lastPointerPoint = point;
+
+                if (
+                    event.type == "mousemove" &&
+                    !wheeling &&
+                    this.#hoverTrackingSuspensionCount === 0
+                ) {
                     this.#tooltip.handleMouseMove(event);
                     this.#tooltipUpdateRequested = false;
 
@@ -135,7 +224,7 @@ export default class InteractionController {
                  * @param {MouseEvent} dispatchedEvent
                  */
                 const dispatchEvent = (dispatchedEvent) => {
-                    dispatchInteractionEvent(point, dispatchedEvent);
+                    dispatchInteraction(point, dispatchedEvent);
                 };
 
                 if (event.type != "wheel") {
@@ -174,7 +263,7 @@ export default class InteractionController {
                         // wheel ownership without running real wheel side
                         // effects first. Inertia is layered on top of that
                         // decision and is not the reason for the probe.
-                        const probeEvent = dispatchInteractionEvent(point, {
+                        const probeEvent = dispatchInteraction(point, {
                             type: "wheelclaimprobe",
                         });
 
@@ -239,7 +328,17 @@ export default class InteractionController {
                     this.#mouseDownCoords?.subtract(Point.fromMouseEvent(event))
                         .length < 3
                 ) {
-                    dispatchEvent(event);
+                    const interaction = dispatchInteraction(point, event);
+
+                    if (
+                        event.type == "dblclick" &&
+                        this.#hoverTrackingSuspensionCount === 0 &&
+                        this.#isInsideCanvas(point)
+                    ) {
+                        this.#scheduleHoverRefreshAfterRender();
+                    }
+
+                    return interaction;
                 }
             }
         };
@@ -313,7 +412,7 @@ export default class InteractionController {
             zDelta
         ) => {
             const point = toCanvasPoint(x, y);
-            dispatchInteractionEvent(point, {
+            dispatchInteraction(point, {
                 type: "touchgesture",
                 phase,
                 pointerCount,
@@ -428,7 +527,10 @@ export default class InteractionController {
                 document.addEventListener(
                     "mouseup",
                     () => this.#tooltip.popEnabledState(),
-                    { once: true }
+                    {
+                        once: true,
+                        capture: true,
+                    }
                 );
                 this.#tooltip.pushEnabledState(false);
             };
@@ -454,12 +556,103 @@ export default class InteractionController {
             event.stopPropagation()
         );
 
-        canvas.addEventListener("mouseout", () => {
+        canvas.addEventListener("mouseout", (event) => {
+            if (this.#isInteractionFrozen()) {
+                return;
+            }
+
+            if (this.#hoverTrackingSuspensionCount > 0) {
+                this.#tooltip.clear();
+                this.#tooltipUpdateRequested = false;
+                return;
+            }
+
+            this.#interactionDispatcher.handlePointerLeave(
+                /** @type {MouseEvent} */ (event)
+            );
+            this.#cursorManager.clear();
             this.#tooltip.clear();
             this.#currentHover = null;
         });
     }
 
+    /**
+     * @param {MouseEvent} event
+     */
+    #toCanvasPoint(event) {
+        const canvas = this.#glHelper.canvas;
+        const rect = canvas.getBoundingClientRect();
+        return new Point(
+            event.clientX - rect.left - canvas.clientLeft,
+            event.clientY - rect.top - canvas.clientTop
+        );
+    }
+
+    /**
+     * @param {Point} point
+     */
+    #isInsideCanvas(point) {
+        const canvas = this.#glHelper.canvas;
+        return (
+            point.x >= 0 &&
+            point.y >= 0 &&
+            point.x <= canvas.clientWidth &&
+            point.y <= canvas.clientHeight
+        );
+    }
+
+    /**
+     * @param {Point} point
+     */
+    #refreshHover(point) {
+        if (!isStillZooming()) {
+            this.#renderPickingFramebuffer();
+            this.#handlePicking(point.x, point.y);
+        }
+    }
+
+    #scheduleHoverRefreshAfterRender() {
+        if (this.#postRenderHoverRefreshRequested) {
+            return;
+        }
+
+        this.#postRenderHoverRefreshRequested = true;
+        this.#animator.requestRender();
+        window.requestAnimationFrame(() => {
+            this.#postRenderHoverRefreshRequested = false;
+
+            if (
+                this.#hoverTrackingSuspensionCount > 0 ||
+                this.#isInteractionFrozen()
+            ) {
+                return;
+            }
+
+            const point = this.#lastPointerPoint;
+            if (!point || !this.#isInsideCanvas(point)) {
+                this.#currentHover = null;
+                this.#cursorManager.clear();
+                return;
+            }
+
+            this.#tooltip.clear();
+            this.#tooltipUpdateRequested = false;
+            this.#refreshHover(point);
+            this.#cursorManager.update({
+                target: this.#interactionDispatcher.getCurrentTarget(),
+                hover: this.#currentHover,
+            });
+        });
+    }
+
+    #isInteractionFrozen() {
+        return (
+            typeof document !== "undefined" &&
+            !!document.body &&
+            document.body.classList.contains(FREEZE_INTERACTION_CLASS_NAME)
+        );
+    }
+
     /**
      * @param {number} x
      * @param {number} y
@@ -520,7 +713,7 @@ export default class InteractionController {
 
                 const tooltipProps = mark.properties.tooltip;
 
-                if (tooltipProps !== null) {
+                if (tooltipProps !== null && tooltipProps !== false) {
                     const handlerName = tooltipProps?.handler ?? "default";
                     const handler = this.#tooltipHandlers[handlerName];
                     if (!handler) {

package/dist/src/genomeSpy/interactionDispatcher.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Dispatches `Interaction` objects through the view hierarchy and synthesizes
+ * subtree-level pointer transition events.
+ *
+ * The dispatcher keeps track of the previously hovered target path and
+ * compares it with the current one on every `mousemove`. From that diff it
+ * emits:
+ * - `mouseleave` for views that are no longer in the pointed subtree
+ * - `mouseenter` for views that have newly entered the pointed subtree
+ *
+ * This is intentionally closer to `mouseenter` / `mouseleave` semantics than
+ * DOM `mouseover` / `mouseout`. Moving between descendants inside the same
+ * subtree does not cause the ancestor to leave and re-enter.
+ *
+ * `dispatch()` handles ordinary event propagation and updates the current
+ * pointed target. `handlePointerLeave()` is used when the pointer leaves the
+ * canvas entirely, in which case the dispatcher emits `mouseleave` for the
+ * whole previously hovered path and clears its tracked state.
+ *
+ * The dispatcher does not do hit testing itself. It relies on views to route
+ * the incoming interaction and set `interaction.target` during propagation.
+ */
+export default class InteractionDispatcher {
+    /**
+     * @param {object} options
+     * @param {import("../view/view.js").default} options.viewRoot
+     */
+    constructor({ viewRoot }: {
+        viewRoot: import("../view/view.js").default;
+    });
+    /**
+     * Dispatches an interaction through the view tree and updates the tracked
+     * hover path for transition synthesis.
+     *
+     * @param {import("../view/layout/point.js").default} point
+     * @param {import("../utils/interactionEvent.js").InteractionUiEvent} uiEvent
+     * @returns {Interaction}
+     */
+    dispatch(point: import("../view/layout/point.js").default, uiEvent: import("../utils/interactionEvent.js").InteractionUiEvent): Interaction;
+    /**
+     * Dispatches mouseleave transitions when the pointer leaves the canvas.
+     *
+     * @param {import("../utils/interactionEvent.js").InteractionUiEvent} uiEvent
+     */
+    handlePointerLeave(uiEvent: import("../utils/interactionEvent.js").InteractionUiEvent): void;
+    getCurrentTarget(): import("../view/view.js").default<import("../spec/view.js").ViewSpec>;
+    #private;
+}
+import Interaction from "../utils/interaction.js";
+//# sourceMappingURL=interactionDispatcher.d.ts.map

package/dist/src/genomeSpy/interactionDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactionDispatcher.d.ts","sourceRoot":"","sources":["../../../src/genomeSpy/interactionDispatcher.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAUI;;;OAGG;IACH,0BAFG;QAAmD,QAAQ,EAAnD,OAAO,iBAAiB,EAAE,OAAO;KAC3C,EAGA;IAED;;;;;;;OAOG;IACH,gBAJW,OAAO,yBAAyB,EAAE,OAAO,WACzC,OAAO,8BAA8B,EAAE,kBAAkB,GACvD,WAAW,CAavB;IAED;;;;OAIG;IACH,4BAFW,OAAO,8BAA8B,EAAE,kBAAkB,QAiBnE;IAED,0FAEC;;CAmHJ;wBA1MuB,yBAAyB"}

package/dist/src/genomeSpy/interactionDispatcher.js

@@ -0,0 +1,203 @@
+import Interaction from "../utils/interaction.js";
+
+/**
+ * Dispatches `Interaction` objects through the view hierarchy and synthesizes
+ * subtree-level pointer transition events.
+ *
+ * The dispatcher keeps track of the previously hovered target path and
+ * compares it with the current one on every `mousemove`. From that diff it
+ * emits:
+ * - `mouseleave` for views that are no longer in the pointed subtree
+ * - `mouseenter` for views that have newly entered the pointed subtree
+ *
+ * This is intentionally closer to `mouseenter` / `mouseleave` semantics than
+ * DOM `mouseover` / `mouseout`. Moving between descendants inside the same
+ * subtree does not cause the ancestor to leave and re-enter.
+ *
+ * `dispatch()` handles ordinary event propagation and updates the current
+ * pointed target. `handlePointerLeave()` is used when the pointer leaves the
+ * canvas entirely, in which case the dispatcher emits `mouseleave` for the
+ * whole previously hovered path and clears its tracked state.
+ *
+ * The dispatcher does not do hit testing itself. It relies on views to route
+ * the incoming interaction and set `interaction.target` during propagation.
+ */
+export default class InteractionDispatcher {
+    /** @type {import("../view/view.js").default} */
+    #viewRoot;
+    /** @type {import("../view/layout/point.js").default | undefined} */
+    #lastPoint;
+    /** @type {import("../view/view.js").default | undefined} */
+    #lastTarget;
+    /** @type {import("../view/view.js").default[]} */
+    #previousPath = [];
+
+    /**
+     * @param {object} options
+     * @param {import("../view/view.js").default} options.viewRoot
+     */
+    constructor({ viewRoot }) {
+        this.#viewRoot = viewRoot;
+    }
+
+    /**
+     * Dispatches an interaction through the view tree and updates the tracked
+     * hover path for transition synthesis.
+     *
+     * @param {import("../view/layout/point.js").default} point
+     * @param {import("../utils/interactionEvent.js").InteractionUiEvent} uiEvent
+     * @returns {Interaction}
+     */
+    dispatch(point, uiEvent) {
+        this.#lastPoint = point;
+        const interaction = new Interaction(point, uiEvent);
+        this.#viewRoot.propagateInteraction(interaction);
+        this.#lastTarget = interaction.target;
+
+        if (interaction.type === "mousemove") {
+            this.#dispatchPointerTransitions(interaction);
+        }
+
+        return interaction;
+    }
+
+    /**
+     * Dispatches mouseleave transitions when the pointer leaves the canvas.
+     *
+     * @param {import("../utils/interactionEvent.js").InteractionUiEvent} uiEvent
+     */
+    handlePointerLeave(uiEvent) {
+        if (!this.#lastPoint || this.#previousPath.length === 0) {
+            this.#previousPath = [];
+            this.#lastTarget = undefined;
+            return;
+        }
+
+        const interaction = new Interaction(
+            this.#lastPoint,
+            uiEvent,
+            "mouseleave"
+        );
+        this.#dispatchLeaveEvents(interaction, this.#previousPath, undefined);
+        this.#previousPath = [];
+        this.#lastTarget = undefined;
+    }
+
+    getCurrentTarget() {
+        return this.#lastTarget;
+    }
+
+    /**
+     * Diffs the old and new pointed paths and emits synthetic subtree
+     * transitions.
+     *
+     * @param {Interaction} interaction
+     */
+    #dispatchPointerTransitions(interaction) {
+        const currentPath = this.#toRootPath(interaction.target);
+        const previousPath = this.#previousPath;
+
+        let commonLength = 0;
+        while (
+            commonLength < previousPath.length &&
+            commonLength < currentPath.length &&
+            previousPath[commonLength] === currentPath[commonLength]
+        ) {
+            commonLength++;
+        }
+
+        if (commonLength < previousPath.length) {
+            this.#dispatchLeaveEvents(
+                interaction,
+                previousPath.slice(commonLength),
+                currentPath.at(-1)
+            );
+        }
+
+        if (commonLength < currentPath.length) {
+            this.#dispatchEnterEvents(
+                interaction,
+                currentPath.slice(commonLength),
+                previousPath.at(-1)
+            );
+        }
+
+        this.#previousPath = currentPath;
+    }
+
+    /**
+     * @param {Interaction} baseInteraction
+     * @param {import("../view/view.js").default[]} leavingViews
+     * @param {import("../view/view.js").default | undefined} relatedTarget
+     */
+    #dispatchLeaveEvents(baseInteraction, leavingViews, relatedTarget) {
+        for (let i = leavingViews.length - 1; i >= 0; i--) {
+            const interaction = new Interaction(
+                baseInteraction.point,
+                baseInteraction.uiEvent,
+                "mouseleave"
+            );
+            const view = leavingViews[i];
+            interaction.target = view;
+            interaction.currentTarget = view;
+            interaction.relatedTarget = relatedTarget;
+            this.#dispatchDirect(view, interaction);
+
+            if (interaction.stopped) {
+                return;
+            }
+        }
+    }
+
+    /**
+     * @param {Interaction} baseInteraction
+     * @param {import("../view/view.js").default[]} enteringViews
+     * @param {import("../view/view.js").default | undefined} relatedTarget
+     */
+    #dispatchEnterEvents(baseInteraction, enteringViews, relatedTarget) {
+        for (const view of enteringViews) {
+            const interaction = new Interaction(
+                baseInteraction.point,
+                baseInteraction.uiEvent,
+                "mouseenter"
+            );
+            interaction.target = view;
+            interaction.currentTarget = view;
+            interaction.relatedTarget = relatedTarget;
+            this.#dispatchDirect(view, interaction);
+
+            if (interaction.stopped) {
+                return;
+            }
+        }
+    }
+
+    /**
+     * @param {import("../view/view.js").default | undefined} target
+     * @returns {import("../view/view.js").default[]}
+     */
+    #toRootPath(target) {
+        return target ? target.getLayoutAncestors().reverse() : [];
+    }
+
+    /**
+     * Dispatches a synthetic transition directly on a single view.
+     *
+     * Unlike ordinary routed propagation, enter/leave transitions are already
+     * resolved to a specific view. Therefore the dispatcher invokes that
+     * view's capture listeners first and bubble listeners second without
+     * re-entering container routing.
+     *
+     * @param {import("../view/view.js").default} view
+     * @param {Interaction} interaction
+     */
+    #dispatchDirect(view, interaction) {
+        view.handleInteraction(interaction, true);
+
+        if (interaction.stopped) {
+            return;
+        }
+
+        view.handleInteraction(interaction, false);
+    }
+}

package/dist/src/genomeSpy/viewContextFactory.d.ts

@@ -7,12 +7,14 @@
  * what they need while keeping production usage explicit.
  *
  * @param {Partial<ViewContext> & {
- *   createOrImportViewWithContext?: (context: ViewContext, spec: import("../spec/view.js").ViewSpec | import("../spec/view.js").ImportSpec, layoutParent?: import("../view/containerView.js").default, dataParent?: import("../view/view.js").default, defaultName?: string, validator?: (spec: import("../spec/view.js").ViewSpec) => void) => Promise<import("../view/view.js").default>
+ *   createOrImportViewWithContext?: (context: ViewContext, spec: import("../spec/view.js").ViewSpec | import("../spec/view.js").ImportSpec, layoutParent?: import("../view/containerView.js").default, dataParent?: import("../view/view.js").default, defaultName?: string, validator?: (spec: import("../spec/view.js").ViewSpec) => void, options?: import("../types/viewContext.js").CreateViewOptions) => Promise<import("../view/view.js").default>
+ *   allowMissingGlHelper?: boolean
  * }} options
  * @returns {ViewContext}
  */
 export function createViewContext(options: Partial<ViewContext> & {
-    createOrImportViewWithContext?: (context: ViewContext, spec: import("../spec/view.js").ViewSpec | import("../spec/view.js").ImportSpec, layoutParent?: import("../view/containerView.js").default, dataParent?: import("../view/view.js").default, defaultName?: string, validator?: (spec: import("../spec/view.js").ViewSpec) => void) => Promise<import("../view/view.js").default>;
+    createOrImportViewWithContext?: (context: ViewContext, spec: import("../spec/view.js").ViewSpec | import("../spec/view.js").ImportSpec, layoutParent?: import("../view/containerView.js").default, dataParent?: import("../view/view.js").default, defaultName?: string, validator?: (spec: import("../spec/view.js").ViewSpec) => void, options?: import("../types/viewContext.js").CreateViewOptions) => Promise<import("../view/view.js").default>;
+    allowMissingGlHelper?: boolean;
 }): ViewContext;
 export type ViewContext = import("../types/viewContext.js").default;
 //# sourceMappingURL=viewContextFactory.d.ts.map

package/dist/src/genomeSpy/viewContextFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viewContextFactory.d.ts","sourceRoot":"","sources":["../../../src/genomeSpy/viewContextFactory.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,2CALW,OAAO,CAAC,WAAW,CAAC,GAAG;IAC7B,6BAA6B,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,QAAQ,GAAG,OAAO,iBAAiB,EAAE,UAAU,EAAE,YAAY,CAAC,EAAE,OAAO,0BAA0B,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,OAAO,iBAAiB,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,QAAQ,KAAK,IAAI,KAAK,OAAO,CAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC,CAAA;CACvX,GACS,WAAW,CAiEvB;0BA5EY,OAAO,yBAAyB,EAAE,OAAO"}
+{"version":3,"file":"viewContextFactory.d.ts","sourceRoot":"","sources":["../../../src/genomeSpy/viewContextFactory.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,2CANW,OAAO,CAAC,WAAW,CAAC,GAAG;IAC7B,6BAA6B,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,QAAQ,GAAG,OAAO,iBAAiB,EAAE,UAAU,EAAE,YAAY,CAAC,EAAE,OAAO,0BAA0B,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,OAAO,iBAAiB,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,yBAAyB,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC,CAAA;IACrb,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,GACS,WAAW,CAwEvB;0BApFY,OAAO,yBAAyB,EAAE,OAAO"}