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

package/lib/spatial/transcript-grouping.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Transcript grouping and marker sizing: how many transcripts one marker stands for at the
+ * current zoom, how big it is drawn, and which colour each gene-tree cluster takes. Pure, so
+ * the budget policy is testable without a viewer.
+ */
+import type { SpatialBounds, SpatialTranscriptTile } from '../contracts/spatial-dataset.contract';
+import { DataRect } from './lod';
+/** Smallest on-screen spacing between groups, in px — below it groups read as noise. */
+export declare const GROUP_MIN_SPACING_PX = 14;
+/**
+ * The bin a selection of genes is grouped into at this zoom, in observation units, or null
+ * to draw every transcript. Bins follow the all-gene pyramid's ladder (`baseBin` × 2^m) so a
+ * gene selection and "all genes" group alike: the finest bin whose markers land at least
+ * `spacingPx` apart on screen. Once the finest bin is that wide, transcripts are drawn as
+ * themselves.
+ */
+export declare function geneBinSize(pxPerUnit: number, baseBin: number, levels?: number, spacingPx?: number): number | null;
+/** The entries of `t` inside `rect` (observation units). */
+export declare function clipTranscripts(t: SpatialTranscriptTile, rect: DataRect): SpatialTranscriptTile;
+/**
+ * Group transcripts into `bin`-wide squares of a grid anchored at the origin (so a pan does
+ * not move them), one entry per (group, square): `groupOf(gene slot)` says which group a gene
+ * is in — its cluster in the gene tree, or itself. Each entry sits at its transcripts'
+ * centroid, weighted by how many each stands for; it takes the gene and the cell holding most
+ * of them, each summed over all its transcripts in the entry. `group[i]` is entry i's group.
+ */
+export declare function groupTranscripts(t: SpatialTranscriptTile, bin: number, groupOf?: (geneSlot: number) => number): {
+    tile: SpatialTranscriptTile;
+    group: Int32Array;
+};
+/**
+ * The colour of each gene-tree cluster of a selection, for colouring transcripts by cluster: a
+ * cluster named like a group of the cells' grouping takes that group's colour (its cells and its
+ * transcripts agree); the others take palette colours in tree order. Clusters are the tree's
+ * groups holding a selected gene, then each ungrouped selected gene on its own. Every gene of a
+ * cluster gets the same colour — the tree's swatches and the markers use this one map.
+ */
+export declare function clusterColorMap(genes: readonly string[], groups: readonly {
+    name: string;
+    genes: readonly string[];
+}[], cellColors: ReadonlyMap<string, string>, palette: readonly string[]): Map<string, string>;
+/** The cluster a selected gene is in: its first gene-tree group holding it, else itself. */
+export declare function clusterOfGene(gene: string, groups: readonly {
+    name: string;
+    genes: readonly string[];
+}[]): string;
+/** Smallest transcript marker, in canvas pixels. */
+export declare const TRANSCRIPT_MIN_PX = 4;
+/** Largest transcript marker, in canvas pixels. */
+export declare const TRANSCRIPT_MAX_PX = 32;
+/**
+ * Physical diameter a single transcript is drawn at, in µm — clearly larger than the
+ * imaged spot (~0.3 µm) so it stays legible, and small enough that neighbouring
+ * molecules inside one cell stay apart.
+ */
+export declare const TRANSCRIPT_PHYSICAL_UM = 1.2;
+/**
+ * Marker diameter in canvas pixels for an entry standing for `weight` transcripts.
+ *
+ * The convention spatial viewers share (deck.gl's `radiusMinPixels`/`radiusMaxPixels`,
+ * Xenium Explorer's transcript size): a PHYSICAL size, clamped to a screen-pixel range.
+ * Zoomed out, markers sit at the minimum and never vanish; zoomed in, they grow with the
+ * tissue instead of shrinking to specks next to cells hundreds of pixels wide. A fixed
+ * screen size does the opposite at high zoom, which is what made transcripts disappear
+ * at pixel-level zoom.
+ *
+ * Aggregates grow with the cube root of their count: area ∝ count would let one dense
+ * aggregate swallow its neighbours, the cube root keeps a 1000-transcript cluster clearly
+ * larger than a 10-transcript one without covering the tile.
+ *
+ * `pxPerMicron` is omitted for data with no known physical unit; the marker is then
+ * screen-sized only.
+ */
+export declare function transcriptMarkerPx(weight: number, scale?: number, pxPerMicron?: number): number;
+/**
+ * How "all genes" is drawn at the current zoom: individual transcripts, a bin level, or nothing.
+ */
+export type AllGenesPlan = {
+    kind: 'individual';
+} | {
+    kind: 'bins';
+    level: number;
+} | {
+    kind: 'none';
+};
+/**
+ * How to draw every transcript in view without exceeding `budget` markers.
+ *
+ * - The transcripts themselves, once the estimated count in view fits the budget.
+ * - Otherwise the finest pyramid level whose bins are at least `minSpacingPx` apart on
+ *   screen and number no more than the budget — groups big enough to read, few enough
+ *   to draw.
+ *
+ * The count in view is estimated from the average density, which over- or under-shoots
+ * locally; the renderer still caps what it draws, so an estimate is enough to choose.
+ */
+export declare function allGenesPlan(o: {
+    rect: DataRect;
+    bounds: SpatialBounds;
+    total: number;
+    pxPerUnit: number;
+    levels: readonly {
+        binSize: number;
+    }[];
+    budget: number;
+    canIndividual: boolean;
+    minSpacingPx?: number;
+}): AllGenesPlan;
+/**
+ * Diameter in px of a group of `count` transcripts in a bin `binPx` wide, where
+ * `refCount` is a typical busy bin in view (its 95th percentile).
+ *
+ * Area grows with the count — a bin with a quarter of the transcripts gets half the
+ * diameter — between a third of the bin (so a sparse bin is still visible) and a little
+ * over the full bin (so dense neighbours just touch rather than pile up).
+ */
+export declare function groupedMarkerPx(count: number, refCount: number, binPx: number, scale?: number): number;
+/** The `p` quantile (0..1) of a count vector — a sample of it for large vectors. */
+export declare function quantileOf(values: ArrayLike<number>, p: number): number;

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

