@jax-data-science/sci-image-visualizer 0.8.3 → 0.9.0

package/esm2022/lib/visualizer/tool-modes.mjs

@@ -0,0 +1,113 @@
+/** Region draw/select/edit modes, routed through the backend's region overlay. The vertex
+ *  tools (drawpolygon/addpoint/deletepoint/move) are handled by the OpenSeadragon overlay;
+ *  Plotly's overlay maps them to no-op. */
+const REGION_MODES = new Set([
+    'drawrect',
+    'drawclosedpath',
+    'drawopenpath',
+    'select',
+    'drawpolygon',
+    'addpoint',
+    'deletepoint',
+    'move',
+]);
+/**
+ * The armed tool mode (one at a time across the region overlay, the viewport drag
+ * modes and the on-canvas tools) and the toolbar's tool settings it arms them with.
+ */
+export class ToolModes {
+    constructor(target, record, zone, 
+    /** Runs after every arm/disarm with the newly armed mode. */
+    armed, markForCheck) {
+        this.target = target;
+        this.record = record;
+        this.armed = armed;
+        /** The armed mode, or null. */
+        this.active = null;
+        /** Wand sensitivity — higher = stricter (smaller selection). Matches QuPath default. */
+        this.wandSensitivity = 2.0;
+        /** Brush diameter in image-pixel coordinates (drives the painted disc size). */
+        this.brushSize = 40;
+        /** Vertex eraser radius in image-pixel coordinates. */
+        this.vertexEraserRadius = 20;
+        /** Class the brush paints while a plot mode armed it; null = plain brush. */
+        this.brushClass = null;
+        this.plotModeTools = {
+            armBrush: (brushClass) => zone.run(() => {
+                this.brushClass = { label: brushClass?.label, color: brushClass?.color };
+                if (this.active === 'brush')
+                    this.target.setBrushOptions({ size: this.brushSize, ...this.brushClass });
+                else
+                    this.apply('brush');
+                markForCheck();
+            }),
+            disarm: () => zone.run(() => {
+                this.brushClass = null;
+                if (this.active !== null)
+                    this.apply(null);
+                markForCheck();
+            }),
+            activeTool$: record.getActiveTool$(),
+        };
+    }
+    /** A tool picked by the user (always the plain tool, never a plot mode's brush class);
+     *  re-picking the armed one disarms it. */
+    toggle(mode) {
+        this.brushClass = null;
+        this.apply(this.active === mode ? null : mode);
+    }
+    /** Arm `mode` (or nothing) across every tool. */
+    apply(mode) {
+        this.active = mode;
+        this.record.setActiveTool(mode);
+        const regionMode = mode !== null && REGION_MODES.has(mode);
+        this.target.getRegionOverlay()?.setMode(regionMode ? mode : 'none');
+        // Viewport drag modes (pan/box-zoom). Region modes own the drag mode via the overlay.
+        if (!regionMode)
+            this.target.setDragMode(mode === 'pan' || mode === 'zoom' ? mode : false);
+        // On-canvas tools: arm the one this mode names (none for a region or viewport mode).
+        this.target.setActiveTool(mode, this.options(mode));
+        this.armed(mode);
+    }
+    /** Disarm whatever is armed and clear every tool mode (a plot-type switch). */
+    deactivate() {
+        this.brushClass = null;
+        this.active = null;
+        this.record.setActiveTool(null);
+        this.target.getRegionOverlay()?.setMode('none');
+        this.target.setDragMode(false);
+        this.target.setActiveTool(null);
+    }
+    setWandSensitivity(value) {
+        if (value === undefined || !Number.isFinite(value))
+            return;
+        this.wandSensitivity = value;
+        this.target.setWandOptions({ sensitivity: value });
+    }
+    setBrushSize(value) {
+        if (value === undefined || !Number.isFinite(value))
+            return;
+        this.brushSize = value;
+        this.target.setBrushOptions({ size: value });
+    }
+    setVertexEraserRadius(value) {
+        if (value === undefined || !Number.isFinite(value))
+            return;
+        this.vertexEraserRadius = value;
+        this.target.setVertexEraserRadius(value);
+    }
+    /** The options a canvas tool is armed with, from the toolbar's settings. */
+    options(mode) {
+        switch (mode) {
+            case 'wand':
+                return { sensitivity: this.wandSensitivity };
+            case 'brush':
+                return { size: this.brushSize, ...this.brushClass };
+            case 'eraseVertex':
+                return { radius: this.vertexEraserRadius };
+            default:
+                return undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool-modes.js","sourceRoot":"","sources":["../../../../src/lib/visualizer/tool-modes.ts"],"names":[],"mappings":"AAyBA;;2CAE2C;AAC3C,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC;IAChD,UAAU;IACV,gBAAgB;IAChB,cAAc;IACd,QAAQ;IACR,aAAa;IACb,UAAU;IACV,aAAa;IACb,MAAM;CACP,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,OAAO,SAAS;IAepB,YACmB,MAAuB,EACvB,MAAwB,EACzC,IAAY;IACZ,6DAA6D;IAC5C,KAAoC,EACrD,YAAwB;QALP,WAAM,GAAN,MAAM,CAAiB;QACvB,WAAM,GAAN,MAAM,CAAkB;QAGxB,UAAK,GAAL,KAAK,CAA+B;QAnBvD,+BAA+B;QAC/B,WAAM,GAAkB,IAAI,CAAC;QAC7B,wFAAwF;QACxF,oBAAe,GAAG,GAAG,CAAC;QACtB,gFAAgF;QAChF,cAAS,GAAG,EAAE,CAAC;QACf,uDAAuD;QACvD,uBAAkB,GAAG,EAAE,CAAC;QAIxB,6EAA6E;QACrE,eAAU,GAA8B,IAAI,CAAC;QAUnD,IAAI,CAAC,aAAa,GAAG;YACnB,QAAQ,EAAE,CAAC,UAA+B,EAAE,EAAE,CAC5C,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;gBACZ,IAAI,CAAC,UAAU,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;gBACzE,IAAI,IAAI,CAAC,MAAM,KAAK,OAAO;oBAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;;oBAClG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACzB,YAAY,EAAE,CAAC;YACjB,CAAC,CAAC;YACJ,MAAM,EAAE,GAAG,EAAE,CACX,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;gBACZ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI;oBAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC3C,YAAY,EAAE,CAAC;YACjB,CAAC,CAAC;YACJ,WAAW,EAAE,MAAM,CAAC,cAAc,EAAE;SACrC,CAAC;IACJ,CAAC;IAED;+CAC2C;IAC3C,MAAM,CAAC,IAAY;QACjB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;IAED,iDAAiD;IACjD,KAAK,CAAC,IAAmB;QACvB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,UAAU,GAAG,IAAI,KAAK,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAE,IAAuB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACxF,sFAAsF;QACtF,IAAI,CAAC,UAAU;YAAE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3F,qFAAqF;QACrF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnB,CAAC;IAED,+EAA+E;IAC/E,UAAU;QACR,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED,kBAAkB,CAAC,KAAyB;QAC1C,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO;QAC3D,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,YAAY,CAAC,KAAyB;QACpC,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO;QAC3D,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,qBAAqB,CAAC,KAAyB;QAC7C,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO;QAC3D,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED,4EAA4E;IACpE,OAAO,CAAC,IAAmB;QACjC,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC;YAC/C,KAAK,OAAO;gBACV,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YACtD,KAAK,aAAa;gBAChB,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC7C;gBACE,OAAO,SAAS,CAAC;QACrB,CAAC;IACH,CAAC;CACF","sourcesContent":["import { NgZone } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { CanvasToolOptions } from '../contracts/display-types';\nimport { PlotModeBrushClass, PlotModeTools } from '../contracts/plot-type-contribution.contract';\nimport { RegionToolMode } from '../contracts/region-overlay.contract';\nimport { IVisualizer } from '../contracts/visualizer.contract';\n\n/** The backend members tool arming drives. */\nexport type ToolModesTarget = Pick<\n  IVisualizer,\n  | 'getRegionOverlay'\n  | 'setDragMode'\n  | 'setActiveTool'\n  | 'setWandOptions'\n  | 'setBrushOptions'\n  | 'setVertexEraserRadius'\n>;\n\n/** Where the armed tool is recorded for everyone else (the shared session store). */\nexport interface ActiveToolRecord {\n  setActiveTool(id: string | null): void;\n  getActiveTool$(): Observable<string | null>;\n}\n\n/** Region draw/select/edit modes, routed through the backend's region overlay. The vertex\n *  tools (drawpolygon/addpoint/deletepoint/move) are handled by the OpenSeadragon overlay;\n *  Plotly's overlay maps them to no-op. */\nconst REGION_MODES: ReadonlySet<string> = new Set([\n  'drawrect',\n  'drawclosedpath',\n  'drawopenpath',\n  'select',\n  'drawpolygon',\n  'addpoint',\n  'deletepoint',\n  'move',\n]);\n\n/**\n * The armed tool mode (one at a time across the region overlay, the viewport drag\n * modes and the on-canvas tools) and the toolbar's tool settings it arms them with.\n */\nexport class ToolModes {\n  /** The armed mode, or null. */\n  active: string | null = null;\n  /** Wand sensitivity — higher = stricter (smaller selection). Matches QuPath default. */\n  wandSensitivity = 2.0;\n  /** Brush diameter in image-pixel coordinates (drives the painted disc size). */\n  brushSize = 40;\n  /** Vertex eraser radius in image-pixel coordinates. */\n  vertexEraserRadius = 20;\n  /** The toolbar tools a contributed plot mode may arm. Calls can come from outside\n   *  Angular, hence the zone. */\n  readonly plotModeTools: PlotModeTools;\n  /** Class the brush paints while a plot mode armed it; null = plain brush. */\n  private brushClass: PlotModeBrushClass | null = null;\n\n  constructor(\n    private readonly target: ToolModesTarget,\n    private readonly record: ActiveToolRecord,\n    zone: NgZone,\n    /** Runs after every arm/disarm with the newly armed mode. */\n    private readonly armed: (mode: string | null) => void,\n    markForCheck: () => void,\n  ) {\n    this.plotModeTools = {\n      armBrush: (brushClass?: PlotModeBrushClass) =>\n        zone.run(() => {\n          this.brushClass = { label: brushClass?.label, color: brushClass?.color };\n          if (this.active === 'brush') this.target.setBrushOptions({ size: this.brushSize, ...this.brushClass });\n          else this.apply('brush');\n          markForCheck();\n        }),\n      disarm: () =>\n        zone.run(() => {\n          this.brushClass = null;\n          if (this.active !== null) this.apply(null);\n          markForCheck();\n        }),\n      activeTool$: record.getActiveTool$(),\n    };\n  }\n\n  /** A tool picked by the user (always the plain tool, never a plot mode's brush class);\n   *  re-picking the armed one disarms it. */\n  toggle(mode: string): void {\n    this.brushClass = null;\n    this.apply(this.active === mode ? null : mode);\n  }\n\n  /** Arm `mode` (or nothing) across every tool. */\n  apply(mode: string | null): void {\n    this.active = mode;\n    this.record.setActiveTool(mode);\n    const regionMode = mode !== null && REGION_MODES.has(mode);\n    this.target.getRegionOverlay()?.setMode(regionMode ? (mode as RegionToolMode) : 'none');\n    // Viewport drag modes (pan/box-zoom). Region modes own the drag mode via the overlay.\n    if (!regionMode) this.target.setDragMode(mode === 'pan' || mode === 'zoom' ? mode : false);\n    // On-canvas tools: arm the one this mode names (none for a region or viewport mode).\n    this.target.setActiveTool(mode, this.options(mode));\n    this.armed(mode);\n  }\n\n  /** Disarm whatever is armed and clear every tool mode (a plot-type switch). */\n  deactivate(): void {\n    this.brushClass = null;\n    this.active = null;\n    this.record.setActiveTool(null);\n    this.target.getRegionOverlay()?.setMode('none');\n    this.target.setDragMode(false);\n    this.target.setActiveTool(null);\n  }\n\n  setWandSensitivity(value: number | undefined): void {\n    if (value === undefined || !Number.isFinite(value)) return;\n    this.wandSensitivity = value;\n    this.target.setWandOptions({ sensitivity: value });\n  }\n\n  setBrushSize(value: number | undefined): void {\n    if (value === undefined || !Number.isFinite(value)) return;\n    this.brushSize = value;\n    this.target.setBrushOptions({ size: value });\n  }\n\n  setVertexEraserRadius(value: number | undefined): void {\n    if (value === undefined || !Number.isFinite(value)) return;\n    this.vertexEraserRadius = value;\n    this.target.setVertexEraserRadius(value);\n  }\n\n  /** The options a canvas tool is armed with, from the toolbar's settings. */\n  private options(mode: string | null): CanvasToolOptions | undefined {\n    switch (mode) {\n      case 'wand':\n        return { sensitivity: this.wandSensitivity };\n      case 'brush':\n        return { size: this.brushSize, ...this.brushClass };\n      case 'eraseVertex':\n        return { radius: this.vertexEraserRadius };\n      default:\n        return undefined;\n    }\n  }\n}\n"]}

package/esm2022/lib/visualizer/viewer-shortcuts.mjs

@@ -0,0 +1,167 @@
+/** Bare keys that toggle a tool mode. */
+const TOOL_KEYS = new Map([
+    ['p', 'pan'],
+    ['b', 'zoomToBox'],
+    ['r', 'drawrect'],
+    ['f', 'drawclosedpath'],
+    ['w', 'wand'],
+    ['e', 'eraseVertex'],
+    ['s', 'select'],
+    ['l', 'drawopenpath'],
+]);
+/** A field the user types into: its keys are never shortcuts. */
+function isTextField(t) {
+    return !!t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable);
+}
+/**
+ * The viewer's keyboard, wheel and context-menu handling: one window listener each,
+ * registered OUTSIDE the Angular zone (zone-patched, every event anywhere in the host
+ * app ran app-wide change detection) and re-entering it only to act.
+ *
+ * Keys: ←/→ step the slice; Enter/Escape resolve a SAM point prompt; Ctrl/Cmd+Z undo,
+ * Ctrl/Cmd+Shift+Z or +Y redo; bare Delete/Backspace/d delete the selected region,
+ * +/= and -/_ zoom, and single letters toggle tools (`TOOL_KEYS`). Any other
+ * modified key is left to the browser (Cmd/Ctrl+D must not delete a region).
+ *
+ * Keys are per viewer: with two live viewers (a main view and a pipeline preview)
+ * one Delete must not delete in both. A key goes to the viewer that holds focus, or
+ * — focus elsewhere — to the viewer the pointer last moved over; any other viewer
+ * ignores it (review CORE-2).
+ */
+export class ViewerShortcuts {
+    /** Every attached instance, to find the one holding focus. */
+    static { this.live = new Set(); }
+    /** The viewer the pointer last moved over. */
+    static { this.lastHovered = null; }
+    constructor(host, zone) {
+        this.host = host;
+        this.zone = zone;
+        this.listeners = [];
+    }
+    /** Register the window listeners (outside the zone). */
+    attach() {
+        this.zone.runOutsideAngular(() => {
+            this.listen('contextmenu', (e) => this.onContextMenu(e), true);
+            this.listen('keydown', (e) => this.onKeydown(e), false);
+            this.listen('wheel', (e) => this.onWheel(e), { capture: true, passive: false });
+            // `pointerover` fires on element transitions only, not on every move.
+            this.listen('pointerover', (e) => {
+                if (this.contains(e.target))
+                    ViewerShortcuts.lastHovered = this;
+            }, true);
+        });
+        ViewerShortcuts.live.add(this);
+    }
+    /** Remove every listener {@link attach} added. */
+    detach() {
+        ViewerShortcuts.live.delete(this);
+        if (ViewerShortcuts.lastHovered === this)
+            ViewerShortcuts.lastHovered = null;
+        for (const [type, listener, options] of this.listeners.splice(0)) {
+            window.removeEventListener(type, listener, options);
+        }
+    }
+    listen(type, listener, options) {
+        window.addEventListener(type, listener, options);
+        this.listeners.push([type, listener, options]);
+    }
+    contains(node) {
+        const el = this.host.hostElement ?? document.getElementById(this.host.plotDivName);
+        return !!node && !!el?.contains(node);
+    }
+    /** Whether this viewer takes keys now: it holds focus, or nothing does and the
+     *  pointer was last over it. */
+    ownsKeys() {
+        const active = document.activeElement;
+        const focused = active && active !== document.body ? [...ViewerShortcuts.live].find((s) => s.contains(active)) : undefined;
+        return (focused ?? ViewerShortcuts.lastHovered) === this;
+    }
+    overPlot(event) {
+        return !!document.getElementById(this.host.plotDivName)?.contains(event.target);
+    }
+    run(fn) {
+        this.zone.run(fn);
+    }
+    onContextMenu(event) {
+        if (!this.overPlot(event))
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        this.run(() => this.host.openContextMenu(event));
+    }
+    onWheel(event) {
+        if (!this.overPlot(event))
+            return;
+        // A renderer that reads the scroll delta (napari, 3D scenes) keeps its own wheel:
+        // a FIXED zoom step per wheel event is far too sensitive there.
+        if (!this.host.wheelZooms())
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        if (event.deltaY < 0)
+            this.run(() => this.host.zoomIn());
+        else if (event.deltaY > 0)
+            this.run(() => this.host.zoomOut());
+    }
+    onKeydown(event) {
+        if (!this.ownsKeys())
+            return;
+        const host = this.host;
+        const target = event.target;
+        if (this.isSliceStepKey(event, target)) {
+            event.preventDefault();
+            this.run(() => host.stepSlice(event.key === 'ArrowRight' ? 1 : -1));
+            return;
+        }
+        if (isTextField(target))
+            return;
+        if (host.activeDragMode() === 'samPoint' && (event.key === 'Enter' || event.key === 'Escape')) {
+            this.run(() => host.resolveSamPrompt(event.key === 'Enter'));
+            return;
+        }
+        if (event.ctrlKey || event.metaKey) {
+            const k = event.key.toLowerCase();
+            if (k === 'z' && !event.shiftKey) {
+                event.preventDefault();
+                this.run(() => host.undo());
+                return;
+            }
+            if ((k === 'z' && event.shiftKey) || k === 'y') {
+                event.preventDefault();
+                this.run(() => host.redo());
+                return;
+            }
+        }
+        // The bare-key shortcuts must not fire on browser/OS shortcuts.
+        if (event.ctrlKey || event.metaKey || event.altKey)
+            return;
+        const key = event.key;
+        if (key === 'Delete' || key === 'Backspace' || key === 'd' || key === 'D')
+            this.run(() => host.deleteRegion());
+        else if (key === '+' || key === '=')
+            this.run(() => host.zoomIn());
+        else if (key === '-' || key === '_')
+            this.run(() => host.zoomOut());
+        else {
+            const mode = TOOL_KEYS.get(key);
+            if (mode)
+                this.run(() => host.toggleDragMode(mode));
+        }
+    }
+    /**
+     * ←/→ step the slice in the Image view, the same way the slider does — only for a
+     * loaded stack, and not while a form field or the slider itself has focus (it
+     * handles arrows natively; stepping here too would double-step). Up/Down are left
+     * to OpenSeadragon (panning).
+     */
+    isSliceStepKey(e, t) {
+        if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight')
+            return false;
+        if (!this.host.canStepSlice())
+            return false;
+        if (t && (/^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName) || t.isContentEditable))
+            return false;
+        return !(t && (t.getAttribute('role') === 'slider' || t.closest('.p-slider')));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewer-shortcuts.js","sourceRoot":"","sources":["../../../../src/lib/visualizer/viewer-shortcuts.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgZone } from '@angular/core';\n\n/** What the shortcuts drive: the viewer's actions and the state they gate on. */\nexport interface ShortcutHost {\n  /** Id of the plot div; the wheel and the context menu act only over it. */\n  readonly plotDivName: string;\n  /** The viewer's own element (toolbar + plot); its keys are scoped to it. Falls back\n   *  to the plot div when absent. */\n  readonly hostElement?: HTMLElement | null;\n  /** The armed tool — SAM point mode takes Enter / Escape. */\n  activeDragMode(): string | null;\n  /** ←/→ step the slice: a loaded stack in the Image view. */\n  canStepSlice(): boolean;\n  /** The wheel steps the zoom: a 2D view whose renderer does not read the wheel itself. */\n  wheelZooms(): boolean;\n  stepSlice(delta: number): void;\n  /** SAM point mode: commit (Enter) or discard (Escape) the prompt. */\n  resolveSamPrompt(commit: boolean): void;\n  undo(): void;\n  redo(): void;\n  deleteRegion(): void;\n  zoomIn(): void;\n  zoomOut(): void;\n  toggleDragMode(mode: string): void;\n  openContextMenu(event: MouseEvent): void;\n}\n\n/** Bare keys that toggle a tool mode. */\nconst TOOL_KEYS: ReadonlyMap<string, string> = new Map([\n  ['p', 'pan'],\n  ['b', 'zoomToBox'],\n  ['r', 'drawrect'],\n  ['f', 'drawclosedpath'],\n  ['w', 'wand'],\n  ['e', 'eraseVertex'],\n  ['s', 'select'],\n  ['l', 'drawopenpath'],\n]);\n\n/** A field the user types into: its keys are never shortcuts. */\nfunction isTextField(t: HTMLElement | null): boolean {\n  return !!t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable);\n}\n\n/**\n * The viewer's keyboard, wheel and context-menu handling: one window listener each,\n * registered OUTSIDE the Angular zone (zone-patched, every event anywhere in the host\n * app ran app-wide change detection) and re-entering it only to act.\n *\n * Keys: ←/→ step the slice; Enter/Escape resolve a SAM point prompt; Ctrl/Cmd+Z undo,\n * Ctrl/Cmd+Shift+Z or +Y redo; bare Delete/Backspace/d delete the selected region,\n * +/= and -/_ zoom, and single letters toggle tools (`TOOL_KEYS`). Any other\n * modified key is left to the browser (Cmd/Ctrl+D must not delete a region).\n *\n * Keys are per viewer: with two live viewers (a main view and a pipeline preview)\n * one Delete must not delete in both. A key goes to the viewer that holds focus, or\n * — focus elsewhere — to the viewer the pointer last moved over; any other viewer\n * ignores it (review CORE-2).\n */\nexport class ViewerShortcuts {\n  /** Every attached instance, to find the one holding focus. */\n  private static readonly live = new Set<ViewerShortcuts>();\n  /** The viewer the pointer last moved over. */\n  private static lastHovered: ViewerShortcuts | null = null;\n  private readonly listeners: [string, EventListener, boolean | AddEventListenerOptions][] = [];\n\n  constructor(\n    private readonly host: ShortcutHost,\n    private readonly zone: NgZone,\n  ) {}\n\n  /** Register the window listeners (outside the zone). */\n  attach(): void {\n    this.zone.runOutsideAngular(() => {\n      this.listen('contextmenu', (e) => this.onContextMenu(e as MouseEvent), true);\n      this.listen('keydown', (e) => this.onKeydown(e as KeyboardEvent), false);\n      this.listen('wheel', (e) => this.onWheel(e as WheelEvent), { capture: true, passive: false });\n      // `pointerover` fires on element transitions only, not on every move.\n      this.listen(\n        'pointerover',\n        (e) => {\n          if (this.contains(e.target as Node)) ViewerShortcuts.lastHovered = this;\n        },\n        true,\n      );\n    });\n    ViewerShortcuts.live.add(this);\n  }\n\n  /** Remove every listener {@link attach} added. */\n  detach(): void {\n    ViewerShortcuts.live.delete(this);\n    if (ViewerShortcuts.lastHovered === this) ViewerShortcuts.lastHovered = null;\n    for (const [type, listener, options] of this.listeners.splice(0)) {\n      window.removeEventListener(type, listener, options);\n    }\n  }\n\n  private listen(type: string, listener: EventListener, options: boolean | AddEventListenerOptions): void {\n    window.addEventListener(type, listener, options);\n    this.listeners.push([type, listener, options]);\n  }\n\n  private contains(node: Node | null): boolean {\n    const el = this.host.hostElement ?? document.getElementById(this.host.plotDivName);\n    return !!node && !!el?.contains(node);\n  }\n\n  /** Whether this viewer takes keys now: it holds focus, or nothing does and the\n   *  pointer was last over it. */\n  private ownsKeys(): boolean {\n    const active = document.activeElement;\n    const focused =\n      active && active !== document.body ? [...ViewerShortcuts.live].find((s) => s.contains(active)) : undefined;\n    return (focused ?? ViewerShortcuts.lastHovered) === this;\n  }\n\n  private overPlot(event: Event): boolean {\n    return !!document.getElementById(this.host.plotDivName)?.contains(event.target as Node);\n  }\n\n  private run(fn: () => void): void {\n    this.zone.run(fn);\n  }\n\n  private onContextMenu(event: MouseEvent): void {\n    if (!this.overPlot(event)) return;\n    event.preventDefault();\n    event.stopImmediatePropagation();\n    this.run(() => this.host.openContextMenu(event));\n  }\n\n  private onWheel(event: WheelEvent): void {\n    if (!this.overPlot(event)) return;\n    // A renderer that reads the scroll delta (napari, 3D scenes) keeps its own wheel:\n    // a FIXED zoom step per wheel event is far too sensitive there.\n    if (!this.host.wheelZooms()) return;\n    event.preventDefault();\n    event.stopImmediatePropagation();\n    if (event.deltaY < 0) this.run(() => this.host.zoomIn());\n    else if (event.deltaY > 0) this.run(() => this.host.zoomOut());\n  }\n\n  private onKeydown(event: KeyboardEvent): void {\n    if (!this.ownsKeys()) return;\n    const host = this.host;\n    const target = event.target as HTMLElement | null;\n    if (this.isSliceStepKey(event, target)) {\n      event.preventDefault();\n      this.run(() => host.stepSlice(event.key === 'ArrowRight' ? 1 : -1));\n      return;\n    }\n    if (isTextField(target)) return;\n    if (host.activeDragMode() === 'samPoint' && (event.key === 'Enter' || event.key === 'Escape')) {\n      this.run(() => host.resolveSamPrompt(event.key === 'Enter'));\n      return;\n    }\n    if (event.ctrlKey || event.metaKey) {\n      const k = event.key.toLowerCase();\n      if (k === 'z' && !event.shiftKey) {\n        event.preventDefault();\n        this.run(() => host.undo());\n        return;\n      }\n      if ((k === 'z' && event.shiftKey) || k === 'y') {\n        event.preventDefault();\n        this.run(() => host.redo());\n        return;\n      }\n    }\n    // The bare-key shortcuts must not fire on browser/OS shortcuts.\n    if (event.ctrlKey || event.metaKey || event.altKey) return;\n    const key = event.key;\n    if (key === 'Delete' || key === 'Backspace' || key === 'd' || key === 'D') this.run(() => host.deleteRegion());\n    else if (key === '+' || key === '=') this.run(() => host.zoomIn());\n    else if (key === '-' || key === '_') this.run(() => host.zoomOut());\n    else {\n      const mode = TOOL_KEYS.get(key);\n      if (mode) this.run(() => host.toggleDragMode(mode));\n    }\n  }\n\n  /**\n   * ←/→ step the slice in the Image view, the same way the slider does — only for a\n   * loaded stack, and not while a form field or the slider itself has focus (it\n   * handles arrows natively; stepping here too would double-step). Up/Down are left\n   * to OpenSeadragon (panning).\n   */\n  private isSliceStepKey(e: KeyboardEvent, t: HTMLElement | null): boolean {\n    if (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight') return false;\n    if (!this.host.canStepSlice()) return false;\n    if (t && (/^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName) || t.isContentEditable)) return false;\n    return !(t && (t.getAttribute('role') === 'slider' || t.closest('.p-slider')));\n  }\n}\n"]}

package/esm2022/lib/visualizer/visualizer-context-menu.mjs

@@ -0,0 +1,119 @@
+import { PlotType } from '../contracts/plot-type';
+import { MultiPolygon, Polygon, Rectangle } from '../models/region';
+const ACTIVE = 'context-menu-active';
+/** The live regions at `indices` (stale indices dropped). */
+export function regionsAt(regions, indices) {
+    return indices.map((i) => regions[i]).filter((r) => !!r);
+}
+/** Regions eligible for set-ops: closed areas (rect / closed polygon / multi-polygon),
+ *  excluding intensity-profile lines. */
+export function opEligible(regions) {
+    return regions.filter((r) => r.kind !== 'profile' &&
+        (r.bounds instanceof Rectangle ||
+            r.bounds instanceof MultiPolygon ||
+            (r.bounds instanceof Polygon && r.bounds.closed !== false)));
+}
+/**
+ * The right-click menu: the selected-region actions lead (2D only), then the
+ * viewport and tool toggles for a 2D view, or the camera modes for a 3D scene. The
+ * armed mode is highlighted.
+ */
+export function buildContextMenu(state, actions) {
+    if (!state.isHeatmap)
+        return surface3dItems(state, actions);
+    const active = state.activeDragMode;
+    const toggle = (label, icon, mode) => ({
+        label,
+        icon,
+        styleClass: active === mode ? ACTIVE : '',
+        command: () => actions.toggleDragMode(mode),
+    });
+    const isImageView = state.basePlotType === PlotType.IMAGE;
+    const items = [];
+    const regionActions = buildRegionActionItems(state, actions);
+    if (regionActions.length)
+        items.push(...regionActions, { separator: true });
+    items.push({ label: 'Autoscale', icon: 'pi pi-window-maximize', command: () => actions.autoscaleImage() }, { separator: true });
+    // 'Zoom selection' is Plotly's rubber-band zoom; it doesn't apply to the
+    // OpenSeadragon-backed Image view (use 'Zoom to box' there instead).
+    if (!isImageView)
+        items.push(toggle('Zoom selection', 'pi pi-search', 'zoom'));
+    items.push(toggle('Zoom to box', 'zoom-box-off-icon', 'zoomToBox'), toggle('Pan', 'pi pi-arrows-alt', 'pan'), { label: 'Zoom in', icon: 'pi pi-search-plus', command: () => actions.zoomIn() }, { label: 'Zoom out', icon: 'pi pi-search-minus', command: () => actions.zoomOut() }, { separator: true }, toggle('Select', 'pi pi-arrow-up-right', 'select'), toggle('Freeform', 'pi pi-pencil', 'drawclosedpath'), toggle('Brush', 'brush-icon', 'brush'), toggle('Polyline', 'polyline-icon', 'drawopenpath'), toggle('Rectangle', 'pi pi-stop', 'drawrect'), toggle('Wand', 'wand-icon', 'wand'), toggle('Vertex eraser', 'pi pi-eraser', 'eraseVertex'));
+    // Vertex editing runs on the OpenSeadragon overlay, which backs the Image plot
+    // type. Hidden for other 2D types (Plotly), where these modes are no-ops.
+    if (isImageView) {
+        items.push(toggle('Polygon (click vertices)', 'polygon-vertices-icon', 'drawpolygon'), toggle('Add vertex', 'vertex-add-icon', 'addpoint'), toggle('Delete vertex', 'vertex-delete-icon', 'deletepoint'));
+    }
+    return items;
+}
+/** A 3D scene's camera modes and reset. */
+function surface3dItems(state, actions) {
+    const mode = (label, icon, m) => ({
+        label,
+        icon,
+        styleClass: state.activeSurface3dMode === m ? ACTIVE : '',
+        command: () => actions.toggleSurface3dMode(m),
+    });
+    return [
+        mode('Zoom', 'pi pi-search', 'zoom'),
+        mode('Pan', 'pi pi-arrows-alt', 'pan'),
+        mode('Orbital rotation', 'pi pi-globe', 'orbit'),
+        mode('Turntable rotation', 'pi pi-sync', 'turntable'),
+        { separator: true },
+        { label: 'Reset camera', icon: 'pi pi-home', command: () => actions.resetSurfaceCamera() },
+    ];
+}
+/**
+ * Immediate region actions on the current selection (jit-ui#85): merge, ungroup,
+ * inverse, simplify, the Bézier conversions, and delete — the one-shot geometry
+ * transforms, grouped apart from the tool/mode toggles and shown only when something
+ * is selected. Each item is gated on what the selection supports. "Select all" leads
+ * whenever the image has regions.
+ */
+export function buildRegionActionItems(state, actions) {
+    if (!state.regions.some((r) => r.kind !== 'profile'))
+        return [];
+    const items = [
+        { label: 'Select all regions', icon: 'pi pi-check-square', command: () => actions.selectAllRegions() },
+    ];
+    const selected = regionsAt(state.regions, state.selectedIndices);
+    if (selected.length === 0)
+        return items;
+    const eligible = opEligible(selected);
+    if (eligible.length >= 2) {
+        items.push({ label: 'Merge / group', icon: 'pi pi-link', command: () => actions.mergeRegions() });
+    }
+    if (selected.some((r) => state.canUngroup(r))) {
+        items.push({ label: 'Ungroup', icon: 'pi pi-sitemap', command: () => actions.ungroupRegions() });
+    }
+    if (eligible.length >= 1) {
+        items.push({ label: 'Inverse', icon: 'pi pi-clone', command: () => actions.inverseRegions() }, {
+            label: 'Simplify',
+            icon: 'pi pi-chart-line',
+            items: [
+                { label: 'Light (1 px)', command: () => actions.simplifyRegions(1) },
+                { label: 'Medium (3 px)', command: () => actions.simplifyRegions(3) },
+                { label: 'Strong (8 px)', command: () => actions.simplifyRegions(8) },
+                { separator: true },
+                { label: 'Custom…', command: () => actions.openSimplifyDialog() },
+            ],
+        });
+    }
+    // Bézier conversions are vertex-level edits — Image (OpenSeadragon) view only —
+    // gated on the selection's current form.
+    if (state.basePlotType === PlotType.IMAGE) {
+        if (selected.some((r) => (r.bounds instanceof Polygon && !r.bounds.bezier) || r.bounds instanceof Rectangle)) {
+            items.push({ label: 'Convert to Bézier', icon: 'to-bezier-icon', command: () => actions.toBezierRegion() });
+        }
+        if (selected.some((r) => r.bounds instanceof Polygon && r.bounds.bezier)) {
+            items.push({
+                label: 'Convert to polygon',
+                icon: 'to-polygon-icon',
+                command: () => actions.toPolygonRegion(),
+            });
+        }
+    }
+    items.push({ label: 'Delete region', icon: 'pi pi-trash', command: () => actions.deleteRegion() });
+    return items;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"visualizer-context-menu.js","sourceRoot":"","sources":["../../../../src/lib/visualizer/visualizer-context-menu.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,SAAS,EAAU,MAAM,kBAAkB,CAAC;AAqC5E,MAAM,MAAM,GAAG,qBAAqB,CAAC;AAErC,6DAA6D;AAC7D,MAAM,UAAU,SAAS,CAAC,OAAiB,EAAE,OAAiB;IAC5D,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,CAAC;AAED;yCACyC;AACzC,MAAM,UAAU,UAAU,CAAC,OAAiB;IAC1C,OAAO,OAAO,CAAC,MAAM,CACnB,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,IAAI,KAAK,SAAS;QACpB,CAAC,CAAC,CAAC,MAAM,YAAY,SAAS;YAC5B,CAAC,CAAC,MAAM,YAAY,YAAY;YAChC,CAAC,CAAC,CAAC,MAAM,YAAY,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC,CAChE,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAuB,EAAE,OAA2B;IACnF,IAAI,CAAC,KAAK,CAAC,SAAS;QAAE,OAAO,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC5D,MAAM,MAAM,GAAG,KAAK,CAAC,cAAc,CAAC;IACpC,MAAM,MAAM,GAAG,CAAC,KAAa,EAAE,IAAY,EAAE,IAAY,EAAY,EAAE,CAAC,CAAC;QACvE,KAAK;QACL,IAAI;QACJ,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;QACzC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC;KAC5C,CAAC,CAAC;IACH,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,KAAK,QAAQ,CAAC,KAAK,CAAC;IAC1D,MAAM,KAAK,GAAe,EAAE,CAAC;IAC7B,MAAM,aAAa,GAAG,sBAAsB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC7D,IAAI,aAAa,CAAC,MAAM;QAAE,KAAK,CAAC,IAAI,CAAC,GAAG,aAAa,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5E,KAAK,CAAC,IAAI,CACR,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,uBAAuB,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,EAC9F,EAAE,SAAS,EAAE,IAAI,EAAE,CACpB,CAAC;IACF,yEAAyE;IACzE,qEAAqE;IACrE,IAAI,CAAC,WAAW;QAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/E,KAAK,CAAC,IAAI,CACR,MAAM,CAAC,aAAa,EAAE,mBAAmB,EAAE,WAAW,CAAC,EACvD,MAAM,CAAC,KAAK,EAAE,kBAAkB,EAAE,KAAK,CAAC,EACxC,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,EAChF,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,EACnF,EAAE,SAAS,EAAE,IAAI,EAAE,EACnB,MAAM,CAAC,QAAQ,EAAE,sBAAsB,EAAE,QAAQ,CAAC,EAClD,MAAM,CAAC,UAAU,EAAE,cAAc,EAAE,gBAAgB,CAAC,EACpD,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,EACtC,MAAM,CAAC,UAAU,EAAE,eAAe,EAAE,cAAc,CAAC,EACnD,MAAM,CAAC,WAAW,EAAE,YAAY,EAAE,UAAU,CAAC,EAC7C,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,EACnC,MAAM,CAAC,eAAe,EAAE,cAAc,EAAE,aAAa,CAAC,CACvD,CAAC;IACF,+EAA+E;IAC/E,0EAA0E;IAC1E,IAAI,WAAW,EAAE,CAAC;QAChB,KAAK,CAAC,IAAI,CACR,MAAM,CAAC,0BAA0B,EAAE,uBAAuB,EAAE,aAAa,CAAC,EAC1E,MAAM,CAAC,YAAY,EAAE,iBAAiB,EAAE,UAAU,CAAC,EACnD,MAAM,CAAC,eAAe,EAAE,oBAAoB,EAAE,aAAa,CAAC,CAC7D,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,2CAA2C;AAC3C,SAAS,cAAc,CAAC,KAAuB,EAAE,OAA2B;IAC1E,MAAM,IAAI,GAAG,CAAC,KAAa,EAAE,IAAY,EAAE,CAAS,EAAY,EAAE,CAAC,CAAC;QAClE,KAAK;QACL,IAAI;QACJ,UAAU,EAAE,KAAK,CAAC,mBAAmB,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;QACzD,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC;KAC9C,CAAC,CAAC;IACH,OAAO;QACL,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,CAAC;QACpC,IAAI,CAAC,KAAK,EAAE,kBAAkB,EAAE,KAAK,CAAC;QACtC,IAAI,CAAC,kBAAkB,EAAE,aAAa,EAAE,OAAO,CAAC;QAChD,IAAI,CAAC,oBAAoB,EAAE,YAAY,EAAE,WAAW,CAAC;QACrD,EAAE,SAAS,EAAE,IAAI,EAAE;QACnB,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE;KAC3F,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAuB,EAAE,OAA2B;IACzF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC;QAAE,OAAO,EAAE,CAAC;IAChE,MAAM,KAAK,GAAe;QACxB,EAAE,KAAK,EAAE,oBAAoB,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE;KACvG,CAAC;IACF,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IACjE,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACxC,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IACpG,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9C,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;IACnG,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CACR,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,EAClF;YACE,KAAK,EAAE,UAAU;YACjB,IAAI,EAAE,kBAAkB;YACxB,KAAK,EAAE;gBACL,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE;gBACpE,EAAE,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE;gBACrE,EAAE,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE;gBACrE,EAAE,SAAS,EAAE,IAAI,EAAE;gBACnB,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE;aAClE;SACF,CACF,CAAC;IACJ,CAAC;IACD,gFAAgF;IAChF,yCAAyC;IACzC,IAAI,KAAK,CAAC,YAAY,KAAK,QAAQ,CAAC,KAAK,EAAE,CAAC;QAC1C,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,YAAY,OAAO,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,YAAY,SAAS,CAAC,EAAE,CAAC;YAC7G,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;QAC9G,CAAC;QACD,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,YAAY,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;YACzE,KAAK,CAAC,IAAI,CAAC;gBACT,KAAK,EAAE,oBAAoB;gBAC3B,IAAI,EAAE,iBAAiB;gBACvB,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,eAAe,EAAE;aACzC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IACnG,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import { MenuItem } from 'primeng/api';\n\nimport { PlotType } from '../contracts/plot-type';\nimport { MultiPolygon, Polygon, Rectangle, Region } from '../models/region';\n\n/** What the right-click menu is built from: the view, the armed modes and the regions. */\nexport interface ContextMenuState {\n  /** 2D view (region tools, step zoom) vs a 3D scene (camera modes). */\n  isHeatmap: boolean;\n  /** The built-in type on screen; the Image view adds the vertex and Bézier items. */\n  basePlotType: PlotType;\n  activeDragMode: string | null;\n  activeSurface3dMode: string;\n  /** Every region on the image (intensity-profile lines included). */\n  regions: Region[];\n  /** The selection, as indices into {@link regions}. */\n  selectedIndices: number[];\n  /** Whether a region is a multi-part region that can be split back into parts. */\n  canUngroup(region: Region): boolean;\n}\n\n/** What the menu's items do (the viewer's own toolbar handlers). */\nexport interface ContextMenuActions {\n  autoscaleImage(): void;\n  zoomIn(): void;\n  zoomOut(): void;\n  toggleDragMode(mode: string): void;\n  toggleSurface3dMode(mode: string): void;\n  resetSurfaceCamera(): void;\n  selectAllRegions(): void;\n  mergeRegions(): void;\n  ungroupRegions(): void;\n  inverseRegions(): void;\n  simplifyRegions(thresholdPx: number): void;\n  openSimplifyDialog(): void;\n  toBezierRegion(): void;\n  toPolygonRegion(): void;\n  deleteRegion(): void;\n}\n\nconst ACTIVE = 'context-menu-active';\n\n/** The live regions at `indices` (stale indices dropped). */\nexport function regionsAt(regions: Region[], indices: number[]): Region[] {\n  return indices.map((i) => regions[i]).filter((r): r is Region => !!r);\n}\n\n/** Regions eligible for set-ops: closed areas (rect / closed polygon / multi-polygon),\n *  excluding intensity-profile lines. */\nexport function opEligible(regions: Region[]): Region[] {\n  return regions.filter(\n    (r) =>\n      r.kind !== 'profile' &&\n      (r.bounds instanceof Rectangle ||\n        r.bounds instanceof MultiPolygon ||\n        (r.bounds instanceof Polygon && r.bounds.closed !== false)),\n  );\n}\n\n/**\n * The right-click menu: the selected-region actions lead (2D only), then the\n * viewport and tool toggles for a 2D view, or the camera modes for a 3D scene. The\n * armed mode is highlighted.\n */\nexport function buildContextMenu(state: ContextMenuState, actions: ContextMenuActions): MenuItem[] {\n  if (!state.isHeatmap) return surface3dItems(state, actions);\n  const active = state.activeDragMode;\n  const toggle = (label: string, icon: string, mode: string): MenuItem => ({\n    label,\n    icon,\n    styleClass: active === mode ? ACTIVE : '',\n    command: () => actions.toggleDragMode(mode),\n  });\n  const isImageView = state.basePlotType === PlotType.IMAGE;\n  const items: MenuItem[] = [];\n  const regionActions = buildRegionActionItems(state, actions);\n  if (regionActions.length) items.push(...regionActions, { separator: true });\n  items.push(\n    { label: 'Autoscale', icon: 'pi pi-window-maximize', command: () => actions.autoscaleImage() },\n    { separator: true },\n  );\n  // 'Zoom selection' is Plotly's rubber-band zoom; it doesn't apply to the\n  // OpenSeadragon-backed Image view (use 'Zoom to box' there instead).\n  if (!isImageView) items.push(toggle('Zoom selection', 'pi pi-search', 'zoom'));\n  items.push(\n    toggle('Zoom to box', 'zoom-box-off-icon', 'zoomToBox'),\n    toggle('Pan', 'pi pi-arrows-alt', 'pan'),\n    { label: 'Zoom in', icon: 'pi pi-search-plus', command: () => actions.zoomIn() },\n    { label: 'Zoom out', icon: 'pi pi-search-minus', command: () => actions.zoomOut() },\n    { separator: true },\n    toggle('Select', 'pi pi-arrow-up-right', 'select'),\n    toggle('Freeform', 'pi pi-pencil', 'drawclosedpath'),\n    toggle('Brush', 'brush-icon', 'brush'),\n    toggle('Polyline', 'polyline-icon', 'drawopenpath'),\n    toggle('Rectangle', 'pi pi-stop', 'drawrect'),\n    toggle('Wand', 'wand-icon', 'wand'),\n    toggle('Vertex eraser', 'pi pi-eraser', 'eraseVertex'),\n  );\n  // Vertex editing runs on the OpenSeadragon overlay, which backs the Image plot\n  // type. Hidden for other 2D types (Plotly), where these modes are no-ops.\n  if (isImageView) {\n    items.push(\n      toggle('Polygon (click vertices)', 'polygon-vertices-icon', 'drawpolygon'),\n      toggle('Add vertex', 'vertex-add-icon', 'addpoint'),\n      toggle('Delete vertex', 'vertex-delete-icon', 'deletepoint'),\n    );\n  }\n  return items;\n}\n\n/** A 3D scene's camera modes and reset. */\nfunction surface3dItems(state: ContextMenuState, actions: ContextMenuActions): MenuItem[] {\n  const mode = (label: string, icon: string, m: string): MenuItem => ({\n    label,\n    icon,\n    styleClass: state.activeSurface3dMode === m ? ACTIVE : '',\n    command: () => actions.toggleSurface3dMode(m),\n  });\n  return [\n    mode('Zoom', 'pi pi-search', 'zoom'),\n    mode('Pan', 'pi pi-arrows-alt', 'pan'),\n    mode('Orbital rotation', 'pi pi-globe', 'orbit'),\n    mode('Turntable rotation', 'pi pi-sync', 'turntable'),\n    { separator: true },\n    { label: 'Reset camera', icon: 'pi pi-home', command: () => actions.resetSurfaceCamera() },\n  ];\n}\n\n/**\n * Immediate region actions on the current selection (jit-ui#85): merge, ungroup,\n * inverse, simplify, the Bézier conversions, and delete — the one-shot geometry\n * transforms, grouped apart from the tool/mode toggles and shown only when something\n * is selected. Each item is gated on what the selection supports. \"Select all\" leads\n * whenever the image has regions.\n */\nexport function buildRegionActionItems(state: ContextMenuState, actions: ContextMenuActions): MenuItem[] {\n  if (!state.regions.some((r) => r.kind !== 'profile')) return [];\n  const items: MenuItem[] = [\n    { label: 'Select all regions', icon: 'pi pi-check-square', command: () => actions.selectAllRegions() },\n  ];\n  const selected = regionsAt(state.regions, state.selectedIndices);\n  if (selected.length === 0) return items;\n  const eligible = opEligible(selected);\n  if (eligible.length >= 2) {\n    items.push({ label: 'Merge / group', icon: 'pi pi-link', command: () => actions.mergeRegions() });\n  }\n  if (selected.some((r) => state.canUngroup(r))) {\n    items.push({ label: 'Ungroup', icon: 'pi pi-sitemap', command: () => actions.ungroupRegions() });\n  }\n  if (eligible.length >= 1) {\n    items.push(\n      { label: 'Inverse', icon: 'pi pi-clone', command: () => actions.inverseRegions() },\n      {\n        label: 'Simplify',\n        icon: 'pi pi-chart-line',\n        items: [\n          { label: 'Light (1 px)', command: () => actions.simplifyRegions(1) },\n          { label: 'Medium (3 px)', command: () => actions.simplifyRegions(3) },\n          { label: 'Strong (8 px)', command: () => actions.simplifyRegions(8) },\n          { separator: true },\n          { label: 'Custom…', command: () => actions.openSimplifyDialog() },\n        ],\n      },\n    );\n  }\n  // Bézier conversions are vertex-level edits — Image (OpenSeadragon) view only —\n  // gated on the selection's current form.\n  if (state.basePlotType === PlotType.IMAGE) {\n    if (selected.some((r) => (r.bounds instanceof Polygon && !r.bounds.bezier) || r.bounds instanceof Rectangle)) {\n      items.push({ label: 'Convert to Bézier', icon: 'to-bezier-icon', command: () => actions.toBezierRegion() });\n    }\n    if (selected.some((r) => r.bounds instanceof Polygon && r.bounds.bezier)) {\n      items.push({\n        label: 'Convert to polygon',\n        icon: 'to-polygon-icon',\n        command: () => actions.toPolygonRegion(),\n      });\n    }\n  }\n  items.push({ label: 'Delete region', icon: 'pi pi-trash', command: () => actions.deleteRegion() });\n  return items;\n}\n"]}