@jax-data-science/sci-image-visualizer 0.5.0 → 0.6.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

@@ -23,4 +23,4 @@ export const DEFAULT_SPATIAL_VIEW = {
     geneMapSmoothing: 1,
     geneMapOpacity: 0.85,
 };
-//# 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;AAqLH,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   * 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 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"]}

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/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"]}