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

package/lib/plot-mode/contribution-host.d.ts

@@ -0,0 +1,125 @@
+import { Injector, NgZone, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Message } from 'primeng/api';
+import { IImageInfo } from '../contracts/image.contract';
+import { PlotType, PlotTypeId } from '../contracts/plot-type';
+import { PlotModeTools, PlotTypeContribution } from '../contracts/plot-type-contribution.contract';
+import { ToolbarContribution, ToolbarDialogToolContribution } from '../contracts/toolbar-tool.contract';
+import { IVisualizer } from '../contracts/visualizer.contract';
+import { PlotModeController } from './plot-mode-controller';
+/** The live contributed mode's side panel, as the template renders it. */
+export interface PlotModePanelView {
+    title: string;
+    /** An Angular component panel, with its own injector… */
+    component: Type<unknown> | null;
+    injector: Injector | null;
+    /** …or a plain host element a `mount` panel rendered into. */
+    host: HTMLElement | null;
+}
+/** The open dialog tool's dialog, as the template renders it. */
+export interface ToolDialogView {
+    title: string;
+    width: string;
+    host: HTMLElement;
+}
+/** What the contributions need from the viewer that hosts them. */
+export interface ContributionViewer {
+    readonly visualizer: IVisualizer;
+    readonly zone: NgZone;
+    /** The toolbar tools a contribution may arm (`PlotModeContext.tools`). */
+    readonly tools: PlotModeTools;
+    /** Parent of a component panel's injector. */
+    readonly injector?: Injector;
+    imageInfo$(): Observable<IImageInfo | null>;
+    /** The selector's id (a built-in type or a contributed mode). */
+    selectedId(): PlotTypeId;
+    /** The built-in type being rendered. */
+    renderedType(): PlotType;
+    /** A contributed mode could not start: select its base type, already on screen. */
+    selectBase(type: PlotType): void;
+    notify(message: Message): void;
+    detectChanges(): void;
+}
+/**
+ * Hosts the library's two kinds of contributed sessions over the viewer:
+ *  - **plot modes** (`PLOT_TYPE_CONTRIBUTIONS`): a selector entry riding on a built-in
+ *    base type, with an optional side panel;
+ *  - **dialog tools** (`TOOLBAR_TOOLS`, `kind: 'dialog'`): a floating dialog over the
+ *    Image view, whose body the tool mounts once the dialog is in the document.
+ *
+ * Both run through a {@link PlotModeController} (one live session each, isolated from
+ * a failing contribution). A session is bound to the base view it drew over, so it
+ * ends before anything else draws ({@link endSessions}) and restarts once the next
+ * render has landed ({@link activate}).
+ */
+export declare class ContributionHost {
+    private readonly viewer;
+    readonly plotModes: PlotModeController;
+    readonly toolDialogs: PlotModeController;
+    /** Dialog tools, sorted; their buttons show in the Image view only. */
+    readonly dialogTools: ToolbarDialogToolContribution[];
+    /** The live mode's panel; null while no contributed session is live. */
+    plotModePanel: PlotModePanelView | null;
+    /** The open dialog tool's live dialog. */
+    toolDialog: ToolDialogView | null;
+    /** The dialog tool the user has open (its session may be between renders). */
+    openDialogToolId: string | null;
+    private destroying;
+    /** The live dialog body's teardown, and a pending wait for its host to connect. */
+    private toolDialogTeardown;
+    private toolDialogFrame;
+    constructor(plotTypeContributions: readonly PlotTypeContribution[] | null | undefined, toolContributions: readonly ToolbarContribution[] | null | undefined, viewer: ContributionViewer);
+    /** End both sessions: the view they drew over is about to go. An open dialog tool
+     *  stays open and restarts on the next {@link activate}. */
+    endSessions(): void;
+    /** A render landed: start the selected mode's session and the open dialog tool's. */
+    activate(): void;
+    /** The viewer is being destroyed: end both sessions without touching its view. */
+    destroy(): void;
+    /** The toolbar button: open the tool's dialog, or close it if it is open. */
+    toggleDialogTool(id: string): void;
+    /** Close the open dialog tool: its body is torn down, then its session ends. */
+    closeDialogTool(): void;
+    /** Attach a `mount` panel's host element once the panel dialog renders its slot. */
+    attachPanelSlot(slot: HTMLElement | undefined): void;
+    /** Attach the open dialog tool's host element once its dialog renders its slot. */
+    attachToolDialogSlot(slot: HTMLElement | undefined): void;
+    /**
+     * Start the selected contributed mode's session, once its base view has plotted.
+     * No-op for a built-in type, or when the base on screen is not the one the mode
+     * rides on. A backend that cannot provide a viewport for it (e.g. OSD fell back to
+     * Plotly) counts as a failed activation.
+     */
+    private activateSelectedPlotMode;
+    /** Start (or restart, after a re-render) the open dialog tool's session. */
+    private activateOpenDialogTool;
+    /** A session's context over the backend on screen, or null when it has no viewport. */
+    private context;
+    /** Render the live mode's panel. Activation can resolve outside Angular (an OSD
+     *  callback, a contribution's own promise), hence the zone re-entry. */
+    private showPlotModePanel;
+    /** Drop the panel (destroying a component panel) before the session ends. */
+    private hidePlotModePanel;
+    /** A contributed mode could not start. Its base type is already on screen — the base
+     *  plotted first — so just select it: nothing needs to re-plot. */
+    private fallBackFromPlotMode;
+    /**
+     * The dialog-tool session is live: render the dialog, then mount the tool's body
+     * once the host element is in the document, so `mount()` can measure it and start
+     * widgets that need a connected element.
+     */
+    private showToolDialog;
+    /**
+     * Mount `tool`'s body into `host` once it is connected (the dialog may attach it a
+     * frame later, when it moves itself to `<body>`). If it never connects within
+     * {@link TOOL_DIALOG_ATTACH_FRAMES} it is mounted anyway, with a warning, rather than
+     * leaving an empty dialog. A throwing `mount()` fails the session like a failed start.
+     */
+    private mountToolDialogBody;
+    /** The dialog-tool session is about to end: tear the body down first, then drop the dialog. */
+    private hideToolDialog;
+    /** A dialog tool could not start: close it and say so. */
+    private dialogToolFailed;
+    /** Run change detection; returns what it threw (logged), or null. */
+    private detectChangesSafely;
+}

