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

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

@@ -1,112 +1,112 @@
 import { OnDestroy, OnInit } from '@angular/core';
-import { OverlayPanel } from 'primeng/overlaypanel';
 import { Region } from '../models/region';
 import { PresetSet, ClassPreset } from '../models/class-preset';
 import { ConfirmationService, MessageService } from 'primeng/api';
 import { IRegionEditorApi } from '../contracts/region-editor-api.contract';
-import { RegionIoPort } from '../contracts/ports/region-io.port';
+import { RegionPersistenceService } from './region-persistence.service';
+import { ClassColorEdit } from './region-color-dialog/region-color-dialog.component';
+import { MaskExportService, MaskMode } from './mask-export.service';
+import { PixelSize } from './region-metrics';
 import * as i0 from "@angular/core";
+/**
+ * The Region Editor (`<region-editor>`): the table of the active image's
+ * annotation regions with class presets, colours, labels, GeoJSON import /
+ * export / server save and mask export. Self-contained: it talks to the viewer
+ * only through {@link REGION_EDITOR_API} (and the host's REGION_IO_PORT), so it
+ * has no inputs or outputs.
+ *
+ * OnPush: template events re-render it; state that lands asynchronously (the
+ * API's region / selection / preset / image-meta streams, save and mask-export
+ * progress, file reads) marks it for check.
+ */
 export declare class RegionEditorComponent implements OnInit, OnDestroy {
     private regionApi;
-    messageService: MessageService;
+    private messageService;
     private confirmationService;
-    private regionIo;
-    protected readonly Array: ArrayConstructor;
-    overlayPanel: OverlayPanel;
-    regions: Region[];
-    regionsCopy: Region[];
-    selectedRegions: Region[];
-    showShapeLabel: boolean;
-    shapeColor: string;
-    fillColor: string;
-    displayHelpDialog: boolean;
-    showColorDialog: boolean;
+    private persistence;
+    private maskExport;
+    private overlayPanel;
+    protected regions: Region[];
+    protected selectedRegions: Region[];
+    protected showShapeLabel: boolean;
+    protected shapeColor: string;
+    protected fillColor: string;
+    protected displayHelpDialog: boolean;
+    protected showColorDialog: boolean;
     /** One colour editor per unique class among the selected regions, shown in the
      *  "edit colour of selected regions" dialog. Unclassified regions (no label)
      *  are grouped under a single entry with an empty `label`. */
-    classColorEdits: {
-        label: string;
-        color: string;
-    }[];
-    labelColors: Map<string, string>;
-    selectedLabelColor: string;
+    protected classColorEdits: ClassColorEdit[];
     /** "Edit class on selected rows" popup: chosen existing class, and a new-class name. */
-    bulkClass: string;
-    newBulkClass: string;
+    protected bulkClass: string;
+    protected newBulkClass: string;
     /** Local mirror of the per-user preset set (chip strip, Class dropdown, dialog). */
-    presetSet: PresetSet;
-    /** Class applied to newly drawn/added regions and to bulk chip-clicks. */
-    activeClass: string | null;
-    showManageDialog: boolean;
+    protected presetSet: PresetSet;
+    /** The class last picked in the panel; a chip-click applies it to the selected rows. */
+    protected activeClass: string | null;
+    protected showManageDialog: boolean;
     /** Working copy edited inside the Manage-classes dialog; committed on Apply/Done. */
-    presetDraft: PresetSet | null;
+    protected presetDraft: PresetSet | null;
     /** class name (match-mode keyed) → number of regions currently using it. */
-    classCounts: Map<string, number>;
+    protected classCounts: Map<string, number>;
     /** Fallback class that a region reverts to when its class is deleted (jit-ui#70). */
-    readonly defaultClassName = "Region";
+    protected readonly defaultClassName = "Region";
     /** Classes as shown in the panel: sorted by region count (desc), then name. */
-    displayClasses: ClassPreset[];
-    readonly matchModeOptions: {
-        label: string;
-        value: string;
-    }[];
-    paginatorFirst: number;
-    paginatorRows: number;
-    readonly rowsPerPageOptions: number[];
-    /** Regions whose Class cell is currently in edit mode.
-     *  Using object identity as the key avoids needing a unique id field. */
-    editingLabelRegions: Set<any>;
-    showSaveAsDialog: boolean;
-    saveAsFilename: string;
-    saveAsFileExists: boolean;
+    protected displayClasses: ClassPreset[];
+    protected paginatorFirst: number;
+    protected paginatorRows: number;
+    protected readonly rowsPerPageOptions: number[];
+    /** Regions whose Class cell is currently in edit mode → the label being typed.
+     *  The draft is committed on Enter and discarded on Escape/✕, so typing never
+     *  writes into the store's region (RT-18). Keyed by object identity, which
+     *  avoids needing a unique id field. */
+    protected editingLabelRegions: Map<Region, string>;
+    protected showSaveAsDialog: boolean;
+    protected saveAsFilename: string;
+    protected saveAsFileExists: boolean;
     /** True while a GeoJSON persist is serializing/uploading — drives the dialog's
      *  progress bar and Cancel button (parity with the Save-mask dialog). */
-    saveAsBusy: boolean;
-    private _saveAsCheck$;
+    protected saveAsBusy: boolean;
+    /** The running GeoJSON save; unsubscribing cancels it (Cancel / destroy). */
     private _saveAsSub?;
-    /** Handle for the deferred-serialize timer so Cancel/destroy can abort it
-     *  before it fires (otherwise the upload would still start). */
-    private _saveAsTimer?;
-    showExportDialog: boolean;
-    exportFilename: string;
-    showSaveMaskDialog: boolean;
-    saveMaskFilename: string;
+    /** Save-as file names to check for an existing file (debounced). */
+    private readonly saveAsCheck$;
+    protected showExportDialog: boolean;
+    protected exportFilename: string;
+    protected showSaveMaskDialog: boolean;
+    protected saveMaskFilename: string;
     /** Mask type chosen in the Save-mask dialog: a binary foreground/background
      *  mask, or a multi-class mask with a distinct id per region. */
-    maskMode: 'binary' | 'multiclass';
+    protected maskMode: MaskMode;
     /** True while the mask worker is rasterizing/encoding — drives the progress
      *  bar and the Cancel button in the dialog. */
-    maskBusy: boolean;
+    protected maskBusy: boolean;
     /** 0–100 rasterization progress; switches to indeterminate during encoding. */
-    maskProgress: number;
-    maskEncoding: boolean;
-    private maskWorker?;
-    private pendingMaskFilename;
+    protected maskProgress: number;
+    protected maskEncoding: boolean;
+    /** The running mask export; unsubscribing cancels it (terminates its worker). */
+    private maskJob?;
     /**
      * PrimeNG p-table multi-selection mode toggle. When true, single-click
      * selects one row (replacing prior); meta/ctrl-click toggles a row in/out
      * of the selection. When false, every click toggles. Default true to
      * match the most common spreadsheet-like UX.
      */
-    metaKey: boolean;
+    protected metaKey: boolean;
     private _updatingFromEditor;
     private _suppressSelectionSyncToPlot;
-    private _regionSub;
-    private _selectedIdxSub;
-    private _metaSub;
-    private _presetSub;
+    private readonly destroyRef;
+    private readonly cdr;
+    private readonly zone;
+    /** Re-render this OnPush view, re-entering the zone when the change came from outside it. */
+    private changed;
     /** Physical pixel size (µm/pixel) of the active image, for region areas in
-     *  µm². Undefined when the format reports no physical size. */
-    private mppX?;
-    private mppY?;
-    constructor(regionApi: IRegionEditorApi, messageService: MessageService, confirmationService: ConfirmationService, regionIo: RegionIoPort);
-    /**
-     * Deep copy of regions for dirty-tracking (`regionsCopy`). Returns plain-object
-     * clones — only structural equality matters here, not prototypes.
-     * TODO: replace with `structuredClone` once verified.
-     */
-    private deepClone;
+     *  µm²; empty when the format reports no physical size. */
+    protected mpp: PixelSize;
+    constructor(regionApi: IRegionEditorApi, messageService: MessageService, confirmationService: ConfirmationService, persistence: RegionPersistenceService, maskExport: MaskExportService);
     ngOnInit(): void;
+    /** Cancels a running GeoJSON save (aborts its upload) and mask export (terminates
+     *  its worker); the API subscriptions end through `takeUntilDestroyed`. */
     ngOnDestroy(): void;
     /**
      * Table → Plot: PrimeNG fires onRowSelect/onRowUnselect after updating
@@ -114,96 +114,81 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
      * the package maps them to its internal index space (which includes the
      * intensity-profile lines the editor never sees).
      */
-    onSelectionChanged(): void;
+    protected onSelectionChanged(): void;
     /**
-     * Apply classification colours and refresh the label→colour map for regions
-     * coming from the visualizer. The visualizer hands back neutral `Region`
-     * objects with bounds, colour and label already populated, so the editor no
-     * longer parses any backend-specific shape format — it only fills in a
-     * fallback colour and rebuilds its local label→colour lookup.
+     * Rows for regions coming from the visualizer: neutral `Region`s with bounds,
+     * colour and label already populated. A region without a colour is shown with
+     * its classification colour (or the default shape colour) — as a copy: the
+     * store's instances are shared with its undo history and must not be changed
+     * in place (RT-1).
      */
     private applyRegionColors;
     /**
-     * Push edits from the editor to the diagram in live-edit mode (no save /
-     * cancel buttons). The `_updatingFromEditor` guard is still used so the
-     * resulting regionUpdateEvent doesn't bounce back as an external change.
+     * The editor's one write path (RT-1): make `next` the table's rows and commit
+     * them to the store — live, as one undoable step (isRegionSaveOn=true; the
+     * router keeps the intensity-profile lines). Rows are the store's instances,
+     * so an edit passes copies ({@link patchRegions}), never changed rows. The
+     * resulting region-update event is ignored (`_updatingFromEditor`), so the
+     * class list and counts are refreshed here (a typed class is added; jit-ui#70).
+     */
+    private commit;
+    /**
+     * Copy-on-write edit (review RT-1). The editor's rows are the region store's
+     * live instances, and the store takes its undo snapshot only when the edit is
+     * committed — so an edit must replace a region with a patched copy (and any
+     * bounds it changes with new bounds), never mutate the instance the store
+     * holds. Returns the copies by original; the selection and an open label edit
+     * follow them.
      */
-    private setRegionsFromEditor;
-    /** Set one region's outline colour from the per-row picker and commit live.
-     *  Remembers it as the label's colour so same-class regions added later match
-     *  (jit-ui#85 — the Region Editor's per-region Color column). */
-    changeRegionColor(region: Region, color: string): void;
-    addRectangle(): void;
+    private patchRegions;
+    /** Set one region's outline colour (an explicit override) and commit live. */
+    protected changeRegionColor(region: Region, color: string): void;
     /**
-     * Update the label of the region on enter key pressed (when editing a label cell in the table)
-     * @param region
-     * @param setRegion
+     * After a label edit on `region`: give every labelled row without a colour its
+     * class colour (preset or fallback, as the store will), and commit when
+     * `commit` is set.
      */
-    labelRegionUpdate(region: Region, setRegion?: boolean): void;
-    xRectUpdate(region: Region, event: any): void;
-    yRectUpdate(region: Region, event: any): void;
-    widthRectUpdate(region: Region, event: any): void;
-    heightRectUpdate(region: Region, event: any): void;
-    onPageChange(event: {
+    protected labelRegionUpdate(region: Region, commit?: boolean): void;
+    /** Labelled rows without a colour get their class colour (copies). */
+    private fillClassColors;
+    /** The current page of the table. Memoized on (regions, first, rows), so
+     *  change detection doesn't hand p-table a new array every tick (RT-20). */
+    protected get pagedRegions(): Region[];
+    private _pageKey;
+    private _page;
+    protected onPageChange(event: {
         first?: number;
         rows?: number;
     }): void;
     /** Select every region in the table (and highlight them on the diagram). */
-    selectAllRegions(): void;
-    deleteSelectedRegions(): void;
-    clearAllRegions(): void;
-    addPolygon(): void;
-    deleteRegion(shapeIdx: number): void;
+    protected selectAllRegions(): void;
+    protected deleteSelectedRegions(): void;
+    protected clearAllRegions(): void;
+    protected deleteRegion(shapeIdx: number): void;
     private clampPaginatorFirst;
-    changeShowShapeLabel(showLabel: boolean): void;
-    isEditingLabel(region: any): boolean;
-    startEditLabel(region: any, event?: Event): void;
-    stopEditLabel(region: any, commit: boolean, event?: Event): void;
-    isRectangle(region: Region): boolean;
-    /**
-     * Region area for display: in µm² (or mm²) when the image reports a physical
-     * pixel size, otherwise in px². Empty string for degenerate regions.
-     */
-    regionArea(region: Region): string;
-    /**
-     * Choose the physical pixel size (µm/pixel) for area display from the image
-     * meta. The calibration may sit on any channel entry — not necessarily [0] —
-     * so pick the first entry with a positive mppX (mirrors
-     * PlotlyService.currentMpp). Falls back to square pixels (mppY = mppX) when
-     * only one axis is reported, so a scaled image shows µm²/mm² rather than px².
-     */
-    private pickMpp;
-    /** Pixel area: width·height for rectangles, shoelace formula for polygons.
-     *  Interior rings (holes) are subtracted, so a donut reports the annulus area,
-     *  not the filled exterior (jit-ui#85). */
-    private areaInPixels;
-    /** Polygon area: exterior shoelace minus each interior ring (hole). */
-    private polygonArea;
-    /** Absolute shoelace area of a single ring. */
-    private ringArea;
-    private fmtArea;
+    protected changeShowShapeLabel(showLabel: boolean): void;
+    protected isEditingLabel(region: Region): boolean;
+    protected startEditLabel(region: Region, event?: Event): void;
+    /** The label typed so far for a row in edit mode (no re-render needed). */
+    protected setLabelDraft(region: Region, value: string): void;
+    protected stopEditLabel(region: Region, commit: boolean, event?: Event): void;
+    /** Region area for display (µm²/mm² when the image is scaled, else px²);
+     *  empty for a degenerate region. See `region-metrics`. */
+    protected regionArea(region: Region): string;
     /**
      * This method rounds all the rectangle regions lengths to multiple of 512
      */
-    roundRectangleLengths(): void;
-    /**
-     * Stop key arrow event propagation
-     * @param event
-     */
-    disableArrowKeys(event: any): void;
-    changeShapeColor(event: any): void;
-    showHelp(): void;
+    protected roundRectangleLengths(): void;
+    protected showHelp(): void;
     /** Open the colour dialog for the currently-selected region(s), building one
      *  colour picker per unique class in the selection. Each picker is seeded with
-     *  the class's current colour (the label→colour map, falling back to the first
-     *  selected region of that class). */
-    openColorDialog(): void;
-    /** Apply each class's chosen colour to the selected regions of that class and
-     *  commit live. Remembers the colour per class so same-class regions added
-     *  later match. */
-    applyColorToSelected(): void;
+     *  the first selected region of that class's colour (else the class colour). */
+    protected openColorDialog(): void;
+    /** Apply each class's chosen colour to the selected regions of that class (an
+     *  explicit override) and commit live. */
+    protected applyColorToSelected(edits?: ClassColorEdit[]): void;
     /** Resolve the display colour for a class name (preset colour or deterministic fallback). */
-    colorForName(name?: string): string;
+    protected colorForName(name?: string): string;
     /**
      * Ensure every class label present in the loaded regions exists in the preset
      * list, auto-adding any that are missing (using the region's already-resolved
@@ -217,89 +202,71 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
     private recomputeClassCounts;
     /** Rebuild the panel's display order — most-used classes first, then by name. */
     private updateDisplayClasses;
-    /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */
-    trackByClassName: (_: number, c: ClassPreset) => string;
     /** Number of regions currently using a class (keyed by the active match mode). */
-    classCount(name: string): number;
+    protected classCount(name: string): number;
     /** Recolour a class from its panel swatch and repaint its (non-overridden) regions. */
-    setClassColor(name: string, color: string): void;
-    /** Tooltip for a class's delete button in the panel. */
-    deleteClassTooltip(name: string): string;
+    protected setClassColor(name: string, color: string): void;
     /** Remove a class. Any regions still using it fall back to the default
      *  "Region" class, so they aren't orphaned (and the class isn't immediately
      *  re-added from its regions by syncClassesFromRegions). */
-    deleteClass(name: string): void;
+    protected deleteClass(name: string): void;
     /** Regions labelled with any of `removedNames` revert to the default
      *  {@link defaultClassName} ("Region"): its class colour, override cleared.
      *  Skips the default itself so deleting "Region" can't self-reassign. (jit-ui#70) */
     private reassignRegionsToDefaultClass;
     /** Stamp a class (and its preset/fallback colour) onto one region from the Class
      *  dropdown; choosing a class opts the region back into the preset colour. */
-    applyPresetToRegion(region: Region, className: string): void;
+    protected applyPresetToRegion(region: Region, className: string): void;
     /** Make a class active (used for new regions) and, if rows are selected, apply
      *  it to them in one commit. */
-    selectActiveClass(name: string): void;
+    protected selectActiveClass(name: string): void;
     /** Apply a class (label + preset/fallback colour) to the current selection and commit. */
     private applyClassToSelected;
     /** "Edit class on selected rows" popup — apply the chosen existing class. */
-    applyBulkClass(): void;
+    protected applyBulkClass(): void;
     /** "Edit class on selected rows" popup — add a new class and set it on the selection. */
-    addAndApplyBulkClass(): void;
-    openManageDialog(): void;
+    protected addAndApplyBulkClass(): void;
+    protected openManageDialog(): void;
     private clonePresetSet;
-    addPresetClass(): void;
-    removePresetClass(i: number): void;
-    addFallbackColor(): void;
-    removeFallbackColor(i: number): void;
     /** Commit the draft: drop blank/duplicate names, persist, and recolour
      *  non-overridden regions with the updated presets. */
-    applyManageDialog(close: boolean): void;
-    resetPresetsToDefaults(): void;
-    exportPresets(): void;
-    importPresets(event: Event): void;
-    importRois(event: Event): void;
-    /**
-     * Regions to serialize on save/export. For a single-file z-stack the store
-     * keeps only the current slice live, so pull EVERY slice's annotations (each
-     * tagged with its zero-based Region.z) to write one combined z-indexed
-     * geojson (jit-ui#93). Otherwise (single-plane image, or a folder stack whose
-     * slices save to their own per-slice files) the current set. (jit-ui#93)
-     */
+    protected applyManageDialog(close: boolean): void;
+    protected resetPresetsToDefaults(): void;
+    protected exportPresets(): void;
+    protected importPresets(event: Event): void;
+    /** Validate and apply an imported annotation-classes JSON file. */
+    private applyImportedPresets;
+    protected importRois(event: Event): void;
+    /** Replace the regions with an imported GeoJSON file's. */
+    private applyImportedRois;
+    /** Regions to serialize on save/export (every slice for a combined z-stack). */
     private regionsForSave;
-    exportRois(): void;
-    confirmExport(): void;
+    protected exportRois(): void;
+    protected confirmExport(): void;
     /** Open the "Save mask" dialog, seeded with `<image-stem>_mask.png`. */
-    openSaveMaskDialog(): void;
+    protected openSaveMaskDialog(): void;
     /**
      * Rasterize the regions to the chosen mask type and download as a PNG. The
-     * heavy work (full-res rasterize + PNG encode) runs in a Web Worker so the UI
-     * never freezes on large/whole-slide images and the job can be cancelled
-     * (jit-ui#95). The dialog stays open showing a progress bar until done.
+     * heavy work runs in a Web Worker ({@link MaskExportService}) so the UI never
+     * freezes on whole-slide images and the job can be cancelled (jit-ui#95);
+     * the dialog stays open with a progress bar until done.
      */
-    confirmSaveMask(): void;
-    /** Cancel an in-progress mask export: terminate the worker and reset state. */
-    cancelSaveMask(): void;
-    /** Worker factory — async so the worker module (and its `import.meta.url`,
-     *  which the CommonJS test compile rejects) is loaded via a dynamic import,
-     *  exactly like the segmentation worker. Overridable in tests. */
-    protected createMaskWorker(): Promise<Worker>;
+    protected confirmSaveMask(): void;
+    /** Cancel an in-progress mask export (terminates its worker) and reset state. */
+    protected cancelSaveMask(): void;
     private finishMask;
     private maskError;
-    private teardownMaskWorker;
-    persistRegions(): void;
-    /**
-     * Save a folder stack's regions as one geojson per slice-file (jit-ui#93).
-     * Groups the store's per-slice regions by slice index and serializes each on
-     * the default plane (z=0) — each slice-file is itself one plane, and the
-     * loader re-derives the slice index from the file's position in the series.
-     * Slices cleared since load are included (empty) so their file is overwritten.
-     */
+    protected persistRegions(): void;
+    /** Save a folder stack's regions as one geojson per slice-file (jit-ui#93).
+     *  No dialog covers the toolbar meanwhile, so a Save while one is uploading
+     *  is ignored rather than starting a second write (and orphaning the first). */
     private saveStackSlices;
-    checkSaveAsFileExists(): void;
-    confirmSaveAs(): void;
+    protected checkSaveAsFileExists(): void;
+    protected confirmSaveAs(): void;
     /** Cancel an in-progress GeoJSON persist: abort the deferred serialize and/or
      *  the in-flight upload, and reset state. */
-    cancelSaveAs(): void;
+    protected cancelSaveAs(): void;
+    private toast;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegionEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RegionEditorComponent, "region-editor", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegionEditorComponent, "region-editor", never, {}, {}, never, never, true, never>;
 }

package/lib/region-editor/region-metrics.d.ts

@@ -0,0 +1,26 @@
+import { Region } from '../models/region';
+import { IImageMetadata } from '../contracts/image.contract';
+/** Physical pixel size (µm/pixel); both undefined when the image is unscaled. */
+export interface PixelSize {
+    mppX?: number;
+    mppY?: number;
+}
+/**
+ * Choose the physical pixel size for area display from the image meta. The
+ * calibration may sit on any channel entry, not necessarily [0], so take the
+ * first entry with a positive mppX (as PlotlyService.currentMpp does). With
+ * only one axis reported, pixels are square (mppY = mppX), so a scaled image
+ * shows µm²/mm² rather than px².
+ */
+export declare function pickMpp(meta: IImageMetadata[] | undefined): PixelSize;
+/**
+ * A region's area in px²: width·height for a rectangle, shoelace for a polygon
+ * with each interior ring (hole) subtracted (a donut reports the annulus), and
+ * the sum of the parts for a multi-polygon (jit-ui#85). 0 for anything else.
+ */
+export declare function regionAreaPx(region: Pick<Region, 'bounds'>): number;
+/**
+ * An area for display: µm² (mm² from 1e6 µm²) when the pixel size is known,
+ * otherwise px². Empty for a degenerate (non-positive) area.
+ */
+export declare function formatArea(px: number, mpp?: PixelSize): string;

package/lib/region-editor/region-persistence.service.d.ts

@@ -0,0 +1,69 @@
+import { Observable } from 'rxjs';
+import { Region } from '../models/region';
+import { IRegionEditorApi } from '../contracts/region-editor-api.contract';
+import { RegionIoPort } from '../contracts/ports/region-io.port';
+import * as i0 from "@angular/core";
+/** One slice-file's serialized regions (folder stack, jit-ui#93). */
+export interface SliceGeoJson {
+    z: number;
+    geoJsonStr: string;
+}
+/**
+ * Region file I/O for the Region Editor: default file names, GeoJSON download
+ * (export), save to the host through {@link RegionIoPort} (with a debounced
+ * "file exists" check), per-slice saves for folder stacks, and reading an
+ * imported file. Provided by the editor; it holds no state — the editor owns
+ * the dialogs, the toasts and the running jobs.
+ */
+export declare class RegionPersistenceService {
+    private readonly api;
+    private readonly io;
+    constructor(api: IRegionEditorApi, io: RegionIoPort);
+    /** The selected image's file name, if any. */
+    selectedFileName(): string | undefined;
+    /** `<image-stem>.geojson` for a server save; undefined with no image selected. */
+    defaultSaveName(): string | undefined;
+    /** `<image-stem>.geojson` (or `rois.geojson`) for a download. */
+    defaultExportName(): string;
+    /** `<image-stem>_mask.png` (or `regions_mask.png`) for a mask download. */
+    defaultMaskName(): string;
+    /** True when a save writes one geojson per slice-file (folder stack, jit-ui#93). */
+    savesPerSlice(): boolean;
+    /**
+     * Regions to serialize on save/export. For a single-file z-stack the store
+     * keeps only the current slice live, so take EVERY slice's annotations (each
+     * tagged with its zero-based Region.z) for one combined z-indexed geojson
+     * (jit-ui#93); otherwise `live` (single plane, or a folder stack whose slices
+     * save to their own files).
+     */
+    regionsForSave(live: Region[]): Region[];
+    /**
+     * Whether each file name in `names` already exists on the host, debounced
+     * 400 ms; a newer name supersedes an in-flight check. A failed check reads as
+     * "does not exist" and later checks keep working.
+     */
+    fileExists(names: Observable<string>): Observable<boolean>;
+    /** Download `regions` as a GeoJSON file named `filename`. */
+    download(regions: Region[], filename: string): void;
+    /**
+     * Save `regions()` to the host as `filename`. Serializing is deferred one
+     * tick (so a progress indicator paints before a large synchronous
+     * serialize); unsubscribing before then cancels the save entirely, and after
+     * it cancels the upload. A serialize failure is an error, like an upload one.
+     */
+    save(regions: () => Region[], filename: string): Observable<void>;
+    /**
+     * A folder stack's regions as one geojson per slice-file (jit-ui#93), each
+     * serialized on the default plane (z=0): every slice-file is one plane, and
+     * the loader re-derives the slice index from the file's position. Slices
+     * cleared since load are included (empty) so their file is overwritten.
+     */
+    sliceGeoJsons(): SliceGeoJson[];
+    /** Write per-slice geojsons through the host port. */
+    saveSlices(slices: SliceGeoJson[]): Observable<void>;
+    /** Read the file chosen in a file input's change event as text, then call
+     *  `onText`. No-op when no file was chosen. */
+    readChosenFile(event: Event, onText: (text: string) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionPersistenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegionPersistenceService>;
+}