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

package/lib/util/supersede.d.ts

@@ -0,0 +1,53 @@
+/**
+ * One task of a {@link Supersede}: the check a load makes after each await, and the
+ * signal it hands to whatever it awaits so that work can stop too, not just its result.
+ *
+ * Callable for compatibility with the first version of this helper, whose `next()`
+ * returned the bare check: `task()` is `task.isCurrent()`.
+ */
+export interface SupersedeTask {
+    (): boolean;
+    /** True until a newer task starts or the owner {@link Supersede.cancel cancels}. */
+    isCurrent(): boolean;
+    /**
+     * Aborted at the moment this task stops being current. Pass it to `fetch`, a worker
+     * call or `IDataRenderer.load()` so superseded work is dropped at the source.
+     */
+    readonly signal: AbortSignal;
+}
+/**
+ * "Latest wins" sequencing for one async concern.
+ *
+ * Every load that can be overtaken — a fetch the user changes their mind about before it
+ * lands — takes a task from {@link next} before its first await and checks it after each
+ * one. A newer task, or {@link cancel}, makes every older one stale and aborts its
+ * {@link SupersedeTask.signal}, so a slow response cannot paint over what the user has
+ * moved on to, and work that honours the signal stops instead of finishing for nobody.
+ *
+ * One instance per concern, never shared: two unrelated loads on one instance cancel each
+ * other, which is how a redraw used to drop a pending colour-source load. A dataset switch
+ * cancels all of them together.
+ */
+export declare class Supersede {
+    private generation;
+    private controller;
+    /**
+     * Start a task, superseding (and aborting) every earlier one.
+     *
+     * @returns the new task; it stays current until a newer task starts or
+     *   {@link cancel} runs.
+     */
+    next(): SupersedeTask;
+    /**
+     * The task of the current generation, WITHOUT starting a new one: a snapshot that goes
+     * stale (and aborts) on the next {@link next} or {@link cancel}. For work that belongs
+     * to whatever is current rather than competing with it — a cache fill that must not
+     * outlive the dataset it was started for, say.
+     */
+    current(): SupersedeTask;
+    /** Make every task started so far stale and abort its signal, without starting one. */
+    cancel(): void;
+    /** @deprecated Use {@link cancel}; kept for one release. */
+    invalidate(): void;
+    private advance;
+}

package/lib/visualization.module.d.ts