package/lib/plot-mode/plot-type-menu.d.ts

@@ -0,0 +1,60 @@
+import { ViewerCapabilities } from '../contracts/capabilities.contract';
+import { IImageInfo } from '../contracts/image.contract';
+import { PlotTypeDescriptor, PlotTypeId } from '../contracts/plot-type';
+import { ContributedPlotTypeDescriptor, PlotTypeOption } from '../contracts/plot-type-contribution.contract';
+/** What a spatial-omics dataset on offer contributes to the plot-type gates. */
+export interface SpatialGates {
+    /** A dataset is published on `SPATIAL_DATA_PORT`. */
+    hasDataset: boolean;
+    /** Its observations carry a z, so it can be drawn as a 3D cloud. */
+    has3d: boolean;
+    /** It brings pixels of its own: a tissue image it registers onto, or a volume
+     *  published as a z-stack image. */
+    hasPixels: boolean;
+}
+/** Everything {@link computePlotTypeMenu} gates on. */
+export interface PlotTypeMenuInput {
+    /** The built-in types the backend advertises. */
+    descriptors: PlotTypeDescriptor[];
+    /** Contributed plot modes (`PLOT_TYPE_CONTRIBUTIONS`). */
+    contributions: ContributedPlotTypeDescriptor[];
+    caps: ViewerCapabilities;
+    imageInfo: IImageInfo | undefined;
+    spatial: SpatialGates;
+    /** Offer every backend's type under its full label, not just the curated set. */
+    testMode: boolean;
+}
+/** The selector's entries: {@link builtIn} then the contributed modes. */
+export interface PlotTypeMenu {
+    builtIn: PlotTypeDescriptor[];
+    menu: PlotTypeOption[];
+}
+/**
+ * Plot types offered in the selector for the current image:
+ *  - Outside **test mode**, only the curated default set (descriptors with a
+ *    `productionLabel`) is offered, shown under suffix-free names — Image,
+ *    Heatmap, Contour and the napari Surface / Volume / Isosurface. Test mode
+ *    exposes every backend's type under its full (backend-suffixed) label.
+ *  - 3D types hidden when the backend can't render a 3D scene.
+ *  - stack-only types (volume, isosurface) hidden unless the file is a stack —
+ *    a volume needs multiple z-slices.
+ *  - scalar-intensity types (contour, surface, isosurface) hidden for RGB
+ *    images — they map a single intensity per pixel. Image and Heatmap render
+ *    any image. A multichannel image's bands are each scalar, so it passes.
+ *  - spatial-omics types hidden until a `SpatialDataset` is published on
+ *    `SPATIAL_DATA_PORT` — the mode has nothing to draw without observations,
+ *    exactly as a volume has nothing to draw without a stack.
+ *  - image-sourced types hidden while a dataset that brings no pixels is up.
+ *
+ * Contributed modes come after every built-in one, under the same label rule and
+ * their own stack/grayscale/spatial gates; a mode also needs whatever its base view
+ * needs, so the base type's gates apply too.
+ */
+export declare function computePlotTypeMenu(input: PlotTypeMenuInput): PlotTypeMenu;
+/**
+ * The type to fall back to when `selected` is no longer offered — Image when it is
+ * on offer, else the first type still offered — or null when `selected` is still
+ * offered (or nothing is). With no image loaded the pixel modes are gone, and falling
+ * back to Image would select a mode the selector does not list and nothing can draw.
+ */
+export declare function reconcilePlotType(menu: PlotTypeOption[], selected: PlotTypeId): PlotTypeId | null;

