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

package/esm2022/lib/spatial-controls/spatial-charts/chart-help.mjs

@@ -0,0 +1,145 @@
+/** What a continuous value can be drawn as. */
+export const CONTINUOUS_KINDS = [
+    { label: 'Histogram', value: 'histogram' },
+    { label: 'Violin', value: 'violin' },
+    { label: 'Box', value: 'box' },
+];
+/** 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 const CATEGORICAL_KINDS = [{ label: 'Counts', value: 'counts' }];
+/** 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 const ALWAYS_KINDS = [{ label: 'Heatmap', value: 'heatmap' }];
+/**
+ * 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 const EMBEDDING_KINDS = [{ label: 'Embedding', value: 'embedding' }];
+/**
+ * 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 function chartKindOptions(categorical, hasEmbeddings) {
+    return [
+        ...(categorical ? CATEGORICAL_KINDS : CONTINUOUS_KINDS),
+        ...ALWAYS_KINDS,
+        ...(hasEmbeddings ? EMBEDDING_KINDS : []),
+    ];
+}
+/**
+ * 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 function kindHelp(kind, embedding) {
+    switch (kind) {
+        case 'counts':
+            return ('<b>Counts</b> — how many observations fall in each category of the column ' +
+                'the map is coloured by, largest first.<br><br>A category code is a label, not ' +
+                'a magnitude, so a frequency is the only distribution it has: there is no ' +
+                'histogram of a cell type.');
+        case 'histogram':
+            return ('<b>Histogram</b> — how the active value is distributed over all ' +
+                'observations.<br><br>With a selection, it is overlaid on the full ' +
+                'distribution rather than replacing it, so you can see where the selected ' +
+                'cells sit within the whole.');
+        case 'violin':
+            return ("<b>Violin</b> — the active value's distribution within each category of " +
+                'the grouping column, drawn as a smoothed density.<br><br>Shows shape a box ' +
+                'plot hides: two groups with the same median can be one peak or two.');
+        case 'box':
+            return ('<b>Box</b> — median, quartiles and range of the active value within each ' +
+                'category of the grouping column.<br><br>Compact and comparable across many ' +
+                'groups, at the cost of hiding whether a group is bimodal.');
+        case 'heatmap':
+            return ('<b>Heatmap</b> — mean expression of each picked gene within each group: ' +
+                'genes down, groups across.<br><br>Each gene is <b>z-scored across the ' +
+                'groups</b> by default, so a colour says "above or below this gene\'s own ' +
+                'average", not "highly expressed". Without that one loud gene saturates the ' +
+                'scale and the rest of the panel reads as blank. Turning it off compares ' +
+                'genes on their raw scale instead.');
+        case 'embedding':
+            return embeddingHelp(embedding);
+        default:
+            return '';
+    }
+}
+/**
+ * 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 function embeddingHelp(embedding) {
+    const shared = '<br><br>Every cell is in all views at once: lasso a group here and ' +
+        'those cells light up on the tissue, because both read the same selection.';
+    const name = (embedding?.label ?? embedding?.name ?? '').toLowerCase();
+    if (name.includes('pca')) {
+        return ('<b>PCA</b> — a <b>linear</b> projection onto the directions of greatest ' +
+            'variance, in order.<br><br>Alone among these, its axes mean something ' +
+            'measurable: each reports the share of total variance it explains, which is why ' +
+            'the labels carry a percentage. Distances are real, and a low percentage tells ' +
+            'you the picture is a thin slice of the variation.' +
+            shared);
+    }
+    if (name.includes('t-sne') || name.includes('tsne')) {
+        return ('<b>t-SNE</b> — cells placed so that close neighbours in expression stay ' +
+            'close.<br><br>Stricter about local neighbourhoods than UMAP and less ' +
+            'trustworthy about anything global: it tends to spread clusters into ' +
+            'evenly-sized islands whose sizes and separations mean little. Read which cells ' +
+            'group together, not how far apart the groups are.' +
+            shared);
+    }
+    return ('<b>UMAP</b> — cells placed so that close neighbours in expression stay ' +
+        'close.<br><br>The axes are arbitrary: unordered, unitless, and reproducible only ' +
+        'up to a rotation, which is why they carry no percentage. Read which cells group ' +
+        'together and which groups touch; do not read the distance between distant ' +
+        'clusters, or the direction of an axis.' +
+        shared);
+}
+/** What the embedding view is showing, said plainly. */
+export function embeddingNote(meta, coloured, selectionCount) {
+    if (!meta)
+        return 'This dataset publishes no embedding.';
+    // A derived embedding says so, and says HOW when the parameters are known: a t-SNE or
+    // UMAP at different settings is a different picture of the same cells, so "computed
+    // here" alone leaves a reader unable to reproduce or compare it.
+    const derived = meta.derived
+        ? ` Computed here${meta.params ? ` (${meta.params})` : ''}, not published with the dataset.`
+        : '';
+    const colour = coloured
+        ? ' Coloured to match the map.'
+        : ' Colour the map by a categorical column to colour these points.';
+    const sel = selectionCount > 0 ? ` ${selectionCount.toLocaleString()} selected are highlighted.` : '';
+    return `${meta.label ?? meta.name}.${colour}${sel}${derived}`;
+}
+/** What the heatmap is currently showing, said plainly. */
+export function heatmapNote(s) {
+    if (s.geneCount === 0)
+        return 'Pick one or more genes for the rows.';
+    const perCell = s.selectionCount > 0 && s.selectionCount <= s.cellColumns;
+    if (perCell) {
+        return (`One column per selected cell (${s.selectionCount}). ` +
+            'Mean expression per cell, so the columns are cells rather than classes.');
+    }
+    const scope = s.selectionCount > 0 ? 'the selected cells' : 'all cells';
+    const scaled = s.zScore
+        ? " Each gene is z-scored across the columns, so the colour is above or below that gene's own average."
+        : ' Raw means, so a highly-expressed gene dominates the scale.';
+    // Saying so matters: without it the panel looks like the whole column.
+    const capped = s.hidden > 0
+        ? ` Showing the ${s.maxColumns} strongest of ${s.maxColumns + s.hidden}, ` +
+            'ranked by the largest value any picked gene reaches.'
+        : '';
+    return `Mean expression of each gene within each ${s.groupBy ?? 'group'}, over ${scope}.${scaled}${capped}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-help.js","sourceRoot":"","sources":["../../../../../src/lib/spatial-controls/spatial-charts/chart-help.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SpatialEmbeddingMeta } from '../../contracts/spatial-dataset.contract';\nimport type { OmicsChartKind } from '../../implementations/plotly/omics-trace-builders';\n\n/**\n * The spatial charts' kind catalogue and the prose that explains each chart: pure\n * functions of what is charted, so none of the ~150 lines of text sit in the component and\n * each sentence is testable on its own.\n */\n\n/** A chart kind as the kind picker offers it. */\nexport interface ChartKindOption {\n  label: string;\n  value: OmicsChartKind;\n}\n\n/** What a continuous value can be drawn as. */\nexport const CONTINUOUS_KINDS: readonly ChartKindOption[] = [\n  { label: 'Histogram', value: 'histogram' },\n  { label: 'Violin', value: 'violin' },\n  { label: 'Box', value: 'box' },\n];\n\n/** What a categorical column can be drawn as: a category code is a label, not a magnitude,\n *  so a histogram of it would be meaningless — what it has is a frequency distribution. */\nexport const CATEGORICAL_KINDS: readonly ChartKindOption[] = [{ label: 'Counts', value: 'counts' }];\n\n/** Available whatever the map is coloured by: the heatmap's subject is a GENE LIST crossed\n *  with a grouping, not the active colour source. */\nexport const ALWAYS_KINDS: readonly ChartKindOption[] = [{ label: 'Heatmap', value: 'heatmap' }];\n\n/**\n * Offered only when the dataset publishes an embedding to draw. Labelled for what it is\n * rather than for one instance of it: this view draws whatever embedding the dataset\n * publishes — a UMAP, a PCA, a t-SNE — and calling the tab \"UMAP\" while it showed a PCA\n * would be a lie the picker beneath it immediately contradicts.\n */\nexport const EMBEDDING_KINDS: readonly ChartKindOption[] = [{ label: 'Embedding', value: 'embedding' }];\n\n/**\n * The kinds the active subject can be drawn as. An embedding is a property of the DATASET,\n * not of the colour source, so it is offered whenever one is published and never\n * otherwise — a tab that draws nothing is worse than an absent one.\n */\nexport function chartKindOptions(categorical: boolean, hasEmbeddings: boolean): ChartKindOption[] {\n  return [\n    ...(categorical ? CATEGORICAL_KINDS : CONTINUOUS_KINDS),\n    ...ALWAYS_KINDS,\n    ...(hasEmbeddings ? EMBEDDING_KINDS : []),\n  ];\n}\n\n/**\n * What the chart on screen actually shows, and what it cannot be read for.\n *\n * Shown on hover from a `?` beside the tabs. Each of these plots answers a different\n * question and two of them are routinely over-read — a UMAP's distances and a heatmap's\n * unscaled colours — so the caveat is part of the explanation rather than a footnote.\n *\n * HTML, because the tooltip renders with `[escape]=\"false\"`: a paragraph and a caveat read\n * as two thoughts, and a single run-on line is skipped rather than read.\n */\nexport function kindHelp(\n  kind: OmicsChartKind,\n  embedding: Pick<SpatialEmbeddingMeta, 'name' | 'label'> | null,\n): string {\n  switch (kind) {\n    case 'counts':\n      return (\n        '<b>Counts</b> — how many observations fall in each category of the column ' +\n        'the map is coloured by, largest first.<br><br>A category code is a label, not ' +\n        'a magnitude, so a frequency is the only distribution it has: there is no ' +\n        'histogram of a cell type.'\n      );\n    case 'histogram':\n      return (\n        '<b>Histogram</b> — how the active value is distributed over all ' +\n        'observations.<br><br>With a selection, it is overlaid on the full ' +\n        'distribution rather than replacing it, so you can see where the selected ' +\n        'cells sit within the whole.'\n      );\n    case 'violin':\n      return (\n        \"<b>Violin</b> — the active value's distribution within each category of \" +\n        'the grouping column, drawn as a smoothed density.<br><br>Shows shape a box ' +\n        'plot hides: two groups with the same median can be one peak or two.'\n      );\n    case 'box':\n      return (\n        '<b>Box</b> — median, quartiles and range of the active value within each ' +\n        'category of the grouping column.<br><br>Compact and comparable across many ' +\n        'groups, at the cost of hiding whether a group is bimodal.'\n      );\n    case 'heatmap':\n      return (\n        '<b>Heatmap</b> — mean expression of each picked gene within each group: ' +\n        'genes down, groups across.<br><br>Each gene is <b>z-scored across the ' +\n        'groups</b> by default, so a colour says \"above or below this gene\\'s own ' +\n        'average\", not \"highly expressed\". Without that one loud gene saturates the ' +\n        'scale and the rest of the panel reads as blank. Turning it off compares ' +\n        'genes on their raw scale instead.'\n      );\n    case 'embedding':\n      return embeddingHelp(embedding);\n    default:\n      return '';\n  }\n}\n\n/**\n * What the embedding on screen is, and how far its geometry can be trusted.\n *\n * Per METHOD, because that is the part people get wrong: a PCA's axes are ordered and\n * measurable while a UMAP's are neither, and the same picture read the two ways supports\n * opposite conclusions.\n */\nexport function embeddingHelp(embedding: Pick<SpatialEmbeddingMeta, 'name' | 'label'> | null): string {\n  const shared =\n    '<br><br>Every cell is in all views at once: lasso a group here and ' +\n    'those cells light up on the tissue, because both read the same selection.';\n  const name = (embedding?.label ?? embedding?.name ?? '').toLowerCase();\n  if (name.includes('pca')) {\n    return (\n      '<b>PCA</b> — a <b>linear</b> projection onto the directions of greatest ' +\n      'variance, in order.<br><br>Alone among these, its axes mean something ' +\n      'measurable: each reports the share of total variance it explains, which is why ' +\n      'the labels carry a percentage. Distances are real, and a low percentage tells ' +\n      'you the picture is a thin slice of the variation.' +\n      shared\n    );\n  }\n  if (name.includes('t-sne') || name.includes('tsne')) {\n    return (\n      '<b>t-SNE</b> — cells placed so that close neighbours in expression stay ' +\n      'close.<br><br>Stricter about local neighbourhoods than UMAP and less ' +\n      'trustworthy about anything global: it tends to spread clusters into ' +\n      'evenly-sized islands whose sizes and separations mean little. Read which cells ' +\n      'group together, not how far apart the groups are.' +\n      shared\n    );\n  }\n  return (\n    '<b>UMAP</b> — cells placed so that close neighbours in expression stay ' +\n    'close.<br><br>The axes are arbitrary: unordered, unitless, and reproducible only ' +\n    'up to a rotation, which is why they carry no percentage. Read which cells group ' +\n    'together and which groups touch; do not read the distance between distant ' +\n    'clusters, or the direction of an axis.' +\n    shared\n  );\n}\n\n/** What the embedding view is showing, said plainly. */\nexport function embeddingNote(\n  meta: Pick<SpatialEmbeddingMeta, 'name' | 'label' | 'derived' | 'params'> | null,\n  coloured: boolean,\n  selectionCount: number,\n): string {\n  if (!meta) return 'This dataset publishes no embedding.';\n  // A derived embedding says so, and says HOW when the parameters are known: a t-SNE or\n  // UMAP at different settings is a different picture of the same cells, so \"computed\n  // here\" alone leaves a reader unable to reproduce or compare it.\n  const derived = meta.derived\n    ? ` Computed here${meta.params ? ` (${meta.params})` : ''}, not published with the dataset.`\n    : '';\n  const colour = coloured\n    ? ' Coloured to match the map.'\n    : ' Colour the map by a categorical column to colour these points.';\n  const sel = selectionCount > 0 ? ` ${selectionCount.toLocaleString()} selected are highlighted.` : '';\n  return `${meta.label ?? meta.name}.${colour}${sel}${derived}`;\n}\n\n/** What the heatmap is showing, as {@link heatmapNote} says it. */\nexport interface HeatmapNoteState {\n  geneCount: number;\n  selectionCount: number;\n  zScore: boolean;\n  /** Columns the cap dropped from the last render. */\n  hidden: number;\n  groupBy: string | null;\n  /** The grouped view's column cap. */\n  maxColumns: number;\n  /** Up to this many selected cells, each is its own column. */\n  cellColumns: number;\n}\n\n/** What the heatmap is currently showing, said plainly. */\nexport function heatmapNote(s: HeatmapNoteState): string {\n  if (s.geneCount === 0) return 'Pick one or more genes for the rows.';\n  const perCell = s.selectionCount > 0 && s.selectionCount <= s.cellColumns;\n  if (perCell) {\n    return (\n      `One column per selected cell (${s.selectionCount}). ` +\n      'Mean expression per cell, so the columns are cells rather than classes.'\n    );\n  }\n  const scope = s.selectionCount > 0 ? 'the selected cells' : 'all cells';\n  const scaled = s.zScore\n    ? \" Each gene is z-scored across the columns, so the colour is above or below that gene's own average.\"\n    : ' Raw means, so a highly-expressed gene dominates the scale.';\n  // Saying so matters: without it the panel looks like the whole column.\n  const capped =\n    s.hidden > 0\n      ? ` Showing the ${s.maxColumns} strongest of ${s.maxColumns + s.hidden}, ` +\n        'ranked by the largest value any picked gene reaches.'\n      : '';\n  return `Mean expression of each gene within each ${s.groupBy ?? 'group'}, over ${scope}.${scaled}${capped}`;\n}\n"]}

