@jax-data-science/sci-image-visualizer 0.5.0 → 0.7.0

package/README.md

@@ -607,6 +607,8 @@ const myMode: PlotTypeContribution = {
     // ctx.visualizer — the public IVisualizer (regions, region overlay, undo…)
     // ctx.viewport  — overlay container, dataToClient / clientToData, frame$ / settled$
     // ctx.imageInfo$ — the current image
+    // ctx.tools     — arm the toolbar brush for a class (0.6.0+):
+    //                 ctx.tools?.armBrush({ label: 'tumour', color: '#1E88E5' })
     const sub = ctx.viewport.frame$.subscribe((visible) => redraw(visible));
     return { deactivate: () => sub.unsubscribe() };
   },
@@ -640,6 +642,53 @@ built-ins. The full contract
 and its guarantees are documented in
 [`plot-type-contribution.contract.ts`](./src/lib/contracts/plot-type-contribution.contract.ts).
 
+## Contributed dialog tools
+
+An interactive tool that is not "set parameters, run once" can be a **dialog
+tool** (0.6.0+). It is provided on `TOOLBAR_TOOLS`, like the run tools, with
+`kind: 'dialog'`:
+
+- **Button:** it sits with the host's own projected buttons at the start of the
+  toolbar, and shows in the Image view only.
+- **Dialog:** clicking the button opens a floating, non-modal dialog and starts
+  a session. The tool fills the dialog body with plain DOM.
+- **Context:** the same one a plot mode gets (the public visualizer, the Image
+  view's viewport, the current image), with `ctx.tools` always present.
+
+```ts
+import { TOOLBAR_TOOLS, ToolbarDialogToolContribution } from '@jax-data-science/sci-image-visualizer';
+
+const myTool: ToolbarDialogToolContribution = {
+  kind: 'dialog',
+  id: 'my-tool',
+  label: 'My tool',
+  icon: { pi: 'pi-pencil' },
+  tooltip: 'Open my tool',
+  dialog: { title: 'My tool', width: '22rem' },
+  activate(ctx) {
+    const sub = ctx.viewport.frame$.subscribe((visible) => redraw(visible));
+    return { deactivate: () => sub.unsubscribe() };
+  },
+  // After activate(), once the dialog has rendered: `host` is in the document here,
+  // so the body can measure itself.
+  mount(host, ctx, session) {
+    host.textContent = 'Hello';
+    return () => { host.textContent = ''; };   // teardown, before deactivate()
+  },
+};
+
+providers: [{ provide: TOOLBAR_TOOLS, useValue: myTool, multi: true }]
+```
+
+**Lifecycle:**
+- Clicking the button again, or closing the dialog, tears the body down and then
+  calls `session.deactivate()`, exactly once.
+- Re-rendering the Image view (another image or slice) ends the session. The
+  dialog stays open, and a fresh session starts on the new view.
+- Leaving the Image view closes the dialog.
+- A failed start closes the dialog with a warning. As with plot modes, nothing
+  the tool throws or rejects escapes.
+
 ## Development
 
 ```bash

package/esm2022/lib/contracts/display-types.mjs

@@ -22,5 +22,32 @@ export const DEFAULT_SPATIAL_VIEW = {
     geneMapVolume: false,
     geneMapSmoothing: 1,
     geneMapOpacity: 0.85,
+    showCells: null,
+    cellSet: null,
+    cellDraw: 'fill',
+    cellOpacity: 0.55,
+    cellTypeColumn: null,
+    transcriptGenes: [],
+    transcriptHiddenGenes: [],
+    transcriptGeneColors: {},
+    transcriptGeneGroups: [],
+    transcriptAllGenes: false,
+    transcriptBudget: 100_000,
+    transcriptMode: 'off',
+    transcriptColorBy: 'cellType',
+    transcriptGlyphs: {},
+    transcriptScale: 1,
+    transcriptOpacity: 0.9,
+    transcriptQuality: 'high',
+    densityOpacity: 0.8,
+    densityBin: 10,
+    densityRange: null,
+    densityColormap: null,
+    cellColorMode: 'group',
+    cellColorGene: null,
+    cellSingleColor: '#4fc3f7',
+    hiddenGroups: [],
+    showImage: true,
+    showAnnotations: true,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display-types.js","sourceRoot":"","sources":["../../../../src/lib/contracts/display-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2KH,MAAM,CAAC,MAAM,oBAAoB,GAAqB;IACpD,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,CAAC;IACb,OAAO,EAAE,CAAC;IACV,QAAQ,EAAE,KAAK;IACf,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;IAC5B,kBAAkB,EAAE,IAAI;IACxB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,GAAG;IAClB,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,IAAI;IAClB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,OAAO,EAAE,KAAK;IACd,cAAc,EAAE,IAAI;IACpB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,cAAc,EAAE,IAAI;CACrB,CAAC","sourcesContent":["/**\n * Publication-critical types that were `any` on the public contracts\n * (refactoring plan, Step 6). Deliberately permissive — every field optional —\n * so existing hosts (which pass PrimeNG `TreeNode`s and plain option objects)\n * keep compiling unchanged while consumers finally get named shapes.\n */\n\n/** A colormap value as Plotly understands it: a built-in scale name (e.g.\n *  'Viridis') or an inline array of `[stop, color]` pairs. */\nexport type ColormapValue = string | Array<[number, string]>;\n\n/** One node of the colormap selector tree (structurally compatible with the\n *  PrimeNG `TreeNode`s the host passes): group nodes carry `children`, leaf\n *  nodes carry the scale in `data.value` (+ a preview image in `data.src`). */\nexport interface ColormapNode {\n  label?: string;\n  data?: { value?: ColormapValue; src?: string };\n  children?: ColormapNode[];\n}\n\n/** Magic-wand pixel-comparison space. */\nexport type WandType = 'GRAY' | 'RGB' | 'LAB_DISTANCE';\n\n/** Options for the magic-wand tool (QuPath-style). */\nexport interface IWandOptions {\n  type?: WandType;\n  /** Gaussian sigma applied to the patch before thresholding. */\n  sigma?: number;\n  /** Higher = stricter (smaller selection) for GRAY/RGB; higher = looser for\n   *  LAB_DISTANCE — matches QuPath. */\n  sensitivity?: number;\n  /** Square patch size in pixels (must be odd). */\n  patchSize?: number;\n  /** When true, skip blur/threshold and flood-fill at exact-match\n   *  (Cmd/Ctrl-click in QuPath). */\n  simpleMode?: boolean;\n}\n\n/** Options for the brush region tool (QuPath-style). */\nexport interface IBrushOptions {\n  /** Brush diameter in matrix (image) pixels. */\n  size?: number;\n}\n\n/** What drives point colour in the spatial-omics mode: an annotation column\n *  from the dataset, or one feature (gene) vector fetched on demand. */\nexport interface SpatialColorBy {\n  kind: 'column' | 'feature';\n  name: string;\n}\n\n/** Display state for the spatial-omics plot mode. Lives in `VisualizerStore`\n *  alongside the colormap/channel state so the renderer reacts to edits the\n *  same way it does for an image. */\nexport interface SpatialViewState {\n  /** Colour source; `null` renders every observation in one neutral colour\n   *  (useful on its own — it shows where the tissue actually is). */\n  colorBy: SpatialColorBy | null;\n  /** Multiplier on the dataset's physical marker size. 1 = true size, which for\n   *  a 55 µm Visium spot is correct but can be invisible when zoomed out. */\n  pointScale: number;\n  /** Alpha for points that are not muted. */\n  opacity: number;\n  /** Log-scale continuous values before mapping them onto the colormap. Seeded\n   *  from the column's `logScaleHint` — count data needs it. */\n  logScale: boolean;\n  /** Percentile clip for the contrast window as `[lo, hi]` fractions, so a\n   *  handful of saturated observations don't flatten the rest. */\n   percentileClip: [number, number];\n  /**\n   * Colormap for CONTINUOUS spatial colouring — a gene, a numeric column — as a\n   * {@link ColormapValue}, the same shape the display colormap carries: a scale\n   * NAME for the built-ins, or an inline `[stop, colour]` array for the rest.\n   * Null follows the display colormap.\n   *\n   * Its own setting because the display colormap belongs to the tissue image and\n   * is usually a grey ramp, which is the wrong thing to read a measurement\n   * through: grey over grey cannot be told apart from the anatomy. Following it\n   * (with a Viridis fallback for exactly that case) is a reasonable default and a\n   * poor ceiling, since which gradient reads best is a judgement about the data.\n   *\n   * One setting for the markers, the 2D gene map and the 3D gene map together, so\n   * the field under the cells and the cells over it cannot disagree about what a\n   * colour means — and the panel's own colour bar is built from it too.\n   */\n  continuousColormap: ColormapValue | null;\n  /**\n   * What the 3D scene draws. The three things in it — the reference volume, the\n   * observation cloud and the cluster density volumes — occupy the same space, so\n   * any two of them hide each other to some degree. These are independent because\n   * the useful views are the combinations: the volumes alone to read an estimated\n   * distribution, one section's cells over them to check that estimate against the\n   * measurement, the anatomy alone to find a landmark.\n   *\n   * Visibility only — the layers stay built, so toggling one back on is immediate\n   * and does not re-run a rasterisation. {@link densityVolume} is the exception and\n   * genuinely gates construction, because building six volumes is not free.\n   */\n  showVolume: boolean;\n  /**\n   * The reference volume's opacity.\n   *\n   * Its own, not {@link opacity} (which belongs to the markers): the volume is a\n   * BACKDROP, and reading the cloud or a density field through it means turning\n   * the anatomy down without touching the data drawn over it. Ranges lower than\n   * the markers' slider for the same reason — a faint anatomical hint is a useful\n   * setting for a backdrop and a useless one for the measurement.\n   */\n  volumeOpacity: number;\n  /** Draw the observation cloud (3D). */\n  showPoints: boolean;\n  /**\n   * Restrict the cloud to ONE imaged section, by index into the dataset's sampled\n   * sections; null draws every section.\n   *\n   * The whole cloud is a stack of discs that hides whatever is drawn between them.\n   * One section at a time is the view that answers \"does the estimated field\n   * actually follow the cells I measured\" — and it is only offered for data that\n   * really is sectioned (see `sampledSections`).\n   */\n  pointSection: number | null;\n  /**\n   * Draw each cluster as a translucent DENSITY volume alongside the 3D cloud.\n   *\n   * Serial sections hundreds of microns apart make a cloud hard to read as an\n   * anatomical distribution — the eye cannot integrate discs into a shape. A\n   * density field can be estimated between the imaged planes (a continuous\n   * estimate, unlike individual cells, which have no correspondence to\n   * interpolate along) and renders as a cloud that reads as an estimate.\n   */\n  densityVolume: boolean;\n  /** Multiplier on the default kernel bandwidth. Above 1 is smoother and less\n   *  committal; below 1 exposes the individual sections. */\n  densitySmoothing: number;\n  /**\n   * Draw the active GENE as a continuous field under the observations (2D).\n   *\n   * Colouring the markers by a gene says which cells express it; it cannot say\n   * where, because the eye will not integrate thousands of dots into a territory.\n   * The field is an estimate — a kernel-weighted mean per cell, transparent where\n   * no cell was measured — and it is drawn beneath the cells, not instead of them,\n   * so the measurement stays on screen next to the interpolation.\n   *\n   * Ignored unless the colour source is a gene: there is nothing else to map.\n   */\n  geneMap: boolean;\n  /**\n   * Restrict the 3D gene map to ONE imaged section, by index into the dataset's\n   * sampled sections; null draws every section's sheet.\n   *\n   * Separate from {@link pointSection} so the combinations stay open: all the\n   * sheets with one section's cells over them is a useful view, and so is one\n   * sheet inside the whole cloud. Ignored while {@link geneMapVolume} is set —\n   * interpolating a single section along z would smear one slide through the\n   * specimen's whole depth and call it an estimate.\n   */\n  geneMapSection: number | null;\n  /**\n   * Smooth the per-section gene maps along z into a continuous VOLUME (3D).\n   *\n   * The sheets are what was measured — one field per imaged slide, with the gaps\n   * between them empty. This turns them into an estimate defined between the\n   * slides, the same move the cluster density volumes make and with the same\n   * caveat: a field may be interpolated between sections, individual cells may\n   * not, and the result is drawn as a translucent cloud so it cannot be mistaken\n   * for measurement.\n   */\n  geneMapVolume: boolean;\n  /** Multiplier on the gene map's kernel bandwidth. */\n  geneMapSmoothing: number;\n  /** The gene map's own opacity. Separate from {@link opacity}, which belongs to\n   *  the markers: turning the cells down to read the field underneath must not\n   *  turn the field down with them. */\n  geneMapOpacity: number;\n}\n\nexport const DEFAULT_SPATIAL_VIEW: SpatialViewState = {\n  colorBy: null,\n  pointScale: 1,\n  opacity: 1,\n  logScale: false,\n  percentileClip: [0.01, 0.99],\n  continuousColormap: null,\n  showVolume: true,\n  volumeOpacity: 0.5,\n  showPoints: true,\n  pointSection: null,\n  densityVolume: false,\n  densitySmoothing: 1,\n  geneMap: false,\n  geneMapSection: null,\n  geneMapVolume: false,\n  geneMapSmoothing: 1,\n  geneMapOpacity: 0.85,\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display-types.js","sourceRoot":"","sources":["../../../../src/lib/contracts/display-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAkRH,MAAM,CAAC,MAAM,oBAAoB,GAAqB;IACpD,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,CAAC;IACb,OAAO,EAAE,CAAC;IACV,QAAQ,EAAE,KAAK;IACf,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;IAC5B,kBAAkB,EAAE,IAAI;IACxB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,GAAG;IAClB,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,IAAI;IAClB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,OAAO,EAAE,KAAK;IACd,cAAc,EAAE,IAAI;IACpB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,cAAc,EAAE,IAAI;IACpB,SAAS,EAAE,IAAI;IACf,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,MAAM;IAChB,WAAW,EAAE,IAAI;IACjB,cAAc,EAAE,IAAI;IACpB,eAAe,EAAE,EAAE;IACnB,qBAAqB,EAAE,EAAE;IACzB,oBAAoB,EAAE,EAAE;IACxB,oBAAoB,EAAE,EAAE;IACxB,kBAAkB,EAAE,KAAK;IACzB,gBAAgB,EAAE,OAAO;IACzB,cAAc,EAAE,KAAK;IACrB,iBAAiB,EAAE,UAAU;IAC7B,gBAAgB,EAAE,EAAE;IACpB,eAAe,EAAE,CAAC;IAClB,iBAAiB,EAAE,GAAG;IACtB,iBAAiB,EAAE,MAAM;IACzB,cAAc,EAAE,GAAG;IACnB,UAAU,EAAE,EAAE;IACd,YAAY,EAAE,IAAI;IAClB,eAAe,EAAE,IAAI;IACrB,aAAa,EAAE,OAAO;IACtB,aAAa,EAAE,IAAI;IACnB,eAAe,EAAE,SAAS;IAC1B,YAAY,EAAE,EAAE;IAChB,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,IAAI;CACtB,CAAC","sourcesContent":["/**\n * Publication-critical types that were `any` on the public contracts\n * (refactoring plan, Step 6). Deliberately permissive — every field optional —\n * so existing hosts (which pass PrimeNG `TreeNode`s and plain option objects)\n * keep compiling unchanged while consumers finally get named shapes.\n */\n\n/** A colormap value as Plotly understands it: a built-in scale name (e.g.\n *  'Viridis') or an inline array of `[stop, color]` pairs. */\nexport type ColormapValue = string | Array<[number, string]>;\n\n/** One node of the colormap selector tree (structurally compatible with the\n *  PrimeNG `TreeNode`s the host passes): group nodes carry `children`, leaf\n *  nodes carry the scale in `data.value` (+ a preview image in `data.src`). */\nexport interface ColormapNode {\n  label?: string;\n  data?: { value?: ColormapValue; src?: string };\n  children?: ColormapNode[];\n}\n\n/** Magic-wand pixel-comparison space. */\nexport type WandType = 'GRAY' | 'RGB' | 'LAB_DISTANCE';\n\n/** Options for the magic-wand tool (QuPath-style). */\nexport interface IWandOptions {\n  type?: WandType;\n  /** Gaussian sigma applied to the patch before thresholding. */\n  sigma?: number;\n  /** Higher = stricter (smaller selection) for GRAY/RGB; higher = looser for\n   *  LAB_DISTANCE — matches QuPath. */\n  sensitivity?: number;\n  /** Square patch size in pixels (must be odd). */\n  patchSize?: number;\n  /** When true, skip blur/threshold and flood-fill at exact-match\n   *  (Cmd/Ctrl-click in QuPath). */\n  simpleMode?: boolean;\n}\n\n/** Options for the brush region tool (QuPath-style). */\nexport interface IBrushOptions {\n  /** Brush diameter in matrix (image) pixels. */\n  size?: number;\n  /**\n   * Paint as one class: new regions take this label, and a stroke only extends\n   * or merges regions with the same label. Unset = the plain brush (label\n   * `'Region'`, extends any region). `setBrushMode(true, …)` sets the class in\n   * full; `setBrushOptions` changes it only when `label` or `color` is passed,\n   * so a size-only update keeps it.\n   */\n  label?: string;\n  /** Colour for the painted regions instead of the shape colour. Kept against preset re-apply. */\n  color?: string;\n}\n\n/** What drives point colour in the spatial-omics mode: an annotation column\n *  from the dataset, or one feature (gene) vector fetched on demand. */\nexport interface SpatialColorBy {\n  kind: 'column' | 'feature';\n  name: string;\n}\n\n/** Display state for the spatial-omics plot mode. Lives in `VisualizerStore`\n *  alongside the colormap/channel state so the renderer reacts to edits the\n *  same way it does for an image. */\nexport interface SpatialViewState {\n  /** Colour source; `null` renders every observation in one neutral colour\n   *  (useful on its own — it shows where the tissue actually is). */\n  colorBy: SpatialColorBy | null;\n  /** Multiplier on the dataset's physical marker size. 1 = true size, which for\n   *  a 55 µm Visium spot is correct but can be invisible when zoomed out. */\n  pointScale: number;\n  /** Alpha for points that are not muted. */\n  opacity: number;\n  /** Log-scale continuous values before mapping them onto the colormap. Seeded\n   *  from the column's `logScaleHint` — count data needs it. */\n  logScale: boolean;\n  /** Percentile clip for the contrast window as `[lo, hi]` fractions, so a\n   *  handful of saturated observations don't flatten the rest. */\n   percentileClip: [number, number];\n  /**\n   * Colormap for CONTINUOUS spatial colouring — a gene, a numeric column — as a\n   * {@link ColormapValue}, the same shape the display colormap carries: a scale\n   * NAME for the built-ins, or an inline `[stop, colour]` array for the rest.\n   * Null follows the display colormap.\n   *\n   * Its own setting because the display colormap belongs to the tissue image and\n   * is usually a grey ramp, which is the wrong thing to read a measurement\n   * through: grey over grey cannot be told apart from the anatomy. Following it\n   * (with a Viridis fallback for exactly that case) is a reasonable default and a\n   * poor ceiling, since which gradient reads best is a judgement about the data.\n   *\n   * One setting for the markers, the 2D gene map and the 3D gene map together, so\n   * the field under the cells and the cells over it cannot disagree about what a\n   * colour means — and the panel's own colour bar is built from it too.\n   */\n  continuousColormap: ColormapValue | null;\n  /**\n   * What the 3D scene draws. The three things in it — the reference volume, the\n   * observation cloud and the cluster density volumes — occupy the same space, so\n   * any two of them hide each other to some degree. These are independent because\n   * the useful views are the combinations: the volumes alone to read an estimated\n   * distribution, one section's cells over them to check that estimate against the\n   * measurement, the anatomy alone to find a landmark.\n   *\n   * Visibility only — the layers stay built, so toggling one back on is immediate\n   * and does not re-run a rasterisation. {@link densityVolume} is the exception and\n   * genuinely gates construction, because building six volumes is not free.\n   */\n  showVolume: boolean;\n  /**\n   * The reference volume's opacity.\n   *\n   * Its own, not {@link opacity} (which belongs to the markers): the volume is a\n   * BACKDROP, and reading the cloud or a density field through it means turning\n   * the anatomy down without touching the data drawn over it. Ranges lower than\n   * the markers' slider for the same reason — a faint anatomical hint is a useful\n   * setting for a backdrop and a useless one for the measurement.\n   */\n  volumeOpacity: number;\n  /** Draw the observation markers — the 3D cloud, or the 2D circles. In 2D they also\n   *  stand in for cells too small on screen to outline. */\n  showPoints: boolean;\n  /**\n   * Restrict the cloud to ONE imaged section, by index into the dataset's sampled\n   * sections; null draws every section.\n   *\n   * The whole cloud is a stack of discs that hides whatever is drawn between them.\n   * One section at a time is the view that answers \"does the estimated field\n   * actually follow the cells I measured\" — and it is only offered for data that\n   * really is sectioned (see `sampledSections`).\n   */\n  pointSection: number | null;\n  /**\n   * Draw each cluster as a translucent DENSITY volume alongside the 3D cloud.\n   *\n   * Serial sections hundreds of microns apart make a cloud hard to read as an\n   * anatomical distribution — the eye cannot integrate discs into a shape. A\n   * density field can be estimated between the imaged planes (a continuous\n   * estimate, unlike individual cells, which have no correspondence to\n   * interpolate along) and renders as a cloud that reads as an estimate.\n   */\n  densityVolume: boolean;\n  /** Multiplier on the default kernel bandwidth. Above 1 is smoother and less\n   *  committal; below 1 exposes the individual sections. */\n  densitySmoothing: number;\n  /**\n   * Draw the active GENE as a continuous field under the observations (2D).\n   *\n   * Colouring the markers by a gene says which cells express it; it cannot say\n   * where, because the eye will not integrate thousands of dots into a territory.\n   * The field is an estimate — a kernel-weighted mean per cell, transparent where\n   * no cell was measured — and it is drawn beneath the cells, not instead of them,\n   * so the measurement stays on screen next to the interpolation.\n   *\n   * Ignored unless the colour source is a gene: there is nothing else to map.\n   */\n  geneMap: boolean;\n  /**\n   * Restrict the 3D gene map to ONE imaged section, by index into the dataset's\n   * sampled sections; null draws every section's sheet.\n   *\n   * Separate from {@link pointSection} so the combinations stay open: all the\n   * sheets with one section's cells over them is a useful view, and so is one\n   * sheet inside the whole cloud. Ignored while {@link geneMapVolume} is set —\n   * interpolating a single section along z would smear one slide through the\n   * specimen's whole depth and call it an estimate.\n   */\n  geneMapSection: number | null;\n  /**\n   * Smooth the per-section gene maps along z into a continuous VOLUME (3D).\n   *\n   * The sheets are what was measured — one field per imaged slide, with the gaps\n   * between them empty. This turns them into an estimate defined between the\n   * slides, the same move the cluster density volumes make and with the same\n   * caveat: a field may be interpolated between sections, individual cells may\n   * not, and the result is drawn as a translucent cloud so it cannot be mistaken\n   * for measurement.\n   */\n  geneMapVolume: boolean;\n  /** Multiplier on the gene map's kernel bandwidth. */\n  geneMapSmoothing: number;\n  /** The gene map's own opacity. Separate from {@link opacity}, which belongs to\n   *  the markers: turning the cells down to read the field underneath must not\n   *  turn the field down with them. */\n  geneMapOpacity: number;\n  /**\n   * Draw cell boundaries (for a dataset with `polygonTiles` or `polygons`).\n   *\n   * Outlines are level-of-detail: coarse rings when zoomed out, every vertex at the\n   * finest zoom, and none at all once a cell is a few pixels wide — there the\n   * observation markers already draw it as a dot.\n   *\n   * `null` (the default) means automatic: on for any dataset that has outlines, since a\n   * segmented cell is better shown as its shape than as a circle. A boolean is the\n   * user's explicit choice.\n   */\n  showCells: boolean | null;\n  /** Which boundary set (`cell`, `nucleus`, or `both` — cells as set by\n   *  {@link cellDraw}, nuclei outlined over them); null takes the dataset's default. */\n  cellSet: string | null;\n  /**\n   * What colours the cells — Xenium Explorer's \"Cell Color\": the active group\n   * ({@link cellTypeColumn}), one gene's expression ({@link cellColorGene}), the cell's\n   * transcript density, one flat colour, or how the cell was segmented.\n   */\n  cellColorMode: 'group' | 'gene' | 'transcriptDensity' | 'single' | 'segmentation';\n  cellColorGene: string | null;\n  /** `#rrggbb` for {@link cellColorMode} `single`. */\n  cellSingleColor: string;\n  /**\n   * Categories of {@link cellTypeColumn} switched off in the groups list: their cells are\n   * not drawn, nor the transcripts inside them. Cleared when the group column changes.\n   */\n  hiddenGroups: string[];\n  /** Draw the tissue image (the Images section's switch). */\n  showImage: boolean;\n  /** Draw the annotation regions (the Annotations section's switch). Selecting from them\n   *  still works while they are hidden. */\n  showAnnotations: boolean;\n  /** Fill the cells with their colour, outline them, or both. */\n  cellDraw: 'fill' | 'outline' | 'both';\n  /** Opacity of the cell fill (outlines draw opaque). */\n  cellOpacity: number;\n  /**\n   * The categorical column that says what TYPE each cell is: it colours the cells\n   * whenever nothing else is chosen, and it colours every transcript by the cell it\n   * falls in. Null picks the dataset's first categorical column. Swapping between a\n   * pipeline's clustering and a curated annotation is swapping this.\n   */\n  cellTypeColumn: string | null;\n  /** Genes whose transcripts are drawn. */\n  transcriptGenes: string[];\n  /** Selected genes switched off with their eye toggle — kept in the list, not drawn. */\n  transcriptHiddenGenes: string[];\n  /** Per-gene marker colour (`#rrggbb`); genes not listed take the palette by position. */\n  transcriptGeneColors: Record<string, string>;\n  /** Named gene groups (e.g. marker genes per cell type) for the selected-genes tree. */\n  transcriptGeneGroups: { name: string; genes: string[] }[];\n  /**\n   * Draw EVERY gene's transcripts instead of {@link transcriptGenes}: grouped into bins\n   * sized by how many transcripts they hold, finer as the camera zooms in, down to one\n   * marker per transcript once those fit {@link transcriptBudget}.\n   */\n  transcriptAllGenes: boolean;\n  /**\n   * Most transcript markers drawn at once. The level of detail is chosen to stay under it,\n   * which is what keeps pan and zoom responsive however dense the data is.\n   */\n  transcriptBudget: number;\n  /**\n   * How transcripts are drawn: `circles` sized by how many transcripts each stands for,\n   * `glyphs` (one icon shape per gene), or a `density` raster. Circles and glyphs are\n   * level-of-detail — aggregated when zoomed out, one per transcript at the finest zoom.\n   */\n  transcriptMode: 'off' | 'circles' | 'glyphs' | 'density';\n  /** Colour transcripts by the type of the cell they fall in, or by gene. */\n  transcriptColorBy: 'cellType' | 'gene';\n  /** Glyph per gene for `glyphs` mode; genes not listed take one by position. */\n  transcriptGlyphs: Record<string, TranscriptGlyphName>;\n  /** Multiplier on transcript marker size. */\n  transcriptScale: number;\n  transcriptOpacity: number;\n  /** `high` keeps only confidently decoded transcripts. */\n  transcriptQuality: 'high' | 'all';\n  /** Opacity of the transcript density raster. */\n  densityOpacity: number;\n  /** Density bin edge in observation units (µm): 10, 20, 40 or 80. */\n  densityBin: number;\n  /** Colour window in transcripts per unit² (µm²); null derives it from the data. */\n  densityRange: [number, number] | null;\n  /** Colormap for the density bins; null uses Inferno. */\n  densityColormap: ColormapValue | null;\n}\n\n/** Transcript glyph names — see `TRANSCRIPT_GLYPHS` in `spatial/spatial-tiles.ts`. */\nexport type TranscriptGlyphName =\n  | 'circle' | 'star' | 'triangle' | 'square' | 'diamond' | 'cross' | 'hexagon'\n  | 'triangle-down' | 'pentagon' | 'x';\n\nexport const DEFAULT_SPATIAL_VIEW: SpatialViewState = {\n  colorBy: null,\n  pointScale: 1,\n  opacity: 1,\n  logScale: false,\n  percentileClip: [0.01, 0.99],\n  continuousColormap: null,\n  showVolume: true,\n  volumeOpacity: 0.5,\n  showPoints: true,\n  pointSection: null,\n  densityVolume: false,\n  densitySmoothing: 1,\n  geneMap: false,\n  geneMapSection: null,\n  geneMapVolume: false,\n  geneMapSmoothing: 1,\n  geneMapOpacity: 0.85,\n  showCells: null,\n  cellSet: null,\n  cellDraw: 'fill',\n  cellOpacity: 0.55,\n  cellTypeColumn: null,\n  transcriptGenes: [],\n  transcriptHiddenGenes: [],\n  transcriptGeneColors: {},\n  transcriptGeneGroups: [],\n  transcriptAllGenes: false,\n  transcriptBudget: 100_000,\n  transcriptMode: 'off',\n  transcriptColorBy: 'cellType',\n  transcriptGlyphs: {},\n  transcriptScale: 1,\n  transcriptOpacity: 0.9,\n  transcriptQuality: 'high',\n  densityOpacity: 0.8,\n  densityBin: 10,\n  densityRange: null,\n  densityColormap: null,\n  cellColorMode: 'group',\n  cellColorGene: null,\n  cellSingleColor: '#4fc3f7',\n  hiddenGroups: [],\n  showImage: true,\n  showAnnotations: true,\n};\n"]}

package/esm2022/lib/contracts/plot-type-contribution.contract.mjs

@@ -63,4 +63,4 @@ export const PLOT_MODE_SESSION = new InjectionToken('PLOT_MODE_SESSION');
 export function contributedPlotTypeOption(d, base) {
     return { ...d, source: base.source };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-type-contribution.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/plot-type-contribution.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,EAAE,cAAc,EAAQ,MAAM,eAAe,CAAC;AAsGrD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAClC,IAAI,cAAc,CAAkC,yBAAyB,CAAC,CAAC;AACjF,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC;AAC1F,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC;AAa1F,mFAAmF;AACnF,MAAM,UAAU,yBAAyB,CACvC,CAAgC,EAChC,IAAwB;IAExB,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;AACvC,CAAC","sourcesContent":["/**\n * How a plot mode gets into the plot-type selector without this library knowing\n * what it is.\n *\n * A package contributes a mode by providing a {@link PlotTypeContribution} on the\n * {@link PLOT_TYPE_CONTRIBUTIONS} multi-provider token, the same way\n * `TOOLBAR_TOOLS` contributes toolbar tools. Nothing registers at import time:\n * installing a package makes a mode available, and adding its provider turns it\n * on. A plain object works, so the contributing package needs no Angular\n * compiler and no decorators:\n *\n *     { provide: PLOT_TYPE_CONTRIBUTIONS, useValue: myContribution, multi: true }\n *     { provide: PLOT_TYPE_CONTRIBUTIONS, useFactory: () => makeContribution(), multi: true }\n *\n * Provide nothing and the selector, the render path and the panel area behave\n * exactly as they did before this extension point existed.\n *\n * WHY A CONTRIBUTED MODE RIDES ON A BUILT-IN ONE\n * A contributed mode does not bring a renderer. It names a built-in\n * {@link ContributedPlotTypeDescriptor.baseType} — in v1 only `PlotType.IMAGE`,\n * the OpenSeadragon view — and the visualizer plots exactly as if that type had\n * been selected: same backend, same toolbar, same region tools, same wheel\n * handling. The contribution then draws over it through the\n * {@link PlotModeViewport} and talks to the viewer through the public\n * {@link IVisualizer}. That keeps every rendering decision in one place and means\n * a contribution can never be half-supported by some code path that switches on\n * the plot type.\n *\n * WHAT THE VISUALIZER GUARANTEES\n *  1. Contributed descriptors are appended after the built-in ones and curated by\n *     the same `productionLabel` / test-mode / `requires*` rules.\n *  2. Selecting one plots with `baseType`'s backend, then calls `activate(ctx)`\n *     once the viewport is ready.\n *  3. Leaving the mode — another type, an image switch (or any re-render of the\n *     base view), or the visualizer being destroyed — calls `session.deactivate()`\n *     exactly once, before the next mode draws. If the mode is still selected\n *     when the new image has plotted, a fresh session is activated for it.\n *  4. `panel` is shown only while a session is live.\n *  5. A thrown error or rejected promise from `activate`, `deactivate`, `mount`\n *     or a mount's teardown is caught and logged; none escapes, so a contribution\n *     cannot break the viewer. Failing to start (`activate`, `mount`, or a panel\n *     component throwing while it is created / first rendered) falls back\n *     to `baseType`. Failing to clean up falls back when that same mode is being\n *     re-activated (base re-render, image switch) — immediately if it already is\n *     live again — and is only logged when the user has moved to another mode; the\n *     user explicitly selecting it again gets a fresh attempt.\n *  6. {@link PLOT_TYPE_CONTRIBUTIONS} has no factory: no providers, no modes.\n */\nimport { InjectionToken, Type } from '@angular/core';\nimport type { Observable } from 'rxjs';\n\nimport type { IImageInfo } from './image.contract';\nimport type { PlotType, PlotTypeDescriptor, PlotTypeId } from './plot-type';\nimport type { IVisualizer } from './visualizer.contract';\n\n/** A rectangle in level-0 image pixels. */\nexport interface PlotModeRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Selector metadata for a contributed plot mode. */\nexport interface ContributedPlotTypeDescriptor {\n  /** Unique id, namespaced, e.g. 'dianne'. Must not clash with PlotType values. */\n  type: string;\n  /** Test-mode label, e.g. 'Digital Pathology - DIANNE'. */\n  label: string;\n  /** Default-selector label; omit to make the mode test-only (same rule as built-ins). */\n  productionLabel?: string;\n  /** 'pi pi-…' class or asset path, same as PlotTypeDescriptor.icon. */\n  icon?: string;\n  /** Always '2d' in v1. */\n  dimensions: '2d';\n  /** Built-in type whose backend renders the base image. v1 supports PlotType.IMAGE (OSD). */\n  baseType: PlotType;\n  /** Same gates as PlotTypeDescriptor, evaluated in addition to the base type's own. */\n  requiresGrayscale?: boolean;\n  requiresStack?: boolean;\n  /** Hidden until a `SpatialDataset` is published on SPATIAL_DATA_PORT (an overlay of spatial observations). */\n  requiresSpatialData?: boolean;\n  /** Hidden unless the published dataset carries `observations.z`. */\n  requiresSpatial3d?: boolean;\n}\n\n/** The base view's viewport, as a contributed mode sees it. */\nexport interface PlotModeViewport {\n  /** Element the mode's overlay canvas/SVG attaches to; fills the plot area. */\n  getOverlayContainer(): HTMLElement | null;\n  /** Level-0 image px -> client px, and the reverse. */\n  dataToClient(x: number, y: number): { x: number; y: number };\n  clientToData(clientX: number, clientY: number): { x: number; y: number };\n  /** Screen px per image px at the current zoom. */\n  dataLengthToScreen(len: number): number;\n  isReady(): boolean;\n  /** Visible image rect in level-0 px, emitted on every redraw frame (pan/zoom animation).\n   *  A new subscriber first receives the current rect when the viewport is ready. */\n  frame$: Observable<PlotModeRect>;\n  /** Same rect, emitted once the viewport settles (existing getViewportChange$ semantics).\n   *  A new subscriber first receives the current rect when the viewport is ready. */\n  settled$: Observable<PlotModeRect>;\n}\n\n/** Everything a contributed mode gets to work with while it is active. */\nexport interface PlotModeContext {\n  /** Full public visualizer API: regions, region overlay (tool modes), undo, etc. */\n  visualizer: IVisualizer;\n  viewport: PlotModeViewport;\n  /** Current image info from IMAGE_STATE_PORT (null until an image is loaded). */\n  imageInfo$: Observable<IImageInfo | null>;\n}\n\n/** A live activation of a contributed mode. */\nexport interface PlotModeSession {\n  /** Called when the user leaves the mode, the image changes, or the visualizer is destroyed. */\n  deactivate(): void;\n}\n\n/**\n * The mode's side panel, shown in the visualizer's right-hand panel area while\n * a session is live. Two forms:\n *\n *  - `component`: an Angular component, rendered through `NgComponentOutlet`\n *    with {@link PLOT_MODE_CONTEXT} and {@link PLOT_MODE_SESSION} in its\n *    injector. Needs an AOT-compiled (partial-Ivy) component.\n *  - `mount`: framework-agnostic. The visualizer hands over an empty host\n *    element after `activate` resolves; the function renders into it and returns\n *    a teardown. The teardown is called exactly once when the mode deactivates,\n *    before `session.deactivate()`, and the host element is then removed.\n */\nexport type PlotModePanel =\n  | { title: string; component: Type<unknown> }\n  | {\n      title: string;\n      mount(host: HTMLElement, ctx: PlotModeContext, session: PlotModeSession): () => void;\n    };\n\n/** A plot mode contributed to the selector. A plain object is enough. */\nexport interface PlotTypeContribution {\n  descriptor: ContributedPlotTypeDescriptor;\n  /** Called after the base backend has plotted the image in this mode. */\n  activate(ctx: PlotModeContext): PlotModeSession | Promise<PlotModeSession>;\n  /**\n   * Optional side panel, rendered in the visualizer's right-hand panel area while the\n   * mode is active. A component panel can inject PLOT_MODE_CONTEXT and PLOT_MODE_SESSION.\n   */\n  panel?: PlotModePanel;\n}\n\n/**\n * Multi-provider token for contributed plot modes.\n *\n * Deliberately has no `factory`: unregistered means no contributed modes, and the\n * library behaves exactly as before. The visualizer injects it `{ optional: true }`\n * and treats null as empty.\n */\nexport const PLOT_TYPE_CONTRIBUTIONS =\n  new InjectionToken<readonly PlotTypeContribution[]>('PLOT_TYPE_CONTRIBUTIONS');\n/** The active mode's context, in a component panel's injector. */\nexport const PLOT_MODE_CONTEXT = new InjectionToken<PlotModeContext>('PLOT_MODE_CONTEXT');\n/** The active mode's session, in a component panel's injector. */\nexport const PLOT_MODE_SESSION = new InjectionToken<PlotModeSession>('PLOT_MODE_SESSION');\n\n/**\n * One entry in the plot-type selector: a built-in {@link PlotTypeDescriptor}\n * as-is, or a contributed descriptor completed with its base type's `source`.\n * Every entry therefore carries the same fields the selector curates by.\n */\nexport interface PlotTypeOption extends Omit<PlotTypeDescriptor, 'type'> {\n  type: PlotTypeId;\n  /** Set only for a contributed mode: the built-in type that renders it. */\n  baseType?: PlotType;\n}\n\n/** The selector entry for a contributed mode, given its base type's descriptor. */\nexport function contributedPlotTypeOption(\n  d: ContributedPlotTypeDescriptor,\n  base: PlotTypeDescriptor,\n): PlotTypeOption {\n  return { ...d, source: base.source };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-type-contribution.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/plot-type-contribution.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,EAAE,cAAc,EAAQ,MAAM,eAAe,CAAC;AAmIrD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAClC,IAAI,cAAc,CAAkC,yBAAyB,CAAC,CAAC;AACjF,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC;AAC1F,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC;AAa1F,mFAAmF;AACnF,MAAM,UAAU,yBAAyB,CACvC,CAAgC,EAChC,IAAwB;IAExB,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;AACvC,CAAC","sourcesContent":["/**\n * How a plot mode gets into the plot-type selector without this library knowing\n * what it is.\n *\n * A package contributes a mode by providing a {@link PlotTypeContribution} on the\n * {@link PLOT_TYPE_CONTRIBUTIONS} multi-provider token, the same way\n * `TOOLBAR_TOOLS` contributes toolbar tools. Nothing registers at import time:\n * installing a package makes a mode available, and adding its provider turns it\n * on. A plain object works, so the contributing package needs no Angular\n * compiler and no decorators:\n *\n *     { provide: PLOT_TYPE_CONTRIBUTIONS, useValue: myContribution, multi: true }\n *     { provide: PLOT_TYPE_CONTRIBUTIONS, useFactory: () => makeContribution(), multi: true }\n *\n * Provide nothing and the selector, the render path and the panel area behave\n * exactly as they did before this extension point existed.\n *\n * WHY A CONTRIBUTED MODE RIDES ON A BUILT-IN ONE\n * A contributed mode does not bring a renderer. It names a built-in\n * {@link ContributedPlotTypeDescriptor.baseType} — in v1 only `PlotType.IMAGE`,\n * the OpenSeadragon view — and the visualizer plots exactly as if that type had\n * been selected: same backend, same toolbar, same region tools, same wheel\n * handling. The contribution then draws over it through the\n * {@link PlotModeViewport} and talks to the viewer through the public\n * {@link IVisualizer}. That keeps every rendering decision in one place and means\n * a contribution can never be half-supported by some code path that switches on\n * the plot type.\n *\n * WHAT THE VISUALIZER GUARANTEES\n *  1. Contributed descriptors are appended after the built-in ones and curated by\n *     the same `productionLabel` / test-mode / `requires*` rules.\n *  2. Selecting one plots with `baseType`'s backend, then calls `activate(ctx)`\n *     once the viewport is ready.\n *  3. Leaving the mode — another type, an image switch (or any re-render of the\n *     base view), or the visualizer being destroyed — calls `session.deactivate()`\n *     exactly once, before the next mode draws. If the mode is still selected\n *     when the new image has plotted, a fresh session is activated for it.\n *  4. `panel` is shown only while a session is live.\n *  5. A thrown error or rejected promise from `activate`, `deactivate`, `mount`\n *     or a mount's teardown is caught and logged; none escapes, so a contribution\n *     cannot break the viewer. Failing to start (`activate`, `mount`, or a panel\n *     component throwing while it is created / first rendered) falls back\n *     to `baseType`. Failing to clean up falls back when that same mode is being\n *     re-activated (base re-render, image switch) — immediately if it already is\n *     live again — and is only logged when the user has moved to another mode; the\n *     user explicitly selecting it again gets a fresh attempt.\n *  6. {@link PLOT_TYPE_CONTRIBUTIONS} has no factory: no providers, no modes.\n */\nimport { InjectionToken, Type } from '@angular/core';\nimport type { Observable } from 'rxjs';\n\nimport type { IImageInfo } from './image.contract';\nimport type { PlotType, PlotTypeDescriptor, PlotTypeId } from './plot-type';\nimport type { IVisualizer } from './visualizer.contract';\n\n/** A rectangle in level-0 image pixels. */\nexport interface PlotModeRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Selector metadata for a contributed plot mode. */\nexport interface ContributedPlotTypeDescriptor {\n  /** Unique id, namespaced, e.g. 'dianne'. Must not clash with PlotType values. */\n  type: string;\n  /** Test-mode label, e.g. 'Digital Pathology - DIANNE'. */\n  label: string;\n  /** Default-selector label; omit to make the mode test-only (same rule as built-ins). */\n  productionLabel?: string;\n  /** 'pi pi-…' class or asset path, same as PlotTypeDescriptor.icon. */\n  icon?: string;\n  /** Always '2d' in v1. */\n  dimensions: '2d';\n  /** Built-in type whose backend renders the base image. v1 supports PlotType.IMAGE (OSD). */\n  baseType: PlotType;\n  /** Same gates as PlotTypeDescriptor, evaluated in addition to the base type's own. */\n  requiresGrayscale?: boolean;\n  requiresStack?: boolean;\n  /** Hidden until a `SpatialDataset` is published on SPATIAL_DATA_PORT (an overlay of spatial observations). */\n  requiresSpatialData?: boolean;\n  /** Hidden unless the published dataset carries `observations.z`. */\n  requiresSpatial3d?: boolean;\n}\n\n/** The base view's viewport, as a contributed mode sees it. */\nexport interface PlotModeViewport {\n  /** Element the mode's overlay canvas/SVG attaches to; fills the plot area. */\n  getOverlayContainer(): HTMLElement | null;\n  /** Level-0 image px -> client px, and the reverse. */\n  dataToClient(x: number, y: number): { x: number; y: number };\n  clientToData(clientX: number, clientY: number): { x: number; y: number };\n  /** Screen px per image px at the current zoom. */\n  dataLengthToScreen(len: number): number;\n  isReady(): boolean;\n  /** Visible image rect in level-0 px, emitted on every redraw frame (pan/zoom animation).\n   *  A new subscriber first receives the current rect when the viewport is ready. */\n  frame$: Observable<PlotModeRect>;\n  /** Same rect, emitted once the viewport settles (existing getViewportChange$ semantics).\n   *  A new subscriber first receives the current rect when the viewport is ready. */\n  settled$: Observable<PlotModeRect>;\n}\n\n/** The class a {@link PlotModeTools.armBrush} stroke paints. */\nexport interface PlotModeBrushClass {\n  /** Label for the painted regions; the stroke only extends or merges regions with it. */\n  label?: string;\n  /** Colour for the painted regions (instead of the toolbar's shape colour). */\n  color?: string;\n}\n\n/**\n * The visualizer's own toolbar tools, armed on a mode's behalf. Going through\n * this rather than {@link IVisualizer} keeps the toolbar in step: the armed\n * tool's button is highlighted and its controls (e.g. the brush size) show.\n */\nexport interface PlotModeTools {\n  /**\n   * Arm the toolbar brush, painting `brushClass`. Calling it again while the\n   * brush is armed switches class; the next stroke starts a region of it.\n   * The user picking any tool from the toolbar (including the brush) replaces\n   * this with the plain tool.\n   */\n  armBrush(brushClass?: PlotModeBrushClass): void;\n  /** Disarm whatever tool is armed, as if the user toggled it off. */\n  disarm(): void;\n  /** The armed toolbar tool id ('brush', 'pan', … or null). Replays the current value. */\n  activeTool$: Observable<string | null>;\n}\n\n/** Everything a contributed mode gets to work with while it is active. */\nexport interface PlotModeContext {\n  /** Full public visualizer API: regions, region overlay (tool modes), undo, etc. */\n  visualizer: IVisualizer;\n  viewport: PlotModeViewport;\n  /** Current image info from IMAGE_STATE_PORT (null until an image is loaded). */\n  imageInfo$: Observable<IImageInfo | null>;\n  /** Toolbar tools (since 0.6.0). Optional so a context built for 0.5.0 still type-checks. */\n  tools?: PlotModeTools;\n}\n\n/** A live activation of a contributed mode. */\nexport interface PlotModeSession {\n  /** Called when the user leaves the mode, the image changes, or the visualizer is destroyed. */\n  deactivate(): void;\n}\n\n/**\n * The mode's side panel, shown in the visualizer's right-hand panel area while\n * a session is live. Two forms:\n *\n *  - `component`: an Angular component, rendered through `NgComponentOutlet`\n *    with {@link PLOT_MODE_CONTEXT} and {@link PLOT_MODE_SESSION} in its\n *    injector. Needs an AOT-compiled (partial-Ivy) component.\n *  - `mount`: framework-agnostic. The visualizer hands over an empty host\n *    element after `activate` resolves; the function renders into it and returns\n *    a teardown. The teardown is called exactly once when the mode deactivates,\n *    before `session.deactivate()`, and the host element is then removed.\n */\nexport type PlotModePanel =\n  | { title: string; component: Type<unknown> }\n  | {\n      title: string;\n      mount(host: HTMLElement, ctx: PlotModeContext, session: PlotModeSession): () => void;\n    };\n\n/** A plot mode contributed to the selector. A plain object is enough. */\nexport interface PlotTypeContribution {\n  descriptor: ContributedPlotTypeDescriptor;\n  /** Called after the base backend has plotted the image in this mode. */\n  activate(ctx: PlotModeContext): PlotModeSession | Promise<PlotModeSession>;\n  /**\n   * Optional side panel, rendered in the visualizer's right-hand panel area while the\n   * mode is active. A component panel can inject PLOT_MODE_CONTEXT and PLOT_MODE_SESSION.\n   */\n  panel?: PlotModePanel;\n}\n\n/**\n * Multi-provider token for contributed plot modes.\n *\n * Deliberately has no `factory`: unregistered means no contributed modes, and the\n * library behaves exactly as before. The visualizer injects it `{ optional: true }`\n * and treats null as empty.\n */\nexport const PLOT_TYPE_CONTRIBUTIONS =\n  new InjectionToken<readonly PlotTypeContribution[]>('PLOT_TYPE_CONTRIBUTIONS');\n/** The active mode's context, in a component panel's injector. */\nexport const PLOT_MODE_CONTEXT = new InjectionToken<PlotModeContext>('PLOT_MODE_CONTEXT');\n/** The active mode's session, in a component panel's injector. */\nexport const PLOT_MODE_SESSION = new InjectionToken<PlotModeSession>('PLOT_MODE_SESSION');\n\n/**\n * One entry in the plot-type selector: a built-in {@link PlotTypeDescriptor}\n * as-is, or a contributed descriptor completed with its base type's `source`.\n * Every entry therefore carries the same fields the selector curates by.\n */\nexport interface PlotTypeOption extends Omit<PlotTypeDescriptor, 'type'> {\n  type: PlotTypeId;\n  /** Set only for a contributed mode: the built-in type that renders it. */\n  baseType?: PlotType;\n}\n\n/** The selector entry for a contributed mode, given its base type's descriptor. */\nexport function contributedPlotTypeOption(\n  d: ContributedPlotTypeDescriptor,\n  base: PlotTypeDescriptor,\n): PlotTypeOption {\n  return { ...d, source: base.source };\n}\n"]}

package/esm2022/lib/contracts/ports/spatial-data.port.mjs

@@ -1,3 +1,5 @@
 import { InjectionToken } from '@angular/core';
+/** {@link TranscriptTileQuery.genes} value meaning "every gene". */
+export const ALL_GENES = '*';
 export const SPATIAL_DATA_PORT = new InjectionToken('SPATIAL_DATA_PORT');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhdGlhbC1kYXRhLnBvcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbnRyYWN0cy9wb3J0cy9zcGF0aWFsLWRhdGEucG9ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBa0cvQyxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGNBQWMsQ0FBa0IsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7XG4gIFNwYXRpYWxDb2x1bW4sIFNwYXRpYWxEYXRhc2V0LCBTcGF0aWFsRW1iZWRkaW5nLCBTcGF0aWFsUG9seWdvbnMsXG59IGZyb20gJy4uL3NwYXRpYWwtZGF0YXNldC5jb250cmFjdCc7XG5cbi8qKlxuICogU3BhdGlhbC1vbWljcyBkYXRhIGFjY2VzcywgaW52ZXJ0ZWQgYXMgYSBwb3J0IHNvIHRoZSB2aXN1YWxpemF0aW9uIGxpYnJhcnlcbiAqIG5ldmVyIGxlYXJucyBob3cgdGhlIGRhdGEgaXMgc3RvcmVkIG9yIHNlcnZlZCDigJQgZXhhY3RseSBsaWtlXG4gKiBgVElMRV9BQ0NFU1NfUE9SVGAgZm9yIHRpbGVzIGFuZCBgUkVHSU9OX0lPX1BPUlRgIGZvciBhbm5vdGF0aW9ucy4gVGhlIGhvc3RcbiAqIHN1cHBsaWVzIGFuIGFkYXB0ZXI7IHRoZSBsaWJyYXJ5IGNvbnN1bWVzIHR5cGVkIGFycmF5cy5cbiAqXG4gKiBXSFkgQSBQT1JUIEFORCBOT1QgQSBSRUFERVJcbiAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuICogVGhlIGludGVyY2hhbmdlIGZvcm1hdCBmb3IgdGhpcyBkYXRhIChTcGF0aWFsRGF0YSBaYXJyIHYzICsgQW5uRGF0YVxuICogY29udmVudGlvbnMgKyBHZW9QYXJxdWV0IHNoYXBlcykgbmVlZHMgdGhyZWUgcGFyc2VycywgYW5kIGl0cyBleHByZXNzaW9uXG4gKiBtYXRyaXggaXMgc3RvcmVkIG9ic2VydmF0aW9uLW1ham9yIOKAlCBzbyByZWFkaW5nIGEgc2luZ2xlIGdlbmUncyBjb2x1bW4gbWVhbnNcbiAqIHRvdWNoaW5nIGV2ZXJ5IHJvdy4gQSBzZXJ2ZXIgY2FuIHByZS1pbmRleCB0aGF0IG9uY2U7IGEgYnJvd3NlciBjYW5ub3QuIFNvXG4gKiB0aGUgbGlicmFyeSB0YWtlcyB2ZWN0b3JzIGl0IGNhbiByZW5kZXIgYW5kIGxlYXZlcyBpbmdlc3QgdG8gd2hvZXZlciBvd25zIHRoZVxuICogZGF0YS4gYFNwYXRpYWxEYXRhSHR0cFNlcnZpY2VgIGlzIGEgcmVhZHktbWFkZSBhZGFwdGVyIGZvciB0aGUgd2lyZSBmb3JtYXRcbiAqIHRoZSBidW5kbGVkIGV4YW1wbGUgc2VydmVyIHNwZWFrczsgYSBob3N0IHdpdGggaXRzIG93biBiYWNrZW5kIGltcGxlbWVudHNcbiAqIHRoaXMgaW50ZXJmYWNlIGluc3RlYWQuXG4gKlxuICogTEFaSU5FU1MgSVMgVEhFIFBPSU5UXG4gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS1cbiAqIGBnZXREYXRhc2V0JCgpYCB5aWVsZHMgb25seSB3aGF0IGlzIGNoZWFwIHRvIGhvbGQ6IGNvb3JkaW5hdGVzIHBsdXMgY29sdW1uXG4gKiBhbmQgZmVhdHVyZSAqbWV0YWRhdGEqLiBFdmVyeSBhY2Nlc3NvciBiZWxvdyBmZXRjaGVzIG9uZSB2ZWN0b3IgYXQgYSB0aW1lLFxuICogZm9yIHRoZSBvbmUgY29sdW1uIG9yIGdlbmUgY3VycmVudGx5IGJlaW5nIGRpc3BsYXllZC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTcGF0aWFsRGF0YVBvcnQge1xuICAvKipcbiAgICogVGhlIGRhdGFzZXQgY3VycmVudGx5IGJlaW5nIHZpc3VhbGl6ZWQsIG9yIG51bGwgd2hlbiBub25lIGlzIHNlbGVjdGVkLlxuICAgKiBFbWl0cyBhZ2FpbiB3aGVuIHRoZSBob3N0IHN3aXRjaGVzIGRhdGFzZXRzLCBzbyB0aGUgdmlldyBjYW4gcmVidWlsZC5cbiAgICovXG4gIGdldERhdGFzZXQkKCk6IE9ic2VydmFibGU8U3BhdGlhbERhdGFzZXQgfCBudWxsPjtcblxuICAvKipcbiAgICogVmFsdWVzIGZvciBvbmUgYW5ub3RhdGlvbiBjb2x1bW4sIGluZGV4LWFsaWduZWQgd2l0aCB0aGUgb2JzZXJ2YXRpb25zLlxuICAgKiBUaGUgY29sdW1uIG11c3QgYmUgb25lIGFkdmVydGlzZWQgaW4gYFNwYXRpYWxEYXRhc2V0LmNvbHVtbnNgOyByZWplY3RcbiAgICogKGRvbid0IHJlc29sdmUgZW1wdHkpIHdoZW4gaXQgaXNuJ3QsIHNvIGEgdHlwbyBzdXJmYWNlcyBpbnN0ZWFkIG9mXG4gICAqIHJlbmRlcmluZyBhcyBcIm5vIGRhdGFcIi5cbiAgICpcbiAgICogSW1wbGVtZW50YXRpb25zIHNob3VsZCBjYWNoZSDigJQgY29sb3VyaW5nIGJ5IGNsdXN0ZXIsIHRoZW4gYnkgYSBnZW5lLCB0aGVuXG4gICAqIGJhY2sgYnkgY2x1c3RlciBtdXN0IG5vdCByZWZldGNoLlxuICAgKi9cbiAgZ2V0Q29sdW1uKG5hbWU6IHN0cmluZyk6IFByb21pc2U8U3BhdGlhbENvbHVtbj47XG5cbiAgLyoqXG4gICAqIE9uZSBmZWF0dXJlJ3MgKGdlbmUncykgZXhwcmVzc2lvbiB2ZWN0b3IsIGluZGV4LWFsaWduZWQgd2l0aCB0aGVcbiAgICogb2JzZXJ2YXRpb25zLiBSZWplY3RzIGZvciBhbiB1bmtub3duIGZlYXR1cmUuXG4gICAqL1xuICBnZXRGZWF0dXJlVmVjdG9yKG5hbWU6IHN0cmluZyk6IFByb21pc2U8RmxvYXQzMkFycmF5PjtcblxuICAvKipcbiAgICogT25lIGVtYmVkZGluZydzIGNvb3JkaW5hdGVzLCBpbmRleC1hbGlnbmVkIHdpdGggdGhlIG9ic2VydmF0aW9ucy5cbiAgICpcbiAgICogVGhlIG5hbWUgbXVzdCBiZSBvbmUgYWR2ZXJ0aXNlZCBpbiBgU3BhdGlhbERhdGFzZXQuZW1iZWRkaW5nc2A7IHJlamVjdHMgb3RoZXJ3aXNlLCBmb3IgdGhlXG4gICAqIHNhbWUgcmVhc29uIGBnZXRDb2x1bW5gIGRvZXMg4oCUIGEgdHlwbyBzaG91bGQgc3VyZmFjZSByYXRoZXIgdGhhbiByZW5kZXIgYXMgYW4gZW1wdHkgcGxvdC5cbiAgICpcbiAgICogT3B0aW9uYWw6IGEgaG9zdCB3aXRoIG5vIGVtYmVkZGluZ3Mgc2ltcGx5IG9taXRzIGl0LCBhbmQgdGhlIFVJIG9mZmVycyBubyBlbWJlZGRpbmcgdmlld3MuXG4gICAqL1xuICBnZXRFbWJlZGRpbmc/KG5hbWU6IHN0cmluZyk6IFByb21pc2U8U3BhdGlhbEVtYmVkZGluZz47XG5cbiAgLyoqXG4gICAqIFR5cGVhaGVhZCBvdmVyIGZlYXR1cmUgbmFtZXMsIGZvciBkYXRhc2V0cyB0b28gd2lkZSB0byBpbmxpbmUgdGhlIGxpc3RcbiAgICogKGBTcGF0aWFsRmVhdHVyZU1ldGEubmFtZXNgIGFic2VudCkuIE9wdGlvbmFsOiBhIGhvc3Qgd2hvc2UgcGFuZWwgaXMgc21hbGxcbiAgICogZW5vdWdoIHRvIGlubGluZSBldmVyeSBuYW1lIG5lZWQgbm90IGltcGxlbWVudCBpdCDigJQgdGhlIFVJIGZhbGxzIGJhY2sgdG9cbiAgICogZmlsdGVyaW5nIGBuYW1lc2AgbG9jYWxseS5cbiAgICovXG4gIHNlYXJjaEZlYXR1cmVzPyhxdWVyeTogc3RyaW5nLCBsaW1pdD86IG51bWJlcik6IFByb21pc2U8c3RyaW5nW10+O1xuXG4gIC8qKlxuICAgKiBQZXItb2JzZXJ2YXRpb24gYm91bmRhcnkgZ2VvbWV0cnksIHdoZW4gdGhlIGRhdGFzZXQgYWR2ZXJ0aXNlc1xuICAgKiBgcG9seWdvbnNgLiBPcHRpb25hbCDigJQgYSBzcG90LWJhc2VkIGFzc2F5IChWaXNpdW0pIGhhcyBubyBzZWdtZW50YXRpb24uXG4gICAqL1xuICBnZXRQb2x5Z29ucz8oKTogUHJvbWlzZTxTcGF0aWFsUG9seWdvbnM+O1xuXG4gIC8qKlxuICAgKiBUaGUgcmVmZXJlbmNlIHZvbHVtZSdzIHZveGVsczogYSB1aW50OCBzY2FsYXIgZmllbGQsIHgtZmFzdGVzdCwgb2YgZXhhY3RseVxuICAgKiBgd2lkdGggKiBoZWlnaHQgKiBkZXB0aGAgYnl0ZXMgYXMgdGhlIGRhdGFzZXQncyB7QGxpbmsgU3BhdGlhbFZvbHVtZU1ldGF9XG4gICAqIGRlY2xhcmVzLlxuICAgKlxuICAgKiBPcHRpb25hbCwgYW5kIG9ubHkgbWVhbmluZ2Z1bCB3aGVuIHRoZSBkYXRhc2V0IGFkdmVydGlzZXMgYSB2b2x1bWUuIFNlcGFyYXRlXG4gICAqIGZyb20gYGdldERhdGFzZXQkKClgIGJlY2F1c2UgaXQgaXMgbWVnYWJ5dGVzOiBhIGhvc3QgdGhhdCBuZXZlciBvcGVucyB0aGUgM0RcbiAgICogbW9kZSBzaG91bGQgbmV2ZXIgcGF5IGZvciBpdC5cbiAgICovXG4gIGdldFZvbHVtZT8oKTogUHJvbWlzZTxVaW50OEFycmF5PjtcblxuICAvKipcbiAgICogU2VydmVyLXNpZGUgXCJ3aGljaCBvYnNlcnZhdGlvbnMgZmFsbCBpbnNpZGUgdGhpcyBwb2x5Z29uXCIsIGZvciBkYXRhc2V0c1xuICAgKiB0b28gbGFyZ2UgdG8gaGl0LXRlc3QgY2xpZW50LXNpZGUuIE9wdGlvbmFsOiB3aXRob3V0IGl0IHRoZSBsaWJyYXJ5XG4gICAqIHBvaW50LWluLXBvbHlnb25zIHRoZSByZXNpZGVudCBjb29yZGluYXRlcyBpdHNlbGYsIHdoaWNoIGlzIGZpbmUgaW50byB0aGVcbiAgICogMTBeNSByYW5nZS4gQ29vcmRpbmF0ZXMgYXJlIGluIHRoZSBzYW1lIHNwYWNlIGFzIHRoZSBvYnNlcnZhdGlvbnMuXG4gICAqL1xuICBxdWVyeVJvaT8ocG9seWdvbjogeyB4OiBudW1iZXJbXTsgeTogbnVtYmVyW10gfSk6IFByb21pc2U8VWludDMyQXJyYXk+O1xufVxuXG5leHBvcnQgY29uc3QgU1BBVElBTF9EQVRBX1BPUlQgPSBuZXcgSW5qZWN0aW9uVG9rZW48U3BhdGlhbERhdGFQb3J0PignU1BBVElBTF9EQVRBX1BPUlQnKTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-data.port.js","sourceRoot":"","sources":["../../../../../src/lib/contracts/ports/spatial-data.port.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAuB/C,oEAAoE;AACpE,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC;AA4I7B,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC","sourcesContent":["import { InjectionToken } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport {\n  SpatialColumn, SpatialDataset, SpatialDensityRaster, SpatialEmbedding, SpatialPolygonTile,\n  CategoricalColumnMeta, SpatialPolygons, SpatialTranscriptCounts, SpatialTranscriptSummary,\n  SpatialTranscriptTile,\n} from '../spatial-dataset.contract';\n\n/** Options for {@link SpatialDataPort.getTranscriptTile}. */\nexport interface TranscriptTileQuery {\n  /**\n   * Genes to include, by name; the tile's `gene` codes index this list. `[ALL_GENES]`\n   * asks for every gene, unaggregated, at level 0 only and clipped to {@link box} — the\n   * `gene` codes are then the dataset's own gene indices.\n   */\n  genes: string[];\n  /** `high` (default) keeps only confidently decoded transcripts. */\n  quality?: 'high' | 'all';\n  /** Clip to `[x0, y0, x1, y1]` in observation units. */\n  box?: [number, number, number, number];\n}\n\n/** {@link TranscriptTileQuery.genes} value meaning \"every gene\". */\nexport const ALL_GENES = '*';\n\n/**\n * Spatial-omics data access, inverted as a port so the visualization library\n * never learns how the data is stored or served — exactly like\n * `TILE_ACCESS_PORT` for tiles and `REGION_IO_PORT` for annotations. The host\n * supplies an adapter; the library consumes typed arrays.\n *\n * WHY A PORT AND NOT A READER\n * ---------------------------\n * The interchange format for this data (SpatialData Zarr v3 + AnnData\n * conventions + GeoParquet shapes) needs three parsers, and its expression\n * matrix is stored observation-major — so reading a single gene's column means\n * touching every row. A server can pre-index that once; a browser cannot. So\n * the library takes vectors it can render and leaves ingest to whoever owns the\n * data. `SpatialDataHttpService` is a ready-made adapter for the wire format\n * the bundled example server speaks; a host with its own backend implements\n * this interface instead.\n *\n * LAZINESS IS THE POINT\n * ---------------------\n * `getDataset$()` yields only what is cheap to hold: coordinates plus column\n * and feature *metadata*. Every accessor below fetches one vector at a time,\n * for the one column or gene currently being displayed.\n */\nexport interface SpatialDataPort {\n  /**\n   * The dataset currently being visualized, or null when none is selected.\n   * Emits again when the host switches datasets, so the view can rebuild.\n   */\n  getDataset$(): Observable<SpatialDataset | null>;\n\n  /**\n   * Values for one annotation column, index-aligned with the observations.\n   * The column must be one advertised in `SpatialDataset.columns`; reject\n   * (don't resolve empty) when it isn't, so a typo surfaces instead of\n   * rendering as \"no data\".\n   *\n   * Implementations should cache — colouring by cluster, then by a gene, then\n   * back by cluster must not refetch.\n   */\n  getColumn(name: string): Promise<SpatialColumn>;\n\n  /**\n   * One feature's (gene's) expression vector, index-aligned with the\n   * observations. Rejects for an unknown feature.\n   */\n  getFeatureVector(name: string): Promise<Float32Array>;\n\n  /**\n   * One embedding's coordinates, index-aligned with the observations.\n   *\n   * The name must be one advertised in `SpatialDataset.embeddings`; rejects otherwise, for the\n   * same reason `getColumn` does — a typo should surface rather than render as an empty plot.\n   *\n   * Optional: a host with no embeddings simply omits it, and the UI offers no embedding views.\n   */\n  getEmbedding?(name: string): Promise<SpatialEmbedding>;\n\n  /**\n   * Typeahead over feature names, for datasets too wide to inline the list\n   * (`SpatialFeatureMeta.names` absent). Optional: a host whose panel is small\n   * enough to inline every name need not implement it — the UI falls back to\n   * filtering `names` locally.\n   */\n  searchFeatures?(query: string, limit?: number): Promise<string[]>;\n\n  /**\n   * Per-observation boundary geometry, when the dataset advertises\n   * `polygons`. Optional — a spot-based assay (Visium) has no segmentation.\n   */\n  getPolygons?(): Promise<SpatialPolygons>;\n\n  /**\n   * One tile of boundaries from `polygonTiles`. An empty tile resolves with `count` 0 —\n   * a tile outside the tissue is an answer, not an error. Optional: only datasets that\n   * advertise `polygonTiles` need it.\n   */\n  getPolygonTile?(set: string, level: number, gx: number, gy: number): Promise<SpatialPolygonTile>;\n\n  /**\n   * One tile of transcripts from `transcriptTiles`, restricted to `query.genes`.\n   * Optional: only datasets that advertise `transcriptTiles` need it.\n   */\n  getTranscriptTile?(\n    level: number, gx: number, gy: number, query: TranscriptTileQuery,\n  ): Promise<SpatialTranscriptTile>;\n\n  /**\n   * One tile of the all-gene grouping pyramid (`transcriptBins`): an entry per bin, with\n   * `weight` its transcript count and `observation` its dominant cell.\n   */\n  getTranscriptBins?(level: number, tx: number, ty: number): Promise<SpatialTranscriptTile>;\n\n  /**\n   * What is inside `box` (observation units): transcript count, distinct genes and cells,\n   * the most frequent of each — optionally restricted to `genes` — plus display ids for\n   * `cells`. Omit `box` for a cell-id lookup only. Optional; drives the hover details of\n   * transcript markers.\n   */\n  getTranscriptSummary?(query: {\n    box?: [number, number, number, number]; genes?: string[]; cells?: number[];\n  }): Promise<SpatialTranscriptSummary>;\n\n  /**\n   * The summed transcript density of `genes` (`[ALL_GENES]` for every gene) on the\n   * dataset's `density` raster, re-binned to `binSize` observation units when given.\n   * Optional: only datasets that advertise `density` need it.\n   */\n  getDensity?(genes: string[], binSize?: number): Promise<SpatialDensityRaster>;\n\n  /**\n   * Import a cell grouping — a CSV/TSV of `cell_id` and `group` — under `label`. The new\n   * categorical column is added to the dataset (which re-emits) and resolved. Optional.\n   */\n  importGroups?(label: string, table: string): Promise<{ column: CategoricalColumnMeta; matched: number }>;\n\n  /** Transcript totals per gene, for estimating how many markers a selection draws. */\n  getTranscriptCounts?(genes: string[]): Promise<SpatialTranscriptCounts>;\n\n  /**\n   * The reference volume's voxels: a uint8 scalar field, x-fastest, of exactly\n   * `width * height * depth` bytes as the dataset's {@link SpatialVolumeMeta}\n   * declares.\n   *\n   * Optional, and only meaningful when the dataset advertises a volume. Separate\n   * from `getDataset$()` because it is megabytes: a host that never opens the 3D\n   * mode should never pay for it.\n   */\n  getVolume?(): Promise<Uint8Array>;\n\n  /**\n   * Server-side \"which observations fall inside this polygon\", for datasets\n   * too large to hit-test client-side. Optional: without it the library\n   * point-in-polygons the resident coordinates itself, which is fine into the\n   * 10^5 range. Coordinates are in the same space as the observations.\n   */\n  queryRoi?(polygon: { x: number[]; y: number[] }): Promise<Uint32Array>;\n}\n\nexport const SPATIAL_DATA_PORT = new InjectionToken<SpatialDataPort>('SPATIAL_DATA_PORT');\n"]}

package/esm2022/lib/contracts/spatial-dataset.contract.mjs

@@ -38,8 +38,10 @@ export function isCategoricalColumn(c) {
 export function isContinuousColumn(c) {
     return c.meta.kind === 'continuous';
 }
+/** "No observation" in {@link SpatialTranscriptTile.observation}. */
+export const NO_OBSERVATION = 0xffffffff;
 /** Look a column's descriptor up by name. */
 export function findColumnMeta(dataset, name) {
     return dataset.columns.find((c) => c.name === name);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-dataset.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/spatial-dataset.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAoEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC;AAmBlC,MAAM,UAAU,mBAAmB,CAAC,CAAgB;IAClD,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC;AACvC,CAAC;AACD,MAAM,UAAU,kBAAkB,CAAC,CAAgB;IACjD,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC;AACtC,CAAC;AAiLD,6CAA6C;AAC7C,MAAM,UAAU,cAAc,CAC5B,OAAuB,EAAE,IAAY;IAErC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AACtD,CAAC","sourcesContent":["/**\n * Backend-neutral data model for a **spatial-omics dataset**: N observations\n * (Visium spots, segmented cells, nuclei, …) positioned in the pixel space of a\n * tissue image, each carrying categorical and continuous annotations, plus an\n * optional feature (gene) matrix and optional per-observation boundaries.\n *\n * DESIGN\n * ------\n * 1. **Struct-of-arrays, not object-per-cell.** Real datasets run 10^3 (Visium)\n *    to 10^6 (Xenium/CosMx) observations. `{x, y}[]` at 500k cells is ~500k\n *    objects the GC has to walk; two `Float32Array`s are two allocations and\n *    upload to the GPU without a copy.\n *\n * 2. **Metadata is eager, values are lazy.** A dataset advertises *which*\n *    columns and features exist ({@link SpatialColumnMeta},\n *    {@link SpatialFeatureMeta}); the vectors themselves are fetched on demand\n *    through {@link SpatialDataPort}. A Visium table is ~30k genes wide — the\n *    dense matrix is ~800 MB — so \"load the dataset\" can never mean \"load the\n *    matrix\". Only the handful of columns actually being displayed is resident.\n *\n * 3. **Data stays data.** No I/O, no RxJS, no Angular in this file — the same\n *    rule `plotly-trace-builders.ts` follows. Fetching lives on the port.\n *\n * The shape mirrors how the field already stores this (SpatialData/AnnData:\n * `obs` annotations, `var` features, `obsm/spatial` coordinates, shapes with a\n * coordinate transform) so an adapter is a projection, not a translation.\n */\n\n/**\n * Observation positions. Every array is length {@link count} and index-aligned:\n * observation `i` is at `(x[i], y[i])`, and column/feature vectors index the\n * same way. This shared index is the join key for the whole model.\n */\nexport interface SpatialObservations {\n  /** N — number of observations. */\n  readonly count: number;\n  /** X in the reference image's pixel space (see {@link SpatialImageRef}). */\n  x: Float32Array;\n  /** Y in the reference image's pixel space. */\n  y: Float32Array;\n  /** Z, for serial sections or genuinely 3D assays. Absent for a single plane. */\n  z?: Float32Array;\n  /** Stable per-observation ids (barcodes, cell ids) for tooltips and export.\n   *  Optional — omit for large datasets where the strings cost more than they\n   *  are worth. */\n  ids?: string[];\n  /** Marker RADIUS in image pixels: one value shared by all observations (a\n   *  Visium spot is a fixed 55 µm ⇒ `27.5 / mppX` px), or one per observation\n   *  (segmented cells). Absent ⇒ the renderer picks a display default. */\n  radius?: Float32Array | number;\n}\n\n/** Fields common to every column descriptor. */\ninterface SpatialColumnMetaBase {\n  /** Column name as the user sees it (`leiden`, `total_counts`). */\n  name: string;\n  /** Longer human-readable description for tooltips/menus. */\n  description?: string;\n}\n\n/**\n * A discrete annotation — cluster, cell type, region, sample. Rendered as a\n * palette + legend; a legend click selects the category's observations.\n */\nexport interface CategoricalColumnMeta extends SpatialColumnMetaBase {\n  kind: 'categorical';\n  /** Category labels; a value's label is `categories[codes[i]]`. */\n  categories: string[];\n  /** Authored display colours as `#rrggbb`, index-aligned with\n   *  {@link categories}. Supply these to keep the viewer's palette identical to\n   *  the figures the same analysis produced in R/Python; omit to let the viewer\n   *  derive one. */\n  colors?: string[];\n}\n\n/**\n * A continuous measurement — expression, QC metric, area, density. Rendered\n * through the shared colormap/LUT + contrast window.\n */\nexport interface ContinuousColumnMeta extends SpatialColumnMetaBase {\n  kind: 'continuous';\n  /** Unit for axis/tooltip labels (`counts`, `µm²`). */\n  unit?: string;\n  /** True when the column reads best log-scaled — count data almost always\n   *  does, and a linear scale collapses it against a few bright outliers. */\n  logScaleHint?: boolean;\n  /** Observed extremes, when the producer knows them. Lets the UI seed a\n   *  contrast window and axis range without first scanning the vector. */\n  min?: number;\n  max?: number;\n}\n\nexport type SpatialColumnMeta = CategoricalColumnMeta | ContinuousColumnMeta;\n\n/**\n * Code meaning \"this observation has no category\" (unassigned / filtered out /\n * not in tissue). Renderers should draw it in the muted background style rather\n * than as a real category, and it must never index {@link\n * CategoricalColumnMeta.categories}.\n */\nexport const NO_CATEGORY = 0xffff;\n\n/** A loaded categorical column: per-observation indices into `meta.categories`,\n *  or {@link NO_CATEGORY}. */\nexport interface CategoricalColumn {\n  meta: CategoricalColumnMeta;\n  /** Length = {@link SpatialObservations.count}. */\n  codes: Uint16Array;\n}\n\n/** A loaded continuous column. `NaN` marks a missing value. */\nexport interface ContinuousColumn {\n  meta: ContinuousColumnMeta;\n  /** Length = {@link SpatialObservations.count}. */\n  values: Float32Array;\n}\n\nexport type SpatialColumn = CategoricalColumn | ContinuousColumn;\n\nexport function isCategoricalColumn(c: SpatialColumn): c is CategoricalColumn {\n  return c.meta.kind === 'categorical';\n}\nexport function isContinuousColumn(c: SpatialColumn): c is ContinuousColumn {\n  return c.meta.kind === 'continuous';\n}\n\n/**\n * The feature (gene) matrix, described but never delivered whole. Vectors come\n * one at a time from {@link SpatialDataPort.getFeatureVector}.\n */\nexport interface SpatialFeatureMeta {\n  /** Number of features available. */\n  count: number;\n  /**\n   * All feature names, when the producer chose to inline them. Present for\n   * targeted panels (Xenium/CosMx ship 300–5,000 genes ⇒ a few dozen KB) and\n   * absent for whole-transcriptome data (Visium ships ~31k ⇒ ~350 KB), where\n   * the UI should use {@link SpatialDataPort.searchFeatures} for typeahead\n   * instead of downloading the list. Consumers must handle both.\n   */\n  names?: string[];\n  /** What a feature value means (`log1p normalized`, `raw counts`). */\n  unit?: string;\n  /** True when feature vectors read best log-scaled (raw counts). */\n  logScaleHint?: boolean;\n}\n\n/**\n * Per-observation boundaries (cell/nucleus segmentation, spot outlines) as flat\n * rings — deliberately NOT GeoJSON objects, which cost one object + one array\n * per cell and would dominate memory at 10^5 polygons.\n *\n * Ring `i` occupies `coords[2*offsets[i] .. 2*offsets[i+1])` as `x0,y0,x1,y1,…`\n * and is implicitly closed. `offsets` has length `count + 1`.\n */\nexport interface SpatialPolygons {\n  coords: Float32Array;\n  offsets: Uint32Array;\n  /** Number of rings — `offsets.length - 1`. */\n  readonly count: number;\n}\n\n/** Presence/size of the boundary geometry, without loading it. */\nexport interface SpatialPolygonsMeta {\n  count: number;\n}\n\n/**\n * How observation coordinates relate to the tissue image they are drawn over.\n * Applied as `world = coord * scale + translate`, matching the affine that\n * SpatialData records per coordinate system — and the full-resolution world\n * convention the napari-js backend already uses so pre-saved regions align on\n * pyramidal slides.\n */\nexport interface SpatialImageRef {\n  /** Host-defined id of the image these coordinates live in, so the host can\n   *  resolve it to an `IImageInfo`. */\n  imageId?: string;\n  /** Data→world scale. Defaults to `[1, 1]` (coordinates already in\n   *  full-resolution image pixels). */\n  scale?: [number, number];\n  /** Data→world translation, in the same units as {@link scale}'s output. */\n  translate?: [number, number];\n  /** Physical pixel size in µm — drives the scale bar and physical marker\n   *  sizing (a 55 µm Visium spot). */\n  mppX?: number;\n  mppY?: number;\n}\n\n/**\n * A spatial-omics dataset: everything cheap enough to hold resident. Column and\n * feature *values*, and polygon *geometry*, are fetched through\n * {@link SpatialDataPort} as they are displayed.\n */\n/**\n * A precomputed low-dimensional embedding over the SAME observations — UMAP, t-SNE, PCA.\n *\n * Announced in the dataset and fetched on demand, exactly like a column or a gene: the\n * coordinates are another per-observation vector, and a dataset may carry several.\n */\nexport interface SpatialEmbeddingMeta {\n  /** Key as the source names it, e.g. `X_umap`. */\n  name: string;\n  /** Short label for menus; falls back to {@link name}. */\n  label?: string;\n  /** 2 for a plane, 3 for a cloud. */\n  dims: 2 | 3;\n  /**\n   * True when the coordinates were COMPUTED for this bundle rather than published with the\n   * dataset. Worth surfacing: a UMAP recomputed with different parameters is a different picture,\n   * and a reader comparing against a paper's figure needs to know which they are looking at.\n   */\n  derived?: boolean;\n  /**\n   * Fraction of total variance each axis accounts for, index-aligned with the dimensions.\n   *\n   * Only meaningful for a LINEAR embedding — PCA. Its axes are ordered, and each one explains a\n   * measurable share of the variance, which is the whole reason to look at a PCA rather than a\n   * UMAP: \"PC1 (23%)\" says something, where \"UMAP 1\" says nothing at all. A UMAP's coordinates\n   * are an arbitrary output of an optimisation with no variance to report, so this stays absent\n   * there rather than being faked.\n   */\n  varianceRatio?: number[];\n  /**\n   * How a derived embedding was computed, in a few words — e.g. \"PCA(50) then perplexity 30,\n   * seed 0\".\n   *\n   * Not decoration. A t-SNE or UMAP is stochastic, and its picture changes materially with\n   * perplexity or `n_neighbors`; two runs at different settings are different pictures of the same\n   * cells, and neither is more correct. Saying \"computed here\" without saying HOW leaves a reader\n   * unable to reproduce or compare it. Absent for a published embedding, whose parameters belong\n   * to whoever published it.\n   */\n  params?: string;\n}\n\n/**\n * One embedding's coordinates.\n *\n * Deliberately shaped like {@link SpatialObservations}' `x`/`y`/`z` rather than an (N, D) matrix:\n * the point of an embedding here is to be swapped in as the scatter's coordinate source, and\n * matching that shape means the renderer, the hover hit-test and the selection code need no\n * variant for it.\n */\nexport interface SpatialEmbedding {\n  meta: SpatialEmbeddingMeta;\n  x: Float32Array;\n  y: Float32Array;\n  z?: Float32Array;\n}\n\nexport interface SpatialDataset {\n  /** Stable id — the key the port's lazy accessors are scoped to. */\n  id: string;\n  /** Human-readable name for menus. */\n  name: string;\n  observations: SpatialObservations;\n  /** Every column available, whether or not its values are loaded. */\n  columns: SpatialColumnMeta[];\n  features?: SpatialFeatureMeta;\n  polygons?: SpatialPolygonsMeta;\n  imageRef?: SpatialImageRef;\n  /** Presence + geometry of a reference volume the observations sit inside. */\n  volume?: SpatialVolumeMeta;\n  /** Embeddings available for these observations, whose coordinates are fetched on demand. */\n  embeddings?: SpatialEmbeddingMeta[];\n  /**\n   * Microns per observation coordinate unit — what makes a scale bar possible.\n   *\n   * The 2D path gets this from `imageRef.mppX`, because there the coordinates are\n   * image pixels. A 3D cloud has no image, so it has to say for itself: `1` means\n   * the coordinates are already microns.\n   *\n   * Absent means the unit is UNKNOWN, and a renderer must then draw no scale bar\n   * rather than assume one. A bar labelled in microns over pixel-space\n   * coordinates is worse than no bar: it looks like a measurement.\n   */\n  micronsPerUnit?: number;\n}\n\n/**\n * A 3D scalar reference volume registered to the observation coordinates — the\n * anatomical backdrop for a point cloud (an atlas template, or an image z-stack).\n *\n * Geometry only; the voxels are fetched through\n * {@link SpatialDataPort.getVolume} when something is going to draw them. A cloud\n * without one still renders, just in empty space.\n *\n * The observations' coordinate frame must be the volume's own: voxel `(i, j, k)`\n * covers `[i * voxelSize[0], (i + 1) * voxelSize[0])` on x, and so on. That means\n * the volume's near corner sits at the coordinate origin, so a renderer can place\n * the two together knowing nothing else.\n */\nexport interface SpatialVolumeMeta {\n  width: number;\n  height: number;\n  depth: number;\n  /** World size of one voxel per axis, in the observations' units. */\n  voxelSize: [number, number, number];\n}\n\n/** Look a column's descriptor up by name. */\nexport function findColumnMeta(\n  dataset: SpatialDataset, name: string,\n): SpatialColumnMeta | undefined {\n  return dataset.columns.find((c) => c.name === name);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-dataset.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/spatial-dataset.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AA8EH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC;AAmBlC,MAAM,UAAU,mBAAmB,CAAC,CAAgB;IAClD,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC;AACvC,CAAC;AACD,MAAM,UAAU,kBAAkB,CAAC,CAAgB;IACjD,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC;AACtC,CAAC;AAqOD,qEAAqE;AACrE,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;AAoGzC,6CAA6C;AAC7C,MAAM,UAAU,cAAc,CAC5B,OAAuB,EAAE,IAAY;IAErC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AACtD,CAAC","sourcesContent":["/**\n * Backend-neutral data model for a **spatial-omics dataset**: N observations\n * (Visium spots, segmented cells, nuclei, …) positioned in the pixel space of a\n * tissue image, each carrying categorical and continuous annotations, plus an\n * optional feature (gene) matrix and optional per-observation boundaries.\n *\n * DESIGN\n * ------\n * 1. **Struct-of-arrays, not object-per-cell.** Real datasets run 10^3 (Visium)\n *    to 10^6 (Xenium/CosMx) observations. `{x, y}[]` at 500k cells is ~500k\n *    objects the GC has to walk; two `Float32Array`s are two allocations and\n *    upload to the GPU without a copy.\n *\n * 2. **Metadata is eager, values are lazy.** A dataset advertises *which*\n *    columns and features exist ({@link SpatialColumnMeta},\n *    {@link SpatialFeatureMeta}); the vectors themselves are fetched on demand\n *    through {@link SpatialDataPort}. A Visium table is ~30k genes wide — the\n *    dense matrix is ~800 MB — so \"load the dataset\" can never mean \"load the\n *    matrix\". Only the handful of columns actually being displayed is resident.\n *\n * 3. **Data stays data.** No I/O, no RxJS, no Angular in this file — the same\n *    rule `plotly-trace-builders.ts` follows. Fetching lives on the port.\n *\n * The shape mirrors how the field already stores this (SpatialData/AnnData:\n * `obs` annotations, `var` features, `obsm/spatial` coordinates, shapes with a\n * coordinate transform) so an adapter is a projection, not a translation.\n */\n\n/**\n * Observation positions. Every array is length {@link count} and index-aligned:\n * observation `i` is at `(x[i], y[i])`, and column/feature vectors index the\n * same way. This shared index is the join key for the whole model.\n */\nexport interface SpatialObservations {\n  /** N — number of observations. */\n  readonly count: number;\n  /** X in the reference image's pixel space (see {@link SpatialImageRef}). */\n  x: Float32Array;\n  /** Y in the reference image's pixel space. */\n  y: Float32Array;\n  /** Z, for serial sections or genuinely 3D assays. Absent for a single plane. */\n  z?: Float32Array;\n  /** Stable per-observation ids (barcodes, cell ids) for tooltips and export.\n   *  Optional — omit for large datasets where the strings cost more than they\n   *  are worth. */\n  ids?: string[];\n  /** Marker RADIUS in image pixels: one value shared by all observations (a\n   *  Visium spot is a fixed 55 µm ⇒ `27.5 / mppX` px), or one per observation\n   *  (segmented cells). Absent ⇒ the renderer picks a display default. */\n  radius?: Float32Array | number;\n}\n\n/** Fields common to every column descriptor. */\ninterface SpatialColumnMetaBase {\n  /** Column name as the user sees it (`leiden`, `total_counts`). */\n  name: string;\n  /** Longer human-readable description for tooltips/menus. */\n  description?: string;\n}\n\n/**\n * A discrete annotation — cluster, cell type, region, sample. Rendered as a\n * palette + legend; a legend click selects the category's observations.\n */\nexport interface CategoricalColumnMeta extends SpatialColumnMetaBase {\n  kind: 'categorical';\n  /** Category labels; a value's label is `categories[codes[i]]`. */\n  categories: string[];\n  /**\n   * Heading the column is listed under in a group picker — e.g. \"Xenium Onboard Analysis\n   * groups\" for a pipeline's clusterings, \"Imported groups\" for ones added by a user.\n   */\n  section?: string;\n  /**\n   * Columns that are variants of one choice — k-means at k = 2…10 — share a family: a\n   * picker lists the family once and offers the variants beside it.\n   */\n  family?: { id: string; label: string; variant: string };\n  /** Authored display colours as `#rrggbb`, index-aligned with\n   *  {@link categories}. Supply these to keep the viewer's palette identical to\n   *  the figures the same analysis produced in R/Python; omit to let the viewer\n   *  derive one. */\n  colors?: string[];\n}\n\n/**\n * A continuous measurement — expression, QC metric, area, density. Rendered\n * through the shared colormap/LUT + contrast window.\n */\nexport interface ContinuousColumnMeta extends SpatialColumnMetaBase {\n  kind: 'continuous';\n  /** Unit for axis/tooltip labels (`counts`, `µm²`). */\n  unit?: string;\n  /** True when the column reads best log-scaled — count data almost always\n   *  does, and a linear scale collapses it against a few bright outliers. */\n  logScaleHint?: boolean;\n  /** Observed extremes, when the producer knows them. Lets the UI seed a\n   *  contrast window and axis range without first scanning the vector. */\n  min?: number;\n  max?: number;\n}\n\nexport type SpatialColumnMeta = CategoricalColumnMeta | ContinuousColumnMeta;\n\n/**\n * Code meaning \"this observation has no category\" (unassigned / filtered out /\n * not in tissue). Renderers should draw it in the muted background style rather\n * than as a real category, and it must never index {@link\n * CategoricalColumnMeta.categories}.\n */\nexport const NO_CATEGORY = 0xffff;\n\n/** A loaded categorical column: per-observation indices into `meta.categories`,\n *  or {@link NO_CATEGORY}. */\nexport interface CategoricalColumn {\n  meta: CategoricalColumnMeta;\n  /** Length = {@link SpatialObservations.count}. */\n  codes: Uint16Array;\n}\n\n/** A loaded continuous column. `NaN` marks a missing value. */\nexport interface ContinuousColumn {\n  meta: ContinuousColumnMeta;\n  /** Length = {@link SpatialObservations.count}. */\n  values: Float32Array;\n}\n\nexport type SpatialColumn = CategoricalColumn | ContinuousColumn;\n\nexport function isCategoricalColumn(c: SpatialColumn): c is CategoricalColumn {\n  return c.meta.kind === 'categorical';\n}\nexport function isContinuousColumn(c: SpatialColumn): c is ContinuousColumn {\n  return c.meta.kind === 'continuous';\n}\n\n/**\n * The feature (gene) matrix, described but never delivered whole. Vectors come\n * one at a time from {@link SpatialDataPort.getFeatureVector}.\n */\nexport interface SpatialFeatureMeta {\n  /** Number of features available. */\n  count: number;\n  /**\n   * All feature names, when the producer chose to inline them. Present for\n   * targeted panels (Xenium/CosMx ship 300–5,000 genes ⇒ a few dozen KB) and\n   * absent for whole-transcriptome data (Visium ships ~31k ⇒ ~350 KB), where\n   * the UI should use {@link SpatialDataPort.searchFeatures} for typeahead\n   * instead of downloading the list. Consumers must handle both.\n   */\n  names?: string[];\n  /** What a feature value means (`log1p normalized`, `raw counts`). */\n  unit?: string;\n  /** True when feature vectors read best log-scaled (raw counts). */\n  logScaleHint?: boolean;\n}\n\n/**\n * Per-observation boundaries (cell/nucleus segmentation, spot outlines) as flat\n * rings — deliberately NOT GeoJSON objects, which cost one object + one array\n * per cell and would dominate memory at 10^5 polygons.\n *\n * Ring `i` occupies `coords[2*offsets[i] .. 2*offsets[i+1])` as `x0,y0,x1,y1,…`\n * and is implicitly closed. `offsets` has length `count + 1`.\n */\nexport interface SpatialPolygons {\n  coords: Float32Array;\n  offsets: Uint32Array;\n  /** Number of rings — `offsets.length - 1`. */\n  readonly count: number;\n}\n\n/** Presence/size of the boundary geometry, without loading it. */\nexport interface SpatialPolygonsMeta {\n  count: number;\n}\n\n/**\n * How observation coordinates relate to the tissue image they are drawn over.\n * Applied as `world = coord * scale + translate`, matching the affine that\n * SpatialData records per coordinate system — and the full-resolution world\n * convention the napari-js backend already uses so pre-saved regions align on\n * pyramidal slides.\n */\nexport interface SpatialImageRef {\n  /** Host-defined id of the image these coordinates live in, so the host can\n   *  resolve it to an `IImageInfo`. */\n  imageId?: string;\n  /** Data→world scale. Defaults to `[1, 1]` (coordinates already in\n   *  full-resolution image pixels). */\n  scale?: [number, number];\n  /** Data→world translation, in the same units as {@link scale}'s output. */\n  translate?: [number, number];\n  /** Physical pixel size in µm — drives the scale bar and physical marker\n   *  sizing (a 55 µm Visium spot). */\n  mppX?: number;\n  mppY?: number;\n}\n\n/**\n * A spatial-omics dataset: everything cheap enough to hold resident. Column and\n * feature *values*, and polygon *geometry*, are fetched through\n * {@link SpatialDataPort} as they are displayed.\n */\n/**\n * A precomputed low-dimensional embedding over the SAME observations — UMAP, t-SNE, PCA.\n *\n * Announced in the dataset and fetched on demand, exactly like a column or a gene: the\n * coordinates are another per-observation vector, and a dataset may carry several.\n */\nexport interface SpatialEmbeddingMeta {\n  /** Key as the source names it, e.g. `X_umap`. */\n  name: string;\n  /** Short label for menus; falls back to {@link name}. */\n  label?: string;\n  /** 2 for a plane, 3 for a cloud. */\n  dims: 2 | 3;\n  /**\n   * True when the coordinates were COMPUTED for this bundle rather than published with the\n   * dataset. Worth surfacing: a UMAP recomputed with different parameters is a different picture,\n   * and a reader comparing against a paper's figure needs to know which they are looking at.\n   */\n  derived?: boolean;\n  /**\n   * Fraction of total variance each axis accounts for, index-aligned with the dimensions.\n   *\n   * Only meaningful for a LINEAR embedding — PCA. Its axes are ordered, and each one explains a\n   * measurable share of the variance, which is the whole reason to look at a PCA rather than a\n   * UMAP: \"PC1 (23%)\" says something, where \"UMAP 1\" says nothing at all. A UMAP's coordinates\n   * are an arbitrary output of an optimisation with no variance to report, so this stays absent\n   * there rather than being faked.\n   */\n  varianceRatio?: number[];\n  /**\n   * How a derived embedding was computed, in a few words — e.g. \"PCA(50) then perplexity 30,\n   * seed 0\".\n   *\n   * Not decoration. A t-SNE or UMAP is stochastic, and its picture changes materially with\n   * perplexity or `n_neighbors`; two runs at different settings are different pictures of the same\n   * cells, and neither is more correct. Saying \"computed here\" without saying HOW leaves a reader\n   * unable to reproduce or compare it. Absent for a published embedding, whose parameters belong\n   * to whoever published it.\n   */\n  params?: string;\n}\n\n/**\n * One embedding's coordinates.\n *\n * Deliberately shaped like {@link SpatialObservations}' `x`/`y`/`z` rather than an (N, D) matrix:\n * the point of an embedding here is to be swapped in as the scatter's coordinate source, and\n * matching that shape means the renderer, the hover hit-test and the selection code need no\n * variant for it.\n */\nexport interface SpatialEmbedding {\n  meta: SpatialEmbeddingMeta;\n  x: Float32Array;\n  y: Float32Array;\n  z?: Float32Array;\n}\n\n/**\n * Level-of-detail geometry, served one grid tile at a time.\n *\n * Whole-dataset vectors stop working somewhere past 10^5 observations: 717k Xenium cell\n * outlines are ~140 MB, and a whole-transcriptome run has ~10^9 transcripts. What scales\n * is what map tiles do — a square grid in the observations' coordinate space, one grid\n * per level, each level's tiles twice the size of the one below and carrying coarser\n * geometry. The renderer asks only for the tiles on screen, at the level the zoom needs.\n *\n * Tile `(gx, gy)` at level `l` covers `[gx·s, (gx+1)·s) × [gy·s, (gy+1)·s)` with\n * `s = levels[l].tileSize`, in the same units as {@link SpatialObservations.x}.\n */\nexport interface SpatialTileLevel {\n  /** Edge length of one tile, in observation coordinate units. */\n  tileSize: number;\n}\n\n/** Axis-aligned extent `[minX, minY, maxX, maxY]` in observation coordinates. */\nexport type SpatialBounds = [number, number, number, number];\n\n/** Tiled cell/nucleus boundaries. Level 0 is the finest (every vertex). */\nexport interface SpatialPolygonTilesMeta {\n  bounds: SpatialBounds;\n  /** Boundary sets on offer — typically `cell` and `nucleus`. */\n  sets: { name: string; label: string }[];\n  /** The set to draw when the user has not chosen. */\n  defaultSet?: string;\n  levels: SpatialTileLevel[];\n}\n\n/** Tiled transcripts. Level 0 is one entry per transcript; coarser levels aggregate. */\nexport interface SpatialTranscriptTilesMeta {\n  bounds: SpatialBounds;\n  /** Total transcripts, for display. */\n  count?: number;\n  /** Real genes (control probes excluded). Names come from the feature search. */\n  geneCount: number;\n  hasZ: boolean;\n  levels: (SpatialTileLevel & {\n    /** True when an entry stands for several transcripts (see {@link SpatialTranscriptTile.weight}). */\n    aggregated: boolean;\n  })[];\n  /**\n   * Levels up to and including this one assign each entry to the cell it lies in\n   * exactly; above it the assignment names the cell nearest an aggregate's centroid.\n   */\n  exactCellLevel?: number;\n}\n\n/**\n * The all-gene transcript grouping pyramid: square bins, four times coarser per level,\n * each holding a count, a centroid and the cell that contributed most of its transcripts.\n * Served per tile, in the {@link SpatialTranscriptTile} layout (one entry per bin).\n *\n * Tile `(tx, ty)` of level `l` covers `origin + [tx·s, (tx+1)·s) × [ty·s, (ty+1)·s)` with\n * `s = levels[l].tileSize` — note the origin, which the per-gene tiles do not have.\n */\nexport interface SpatialTranscriptBinsMeta {\n  bounds: SpatialBounds;\n  origin: [number, number];\n  /** Transcripts the pyramid was built from. */\n  count: number;\n  levels: { binSize: number; tileSize: number }[];\n}\n\n/**\n * A grouping pyramid the server is still building (it builds one itself when a dataset\n * arrives without it). \"All genes\" becomes available once it is done.\n */\nexport interface SpatialTranscriptBinsStatus {\n  state: 'queued' | 'building' | 'failed';\n  /** Source tiles processed so far, of `total`. */\n  done?: number;\n  total?: number;\n  message?: string;\n}\n\n/** What is in an area — the hover details of a transcript marker or grouped bin. */\nexport interface SpatialTranscriptSummary {\n  /** Absent for a pure cell-id lookup. */\n  transcripts?: number;\n  /** Distinct genes among them. */\n  genes?: number;\n  topGenes?: { name: string; count: number }[];\n  /** Distinct cells they fall in, and how many fall in none. */\n  cells?: number;\n  unassigned?: number;\n  topCells?: { index: number; id?: string; count: number }[];\n  /** Display ids of the cells asked for, by observation index. */\n  cellIds?: Record<number, string>;\n}\n\n/** A per-gene transcript-count raster covering the section. */\nexport interface SpatialDensityMeta {\n  /** Size of one raster cell, in observation units, `[x, y]`. */\n  gridSize: [number, number];\n  /** Observation-space position of raster cell (0, 0)'s near corner. */\n  origin: [number, number];\n  rows: number;\n  cols: number;\n}\n\n/** \"No observation\" in {@link SpatialTranscriptTile.observation}. */\nexport const NO_OBSERVATION = 0xffffffff;\n\n/** One tile of boundaries: rings as in {@link SpatialPolygons}, plus who owns each ring. */\nexport interface SpatialPolygonTile extends SpatialPolygons {\n  /** Observation index of ring `i` — the join key to columns and features. */\n  observation: Uint32Array;\n}\n\n/** One tile of transcripts (or aggregates of them). Every array has length {@link count}. */\nexport interface SpatialTranscriptTile {\n  readonly count: number;\n  aggregated: boolean;\n  x: Float32Array;\n  y: Float32Array;\n  z: Float32Array;\n  /** Transcripts each entry stands for — 1 at an unaggregated level. */\n  weight: Uint32Array;\n  /** Observation (cell) the entry falls in, or {@link NO_OBSERVATION}. */\n  observation: Uint32Array;\n  /** Index into the `genes` list the tile was requested with. */\n  gene: Uint16Array;\n}\n\n/** Transcript totals for an estimate of how many markers a selection would draw. */\nexport interface SpatialTranscriptCounts {\n  /** Total transcripts per requested gene, over the whole dataset. */\n  counts: Record<string, number>;\n  /** Total over every gene. */\n  total: number;\n  /** Extent the totals are spread over (observation units). */\n  bounds: SpatialBounds;\n}\n\n/** A summed density raster for a list of genes; `values` is row-major `rows × cols`. */\nexport interface SpatialDensityRaster {\n  meta: SpatialDensityMeta;\n  genes: string[];\n  values: Float32Array;\n}\n\nexport interface SpatialDataset {\n  /** Stable id — the key the port's lazy accessors are scoped to. */\n  id: string;\n  /** Human-readable name for menus. */\n  name: string;\n  observations: SpatialObservations;\n  /** Every column available, whether or not its values are loaded. */\n  columns: SpatialColumnMeta[];\n  features?: SpatialFeatureMeta;\n  polygons?: SpatialPolygonsMeta;\n  imageRef?: SpatialImageRef;\n  /** Presence + geometry of a reference volume the observations sit inside. */\n  volume?: SpatialVolumeMeta;\n  /** Embeddings available for these observations, whose coordinates are fetched on demand. */\n  embeddings?: SpatialEmbeddingMeta[];\n  /** Level-of-detail boundaries, fetched per tile — see {@link SpatialPolygonTilesMeta}. */\n  polygonTiles?: SpatialPolygonTilesMeta;\n  /** Level-of-detail transcripts, fetched per tile — see {@link SpatialTranscriptTilesMeta}. */\n  transcriptTiles?: SpatialTranscriptTilesMeta;\n  /** A served per-gene transcript density raster. */\n  density?: SpatialDensityMeta;\n  /** The all-gene transcript grouping pyramid, when it has been built. */\n  transcriptBins?: SpatialTranscriptBinsMeta;\n  /** Present while the server is still building {@link transcriptBins}. */\n  transcriptBinsStatus?: SpatialTranscriptBinsStatus;\n  /**\n   * Microns per observation coordinate unit — what makes a scale bar possible.\n   *\n   * The 2D path gets this from `imageRef.mppX`, because there the coordinates are\n   * image pixels. A 3D cloud has no image, so it has to say for itself: `1` means\n   * the coordinates are already microns.\n   *\n   * Absent means the unit is UNKNOWN, and a renderer must then draw no scale bar\n   * rather than assume one. A bar labelled in microns over pixel-space\n   * coordinates is worse than no bar: it looks like a measurement.\n   */\n  micronsPerUnit?: number;\n}\n\n/**\n * A 3D scalar reference volume registered to the observation coordinates — the\n * anatomical backdrop for a point cloud (an atlas template, or an image z-stack).\n *\n * Geometry only; the voxels are fetched through\n * {@link SpatialDataPort.getVolume} when something is going to draw them. A cloud\n * without one still renders, just in empty space.\n *\n * The observations' coordinate frame must be the volume's own: voxel `(i, j, k)`\n * covers `[i * voxelSize[0], (i + 1) * voxelSize[0])` on x, and so on. That means\n * the volume's near corner sits at the coordinate origin, so a renderer can place\n * the two together knowing nothing else.\n */\nexport interface SpatialVolumeMeta {\n  width: number;\n  height: number;\n  depth: number;\n  /** World size of one voxel per axis, in the observations' units. */\n  voxelSize: [number, number, number];\n}\n\n/** Look a column's descriptor up by name. */\nexport function findColumnMeta(\n  dataset: SpatialDataset, name: string,\n): SpatialColumnMeta | undefined {\n  return dataset.columns.find((c) => c.name === name);\n}\n"]}

package/esm2022/lib/contracts/toolbar-tool.contract.mjs

@@ -35,6 +35,17 @@
  * than an escape hatch that returns a component — the moment one tool draws
  * itself, the toolbar stops being able to lay tools out consistently.
  *
+ * DIALOG TOOLS
+ * Some tools are not "set parameters, run once" but an interactive session: the
+ * user paints, the tool retrains and redraws, over and over (DIANNE). A schema
+ * cannot describe that, so {@link ToolbarDialogToolContribution} is the one
+ * variant that renders its own body. The toolbar still owns the button, its
+ * placement and the dialog chrome; the tool only fills the dialog, with plain
+ * DOM (`mount`), so it needs neither Angular nor this library's PrimeNG version.
+ * Its button sits with the host's own actions at the start of the toolbar, and
+ * shows only in the Image view, the view its context ({@link ToolDialogContext})
+ * draws over.
+ *
  * WHY AN EMPTY MODEL LIST HIDES THE TOOL
  * {@link ToolbarToolContribution.models} returning `[]` removes the tool from
  * the toolbar entirely. This preserves the behaviour the built-in tools already
@@ -43,8 +54,14 @@
  * not require unregistering the provider.
  */
 import { InjectionToken } from '@angular/core';
+/** Whether a contribution is a {@link ToolbarDialogToolContribution}. */
+export function isDialogToolContribution(c) {
+    return !!c && c.kind === 'dialog';
+}
 /**
- * Multi-provider token for contributed tools.
+ * Multi-provider token for contributed tools: run tools
+ * ({@link ToolbarToolContribution}) and, since 0.6.0, dialog tools
+ * ({@link ToolbarDialogToolContribution}).
  *
  * Deliberately has no `factory`: unregistered means no tools, which is what
  * makes this library shippable without the closed model packages. Inject it
@@ -57,8 +74,33 @@ export function sortToolContributions(tools) {
     // provider order without having to invent numbers.
     return tools.map((t, i) => ({ t, i })).sort((a, b) => (a.t.order ?? 100) - (b.t.order ?? 100) || a.i - b.i).map(({ t }) => t);
 }
-/** The tools a toolbar should actually show: those with at least one model. */
+/** The run tools a toolbar should actually show: those with at least one model.
+ *  Dialog tools are left out (see {@link dialogToolContributions}). */
 export function visibleToolContributions(tools) {
-    return sortToolContributions(tools ?? []).filter((t) => t.models().length > 0);
+    const run = (tools ?? []).filter((t) => !isDialogToolContribution(t) && typeof t?.models === 'function');
+    return sortToolContributions(run).filter((t) => t.models().length > 0);
+}
+/**
+ * The dialog tools, in display order. A malformed one (no string `id`, no
+ * `activate` or `mount` function) or a repeated `id` is dropped with a warning
+ * rather than breaking the toolbar.
+ */
+export function dialogToolContributions(tools, log = console) {
+    const seen = new Set();
+    const out = [];
+    for (const t of (tools ?? []).filter(isDialogToolContribution)) {
+        if (typeof t.id !== 'string' || !t.id || typeof t.activate !== 'function'
+            || typeof t.mount !== 'function') {
+            log.warn('[visualizer] dialog tool ignored: it needs a string `id` and `activate` and `mount` functions.', t);
+            continue;
+        }
+        if (seen.has(t.id)) {
+            log.warn(`[visualizer] dialog tool '${t.id}' ignored: another dialog tool already uses that id.`);
+            continue;
+        }
+        seen.add(t.id);
+        out.push(t);
+    }
+    return sortToolContributions(out);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolbar-tool.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/toolbar-tool.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AA4I/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAAqC,eAAe,CAAC,CAAC;AAErG,iDAAiD;AACjD,MAAM,UAAU,qBAAqB,CACnC,KAAyC;IAEzC,6EAA6E;IAC7E,mDAAmD;IACnD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACnD,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CACrD,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,wBAAwB,CACtC,KAA4D;IAE5D,OAAO,qBAAqB,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjF,CAAC","sourcesContent":["/**\n * How a tool gets into the toolbar without this library knowing what it is.\n *\n * WHY THIS EXISTS\n * The YOLO detector and the retinal-layer segmenter used to be built in: their\n * buttons were hardcoded in the toolbar template, their model registries named\n * JAX checkpoints, and the `INSTANCE_SEGMENTER` / `SEMANTIC_SEGMENTER` tokens\n * defaulted to in-library services that imported `yolo-segdetect-js` and\n * `jax-ai-js`. Those default factories were the only thing pulling either\n * package into the bundle — the contracts themselves were already clean.\n *\n * That arrangement cannot ship in an open library while the models are closed.\n * So the tools move out, into a package that depends on this one, and arrive\n * back through {@link TOOLBAR_TOOLS}. This library keeps the contracts, the\n * chrome and the region plumbing; it no longer knows that YOLO exists.\n *\n * A host registers tools with a multi-provider:\n *\n *     { provide: TOOLBAR_TOOLS, useExisting: YoloToolContribution, multi: true }\n *\n * Register nothing and the toolbar has no segmentation tools, the help dialog\n * lists none, and neither model package is in the graph.\n *\n * WHY PARAMS ARE DECLARED, NOT RENDERED\n * A contribution describes its parameters ({@link ToolParamSpec}) instead of\n * supplying a component to draw them. The toolbar renders one generic dialog\n * from that description. The alternative — each plugin shipping its own dialog\n * component — would make every plugin depend on this library's exact PrimeNG\n * version and styling internals to look like the rest of the toolbar, and the\n * two dialogs that exist today are entirely numbers and one checkbox. A schema\n * covers them, and it is the same shape jit-ui already uses for its pipeline\n * step parameters, so the vocabulary is familiar.\n *\n * If a tool ever needs a control this cannot express, add a variant here rather\n * than an escape hatch that returns a component — the moment one tool draws\n * itself, the toolbar stops being able to lay tools out consistently.\n *\n * WHY AN EMPTY MODEL LIST HIDES THE TOOL\n * {@link ToolbarToolContribution.models} returning `[]` removes the tool from\n * the toolbar entirely. This preserves the behaviour the built-in tools already\n * had (their buttons were `*ngIf`'d on a filtered registry), and it gives a host\n * one switch for \"the weights are not configured in this deployment\" that does\n * not require unregistering the provider.\n */\nimport { InjectionToken } from '@angular/core';\nimport type { Observable } from 'rxjs';\n\nimport type { IVisualizer } from './visualizer.contract';\n\n/** A number field. Rendered as a stepper, matching the built-in dialogs. */\nexport interface NumberParamSpec {\n  id: string;\n  label: string;\n  type: 'number';\n  min?: number;\n  max?: number;\n  step?: number;\n  /** Decimal places to show. Omit for integers. */\n  fractionDigits?: number;\n  /** Hover help. Plain text; it is not rendered as HTML. */\n  tooltip?: string;\n}\n\n/** A checkbox. `label` sits beside it and may run to a sentence or two. */\nexport interface BooleanParamSpec {\n  id: string;\n  label: string;\n  type: 'boolean';\n  tooltip?: string;\n}\n\n/** A fixed set of choices. */\nexport interface SelectParamSpec {\n  id: string;\n  label: string;\n  type: 'select';\n  options: { label: string; value: string | number }[];\n  tooltip?: string;\n}\n\nexport type ToolParamSpec = NumberParamSpec | BooleanParamSpec | SelectParamSpec;\n\n/** One selectable checkpoint. */\nexport interface ToolModelOption {\n  id: string;\n  label: string;\n  /**\n   * Describes the checkpoint in the picker's hover tooltip — size, speed,\n   * training domain, accuracy. **Rendered as HTML**, so it is trusted content\n   * from the contributing package, never anything user-supplied.\n   */\n  info?: string;\n  /**\n   * Parameter values this checkpoint wants, merged over\n   * {@link ToolbarToolContribution.defaultParams} when it is selected. Defaults\n   * belong to the model rather than the tool — a detector trained on native 40x\n   * patches wants different tiling from one trained on thumbnails.\n   */\n  defaults?: Record<string, unknown>;\n}\n\n/**\n * The `status$` / `busy$` / `progress$` surface the toolbar drives its sticky\n * toast and progress bar from. `progress$` is a 0..1 fraction, or -1 for\n * indeterminate.\n */\nexport interface ToolProgress {\n  status$: Observable<string>;\n  busy$: Observable<boolean>;\n  progress$: Observable<number>;\n}\n\n/** Toolbar icon: a published asset, or a PrimeIcon class name. */\nexport type ToolIcon = { src: string; pi?: never } | { pi: string; src?: never };\n\n/**\n * A tool contributed to the toolbar.\n *\n * Implement it on an `@Injectable()` service in the contributing package, so it\n * can inject its own segmenter and model registry — this library provides\n * neither and must not learn to.\n */\nexport interface ToolbarToolContribution {\n  /** Stable identity, used for tracking and persisted preferences. */\n  id: string;\n  /** Short name, used in the toast and the help dialog heading. */\n  label: string;\n  icon: ToolIcon;\n\n  /** Tooltip on the run button — say what it does to the current view. */\n  runTooltip: string;\n  /** Tooltip on the checkpoint picker. Defaults to \"Pick the model\". */\n  modelTooltip?: string;\n  /** Tooltip on the parameters button. Defaults to \"Parameters\". */\n  paramsTooltip?: string;\n\n  /**\n   * Where it sits among the segmentation tools. Lower sorts first; ties fall\n   * back to registration order. The built-in prompted tools occupy 0-99, so\n   * contributed tools should start at 100 to land after them.\n   */\n  order?: number;\n\n  /** Selectable checkpoints. **Empty hides the tool.** */\n  models(): ToolModelOption[];\n  /** Which checkpoint runs when the user has not chosen. */\n  defaultModelId(): string;\n  /**\n   * Called when the user picks a checkpoint, before parameters are re-seeded.\n   * Use it to record the choice in the contributing package's own registry.\n   */\n  onModelChange?(modelId: string): void;\n\n  /** Parameter fields, in dialog order. Empty hides the parameters button. */\n  params: ToolParamSpec[];\n  /**\n   * Baseline parameter values for a checkpoint. Called on first use and again\n   * on \"Reset to model defaults\", so it must be pure and must return every key\n   * the tool reads — a parameter the dialog shows but this omits renders as\n   * empty and reaches `run` as undefined.\n   */\n  defaultParams(modelId: string): Record<string, unknown>;\n\n  /**\n   * Entry for the help dialog's tool list. `body` is rendered as HTML and may\n   * reference published assets (e.g. the tool's own icon).\n   */\n  help?: { body: string };\n\n  /** Progress surface for the toast. */\n  progress: ToolProgress;\n\n  /**\n   * Run over what is currently displayed, and write whatever it finds through\n   * `viz`. Resolves with the number of regions added.\n   *\n   * Everything the tool needs is on {@link IVisualizer}, which is part of this\n   * library's public surface — a contribution never reaches into internals.\n   * Region writes go through the same path the built-in tools use, so the\n   * index-based overlays and the Regions table stay consistent.\n   */\n  run(viz: IVisualizer, params: Record<string, unknown>): Promise<number>;\n}\n\n/**\n * Multi-provider token for contributed tools.\n *\n * Deliberately has no `factory`: unregistered means no tools, which is what\n * makes this library shippable without the closed model packages. Inject it\n * `{ optional: true }` and treat null as empty.\n */\nexport const TOOLBAR_TOOLS = new InjectionToken<readonly ToolbarToolContribution[]>('TOOLBAR_TOOLS');\n\n/** Sort contributed tools into display order. */\nexport function sortToolContributions(\n  tools: readonly ToolbarToolContribution[],\n): ToolbarToolContribution[] {\n  // Stable: equal `order` keeps registration order, so a host controls ties by\n  // provider order without having to invent numbers.\n  return tools.map((t, i) => ({ t, i })).sort((a, b) =>\n    (a.t.order ?? 100) - (b.t.order ?? 100) || a.i - b.i,\n  ).map(({ t }) => t);\n}\n\n/** The tools a toolbar should actually show: those with at least one model. */\nexport function visibleToolContributions(\n  tools: readonly ToolbarToolContribution[] | null | undefined,\n): ToolbarToolContribution[] {\n  return sortToolContributions(tools ?? []).filter((t) => t.models().length > 0);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolbar-tool.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/toolbar-tool.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAiM/C,yEAAyE;AACzE,MAAM,UAAU,wBAAwB,CAAC,CAAU;IACjD,OAAO,CAAC,CAAC,CAAC,IAAK,CAAwB,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC5D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAAiC,eAAe,CAAC,CAAC;AAEjG,iDAAiD;AACjD,MAAM,UAAU,qBAAqB,CACnC,KAAmB;IAEnB,6EAA6E;IAC7E,mDAAmD;IACnD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACnD,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CACrD,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC;AAED;uEACuE;AACvE,MAAM,UAAU,wBAAwB,CACtC,KAAwD;IAExD,MAAM,GAAG,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAC9B,CAAC,CAAC,EAAgC,EAAE,CAClC,CAAC,wBAAwB,CAAC,CAAC,CAAC,IAAI,OAAQ,CAA6B,EAAE,MAAM,KAAK,UAAU,CAC/F,CAAC;IACF,OAAO,qBAAqB,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAwD,EACxD,MAA0C,OAAO;IAEjD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,GAAG,GAAoC,EAAE,CAAC;IAChD,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,wBAAwB,CAAC,EAAE,CAAC;QAC/D,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,OAAO,CAAC,CAAC,QAAQ,KAAK,UAAU;eAClE,OAAO,CAAC,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;YACrC,GAAG,CAAC,IAAI,CAAC,gGAAgG,EAAE,CAAC,CAAC,CAAC;YAC9G,SAAS;QACX,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;YACnB,GAAG,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC,EAAE,sDAAsD,CAAC,CAAC;YAClG,SAAS;QACX,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACf,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACd,CAAC;IACD,OAAO,qBAAqB,CAAC,GAAG,CAAC,CAAC;AACpC,CAAC","sourcesContent":["/**\n * How a tool gets into the toolbar without this library knowing what it is.\n *\n * WHY THIS EXISTS\n * The YOLO detector and the retinal-layer segmenter used to be built in: their\n * buttons were hardcoded in the toolbar template, their model registries named\n * JAX checkpoints, and the `INSTANCE_SEGMENTER` / `SEMANTIC_SEGMENTER` tokens\n * defaulted to in-library services that imported `yolo-segdetect-js` and\n * `jax-ai-js`. Those default factories were the only thing pulling either\n * package into the bundle — the contracts themselves were already clean.\n *\n * That arrangement cannot ship in an open library while the models are closed.\n * So the tools move out, into a package that depends on this one, and arrive\n * back through {@link TOOLBAR_TOOLS}. This library keeps the contracts, the\n * chrome and the region plumbing; it no longer knows that YOLO exists.\n *\n * A host registers tools with a multi-provider:\n *\n *     { provide: TOOLBAR_TOOLS, useExisting: YoloToolContribution, multi: true }\n *\n * Register nothing and the toolbar has no segmentation tools, the help dialog\n * lists none, and neither model package is in the graph.\n *\n * WHY PARAMS ARE DECLARED, NOT RENDERED\n * A contribution describes its parameters ({@link ToolParamSpec}) instead of\n * supplying a component to draw them. The toolbar renders one generic dialog\n * from that description. The alternative — each plugin shipping its own dialog\n * component — would make every plugin depend on this library's exact PrimeNG\n * version and styling internals to look like the rest of the toolbar, and the\n * two dialogs that exist today are entirely numbers and one checkbox. A schema\n * covers them, and it is the same shape jit-ui already uses for its pipeline\n * step parameters, so the vocabulary is familiar.\n *\n * If a tool ever needs a control this cannot express, add a variant here rather\n * than an escape hatch that returns a component — the moment one tool draws\n * itself, the toolbar stops being able to lay tools out consistently.\n *\n * DIALOG TOOLS\n * Some tools are not \"set parameters, run once\" but an interactive session: the\n * user paints, the tool retrains and redraws, over and over (DIANNE). A schema\n * cannot describe that, so {@link ToolbarDialogToolContribution} is the one\n * variant that renders its own body. The toolbar still owns the button, its\n * placement and the dialog chrome; the tool only fills the dialog, with plain\n * DOM (`mount`), so it needs neither Angular nor this library's PrimeNG version.\n * Its button sits with the host's own actions at the start of the toolbar, and\n * shows only in the Image view, the view its context ({@link ToolDialogContext})\n * draws over.\n *\n * WHY AN EMPTY MODEL LIST HIDES THE TOOL\n * {@link ToolbarToolContribution.models} returning `[]` removes the tool from\n * the toolbar entirely. This preserves the behaviour the built-in tools already\n * had (their buttons were `*ngIf`'d on a filtered registry), and it gives a host\n * one switch for \"the weights are not configured in this deployment\" that does\n * not require unregistering the provider.\n */\nimport { InjectionToken } from '@angular/core';\nimport type { Observable } from 'rxjs';\n\nimport type { IVisualizer } from './visualizer.contract';\nimport type { PlotModeContext, PlotModeSession, PlotModeTools } from './plot-type-contribution.contract';\n\n/** A number field. Rendered as a stepper, matching the built-in dialogs. */\nexport interface NumberParamSpec {\n  id: string;\n  label: string;\n  type: 'number';\n  min?: number;\n  max?: number;\n  step?: number;\n  /** Decimal places to show. Omit for integers. */\n  fractionDigits?: number;\n  /** Hover help. Plain text; it is not rendered as HTML. */\n  tooltip?: string;\n}\n\n/** A checkbox. `label` sits beside it and may run to a sentence or two. */\nexport interface BooleanParamSpec {\n  id: string;\n  label: string;\n  type: 'boolean';\n  tooltip?: string;\n}\n\n/** A fixed set of choices. */\nexport interface SelectParamSpec {\n  id: string;\n  label: string;\n  type: 'select';\n  options: { label: string; value: string | number }[];\n  tooltip?: string;\n}\n\nexport type ToolParamSpec = NumberParamSpec | BooleanParamSpec | SelectParamSpec;\n\n/** One selectable checkpoint. */\nexport interface ToolModelOption {\n  id: string;\n  label: string;\n  /**\n   * Describes the checkpoint in the picker's hover tooltip — size, speed,\n   * training domain, accuracy. **Rendered as HTML**, so it is trusted content\n   * from the contributing package, never anything user-supplied.\n   */\n  info?: string;\n  /**\n   * Parameter values this checkpoint wants, merged over\n   * {@link ToolbarToolContribution.defaultParams} when it is selected. Defaults\n   * belong to the model rather than the tool — a detector trained on native 40x\n   * patches wants different tiling from one trained on thumbnails.\n   */\n  defaults?: Record<string, unknown>;\n}\n\n/**\n * The `status$` / `busy$` / `progress$` surface the toolbar drives its sticky\n * toast and progress bar from. `progress$` is a 0..1 fraction, or -1 for\n * indeterminate.\n */\nexport interface ToolProgress {\n  status$: Observable<string>;\n  busy$: Observable<boolean>;\n  progress$: Observable<number>;\n}\n\n/** Toolbar icon: a published asset, or a PrimeIcon class name. */\nexport type ToolIcon = { src: string; pi?: never } | { pi: string; src?: never };\n\n/**\n * A tool contributed to the toolbar.\n *\n * Implement it on an `@Injectable()` service in the contributing package, so it\n * can inject its own segmenter and model registry — this library provides\n * neither and must not learn to.\n */\nexport interface ToolbarToolContribution {\n  /** Stable identity, used for tracking and persisted preferences. */\n  id: string;\n  /** Short name, used in the toast and the help dialog heading. */\n  label: string;\n  icon: ToolIcon;\n\n  /** Tooltip on the run button — say what it does to the current view. */\n  runTooltip: string;\n  /** Tooltip on the checkpoint picker. Defaults to \"Pick the model\". */\n  modelTooltip?: string;\n  /** Tooltip on the parameters button. Defaults to \"Parameters\". */\n  paramsTooltip?: string;\n\n  /**\n   * Where it sits among the segmentation tools. Lower sorts first; ties fall\n   * back to registration order. The built-in prompted tools occupy 0-99, so\n   * contributed tools should start at 100 to land after them.\n   */\n  order?: number;\n\n  /** Selectable checkpoints. **Empty hides the tool.** */\n  models(): ToolModelOption[];\n  /** Which checkpoint runs when the user has not chosen. */\n  defaultModelId(): string;\n  /**\n   * Called when the user picks a checkpoint, before parameters are re-seeded.\n   * Use it to record the choice in the contributing package's own registry.\n   */\n  onModelChange?(modelId: string): void;\n\n  /** Parameter fields, in dialog order. Empty hides the parameters button. */\n  params: ToolParamSpec[];\n  /**\n   * Baseline parameter values for a checkpoint. Called on first use and again\n   * on \"Reset to model defaults\", so it must be pure and must return every key\n   * the tool reads — a parameter the dialog shows but this omits renders as\n   * empty and reaches `run` as undefined.\n   */\n  defaultParams(modelId: string): Record<string, unknown>;\n\n  /**\n   * Entry for the help dialog's tool list. `body` is rendered as HTML and may\n   * reference published assets (e.g. the tool's own icon).\n   */\n  help?: { body: string };\n\n  /** Progress surface for the toast. */\n  progress: ToolProgress;\n\n  /**\n   * Run over what is currently displayed, and write whatever it finds through\n   * `viz`. Resolves with the number of regions added.\n   *\n   * Everything the tool needs is on {@link IVisualizer}, which is part of this\n   * library's public surface — a contribution never reaches into internals.\n   * Region writes go through the same path the built-in tools use, so the\n   * index-based overlays and the Regions table stay consistent.\n   */\n  run(viz: IVisualizer, params: Record<string, unknown>): Promise<number>;\n}\n\n/**\n * What a dialog tool gets while its dialog is open: the same surface a\n * contributed plot mode gets (the public visualizer, the Image view's viewport\n * and the current image), with the toolbar tools always present.\n */\nexport type ToolDialogContext = PlotModeContext & { tools: PlotModeTools };\n\n/** A live dialog-tool session. `deactivate()` runs exactly once, after the body's teardown. */\nexport type ToolDialogSession = PlotModeSession;\n\n/**\n * A toolbar tool that opens a dialog instead of running once (see DIALOG TOOLS\n * above). Clicking its button opens the dialog and starts a session; clicking it\n * again, or closing the dialog, ends it.\n *\n * The session is bound to the Image view on screen. When that view is re-rendered\n * (another image, another slice) the session ends and, with the dialog still\n * open, a fresh one starts once the new view is ready. Leaving the Image view\n * closes the dialog. As with plot modes, nothing the tool throws or rejects\n * escapes: a failed start closes the dialog with a warning.\n */\nexport interface ToolbarDialogToolContribution {\n  kind: 'dialog';\n  /** Stable identity. Must not clash with another toolbar tool. */\n  id: string;\n  /** Short name; the dialog title unless `dialog.title` is set. */\n  label: string;\n  icon: ToolIcon;\n  /** Tooltip on the button. */\n  tooltip: string;\n  /** Order among the dialog tools. Lower sorts first; ties keep registration order. */\n  order?: number;\n  dialog?: {\n    title?: string;\n    /** CSS width of the dialog. Default `'22rem'`. */\n    width?: string;\n  };\n  /** Entry for the help dialog's tool list, rendered as HTML (trusted content). */\n  help?: { body: string };\n  /** Start a session, once the Image view's viewport is ready. */\n  activate(ctx: ToolDialogContext): ToolDialogSession | Promise<ToolDialogSession>;\n  /**\n   * Render the dialog body into `host`; return its teardown (called before\n   * `deactivate()`). Called after `activate` resolves, once the dialog has rendered and\n   * `host` is in the document, so the body can measure itself.\n   */\n  mount(host: HTMLElement, ctx: ToolDialogContext, session: ToolDialogSession): () => void;\n}\n\n/** Anything provided on {@link TOOLBAR_TOOLS}. A run tool has no `kind`. */\nexport type ToolbarContribution = ToolbarToolContribution | ToolbarDialogToolContribution;\n\n/** Whether a contribution is a {@link ToolbarDialogToolContribution}. */\nexport function isDialogToolContribution(c: unknown): c is ToolbarDialogToolContribution {\n  return !!c && (c as { kind?: unknown }).kind === 'dialog';\n}\n\n/**\n * Multi-provider token for contributed tools: run tools\n * ({@link ToolbarToolContribution}) and, since 0.6.0, dialog tools\n * ({@link ToolbarDialogToolContribution}).\n *\n * Deliberately has no `factory`: unregistered means no tools, which is what\n * makes this library shippable without the closed model packages. Inject it\n * `{ optional: true }` and treat null as empty.\n */\nexport const TOOLBAR_TOOLS = new InjectionToken<readonly ToolbarContribution[]>('TOOLBAR_TOOLS');\n\n/** Sort contributed tools into display order. */\nexport function sortToolContributions<T extends { order?: number }>(\n  tools: readonly T[],\n): T[] {\n  // Stable: equal `order` keeps registration order, so a host controls ties by\n  // provider order without having to invent numbers.\n  return tools.map((t, i) => ({ t, i })).sort((a, b) =>\n    (a.t.order ?? 100) - (b.t.order ?? 100) || a.i - b.i,\n  ).map(({ t }) => t);\n}\n\n/** The run tools a toolbar should actually show: those with at least one model.\n *  Dialog tools are left out (see {@link dialogToolContributions}). */\nexport function visibleToolContributions(\n  tools: readonly ToolbarContribution[] | null | undefined,\n): ToolbarToolContribution[] {\n  const run = (tools ?? []).filter(\n    (t): t is ToolbarToolContribution =>\n      !isDialogToolContribution(t) && typeof (t as ToolbarToolContribution)?.models === 'function',\n  );\n  return sortToolContributions(run).filter((t) => t.models().length > 0);\n}\n\n/**\n * The dialog tools, in display order. A malformed one (no string `id`, no\n * `activate` or `mount` function) or a repeated `id` is dropped with a warning\n * rather than breaking the toolbar.\n */\nexport function dialogToolContributions(\n  tools: readonly ToolbarContribution[] | null | undefined,\n  log: { warn(...args: unknown[]): void } = console,\n): ToolbarDialogToolContribution[] {\n  const seen = new Set<string>();\n  const out: ToolbarDialogToolContribution[] = [];\n  for (const t of (tools ?? []).filter(isDialogToolContribution)) {\n    if (typeof t.id !== 'string' || !t.id || typeof t.activate !== 'function'\n        || typeof t.mount !== 'function') {\n      log.warn('[visualizer] dialog tool ignored: it needs a string `id` and `activate` and `mount` functions.', t);\n      continue;\n    }\n    if (seen.has(t.id)) {\n      log.warn(`[visualizer] dialog tool '${t.id}' ignored: another dialog tool already uses that id.`);\n      continue;\n    }\n    seen.add(t.id);\n    out.push(t);\n  }\n  return sortToolContributions(out);\n}\n"]}