package/lib/plot-mode/tool-params-model.d.ts

@@ -0,0 +1,49 @@
+import { NumberParamSpec, SelectParamSpec, ToolParamSpec, ToolbarToolContribution } from '../contracts/toolbar-tool.contract';
+/** The open parameter dialog, as its template binds it. */
+export interface OpenToolParams {
+    tool: ToolbarToolContribution;
+    /** The tool's live values; the dialog edits them in place. */
+    values: Record<string, unknown>;
+    /** Each field's spec, already narrowed for the template (an `*ngSwitchCase` does not
+     *  narrow a union in the template type checker). */
+    fields: {
+        spec: ToolParamSpec;
+        number: NumberParamSpec | null;
+        select: SelectParamSpec | null;
+    }[];
+}
+/**
+ * Checkpoint choice and parameter values of the contributed no-prompt tools
+ * (`TOOLBAR_TOOLS`), and the generic parameter dialog over them.
+ *
+ * Values are seeded from the tool's defaults with the active checkpoint's own
+ * `ToolModelOption.defaults` on top — they encode the scale and crowding the
+ * checkpoint was trained for — lazily, on first use, and re-seeded when the
+ * checkpoint changes or the user resets.
+ */
+export declare class ToolParamsModel {
+    readonly tools: ToolbarToolContribution[];
+    /** Active checkpoint per tool; replaced (not mutated) so the toolbar sees a new reference. */
+    toolModelIds: Record<string, string>;
+    /** Parameter values per tool. */
+    toolParams: Record<string, Record<string, unknown>>;
+    /** The open dialog, built once on open so change detection only reads properties. Null while closed. */
+    openParams: OpenToolParams | null;
+    constructor(tools: ToolbarToolContribution[]);
+    /** A tool's current values, seeded on first use. */
+    paramsFor(toolId: string): Record<string, unknown>;
+    /** Active checkpoint for a tool, falling back to the tool's own default. */
+    modelIdFor(tool: ToolbarToolContribution): string;
+    /** Switching checkpoint re-seeds the parameters: the defaults belong to the model. */
+    setModel(toolId: string, modelId: string): void;
+    reset(toolId: string): void;
+    open(toolId: string): void;
+    close(): void;
+    /** The values to run a tool with: its parameters plus the active checkpoint. */
+    runParams(tool: ToolbarToolContribution): Record<string, unknown>;
+    find(toolId: string): ToolbarToolContribution | undefined;
+    /** A tool's defaults for a checkpoint, with that checkpoint's own overrides on top. */
+    private seed;
+    /** A tool's values object was replaced: point an open dialog for it at the new one. */
+    private rebind;
+}

