@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.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/class-tree/class-tree.component.mjs

@@ -0,0 +1,156 @@
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, Input, Output, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { InputTextModule } from 'primeng/inputtext';
+import { TooltipModule } from 'primeng/tooltip';
+import { HexColorPickerComponent } from '../../hex-color-picker/hex-color-picker.component';
+import { ancestors, buildClassTree, subtree, visibleRows } from './class-tree';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "primeng/inputtext";
+import * as i4 from "primeng/tooltip";
+/**
+ * The Region Editor's classes as a hierarchy (a brain atlas's ontology), as the Allen atlas viewer
+ * shows it: collapsible, each class with its colour, name and long name, and the regions it and
+ * its subclasses have on this slice; a class with none is greyed. Picking a class selects all its
+ * regions and its subclasses' (the editor does the selecting). Search by name or long name. A
+ * class's swatch recolours it, as the class list's does; its eye hides it and its subclasses.
+ */
+export class ClassTreeComponent {
+    constructor(el) {
+        this.el = el;
+        /** The hierarchy. */
+        this.nodes = [];
+        /** Regions per class on this slice (the regions and the region source's). */
+        this.counts = new Map();
+        /** A class's colour (a new function when the colours change, so the rows repaint). */
+        this.colorOf = () => '#999999';
+        /** The class picked last (highlighted, its path expanded, scrolled into view). */
+        this.picked = null;
+        /** Classes with a selected region (marked). */
+        this.marked = new Set();
+        /** Whether a volume view is on screen: each class can then be shown in 3D. */
+        this.volume = false;
+        /** The classes shown in 3D. */
+        this.shown3d = new Set();
+        /** The classes hidden from view. */
+        this.hidden = new Set();
+        this.pick = new EventEmitter();
+        /** A class's swatch picked a new colour. */
+        this.recolor = new EventEmitter();
+        /** A class's 3D toggle: it with every class under it. */
+        this.toggle3d = new EventEmitter();
+        /** A class's eye: hide (or show) it with every class under it. */
+        this.toggleHidden = new EventEmitter();
+        this.tree = buildClassTree([], new Map());
+        this.rows = [];
+        /** Each row's visibility (a row absent: shown). */
+        this.visibility = new Map();
+        this.query = '';
+        this.expanded = new Set();
+        this.trackRow = (_, r) => r.name;
+    }
+    ngOnChanges(changes) {
+        const fresh = !!changes['nodes'];
+        if (fresh || changes['counts'])
+            this.tree = buildClassTree(this.nodes, this.counts);
+        // A new hierarchy opens with its roots expanded, as the atlas viewer does.
+        if (fresh)
+            this.expanded = new Set(this.tree.roots);
+        if (changes['picked'] && this.picked)
+            for (const a of ancestors(this.tree, this.picked))
+                this.expanded.add(a);
+        this.refresh();
+        // A pick from elsewhere (a surface clicked in 3D) may be off screen: bring its row into view.
+        if (changes['picked'] && this.picked)
+            setTimeout(() => scrollToPicked(this.el.nativeElement, '.tree-row.picked'));
+    }
+    node(name) {
+        return this.tree.node.get(name);
+    }
+    total(name) {
+        return this.tree.total.get(name) ?? 0;
+    }
+    toggle(row, event) {
+        event.stopPropagation();
+        if (this.expanded.has(row.name))
+            this.expanded.delete(row.name);
+        else
+            this.expanded.add(row.name);
+        this.refresh();
+    }
+    choose(name, event) {
+        const e = event;
+        this.pick.emit({ name, classes: subtree(this.tree, name), additive: e.shiftKey || e.metaKey || e.ctrlKey });
+    }
+    /** The eye: a class hidden (wholly) is shown again with its subclasses; otherwise they are hidden. */
+    flipHidden(name, event) {
+        event.stopPropagation();
+        const hidden = this.visibility.get(name) !== 'hidden';
+        this.toggleHidden.emit({ classes: subtree(this.tree, name), hidden });
+    }
+    flip3d(name, event) {
+        event.stopPropagation();
+        this.toggle3d.emit({ name, classes: subtree(this.tree, name) });
+    }
+    onQuery(value) {
+        this.query = value;
+        this.refresh();
+    }
+    /** Enter in the search box picks the first match. */
+    pickFirstMatch(event) {
+        const q = this.query.trim().toLowerCase();
+        const hit = this.rows.find((r) => r.name.toLowerCase().includes(q) || (this.node(r.name)?.title ?? '').toLowerCase().includes(q));
+        if (hit)
+            this.choose(hit.name, event);
+    }
+    refresh() {
+        this.rows = visibleRows(this.tree, this.expanded, this.query);
+        this.visibility = new Map();
+        if (!this.hidden.size)
+            return;
+        for (const row of this.rows) {
+            const classes = subtree(this.tree, row.name);
+            const off = classes.filter((c) => this.hidden.has(c)).length;
+            if (off)
+                this.visibility.set(row.name, off === classes.length ? 'hidden' : 'partial');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: ClassTreeComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: ClassTreeComponent, isStandalone: true, selector: "region-class-tree", inputs: { nodes: "nodes", counts: "counts", colorOf: "colorOf", picked: "picked", marked: "marked", volume: "volume", shown3d: "shown3d", hidden: "hidden" }, outputs: { pick: "pick", recolor: "recolor", toggle3d: "toggle3d", toggleHidden: "toggleHidden" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"class-tree\">\n  <div class=\"tree-header\" *ngIf=\"picked as p\">\n    <span class=\"tree-picked\">\n      <b>{{ p }}</b\n      ><span *ngIf=\"node(p)?.title as t\"> \u00B7 {{ t }}</span>\n    </span>\n  </div>\n  <input\n    type=\"text\"\n    pInputText\n    class=\"p-inputtext-sm tree-search\"\n    placeholder=\"Search by name\"\n    aria-label=\"Search the classes\"\n    [ngModel]=\"query\"\n    (ngModelChange)=\"onQuery($event)\"\n    (keydown.enter)=\"pickFirstMatch($event)\"\n  />\n  <div class=\"tree-body\" role=\"tree\">\n    <div\n      *ngFor=\"let row of rows; trackBy: trackRow\"\n      class=\"tree-row\"\n      role=\"treeitem\"\n      tabindex=\"0\"\n      [attr.aria-expanded]=\"row.hasChildren ? row.expanded : null\"\n      [class.absent]=\"total(row.name) === 0\"\n      [class.picked]=\"row.name === picked\"\n      [class.marked]=\"marked.has(row.name)\"\n      [class.hidden-class]=\"visibility.get(row.name) === 'hidden'\"\n      [style.padding-left.rem]=\"0.35 + row.depth * 0.9\"\n      [pTooltip]=\"node(row.name)?.title || row.name\"\n      tooltipPosition=\"left\"\n      [showDelay]=\"600\"\n      (click)=\"choose(row.name, $event)\"\n      (keydown.enter)=\"choose(row.name, $event)\"\n    >\n      <i\n        class=\"pi tree-toggle\"\n        [class.pi-minus-circle]=\"row.hasChildren && row.expanded\"\n        [class.pi-plus-circle]=\"row.hasChildren && !row.expanded\"\n        [attr.aria-label]=\"row.expanded ? 'Collapse' : 'Expand'\"\n        (click)=\"row.hasChildren && toggle(row, $event)\"\n      ></i>\n      <i\n        class=\"pi tree-eye\"\n        [ngClass]=\"visibility.get(row.name) === 'hidden' ? 'pi-eye-slash' : 'pi-eye'\"\n        [class.partial]=\"visibility.get(row.name) === 'partial'\"\n        role=\"button\"\n        [attr.aria-pressed]=\"visibility.get(row.name) !== 'hidden'\"\n        [attr.aria-label]=\"(visibility.get(row.name) === 'hidden' ? 'Show ' : 'Hide ') + row.name\"\n        [pTooltip]=\"\n          (visibility.get(row.name) === 'hidden' ? 'Show' : 'Hide') +\n          (row.hasChildren ? ' it and its subclasses' : '') +\n          (visibility.get(row.name) === 'partial' ? ' (some are hidden)' : '')\n        \"\n        tooltipPosition=\"left\"\n        (click)=\"flipHidden(row.name, $event)\"\n        (keydown.enter)=\"flipHidden(row.name, $event)\"\n      ></i>\n      <span class=\"tree-swatch\" (click)=\"$event.stopPropagation()\" (keydown.enter)=\"$event.stopPropagation()\">\n        <hex-color-picker\n          [color]=\"colorOf(row.name)\"\n          (colorChange)=\"recolor.emit({ name: row.name, color: $event })\"\n        >\n        </hex-color-picker>\n      </span>\n      <span class=\"tree-name\">{{ row.name }}</span>\n      <span class=\"tree-long\">{{ node(row.name)?.title }}</span>\n      <span class=\"tree-count\" *ngIf=\"total(row.name) > 0\">{{ total(row.name) }}</span>\n      <i\n        *ngIf=\"volume\"\n        class=\"pi pi-box tree-3d\"\n        [class.on]=\"shown3d.has(row.name)\"\n        role=\"button\"\n        [attr.aria-pressed]=\"shown3d.has(row.name)\"\n        [attr.aria-label]=\"'Show ' + row.name + ' in 3D'\"\n        pTooltip=\"Show in the volume, in 3D\"\n        tooltipPosition=\"left\"\n        (click)=\"flip3d(row.name, $event)\"\n      ></i>\n    </div>\n    <div *ngIf=\"!rows.length\" class=\"tree-empty\">No class matches.</div>\n  </div>\n</div>\n", styles: [":host{display:block;flex:0 0 auto}.class-tree{display:flex;flex-direction:column;padding-top:.25rem}.tree-header{display:flex;align-items:baseline;gap:.5rem;padding:0 .5rem .25rem}.tree-picked{font-size:.8rem;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tree-search{margin:0 .5rem .25rem}.tree-body{height:14rem;min-height:3rem;max-height:70vh;overflow:auto;resize:vertical;padding-bottom:.25rem}.tree-row{display:flex;align-items:center;gap:.35rem;padding-top:.05rem;padding-bottom:.05rem;padding-right:.5rem;cursor:pointer;font-size:.8rem;white-space:nowrap}.tree-row:hover,.tree-row:focus-visible{background:var(--surface-hover, rgba(0, 0, 0, .04))}.tree-row.picked{background:var(--highlight-bg, rgba(51, 153, 255, .15))}.tree-row.marked{box-shadow:inset 3px 0 0 var(--primary-color)}.tree-row.absent{color:var(--text-color-secondary, #8a8a8a);font-style:italic;opacity:.7}.tree-toggle{flex:0 0 .9rem;font-size:.75rem;color:var(--text-color-secondary)}.tree-swatch{flex:0 0 auto;display:inline-flex}::ng-deep region-class-tree .tree-swatch .hex-picker-swatch{width:.8rem;height:.8rem;border-width:1px;border-radius:0}.tree-name{font-weight:700}.absent .tree-name{font-weight:400}.tree-long{min-width:0;overflow:hidden;text-overflow:ellipsis;flex:1 1 auto}.tree-count{flex:0 0 auto;font-size:.7rem;color:var(--text-color-secondary)}.tree-empty{padding:.5rem;font-size:.8rem;color:var(--text-color-secondary)}.tree-3d{flex:0 0 auto;font-size:.8rem;opacity:.35;cursor:pointer}.tree-3d:hover{opacity:.8}.tree-3d.on{opacity:1;color:var(--primary-color)}.tree-eye{flex:0 0 auto;font-size:.8rem;opacity:.4;cursor:pointer}.tree-eye:hover{opacity:.9}.tree-eye.partial{opacity:.7;color:var(--primary-color)}.tree-row.hidden-class .tree-eye{opacity:1}.tree-row.hidden-class .tree-swatch,.tree-row.hidden-class .tree-name,.tree-row.hidden-class .tree-long,.tree-row.hidden-class .tree-count{opacity:.45}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { 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: InputTextModule }, { kind: "directive", type: i3.InputText, selector: "[pInputText]", inputs: ["variant"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i4.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: ClassTreeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'region-class-tree', standalone: true, imports: [CommonModule, FormsModule, InputTextModule, TooltipModule, HexColorPickerComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"class-tree\">\n  <div class=\"tree-header\" *ngIf=\"picked as p\">\n    <span class=\"tree-picked\">\n      <b>{{ p }}</b\n      ><span *ngIf=\"node(p)?.title as t\"> \u00B7 {{ t }}</span>\n    </span>\n  </div>\n  <input\n    type=\"text\"\n    pInputText\n    class=\"p-inputtext-sm tree-search\"\n    placeholder=\"Search by name\"\n    aria-label=\"Search the classes\"\n    [ngModel]=\"query\"\n    (ngModelChange)=\"onQuery($event)\"\n    (keydown.enter)=\"pickFirstMatch($event)\"\n  />\n  <div class=\"tree-body\" role=\"tree\">\n    <div\n      *ngFor=\"let row of rows; trackBy: trackRow\"\n      class=\"tree-row\"\n      role=\"treeitem\"\n      tabindex=\"0\"\n      [attr.aria-expanded]=\"row.hasChildren ? row.expanded : null\"\n      [class.absent]=\"total(row.name) === 0\"\n      [class.picked]=\"row.name === picked\"\n      [class.marked]=\"marked.has(row.name)\"\n      [class.hidden-class]=\"visibility.get(row.name) === 'hidden'\"\n      [style.padding-left.rem]=\"0.35 + row.depth * 0.9\"\n      [pTooltip]=\"node(row.name)?.title || row.name\"\n      tooltipPosition=\"left\"\n      [showDelay]=\"600\"\n      (click)=\"choose(row.name, $event)\"\n      (keydown.enter)=\"choose(row.name, $event)\"\n    >\n      <i\n        class=\"pi tree-toggle\"\n        [class.pi-minus-circle]=\"row.hasChildren && row.expanded\"\n        [class.pi-plus-circle]=\"row.hasChildren && !row.expanded\"\n        [attr.aria-label]=\"row.expanded ? 'Collapse' : 'Expand'\"\n        (click)=\"row.hasChildren && toggle(row, $event)\"\n      ></i>\n      <i\n        class=\"pi tree-eye\"\n        [ngClass]=\"visibility.get(row.name) === 'hidden' ? 'pi-eye-slash' : 'pi-eye'\"\n        [class.partial]=\"visibility.get(row.name) === 'partial'\"\n        role=\"button\"\n        [attr.aria-pressed]=\"visibility.get(row.name) !== 'hidden'\"\n        [attr.aria-label]=\"(visibility.get(row.name) === 'hidden' ? 'Show ' : 'Hide ') + row.name\"\n        [pTooltip]=\"\n          (visibility.get(row.name) === 'hidden' ? 'Show' : 'Hide') +\n          (row.hasChildren ? ' it and its subclasses' : '') +\n          (visibility.get(row.name) === 'partial' ? ' (some are hidden)' : '')\n        \"\n        tooltipPosition=\"left\"\n        (click)=\"flipHidden(row.name, $event)\"\n        (keydown.enter)=\"flipHidden(row.name, $event)\"\n      ></i>\n      <span class=\"tree-swatch\" (click)=\"$event.stopPropagation()\" (keydown.enter)=\"$event.stopPropagation()\">\n        <hex-color-picker\n          [color]=\"colorOf(row.name)\"\n          (colorChange)=\"recolor.emit({ name: row.name, color: $event })\"\n        >\n        </hex-color-picker>\n      </span>\n      <span class=\"tree-name\">{{ row.name }}</span>\n      <span class=\"tree-long\">{{ node(row.name)?.title }}</span>\n      <span class=\"tree-count\" *ngIf=\"total(row.name) > 0\">{{ total(row.name) }}</span>\n      <i\n        *ngIf=\"volume\"\n        class=\"pi pi-box tree-3d\"\n        [class.on]=\"shown3d.has(row.name)\"\n        role=\"button\"\n        [attr.aria-pressed]=\"shown3d.has(row.name)\"\n        [attr.aria-label]=\"'Show ' + row.name + ' in 3D'\"\n        pTooltip=\"Show in the volume, in 3D\"\n        tooltipPosition=\"left\"\n        (click)=\"flip3d(row.name, $event)\"\n      ></i>\n    </div>\n    <div *ngIf=\"!rows.length\" class=\"tree-empty\">No class matches.</div>\n  </div>\n</div>\n", styles: [":host{display:block;flex:0 0 auto}.class-tree{display:flex;flex-direction:column;padding-top:.25rem}.tree-header{display:flex;align-items:baseline;gap:.5rem;padding:0 .5rem .25rem}.tree-picked{font-size:.8rem;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tree-search{margin:0 .5rem .25rem}.tree-body{height:14rem;min-height:3rem;max-height:70vh;overflow:auto;resize:vertical;padding-bottom:.25rem}.tree-row{display:flex;align-items:center;gap:.35rem;padding-top:.05rem;padding-bottom:.05rem;padding-right:.5rem;cursor:pointer;font-size:.8rem;white-space:nowrap}.tree-row:hover,.tree-row:focus-visible{background:var(--surface-hover, rgba(0, 0, 0, .04))}.tree-row.picked{background:var(--highlight-bg, rgba(51, 153, 255, .15))}.tree-row.marked{box-shadow:inset 3px 0 0 var(--primary-color)}.tree-row.absent{color:var(--text-color-secondary, #8a8a8a);font-style:italic;opacity:.7}.tree-toggle{flex:0 0 .9rem;font-size:.75rem;color:var(--text-color-secondary)}.tree-swatch{flex:0 0 auto;display:inline-flex}::ng-deep region-class-tree .tree-swatch .hex-picker-swatch{width:.8rem;height:.8rem;border-width:1px;border-radius:0}.tree-name{font-weight:700}.absent .tree-name{font-weight:400}.tree-long{min-width:0;overflow:hidden;text-overflow:ellipsis;flex:1 1 auto}.tree-count{flex:0 0 auto;font-size:.7rem;color:var(--text-color-secondary)}.tree-empty{padding:.5rem;font-size:.8rem;color:var(--text-color-secondary)}.tree-3d{flex:0 0 auto;font-size:.8rem;opacity:.35;cursor:pointer}.tree-3d:hover{opacity:.8}.tree-3d.on{opacity:1;color:var(--primary-color)}.tree-eye{flex:0 0 auto;font-size:.8rem;opacity:.4;cursor:pointer}.tree-eye:hover{opacity:.9}.tree-eye.partial{opacity:.7;color:var(--primary-color)}.tree-row.hidden-class .tree-eye{opacity:1}.tree-row.hidden-class .tree-swatch,.tree-row.hidden-class .tree-name,.tree-row.hidden-class .tree-long,.tree-row.hidden-class .tree-count{opacity:.45}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { nodes: [{
+                type: Input
+            }], counts: [{
+                type: Input
+            }], colorOf: [{
+                type: Input
+            }], picked: [{
+                type: Input
+            }], marked: [{
+                type: Input
+            }], volume: [{
+                type: Input
+            }], shown3d: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], pick: [{
+                type: Output
+            }], recolor: [{
+                type: Output
+            }], toggle3d: [{
+                type: Output
+            }], toggleHidden: [{
+                type: Output
+            }] } });
+/** Scroll the row matching `selector` inside `host` into view, if it is out of it. */
+export function scrollToPicked(host, selector) {
+    const row = host.querySelector(selector);
+    row?.scrollIntoView?.({ block: 'nearest' });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-tree.component.js","sourceRoot":"","sources":["../../../../../src/lib/region-editor/class-tree/class-tree.component.ts","../../../../../src/lib/region-editor/class-tree/class-tree.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { InputTextModule } from 'primeng/inputtext';\nimport { TooltipModule } from 'primeng/tooltip';\n\nimport type { RegionClassNode } from '../../region-source/region-tiles';\nimport { HexColorPickerComponent } from '../../hex-color-picker/hex-color-picker.component';\nimport { ClassTree, ClassTreeRow, ancestors, buildClassTree, subtree, visibleRows } from './class-tree';\n\n/** A pick in the tree: the class, and it with every class under it. */\nexport interface ClassTreePick {\n  name: string;\n  classes: string[];\n  additive: boolean;\n}\n\n/** Whether a class is shown: it and its subclasses all, none ('hidden'), or only some ('partial'). */\nexport type ClassVisibility = 'shown' | 'hidden' | 'partial';\n\n/**\n * The Region Editor's classes as a hierarchy (a brain atlas's ontology), as the Allen atlas viewer\n * shows it: collapsible, each class with its colour, name and long name, and the regions it and\n * its subclasses have on this slice; a class with none is greyed. Picking a class selects all its\n * regions and its subclasses' (the editor does the selecting). Search by name or long name. A\n * class's swatch recolours it, as the class list's does; its eye hides it and its subclasses.\n */\n@Component({\n  selector: 'region-class-tree',\n  standalone: true,\n  imports: [CommonModule, FormsModule, InputTextModule, TooltipModule, HexColorPickerComponent],\n  templateUrl: './class-tree.component.html',\n  styleUrls: ['./class-tree.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ClassTreeComponent implements OnChanges {\n  /** The hierarchy. */\n  @Input() nodes: readonly RegionClassNode[] = [];\n  /** Regions per class on this slice (the regions and the region source's). */\n  @Input() counts: ReadonlyMap<string, number> = new Map();\n  /** A class's colour (a new function when the colours change, so the rows repaint). */\n  @Input() colorOf: (name: string) => string = () => '#999999';\n  /** The class picked last (highlighted, its path expanded, scrolled into view). */\n  @Input() picked: string | null = null;\n  /** Classes with a selected region (marked). */\n  @Input() marked: ReadonlySet<string> = new Set();\n  /** Whether a volume view is on screen: each class can then be shown in 3D. */\n  @Input() volume = false;\n  /** The classes shown in 3D. */\n  @Input() shown3d: ReadonlySet<string> = new Set();\n  /** The classes hidden from view. */\n  @Input() hidden: ReadonlySet<string> = new Set();\n\n  @Output() pick = new EventEmitter<ClassTreePick>();\n  /** A class's swatch picked a new colour. */\n  @Output() recolor = new EventEmitter<{ name: string; color: string }>();\n  /** A class's 3D toggle: it with every class under it. */\n  @Output() toggle3d = new EventEmitter<{ name: string; classes: string[] }>();\n  /** A class's eye: hide (or show) it with every class under it. */\n  @Output() toggleHidden = new EventEmitter<{ classes: string[]; hidden: boolean }>();\n\n  protected tree: ClassTree = buildClassTree([], new Map());\n  protected rows: ClassTreeRow[] = [];\n  /** Each row's visibility (a row absent: shown). */\n  protected visibility = new Map<string, ClassVisibility>();\n  protected query = '';\n  private expanded = new Set<string>();\n\n  constructor(private readonly el: ElementRef<HTMLElement>) {}\n\n  ngOnChanges(changes: SimpleChanges): void {\n    const fresh = !!changes['nodes'];\n    if (fresh || changes['counts']) this.tree = buildClassTree(this.nodes, this.counts);\n    // A new hierarchy opens with its roots expanded, as the atlas viewer does.\n    if (fresh) this.expanded = new Set(this.tree.roots);\n    if (changes['picked'] && this.picked) for (const a of ancestors(this.tree, this.picked)) this.expanded.add(a);\n    this.refresh();\n    // A pick from elsewhere (a surface clicked in 3D) may be off screen: bring its row into view.\n    if (changes['picked'] && this.picked)\n      setTimeout(() => scrollToPicked(this.el.nativeElement, '.tree-row.picked'));\n  }\n\n  protected node(name: string): RegionClassNode | undefined {\n    return this.tree.node.get(name);\n  }\n\n  protected total(name: string): number {\n    return this.tree.total.get(name) ?? 0;\n  }\n\n  protected toggle(row: ClassTreeRow, event: Event): void {\n    event.stopPropagation();\n    if (this.expanded.has(row.name)) this.expanded.delete(row.name);\n    else this.expanded.add(row.name);\n    this.refresh();\n  }\n\n  protected choose(name: string, event: Event): void {\n    const e = event as MouseEvent | KeyboardEvent;\n    this.pick.emit({ name, classes: subtree(this.tree, name), additive: e.shiftKey || e.metaKey || e.ctrlKey });\n  }\n\n  /** The eye: a class hidden (wholly) is shown again with its subclasses; otherwise they are hidden. */\n  protected flipHidden(name: string, event: Event): void {\n    event.stopPropagation();\n    const hidden = this.visibility.get(name) !== 'hidden';\n    this.toggleHidden.emit({ classes: subtree(this.tree, name), hidden });\n  }\n\n  protected flip3d(name: string, event: Event): void {\n    event.stopPropagation();\n    this.toggle3d.emit({ name, classes: subtree(this.tree, name) });\n  }\n\n  protected onQuery(value: string): void {\n    this.query = value;\n    this.refresh();\n  }\n\n  /** Enter in the search box picks the first match. */\n  protected pickFirstMatch(event: Event): void {\n    const q = this.query.trim().toLowerCase();\n    const hit = this.rows.find(\n      (r) => r.name.toLowerCase().includes(q) || (this.node(r.name)?.title ?? '').toLowerCase().includes(q),\n    );\n    if (hit) this.choose(hit.name, event);\n  }\n\n  protected readonly trackRow = (_: number, r: ClassTreeRow) => r.name;\n\n  private refresh(): void {\n    this.rows = visibleRows(this.tree, this.expanded, this.query);\n    this.visibility = new Map();\n    if (!this.hidden.size) return;\n    for (const row of this.rows) {\n      const classes = subtree(this.tree, row.name);\n      const off = classes.filter((c) => this.hidden.has(c)).length;\n      if (off) this.visibility.set(row.name, off === classes.length ? 'hidden' : 'partial');\n    }\n  }\n}\n\n/** Scroll the row matching `selector` inside `host` into view, if it is out of it. */\nexport function scrollToPicked(host: HTMLElement, selector: string): void {\n  const row = host.querySelector(selector) as HTMLElement | null;\n  row?.scrollIntoView?.({ block: 'nearest' });\n}\n","<div class=\"class-tree\">\n  <div class=\"tree-header\" *ngIf=\"picked as p\">\n    <span class=\"tree-picked\">\n      <b>{{ p }}</b\n      ><span *ngIf=\"node(p)?.title as t\"> · {{ t }}</span>\n    </span>\n  </div>\n  <input\n    type=\"text\"\n    pInputText\n    class=\"p-inputtext-sm tree-search\"\n    placeholder=\"Search by name\"\n    aria-label=\"Search the classes\"\n    [ngModel]=\"query\"\n    (ngModelChange)=\"onQuery($event)\"\n    (keydown.enter)=\"pickFirstMatch($event)\"\n  />\n  <div class=\"tree-body\" role=\"tree\">\n    <div\n      *ngFor=\"let row of rows; trackBy: trackRow\"\n      class=\"tree-row\"\n      role=\"treeitem\"\n      tabindex=\"0\"\n      [attr.aria-expanded]=\"row.hasChildren ? row.expanded : null\"\n      [class.absent]=\"total(row.name) === 0\"\n      [class.picked]=\"row.name === picked\"\n      [class.marked]=\"marked.has(row.name)\"\n      [class.hidden-class]=\"visibility.get(row.name) === 'hidden'\"\n      [style.padding-left.rem]=\"0.35 + row.depth * 0.9\"\n      [pTooltip]=\"node(row.name)?.title || row.name\"\n      tooltipPosition=\"left\"\n      [showDelay]=\"600\"\n      (click)=\"choose(row.name, $event)\"\n      (keydown.enter)=\"choose(row.name, $event)\"\n    >\n      <i\n        class=\"pi tree-toggle\"\n        [class.pi-minus-circle]=\"row.hasChildren && row.expanded\"\n        [class.pi-plus-circle]=\"row.hasChildren && !row.expanded\"\n        [attr.aria-label]=\"row.expanded ? 'Collapse' : 'Expand'\"\n        (click)=\"row.hasChildren && toggle(row, $event)\"\n      ></i>\n      <i\n        class=\"pi tree-eye\"\n        [ngClass]=\"visibility.get(row.name) === 'hidden' ? 'pi-eye-slash' : 'pi-eye'\"\n        [class.partial]=\"visibility.get(row.name) === 'partial'\"\n        role=\"button\"\n        [attr.aria-pressed]=\"visibility.get(row.name) !== 'hidden'\"\n        [attr.aria-label]=\"(visibility.get(row.name) === 'hidden' ? 'Show ' : 'Hide ') + row.name\"\n        [pTooltip]=\"\n          (visibility.get(row.name) === 'hidden' ? 'Show' : 'Hide') +\n          (row.hasChildren ? ' it and its subclasses' : '') +\n          (visibility.get(row.name) === 'partial' ? ' (some are hidden)' : '')\n        \"\n        tooltipPosition=\"left\"\n        (click)=\"flipHidden(row.name, $event)\"\n        (keydown.enter)=\"flipHidden(row.name, $event)\"\n      ></i>\n      <span class=\"tree-swatch\" (click)=\"$event.stopPropagation()\" (keydown.enter)=\"$event.stopPropagation()\">\n        <hex-color-picker\n          [color]=\"colorOf(row.name)\"\n          (colorChange)=\"recolor.emit({ name: row.name, color: $event })\"\n        >\n        </hex-color-picker>\n      </span>\n      <span class=\"tree-name\">{{ row.name }}</span>\n      <span class=\"tree-long\">{{ node(row.name)?.title }}</span>\n      <span class=\"tree-count\" *ngIf=\"total(row.name) > 0\">{{ total(row.name) }}</span>\n      <i\n        *ngIf=\"volume\"\n        class=\"pi pi-box tree-3d\"\n        [class.on]=\"shown3d.has(row.name)\"\n        role=\"button\"\n        [attr.aria-pressed]=\"shown3d.has(row.name)\"\n        [attr.aria-label]=\"'Show ' + row.name + ' in 3D'\"\n        pTooltip=\"Show in the volume, in 3D\"\n        tooltipPosition=\"left\"\n        (click)=\"flip3d(row.name, $event)\"\n      ></i>\n    </div>\n    <div *ngIf=\"!rows.length\" class=\"tree-empty\">No class matches.</div>\n  </div>\n</div>\n"]}

package/esm2022/lib/region-editor/class-tree/class-tree.mjs

@@ -0,0 +1,108 @@
+/**
+ * Build the tree of `nodes`, counting `counts` (regions per class) up through it. A node whose
+ * parent is not in the hierarchy is a root; siblings sort by `order`, then as listed.
+ */
+export function buildClassTree(nodes, counts) {
+    const node = new Map();
+    for (const n of nodes)
+        if (!node.has(n.name))
+            node.set(n.name, n);
+    const children = new Map();
+    const parent = new Map();
+    const roots = [];
+    const position = new Map(nodes.map((n, i) => [n.name, i]));
+    for (const n of node.values()) {
+        const p = n.parent && node.has(n.parent) && n.parent !== n.name ? n.parent : null;
+        parent.set(n.name, p);
+        if (p) {
+            const list = children.get(p);
+            if (list)
+                list.push(n.name);
+            else
+                children.set(p, [n.name]);
+        }
+        else
+            roots.push(n.name);
+    }
+    const byOrder = (a, b) => (node.get(a)?.order ?? Infinity) - (node.get(b)?.order ?? Infinity) ||
+        (position.get(a) ?? 0) - (position.get(b) ?? 0);
+    roots.sort(byOrder);
+    for (const list of children.values())
+        list.sort(byOrder);
+    const total = new Map();
+    const visit = (name, seen) => {
+        const known = total.get(name);
+        if (known !== undefined)
+            return known;
+        if (seen.has(name))
+            return 0; // a cycle in a malformed file
+        seen.add(name);
+        let sum = counts.get(name) ?? 0;
+        for (const c of children.get(name) ?? [])
+            sum += visit(c, seen);
+        total.set(name, sum);
+        return sum;
+    };
+    for (const name of node.keys())
+        visit(name, new Set());
+    return { roots, node, children, parent, total };
+}
+/** `name` and every class under it. */
+export function subtree(tree, name) {
+    const out = [];
+    const stack = [name];
+    const seen = new Set();
+    while (stack.length) {
+        const n = stack.pop();
+        if (seen.has(n))
+            continue;
+        seen.add(n);
+        out.push(n);
+        for (const c of tree.children.get(n) ?? [])
+            stack.push(c);
+    }
+    return out;
+}
+/** The classes from the root down to `name`'s parent. */
+export function ancestors(tree, name) {
+    const out = [];
+    let p = tree.parent.get(name) ?? null;
+    while (p && !out.includes(p)) {
+        out.unshift(p);
+        p = tree.parent.get(p) ?? null;
+    }
+    return out;
+}
+/**
+ * The rows to draw: depth-first through the expanded nodes. With a `query`, only the nodes whose
+ * name or title contains it and their ancestors, all expanded.
+ */
+export function visibleRows(tree, expanded, query = '') {
+    const q = query.trim().toLowerCase();
+    let keep = null;
+    if (q) {
+        keep = new Set();
+        for (const [name, n] of tree.node) {
+            if (name.toLowerCase().includes(q) || (n.title ?? '').toLowerCase().includes(q)) {
+                keep.add(name);
+                for (const a of ancestors(tree, name))
+                    keep.add(a);
+            }
+        }
+    }
+    const rows = [];
+    const walk = (name, depth) => {
+        if (keep && !keep.has(name))
+            return;
+        const kids = tree.children.get(name) ?? [];
+        const open = keep ? true : expanded.has(name);
+        rows.push({ name, depth, hasChildren: kids.length > 0, expanded: open && kids.length > 0 });
+        if (open)
+            for (const c of kids)
+                walk(c, depth + 1);
+    };
+    for (const r of tree.roots)
+        walk(r, 0);
+    return rows;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-tree.js","sourceRoot":"","sources":["../../../../../src/lib/region-editor/class-tree/class-tree.ts"],"names":[],"mappings":"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","sourcesContent":["import type { RegionClassNode } from '../../region-source/region-tiles';\n\n/** A class hierarchy as a tree: children in order, subtree counts, depths. Pure. */\nexport interface ClassTree {\n  roots: string[];\n  node: Map<string, RegionClassNode>;\n  children: Map<string, string[]>;\n  parent: Map<string, string | null>;\n  /** Regions of the class and every class under it. */\n  total: Map<string, number>;\n}\n\n/**\n * Build the tree of `nodes`, counting `counts` (regions per class) up through it. A node whose\n * parent is not in the hierarchy is a root; siblings sort by `order`, then as listed.\n */\nexport function buildClassTree(nodes: readonly RegionClassNode[], counts: ReadonlyMap<string, number>): ClassTree {\n  const node = new Map<string, RegionClassNode>();\n  for (const n of nodes) if (!node.has(n.name)) node.set(n.name, n);\n  const children = new Map<string, string[]>();\n  const parent = new Map<string, string | null>();\n  const roots: string[] = [];\n  const position = new Map(nodes.map((n, i) => [n.name, i]));\n  for (const n of node.values()) {\n    const p = n.parent && node.has(n.parent) && n.parent !== n.name ? n.parent : null;\n    parent.set(n.name, p);\n    if (p) {\n      const list = children.get(p);\n      if (list) list.push(n.name);\n      else children.set(p, [n.name]);\n    } else roots.push(n.name);\n  }\n  const byOrder = (a: string, b: string) =>\n    (node.get(a)?.order ?? Infinity) - (node.get(b)?.order ?? Infinity) ||\n    (position.get(a) ?? 0) - (position.get(b) ?? 0);\n  roots.sort(byOrder);\n  for (const list of children.values()) list.sort(byOrder);\n\n  const total = new Map<string, number>();\n  const visit = (name: string, seen: Set<string>): number => {\n    const known = total.get(name);\n    if (known !== undefined) return known;\n    if (seen.has(name)) return 0; // a cycle in a malformed file\n    seen.add(name);\n    let sum = counts.get(name) ?? 0;\n    for (const c of children.get(name) ?? []) sum += visit(c, seen);\n    total.set(name, sum);\n    return sum;\n  };\n  for (const name of node.keys()) visit(name, new Set());\n  return { roots, node, children, parent, total };\n}\n\n/** `name` and every class under it. */\nexport function subtree(tree: ClassTree, name: string): string[] {\n  const out: string[] = [];\n  const stack = [name];\n  const seen = new Set<string>();\n  while (stack.length) {\n    const n = stack.pop() as string;\n    if (seen.has(n)) continue;\n    seen.add(n);\n    out.push(n);\n    for (const c of tree.children.get(n) ?? []) stack.push(c);\n  }\n  return out;\n}\n\n/** The classes from the root down to `name`'s parent. */\nexport function ancestors(tree: ClassTree, name: string): string[] {\n  const out: string[] = [];\n  let p = tree.parent.get(name) ?? null;\n  while (p && !out.includes(p)) {\n    out.unshift(p);\n    p = tree.parent.get(p) ?? null;\n  }\n  return out;\n}\n\n/** One visible row of the tree. */\nexport interface ClassTreeRow {\n  name: string;\n  depth: number;\n  hasChildren: boolean;\n  expanded: boolean;\n}\n\n/**\n * The rows to draw: depth-first through the expanded nodes. With a `query`, only the nodes whose\n * name or title contains it and their ancestors, all expanded.\n */\nexport function visibleRows(tree: ClassTree, expanded: ReadonlySet<string>, query = ''): ClassTreeRow[] {\n  const q = query.trim().toLowerCase();\n  let keep: Set<string> | null = null;\n  if (q) {\n    keep = new Set();\n    for (const [name, n] of tree.node) {\n      if (name.toLowerCase().includes(q) || (n.title ?? '').toLowerCase().includes(q)) {\n        keep.add(name);\n        for (const a of ancestors(tree, name)) keep.add(a);\n      }\n    }\n  }\n  const rows: ClassTreeRow[] = [];\n  const walk = (name: string, depth: number) => {\n    if (keep && !keep.has(name)) return;\n    const kids = tree.children.get(name) ?? [];\n    const open = keep ? true : expanded.has(name);\n    rows.push({ name, depth, hasChildren: kids.length > 0, expanded: open && kids.length > 0 });\n    if (open) for (const c of kids) walk(c, depth + 1);\n  };\n  for (const r of tree.roots) walk(r, 0);\n  return rows;\n}\n"]}