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

package/esm2022/lib/spatial/spatial-panel-model.mjs

@@ -0,0 +1,282 @@
+import { INFERNO_LUT } from 'napari-js/colormaps';
+import { lutFor, spatialContinuousLut } from './spatial-encoding';
+import { TRANSCRIPT_GLYPHS, glyphOutline } from './spatial-tiles';
+/** A gene name as a dropdown option. Objects rather than bare strings because the
+ *  dropdown filters on a named field (`filterBy="label"`), which a string has not. */
+export function geneOption(name) {
+    return { label: name, value: name };
+}
+/** Glyph choices with an SVG `points` string for the preview. */
+export const GLYPH_OPTIONS = TRANSCRIPT_GLYPHS.map((g) => {
+    const o = glyphOutline(g);
+    const pts = [];
+    for (let i = 0; i < o.length; i += 2)
+        pts.push(`${o[i].toFixed(3)},${o[i + 1].toFixed(3)}`);
+    return { label: g.replace('-', ' '), value: g, points: pts.join(' ') };
+});
+/** The preview outline of `glyph`, or `''` for an unknown one. */
+export function glyphPoints(glyph) {
+    return GLYPH_OPTIONS.find((o) => o.value === glyph)?.points ?? '';
+}
+/** Outlier clipping presets, as `[lo, hi]` percentile fractions. */
+export const CLIP_OPTIONS = [
+    { label: 'None', value: [0, 1] },
+    { label: '1%', value: [0.01, 0.99] },
+    { label: '2%', value: [0.02, 0.98] },
+    { label: '5%', value: [0.05, 0.95] },
+];
+/**
+ * `group,gene` rows (CSV or TSV, header optional) → gene groups, in file order.
+ */
+export function parseGeneGroups(text) {
+    const groups = new Map();
+    for (const line of text.split(/\r?\n/)) {
+        const [a, b] = line.split(/,|\t/).map((f) => f.trim().replace(/^"|"$/g, ''));
+        if (!a || !b || (/^(group|cell_?type|name)$/i.test(a) && /^(gene|genes|feature)$/i.test(b)))
+            continue;
+        const list = groups.get(a) ?? [];
+        if (!list.includes(b))
+            list.push(b);
+        groups.set(a, list);
+    }
+    return [...groups].map(([name, genes]) => ({ name, genes }));
+}
+/** `name — 2 categories` / `name — counts`: a column as the pickers list it. */
+export function columnLabel(c) {
+    const kind = c.kind === 'categorical'
+        ? `${c.categories.length} categories`
+        : (c.unit ?? 'continuous');
+    return `${c.name} — ${kind}`;
+}
+/** A categorical column's label in the group pickers: its description where it is a
+ *  sectioned (derived) grouping, its name and size otherwise. */
+function groupLabel(c) {
+    return c.description && c.section ? c.description : columnLabel(c);
+}
+/** Colour-by column choices — "None" plus every column the dataset declares. */
+export function columnOptions(ds) {
+    return [
+        { label: 'None (flat colour)', value: null },
+        ...(ds?.columns ?? []).map((c) => ({ label: columnLabel(c), value: c.name })),
+    ];
+}
+/** {@link TileOptions} for `ds`: short labels, cell set first, "Both" when there are two —
+ *  as Xenium Explorer. */
+export function tileOptions(ds) {
+    const sets = [...(ds?.polygonTiles?.sets ?? [])].sort((a, b) => a.name === 'cell' ? -1 : b.name === 'cell' ? 1 : 0);
+    const has = (name) => !!ds?.columns.some((c) => c.name === name);
+    return {
+        cellSetOptions: [
+            ...sets.map((s) => ({ label: s.label.replace(/\s*boundar(y|ies)$/i, ''), value: s.name })),
+            ...(sets.length > 1 ? [{ label: 'Both', value: 'both' }] : []),
+        ],
+        transcriptModeOptions: [
+            ...(ds?.transcriptTiles
+                ? [
+                    { label: 'Points', value: 'circles' },
+                    { label: 'Icons', value: 'glyphs' },
+                ]
+                : []),
+            ...(ds?.density ? [{ label: 'Density Map', value: 'density' }] : []),
+        ],
+        cellColorOptions: [
+            { label: 'Group Affiliation', value: 'group' },
+            ...(ds?.features ? [{ label: 'Gene Expression', value: 'gene' }] : []),
+            ...(has('transcript_density')
+                ? [{ label: 'Transcript Density Map', value: 'transcriptDensity' }]
+                : []),
+            { label: 'Single Color', value: 'single' },
+            ...(has('segmentation_method') ? [{ label: 'Segmentation Method', value: 'segmentation' }] : []),
+        ],
+    };
+}
+/** The value the group picker uses for a family of columns. */
+export const FAMILY_PREFIX = 'family:';
+/**
+ * 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. The segmentation method is not a grouping of cells.
+ */
+export function groupOptions(ds) {
+    const sections = new Map();
+    const seenFamilies = new Set();
+    for (const c of ds?.columns ?? []) {
+        if (c.kind !== 'categorical' || c.name === 'segmentation_method')
+            continue;
+        const section = c.section ?? 'Groups';
+        const list = sections.get(section) ?? [];
+        if (c.family) {
+            if (seenFamilies.has(c.family.id))
+                continue;
+            seenFamilies.add(c.family.id);
+            list.push({ label: c.family.label, value: `${FAMILY_PREFIX}${c.family.id}` });
+        }
+        else {
+            list.push({ label: groupLabel(c), value: c.name });
+        }
+        sections.set(section, list);
+    }
+    return [...sections].map(([label, items]) => ({ label, items }));
+}
+function categoricalMeta(ds, name) {
+    const meta = name ? ds?.columns.find((c) => c.name === name) : undefined;
+    return meta?.kind === 'categorical' ? meta : undefined;
+}
+/** The group picker's value for the active group column: its family's entry, or itself. */
+export function groupEntryFor(ds, column) {
+    const family = categoricalMeta(ds, column)?.family;
+    return family ? `${FAMILY_PREFIX}${family.id}` : column;
+}
+/** The columns of family `id`, in dataset order. */
+export function familyMembers(ds, id) {
+    return (ds?.columns ?? []).filter((c) => c.kind === 'categorical' && c.family?.id === id);
+}
+/** Variants of the active column's family (k = 2…10), or none when it has no family. */
+export function groupVariantOptions(ds, column) {
+    const family = categoricalMeta(ds, column)?.family;
+    return family ? familyMembers(ds, family.id).map((c) => ({ label: c.family.variant, value: c.name })) : [];
+}
+/** A grouping's categories with colours and cell counts, largest first, and their total. */
+export function countGroupRows(v) {
+    const counts = new Uint32Array(v.categories.length);
+    for (const c of v.codes)
+        if (c < counts.length)
+            counts[c]++;
+    const rows = v.categories
+        .map((label, i) => ({ label, color: v.colors[i] ?? '#999', count: counts[i] }))
+        .sort((a, b) => b.count - a.count);
+    return { rows, total: rows.reduce((n, r) => n + r.count, 0) };
+}
+/** `list` with `items` removed (`on`) or added (`!on`) — a hidden-set toggle. */
+export function toggleHidden(list, items, on) {
+    const hidden = new Set(list);
+    for (const item of items) {
+        if (on)
+            hidden.delete(item);
+        else
+            hidden.add(item);
+    }
+    return [...hidden];
+}
+/** The selected genes as Explorer's tree: named groups, then the ungrouped ones. */
+export function buildGeneTree(selected, groups) {
+    const chosen = new Set(selected);
+    const grouped = new Set();
+    const out = [];
+    for (const g of groups) {
+        const genes = g.genes.filter((x) => chosen.has(x));
+        if (!genes.length)
+            continue;
+        genes.forEach((x) => grouped.add(x));
+        out.push({ name: g.name, genes });
+    }
+    const rest = selected.filter((x) => !grouped.has(x));
+    if (rest.length)
+        out.push({ name: null, genes: rest });
+    return out;
+}
+/** Every categorical column but the segmentation method, which says nothing about genes. */
+export function markerColumnOptions(columns) {
+    return (columns ?? [])
+        .filter((c) => c.kind === 'categorical' && c.name !== 'segmentation_method')
+        .map((c) => ({ label: groupLabel(c), value: c.name }));
+}
+/**
+ * Each picked cluster's marker genes as a gene group named after it. A gene that marks
+ * several clusters goes to the one it scores highest in, so the tree lists it once;
+ * clusters left with no gene are dropped.
+ */
+export function markerGeneGroups(result, picked) {
+    const best = new Map();
+    for (const g of result.groups) {
+        if (!picked.has(g.name))
+            continue;
+        for (const gene of g.genes) {
+            const prev = best.get(gene.name);
+            if (!prev || gene.score > prev.score)
+                best.set(gene.name, { group: g.name, score: gene.score });
+        }
+    }
+    return result.groups
+        .filter((g) => picked.has(g.name))
+        .map((g) => ({
+        name: g.name,
+        genes: g.genes.map((x) => x.name).filter((n) => best.get(n)?.group === g.name),
+    }))
+        .filter((g) => g.genes.length);
+}
+/** `groups` merged into the view's gene groups (replacing any of the same name). */
+export function withGeneGroups(view, groups) {
+    const names = new Set(groups.map((g) => g.name));
+    return [...view.transcriptGeneGroups.filter((g) => !names.has(g.name)), ...groups];
+}
+/**
+ * The patch that adds marker groups: the groups, their genes appended to the selection,
+ * transcripts coloured by cluster (as their cells are), and switched on when off.
+ */
+export function markerGenesPatch(view, groups) {
+    const genes = [...view.transcriptGenes];
+    for (const g of groups)
+        for (const n of g.genes)
+            if (!genes.includes(n))
+                genes.push(n);
+    return {
+        transcriptGeneGroups: withGeneGroups(view, groups),
+        transcriptGenes: genes,
+        transcriptColorBy: 'cluster',
+        ...(view.transcriptMode === 'off' ? { transcriptMode: 'circles' } : {}),
+    };
+}
+/** The patch that imports gene groups: the groups, and their genes added to the selection. */
+export function importGeneGroupsPatch(view, groups) {
+    return {
+        transcriptGeneGroups: withGeneGroups(view, groups),
+        transcriptGenes: [...new Set([...view.transcriptGenes, ...groups.flatMap((g) => g.genes)])],
+        transcriptAllGenes: false,
+    };
+}
+/** `linear-gradient(...)` sampling `lut` at `steps + 1` evenly spaced stops. */
+export function gradientCss(lut, steps = 16) {
+    const stops = [];
+    for (let i = 0; i <= steps; i++) {
+        const [r, g, b] = lut[Math.round((i / steps) * (lut.length - 1))];
+        stops.push(`rgb(${r},${g},${b}) ${((i / steps) * 100).toFixed(0)}%`);
+    }
+    return `linear-gradient(to right, ${stops.join(', ')})`;
+}
+/**
+ * The continuous colour bar, resolved exactly the way the renderer resolves its colours —
+ * the same override, the same grey fallback. Built from `lutFor` alone, this bar showed a
+ * black-to-white ramp while the canvas drew Viridis, which makes the key worse than none.
+ */
+export function continuousColorBarCss(colormap, reverse, override) {
+    return gradientCss(spatialContinuousLut(colormap, reverse, override));
+}
+/** The density map's colour bar: its own colormap, Inferno by default. */
+export function densityColorBarCss(colormap) {
+    return gradientCss(lutFor(colormap ?? INFERNO_LUT));
+}
+/** The middle of a section stack: where a "one section" picker opens, rather than on the
+ *  first section, which for a brain is a nearly empty olfactory-bulb slide. */
+export function middleSection(sections) {
+    return sections ? Math.floor((sections.length - 1) / 2) : 0;
+}
+/** "12 of 53" — 1-based, because the sections are slides, not array slots; `''` with none. */
+export function sectionLabel(sections, at) {
+    const total = sections?.length ?? 0;
+    if (!total)
+        return '';
+    const i = Math.max(0, Math.min(total - 1, at ?? 0));
+    return `${i + 1} of ${total}`;
+}
+/** Why "All genes" is not offered yet, while the server builds its pyramid; null otherwise. */
+export function allGenesPreparingNote(ds) {
+    const st = ds?.transcriptBinsStatus;
+    if (!st || ds?.transcriptBins)
+        return null;
+    if (st.state === 'failed')
+        return `"All genes" is unavailable: preparing it failed (${st.message ?? 'unknown error'}).`;
+    const pct = st.total ? ` — ${Math.floor((100 * (st.done ?? 0)) / st.total)}% when this dataset was opened` : '';
+    return `"All genes" is being prepared on the server${pct}; reopen the dataset once it is done.`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-panel-model.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-panel-model.ts"],"names":[],"mappings":"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","sourcesContent":["import { INFERNO_LUT } from 'napari-js/colormaps';\n\nimport type {\n  CategoricalColumnMeta,\n  SpatialColumnMeta,\n  SpatialDataset,\n  SpatialMarkerGenes,\n} from '../contracts/spatial-dataset.contract';\nimport type { SpatialCategoricalView } from '../contracts/visualizer.contract';\nimport type { ColormapValue, SpatialViewState, TranscriptGlyphName } from '../contracts/display-types';\nimport type { Rgb } from '../contracts/colormap-lut';\nimport { lutFor, spatialContinuousLut } from './spatial-encoding';\nimport { TRANSCRIPT_GLYPHS, glyphOutline } from './spatial-tiles';\n\n/**\n * Pure model of the spatial-omics panel: the option lists, rows and patches its controls\n * show and write, as functions of the dataset and the view. No Angular and no state, so\n * every rule here is unit-tested without a TestBed and shared by whichever panel shows it.\n */\n\n/** A labelled dropdown option. */\nexport interface PanelOption<T> {\n  label: string;\n  value: T;\n}\n\n/** A gene name as a dropdown option. Objects rather than bare strings because the\n *  dropdown filters on a named field (`filterBy=\"label\"`), which a string has not. */\nexport function geneOption(name: string): PanelOption<string> {\n  return { label: name, value: name };\n}\n\n/** A transcript glyph choice, with an SVG `points` string for its preview. */\nexport interface GlyphOption extends PanelOption<TranscriptGlyphName> {\n  points: string;\n}\n\n/** Glyph choices with an SVG `points` string for the preview. */\nexport const GLYPH_OPTIONS: GlyphOption[] = TRANSCRIPT_GLYPHS.map((g) => {\n  const o = glyphOutline(g);\n  const pts: string[] = [];\n  for (let i = 0; i < o.length; i += 2) pts.push(`${o[i].toFixed(3)},${o[i + 1].toFixed(3)}`);\n  return { label: g.replace('-', ' '), value: g as TranscriptGlyphName, points: pts.join(' ') };\n});\n\n/** The preview outline of `glyph`, or `''` for an unknown one. */\nexport function glyphPoints(glyph: TranscriptGlyphName): string {\n  return GLYPH_OPTIONS.find((o) => o.value === glyph)?.points ?? '';\n}\n\n/** Outlier clipping presets, as `[lo, hi]` percentile fractions. */\nexport const CLIP_OPTIONS: PanelOption<[number, number]>[] = [\n  { label: 'None', value: [0, 1] },\n  { label: '1%', value: [0.01, 0.99] },\n  { label: '2%', value: [0.02, 0.98] },\n  { label: '5%', value: [0.05, 0.95] },\n];\n\n/**\n * `group,gene` rows (CSV or TSV, header optional) → gene groups, in file order.\n */\nexport function parseGeneGroups(text: string): { name: string; genes: string[] }[] {\n  const groups = new Map<string, string[]>();\n  for (const line of text.split(/\\r?\\n/)) {\n    const [a, b] = line.split(/,|\\t/).map((f) => f.trim().replace(/^\"|\"$/g, ''));\n    if (!a || !b || (/^(group|cell_?type|name)$/i.test(a) && /^(gene|genes|feature)$/i.test(b))) continue;\n    const list = groups.get(a) ?? [];\n    if (!list.includes(b)) list.push(b);\n    groups.set(a, list);\n  }\n  return [...groups].map(([name, genes]) => ({ name, genes }));\n}\n\n/** `name — 2 categories` / `name — counts`: a column as the pickers list it. */\nexport function columnLabel(c: SpatialColumnMeta): string {\n  const kind =\n    c.kind === 'categorical'\n      ? `${(c as CategoricalColumnMeta).categories.length} categories`\n      : (c.unit ?? 'continuous');\n  return `${c.name} — ${kind}`;\n}\n\n/** A categorical column's label in the group pickers: its description where it is a\n *  sectioned (derived) grouping, its name and size otherwise. */\nfunction groupLabel(c: CategoricalColumnMeta): string {\n  return c.description && c.section ? c.description : columnLabel(c);\n}\n\n/** Colour-by column choices — \"None\" plus every column the dataset declares. */\nexport function columnOptions(ds: SpatialDataset | null): PanelOption<string | null>[] {\n  return [\n    { label: 'None (flat colour)', value: null },\n    ...(ds?.columns ?? []).map((c) => ({ label: columnLabel(c), value: c.name })),\n  ];\n}\n\n/** The option lists of the cell and transcript controls, which depend on the dataset only. */\nexport interface TileOptions {\n  cellSetOptions: PanelOption<string>[];\n  transcriptModeOptions: PanelOption<SpatialViewState['transcriptMode']>[];\n  cellColorOptions: PanelOption<SpatialViewState['cellColorMode']>[];\n}\n\n/** {@link TileOptions} for `ds`: short labels, cell set first, \"Both\" when there are two —\n *  as Xenium Explorer. */\nexport function tileOptions(ds: SpatialDataset | null): TileOptions {\n  const sets = [...(ds?.polygonTiles?.sets ?? [])].sort((a, b) =>\n    a.name === 'cell' ? -1 : b.name === 'cell' ? 1 : 0,\n  );\n  const has = (name: string) => !!ds?.columns.some((c) => c.name === name);\n  return {\n    cellSetOptions: [\n      ...sets.map((s) => ({ label: s.label.replace(/\\s*boundar(y|ies)$/i, ''), value: s.name })),\n      ...(sets.length > 1 ? [{ label: 'Both', value: 'both' }] : []),\n    ],\n    transcriptModeOptions: [\n      ...(ds?.transcriptTiles\n        ? [\n            { label: 'Points', value: 'circles' as const },\n            { label: 'Icons', value: 'glyphs' as const },\n          ]\n        : []),\n      ...(ds?.density ? [{ label: 'Density Map', value: 'density' as const }] : []),\n    ],\n    cellColorOptions: [\n      { label: 'Group Affiliation', value: 'group' },\n      ...(ds?.features ? [{ label: 'Gene Expression', value: 'gene' as const }] : []),\n      ...(has('transcript_density')\n        ? [{ label: 'Transcript Density Map', value: 'transcriptDensity' as const }]\n        : []),\n      { label: 'Single Color', value: 'single' },\n      ...(has('segmentation_method') ? [{ label: 'Segmentation Method', value: 'segmentation' as const }] : []),\n    ],\n  };\n}\n\n/** A section of the group picker. */\nexport interface GroupOptionSection {\n  label: string;\n  items: PanelOption<string>[];\n}\n\n/** The value the group picker uses for a family of columns. */\nexport const FAMILY_PREFIX = 'family:';\n\n/**\n * The group picker: categorical columns under their section heading, a family of\n * variants (k-means at k = 2…10) listed once. Values are a column name, or\n * `family:<id>` for a family. The segmentation method is not a grouping of cells.\n */\nexport function groupOptions(ds: SpatialDataset | null): GroupOptionSection[] {\n  const sections = new Map<string, PanelOption<string>[]>();\n  const seenFamilies = new Set<string>();\n  for (const c of ds?.columns ?? []) {\n    if (c.kind !== 'categorical' || c.name === 'segmentation_method') continue;\n    const section = c.section ?? 'Groups';\n    const list = sections.get(section) ?? [];\n    if (c.family) {\n      if (seenFamilies.has(c.family.id)) continue;\n      seenFamilies.add(c.family.id);\n      list.push({ label: c.family.label, value: `${FAMILY_PREFIX}${c.family.id}` });\n    } else {\n      list.push({ label: groupLabel(c), value: c.name });\n    }\n    sections.set(section, list);\n  }\n  return [...sections].map(([label, items]) => ({ label, items }));\n}\n\nfunction categoricalMeta(ds: SpatialDataset | null, name: string | null): CategoricalColumnMeta | undefined {\n  const meta = name ? ds?.columns.find((c) => c.name === name) : undefined;\n  return meta?.kind === 'categorical' ? meta : undefined;\n}\n\n/** The group picker's value for the active group column: its family's entry, or itself. */\nexport function groupEntryFor(ds: SpatialDataset | null, column: string | null): string | null {\n  const family = categoricalMeta(ds, column)?.family;\n  return family ? `${FAMILY_PREFIX}${family.id}` : column;\n}\n\n/** The columns of family `id`, in dataset order. */\nexport function familyMembers(ds: SpatialDataset | null, id: string): CategoricalColumnMeta[] {\n  return (ds?.columns ?? []).filter(\n    (c): c is CategoricalColumnMeta => c.kind === 'categorical' && c.family?.id === id,\n  );\n}\n\n/** Variants of the active column's family (k = 2…10), or none when it has no family. */\nexport function groupVariantOptions(ds: SpatialDataset | null, column: string | null): PanelOption<string>[] {\n  const family = categoricalMeta(ds, column)?.family;\n  return family ? familyMembers(ds, family.id).map((c) => ({ label: c.family!.variant, value: c.name })) : [];\n}\n\n/** One row of the groups list: a category with its colour and cell count. */\nexport interface GroupRow {\n  label: string;\n  color: string;\n  count: number;\n}\n\n/** A grouping's categories with colours and cell counts, largest first, and their total. */\nexport function countGroupRows(v: Pick<SpatialCategoricalView, 'categories' | 'colors' | 'codes'>): {\n  rows: GroupRow[];\n  total: number;\n} {\n  const counts = new Uint32Array(v.categories.length);\n  for (const c of v.codes) if (c < counts.length) counts[c]++;\n  const rows = v.categories\n    .map((label, i) => ({ label, color: v.colors[i] ?? '#999', count: counts[i] }))\n    .sort((a, b) => b.count - a.count);\n  return { rows, total: rows.reduce((n, r) => n + r.count, 0) };\n}\n\n/** `list` with `items` removed (`on`) or added (`!on`) — a hidden-set toggle. */\nexport function toggleHidden(list: readonly string[], items: readonly string[], on: boolean): string[] {\n  const hidden = new Set(list);\n  for (const item of items) {\n    if (on) hidden.delete(item);\n    else hidden.add(item);\n  }\n  return [...hidden];\n}\n\n/** One node of the selected-genes tree: a named gene group, or the ungrouped rest (`null`). */\nexport interface GeneTreeNode {\n  name: string | null;\n  genes: string[];\n}\n\n/** The selected genes as Explorer's tree: named groups, then the ungrouped ones. */\nexport function buildGeneTree(\n  selected: readonly string[],\n  groups: readonly { name: string; genes: readonly string[] }[],\n): GeneTreeNode[] {\n  const chosen = new Set(selected);\n  const grouped = new Set<string>();\n  const out: GeneTreeNode[] = [];\n  for (const g of groups) {\n    const genes = g.genes.filter((x) => chosen.has(x));\n    if (!genes.length) continue;\n    genes.forEach((x) => grouped.add(x));\n    out.push({ name: g.name, genes });\n  }\n  const rest = selected.filter((x) => !grouped.has(x));\n  if (rest.length) out.push({ name: null, genes: rest });\n  return out;\n}\n\n/** Every categorical column but the segmentation method, which says nothing about genes. */\nexport function markerColumnOptions(columns: readonly SpatialColumnMeta[] | undefined): PanelOption<string>[] {\n  return (columns ?? [])\n    .filter((c): c is CategoricalColumnMeta => c.kind === 'categorical' && c.name !== 'segmentation_method')\n    .map((c) => ({ label: groupLabel(c), value: c.name }));\n}\n\n/**\n * Each picked cluster's marker genes as a gene group named after it. A gene that marks\n * several clusters goes to the one it scores highest in, so the tree lists it once;\n * clusters left with no gene are dropped.\n */\nexport function markerGeneGroups(\n  result: Pick<SpatialMarkerGenes, 'groups'>,\n  picked: ReadonlySet<string>,\n): { name: string; genes: string[] }[] {\n  const best = new Map<string, { group: string; score: number }>();\n  for (const g of result.groups) {\n    if (!picked.has(g.name)) continue;\n    for (const gene of g.genes) {\n      const prev = best.get(gene.name);\n      if (!prev || gene.score > prev.score) best.set(gene.name, { group: g.name, score: gene.score });\n    }\n  }\n  return result.groups\n    .filter((g) => picked.has(g.name))\n    .map((g) => ({\n      name: g.name,\n      genes: g.genes.map((x) => x.name).filter((n) => best.get(n)?.group === g.name),\n    }))\n    .filter((g) => g.genes.length);\n}\n\n/** `groups` merged into the view's gene groups (replacing any of the same name). */\nexport function withGeneGroups(\n  view: Pick<SpatialViewState, 'transcriptGeneGroups'>,\n  groups: { name: string; genes: string[] }[],\n): SpatialViewState['transcriptGeneGroups'] {\n  const names = new Set(groups.map((g) => g.name));\n  return [...view.transcriptGeneGroups.filter((g) => !names.has(g.name)), ...groups];\n}\n\n/**\n * The patch that adds marker groups: the groups, their genes appended to the selection,\n * transcripts coloured by cluster (as their cells are), and switched on when off.\n */\nexport function markerGenesPatch(\n  view: Pick<SpatialViewState, 'transcriptGeneGroups' | 'transcriptGenes' | 'transcriptMode'>,\n  groups: { name: string; genes: string[] }[],\n): Partial<SpatialViewState> {\n  const genes = [...view.transcriptGenes];\n  for (const g of groups) for (const n of g.genes) if (!genes.includes(n)) genes.push(n);\n  return {\n    transcriptGeneGroups: withGeneGroups(view, groups),\n    transcriptGenes: genes,\n    transcriptColorBy: 'cluster',\n    ...(view.transcriptMode === 'off' ? { transcriptMode: 'circles' as const } : {}),\n  };\n}\n\n/** The patch that imports gene groups: the groups, and their genes added to the selection. */\nexport function importGeneGroupsPatch(\n  view: Pick<SpatialViewState, 'transcriptGeneGroups' | 'transcriptGenes'>,\n  groups: { name: string; genes: string[] }[],\n): Partial<SpatialViewState> {\n  return {\n    transcriptGeneGroups: withGeneGroups(view, groups),\n    transcriptGenes: [...new Set([...view.transcriptGenes, ...groups.flatMap((g) => g.genes)])],\n    transcriptAllGenes: false,\n  };\n}\n\n/** `linear-gradient(...)` sampling `lut` at `steps + 1` evenly spaced stops. */\nexport function gradientCss(lut: readonly Rgb[], steps = 16): string {\n  const stops: string[] = [];\n  for (let i = 0; i <= steps; i++) {\n    const [r, g, b] = lut[Math.round((i / steps) * (lut.length - 1))];\n    stops.push(`rgb(${r},${g},${b}) ${((i / steps) * 100).toFixed(0)}%`);\n  }\n  return `linear-gradient(to right, ${stops.join(', ')})`;\n}\n\n/**\n * The continuous colour bar, resolved exactly the way the renderer resolves its colours —\n * the same override, the same grey fallback. Built from `lutFor` alone, this bar showed a\n * black-to-white ramp while the canvas drew Viridis, which makes the key worse than none.\n */\nexport function continuousColorBarCss(\n  colormap: unknown,\n  reverse: boolean,\n  override: ColormapValue | null,\n): string {\n  return gradientCss(spatialContinuousLut(colormap, reverse, override));\n}\n\n/** The density map's colour bar: its own colormap, Inferno by default. */\nexport function densityColorBarCss(colormap: SpatialViewState['densityColormap']): string {\n  return gradientCss(lutFor(colormap ?? INFERNO_LUT));\n}\n\n/** The middle of a section stack: where a \"one section\" picker opens, rather than on the\n *  first section, which for a brain is a nearly empty olfactory-bulb slide. */\nexport function middleSection(sections: ArrayLike<number> | null): number {\n  return sections ? Math.floor((sections.length - 1) / 2) : 0;\n}\n\n/** \"12 of 53\" — 1-based, because the sections are slides, not array slots; `''` with none. */\nexport function sectionLabel(sections: ArrayLike<number> | null, at: number | null): string {\n  const total = sections?.length ?? 0;\n  if (!total) return '';\n  const i = Math.max(0, Math.min(total - 1, at ?? 0));\n  return `${i + 1} of ${total}`;\n}\n\n/** Why \"All genes\" is not offered yet, while the server builds its pyramid; null otherwise. */\nexport function allGenesPreparingNote(ds: SpatialDataset | null): string | null {\n  const st = ds?.transcriptBinsStatus;\n  if (!st || ds?.transcriptBins) return null;\n  if (st.state === 'failed')\n    return `\"All genes\" is unavailable: preparing it failed (${st.message ?? 'unknown error'}).`;\n  const pct = st.total ? ` — ${Math.floor((100 * (st.done ?? 0)) / st.total)}% when this dataset was opened` : '';\n  return `\"All genes\" is being prepared on the server${pct}; reopen the dataset once it is done.`;\n}\n"]}

package/esm2022/lib/spatial/spatial-sections.mjs

@@ -93,4 +93,4 @@ export function sectionsOf(obs) {
     memo.set(obs, sections);
     return sections;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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