@@ -1,49 +1,28 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./visualizer.component";
-import * as i2 from "./toolbar/toolbar.component";
-import * as i3 from "./region-editor/region-editor.component";
-import * as i4 from "./hex-color-picker/hex-color-picker.component";
-import * as i5 from "./channel-histogram/channel-histogram.component";
-import * as i6 from "./spatial-controls/spatial-controls.component";
-import * as i7 from "./spatial-controls/spatial-charts/spatial-charts.component";
-import * as i8 from "@angular/common";
-import * as i9 from "@angular/forms";
-import * as i10 from "primeng/toolbar";
-import * as i11 from "primeng/button";
-import * as i12 from "primeng/menu";
-import * as i13 from "primeng/dropdown";
-import * as i14 from "primeng/slider";
-import * as i15 from "primeng/treeselect";
-import * as i16 from "primeng/inputnumber";
-import * as i17 from "primeng/dialog";
-import * as i18 from "primeng/contextmenu";
-import * as i19 from "primeng/progressbar";
-import * as i20 from "primeng/toast";
-import * as i21 from "primeng/tooltip";
-import * as i22 from "primeng/ripple";
-import * as i23 from "primeng/table";
-import * as i24 from "primeng/paginator";
-import * as i25 from "primeng/overlaypanel";
-import * as i26 from "primeng/confirmdialog";
-import * as i27 from "primeng/inputtext";
-import * as i28 from "primeng/checkbox";
-import * as i29 from "primeng/multiselect";
-import * as i30 from "primeng/radiobutton";
-import * as i31 from "primeng/selectbutton";
-import * as i32 from "primeng/autocomplete";
+import * as i2 from "./region-editor/region-editor.component";
+import * as i3 from "./hex-color-picker/hex-color-picker.component";
+import * as i4 from "./channel-histogram/channel-histogram.component";
+import * as i5 from "./spatial-controls/spatial-controls.component";
+import * as i6 from "./spatial-controls/spatial-charts/spatial-charts.component";
 /**
  * Self-contained plotting UI: the {@link VisualizerComponent} (plot surface
- * + render orchestration), its {@link ToolbarComponent}, and the
- * {@link RegionEditorComponent} (the Regions tab table/editor). Consumers embed
- * `<visualizer>` / `<region-editor>` and need know nothing about the toolbar,
- * the rendering backends, or region file I/O (supplied via the REGION_IO_PORT).
+ * + render orchestration, with its toolbar), the {@link RegionEditorComponent}
+ * (the Regions table/editor), {@link HexColorPickerComponent}
+ * (`<hex-color-picker>`, `[color]` in, `(colorChange)` out),
+ * {@link ChannelHistogramComponent}, {@link SpatialControlsComponent} and
+ * {@link SpatialChartsComponent}. Consumers embed `<visualizer>` /
+ * `<region-editor>` and need know nothing about the toolbar, the rendering
+ * backends, or region file I/O (supplied via the REGION_IO_PORT).
  *
- * Also exports {@link HexColorPickerComponent} (`<hex-color-picker>`) as a
- * standalone reusable picker (`[color]` in, `(colorChange)` out) so consuming
- * apps can use it on its own, the same way as the visualizer and region editor.
+ * @deprecated A re-export shim, kept for one minor release: every component is
+ * standalone now. Import the components themselves (`imports: [VisualizerComponent]`)
+ * and bind the backend chain with {@link provideVisualization} — in the application's
+ * providers for one app-wide viewer chain, or a component's for an isolated one —
+ * instead of the root bindings this module adds.
  */
 export declare class VisualizationModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<VisualizationModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<VisualizationModule, [typeof i1.VisualizerComponent, typeof i2.ToolbarComponent, typeof i3.RegionEditorComponent, typeof i4.HexColorPickerComponent, typeof i5.ChannelHistogramComponent, typeof i6.SpatialControlsComponent, typeof i7.SpatialChartsComponent], [typeof i8.CommonModule, typeof i9.FormsModule, typeof i10.ToolbarModule, typeof i11.ButtonModule, typeof i12.MenuModule, typeof i13.DropdownModule, typeof i14.SliderModule, typeof i15.TreeSelectModule, typeof i16.InputNumberModule, typeof i17.DialogModule, typeof i18.ContextMenuModule, typeof i19.ProgressBarModule, typeof i20.ToastModule, typeof i21.TooltipModule, typeof i22.RippleModule, typeof i23.TableModule, typeof i24.PaginatorModule, typeof i25.OverlayPanelModule, typeof i26.ConfirmDialogModule, typeof i27.InputTextModule, typeof i28.CheckboxModule, typeof i29.MultiSelectModule, typeof i30.RadioButtonModule, typeof i31.SelectButtonModule, typeof i32.AutoCompleteModule], [typeof i1.VisualizerComponent, typeof i3.RegionEditorComponent, typeof i4.HexColorPickerComponent, typeof i5.ChannelHistogramComponent, typeof i6.SpatialControlsComponent, typeof i7.SpatialChartsComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisualizationModule, never, [typeof i1.VisualizerComponent, typeof i2.RegionEditorComponent, typeof i3.HexColorPickerComponent, typeof i4.ChannelHistogramComponent, typeof i5.SpatialControlsComponent, typeof i6.SpatialChartsComponent], [typeof i1.VisualizerComponent, typeof i2.RegionEditorComponent, typeof i3.HexColorPickerComponent, typeof i4.ChannelHistogramComponent, typeof i5.SpatialControlsComponent, typeof i6.SpatialChartsComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<VisualizationModule>;
 }

package/lib/visualizer/floating-drag.directive.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+/** A screen position, in CSS pixels. */
+export interface FloatingPos {
+    x: number;
+    y: number;
+}
+/**
+ * Drag handle of a floating, `position: fixed` panel (the intensity inset header,
+ * the toolbar dock handle). On mousedown it asks {@link origin} where the panel is —
+ * the host may detach a docked panel right there — then emits the new position on
+ * every move until mouseup.
+ *
+ * The move/up listeners exist only while a drag is in progress and run outside the
+ * Angular zone, re-entering it per emitted position: a permanent window mousemove
+ * listener made every pointer move anywhere in the host app run change detection.
+ */
+export declare class FloatingDragDirective implements OnDestroy {
+    private readonly zone;
+    /** Called on mousedown: the panel's position the drag starts from. */
+    origin: () => FloatingPos;
+    /** The panel's new position, per pointer move. */
+    readonly vizFloatingDragMove: EventEmitter<FloatingPos>;
+    private end;
+    constructor(zone: NgZone);
+    onMouseDown(e: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FloatingDragDirective, "[vizFloatingDrag]", never, { "origin": { "alias": "vizFloatingDrag"; "required": false; }; }, { "vizFloatingDragMove": "vizFloatingDragMove"; }, never, never, true, never>;
+}

package/lib/visualizer/region-actions.d.ts

@@ -0,0 +1,54 @@
+import { Observable } from 'rxjs';
+import { Message } from 'primeng/api';
+import { IRegionStore } from '../contracts/visualizer.contract';
+import { Region } from '../models/region';
+import { RegionOpsService } from '../region-ops.service';
+/** The region-store members the set-operations read and write through. */
+export type RegionActionsTarget = Pick<IRegionStore, 'getRegions' | 'setRegions' | 'setSelectedShapeIndices' | 'getSelectedShapeIndices$' | 'getCanUndo$' | 'getCanRedo$'>;
+/**
+ * Region set-operations on the current selection (jit-ui#85) — select all, merge,
+ * ungroup, inverse, simplify — plus the store mirrors the toolbar and the context
+ * menu read synchronously: the selection and the undo/redo availability.
+ *
+ * Every operation commits through `setRegions`, so it is undo-tracked and the
+ * backend on screen re-renders; profile lines and unselected regions are kept.
+ */
+export declare class RegionActions {
+    private readonly target;
+    private readonly ops;
+    /** `[width, height]` of the image, when known — the frame inverse and merge rasterize in. */
+    private readonly imageSize;
+    private readonly notify;
+    /** Current selection (array indices), mirrored from the store. */
+    selectedIndices: number[];
+    /** Whether a region action is available to undo / redo; drive the toolbar buttons. */
+    canUndo: boolean;
+    canRedo: boolean;
+    /** Custom-threshold Simplify dialog. */
+    displaySimplifyDialog: boolean;
+    simplifyThreshold: number;
+    constructor(target: RegionActionsTarget, ops: RegionOpsService, 
+    /** `[width, height]` of the image, when known — the frame inverse and merge rasterize in. */
+    imageSize: () => number[] | undefined, notify: (message: Message) => void);
+    /** Mirror the store's selection and undo/redo depth until `until$` emits.
+     *  `changed` runs after an undo/redo flip (the toolbar binds those). */
+    bind(until$: Observable<unknown>, changed: () => void): void;
+    /** The currently-selected regions (live store instances). */
+    get selected(): Region[];
+    /** Select every region on the image (excludes intensity-profile lines). */
+    selectAll(): void;
+    /** Merge the selected regions into a single (possibly multi-part) region. */
+    merge(): void;
+    /** Split each selected multi-part region into one region per part. */
+    ungroup(): void;
+    /** Replace the selection with its inverse inside the image rectangle. */
+    inverse(): void;
+    /** Douglas–Peucker simplify each selected region by `thresholdPx`, closing the dialog. */
+    simplify(thresholdPx: number): void;
+    openSimplifyDialog(): void;
+    /** Commit a set-op: drop `remove`, append `add`, and select the results. */
+    private replace;
+    /** Image pixel dimensions for the raster ops; falls back to the selection's extent
+     *  when the image size isn't known (keeps clamping sane). */
+    private frame;
+}

package/lib/visualizer/region-load.d.ts

@@ -0,0 +1,27 @@
+import { IImageInfo } from '../contracts/image.contract';
+import { IRegionStore } from '../contracts/visualizer.contract';
+/** The region-store members {@link applyImageRois} writes through. */
+export type RegionLoadTarget = Pick<IRegionStore, 'importRegions' | 'enterStackMode' | 'setRegions' | 'resetUndoHistory'>;
+/**
+ * Apply an image's saved ROIs once its render has landed, choosing the region
+ * layout from the image's shape:
+ *
+ *  - **Folder stack** (`isStack && tiled === false`, see loadSeriesAsStack): a stack
+ *    of self-contained per-slice files. Each slice-file may carry its own sibling
+ *    `<stem>.geojson` (`roiJsonStrs[z]`), but a fresh folder with none yet leaves
+ *    `roiJsonStrs` undefined — so this keys off `tiled === false`, NOT `roiJsonStrs`,
+ *    and an unannotated folder stack still enters the per-slice-file layout (saving
+ *    back one geojson per slice-file) rather than the combined one (jit-ui#93).
+ *  - **Single-file z-stack**: one sibling geojson holding every slice's regions,
+ *    indexed by QuPath's `geometry.plane.z`. Per-slice (combined) mode is entered when
+ *    the geojson actually carries slice indices, or when there is nothing yet to
+ *    author against. A legacy geojson whose regions are all on the default plane
+ *    stays global (shown on every slice), so existing single-plane annotations are
+ *    not confined to slice 0.
+ *  - **Single plane** (or that legacy global stack): one region set for the image.
+ *    Loading saved ROIs is not a user edit, so the undo history starts fresh and the
+ *    first undo cannot wipe them (jit-ui#85).
+ *
+ * `z` is the slice shown now; entering stack mode makes it live and resets undo.
+ */
+export declare function applyImageRois(info: IImageInfo, target: RegionLoadTarget, z: number): void;

package/lib/visualizer/spatial-dataset-binder.d.ts

@@ -0,0 +1,74 @@
+import { Observable } from 'rxjs';
+import { IImageInfo } from '../contracts/image.contract';
+import { PlotType, PlotTypeId } from '../contracts/plot-type';
+import { SpatialDataPort } from '../contracts/ports/spatial-data.port';
+import { SpatialDataset } from '../contracts/spatial-dataset.contract';
+import { SpatialGates } from '../plot-mode/plot-type-menu';
+/** What a dataset switch asks of the viewer. */
+export interface SpatialBinderHost {
+    /** The plot-type gates changed: recompute the selector. */
+    gatesChanged(): void;
+    /** The selector's current id, and the built-in type rendered for it. */
+    selectedId(): PlotTypeId;
+    basePlotType(): PlotType;
+    /** Whether an image is loaded. */
+    hasImage(): boolean;
+    selectPlotType(type: PlotType): void;
+    /** Re-plot the current mode. */
+    replot(): void;
+    /** Publish an image as the host's current one. */
+    publishImage(info: IImageInfo): void;
+    setImageLoading(loading: boolean): void;
+    /** The switch is handled: reconcile the selection with the new gates and re-render. */
+    settled(): void;
+    detectChanges(): void;
+}
+/**
+ * Binds the viewer to the spatial-omics dataset on `SPATIAL_DATA_PORT`: the gates it
+ * puts on the plot-type selector ({@link gates}), the mode an image-less dataset opens
+ * on, and publishing a dataset's registered volume AS the image.
+ *
+ * No-op when the host provides no port — the spatial types then stay hidden.
+ */
+export declare class SpatialDatasetBinder implements SpatialGates {
+    private readonly port;
+    private readonly host;
+    /** The dataset on offer, for drawing one that brings no image. */
+    dataset: SpatialDataset | null;
+    /** A dataset is published — gates the spatial plot types; the toolbar binds it too. */
+    hasDataset: boolean;
+    /** Its observations carry a z, gating the 3D spatial mode. */
+    has3d: boolean;
+    /** It brings pixels of its own (see {@link SpatialGates.hasPixels}). */
+    hasPixels: boolean;
+    /** Dataset identity + capability shape the last emission was handled at, so a
+     *  switch between two datasets of the same shape is not mistaken for a repeat. */
+    private key;
+    /** Dataset + geometry the published volume image was built from, so a re-emitted
+     *  dataset doesn't re-fetch megabytes or reset the user's scrub. */
+    private volumeImageKey;
+    /** Blob URLs backing that image — ours to revoke. */
+    private volumeImageUrls;
+    constructor(port: SpatialDataPort | undefined, host: SpatialBinderHost);
+    /** Follow the port's dataset until `until$` emits. */
+    bind(until$: Observable<unknown>): void;
+    /** Revoke the published volume image's blob URLs (teardown). */
+    dispose(): void;
+    private onDataset;
+    /**
+     * Publish a dataset's reference volume AS the image, and open the 2D Image view on it:
+     * the slice bar scrubs z, and the contrast window, colormaps and region tools all work
+     * because the volume genuinely is the image now. The 3D cloud stays one pick away.
+     *
+     * Keyed by dataset + geometry: the dataset stream re-emits on things like a
+     * colour-column change, and rebuilding then would re-fetch the voxels and throw the
+     * user back to the middle slice.
+     */
+    private showVolumeAsImage;
+    /** Forget the published volume image so re-selecting the dataset rebuilds it. The
+     *  URLs deliberately stay alive: the host may still be displaying that image, and
+     *  revoking under it would break every later tile read. They are freed when the next
+     *  volume replaces them, or on {@link dispose}. */
+    private dropVolumeImage;
+    private revokeVolumeImageUrls;
+}

package/lib/visualizer/tool-modes.d.ts

@@ -0,0 +1,49 @@
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PlotModeTools } from '../contracts/plot-type-contribution.contract';
+import { IVisualizer } from '../contracts/visualizer.contract';
+/** The backend members tool arming drives. */
+export type ToolModesTarget = Pick<IVisualizer, 'getRegionOverlay' | 'setDragMode' | 'setActiveTool' | 'setWandOptions' | 'setBrushOptions' | 'setVertexEraserRadius'>;
+/** Where the armed tool is recorded for everyone else (the shared session store). */
+export interface ActiveToolRecord {
+    setActiveTool(id: string | null): void;
+    getActiveTool$(): Observable<string | null>;
+}
+/**
+ * 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 declare class ToolModes {
+    private readonly target;
+    private readonly record;
+    /** Runs after every arm/disarm with the newly armed mode. */
+    private readonly armed;
+    /** The armed mode, or null. */
+    active: string | null;
+    /** Wand sensitivity — higher = stricter (smaller selection). Matches QuPath default. */
+    wandSensitivity: number;
+    /** Brush diameter in image-pixel coordinates (drives the painted disc size). */
+    brushSize: number;
+    /** Vertex eraser radius in image-pixel coordinates. */
+    vertexEraserRadius: number;
+    /** The toolbar tools a contributed plot mode may arm. Calls can come from outside
+     *  Angular, hence the zone. */
+    readonly plotModeTools: PlotModeTools;
+    /** Class the brush paints while a plot mode armed it; null = plain brush. */
+    private brushClass;
+    constructor(target: ToolModesTarget, record: ActiveToolRecord, zone: NgZone, 
+    /** Runs after every arm/disarm with the newly armed mode. */
+    armed: (mode: string | null) => void, markForCheck: () => void);
+    /** 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: string): void;
+    /** Arm `mode` (or nothing) across every tool. */
+    apply(mode: string | null): void;
+    /** Disarm whatever is armed and clear every tool mode (a plot-type switch). */
+    deactivate(): void;
+    setWandSensitivity(value: number | undefined): void;
+    setBrushSize(value: number | undefined): void;
+    setVertexEraserRadius(value: number | undefined): void;
+    /** The options a canvas tool is armed with, from the toolbar's settings. */
+    private options;
+}

