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

package/esm2022/lib/processing/image-crop.mjs

@@ -59,4 +59,4 @@ export function cropImage(image, opts = {}) {
     const final = downsampleRgba(cropped.data, cropped.width, cropped.height, factor);
     return new ProcessingImage(final.width, final.height, 4, final.data);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-crop.js","sourceRoot":"","sources":["../../../../src/lib/processing/image-crop.ts"],"names":[],"mappings":"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","sourcesContent":["import { ProcessingImage } from './processing-image';\n\n/** Crop options in source-image pixels. Out-of-range values are clamped. */\nexport interface CropImageOptions {\n  x?: number;\n  y?: number;\n  width?: number;\n  height?: number;\n  /** Power-of-two downsample level applied to the crop (0 = full resolution). */\n  level?: number;\n}\n\n/** Copy a clamped rectangle of an RGBA source into a fresh, tightly-packed buffer. */\nfunction cropRgba(\n  src: Uint8ClampedArray, srcWidth: number, srcHeight: number,\n  x: number, y: number, w: number, h: number,\n): { data: Uint8ClampedArray; width: number; height: number } {\n  // Clamp the rectangle to the image so bad params snap to the valid region\n  // instead of reading out of bounds.\n  const x0 = Math.max(0, Math.min(srcWidth - 1, Math.floor(x)));\n  const y0 = Math.max(0, Math.min(srcHeight - 1, Math.floor(y)));\n  const width = Math.max(1, Math.min(srcWidth - x0, Math.floor(w)));\n  const height = Math.max(1, Math.min(srcHeight - y0, Math.floor(h)));\n  const out = new Uint8ClampedArray(width * height * 4);\n  for (let row = 0; row < height; row++) {\n    const srcRow = (y0 + row) * srcWidth + x0;\n    const dstRow = row * width;\n    for (let col = 0; col < width; col++) {\n      const si = (srcRow + col) * 4;\n      const di = (dstRow + col) * 4;\n      out[di]     = src[si]     as number;\n      out[di + 1] = src[si + 1] as number;\n      out[di + 2] = src[si + 2] as number;\n      out[di + 3] = src[si + 3] as number;\n    }\n  }\n  return { data: out, width, height };\n}\n\n/** Nearest-neighbour downsample by an integer factor (≥1). factor=1 is a no-op. */\nfunction downsampleRgba(\n  src: Uint8ClampedArray, srcWidth: number, srcHeight: number, factor: number,\n): { data: Uint8ClampedArray; width: number; height: number } {\n  if (factor <= 1) return { data: src, width: srcWidth, height: srcHeight };\n  const width = Math.max(1, Math.floor(srcWidth / factor));\n  const height = Math.max(1, Math.floor(srcHeight / factor));\n  const out = new Uint8ClampedArray(width * height * 4);\n  for (let row = 0; row < height; row++) {\n    const sy = Math.min(srcHeight - 1, row * factor);\n    for (let col = 0; col < width; col++) {\n      const sx = Math.min(srcWidth - 1, col * factor);\n      const si = (sy * srcWidth + sx) * 4;\n      const di = (row * width + col) * 4;\n      out[di]     = src[si]     as number;\n      out[di + 1] = src[si + 1] as number;\n      out[di + 2] = src[si + 2] as number;\n      out[di + 3] = src[si + 3] as number;\n    }\n  }\n  return { data: out, width, height };\n}\n\n/**\n * Crop a rectangular region out of a {@link ProcessingImage} (browser-side, the\n * counterpart of the JIT server's Slide Crop), optionally downsampling the crop\n * by `2^level`. The rectangle is in source pixels and clamped to the image, so\n * out-of-range values snap to the valid region rather than throwing. Always\n * returns a 4-channel (RGBA) image.\n */\nexport function cropImage(image: ProcessingImage, opts: CropImageOptions = {}): ProcessingImage {\n  // Work on RGBA so the crop is channel-count agnostic.\n  const src = image.channels === 4 ? image.data : image.toImageData().data;\n  const cropped = cropRgba(\n    src, image.width, image.height,\n    Number(opts.x ?? 0), Number(opts.y ?? 0),\n    Number(opts.width ?? image.width), Number(opts.height ?? image.height),\n  );\n  const level = Math.max(0, Math.floor(Number(opts.level ?? 0)));\n  const factor = level > 0 ? 2 ** level : 1;\n  const final = downsampleRgba(cropped.data, cropped.width, cropped.height, factor);\n  return new ProcessingImage(final.width, final.height, 4, final.data);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-crop.js","sourceRoot":"","sources":["../../../../src/lib/processing/image-crop.ts"],"names":[],"mappings":"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","sourcesContent":["import { ProcessingImage } from './processing-image';\n\n/** Crop options in source-image pixels. Out-of-range values are clamped. */\nexport interface CropImageOptions {\n  x?: number;\n  y?: number;\n  width?: number;\n  height?: number;\n  /** Power-of-two downsample level applied to the crop (0 = full resolution). */\n  level?: number;\n}\n\n/** Copy a clamped rectangle of an RGBA source into a fresh, tightly-packed buffer. */\nfunction cropRgba(\n  src: Uint8ClampedArray,\n  srcWidth: number,\n  srcHeight: number,\n  x: number,\n  y: number,\n  w: number,\n  h: number,\n): { data: Uint8ClampedArray; width: number; height: number } {\n  // Clamp the rectangle to the image so bad params snap to the valid region\n  // instead of reading out of bounds.\n  const x0 = Math.max(0, Math.min(srcWidth - 1, Math.floor(x)));\n  const y0 = Math.max(0, Math.min(srcHeight - 1, Math.floor(y)));\n  const width = Math.max(1, Math.min(srcWidth - x0, Math.floor(w)));\n  const height = Math.max(1, Math.min(srcHeight - y0, Math.floor(h)));\n  const out = new Uint8ClampedArray(width * height * 4);\n  for (let row = 0; row < height; row++) {\n    const srcRow = (y0 + row) * srcWidth + x0;\n    const dstRow = row * width;\n    for (let col = 0; col < width; col++) {\n      const si = (srcRow + col) * 4;\n      const di = (dstRow + col) * 4;\n      out[di] = src[si] as number;\n      out[di + 1] = src[si + 1] as number;\n      out[di + 2] = src[si + 2] as number;\n      out[di + 3] = src[si + 3] as number;\n    }\n  }\n  return { data: out, width, height };\n}\n\n/** Nearest-neighbour downsample by an integer factor (≥1). factor=1 is a no-op. */\nfunction downsampleRgba(\n  src: Uint8ClampedArray,\n  srcWidth: number,\n  srcHeight: number,\n  factor: number,\n): { data: Uint8ClampedArray; width: number; height: number } {\n  if (factor <= 1) return { data: src, width: srcWidth, height: srcHeight };\n  const width = Math.max(1, Math.floor(srcWidth / factor));\n  const height = Math.max(1, Math.floor(srcHeight / factor));\n  const out = new Uint8ClampedArray(width * height * 4);\n  for (let row = 0; row < height; row++) {\n    const sy = Math.min(srcHeight - 1, row * factor);\n    for (let col = 0; col < width; col++) {\n      const sx = Math.min(srcWidth - 1, col * factor);\n      const si = (sy * srcWidth + sx) * 4;\n      const di = (row * width + col) * 4;\n      out[di] = src[si] as number;\n      out[di + 1] = src[si + 1] as number;\n      out[di + 2] = src[si + 2] as number;\n      out[di + 3] = src[si + 3] as number;\n    }\n  }\n  return { data: out, width, height };\n}\n\n/**\n * Crop a rectangular region out of a {@link ProcessingImage} (browser-side, the\n * counterpart of the JIT server's Slide Crop), optionally downsampling the crop\n * by `2^level`. The rectangle is in source pixels and clamped to the image, so\n * out-of-range values snap to the valid region rather than throwing. Always\n * returns a 4-channel (RGBA) image.\n */\nexport function cropImage(image: ProcessingImage, opts: CropImageOptions = {}): ProcessingImage {\n  // Work on RGBA so the crop is channel-count agnostic.\n  const src = image.channels === 4 ? image.data : image.toImageData().data;\n  const cropped = cropRgba(\n    src,\n    image.width,\n    image.height,\n    Number(opts.x ?? 0),\n    Number(opts.y ?? 0),\n    Number(opts.width ?? image.width),\n    Number(opts.height ?? image.height),\n  );\n  const level = Math.max(0, Math.floor(Number(opts.level ?? 0)));\n  const factor = level > 0 ? 2 ** level : 1;\n  const final = downsampleRgba(cropped.data, cropped.width, cropped.height, factor);\n  return new ProcessingImage(final.width, final.height, 4, final.data);\n}\n"]}

package/esm2022/lib/processing/processing-image.mjs

@@ -13,38 +13,51 @@ export class ProcessingImage {
         this.channels = channels;
         this.data = data;
     }
-    /** Convert to browser-native ImageData (RGBA). */
+    /**
+     * Convert to browser-native ImageData (RGBA). Gray (1), gray+alpha (2) and
+     * RGB (3) are expanded; other channel counts throw.
+     */
     toImageData() {
         if (this.channels === 4) {
             return new ImageData(this.data, this.width, this.height);
         }
-        // Expand grayscale or RGB to RGBA
+        const c = this.channels;
+        if (c < 1 || c > 3) {
+            throw new Error(`ProcessingImage: cannot convert ${c} channels to RGBA (expected 1–4).`);
+        }
         const rgba = new Uint8ClampedArray(this.width * this.height * 4);
         for (let i = 0; i < this.width * this.height; i++) {
-            if (this.channels === 1) {
-                rgba[i * 4] = this.data[i];
-                rgba[i * 4 + 1] = this.data[i];
-                rgba[i * 4 + 2] = this.data[i];
+            const src = i * c;
+            const dst = i * 4;
+            if (c === 3) {
+                rgba[dst] = this.data[src];
+                rgba[dst + 1] = this.data[src + 1];
+                rgba[dst + 2] = this.data[src + 2];
             }
-            else if (this.channels === 3) {
-                rgba[i * 4] = this.data[i * 3];
-                rgba[i * 4 + 1] = this.data[i * 3 + 1];
-                rgba[i * 4 + 2] = this.data[i * 3 + 2];
+            else {
+                rgba[dst] = rgba[dst + 1] = rgba[dst + 2] = this.data[src];
             }
-            rgba[i * 4 + 3] = 255;
+            rgba[dst + 3] = c === 2 ? this.data[src + 1] : 255;
         }
         return new ImageData(rgba, this.width, this.height);
     }
-    /** Convert to Blob for saving/downloading. */
+    /** Convert to Blob for saving/downloading. Rejects when the browser can't encode it. */
     async toBlob(mime = 'image/png') {
         const canvas = document.createElement('canvas');
         canvas.width = this.width;
         canvas.height = this.height;
         const ctx = canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('ProcessingImage: no 2D canvas context available.');
         ctx.putImageData(this.toImageData(), 0, 0);
-        return new Promise((resolve) => {
-            canvas.toBlob((blob) => resolve(blob), mime);
+        return new Promise((resolve, reject) => {
+            canvas.toBlob((blob) => {
+                if (blob)
+                    resolve(blob);
+                else
+                    reject(new Error(`ProcessingImage: the browser could not encode the image as ${mime}.`));
+            }, mime);
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/provide-visualization.mjs

@@ -4,12 +4,25 @@ import { OpenSeadragonVisualizerService } from './implementations/osd/openseadra
 import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
 import { VisualizerStore } from './store/visualizer-store.service';
 import { RegionStore } from './store/region-store.service';
-import { WandToolService } from './toolbar/wand/wand-tool.service';
-import { VertexEraserToolService } from './toolbar/vertex-eraser/vertex-eraser-tool.service';
-import { ZoomToBoxToolService } from './toolbar/zoom-to-box/zoom-to-box-tool.service';
+import { SamToolService } from './toolbar/segmentation/sam-tool.service';
+import { SamPointToolService } from './toolbar/segmentation/sam-point-tool.service';
+import { CellSegmentToolService } from './toolbar/segmentation/cell-segment-tool.service';
+import { SpatialSelectionStore } from './store/spatial-selection.service';
+import { IntensityProfileService } from './intensity/intensity-profile.service';
 import { VISUALIZER } from './contracts/visualizer.contract';
 import { REGION_EDITOR_API } from './contracts/region-editor-api.contract';
 import { CHANNEL_HISTOGRAM_API } from './contracts/channel-histogram-api.contract';
+/**
+ * The three host-facing contracts, all served by the router. Shared by
+ * {@link provideVisualization} (component scope) and `VisualizationModule` (root),
+ * so both bind them the same way; at each scope they resolve to that scope's router.
+ * Package-internal (not exported from the public API).
+ */
+export const VISUALIZER_TOKEN_BINDINGS = [
+    { provide: VISUALIZER, useExisting: RoutingVisualizerService },
+    { provide: REGION_EDITOR_API, useExisting: RoutingVisualizerService },
+    { provide: CHANNEL_HISTOGRAM_API, useExisting: RoutingVisualizerService },
+];
 /**
  * A self-contained, isolated visualization backend chain for a component subtree.
  *
@@ -37,10 +50,20 @@ import { CHANNEL_HISTOGRAM_API } from './contracts/channel-histogram-api.contrac
  * embedded viewer gets its own router/Plotly/OSD/stores/tools while the rest of the
  * app keeps the default root instance.
  *
+ * In an application's own providers (`bootstrapApplication(App, { providers: [
+ * provideVisualization(), …] })`) it binds the one app-wide chain instead — the
+ * standalone counterpart of importing the deprecated `VisualizationModule`.
+ *
  * Lists EVERY stateful service in the chain. Stateless collaborators (HttpClient,
  * MessageService, WandService) deliberately resolve to root — they hold no
- * per-viewer state, so sharing them is correct and keeps this list minimal. When a
- * new stateful service joins the rendering chain, add it here too.
+ * per-viewer state, so sharing them is correct and keeps this list minimal. The
+ * SAM model session (`SamSessionService`) is also root on purpose: every viewer's
+ * SAM tools share one model download and Worker/GPU session (see its doc; a host
+ * can provide it at a viewer component to get a per-viewer session that is
+ * disposed with the viewer). When a
+ * new stateful service joins the rendering chain, add it here too —
+ * `provide-visualization.spec.ts` fails until it is listed (or allow-listed there as
+ * deliberately shared).
  */
 export function provideVisualization() {
     return [
@@ -50,14 +73,17 @@ export function provideVisualization() {
         NapariVisualizerService,
         VisualizerStore,
         RegionStore,
-        WandToolService,
-        VertexEraserToolService,
-        ZoomToBoxToolService,
-        // The three host-facing contracts are all served by the router — bound here at
-        // the SAME (component) scope so they resolve to the isolated instance, not root.
-        { provide: VISUALIZER, useExisting: RoutingVisualizerService },
-        { provide: REGION_EDITOR_API, useExisting: RoutingVisualizerService },
-        { provide: CHANNEL_HISTOGRAM_API, useExisting: RoutingVisualizerService },
+        SpatialSelectionStore,
+        IntensityProfileService,
+        // The canvas tools (wand, brush, eraser, zoom-to-box, SAM point) are not here:
+        // each backend above builds its own instances in its CanvasToolManager. The
+        // SAM point tools report through the chain's SamPointToolService.
+        SamToolService,
+        SamPointToolService,
+        CellSegmentToolService,
+        // The host-facing contracts, bound here at the SAME (component) scope so they
+        // resolve to the isolated router instance, not root.
+        ...VISUALIZER_TOKEN_BINDINGS,
     ];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provide-visualization.js","sourceRoot":"","sources":["../../../src/lib/provide-visualization.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AACxE,OAAO,EAAE,8BAA8B,EAAE,MAAM,wDAAwD,CAAC;AACxG,OAAO,EAAE,uBAAuB,EAAE,MAAM,uDAAuD,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AACpF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kDAAkD,CAAC;AAC1F,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAEnF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAe;IACnD,EAAE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,wBAAwB,EAAE;IAC9D,EAAE,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,wBAAwB,EAAE;IACrE,EAAE,OAAO,EAAE,qBAAqB,EAAE,WAAW,EAAE,wBAAwB,EAAE;CAC1E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO;QACL,wBAAwB;QACxB,aAAa;QACb,8BAA8B;QAC9B,uBAAuB;QACvB,eAAe;QACf,WAAW;QACX,qBAAqB;QACrB,uBAAuB;QACvB,+EAA+E;QAC/E,4EAA4E;QAC5E,kEAAkE;QAClE,cAAc;QACd,mBAAmB;QACnB,sBAAsB;QACtB,8EAA8E;QAC9E,qDAAqD;QACrD,GAAG,yBAAyB;KAC7B,CAAC;AACJ,CAAC","sourcesContent":["import { Provider } from '@angular/core';\n\nimport { RoutingVisualizerService } from './routing-visualizer.service';\nimport { PlotlyService } from './implementations/plotly/plotly.service';\nimport { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';\nimport { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { RegionStore } from './store/region-store.service';\nimport { SamToolService } from './toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from './toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from './toolbar/segmentation/cell-segment-tool.service';\nimport { SpatialSelectionStore } from './store/spatial-selection.service';\nimport { IntensityProfileService } from './intensity/intensity-profile.service';\nimport { VISUALIZER } from './contracts/visualizer.contract';\nimport { REGION_EDITOR_API } from './contracts/region-editor-api.contract';\nimport { CHANNEL_HISTOGRAM_API } from './contracts/channel-histogram-api.contract';\n\n/**\n * The three host-facing contracts, all served by the router. Shared by\n * {@link provideVisualization} (component scope) and `VisualizationModule` (root),\n * so both bind them the same way; at each scope they resolve to that scope's router.\n * Package-internal (not exported from the public API).\n */\nexport const VISUALIZER_TOKEN_BINDINGS: Provider[] = [\n  { provide: VISUALIZER, useExisting: RoutingVisualizerService },\n  { provide: REGION_EDITOR_API, useExisting: RoutingVisualizerService },\n  { provide: CHANNEL_HISTOGRAM_API, useExisting: RoutingVisualizerService },\n];\n\n/**\n * A self-contained, isolated visualization backend chain for a component subtree.\n *\n * The chain services are `providedIn: 'root'` singletons, so by default the whole\n * app shares one viewer's state (regions, image, channels, render handles) — which\n * is correct for the single main viewer. A consumer that needs a SECOND, independent\n * viewer (e.g. a modal that mounts `<visualizer>` over the live main view\n * and must not clobber its regions/image) drops this into its component `providers`:\n *\n * ```ts\n * @Component({\n *   ...,\n *   providers: [\n *     ...provideVisualization(),                 // isolated chain instance\n *     // plus the host ports + config for THIS viewer:\n *     { provide: IMAGE_STATE_PORT, useClass: MyImageStateAdapter },\n *     { provide: TILE_ACCESS_PORT, useClass: MyTileAccessAdapter },\n *     { provide: REGION_IO_PORT,   useClass: MyRegionIoAdapter },\n *     { provide: VIZ_CONFIG,       useValue: { slideCropServer: '' } },\n *   ],\n * })\n * ```\n *\n * Component-scoped providers shadow the root singletons for that subtree, so the\n * embedded viewer gets its own router/Plotly/OSD/stores/tools while the rest of the\n * app keeps the default root instance.\n *\n * In an application's own providers (`bootstrapApplication(App, { providers: [\n * provideVisualization(), …] })`) it binds the one app-wide chain instead — the\n * standalone counterpart of importing the deprecated `VisualizationModule`.\n *\n * Lists EVERY stateful service in the chain. Stateless collaborators (HttpClient,\n * MessageService, WandService) deliberately resolve to root — they hold no\n * per-viewer state, so sharing them is correct and keeps this list minimal. The\n * SAM model session (`SamSessionService`) is also root on purpose: every viewer's\n * SAM tools share one model download and Worker/GPU session (see its doc; a host\n * can provide it at a viewer component to get a per-viewer session that is\n * disposed with the viewer). When a\n * new stateful service joins the rendering chain, add it here too —\n * `provide-visualization.spec.ts` fails until it is listed (or allow-listed there as\n * deliberately shared).\n */\nexport function provideVisualization(): Provider[] {\n  return [\n    RoutingVisualizerService,\n    PlotlyService,\n    OpenSeadragonVisualizerService,\n    NapariVisualizerService,\n    VisualizerStore,\n    RegionStore,\n    SpatialSelectionStore,\n    IntensityProfileService,\n    // The canvas tools (wand, brush, eraser, zoom-to-box, SAM point) are not here:\n    // each backend above builds its own instances in its CanvasToolManager. The\n    // SAM point tools report through the chain's SamPointToolService.\n    SamToolService,\n    SamPointToolService,\n    CellSegmentToolService,\n    // The host-facing contracts, bound here at the SAME (component) scope so they\n    // resolve to the isolated router instance, not root.\n    ...VISUALIZER_TOKEN_BINDINGS,\n  ];\n}\n"]}

package/esm2022/lib/region-editor/classes-panel/classes-panel.component.mjs

@@ -0,0 +1,99 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ButtonModule } from 'primeng/button';
+import { TooltipModule } from 'primeng/tooltip';
+import { presetKey } from '../../store/class-color.util';
+import { HexColorPickerComponent } from '../../hex-color-picker/hex-color-picker.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "primeng/button";
+import * as i3 from "primeng/tooltip";
+/**
+ * The Region Editor's docked "Classes" panel (jit-ui#70): every annotation
+ * class with its colour swatch and region count. A row click picks the active
+ * class (and re-classifies a selection), the swatch recolours the class, the
+ * trash removes it, Manage opens the full editor. Presentational: the editor
+ * applies every action.
+ */
+export class ClassesPanelComponent {
+    constructor() {
+        /** The classes in display order. */
+        this.classes = [];
+        /** Region count per class, keyed by {@link presetKey} under `matchMode`. */
+        this.counts = new Map();
+        /** How labels are matched to classes (keys {@link counts}). */
+        this.matchMode = 'exact';
+        /** The active class (highlighted), or null. */
+        this.activeClass = null;
+        /** Number of selected regions (changes what a row click does). */
+        this.selectedCount = 0;
+        /** The class regions revert to; it can't be removed while in use. */
+        this.defaultClassName = 'Region';
+        /** A row was clicked: make the class active / apply it to the selection. */
+        this.pick = new EventEmitter();
+        /** A class's swatch picked a new colour. */
+        this.recolor = new EventEmitter();
+        /** A class's trash button (its name). */
+        this.remove = new EventEmitter();
+        /** Manage clicked. */
+        this.manage = new EventEmitter();
+        /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */
+        this.trackByName = (_, c) => c.name;
+        /** The rows drawn, rebuilt when an input changes rather than per check. */
+        this.rows = [];
+    }
+    ngOnChanges() {
+        this.rows = this.classes.map((c) => ({
+            name: c.name,
+            color: c.color,
+            count: this.count(c.name),
+            canRemove: this.canRemove(c.name),
+            rowTooltip: this.rowTooltip(c.name),
+            removeTooltip: this.removeTooltip(c.name),
+        }));
+    }
+    count(name) {
+        return this.counts.get(presetKey({ matchMode: this.matchMode }, name)) ?? 0;
+    }
+    canRemove(name) {
+        return !(name === this.defaultClassName && this.count(name) > 0);
+    }
+    rowTooltip(name) {
+        return this.selectedCount
+            ? `Apply “${name}” to the selected region(s)`
+            : `Set “${name}” active — new regions use it`;
+    }
+    removeTooltip(name) {
+        const inUse = this.count(name) > 0;
+        if (name === this.defaultClassName && inUse)
+            return 'The default class cannot be removed while in use';
+        return inUse ? `Remove class — its regions revert to ${this.defaultClassName}` : 'Remove class';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ClassesPanelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: ClassesPanelComponent, isStandalone: true, selector: "region-classes-panel", inputs: { classes: "classes", counts: "counts", matchMode: "matchMode", activeClass: "activeClass", selectedCount: "selectedCount", defaultClassName: "defaultClassName" }, outputs: { pick: "pick", recolor: "recolor", remove: "remove", manage: "manage" }, usesOnChanges: true, ngImport: i0, template: "<!-- Docked \"Classes\" panel (jit-ui#70): the always-visible list of annotation\n     classes above the regions table. Click a row to make it the active class\n     (new regions inherit it; with rows selected it re-classifies them); recolour\n     via the swatch; the badge shows how many regions use the class. \"Manage\"\n     opens the full editor (fallback palette, auto-add, matching, import/export). -->\n<div class=\"classes-panel\">\n  <div class=\"classes-panel-header\">\n    <span class=\"classes-panel-title\">Classes</span>\n    <button\n      pButton\n      type=\"button\"\n      icon=\"pi pi-cog\"\n      label=\"Manage\"\n      class=\"p-button-sm p-button-text\"\n      pTooltip=\"Manage classes \u2014 add / remove, palette, matching, import/export\"\n      tooltipPosition=\"bottom\"\n      (click)=\"manage.emit()\"\n    ></button>\n  </div>\n  <div class=\"classes-panel-body\">\n    <div\n      *ngFor=\"let c of rows; trackBy: trackByName\"\n      class=\"class-row\"\n      [class.active]=\"activeClass === c.name\"\n      (click)=\"pick.emit(c.name)\"\n      [pTooltip]=\"c.rowTooltip\"\n      tooltipPosition=\"bottom\"\n    >\n      <span class=\"row-swatch\" (click)=\"$event.stopPropagation()\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"recolor.emit({ name: c.name, color: $event })\">\n        </hex-color-picker>\n      </span>\n      <span class=\"row-name\">{{ c.name }}</span>\n      <span class=\"row-count\" [class.zero]=\"c.count === 0\">{{ c.count }}</span>\n      <button\n        pButton\n        type=\"button\"\n        icon=\"pi pi-trash\"\n        class=\"p-button-sm p-button-text p-button-warning row-del\"\n        [disabled]=\"!c.canRemove\"\n        [pTooltip]=\"c.removeTooltip\"\n        tooltipPosition=\"bottom\"\n        [attr.aria-label]=\"'Remove class ' + c.name\"\n        (click)=\"$event.stopPropagation(); remove.emit(c.name)\"\n      ></button>\n    </div>\n    <div *ngIf=\"!classes.length\" class=\"classes-empty\">No classes yet \u2014 add one from Manage.</div>\n  </div>\n</div>\n", styles: ["@charset \"UTF-8\";:host{display:block;flex:0 0 auto}.classes-panel{display:flex;flex-direction:column;flex:0 0 auto;border-bottom:1px solid var(--surface-border)}.classes-panel-header{display:flex;align-items:center;gap:.35rem;padding:.35rem .5rem;border-bottom:1px solid var(--surface-border)}.classes-panel-title{font-size:.75rem;font-weight:600;letter-spacing:.03em;text-transform:uppercase;color:var(--text-color-secondary);margin-right:auto}.classes-panel-body{height:7rem;min-height:2.5rem;max-height:60vh;overflow-x:hidden;overflow-y:auto;resize:vertical}::ng-deep region-classes-panel .classes-panel-body .hex-picker-swatch{width:1.25rem;height:1.25rem;border-width:1px}.class-row{display:flex;align-items:center;gap:.5rem;padding:.1rem .5rem;cursor:pointer;border-left:3px solid transparent}.class-row:hover{background:var(--surface-hover, rgba(0, 0, 0, .04))}.class-row.active{background:var(--highlight-bg, rgba(51, 153, 255, .12));border-left-color:var(--primary-color)}.class-row .row-swatch{flex:0 0 auto;display:inline-flex}.class-row .row-name{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.85rem}.class-row.active .row-name{color:var(--primary-color);font-weight:600}.class-row .row-count{flex:0 0 auto;min-width:1.5rem;text-align:center;font-size:.72rem;font-variant-numeric:tabular-nums;color:var(--text-color-secondary);background:var(--surface-200, rgba(0, 0, 0, .06));border-radius:10px;padding:0 .4rem}.class-row .row-count.zero{opacity:.5}.class-row .row-del{flex:0 0 auto}.classes-empty{font-size:.8rem;color:var(--text-color-secondary);padding:.5rem}::ng-deep region-classes-panel .classes-panel-body .class-row .p-button.p-button-icon-only{width:1.75rem;height:1.75rem;padding:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i2.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i3.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "component", type: HexColorPickerComponent, selector: "hex-color-picker", inputs: ["color"], outputs: ["colorChange", "colorInput"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ClassesPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'region-classes-panel', standalone: true, imports: [CommonModule, ButtonModule, TooltipModule, HexColorPickerComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: "<!-- Docked \"Classes\" panel (jit-ui#70): the always-visible list of annotation\n     classes above the regions table. Click a row to make it the active class\n     (new regions inherit it; with rows selected it re-classifies them); recolour\n     via the swatch; the badge shows how many regions use the class. \"Manage\"\n     opens the full editor (fallback palette, auto-add, matching, import/export). -->\n<div class=\"classes-panel\">\n  <div class=\"classes-panel-header\">\n    <span class=\"classes-panel-title\">Classes</span>\n    <button\n      pButton\n      type=\"button\"\n      icon=\"pi pi-cog\"\n      label=\"Manage\"\n      class=\"p-button-sm p-button-text\"\n      pTooltip=\"Manage classes \u2014 add / remove, palette, matching, import/export\"\n      tooltipPosition=\"bottom\"\n      (click)=\"manage.emit()\"\n    ></button>\n  </div>\n  <div class=\"classes-panel-body\">\n    <div\n      *ngFor=\"let c of rows; trackBy: trackByName\"\n      class=\"class-row\"\n      [class.active]=\"activeClass === c.name\"\n      (click)=\"pick.emit(c.name)\"\n      [pTooltip]=\"c.rowTooltip\"\n      tooltipPosition=\"bottom\"\n    >\n      <span class=\"row-swatch\" (click)=\"$event.stopPropagation()\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"recolor.emit({ name: c.name, color: $event })\">\n        </hex-color-picker>\n      </span>\n      <span class=\"row-name\">{{ c.name }}</span>\n      <span class=\"row-count\" [class.zero]=\"c.count === 0\">{{ c.count }}</span>\n      <button\n        pButton\n        type=\"button\"\n        icon=\"pi pi-trash\"\n        class=\"p-button-sm p-button-text p-button-warning row-del\"\n        [disabled]=\"!c.canRemove\"\n        [pTooltip]=\"c.removeTooltip\"\n        tooltipPosition=\"bottom\"\n        [attr.aria-label]=\"'Remove class ' + c.name\"\n        (click)=\"$event.stopPropagation(); remove.emit(c.name)\"\n      ></button>\n    </div>\n    <div *ngIf=\"!classes.length\" class=\"classes-empty\">No classes yet \u2014 add one from Manage.</div>\n  </div>\n</div>\n", styles: ["@charset \"UTF-8\";:host{display:block;flex:0 0 auto}.classes-panel{display:flex;flex-direction:column;flex:0 0 auto;border-bottom:1px solid var(--surface-border)}.classes-panel-header{display:flex;align-items:center;gap:.35rem;padding:.35rem .5rem;border-bottom:1px solid var(--surface-border)}.classes-panel-title{font-size:.75rem;font-weight:600;letter-spacing:.03em;text-transform:uppercase;color:var(--text-color-secondary);margin-right:auto}.classes-panel-body{height:7rem;min-height:2.5rem;max-height:60vh;overflow-x:hidden;overflow-y:auto;resize:vertical}::ng-deep region-classes-panel .classes-panel-body .hex-picker-swatch{width:1.25rem;height:1.25rem;border-width:1px}.class-row{display:flex;align-items:center;gap:.5rem;padding:.1rem .5rem;cursor:pointer;border-left:3px solid transparent}.class-row:hover{background:var(--surface-hover, rgba(0, 0, 0, .04))}.class-row.active{background:var(--highlight-bg, rgba(51, 153, 255, .12));border-left-color:var(--primary-color)}.class-row .row-swatch{flex:0 0 auto;display:inline-flex}.class-row .row-name{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.85rem}.class-row.active .row-name{color:var(--primary-color);font-weight:600}.class-row .row-count{flex:0 0 auto;min-width:1.5rem;text-align:center;font-size:.72rem;font-variant-numeric:tabular-nums;color:var(--text-color-secondary);background:var(--surface-200, rgba(0, 0, 0, .06));border-radius:10px;padding:0 .4rem}.class-row .row-count.zero{opacity:.5}.class-row .row-del{flex:0 0 auto}.classes-empty{font-size:.8rem;color:var(--text-color-secondary);padding:.5rem}::ng-deep region-classes-panel .classes-panel-body .class-row .p-button.p-button-icon-only{width:1.75rem;height:1.75rem;padding:0}\n"] }]
+        }], propDecorators: { classes: [{
+                type: Input
+            }], counts: [{
+                type: Input
+            }], matchMode: [{
+                type: Input
+            }], activeClass: [{
+                type: Input
+            }], selectedCount: [{
+                type: Input
+            }], defaultClassName: [{
+                type: Input
+            }], pick: [{
+                type: Output
+            }], recolor: [{
+                type: Output
+            }], remove: [{
+                type: Output
+            }], manage: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes-panel.component.js","sourceRoot":"","sources":["../../../../../src/lib/region-editor/classes-panel/classes-panel.component.ts","../../../../../src/lib/region-editor/classes-panel/classes-panel.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, OnChanges, Output } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ButtonModule } from 'primeng/button';\nimport { TooltipModule } from 'primeng/tooltip';\n\nimport { ClassPreset, MatchMode } from '../../models/class-preset';\nimport { presetKey } from '../../store/class-color.util';\nimport { HexColorPickerComponent } from '../../hex-color-picker/hex-color-picker.component';\n\n/** One class row as the template draws it, derived once per input change. */\ninterface ClassRow {\n  name: string;\n  color: string;\n  count: number;\n  canRemove: boolean;\n  rowTooltip: string;\n  removeTooltip: string;\n}\n\n/**\n * The Region Editor's docked \"Classes\" panel (jit-ui#70): every annotation\n * class with its colour swatch and region count. A row click picks the active\n * class (and re-classifies a selection), the swatch recolours the class, the\n * trash removes it, Manage opens the full editor. Presentational: the editor\n * applies every action.\n */\n@Component({\n  selector: 'region-classes-panel',\n  standalone: true,\n  imports: [CommonModule, ButtonModule, TooltipModule, HexColorPickerComponent],\n  templateUrl: './classes-panel.component.html',\n  styleUrls: ['./classes-panel.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ClassesPanelComponent implements OnChanges {\n  /** The classes in display order. */\n  @Input() classes: ClassPreset[] = [];\n  /** Region count per class, keyed by {@link presetKey} under `matchMode`. */\n  @Input() counts = new Map<string, number>();\n  /** How labels are matched to classes (keys {@link counts}). */\n  @Input() matchMode: MatchMode = 'exact';\n  /** The active class (highlighted), or null. */\n  @Input() activeClass: string | null = null;\n  /** Number of selected regions (changes what a row click does). */\n  @Input() selectedCount = 0;\n  /** The class regions revert to; it can't be removed while in use. */\n  @Input() defaultClassName = 'Region';\n\n  /** A row was clicked: make the class active / apply it to the selection. */\n  @Output() pick = new EventEmitter<string>();\n  /** A class's swatch picked a new colour. */\n  @Output() recolor = new EventEmitter<{ name: string; color: string }>();\n  /** A class's trash button (its name). */\n  @Output() remove = new EventEmitter<string>();\n  /** Manage clicked. */\n  @Output() manage = new EventEmitter<void>();\n\n  /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */\n  protected readonly trackByName = (_: number, c: ClassRow): string => c.name;\n\n  /** The rows drawn, rebuilt when an input changes rather than per check. */\n  protected rows: ClassRow[] = [];\n\n  ngOnChanges(): void {\n    this.rows = this.classes.map((c) => ({\n      name: c.name,\n      color: c.color,\n      count: this.count(c.name),\n      canRemove: this.canRemove(c.name),\n      rowTooltip: this.rowTooltip(c.name),\n      removeTooltip: this.removeTooltip(c.name),\n    }));\n  }\n\n  private count(name: string): number {\n    return this.counts.get(presetKey({ matchMode: this.matchMode }, name)) ?? 0;\n  }\n\n  private canRemove(name: string): boolean {\n    return !(name === this.defaultClassName && this.count(name) > 0);\n  }\n\n  protected rowTooltip(name: string): string {\n    return this.selectedCount\n      ? `Apply “${name}” to the selected region(s)`\n      : `Set “${name}” active — new regions use it`;\n  }\n\n  protected removeTooltip(name: string): string {\n    const inUse = this.count(name) > 0;\n    if (name === this.defaultClassName && inUse) return 'The default class cannot be removed while in use';\n    return inUse ? `Remove class — its regions revert to ${this.defaultClassName}` : 'Remove class';\n  }\n}\n","<!-- Docked \"Classes\" panel (jit-ui#70): the always-visible list of annotation\n     classes above the regions table. Click a row to make it the active class\n     (new regions inherit it; with rows selected it re-classifies them); recolour\n     via the swatch; the badge shows how many regions use the class. \"Manage\"\n     opens the full editor (fallback palette, auto-add, matching, import/export). -->\n<div class=\"classes-panel\">\n  <div class=\"classes-panel-header\">\n    <span class=\"classes-panel-title\">Classes</span>\n    <button\n      pButton\n      type=\"button\"\n      icon=\"pi pi-cog\"\n      label=\"Manage\"\n      class=\"p-button-sm p-button-text\"\n      pTooltip=\"Manage classes — add / remove, palette, matching, import/export\"\n      tooltipPosition=\"bottom\"\n      (click)=\"manage.emit()\"\n    ></button>\n  </div>\n  <div class=\"classes-panel-body\">\n    <div\n      *ngFor=\"let c of rows; trackBy: trackByName\"\n      class=\"class-row\"\n      [class.active]=\"activeClass === c.name\"\n      (click)=\"pick.emit(c.name)\"\n      [pTooltip]=\"c.rowTooltip\"\n      tooltipPosition=\"bottom\"\n    >\n      <span class=\"row-swatch\" (click)=\"$event.stopPropagation()\">\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"recolor.emit({ name: c.name, color: $event })\">\n        </hex-color-picker>\n      </span>\n      <span class=\"row-name\">{{ c.name }}</span>\n      <span class=\"row-count\" [class.zero]=\"c.count === 0\">{{ c.count }}</span>\n      <button\n        pButton\n        type=\"button\"\n        icon=\"pi pi-trash\"\n        class=\"p-button-sm p-button-text p-button-warning row-del\"\n        [disabled]=\"!c.canRemove\"\n        [pTooltip]=\"c.removeTooltip\"\n        tooltipPosition=\"bottom\"\n        [attr.aria-label]=\"'Remove class ' + c.name\"\n        (click)=\"$event.stopPropagation(); remove.emit(c.name)\"\n      ></button>\n    </div>\n    <div *ngIf=\"!classes.length\" class=\"classes-empty\">No classes yet — add one from Manage.</div>\n  </div>\n</div>\n"]}

package/esm2022/lib/region-editor/file-stem.mjs

@@ -0,0 +1,13 @@
+/**
+ * A file name without its extension: `slide.ome.tif` → `slide.ome`. A name with
+ * no extension — or only a leading dot, like `.hidden` — is returned whole, so
+ * a derived name is never a bare `.geojson`. `fallback` stands in for a missing
+ * name.
+ */
+export function fileStem(name, fallback) {
+    if (!name)
+        return fallback;
+    const dot = name.lastIndexOf('.');
+    return dot > 0 ? name.substring(0, dot) : name;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1zdGVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9yZWdpb24tZWRpdG9yL2ZpbGUtc3RlbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxRQUFRLENBQUMsSUFBK0IsRUFBRSxRQUFnQjtJQUN4RSxJQUFJLENBQUMsSUFBSTtRQUFFLE9BQU8sUUFBUSxDQUFDO0lBQzNCLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEMsT0FBTyxHQUFHLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ2pELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgZmlsZSBuYW1lIHdpdGhvdXQgaXRzIGV4dGVuc2lvbjogYHNsaWRlLm9tZS50aWZgIOKGkiBgc2xpZGUub21lYC4gQSBuYW1lIHdpdGhcbiAqIG5vIGV4dGVuc2lvbiDigJQgb3Igb25seSBhIGxlYWRpbmcgZG90LCBsaWtlIGAuaGlkZGVuYCDigJQgaXMgcmV0dXJuZWQgd2hvbGUsIHNvXG4gKiBhIGRlcml2ZWQgbmFtZSBpcyBuZXZlciBhIGJhcmUgYC5nZW9qc29uYC4gYGZhbGxiYWNrYCBzdGFuZHMgaW4gZm9yIGEgbWlzc2luZ1xuICogbmFtZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZpbGVTdGVtKG5hbWU6IHN0cmluZyB8IG51bGwgfCB1bmRlZmluZWQsIGZhbGxiYWNrOiBzdHJpbmcpOiBzdHJpbmcge1xuICBpZiAoIW5hbWUpIHJldHVybiBmYWxsYmFjaztcbiAgY29uc3QgZG90ID0gbmFtZS5sYXN0SW5kZXhPZignLicpO1xuICByZXR1cm4gZG90ID4gMCA/IG5hbWUuc3Vic3RyaW5nKDAsIGRvdCkgOiBuYW1lO1xufVxuIl19

package/esm2022/lib/region-editor/manage-classes-dialog/manage-classes-dialog.component.mjs

@@ -0,0 +1,118 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { SharedModule } from 'primeng/api';
+import { ButtonModule } from 'primeng/button';
+import { CheckboxModule } from 'primeng/checkbox';
+import { DialogModule } from 'primeng/dialog';
+import { InputTextModule } from 'primeng/inputtext';
+import { SelectButtonModule } from 'primeng/selectbutton';
+import { TooltipModule } from 'primeng/tooltip';
+import { HexColorPickerComponent } from '../../hex-color-picker/hex-color-picker.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "primeng/api";
+import * as i4 from "primeng/button";
+import * as i5 from "primeng/checkbox";
+import * as i6 from "primeng/dialog";
+import * as i7 from "primeng/inputtext";
+import * as i8 from "primeng/selectbutton";
+import * as i9 from "primeng/tooltip";
+/**
+ * "Manage annotation classes" (jit-ui#70): edit the classes, the fallback
+ * palette, auto-add and label matching of a working copy of the preset set,
+ * plus reset / import / export. The editor owns the draft (`[(draft)]`); every
+ * edit here emits a new draft object (nothing is changed in place), and Apply
+ * asks the editor to persist it.
+ */
+export class ManageClassesDialogComponent {
+    constructor() {
+        /** The dialog is open. */
+        this.visible = false;
+        /** The dialog was closed (`false`); two-way with {@link visible}. */
+        this.visibleChange = new EventEmitter();
+        /** The working copy being edited (null until the dialog is opened). */
+        this.draft = null;
+        /** Every edit: the new draft object; two-way with {@link draft}. */
+        this.draftChange = new EventEmitter();
+        /** Apply clicked: persist the draft and close. */
+        this.apply = new EventEmitter();
+        /** Reset clicked: restore the default classes. */
+        this.resetDefaults = new EventEmitter();
+        /** A preset JSON file was chosen (the input's change event). */
+        this.importFile = new EventEmitter();
+        /** Export clicked. */
+        this.export = new EventEmitter();
+        this.matchModeOptions = [
+            { label: 'Exact', value: 'exact' },
+            { label: 'Normalized', value: 'normalized' },
+        ];
+        /** Rows keep their DOM (and input focus) while their class object is replaced. */
+        this.trackByIndex = (i) => i;
+    }
+    addClass() {
+        this.update((d) => ({ classes: [...d.classes, { name: '', color: '#888888', source: 'user' }] }));
+    }
+    removeClass(i) {
+        this.update((d) => ({ classes: d.classes.filter((_, k) => k !== i) }));
+    }
+    patchClass(i, patch) {
+        this.update((d) => ({ classes: d.classes.map((c, k) => (k === i ? { ...c, ...patch } : c)) }));
+    }
+    addFallbackColor() {
+        this.update((d) => ({ fallbackPalette: [...d.fallbackPalette, '#888888'] }));
+    }
+    removeFallbackColor(i) {
+        this.update((d) => ({ fallbackPalette: d.fallbackPalette.filter((_, k) => k !== i) }));
+    }
+    setFallbackColor(i, color) {
+        this.update((d) => ({ fallbackPalette: d.fallbackPalette.map((c, k) => (k === i ? color : c)) }));
+    }
+    setAutoPromote(autoPromote) {
+        this.update(() => ({ autoPromote }));
+    }
+    setMatchMode(matchMode) {
+        this.update(() => ({ matchMode }));
+    }
+    update(change) {
+        if (!this.draft)
+            return;
+        this.draft = { ...this.draft, ...change(this.draft) };
+        this.draftChange.emit(this.draft);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ManageClassesDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: ManageClassesDialogComponent, isStandalone: true, selector: "region-manage-classes-dialog", inputs: { visible: "visible", draft: "draft" }, outputs: { visibleChange: "visibleChange", draftChange: "draftChange", apply: "apply", resetDefaults: "resetDefaults", importFile: "importFile", export: "export" }, ngImport: i0, template: "<p-dialog\n  header=\"Manage annotation classes\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [modal]=\"true\"\n  appendTo=\"body\"\n  [style]=\"{ width: '34rem' }\"\n  [draggable]=\"true\"\n  [resizable]=\"false\"\n>\n  <div *ngIf=\"draft\" class=\"manage-dialog flex flex-column gap-3 pt-2\">\n    <div class=\"manage-classes flex flex-column gap-2\">\n      <div\n        *ngFor=\"let c of draft.classes; let i = index; trackBy: trackByIndex\"\n        class=\"manage-class-row flex align-items-center gap-2\"\n      >\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"patchClass(i, { color: $event })\"></hex-color-picker>\n        <input\n          type=\"text\"\n          pInputText\n          class=\"p-inputtext-sm flex-1\"\n          [ngModel]=\"c.name\"\n          (ngModelChange)=\"patchClass(i, { name: $event })\"\n          placeholder=\"Class name\"\n          aria-label=\"Class name\"\n        />\n        <button\n          pButton\n          type=\"button\"\n          icon=\"pi pi-trash\"\n          class=\"p-button-sm p-button-text p-button-warning\"\n          pTooltip=\"Remove class\"\n          tooltipPosition=\"bottom\"\n          aria-label=\"Remove class\"\n          (click)=\"removeClass(i)\"\n        ></button>\n      </div>\n      <button\n        pButton\n        type=\"button\"\n        icon=\"pi pi-plus\"\n        label=\"Add class\"\n        class=\"p-button-sm p-button-text align-self-start\"\n        (click)=\"addClass()\"\n      ></button>\n    </div>\n\n    <div class=\"manage-section flex flex-column gap-2\">\n      <span class=\"section-title font-medium\"\n        >Fallback palette <small class=\"text-color-secondary\">\u2014 colours for classes not listed</small></span\n      >\n      <div class=\"fallback-palette flex align-items-center flex-wrap gap-2\">\n        <span\n          *ngFor=\"let col of draft.fallbackPalette; let i = index; trackBy: trackByIndex\"\n          class=\"fallback-swatch flex align-items-center\"\n        >\n          <hex-color-picker [color]=\"col\" (colorChange)=\"setFallbackColor(i, $event)\"></hex-color-picker>\n          <i\n            class=\"pi pi-times icon-hover ml-1\"\n            pTooltip=\"Remove\"\n            tooltipPosition=\"bottom\"\n            (click)=\"removeFallbackColor(i)\"\n          ></i>\n        </span>\n        <button\n          pButton\n          type=\"button\"\n          icon=\"pi pi-plus\"\n          class=\"p-button-sm p-button-text\"\n          pTooltip=\"Add fallback colour\"\n          tooltipPosition=\"bottom\"\n          aria-label=\"Add fallback colour\"\n          (click)=\"addFallbackColor()\"\n        ></button>\n      </div>\n    </div>\n\n    <div class=\"flex align-items-center gap-2\">\n      <p-checkbox\n        [ngModel]=\"draft.autoPromote\"\n        (ngModelChange)=\"setAutoPromote($event)\"\n        [binary]=\"true\"\n        inputId=\"autoPromote\"\n      ></p-checkbox>\n      <label for=\"autoPromote\">Auto-add detected classes to this list as they appear</label>\n    </div>\n\n    <div class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium\">Label matching</span>\n      <p-selectButton\n        [options]=\"matchModeOptions\"\n        [ngModel]=\"draft.matchMode\"\n        (ngModelChange)=\"setMatchMode($event)\"\n        optionLabel=\"label\"\n        optionValue=\"value\"\n      ></p-selectButton>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"manage-footer flex align-items-center flex-wrap gap-2 w-full\">\n      <span class=\"flex align-items-center flex-wrap gap-1\">\n        <p-button label=\"Reset\" icon=\"pi pi-refresh\" [text]=\"true\" (onClick)=\"resetDefaults.emit()\"></p-button>\n        <p-button label=\"Import\" icon=\"pi pi-upload\" [text]=\"true\" (onClick)=\"presetFileInput.click()\"></p-button>\n        <input\n          #presetFileInput\n          type=\"file\"\n          accept=\".json,application/json\"\n          hidden\n          (change)=\"importFile.emit($event); presetFileInput.value = ''\"\n        />\n        <p-button label=\"Export\" icon=\"pi pi-download\" [text]=\"true\" (onClick)=\"export.emit()\"></p-button>\n      </span>\n      <span class=\"flex-1\"></span>\n      <!-- Apply persists to the server and closes. -->\n      <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"apply.emit()\"></p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n", styles: [".manage-dialog .manage-class-row hex-color-picker,.manage-dialog .fallback-palette hex-color-picker{flex:0 0 auto}.manage-dialog .fallback-palette .icon-hover{cursor:pointer;color:var(--text-color-secondary)}.manage-dialog .fallback-palette .icon-hover:hover{color:var(--primary-color)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: SharedModule }, { kind: "directive", type: i3.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i4.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain"] }, { kind: "component", type: i4.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "ngmodule", type: CheckboxModule }, { kind: "component", type: i5.Checkbox, selector: "p-checkbox", inputs: ["value", "name", "disabled", "binary", "label", "ariaLabelledBy", "ariaLabel", "tabindex", "inputId", "style", "styleClass", "labelStyleClass", "formControl", "checkboxIcon", "readonly", "required", "autofocus", "trueValue", "falseValue", "variant"], outputs: ["onChange", "onFocus", "onBlur"] }, { kind: "ngmodule", type: DialogModule }, { kind: "component", type: i6.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "visible", "style", "position"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i7.InputText, selector: "[pInputText]", inputs: ["variant"] }, { kind: "ngmodule", type: SelectButtonModule }, { kind: "component", type: i8.SelectButton, selector: "p-selectButton", inputs: ["options", "optionLabel", "optionValue", "optionDisabled", "unselectable", "tabindex", "multiple", "allowEmpty", "style", "styleClass", "ariaLabelledBy", "disabled", "dataKey", "autofocus"], outputs: ["onOptionClick", "onChange"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i9.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "component", type: HexColorPickerComponent, selector: "hex-color-picker", inputs: ["color"], outputs: ["colorChange", "colorInput"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ManageClassesDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'region-manage-classes-dialog', standalone: true, imports: [
+                        CommonModule,
+                        FormsModule,
+                        SharedModule,
+                        ButtonModule,
+                        CheckboxModule,
+                        DialogModule,
+                        InputTextModule,
+                        SelectButtonModule,
+                        TooltipModule,
+                        HexColorPickerComponent,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<p-dialog\n  header=\"Manage annotation classes\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [modal]=\"true\"\n  appendTo=\"body\"\n  [style]=\"{ width: '34rem' }\"\n  [draggable]=\"true\"\n  [resizable]=\"false\"\n>\n  <div *ngIf=\"draft\" class=\"manage-dialog flex flex-column gap-3 pt-2\">\n    <div class=\"manage-classes flex flex-column gap-2\">\n      <div\n        *ngFor=\"let c of draft.classes; let i = index; trackBy: trackByIndex\"\n        class=\"manage-class-row flex align-items-center gap-2\"\n      >\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"patchClass(i, { color: $event })\"></hex-color-picker>\n        <input\n          type=\"text\"\n          pInputText\n          class=\"p-inputtext-sm flex-1\"\n          [ngModel]=\"c.name\"\n          (ngModelChange)=\"patchClass(i, { name: $event })\"\n          placeholder=\"Class name\"\n          aria-label=\"Class name\"\n        />\n        <button\n          pButton\n          type=\"button\"\n          icon=\"pi pi-trash\"\n          class=\"p-button-sm p-button-text p-button-warning\"\n          pTooltip=\"Remove class\"\n          tooltipPosition=\"bottom\"\n          aria-label=\"Remove class\"\n          (click)=\"removeClass(i)\"\n        ></button>\n      </div>\n      <button\n        pButton\n        type=\"button\"\n        icon=\"pi pi-plus\"\n        label=\"Add class\"\n        class=\"p-button-sm p-button-text align-self-start\"\n        (click)=\"addClass()\"\n      ></button>\n    </div>\n\n    <div class=\"manage-section flex flex-column gap-2\">\n      <span class=\"section-title font-medium\"\n        >Fallback palette <small class=\"text-color-secondary\">\u2014 colours for classes not listed</small></span\n      >\n      <div class=\"fallback-palette flex align-items-center flex-wrap gap-2\">\n        <span\n          *ngFor=\"let col of draft.fallbackPalette; let i = index; trackBy: trackByIndex\"\n          class=\"fallback-swatch flex align-items-center\"\n        >\n          <hex-color-picker [color]=\"col\" (colorChange)=\"setFallbackColor(i, $event)\"></hex-color-picker>\n          <i\n            class=\"pi pi-times icon-hover ml-1\"\n            pTooltip=\"Remove\"\n            tooltipPosition=\"bottom\"\n            (click)=\"removeFallbackColor(i)\"\n          ></i>\n        </span>\n        <button\n          pButton\n          type=\"button\"\n          icon=\"pi pi-plus\"\n          class=\"p-button-sm p-button-text\"\n          pTooltip=\"Add fallback colour\"\n          tooltipPosition=\"bottom\"\n          aria-label=\"Add fallback colour\"\n          (click)=\"addFallbackColor()\"\n        ></button>\n      </div>\n    </div>\n\n    <div class=\"flex align-items-center gap-2\">\n      <p-checkbox\n        [ngModel]=\"draft.autoPromote\"\n        (ngModelChange)=\"setAutoPromote($event)\"\n        [binary]=\"true\"\n        inputId=\"autoPromote\"\n      ></p-checkbox>\n      <label for=\"autoPromote\">Auto-add detected classes to this list as they appear</label>\n    </div>\n\n    <div class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium\">Label matching</span>\n      <p-selectButton\n        [options]=\"matchModeOptions\"\n        [ngModel]=\"draft.matchMode\"\n        (ngModelChange)=\"setMatchMode($event)\"\n        optionLabel=\"label\"\n        optionValue=\"value\"\n      ></p-selectButton>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"manage-footer flex align-items-center flex-wrap gap-2 w-full\">\n      <span class=\"flex align-items-center flex-wrap gap-1\">\n        <p-button label=\"Reset\" icon=\"pi pi-refresh\" [text]=\"true\" (onClick)=\"resetDefaults.emit()\"></p-button>\n        <p-button label=\"Import\" icon=\"pi pi-upload\" [text]=\"true\" (onClick)=\"presetFileInput.click()\"></p-button>\n        <input\n          #presetFileInput\n          type=\"file\"\n          accept=\".json,application/json\"\n          hidden\n          (change)=\"importFile.emit($event); presetFileInput.value = ''\"\n        />\n        <p-button label=\"Export\" icon=\"pi pi-download\" [text]=\"true\" (onClick)=\"export.emit()\"></p-button>\n      </span>\n      <span class=\"flex-1\"></span>\n      <!-- Apply persists to the server and closes. -->\n      <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"apply.emit()\"></p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n", styles: [".manage-dialog .manage-class-row hex-color-picker,.manage-dialog .fallback-palette hex-color-picker{flex:0 0 auto}.manage-dialog .fallback-palette .icon-hover{cursor:pointer;color:var(--text-color-secondary)}.manage-dialog .fallback-palette .icon-hover:hover{color:var(--primary-color)}\n"] }]
+        }], propDecorators: { visible: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }], draft: [{
+                type: Input
+            }], draftChange: [{
+                type: Output
+            }], apply: [{
+                type: Output
+            }], resetDefaults: [{
+                type: Output
+            }], importFile: [{
+                type: Output
+            }], export: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manage-classes-dialog.component.js","sourceRoot":"","sources":["../../../../../src/lib/region-editor/manage-classes-dialog/manage-classes-dialog.component.ts","../../../../../src/lib/region-editor/manage-classes-dialog/manage-classes-dialog.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { SharedModule } from 'primeng/api';\nimport { ButtonModule } from 'primeng/button';\nimport { CheckboxModule } from 'primeng/checkbox';\nimport { DialogModule } from 'primeng/dialog';\nimport { InputTextModule } from 'primeng/inputtext';\nimport { SelectButtonModule } from 'primeng/selectbutton';\nimport { TooltipModule } from 'primeng/tooltip';\n\nimport { ClassPreset, MatchMode, PresetSet } from '../../models/class-preset';\nimport { HexColorPickerComponent } from '../../hex-color-picker/hex-color-picker.component';\n\n/**\n * \"Manage annotation classes\" (jit-ui#70): edit the classes, the fallback\n * palette, auto-add and label matching of a working copy of the preset set,\n * plus reset / import / export. The editor owns the draft (`[(draft)]`); every\n * edit here emits a new draft object (nothing is changed in place), and Apply\n * asks the editor to persist it.\n */\n@Component({\n  selector: 'region-manage-classes-dialog',\n  standalone: true,\n  imports: [\n    CommonModule,\n    FormsModule,\n    SharedModule,\n    ButtonModule,\n    CheckboxModule,\n    DialogModule,\n    InputTextModule,\n    SelectButtonModule,\n    TooltipModule,\n    HexColorPickerComponent,\n  ],\n  templateUrl: './manage-classes-dialog.component.html',\n  styleUrls: ['./manage-classes-dialog.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ManageClassesDialogComponent {\n  /** The dialog is open. */\n  @Input() visible = false;\n  /** The dialog was closed (`false`); two-way with {@link visible}. */\n  @Output() visibleChange = new EventEmitter<boolean>();\n\n  /** The working copy being edited (null until the dialog is opened). */\n  @Input() draft: PresetSet | null = null;\n  /** Every edit: the new draft object; two-way with {@link draft}. */\n  @Output() draftChange = new EventEmitter<PresetSet>();\n\n  /** Apply clicked: persist the draft and close. */\n  @Output() apply = new EventEmitter<void>();\n  /** Reset clicked: restore the default classes. */\n  @Output() resetDefaults = new EventEmitter<void>();\n  /** A preset JSON file was chosen (the input's change event). */\n  @Output() importFile = new EventEmitter<Event>();\n  /** Export clicked. */\n  @Output() export = new EventEmitter<void>();\n\n  protected readonly matchModeOptions = [\n    { label: 'Exact', value: 'exact' },\n    { label: 'Normalized', value: 'normalized' },\n  ];\n\n  /** Rows keep their DOM (and input focus) while their class object is replaced. */\n  protected readonly trackByIndex = (i: number): number => i;\n\n  protected addClass(): void {\n    this.update((d) => ({ classes: [...d.classes, { name: '', color: '#888888', source: 'user' }] }));\n  }\n\n  protected removeClass(i: number): void {\n    this.update((d) => ({ classes: d.classes.filter((_, k) => k !== i) }));\n  }\n\n  protected patchClass(i: number, patch: Partial<ClassPreset>): void {\n    this.update((d) => ({ classes: d.classes.map((c, k) => (k === i ? { ...c, ...patch } : c)) }));\n  }\n\n  protected addFallbackColor(): void {\n    this.update((d) => ({ fallbackPalette: [...d.fallbackPalette, '#888888'] }));\n  }\n\n  protected removeFallbackColor(i: number): void {\n    this.update((d) => ({ fallbackPalette: d.fallbackPalette.filter((_, k) => k !== i) }));\n  }\n\n  protected setFallbackColor(i: number, color: string): void {\n    this.update((d) => ({ fallbackPalette: d.fallbackPalette.map((c, k) => (k === i ? color : c)) }));\n  }\n\n  protected setAutoPromote(autoPromote: boolean): void {\n    this.update(() => ({ autoPromote }));\n  }\n\n  protected setMatchMode(matchMode: MatchMode): void {\n    this.update(() => ({ matchMode }));\n  }\n\n  private update(change: (d: PresetSet) => Partial<PresetSet>): void {\n    if (!this.draft) return;\n    this.draft = { ...this.draft, ...change(this.draft) };\n    this.draftChange.emit(this.draft);\n  }\n}\n","<p-dialog\n  header=\"Manage annotation classes\"\n  [visible]=\"visible\"\n  (visibleChange)=\"visibleChange.emit($event)\"\n  [modal]=\"true\"\n  appendTo=\"body\"\n  [style]=\"{ width: '34rem' }\"\n  [draggable]=\"true\"\n  [resizable]=\"false\"\n>\n  <div *ngIf=\"draft\" class=\"manage-dialog flex flex-column gap-3 pt-2\">\n    <div class=\"manage-classes flex flex-column gap-2\">\n      <div\n        *ngFor=\"let c of draft.classes; let i = index; trackBy: trackByIndex\"\n        class=\"manage-class-row flex align-items-center gap-2\"\n      >\n        <hex-color-picker [color]=\"c.color\" (colorChange)=\"patchClass(i, { color: $event })\"></hex-color-picker>\n        <input\n          type=\"text\"\n          pInputText\n          class=\"p-inputtext-sm flex-1\"\n          [ngModel]=\"c.name\"\n          (ngModelChange)=\"patchClass(i, { name: $event })\"\n          placeholder=\"Class name\"\n          aria-label=\"Class name\"\n        />\n        <button\n          pButton\n          type=\"button\"\n          icon=\"pi pi-trash\"\n          class=\"p-button-sm p-button-text p-button-warning\"\n          pTooltip=\"Remove class\"\n          tooltipPosition=\"bottom\"\n          aria-label=\"Remove class\"\n          (click)=\"removeClass(i)\"\n        ></button>\n      </div>\n      <button\n        pButton\n        type=\"button\"\n        icon=\"pi pi-plus\"\n        label=\"Add class\"\n        class=\"p-button-sm p-button-text align-self-start\"\n        (click)=\"addClass()\"\n      ></button>\n    </div>\n\n    <div class=\"manage-section flex flex-column gap-2\">\n      <span class=\"section-title font-medium\"\n        >Fallback palette <small class=\"text-color-secondary\">— colours for classes not listed</small></span\n      >\n      <div class=\"fallback-palette flex align-items-center flex-wrap gap-2\">\n        <span\n          *ngFor=\"let col of draft.fallbackPalette; let i = index; trackBy: trackByIndex\"\n          class=\"fallback-swatch flex align-items-center\"\n        >\n          <hex-color-picker [color]=\"col\" (colorChange)=\"setFallbackColor(i, $event)\"></hex-color-picker>\n          <i\n            class=\"pi pi-times icon-hover ml-1\"\n            pTooltip=\"Remove\"\n            tooltipPosition=\"bottom\"\n            (click)=\"removeFallbackColor(i)\"\n          ></i>\n        </span>\n        <button\n          pButton\n          type=\"button\"\n          icon=\"pi pi-plus\"\n          class=\"p-button-sm p-button-text\"\n          pTooltip=\"Add fallback colour\"\n          tooltipPosition=\"bottom\"\n          aria-label=\"Add fallback colour\"\n          (click)=\"addFallbackColor()\"\n        ></button>\n      </div>\n    </div>\n\n    <div class=\"flex align-items-center gap-2\">\n      <p-checkbox\n        [ngModel]=\"draft.autoPromote\"\n        (ngModelChange)=\"setAutoPromote($event)\"\n        [binary]=\"true\"\n        inputId=\"autoPromote\"\n      ></p-checkbox>\n      <label for=\"autoPromote\">Auto-add detected classes to this list as they appear</label>\n    </div>\n\n    <div class=\"flex align-items-center gap-3\">\n      <span class=\"font-medium\">Label matching</span>\n      <p-selectButton\n        [options]=\"matchModeOptions\"\n        [ngModel]=\"draft.matchMode\"\n        (ngModelChange)=\"setMatchMode($event)\"\n        optionLabel=\"label\"\n        optionValue=\"value\"\n      ></p-selectButton>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"manage-footer flex align-items-center flex-wrap gap-2 w-full\">\n      <span class=\"flex align-items-center flex-wrap gap-1\">\n        <p-button label=\"Reset\" icon=\"pi pi-refresh\" [text]=\"true\" (onClick)=\"resetDefaults.emit()\"></p-button>\n        <p-button label=\"Import\" icon=\"pi pi-upload\" [text]=\"true\" (onClick)=\"presetFileInput.click()\"></p-button>\n        <input\n          #presetFileInput\n          type=\"file\"\n          accept=\".json,application/json\"\n          hidden\n          (change)=\"importFile.emit($event); presetFileInput.value = ''\"\n        />\n        <p-button label=\"Export\" icon=\"pi pi-download\" [text]=\"true\" (onClick)=\"export.emit()\"></p-button>\n      </span>\n      <span class=\"flex-1\"></span>\n      <!-- Apply persists to the server and closes. -->\n      <p-button label=\"Apply\" icon=\"pi pi-check\" (onClick)=\"apply.emit()\"></p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n"]}