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

package/lib/spatial-controls/spatial-gene-picker.d.ts

@@ -0,0 +1,86 @@
+import { BehaviorSubject } from 'rxjs';
+import type { ISpatialControls } from '../contracts/visualizer.contract';
+import type { SpatialDataset } from '../contracts/spatial-dataset.contract';
+import { PanelOption } from '../spatial/spatial-panel-model';
+/** What a gene dropdown shows: its options, and what an empty list means. */
+export interface GenePickerState {
+    /**
+     * The options. The full name list when the dataset inlines it (a targeted panel: 8 for
+     * the ABC demo, 300–5,000 for Xenium/CosMx) — or rather its best few hundred, see
+     * {@link GenePickerModel}. A whole-transcriptome dataset does not ship its ~31k names, so
+     * there the list is what the port's last search returned and filtering is server-side —
+     * same control either way.
+     */
+    options: PanelOption<string>[];
+    /** True when the options come from the port per keystroke rather than a resident list,
+     *  which changes what an empty list means (nothing matched *yet*). */
+    remote: boolean;
+    /** The last remote lookup failed. */
+    failed: boolean;
+}
+/**
+ * The gene list behind every gene dropdown of the spatial-omics panel — "Colour by gene",
+ * the cells' gene colouring, and the transcript genes. One model for all three: they share
+ * one list and one search, so each opens on the head of the full list rather than on
+ * whatever another was last filtered to, and a whole-transcriptome list is fetched once.
+ *
+ * Every gene the dataset inlined is held as plain strings and searched per keystroke. A
+ * whole-transcriptome dataset inlines ~18k names — cheap to keep, ruinous to hand a
+ * dropdown all at once — so the options are only ever the best few hundred of them.
+ *
+ * Plain class, no Angular: the owner passes `run`, which re-enters the zone, and the
+ * dropdowns read {@link state$} through the `async` pipe, so an OnPush panel re-renders
+ * when a search lands.
+ */
+export declare class GenePickerModel {
+    private readonly controls;
+    private readonly chosen;
+    private readonly run;
+    /** Most names fetched for the lazy list — well above any panel, whole-transcriptome included. */
+    static readonly LIST_MAX = 100000;
+    /** Names asked of the port per keystroke while the list is not resident. */
+    static readonly SEARCH_LIMIT = 50;
+    readonly state$: BehaviorSubject<GenePickerState>;
+    private names;
+    private listLoading;
+    /** Guards the typeahead: typing outruns the lookup. */
+    private readonly search;
+    /** Guards the whole-transcriptome list preload against a dataset switch. */
+    private readonly listLoad;
+    /**
+     * @param controls the port, or null when none is bound.
+     * @param chosen the genes already chosen anywhere, kept among the options: a multi-select
+     *   shows a chip only for a value it can find among its options.
+     * @param run where async results are applied — the owner's `NgZone.run`.
+     */
+    constructor(controls: () => ISpatialControls | null, chosen: () => readonly string[], run?: (fn: () => void) => void);
+    get options(): PanelOption<string>[];
+    get remote(): boolean;
+    get failed(): boolean;
+    /** Genes resident in the list (the inlined names, or the fetched list once loaded). */
+    get residentCount(): number;
+    /** A new dataset: its own names (or none), and nothing in flight for the previous one. */
+    setDataset(dataset: SpatialDataset | null): void;
+    /**
+     * A keystroke in a gene dropdown's filter box.
+     *
+     * With the names resident, search them here and materialise only the top matches: the
+     * dropdown's own filter then runs over those and agrees — they were chosen by the same
+     * query — so the control behaves as if it still held the whole list. Without them there
+     * is nothing to filter, so the query goes to the port and its answer BECOMES the option
+     * list — the same control, filtering one hop further away.
+     */
+    onFilter(query: string): Promise<void>;
+    /**
+     * A gene dropdown opened.
+     *
+     * A whole-transcriptome dataset does not inline its ~30k names; they are fetched here,
+     * once, on first open — the list is then resident and every keystroke filters locally,
+     * exactly as for a targeted panel. Until it arrives the dropdown falls back to asking the
+     * server per keystroke.
+     */
+    ensureList(): Promise<void>;
+    /** Options for `names`, plus the genes already chosen. */
+    private withChosen;
+    private set;
+}