package/lib/plot.utilities.d.ts

@@ -3,13 +3,19 @@ import { ShapeSelection } from './models/shape';
 export declare const COLORMAP_OPTIONS: {
     label: string;
     data: null;
-    children: {
+    children: ({
+        label: string;
+        data: {
+            value: [number, string][];
+            src: string;
+        };
+    } | {
         label: string;
         data: {
             value: string;
             src: string;
         };
-    }[];
+    })[];
 }[];
 export declare const CONFIG: {
     displaylogo: boolean;
@@ -45,7 +51,9 @@ export declare class PlotUtilities {
      */
     getRectangle(coordinates: number[], trueImageSize: number[]): Rectangle;
     /**
-     * given a dom object (found by id), return a Rectangle of the bounding element.
+     * The on-screen box a plot div is laid out in: the bounding rectangle of the
+     * element with id `div`'s parent (callers pass the plot div's own id). An
+     * empty Rectangle when there is no such element or it has no parent.
      * @param div
      */
     getDomRectangle(div: string): Rectangle;
@@ -61,47 +69,28 @@ export declare class PlotUtilities {
      */
     getPolygon(fig: any): any;
     /**
-     * TESTED
      * Rounds a list of numbers
      * @param a
      */
     round(a: number[]): number[];
     /**
-     * TESTED
-     * Returns true of zoom is the same as image size
+     * Returns true if the zoom is the same as the image size
      * @param rect Rectangle area
      * @param trueImgSize
      * @return true if rect is out of image size boundary
      */
     isZoomSameAsImgSize(rect: Rectangle, trueImgSize: number[]): boolean;
     /**
-     * Save the json string to a file
-     * @param jsonString
-     */
-    saveToFile(jsonString: any, baseName?: string): void;
-    /**
-     * Function that imports ROIs from a geojson object
-     * @param geoJsonStr
-     * @return Region[]
+     * Download a GeoJSON string as `<baseName without extension>.geojson`
+     * (`rois.geojson` without a base name).
      */
+    saveToFile(jsonString: string, baseName?: string): void;
+    /** Parse GeoJSON into regions; see {@link regionsFromGeoJson} in `models/region-geojson`. */
     importROIsFromGeoJson(geoJsonStr: string): Region[];
-    /**
-     * Function that returns a geojson object from a Plotly ROI
-     * @param rois
-     * @return FeatureCollection<Geometry, GeoJsonProperties>
-     */
+    /** Serialise regions as GeoJSON; see {@link regionsToGeoJson} in `models/region-geojson`. */
     exportROIsToGeoJson(rois: Region[]): string;
-    /**
-     * Convert GeoJSON interior rings into the neutral hole representation
-     * (`number[][]` per ring, no repeated closing point). Degenerate rings (< 3
-     * distinct points) are dropped. jit-ui#85.
-     */
-    /**
-     * Build a closed {@link Polygon} from a GeoJSON ring set: `rings[0]` is the
-     * exterior (closing point dropped), `rings[1..]` are interior holes. jit-ui#85.
-     */
-    private polygonFromRings;
-    private ringsToHoles;
+    /** `#rrggbb` for an RGB triple; see {@link rgbToHex} in `contracts/color`. */
     rgbToHex(r: number, g: number, b: number): string;
+    /** RGB for a hex colour (`#rgb` / `#rrggbb`); black when missing or unparseable. */
     hexToRgb(hex: string | undefined): number[];
 }

package/lib/processing/processing-image.d.ts

@@ -10,8 +10,11 @@ export declare class ProcessingImage {
     /** Create from browser ImageData. */
     static fromImageData(imageData: ImageData): ProcessingImage;
     constructor(width: number, height: number, channels: number, data: Uint8ClampedArray);
-    /** Convert to browser-native ImageData (RGBA). */
+    /**
+     * Convert to browser-native ImageData (RGBA). Gray (1), gray+alpha (2) and
+     * RGB (3) are expanded; other channel counts throw.
+     */
     toImageData(): ImageData;
-    /** Convert to Blob for saving/downloading. */
+    /** Convert to Blob for saving/downloading. Rejects when the browser can't encode it. */
     toBlob(mime?: string): Promise<Blob>;
 }

package/lib/provide-visualization.d.ts

@@ -1,4 +1,11 @@
 import { Provider } from '@angular/core';
+/**
+ * The three host-facing contracts, all served by the router. Shared by
+ * {@link provideVisualization} (component scope) and `VisualizationModule` (root),
+ * so both bind them the same way; at each scope they resolve to that scope's router.
+ * Package-internal (not exported from the public API).
+ */
+export declare const VISUALIZER_TOKEN_BINDINGS: Provider[];
 /**
  * A self-contained, isolated visualization backend chain for a component subtree.
  *
@@ -26,9 +33,19 @@ import { Provider } from '@angular/core';
  * embedded viewer gets its own router/Plotly/OSD/stores/tools while the rest of the
  * app keeps the default root instance.
  *
+ * In an application's own providers (`bootstrapApplication(App, { providers: [
+ * provideVisualization(), …] })`) it binds the one app-wide chain instead — the
+ * standalone counterpart of importing the deprecated `VisualizationModule`.
+ *
  * Lists EVERY stateful service in the chain. Stateless collaborators (HttpClient,
  * MessageService, WandService) deliberately resolve to root — they hold no
- * per-viewer state, so sharing them is correct and keeps this list minimal. When a
- * new stateful service joins the rendering chain, add it here too.
+ * per-viewer state, so sharing them is correct and keeps this list minimal. The
+ * SAM model session (`SamSessionService`) is also root on purpose: every viewer's
+ * SAM tools share one model download and Worker/GPU session (see its doc; a host
+ * can provide it at a viewer component to get a per-viewer session that is
+ * disposed with the viewer). When a
+ * new stateful service joins the rendering chain, add it here too —
+ * `provide-visualization.spec.ts` fails until it is listed (or allow-listed there as
+ * deliberately shared).
  */
 export declare function provideVisualization(): Provider[];

package/lib/region-editor/class-tree/class-tree.component.d.ts

@@ -0,0 +1,78 @@
+import { ElementRef, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import type { RegionClassNode } from '../../region-source/region-tiles';
+import { ClassTree, ClassTreeRow } from './class-tree';
+import * as i0 from "@angular/core";
+/** A pick in the tree: the class, and it with every class under it. */
+export interface ClassTreePick {
+    name: string;
+    classes: string[];
+    additive: boolean;
+}
+/** Whether a class is shown: it and its subclasses all, none ('hidden'), or only some ('partial'). */
+export type ClassVisibility = 'shown' | 'hidden' | 'partial';
+/**
+ * The Region Editor's classes as a hierarchy (a brain atlas's ontology), as the Allen atlas viewer
+ * shows it: collapsible, each class with its colour, name and long name, and the regions it and
+ * its subclasses have on this slice; a class with none is greyed. Picking a class selects all its
+ * regions and its subclasses' (the editor does the selecting). Search by name or long name. A
+ * class's swatch recolours it, as the class list's does; its eye hides it and its subclasses.
+ */
+export declare class ClassTreeComponent implements OnChanges {
+    private readonly el;
+    /** The hierarchy. */
+    nodes: readonly RegionClassNode[];
+    /** Regions per class on this slice (the regions and the region source's). */
+    counts: ReadonlyMap<string, number>;
+    /** A class's colour (a new function when the colours change, so the rows repaint). */
+    colorOf: (name: string) => string;
+    /** The class picked last (highlighted, its path expanded, scrolled into view). */
+    picked: string | null;
+    /** Classes with a selected region (marked). */
+    marked: ReadonlySet<string>;
+    /** Whether a volume view is on screen: each class can then be shown in 3D. */
+    volume: boolean;
+    /** The classes shown in 3D. */
+    shown3d: ReadonlySet<string>;
+    /** The classes hidden from view. */
+    hidden: ReadonlySet<string>;
+    pick: EventEmitter<ClassTreePick>;
+    /** A class's swatch picked a new colour. */
+    recolor: EventEmitter<{
+        name: string;
+        color: string;
+    }>;
+    /** A class's 3D toggle: it with every class under it. */
+    toggle3d: EventEmitter<{
+        name: string;
+        classes: string[];
+    }>;
+    /** A class's eye: hide (or show) it with every class under it. */
+    toggleHidden: EventEmitter<{
+        classes: string[];
+        hidden: boolean;
+    }>;
+    protected tree: ClassTree;
+    protected rows: ClassTreeRow[];
+    /** Each row's visibility (a row absent: shown). */
+    protected visibility: Map<string, ClassVisibility>;
+    protected query: string;
+    private expanded;
+    constructor(el: ElementRef<HTMLElement>);
+    ngOnChanges(changes: SimpleChanges): void;
+    protected node(name: string): RegionClassNode | undefined;
+    protected total(name: string): number;
+    protected toggle(row: ClassTreeRow, event: Event): void;
+    protected choose(name: string, event: Event): void;
+    /** The eye: a class hidden (wholly) is shown again with its subclasses; otherwise they are hidden. */
+    protected flipHidden(name: string, event: Event): void;
+    protected flip3d(name: string, event: Event): void;
+    protected onQuery(value: string): void;
+    /** Enter in the search box picks the first match. */
+    protected pickFirstMatch(event: Event): void;
+    protected readonly trackRow: (_: number, r: ClassTreeRow) => string;
+    private refresh;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClassTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClassTreeComponent, "region-class-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "counts": { "alias": "counts"; "required": false; }; "colorOf": { "alias": "colorOf"; "required": false; }; "picked": { "alias": "picked"; "required": false; }; "marked": { "alias": "marked"; "required": false; }; "volume": { "alias": "volume"; "required": false; }; "shown3d": { "alias": "shown3d"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, { "pick": "pick"; "recolor": "recolor"; "toggle3d": "toggle3d"; "toggleHidden": "toggleHidden"; }, never, never, true, never>;
+}
+/** Scroll the row matching `selector` inside `host` into view, if it is out of it. */
+export declare function scrollToPicked(host: HTMLElement, selector: string): void;

package/lib/region-editor/class-tree/class-tree.d.ts

@@ -0,0 +1,31 @@
+import type { RegionClassNode } from '../../region-source/region-tiles';
+/** A class hierarchy as a tree: children in order, subtree counts, depths. Pure. */
+export interface ClassTree {
+    roots: string[];
+    node: Map<string, RegionClassNode>;
+    children: Map<string, string[]>;
+    parent: Map<string, string | null>;
+    /** Regions of the class and every class under it. */
+    total: Map<string, number>;
+}
+/**
+ * Build the tree of `nodes`, counting `counts` (regions per class) up through it. A node whose
+ * parent is not in the hierarchy is a root; siblings sort by `order`, then as listed.
+ */
+export declare function buildClassTree(nodes: readonly RegionClassNode[], counts: ReadonlyMap<string, number>): ClassTree;
+/** `name` and every class under it. */
+export declare function subtree(tree: ClassTree, name: string): string[];
+/** The classes from the root down to `name`'s parent. */
+export declare function ancestors(tree: ClassTree, name: string): string[];
+/** One visible row of the tree. */
+export interface ClassTreeRow {
+    name: string;
+    depth: number;
+    hasChildren: boolean;
+    expanded: boolean;
+}
+/**
+ * The rows to draw: depth-first through the expanded nodes. With a `query`, only the nodes whose
+ * name or title contains it and their ancestors, all expanded.
+ */
+export declare function visibleRows(tree: ClassTree, expanded: ReadonlySet<string>, query?: string): ClassTreeRow[];

package/lib/region-editor/classes-panel/classes-panel.component.d.ts

@@ -0,0 +1,86 @@
+import { ElementRef, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ClassPreset, MatchMode } from '../../models/class-preset';
+import * as i0 from "@angular/core";
+/** One class row as the template draws it, derived once per input change. */
+interface ClassRow {
+    name: string;
+    color: string;
+    count: number;
+    canRemove: boolean;
+    rowTooltip: string;
+    removeTooltip: string;
+}
+/**
+ * The Region Editor's docked "Classes" panel (jit-ui#70): every annotation
+ * class with its colour swatch and region count. A row click picks the active
+ * class (and re-classifies a selection), the swatch recolours the class, the
+ * trash removes it, Manage opens the full editor; the search box filters the
+ * rows by name; the eye hides a class's regions. For a class hierarchy the editor projects a class tree in,
+ * shown in place of the list while {@link treeView} is on. Presentational: the
+ * editor applies every action.
+ */
+export declare class ClassesPanelComponent implements OnChanges {
+    private readonly el;
+    /** The classes in display order. */
+    classes: ClassPreset[];
+    /** Region count per class, keyed by {@link presetKey} under `matchMode`. */
+    counts: Map<string, number>;
+    /** How labels are matched to classes (keys {@link counts}). */
+    matchMode: MatchMode;
+    /** The active class (highlighted), or null. */
+    activeClass: string | null;
+    /** The class picked last (in the class tree, or a surface in 3D): highlighted, scrolled into view. */
+    picked: string | null;
+    /** Classes with a selected region (marked). */
+    marked: ReadonlySet<string>;
+    /** Number of selected regions (changes what a row click does). */
+    selectedCount: number;
+    /** The class regions revert to; it can't be removed while in use. */
+    defaultClassName: string;
+    /** Whether a volume view is on screen: each class can then be shown in 3D. */
+    volume: boolean;
+    /** The classes shown in 3D. */
+    shown3d: ReadonlySet<string>;
+    /** The classes hidden from view. */
+    hidden: ReadonlySet<string>;
+    /** A class's eye (its name): hide it, or show it again. */
+    toggleHidden: EventEmitter<string>;
+    /** A class's 3D toggle (its name). */
+    toggle3d: EventEmitter<string>;
+    /** Whether the projected class tree is shown instead of the list; null: there is no tree. */
+    treeView: boolean | null;
+    /** The list / tree switch. */
+    treeViewChange: EventEmitter<boolean>;
+    /** A row was clicked: make the class active / apply it to the selection. */
+    pick: EventEmitter<string>;
+    /** A class's swatch picked a new colour. */
+    recolor: EventEmitter<{
+        name: string;
+        color: string;
+    }>;
+    /** A class's trash button (its name). */
+    remove: EventEmitter<string>;
+    /** Manage clicked. */
+    manage: EventEmitter<void>;
+    /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */
+    protected readonly trackByName: (_: number, c: ClassRow) => string;
+    /** Every class's row, rebuilt when an input changes rather than per check. */
+    protected rows: ClassRow[];
+    /** The rows matching {@link query}. */
+    protected shownRows: ClassRow[];
+    /** The search box's text. */
+    protected query: string;
+    constructor(el: ElementRef<HTMLElement>);
+    ngOnChanges(changes?: SimpleChanges): void;
+    protected onQuery(value: string): void;
+    /** Enter in the search box picks the first match. */
+    protected pickFirstMatch(): void;
+    private filter;
+    private count;
+    private canRemove;
+    protected rowTooltip(name: string): string;
+    protected removeTooltip(name: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClassesPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClassesPanelComponent, "region-classes-panel", never, { "classes": { "alias": "classes"; "required": false; }; "counts": { "alias": "counts"; "required": false; }; "matchMode": { "alias": "matchMode"; "required": false; }; "activeClass": { "alias": "activeClass"; "required": false; }; "picked": { "alias": "picked"; "required": false; }; "marked": { "alias": "marked"; "required": false; }; "selectedCount": { "alias": "selectedCount"; "required": false; }; "defaultClassName": { "alias": "defaultClassName"; "required": false; }; "volume": { "alias": "volume"; "required": false; }; "shown3d": { "alias": "shown3d"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "treeView": { "alias": "treeView"; "required": false; }; }, { "toggleHidden": "toggleHidden"; "toggle3d": "toggle3d"; "treeViewChange": "treeViewChange"; "pick": "pick"; "recolor": "recolor"; "remove": "remove"; "manage": "manage"; }, never, ["*"], true, never>;
+}
+export {};

package/lib/region-editor/file-stem.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A file name without its extension: `slide.ome.tif` → `slide.ome`. A name with
+ * no extension — or only a leading dot, like `.hidden` — is returned whole, so
+ * a derived name is never a bare `.geojson`. `fallback` stands in for a missing
+ * name.
+ */
+export declare function fileStem(name: string | null | undefined, fallback: string): string;

package/lib/region-editor/manage-classes-dialog/manage-classes-dialog.component.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from '@angular/core';
+import { ClassPreset, MatchMode, PresetSet } from '../../models/class-preset';
+import * as i0 from "@angular/core";
+/**
+ * "Manage annotation classes" (jit-ui#70): edit the classes, the fallback
+ * palette, auto-add and label matching of a working copy of the preset set,
+ * plus reset / import / export. The editor owns the draft (`[(draft)]`); every
+ * edit here emits a new draft object (nothing is changed in place), and Apply
+ * asks the editor to persist it.
+ */
+export declare class ManageClassesDialogComponent {
+    /** The dialog is open. */
+    visible: boolean;
+    /** The dialog was closed (`false`); two-way with {@link visible}. */
+    visibleChange: EventEmitter<boolean>;
+    /** The working copy being edited (null until the dialog is opened). */
+    draft: PresetSet | null;
+    /** Every edit: the new draft object; two-way with {@link draft}. */
+    draftChange: EventEmitter<PresetSet>;
+    /** Apply clicked: persist the draft and close. */
+    apply: EventEmitter<void>;
+    /** Reset clicked: restore the default classes. */
+    resetDefaults: EventEmitter<void>;
+    /** A preset JSON file was chosen (the input's change event). */
+    importFile: EventEmitter<Event>;
+    /** Export clicked. */
+    export: EventEmitter<void>;
+    protected readonly matchModeOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Rows keep their DOM (and input focus) while their class object is replaced. */
+    protected readonly trackByIndex: (i: number) => number;
+    protected addClass(): void;
+    protected removeClass(i: number): void;
+    protected patchClass(i: number, patch: Partial<ClassPreset>): void;
+    protected addFallbackColor(): void;
+    protected removeFallbackColor(i: number): void;
+    protected setFallbackColor(i: number, color: string): void;
+    protected setAutoPromote(autoPromote: boolean): void;
+    protected setMatchMode(matchMode: MatchMode): void;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ManageClassesDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ManageClassesDialogComponent, "region-manage-classes-dialog", never, { "visible": { "alias": "visible"; "required": false; }; "draft": { "alias": "draft"; "required": false; }; }, { "visibleChange": "visibleChange"; "draftChange": "draftChange"; "apply": "apply"; "resetDefaults": "resetDefaults"; "importFile": "importFile"; "export": "export"; }, never, never, true, never>;
+}