package/lib/visualizer/viewer-shortcuts.d.ts

@@ -0,0 +1,71 @@
+import { NgZone } from '@angular/core';
+/** What the shortcuts drive: the viewer's actions and the state they gate on. */
+export interface ShortcutHost {
+    /** Id of the plot div; the wheel and the context menu act only over it. */
+    readonly plotDivName: string;
+    /** The viewer's own element (toolbar + plot); its keys are scoped to it. Falls back
+     *  to the plot div when absent. */
+    readonly hostElement?: HTMLElement | null;
+    /** The armed tool — SAM point mode takes Enter / Escape. */
+    activeDragMode(): string | null;
+    /** ←/→ step the slice: a loaded stack in the Image view. */
+    canStepSlice(): boolean;
+    /** The wheel steps the zoom: a 2D view whose renderer does not read the wheel itself. */
+    wheelZooms(): boolean;
+    stepSlice(delta: number): void;
+    /** SAM point mode: commit (Enter) or discard (Escape) the prompt. */
+    resolveSamPrompt(commit: boolean): void;
+    undo(): void;
+    redo(): void;
+    deleteRegion(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    toggleDragMode(mode: string): void;
+    openContextMenu(event: MouseEvent): void;
+}
+/**
+ * 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 declare class ViewerShortcuts {
+    private readonly host;
+    private readonly zone;
+    /** Every attached instance, to find the one holding focus. */
+    private static readonly live;
+    /** The viewer the pointer last moved over. */
+    private static lastHovered;
+    private readonly listeners;
+    constructor(host: ShortcutHost, zone: NgZone);
+    /** Register the window listeners (outside the zone). */
+    attach(): void;
+    /** Remove every listener {@link attach} added. */
+    detach(): void;
+    private listen;
+    private contains;
+    /** Whether this viewer takes keys now: it holds focus, or nothing does and the
+     *  pointer was last over it. */
+    private ownsKeys;
+    private overPlot;
+    private run;
+    private onContextMenu;
+    private onWheel;
+    private onKeydown;
+    /**
+     * ←/→ 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).
+     */
+    private isSliceStepKey;
+}