package/esm2022/lib/spatial-controls/spatial-charts/plotly-chart-host.mjs

@@ -0,0 +1,158 @@
+import * as Plotly from 'plotly.js-dist-min';
+/** Plotly config: a static-ish analysis chart, not an editable figure. */
+export const CHART_CONFIG = {
+    displaylogo: false,
+    responsive: true,
+    modeBarButtonsToRemove: ['lasso2d', 'select2d', 'autoScale2d'],
+};
+/**
+ * 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 const EMBEDDING_CONFIG = {
+    displaylogo: false,
+    responsive: true,
+    scrollZoom: true,
+    modeBarButtonsToRemove: ['autoScale2d'],
+};
+/**
+ * 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 class PlotlyChartHost {
+    constructor() {
+        /**
+         * 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.
+         */
+        this.drawnHeight = null;
+    }
+    /** Whether the plot on screen fixed its own height. */
+    get hasFixedHeight() {
+        return this.drawnHeight !== null;
+    }
+    /**
+     * 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.
+     */
+    async draw(div, traces, layout, config = CHART_CONFIG) {
+        const height = layout?.height;
+        this.drawnHeight = typeof height === 'number' ? height : null;
+        await Plotly.react(div, traces, layout, config);
+    }
+    /** Purge `div`, freeing its plot (and WebGL context); a div with no plot is fine. */
+    purge(div) {
+        try {
+            Plotly.purge(div);
+        }
+        catch {
+            // Nothing plotted there, or the div is already gone.
+        }
+    }
+    /**
+     * 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) {
+        const el = document.getElementById(div);
+        if (!el)
+            return;
+        const width = Math.round(el.clientWidth);
+        // Zero while the section is collapsed or the dialog is closed; relaying out to a zero
+        // box makes Plotly compute a layout it does not recover from.
+        if (width <= 0)
+            return;
+        try {
+            Plotly.relayout(el, this.drawnHeight === null ? { autosize: true } : { width });
+        }
+        catch {
+            // Nothing plotted yet.
+        }
+    }
+    /**
+     * 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, handlers) {
+        const el = document.getElementById(div);
+        if (!el?.on)
+            return;
+        el.removeAllListeners?.('plotly_selected');
+        el.removeAllListeners?.('plotly_deselect');
+        el.on('plotly_selected', (ev) => {
+            // A lasso that selects nothing arrives as an event with no points; it is a clear,
+            // which is what dragging an empty patch looks like it should do.
+            const points = ev?.points ?? [];
+            const indices = [];
+            for (const p of points) {
+                // The observation index rides on `customdata` — see `buildEmbeddingTraces`. A
+                // point's index within its trace is not the observation once the points are split
+                // by category, so this is the only correct source.
+                const id = p.customdata;
+                if (typeof id === 'number')
+                    indices.push(id);
+            }
+            if (indices.length === 0)
+                handlers.deselected();
+            else
+                handlers.selected(indices);
+        });
+        el.on('plotly_deselect', () => handlers.deselected());
+    }
+    /**
+     * 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) {
+        const el = document.getElementById(div);
+        if (!el?.removeAllListeners)
+            return;
+        el.removeAllListeners('plotly_selected');
+        el.removeAllListeners('plotly_deselect');
+    }
+    /**
+     * 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) {
+        const el = document.getElementById(div);
+        const full = el?._fullLayout;
+        if (!full)
+            return null;
+        if (full.scene?.camera)
+            return { camera: full.scene.camera };
+        const zoomed = full.xaxis?.autorange === false && full.yaxis?.autorange === false;
+        if (zoomed && full.xaxis?.range && full.yaxis?.range) {
+            return { ranges: { x: full.xaxis.range, y: full.yaxis.range } };
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-chart-host.js","sourceRoot":"","sources":["../../../../../src/lib/spatial-controls/spatial-charts/plotly-chart-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAE7C,0EAA0E;AAC1E,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,WAAW,EAAE,KAAK;IAClB,UAAU,EAAE,IAAI;IAChB,sBAAsB,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC;CAC/D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,WAAW,EAAE,KAAK;IAClB,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,sBAAsB,EAAE,CAAC,aAAa,CAAC;CACxC,CAAC;AAgBF;;;;;;;GAOG;AACH,MAAM,OAAO,eAAe;IAA5B;QACE;;;;WAIG;QACK,gBAAW,GAAkB,IAAI,CAAC;IA4H5C,CAAC;IA1HC,uDAAuD;IACvD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,CAAC,GAAW,EAAE,MAAe,EAAE,MAAe,EAAE,SAAkB,YAAY;QACtF,MAAM,MAAM,GAAI,MAAsC,EAAE,MAAM,CAAC;QAC/D,IAAI,CAAC,WAAW,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9D,MAAM,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,MAAe,EAAE,MAAe,EAAE,MAAe,CAAC,CAAC;IAC7E,CAAC;IAED,qFAAqF;IACrF,KAAK,CAAC,GAAW;QACf,IAAI,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;QAAC,MAAM,CAAC;YACP,qDAAqD;QACvD,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,GAAW;QACf,MAAM,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,CAAC,EAAE;YAAE,OAAO;QAChB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC;QACzC,sFAAsF;QACtF,8DAA8D;QAC9D,IAAI,KAAK,IAAI,CAAC;YAAE,OAAO;QACvB,IAAI,CAAC;YACH,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAClF,CAAC;QAAC,MAAM,CAAC;YACP,uBAAuB;QACzB,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CAAC,GAAW,EAAE,QAA+B;QACxD,MAAM,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAoC,CAAC;QAC3E,IAAI,CAAC,EAAE,EAAE,EAAE;YAAE,OAAO;QACpB,EAAE,CAAC,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,CAAC;QAC3C,EAAE,CAAC,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,CAAC;QAC3C,EAAE,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE;YAC9B,kFAAkF;YAClF,iEAAiE;YACjE,MAAM,MAAM,GAAI,EAAkD,EAAE,MAAM,IAAI,EAAE,CAAC;YACjF,MAAM,OAAO,GAAa,EAAE,CAAC;YAC7B,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;gBACvB,8EAA8E;gBAC9E,kFAAkF;gBAClF,mDAAmD;gBACnD,MAAM,EAAE,GAAI,CAA8B,CAAC,UAAU,CAAC;gBACtD,IAAI,OAAO,EAAE,KAAK,QAAQ;oBAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC/C,CAAC;YACD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;;gBAC3C,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,EAAE,CAAC,iBAAiB,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC;IACxD,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,GAAW;QACzB,MAAM,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAoC,CAAC;QAC3E,IAAI,CAAC,EAAE,EAAE,kBAAkB;YAAE,OAAO;QACpC,EAAE,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;QACzC,EAAE,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,GAAW;QAClB,MAAM,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACxC,MAAM,IAAI,GACR,EAOD,EAAE,WAAW,CAAC;QACf,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM;YAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,SAAS,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,EAAE,SAAS,KAAK,KAAK,CAAC;QAClF,IAAI,MAAM,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC;YACrD,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;QAClE,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import * as Plotly from 'plotly.js-dist-min';\n\n/** Plotly config: a static-ish analysis chart, not an editable figure. */\nexport const CHART_CONFIG = {\n  displaylogo: false,\n  responsive: true,\n  modeBarButtonsToRemove: ['lasso2d', 'select2d', 'autoScale2d'],\n};\n\n/**\n * Config for the embedding, which unlike the distributions is a plot you SELECT in.\n *\n * The lasso and box-select are kept — drawing round a cluster is how a population gets\n * picked out of a UMAP — and the wheel zooms, because exploring an embedding means zooming\n * into a cluster and reaching for a toolbar button to do it breaks that.\n */\nexport const EMBEDDING_CONFIG = {\n  displaylogo: false,\n  responsive: true,\n  scrollZoom: true,\n  modeBarButtonsToRemove: ['autoScale2d'],\n};\n\n/** What a lasso or box selection in a plot reports. */\nexport interface PlotSelectionHandlers {\n  /** The observation indices selected (empty for a selection that caught nothing). */\n  selected(indices: number[]): void;\n  /** The modebar's deselect, or a plain click on empty space. */\n  deselected(): void;\n}\n\n/** The view the user has set up on a live plot: a 3D camera, or a zoomed 2D range. */\nexport interface LivePlotView {\n  camera?: unknown;\n  ranges?: { x: unknown; y: unknown };\n}\n\n/**\n * Plotly I/O for the spatial charts, keyed by the id of the div drawn into: drawing,\n * purging, re-fitting to the container, binding a selection, and reading back the view\n * the user has set up. The only place the charts import Plotly.\n *\n * Remembers whether the last drawn layout fixed its own height, because re-fitting depends\n * on it (see {@link refit}).\n */\nexport class PlotlyChartHost {\n  /**\n   * The height the drawn layout asked for, or null where it autosizes. The counts and\n   * heatmap layouts size their height to their content — one band per bar, per gene row —\n   * while the distribution kinds want to fill whatever height they are given.\n   */\n  private drawnHeight: number | null = null;\n\n  /** Whether the plot on screen fixed its own height. */\n  get hasFixedHeight(): boolean {\n    return this.drawnHeight !== null;\n  }\n\n  /**\n   * Draw into `div`, remembering whether this layout fixed its own height.\n   *\n   * The layout builders return `unknown` on purpose — they keep Plotly's layout types out\n   * of the pure module — so the height is read back by narrowing rather than declared.\n   * `height` is Plotly's own key, not ours.\n   */\n  async draw(div: string, traces: unknown, layout: unknown, config: unknown = CHART_CONFIG): Promise<void> {\n    const height = (layout as { height?: unknown } | null)?.height;\n    this.drawnHeight = typeof height === 'number' ? height : null;\n    await Plotly.react(div, traces as never, layout as never, config as never);\n  }\n\n  /** Purge `div`, freeing its plot (and WebGL context); a div with no plot is fine. */\n  purge(div: string): void {\n    try {\n      Plotly.purge(div);\n    } catch {\n      // Nothing plotted there, or the div is already gone.\n    }\n  }\n\n  /**\n   * Re-fit whatever is plotted in `div` to its container.\n   *\n   * Plotly does not notice a container resize on its own — its `responsive` option listens\n   * for WINDOW resizes only. And `autosize` takes BOTH dimensions from the container, which\n   * is right only where the layout did not fix its own height. Measured: autosizing a layout\n   * with an explicit height of 500 replaced it with the container's 400. The counts and\n   * heatmap layouts size themselves to their row count, so for them the width is set ALONE\n   * and the height left to stand.\n   */\n  refit(div: string): void {\n    const el = document.getElementById(div);\n    if (!el) return;\n    const width = Math.round(el.clientWidth);\n    // Zero while the section is collapsed or the dialog is closed; relaying out to a zero\n    // box makes Plotly compute a layout it does not recover from.\n    if (width <= 0) return;\n    try {\n      Plotly.relayout(el, this.drawnHeight === null ? { autosize: true } : { width });\n    } catch {\n      // Nothing plotted yet.\n    }\n  }\n\n  /**\n   * Turn a lasso or box selection in `div` into observation indices.\n   *\n   * Bound after each draw, and the previous listeners removed first: `Plotly.react`\n   * preserves handlers, so re-binding without removing would fire the selection once per\n   * redraw the plot had ever had.\n   */\n  bindSelection(div: string, handlers: PlotSelectionHandlers): void {\n    const el = document.getElementById(div) as Plotly.PlotlyHTMLElement | null;\n    if (!el?.on) return;\n    el.removeAllListeners?.('plotly_selected');\n    el.removeAllListeners?.('plotly_deselect');\n    el.on('plotly_selected', (ev) => {\n      // A lasso that selects nothing arrives as an event with no points; it is a clear,\n      // which is what dragging an empty patch looks like it should do.\n      const points = (ev as { points?: readonly unknown[] } | undefined)?.points ?? [];\n      const indices: number[] = [];\n      for (const p of points) {\n        // The observation index rides on `customdata` — see `buildEmbeddingTraces`. A\n        // point's index within its trace is not the observation once the points are split\n        // by category, so this is the only correct source.\n        const id = (p as { customdata?: unknown }).customdata;\n        if (typeof id === 'number') indices.push(id);\n      }\n      if (indices.length === 0) handlers.deselected();\n      else handlers.selected(indices);\n    });\n    el.on('plotly_deselect', () => handlers.deselected());\n  }\n\n  /**\n   * Drop the selection handlers from a div another chart is about to use.\n   *\n   * `plotly_deselect` fires on a plain click in ANY Plotly chart, so handlers left bound\n   * for an embedding would make the first click on a bar clear the map's selection.\n   */\n  unbindSelection(div: string): void {\n    const el = document.getElementById(div) as Plotly.PlotlyHTMLElement | null;\n    if (!el?.removeAllListeners) return;\n    el.removeAllListeners('plotly_selected');\n    el.removeAllListeners('plotly_deselect');\n  }\n\n  /**\n   * The view the user has set up on the live plot in `div`, to carry across a redraw.\n   *\n   * `Plotly.react` resets a 3D scene camera and any zoomed 2D range unless the layout\n   * carries them, so selecting a category or recolouring would throw away an orientation\n   * that took work to find. Null where nothing is drawn yet, or a 2D plot is not zoomed:\n   * passing an autoranged range back would freeze the axes and stop the plot re-fitting\n   * when the data changes.\n   */\n  liveView(div: string): LivePlotView | null {\n    const el = document.getElementById(div);\n    const full = (\n      el as {\n        _fullLayout?: {\n          scene?: { camera?: unknown };\n          xaxis?: { range?: unknown; autorange?: boolean };\n          yaxis?: { range?: unknown; autorange?: boolean };\n        };\n      } | null\n    )?._fullLayout;\n    if (!full) return null;\n    if (full.scene?.camera) return { camera: full.scene.camera };\n    const zoomed = full.xaxis?.autorange === false && full.yaxis?.autorange === false;\n    if (zoomed && full.xaxis?.range && full.yaxis?.range) {\n      return { ranges: { x: full.xaxis.range, y: full.yaxis.range } };\n    }\n    return null;\n  }\n}\n"]}

package/esm2022/lib/spatial-controls/spatial-charts/spatial-chart-window/spatial-chart-window.component.mjs

@@ -0,0 +1,47 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { DialogModule } from 'primeng/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dialog";
+/**
+ * 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 class SpatialChartWindowComponent {
+    constructor() {
+        /** The window's header — what it is showing. */
+        this.title = '';
+        /** The id of the div the chart is drawn into. */
+        this.divId = '';
+        /** Whether the drawn layout fixed its own height (and so the window scrolls). */
+        this.fixedHeight = false;
+        /** The window was closed: put the chart back. */
+        this.closed = new EventEmitter();
+        /** The window is up and its div exists: the chart can be drawn into it. */
+        this.shown = new EventEmitter();
+        /** The window was resized: re-fit the chart. */
+        this.resizeEnd = new EventEmitter();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SpatialChartWindowComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: SpatialChartWindowComponent, isStandalone: true, selector: "spatial-chart-window", inputs: { title: "title", divId: "divId", fixedHeight: "fixedHeight" }, outputs: { closed: "closed", shown: "shown", resizeEnd: "resizeEnd" }, ngImport: i0, template: "<!-- The detached chart. Its own non-modal, draggable, resizable window so it can be put\n     beside the spatial-omics dialog. `appendTo=\"body\"` keeps it out of the dialog's\n     stacking context, or it would be clipped by the panel it is meant to sit next to. -->\n<p-dialog\n  [header]=\"title\"\n  [visible]=\"true\"\n  (visibleChange)=\"closed.emit()\"\n  [modal]=\"false\"\n  [resizable]=\"true\"\n  [draggable]=\"true\"\n  position=\"right\"\n  appendTo=\"body\"\n  (onShow)=\"shown.emit()\"\n  (onResizeEnd)=\"resizeEnd.emit()\"\n  [style]=\"{ width: '34rem', height: '30rem' }\"\n  [contentStyle]=\"{\n    display: 'flex',\n    flexDirection: 'column',\n    gap: '0.25rem',\n    padding: '0.4rem 0.6rem 0.5rem',\n    flex: '1 1 auto',\n    minHeight: '0',\n    overflow: 'auto',\n  }\"\n  styleClass=\"spatial-detached-dialog\"\n>\n  <div [id]=\"divId\" class=\"sx-detached-plot\" [class.sx-plot-fixed]=\"fixedHeight\"></div>\n  <ng-content></ng-content>\n</p-dialog>\n", styles: [".sx-detached-plot{flex:1;width:100%;min-height:0;overflow:hidden}.sx-detached-plot.sx-plot-fixed{flex:0 0 auto;min-height:auto;overflow:visible}\n"], dependencies: [{ kind: "ngmodule", type: DialogModule }, { kind: "component", type: i1.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "visible", "style", "position"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SpatialChartWindowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'spatial-chart-window', standalone: true, imports: [DialogModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<!-- The detached chart. Its own non-modal, draggable, resizable window so it can be put\n     beside the spatial-omics dialog. `appendTo=\"body\"` keeps it out of the dialog's\n     stacking context, or it would be clipped by the panel it is meant to sit next to. -->\n<p-dialog\n  [header]=\"title\"\n  [visible]=\"true\"\n  (visibleChange)=\"closed.emit()\"\n  [modal]=\"false\"\n  [resizable]=\"true\"\n  [draggable]=\"true\"\n  position=\"right\"\n  appendTo=\"body\"\n  (onShow)=\"shown.emit()\"\n  (onResizeEnd)=\"resizeEnd.emit()\"\n  [style]=\"{ width: '34rem', height: '30rem' }\"\n  [contentStyle]=\"{\n    display: 'flex',\n    flexDirection: 'column',\n    gap: '0.25rem',\n    padding: '0.4rem 0.6rem 0.5rem',\n    flex: '1 1 auto',\n    minHeight: '0',\n    overflow: 'auto',\n  }\"\n  styleClass=\"spatial-detached-dialog\"\n>\n  <div [id]=\"divId\" class=\"sx-detached-plot\" [class.sx-plot-fixed]=\"fixedHeight\"></div>\n  <ng-content></ng-content>\n</p-dialog>\n", styles: [".sx-detached-plot{flex:1;width:100%;min-height:0;overflow:hidden}.sx-detached-plot.sx-plot-fixed{flex:0 0 auto;min-height:auto;overflow:visible}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], divId: [{
+                type: Input
+            }], fixedHeight: [{
+                type: Input
+            }], closed: [{
+                type: Output
+            }], shown: [{
+                type: Output
+            }], resizeEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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