@@ -0,0 +1,64 @@
+import { EventEmitter, 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 type { GenePickerModel } from '../spatial-gene-picker';
+import * as i0 from "@angular/core";
+/**
+ * The Cells section, as Xenium Explorer's: the outlines' on/off switch, which boundary set
+ * is drawn, how cells are coloured (with the gene, the colour, or the colour bar that
+ * goes with it), the {@link SpatialGroupsPanelComponent groups}, and how cells are drawn.
+ *
+ * Writes only through `controls.setViewState`.
+ */
+export declare class SpatialCellsPanelComponent 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 the "Gene Expression" colouring picks from, shared with the other
+     *  gene dropdowns. */
+    genes: GenePickerModel | null;
+    /** The observations' continuous colour bar, shown for the gene colouring while it has one. */
+    colorBarCss: string | null;
+    /** Whether the section is expanded. */
+    open: boolean;
+    /** Asks to open or close it; two-way with `open`. */
+    readonly openChange: EventEmitter<boolean>;
+    /** Virtual-scrolled only past this many options: the scroller earns its complexity for
+     *  a few thousand names, and for eight it adds only overhead — a virtual viewport that
+     *  short swallows the clicks it is meant to forward. */
+    protected readonly geneVirtualScrollFrom = 200;
+    protected readonly cellDrawOptions: PanelOption<SpatialViewState['cellDraw']>[];
+    /**
+     * Option lists for the cell controls. Built once per dataset rather than in getters: a
+     * getter returns a fresh array on every change-detection pass, and PrimeNG re-renders
+     * its buttons whenever the array identity changes — which made them impossible to click.
+     */
+    protected cellSetOptions: PanelOption<string>[];
+    /** Cell colour modes on offer (Xenium Explorer's "Cell Color"). */
+    protected cellColorOptions: PanelOption<SpatialViewState['cellColorMode']>[];
+    /** The density colour bar, rebuilt only when its colormap changes (a 256-entry LUT). */
+    protected densityColorBarCss: string;
+    private densityBarFor;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Whether outlines are on — the explicit choice, or automatically for data that has them. */
+    protected get cellsOn(): boolean;
+    /** The boundary set drawn: the view's choice, else the dataset's default, else its first. */
+    protected get activeCellSet(): string | null;
+    /** Fill opacity as a 0–100 number, for the box beside the slider. */
+    protected get cellOpacityPercent(): number;
+    protected onShowCells(on: boolean): void;
+    protected onCellSet(set: string): void;
+    protected onCellDraw(draw: SpatialViewState['cellDraw']): void;
+    protected onCellOpacity(value: number | undefined): void;
+    protected onCellOpacityPercent(v: number | null): void;
+    protected onCellColorMode(mode: SpatialViewState['cellColorMode']): void;
+    protected onCellColorGene(gene: string | null): void;
+    protected onCellSingleColor(hex: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialCellsPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialCellsPanelComponent, "spatial-cells-panel", never, { "controls": { "alias": "controls"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "view": { "alias": "view"; "required": false; }; "genes": { "alias": "genes"; "required": false; }; "colorBarCss": { "alias": "colorBarCss"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, never, true, never>;
+}

package/lib/spatial-controls/spatial-charts/chart-data-model.d.ts

@@ -0,0 +1,153 @@
+import type { ISpatialControls } from '../../contracts/visualizer.contract';
+import type { SpatialDataset, SpatialEmbedding, SpatialEmbeddingMeta } from '../../contracts/spatial-dataset.contract';
+import type { SpatialColorBy } from '../../contracts/display-types';
+import type { OmicsGrouping } from '../../implementations/plotly/omics-trace-builders';
+/** What a colour-source load came to. */
+export type ValueLoad = 
+/** Nothing to chart: no colour source, or no port. */
+'none'
+/** A categorical column: its counts per category are loaded. */
+ | 'categorical'
+/** A gene or numeric column: its values are loaded. */
+ | 'continuous'
+/** The load failed; {@link ChartDataModel.notice} says why. */
+ | 'failed'
+/** A newer load (or a dataset switch) overtook this one: nothing to do. */
+ | 'superseded';
+/** What the renderer draws from: everything loaded for the current dataset. */
+export interface ChartData {
+    /** The colour source's values, when it is continuous. */
+    values: Float32Array | null;
+    /** The colour source's categories, when it is a categorical column. */
+    categorical: OmicsGrouping | null;
+    /** The grouping column the violin, box and heatmap split by. */
+    grouping: OmicsGrouping | null;
+    groupBy: string | null;
+    /** The heatmap's genes that have their vectors, in row order. */
+    heatmapRows: {
+        name: string;
+        values: Float32Array;
+    }[];
+    /** The drawn embedding's coordinates, once loaded. */
+    embeddingCoords: SpatialEmbedding | null;
+}
+/**
+ * The data the spatial charts draw, and its loading: the colour source's vector (or its
+ * categories), the grouping column, the heatmap's gene vectors, and the embedding's
+ * coordinates.
+ *
+ * Each load has its OWN {@link Supersede}: on one shared counter a redraw for a selection
+ * change dropped a pending colour-source load (SPATIAL-2), and a busy flag per load, since
+ * a shared one was left set by whichever load lost its race. A dataset switch
+ * ({@link onDatasetChanged}) cancels all of them together and drops every vector, because
+ * each is indexed by the previous dataset's observations (SPATIAL-1).
+ *
+ * Plain class: the component asks it to load, then renders {@link snapshot}.
+ */
+export declare class ChartDataModel {
+    /** Categorical column the violin/box (and heatmap) split by; null = one trace for all. */
+    groupBy: string | null;
+    groupOptions: {
+        label: string;
+        value: string | null;
+    }[];
+    /**
+     * Genes the heatmap's rows are. Local rather than in `SpatialViewState`, as the chart
+     * kind is: this is what the panel is charting, not what the map is drawing.
+     */
+    heatmapGenes: string[];
+    geneOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Embeddings to offer, and which of them is drawn. */
+    embeddings: SpatialEmbeddingMeta[];
+    embedding: SpatialEmbeddingMeta | null;
+    embeddingCoords: SpatialEmbedding | null;
+    /** Set when something cannot be charted, for an inline hint. */
+    notice: string | null;
+    private values;
+    /** Set instead of `values` when the colour source is a categorical column: its
+     *  distribution is counts per category, not a histogram of its codes. */
+    private categorical;
+    private grouping;
+    /** Every gene the dataset inlined. `geneOptions` is only ever the best few hundred of
+     *  these — see `gene-search.ts` for why a whole-transcriptome list cannot be handed to
+     *  the control whole. */
+    private geneNames;
+    /** What is typed in the picker's filter box, so the options can be rebuilt when the
+     *  selection changes without losing the query. */
+    private geneQuery;
+    /** Fetched vectors by gene name, so adding a fourth gene does not refetch the first
+     *  three — each is a full per-observation Float32Array. */
+    private readonly geneCache;
+    private valueBusy;
+    private heatmapBusy;
+    private embeddingBusy;
+    /** Guards the colour-source fetch: a fast colour-source change can resolve out of order,
+     *  and a stale vector would be charted against the new label. */
+    private readonly valueLoad;
+    /** The same for the grouping, which the user can change as fast. */
+    private readonly groupLoad;
+    private readonly heatmapLoad;
+    private readonly embeddingLoad;
+    /** The dataset the loaded vectors belong to; `undefined` before the first. */
+    private datasetId;
+    /** A load is in flight. */
+    get busy(): boolean;
+    /** Whether the colour source is a categorical column (with its categories loaded). */
+    get isCategorical(): boolean;
+    /** Whether a grouping column's categories are loaded. */
+    get hasGrouping(): boolean;
+    /** What the renderer draws from. */
+    snapshot(): ChartData;
+    /**
+     * A dataset emission: its grouping columns, gene names and the embeddings to offer.
+     *
+     * @returns true when this is a SWITCH from another dataset. Every vector loaded so far is
+     *   then dropped and every load still running for the old dataset cancelled; the caller
+     *   must reload the colour source (and the grouping), because a port may go straight from
+     *   one dataset to the next with a colour source of the same name, so the view need not
+     *   re-emit.
+     */
+    onDatasetChanged(dataset: SpatialDataset | null, categoricalColumns: readonly string[], embeddings: SpatialEmbeddingMeta[]): boolean;
+    /** Fetch the colour source's vector — or, for a categorical column, its categories. */
+    loadValues(controls: ISpatialControls | null, source: SpatialColorBy | null): Promise<ValueLoad>;
+    /**
+     * Group by `name` (null for none), fetching its categories.
+     *
+     * @returns false when a later choice overtook this one — sequenced, because picking A
+     *   then B with a slower A would otherwise chart A's categories under a dropdown that
+     *   says B. A failure falls back to no grouping.
+     */
+    loadGrouping(controls: ISpatialControls | null, name: string | null): Promise<boolean>;
+    /** The heatmap's rows. Chosen genes stay among the options, or the control cannot label
+     *  its chips. */
+    setHeatmapGenes(names: string[] | null): void;
+    /** The gene picker's filter box changed: search the resident names, show the best. */
+    filterGenes(query: string | null): void;
+    /**
+     * Fetch any gene the heatmap needs and does not already hold.
+     *
+     * Sequenced: each vector is a separate request, and a slower one must not paint rows
+     * for a gene list the user has already moved on from — nor land in the cache of a
+     * dataset it was not fetched for.
+     */
+    loadHeatmapGenes(controls: ISpatialControls | null): Promise<void>;
+    /** Draw `name` next, when the dataset offers it. @returns whether the choice changed. */
+    selectEmbedding(name: string): boolean;
+    /**
+     * The coordinates for `meta`: kept when already loaded, else fetched — sequenced, as a
+     * slower round-trip must not paint over an embedding the user has already moved on from.
+     *
+     * @returns whether they are ready to draw ('failed' has set {@link notice}).
+     */
+    loadEmbedding(getEmbedding: (name: string) => Promise<SpatialEmbedding>, meta: SpatialEmbeddingMeta): Promise<'ready' | 'failed' | 'superseded'>;
+    /**
+     * Supersede any embedding load in flight without starting one — for a draw that needs
+     * no fetch (computed here, or still to be computed), which a slower fetch must not
+     * overwrite.
+     */
+    supersedeEmbeddingLoad(): void;
+    private refreshGeneOptions;
+}

package/lib/spatial-controls/spatial-charts/chart-help.d.ts

@@ -0,0 +1,69 @@
+import type { SpatialEmbeddingMeta } from '../../contracts/spatial-dataset.contract';
+import type { OmicsChartKind } from '../../implementations/plotly/omics-trace-builders';
+/**
+ * The spatial charts' kind catalogue and the prose that explains each chart: pure
+ * functions of what is charted, so none of the ~150 lines of text sit in the component and
+ * each sentence is testable on its own.
+ */
+/** A chart kind as the kind picker offers it. */
+export interface ChartKindOption {
+    label: string;
+    value: OmicsChartKind;
+}
+/** What a continuous value can be drawn as. */
+export declare const CONTINUOUS_KINDS: readonly ChartKindOption[];
+/** What a categorical column can be drawn as: a category code is a label, not a magnitude,
+ *  so a histogram of it would be meaningless — what it has is a frequency distribution. */
+export declare const CATEGORICAL_KINDS: readonly ChartKindOption[];
+/** Available whatever the map is coloured by: the heatmap's subject is a GENE LIST crossed
+ *  with a grouping, not the active colour source. */
+export declare const ALWAYS_KINDS: readonly ChartKindOption[];
+/**
+ * Offered only when the dataset publishes an embedding to draw. Labelled for what it is
+ * rather than for one instance of it: this view draws whatever embedding the dataset
+ * publishes — a UMAP, a PCA, a t-SNE — and calling the tab "UMAP" while it showed a PCA
+ * would be a lie the picker beneath it immediately contradicts.
+ */
+export declare const EMBEDDING_KINDS: readonly ChartKindOption[];
+/**
+ * The kinds the active subject can be drawn as. An embedding is a property of the DATASET,
+ * not of the colour source, so it is offered whenever one is published and never
+ * otherwise — a tab that draws nothing is worse than an absent one.
+ */
+export declare function chartKindOptions(categorical: boolean, hasEmbeddings: boolean): ChartKindOption[];
+/**
+ * What the chart on screen actually shows, and what it cannot be read for.
+ *
+ * Shown on hover from a `?` beside the tabs. Each of these plots answers a different
+ * question and two of them are routinely over-read — a UMAP's distances and a heatmap's
+ * unscaled colours — so the caveat is part of the explanation rather than a footnote.
+ *
+ * HTML, because the tooltip renders with `[escape]="false"`: a paragraph and a caveat read
+ * as two thoughts, and a single run-on line is skipped rather than read.
+ */
+export declare function kindHelp(kind: OmicsChartKind, embedding: Pick<SpatialEmbeddingMeta, 'name' | 'label'> | null): string;
+/**
+ * What the embedding on screen is, and how far its geometry can be trusted.
+ *
+ * Per METHOD, because that is the part people get wrong: a PCA's axes are ordered and
+ * measurable while a UMAP's are neither, and the same picture read the two ways supports
+ * opposite conclusions.
+ */
+export declare function embeddingHelp(embedding: Pick<SpatialEmbeddingMeta, 'name' | 'label'> | null): string;
+/** What the embedding view is showing, said plainly. */
+export declare function embeddingNote(meta: Pick<SpatialEmbeddingMeta, 'name' | 'label' | 'derived' | 'params'> | null, coloured: boolean, selectionCount: number): string;
+/** What the heatmap is showing, as {@link heatmapNote} says it. */
+export interface HeatmapNoteState {
+    geneCount: number;
+    selectionCount: number;
+    zScore: boolean;
+    /** Columns the cap dropped from the last render. */
+    hidden: number;
+    groupBy: string | null;
+    /** The grouped view's column cap. */
+    maxColumns: number;
+    /** Up to this many selected cells, each is its own column. */
+    cellColumns: number;
+}
+/** What the heatmap is currently showing, said plainly. */
+export declare function heatmapNote(s: HeatmapNoteState): string;

package/lib/spatial-controls/spatial-charts/plotly-chart-host.d.ts

@@ -0,0 +1,98 @@
+/** Plotly config: a static-ish analysis chart, not an editable figure. */
+export declare const CHART_CONFIG: {
+    displaylogo: boolean;
+    responsive: boolean;
+    modeBarButtonsToRemove: string[];
+};
+/**
+ * Config for the embedding, which unlike the distributions is a plot you SELECT in.
+ *
+ * The lasso and box-select are kept — drawing round a cluster is how a population gets
+ * picked out of a UMAP — and the wheel zooms, because exploring an embedding means zooming
+ * into a cluster and reaching for a toolbar button to do it breaks that.
+ */
+export declare const EMBEDDING_CONFIG: {
+    displaylogo: boolean;
+    responsive: boolean;
+    scrollZoom: boolean;
+    modeBarButtonsToRemove: string[];
+};
+/** What a lasso or box selection in a plot reports. */
+export interface PlotSelectionHandlers {
+    /** The observation indices selected (empty for a selection that caught nothing). */
+    selected(indices: number[]): void;
+    /** The modebar's deselect, or a plain click on empty space. */
+    deselected(): void;
+}
+/** The view the user has set up on a live plot: a 3D camera, or a zoomed 2D range. */
+export interface LivePlotView {
+    camera?: unknown;
+    ranges?: {
+        x: unknown;
+        y: unknown;
+    };
+}
+/**
+ * Plotly I/O for the spatial charts, keyed by the id of the div drawn into: drawing,
+ * purging, re-fitting to the container, binding a selection, and reading back the view
+ * the user has set up. The only place the charts import Plotly.
+ *
+ * Remembers whether the last drawn layout fixed its own height, because re-fitting depends
+ * on it (see {@link refit}).
+ */
+export declare class PlotlyChartHost {
+    /**
+     * The height the drawn layout asked for, or null where it autosizes. The counts and
+     * heatmap layouts size their height to their content — one band per bar, per gene row —
+     * while the distribution kinds want to fill whatever height they are given.
+     */
+    private drawnHeight;
+    /** Whether the plot on screen fixed its own height. */
+    get hasFixedHeight(): boolean;
+    /**
+     * Draw into `div`, remembering whether this layout fixed its own height.
+     *
+     * The layout builders return `unknown` on purpose — they keep Plotly's layout types out
+     * of the pure module — so the height is read back by narrowing rather than declared.
+     * `height` is Plotly's own key, not ours.
+     */
+    draw(div: string, traces: unknown, layout: unknown, config?: unknown): Promise<void>;
+    /** Purge `div`, freeing its plot (and WebGL context); a div with no plot is fine. */
+    purge(div: string): void;
+    /**
+     * Re-fit whatever is plotted in `div` to its container.
+     *
+     * Plotly does not notice a container resize on its own — its `responsive` option listens
+     * for WINDOW resizes only. And `autosize` takes BOTH dimensions from the container, which
+     * is right only where the layout did not fix its own height. Measured: autosizing a layout
+     * with an explicit height of 500 replaced it with the container's 400. The counts and
+     * heatmap layouts size themselves to their row count, so for them the width is set ALONE
+     * and the height left to stand.
+     */
+    refit(div: string): void;
+    /**
+     * Turn a lasso or box selection in `div` into observation indices.
+     *
+     * Bound after each draw, and the previous listeners removed first: `Plotly.react`
+     * preserves handlers, so re-binding without removing would fire the selection once per
+     * redraw the plot had ever had.
+     */
+    bindSelection(div: string, handlers: PlotSelectionHandlers): void;
+    /**
+     * Drop the selection handlers from a div another chart is about to use.
+     *
+     * `plotly_deselect` fires on a plain click in ANY Plotly chart, so handlers left bound
+     * for an embedding would make the first click on a bar clear the map's selection.
+     */
+    unbindSelection(div: string): void;
+    /**
+     * The view the user has set up on the live plot in `div`, to carry across a redraw.
+     *
+     * `Plotly.react` resets a 3D scene camera and any zoomed 2D range unless the layout
+     * carries them, so selecting a category or recolouring would throw away an orientation
+     * that took work to find. Null where nothing is drawn yet, or a 2D plot is not zoomed:
+     * passing an autoranged range back would freeze the axes and stop the plot re-fitting
+     * when the data changes.
+     */
+    liveView(div: string): LivePlotView | null;
+}

package/lib/spatial-controls/spatial-charts/spatial-chart-window/spatial-chart-window.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * The detached chart window: a non-modal, draggable, resizable dialog beside the
+ * spatial-omics dialog, holding the plot div (by {@link divId}) and whatever is projected
+ * under it (the chart's hints).
+ *
+ * Presentational: the charts panel draws into the div, and decides what closing,
+ * showing and resizing the window mean.
+ */
+export declare class SpatialChartWindowComponent {
+    /** The window's header — what it is showing. */
+    title: string;
+    /** The id of the div the chart is drawn into. */
+    divId: string;
+    /** Whether the drawn layout fixed its own height (and so the window scrolls). */
+    fixedHeight: boolean;
+    /** The window was closed: put the chart back. */
+    readonly closed: EventEmitter<void>;
+    /** The window is up and its div exists: the chart can be drawn into it. */
+    readonly shown: EventEmitter<void>;
+    /** The window was resized: re-fit the chart. */
+    readonly resizeEnd: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialChartWindowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialChartWindowComponent, "spatial-chart-window", never, { "title": { "alias": "title"; "required": false; }; "divId": { "alias": "divId"; "required": false; }; "fixedHeight": { "alias": "fixedHeight"; "required": false; }; }, { "closed": "closed"; "shown": "shown"; "resizeEnd": "resizeEnd"; }, never, ["*"], true, never>;
+}