package/lib/visualizer/visualizer-context-menu.d.ts

@@ -0,0 +1,55 @@
+import { MenuItem } from 'primeng/api';
+import { PlotType } from '../contracts/plot-type';
+import { Region } from '../models/region';
+/** What the right-click menu is built from: the view, the armed modes and the regions. */
+export interface ContextMenuState {
+    /** 2D view (region tools, step zoom) vs a 3D scene (camera modes). */
+    isHeatmap: boolean;
+    /** The built-in type on screen; the Image view adds the vertex and Bézier items. */
+    basePlotType: PlotType;
+    activeDragMode: string | null;
+    activeSurface3dMode: string;
+    /** Every region on the image (intensity-profile lines included). */
+    regions: Region[];
+    /** The selection, as indices into {@link regions}. */
+    selectedIndices: number[];
+    /** Whether a region is a multi-part region that can be split back into parts. */
+    canUngroup(region: Region): boolean;
+}
+/** What the menu's items do (the viewer's own toolbar handlers). */
+export interface ContextMenuActions {
+    autoscaleImage(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    toggleDragMode(mode: string): void;
+    toggleSurface3dMode(mode: string): void;
+    resetSurfaceCamera(): void;
+    selectAllRegions(): void;
+    mergeRegions(): void;
+    ungroupRegions(): void;
+    inverseRegions(): void;
+    simplifyRegions(thresholdPx: number): void;
+    openSimplifyDialog(): void;
+    toBezierRegion(): void;
+    toPolygonRegion(): void;
+    deleteRegion(): void;
+}
+/** The live regions at `indices` (stale indices dropped). */
+export declare function regionsAt(regions: Region[], indices: number[]): Region[];
+/** Regions eligible for set-ops: closed areas (rect / closed polygon / multi-polygon),
+ *  excluding intensity-profile lines. */
+export declare function opEligible(regions: Region[]): Region[];
+/**
+ * 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 declare function buildContextMenu(state: ContextMenuState, actions: ContextMenuActions): MenuItem[];
+/**
+ * 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 declare function buildRegionActionItems(state: ContextMenuState, actions: ContextMenuActions): MenuItem[];