package/lib/spatial-controls/spatial-gene-tree/spatial-gene-tree.component.d.ts

@@ -0,0 +1,102 @@
+import { ChangeDetectorRef, NgZone, OnChanges, SimpleChanges } from '@angular/core';
+import type { ISpatialControls } from '../../contracts/visualizer.contract';
+import type { SpatialDataset } from '../../contracts/spatial-dataset.contract';
+import { SpatialViewState, TranscriptGlyphName } from '../../contracts/display-types';
+import { GeneTreeNode } from '../../spatial/spatial-panel-model';
+import * as i0 from "@angular/core";
+/** One gene row as the template draws it, derived once per input change. */
+interface GeneRowView {
+    shown: boolean;
+    swatch: string;
+    /** The row's glyph outline (drawn in Icons mode). */
+    points: string;
+    /** Transcripts in view, or null before the renderer reports any. */
+    count: number | null;
+}
+/**
+ * The selected transcript genes as Xenium Explorer's tree: the gene groups, then the
+ * ungrouped genes, each row with an eye that hides it without deselecting it, its marker
+ * in its colour (opening one icon-and-colour picker per gene), and its transcript count in
+ * view.
+ *
+ * Writes only through `controls.setViewState`.
+ */
+export declare class SpatialGeneTreeComponent implements OnChanges {
+    private readonly zone;
+    private readonly cdr;
+    /** The spatial controls this panel reads and writes through; null without a `SPATIAL_DATA_PORT`. */
+    controls: ISpatialControls | null;
+    /** The dataset on offer, or null. */
+    dataset: SpatialDataset | null;
+    /** The current spatial view state: what is drawn, and how. */
+    view: SpatialViewState;
+    /** Transcripts of each selected gene in the current view, from the renderer. */
+    geneCounts: Record<string, number> | null;
+    /** Real genes in the panel — the tree's denominator. */
+    geneTotal: number;
+    protected readonly glyphOptions: import("../../spatial/spatial-panel-model").GlyphOption[];
+    /** Swatches in the picker: the categorical palette genes are coloured from by default. */
+    protected readonly colorPresets: string[];
+    /** The tree, rebuilt when the view changes — never per change-detection pass. */
+    protected geneTree: GeneTreeNode[];
+    /** Per gene: its eye, swatch, glyph and count — rebuilt with the inputs (and when the
+     *  cells' group colours arrive), so the template does no per-row lookups per check. */
+    protected rows: Map<string, GeneRowView>;
+    /** Per named group, and for the root: whether any of its genes is shown. */
+    protected groupShown: Map<string, boolean>;
+    protected rootShown: boolean;
+    protected collapsedGeneGroups: Set<string>;
+    protected geneTreeOpen: boolean;
+    /** The gene the open picker edits. */
+    protected styleGene: string | null;
+    /** Colours of the cells' groups, by name — what a cluster of the same name is drawn in. */
+    private cellGroupColors;
+    /** The grouping {@link cellGroupColors} belongs to — a repeat request for it is a no-op. */
+    private cellGroupColorsFor;
+    /** Latest wins among colour loads for {@link cellGroupColors}. */
+    private readonly cellGroupColorsLoad;
+    constructor(zone: NgZone, cdr: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    private rebuildRows;
+    protected toggleGeneGroup(name: string): void;
+    protected isGeneShown(gene: string): boolean;
+    protected areGenesShown(genes: string[]): boolean;
+    /** The eye toggle: hide or show genes without removing them from the selection. */
+    protected onGenesShown(genes: string[], on: boolean): void;
+    /** The root eye while every gene is shown: back to the chosen list. */
+    protected onToggleAllGenes(): void;
+    protected onGeneColor(gene: string, hex: string): void;
+    protected openGeneStyle(event: Event, gene: string, panel: {
+        toggle(e: Event): void;
+        hide(): void;
+    }): void;
+    /** The icon the open picker shows as chosen. */
+    protected get styleGlyph(): TranscriptGlyphName | null;
+    protected glyphPoints(glyph: TranscriptGlyphName): string;
+    protected glyphOf(gene: string, slot: number): TranscriptGlyphName;
+    protected onGlyph(gene: string, glyph: TranscriptGlyphName): void;
+    /** A typed hex colour, accepted as `#rrggbb` or `rrggbb`; anything else is ignored. */
+    protected onGeneHex(gene: string, text: string): void;
+    /** Back to the gene's default icon and colour (by its position in the list). */
+    protected resetGeneStyle(gene: string): void;
+    /** The colour gene `slot` is drawn in when transcripts are coloured by gene. */
+    geneColor(slot: number): string;
+    protected geneColorOf(gene: string): string;
+    /** In Cluster colouring, a gene's swatch is its cluster's colour, as its markers are. */
+    protected geneSwatchOf(gene: string): string;
+    protected geneCountOf(gene: string): number | null;
+    protected trackByNode: (_i: number, node: {
+        name: string | null;
+    }) => string;
+    protected trackByLabelString: (_i: number, s: string) => string;
+    /**
+     * The cluster colours, rebuilt only when what they come from changes. The template asks
+     * once per gene row per change-detection pass, and rebuilding per call made that O(G²).
+     */
+    private clusterColors;
+    private clusterColorMemo;
+    private refreshCellGroupColors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialGeneTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialGeneTreeComponent, "spatial-gene-tree", never, { "controls": { "alias": "controls"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "view": { "alias": "view"; "required": false; }; "geneCounts": { "alias": "geneCounts"; "required": false; }; "geneTotal": { "alias": "geneTotal"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/spatial-controls/spatial-groups-panel/spatial-groups-panel.component.d.ts

@@ -0,0 +1,72 @@
+import { ChangeDetectorRef, NgZone, OnChanges, SimpleChanges } from '@angular/core';
+import type { ISpatialControls } from '../../contracts/visualizer.contract';
+import type { SpatialDataset } from '../../contracts/spatial-dataset.contract';
+import { SpatialViewState } from '../../contracts/display-types';
+import { GroupOptionSection, GroupRow, PanelOption } from '../../spatial/spatial-panel-model';
+import * as i0 from "@angular/core";
+/**
+ * The cells' grouping, as Xenium Explorer's Groups section: the group picker (columns under
+ * their section heading, a k-means family once, with its k beside it), CSV import of a new
+ * grouping, and the grouping's categories with their colours, cell counts and show/hide
+ * switches.
+ *
+ * Writes only through `controls.setViewState` (`cellTypeColumn`, `hiddenGroups`).
+ */
+export declare class SpatialGroupsPanelComponent implements OnChanges {
+    private readonly zone;
+    private readonly cdr;
+    /** The spatial controls this panel reads and writes through; null without a `SPATIAL_DATA_PORT`. */
+    controls: ISpatialControls | null;
+    /** The dataset on offer, or null. */
+    dataset: SpatialDataset | null;
+    /** The current spatial view state: what is drawn, and how. */
+    view: SpatialViewState;
+    /**
+     * The group picker: categorical columns under their section heading, a family of
+     * variants (k-means at k = 2…10) listed once. Values are a column name, or
+     * `family:<id>` for a family.
+     */
+    protected groupOptions: GroupOptionSection[];
+    /** Variants of the active family (k = 2…10), when a family is active. */
+    protected groupVariantOptions: PanelOption<string>[];
+    /** The last variant chosen per family, so switching away and back keeps k. */
+    private readonly familyChoice;
+    /** The active grouping's categories with colours and cell counts, largest first. */
+    protected groupRows: GroupRow[];
+    protected groupTotal: number;
+    protected groupsExpanded: boolean;
+    /** The grouping {@link groupRows} shows or is loading — a repeat request for it is a no-op. */
+    private groupRowsFor;
+    /** Latest wins among group-row loads, so a slow one for an earlier grouping (or the
+     *  previous dataset's column of the same name) cannot land over the current one. */
+    private readonly groupRowsLoad;
+    protected groupImportError: string | null;
+    protected groupImporting: boolean;
+    constructor(zone: NgZone, cdr: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    /** The categorical column the cells are grouped by. */
+    protected get activeCellTypeColumn(): string | null;
+    /** The picker's value for the active group column. */
+    protected get activeGroupEntry(): string | null;
+    protected onGroupEntry(value: string): void;
+    protected onGroupVariant(name: string): void;
+    onCellTypeColumn(name: string | null): void;
+    /** {@link SpatialViewState.hiddenGroups} as a set, for the per-row checks. */
+    private hiddenGroups;
+    protected isGroupShown(label: string): boolean;
+    protected get allGroupsShown(): boolean;
+    protected onGroupShown(label: string, on: boolean): void;
+    protected onAllGroupsShown(on: boolean): void;
+    protected get canImportGroups(): boolean;
+    /** '+': a CSV/TSV of `cell_id` and group, named after the file. */
+    protected onImportGroupsFile(input: HTMLInputElement): Promise<void>;
+    protected trackByLabel: (_i: number, row: {
+        label: string;
+    }) => string;
+    private refreshVariants;
+    private refreshGroups;
+    /** Apply an async result inside the zone and re-render this OnPush panel. */
+    private apply;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialGroupsPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialGroupsPanelComponent, "spatial-groups-panel", never, { "controls": { "alias": "controls"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "view": { "alias": "view"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/spatial-controls/spatial-key/spatial-key.component.d.ts

@@ -0,0 +1,66 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import type { ISpatialControls } from '../../contracts/visualizer.contract';
+import type { SpatialDataset } from '../../contracts/spatial-dataset.contract';
+import { ColormapNode, ColormapValue, SpatialViewState } from '../../contracts/display-types';
+import type { SpatialLegendEntry } from './spatial-key.model';
+import * as i0 from "@angular/core";
+/**
+ * The key for the active colouring: its name, a description when the column is derived,
+ * and either a categorical legend whose rows select their category or a continuous colour
+ * bar with the colormap picker that drives it.
+ *
+ * Presentational over {@link SpatialKeyModel}, which the dialog keeps (the rest of the
+ * panel needs to know whether the colouring is categorical even while the key is not on
+ * screen). Writes only the continuous colormap, through `controls.setViewState`; a legend
+ * click goes up as {@link categoryClicked}, because the selection is the dialog's.
+ */
+export declare class SpatialKeyComponent implements OnChanges {
+    /** The spatial controls this panel reads and writes through; null without a `SPATIAL_DATA_PORT`. */
+    controls: ISpatialControls | null;
+    /** The dataset on offer, or null. */
+    dataset: SpatialDataset | null;
+    /** The current spatial view state: what is drawn, and how. */
+    view: SpatialViewState;
+    /** The categorical legend, or null for a continuous (or no) colouring. */
+    legend: SpatialLegendEntry[] | null;
+    /** The continuous colour bar's CSS gradient, or null. */
+    colorBarCss: string | null;
+    /** The legend row whose category is selected, for highlighting. */
+    selectedCategory: number | null;
+    /**
+     * Colormap tree for the continuous colour scale: the library's own `COLORMAP_OPTIONS`,
+     * shown with the same swatches the image's colormap picker uses — choosing a gradient
+     * is a visual decision, so a list of names would be the wrong control.
+     */
+    colormapOptions: ColormapNode[];
+    /** A legend row was clicked: select that category (or clear it, when it is selected). */
+    readonly categoryClicked: EventEmitter<number>;
+    /** The node currently picked from {@link colormapOptions}. */
+    protected selectedColormapNode: ColormapNode | null;
+    /** Label for the current colouring, for the key's heading. */
+    protected colorByLabel: string;
+    /**
+     * Description of the active column, when it has one. Surfaced because a DERIVED column
+     * (k-means clusters, QC totals computed at conversion) must not read as though it came
+     * with the data.
+     */
+    protected activeDescription: string | null;
+    ngOnChanges(): void;
+    /** True when the active colouring is a categorical column. */
+    protected get isCategorical(): boolean;
+    /** Whether the colour bar applies: there is a colouring, and it is not categorical. */
+    protected get isContinuous(): boolean;
+    /**
+     * The continuous colour scale's colormap. Clearing it goes back to following the
+     * image's, which is the default.
+     */
+    /** Keeps the legend rows across a refresh of the same categories (one per category). */
+    protected readonly trackByLabel: (_: number, entry: SpatialLegendEntry) => string;
+    protected onContinuousColormap(node: ColormapNode | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialKeyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialKeyComponent, "spatial-key", never, { "controls": { "alias": "controls"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "view": { "alias": "view"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "colorBarCss": { "alias": "colorBarCss"; "required": false; }; "selectedCategory": { "alias": "selectedCategory"; "required": false; }; "colormapOptions": { "alias": "colormapOptions"; "required": false; }; }, { "categoryClicked": "categoryClicked"; }, never, never, true, never>;
+}
+/** Label for `view`'s colouring, for the key's heading. */
+export declare function colorByLabel(view: Pick<SpatialViewState, 'colorBy'>): string;
+/** The tree node holding a colormap value, so the picker shows what is in use. */
+export declare function colormapNodeFor(options: readonly ColormapNode[], value: ColormapValue | null): ColormapNode | null;

package/lib/spatial-controls/spatial-key/spatial-key.model.d.ts

@@ -0,0 +1,33 @@
+import type { ISpatialControls } from '../../contracts/visualizer.contract';
+import type { SpatialDataset } from '../../contracts/spatial-dataset.contract';
+import type { ColormapNode, SpatialViewState } from '../../contracts/display-types';
+/** One legend row for a categorical colouring. */
+export interface SpatialLegendEntry {
+    label: string;
+    color: string;
+}
+/**
+ * The key for the active colouring: a categorical legend, or a continuous colour bar.
+ *
+ * Built with the SAME functions the renderer uses (`categoryColors` → the renderer's
+ * resolved category colours, `spatialContinuousLut`), so the key cannot drift from what is
+ * on screen. Kept by the dialog rather than by `<spatial-key>`: whether the colouring is
+ * categorical decides which knobs the rest of the panel offers, whether or not the key
+ * itself is on screen.
+ */
+export declare class SpatialKeyModel {
+    private readonly run;
+    /** Categorical key, or null when the active colouring is continuous (or none). */
+    legend: SpatialLegendEntry[] | null;
+    /** CSS gradient for a continuous colouring, or null when categorical (or none). */
+    colorBarCss: string | null;
+    /** Latest wins: a slower earlier column would paint its palette into the legend for the
+     *  column now selected. */
+    private readonly load;
+    /** @param run where async results are applied — the owner's `NgZone.run`. */
+    constructor(run?: (fn: () => void) => void);
+    /** True when the active colouring is a categorical column. */
+    get isCategorical(): boolean;
+    /** Rebuild the legend or colour bar for `view`'s colouring. */
+    refresh(controls: ISpatialControls | null, dataset: SpatialDataset | null, view: Pick<SpatialViewState, 'colorBy' | 'continuousColormap'>, colormap: ColormapNode | null, reverse: boolean): Promise<void>;
+}

package/lib/spatial-controls/spatial-marker-genes-form/spatial-marker-genes-form.component.d.ts

@@ -0,0 +1,64 @@
+import { ChangeDetectorRef, EventEmitter, NgZone, OnChanges, SimpleChanges } from '@angular/core';
+import type { ISpatialControls } from '../../contracts/visualizer.contract';
+import type { SpatialDataset } from '../../contracts/spatial-dataset.contract';
+import { SpatialViewState } from '../../contracts/display-types';
+import { PanelOption } from '../../spatial/spatial-panel-model';
+import * as i0 from "@angular/core";
+/**
+ * "Add marker genes of clusters": pick a grouping, how many genes per cluster and which
+ * clusters, and each picked cluster's top marker genes are added as a gene group named
+ * after it — and selected, coloured by cluster.
+ *
+ * Shown while {@link open}; it closes itself (through {@link openChange}) once the genes
+ * are added. Writes only through `controls.setViewState`.
+ */
+export declare class SpatialMarkerGenesFormComponent implements OnChanges {
+    private readonly zone;
+    private readonly cdr;
+    /** The spatial controls this panel reads and writes through; null without a `SPATIAL_DATA_PORT`. */
+    controls: ISpatialControls | null;
+    /** The dataset on offer, or null. */
+    dataset: SpatialDataset | null;
+    /** The current spatial view state: what is drawn, and how. */
+    view: SpatialViewState;
+    /** Whether the form is shown. Opening it picks the cells' grouping and every cluster. */
+    open: boolean;
+    /** Asks to open or close it; two-way with `open`. */
+    readonly openChange: EventEmitter<boolean>;
+    protected markerColumn: string | null;
+    protected markerPerGroup: number;
+    protected readonly markerPerGroupOptions: {
+        label: string;
+        value: number;
+    }[];
+    protected markerClusters: string[];
+    protected markerClusterOptions: PanelOption<string>[];
+    protected markerLoading: boolean;
+    protected markerError: string | null;
+    /**
+     * Every categorical column but the segmentation method, which says nothing about genes.
+     * Rebuilt with the dataset, never per change-detection pass: a fresh array per pass makes
+     * PrimeNG re-render the options, and an option re-rendered under the pointer swallows
+     * the click.
+     */
+    protected markerColumnOptions: PanelOption<string>[];
+    constructor(zone: NgZone, cdr: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    protected onMarkerColumn(column: string): void;
+    protected close(): void;
+    /**
+     * Add each picked cluster's top marker genes as a gene group named after it, and select
+     * them. A gene that marks several clusters goes to the one it is most specific to, so the
+     * tree lists it once.
+     */
+    protected addMarkerGenes(): Promise<void>;
+    /** On opening: the cells' grouping (or the last column picked, while it still exists),
+     *  every one of its clusters, and no stale error. */
+    private prepare;
+    /** The clusters of the chosen column, all picked to start with. */
+    private refreshMarkerClusters;
+    /** Apply an async result inside the zone and re-render this OnPush form. */
+    private apply;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialMarkerGenesFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialMarkerGenesFormComponent, "spatial-marker-genes-form", never, { "controls": { "alias": "controls"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "view": { "alias": "view"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, never, true, never>;
+}

package/lib/spatial-controls/spatial-observations-panel/spatial-observations-panel.component.d.ts

@@ -0,0 +1,117 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import type { ISpatialControls } from '../../contracts/visualizer.contract';
+import type { SpatialDataset } from '../../contracts/spatial-dataset.contract';
+import { ColormapNode, SpatialViewState } from '../../contracts/display-types';
+import { SpatialSelectionMask } from '../../spatial/spatial-selection';
+import { PanelOption } from '../../spatial/spatial-panel-model';
+import type { GenePickerModel } from '../spatial-gene-picker';
+import type { SpatialLegendEntry } from '../spatial-key/spatial-key.model';
+import * as i0 from "@angular/core";
+/**
+ * The Observations section — one marker per observation (cell centroid, Visium spot) — and
+ * what else draws them: what colours them (a column or a gene, mutually exclusive, with
+ * the {@link SpatialKeyComponent key}), point size and opacity, the gene map, the 3D scene
+ * (volume, cloud, sections, density volumes) and the continuous-only knobs.
+ *
+ * Renders the section and the sections after it as siblings in the dialog body
+ * (`display: contents`). Writes only through the port: `setViewState`, and the colour
+ * source's own `colorByColumn` / `colorByFeature` / `clearColorBy`.
+ */
+export declare class SpatialObservationsPanelComponent implements OnChanges {
+    /** The spatial controls this panel reads and writes through; null without a `SPATIAL_DATA_PORT`. */
+    controls: ISpatialControls | null;
+    /** The dataset on offer, or null. */
+    dataset: SpatialDataset | null;
+    /** The current spatial view state: what is drawn, and how. */
+    view: SpatialViewState;
+    /** The gene list "Colour by gene" picks from, shared with the other gene dropdowns. */
+    genes: GenePickerModel | null;
+    /** The key's categorical legend, or null — which also decides the continuous knobs. */
+    legend: SpatialLegendEntry[] | null;
+    /** The key's continuous colour bar (a CSS gradient), or null when categorical. */
+    colorBarCss: string | null;
+    /** The current selection (its count, and what is muted). */
+    selection: SpatialSelectionMask;
+    /** The legend row whose category is selected, for highlighting. */
+    selectedCategory: number | null;
+    /** Colormap tree for the continuous colour scale. */
+    colormapOptions: ColormapNode[];
+    /** Set while the 3D cloud is the active mode. */
+    is3d: boolean;
+    /** Whether the Observations section is expanded. */
+    open: boolean;
+    /** Asks to open or close it; two-way with `open`. */
+    readonly openChange: EventEmitter<boolean>;
+    /** A legend row was clicked (see the key). */
+    readonly categoryClicked: EventEmitter<number>;
+    protected readonly clipOptions: PanelOption<[number, number]>[];
+    /** Virtual-scrolled only past this many options (see the cells panel's gene dropdown). */
+    protected readonly geneVirtualScrollFrom = 200;
+    /** Colour-by column choices — "None" plus every column the dataset declares. */
+    protected columnOptions: PanelOption<string | null>[];
+    protected selectedColumn: string | null;
+    protected selectedGene: string | null;
+    /**
+     * The dataset's imaged section positions, or null when its z is continuous rather than
+     * sectioned. Read once per dataset — the scan walks the z of every observation, so it
+     * must not sit in a template getter.
+     */
+    protected sections: Float32Array | null;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Column dropdown. Choosing a column supersedes any gene selection. */
+    protected onColumn(name: string | null): void;
+    /** A gene was picked; it supersedes any column selection. */
+    protected onGene(name: string | null): void;
+    /** Cell outlines on offer, which changes what the circles mean. */
+    protected get hasCells(): boolean;
+    /** True while a selection is active — everything else renders muted. */
+    get hasSelection(): boolean;
+    /** Whether log/clip apply — they are continuous-only knobs. */
+    protected get isContinuous(): boolean;
+    protected onPointScale(value: number | undefined): void;
+    protected onOpacity(value: number | undefined): void;
+    protected onLogScale(on: boolean): void;
+    protected onGeneMap(on: boolean): void;
+    /** 3D: smooth the per-section sheets along z into a continuous volume. */
+    protected onGeneMapVolume(on: boolean): void;
+    /** 3D: restrict the sheets to one imaged section. */
+    protected onGeneMapOneSection(on: boolean): void;
+    protected onGeneMapSection(value: number | undefined): void;
+    protected get geneMapOneSection(): boolean;
+    /** "12 of 53" for the gene map's own section, 1-based like the cloud's. */
+    protected get geneMapSectionLabel(): string;
+    protected onGeneMapSmoothing(value: number | undefined): void;
+    protected onGeneMapOpacity(value: number | undefined): void;
+    /**
+     * What the 3D gene map is currently showing, said plainly — the sheets are a
+     * measurement and the volume is an estimate, and the panel has to be the place
+     * that says which one is on screen.
+     */
+    protected get geneMapVolumeNote(): string;
+    /** True while a gene is the colour source — the only thing a gene map can map. */
+    protected get canMapGene(): boolean;
+    protected onShowVolume(on: boolean): void;
+    protected onVolumeOpacity(value: number | undefined): void;
+    protected onShowPoints(on: boolean): void;
+    /** The "one section at a time" switch: null restores the whole stack. */
+    protected onOneSection(on: boolean): void;
+    protected onPointSection(value: number | undefined): void;
+    /** True while the cloud is restricted to a single section. */
+    protected get oneSection(): boolean;
+    /** Highest section index the slider can reach. */
+    protected get lastSection(): number;
+    /** "12 of 53" — 1-based, because the sections are slides, not array slots. */
+    protected get sectionLabel(): string;
+    /** Whether this dataset has sections to pick from at all. */
+    protected get isSectioned(): boolean;
+    protected onDensityVolume(on: boolean): void;
+    protected onDensitySmoothing(value: number | undefined): void;
+    /** What the density volumes are actually showing, said plainly — an estimate is
+     *  only honest if the reader knows it is one, and which clusters are in view. */
+    protected get densityNote(): string;
+    /** Mirrors the renderer's cap, for the note only. */
+    private static readonly DENSITY_MAX_CLUSTERS;
+    protected onClip(value: [number, number]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialObservationsPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialObservationsPanelComponent, "spatial-observations-panel", never, { "controls": { "alias": "controls"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "view": { "alias": "view"; "required": false; }; "genes": { "alias": "genes"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "colorBarCss": { "alias": "colorBarCss"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "selectedCategory": { "alias": "selectedCategory"; "required": false; }; "colormapOptions": { "alias": "colormapOptions"; "required": false; }; "is3d": { "alias": "is3d"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; "categoryClicked": "categoryClicked"; }, never, never, true, never>;
+}