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

package/lib/workers/spatial-math-ops.d.ts

@@ -0,0 +1,65 @@
+import type { SpatialObservations } from '../contracts/spatial-dataset.contract';
+import { DensityGrid, DensityOptions } from '../spatial/spatial-density';
+import { ExpressionField, ExpressionFieldOptions, ExpressionVolumeField, ExpressionVolumeOptions } from '../spatial/spatial-expression';
+import { HeatmapGene, HeatmapGroups, HeatmapMatrix, HeatmapMatrixOptions } from '../spatial/spatial-heatmap';
+/**
+ * The pure spatial field and density math, as messages: what crosses into
+ * `spatial-math.worker` and what comes back, and the one dispatcher both the worker and
+ * the main-thread fallback run. DOM-free and Angular-free, because the worker bundles it.
+ */
+/**
+ * Just the coordinates of {@link SpatialObservations}: all the math reads. Cloning the
+ * full observations would also copy `ids` — millions of strings on a large dataset.
+ */
+export type SpatialMathObservations = Pick<SpatialObservations, 'count' | 'x' | 'y' | 'z'>;
+/** One computation, by name, with the arguments of the synchronous function it runs. */
+export type SpatialMathRequest = {
+    op: 'expressionField';
+    obs: SpatialMathObservations;
+    opts: ExpressionFieldOptions;
+} | {
+    op: 'expressionVolume';
+    obs: SpatialMathObservations;
+    grid: DensityGrid;
+    opts: ExpressionVolumeOptions;
+} | {
+    op: 'rasterizeDensity';
+    obs: SpatialMathObservations;
+    grid: DensityGrid;
+    opts: DensityOptions;
+} | {
+    op: 'heatmapMatrix';
+    genes: readonly HeatmapGene[];
+    groups: HeatmapGroups;
+    opts: HeatmapMatrixOptions;
+};
+/** What each {@link SpatialMathRequest} op resolves to. */
+export interface SpatialMathResults {
+    expressionField: ExpressionField | null;
+    expressionVolume: ExpressionVolumeField | null;
+    rasterizeDensity: Uint8Array | null;
+    heatmapMatrix: HeatmapMatrix | null;
+}
+/** A request on the wire: the computation plus the id its answer is matched by. */
+export type SpatialMathMessage = SpatialMathRequest & {
+    id: number;
+};
+/** The worker's answer to one {@link SpatialMathMessage}. */
+export type SpatialMathReply = {
+    id: number;
+    ok: true;
+    result: SpatialMathResults[keyof SpatialMathResults];
+} | {
+    id: number;
+    ok: false;
+    error: string;
+};
+/** The coordinates of `obs`, without the per-observation strings the math never reads. */
+export declare function slimObservations(obs: SpatialMathObservations): SpatialMathObservations;
+/** Run one request synchronously — in the worker, or on the main thread as the fallback. */
+export declare function runSpatialMath<R extends SpatialMathRequest>(request: R): SpatialMathResults[R['op']];
+/**
+ * The buffers of a result, to transfer rather than copy back: the worker made them and
+ * never reads them again. Deduplicated, since a transfer list may not name one twice.
+ */
+export declare function resultTransferables(result: unknown): ArrayBuffer[];

package/lib/workers/spatial-math-worker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Factory for the spatial-math Web Worker, isolated in its own module so the
+ * `import.meta.url` reference — which the bundler needs in order to locate the worker —
+ * is never pulled into the ts-jest CommonJS compile of anything that uses it. Same
+ * arrangement as `spatial/tsne-worker.ts` and `region-editor/mask-worker.ts`.
+ */
+export declare function createSpatialMathWorker(): Worker;

package/lib/workers/spatial-math.d.ts

@@ -0,0 +1,74 @@
+import type { SpatialObservations } from '../contracts/spatial-dataset.contract';
+import type { DensityGrid, DensityOptions } from '../spatial/spatial-density';
+import type { ExpressionField, ExpressionFieldOptions, ExpressionVolumeField, ExpressionVolumeOptions } from '../spatial/spatial-expression';
+import type { HeatmapGene, HeatmapGroups, HeatmapMatrix, HeatmapMatrixOptions } from '../spatial/spatial-heatmap';
+import { SpatialMathRequest, SpatialMathResults } from './spatial-math-ops';
+/**
+ * Async, off-main-thread versions of the pure spatial field and density math
+ * (`expressionField`, `expressionVolume`, `rasterizeDensity`, `heatmapMatrix`).
+ *
+ * Each call runs in `spatial-math.worker` when it is big enough to be worth posting, and
+ * on the main thread otherwise — below {@link SPATIAL_MATH_WORKER_MIN_OBSERVATIONS}, where
+ * Web Workers do not exist (jsdom, SSR), or when the worker fails to start. Same
+ * function, same answer either way; only where it runs changes.
+ *
+ * Inputs are copied to the worker, never transferred: they are the dataset's own arrays,
+ * which the caller keeps using. Results are transferred back.
+ *
+ * An `AbortSignal` (a `Supersede` task's, typically) rejects the call with an
+ * `AbortError` as soon as it fires. When that leaves the worker with nothing else to do,
+ * the worker is terminated so the abandoned computation stops using the CPU; the next
+ * call starts a fresh one.
+ */
+/**
+ * Below this many observations (genes × observations for a heatmap) a call runs on the
+ * main thread: copying the inputs to a worker would cost about what it saves.
+ */
+export declare const SPATIAL_MATH_WORKER_MIN_OBSERVATIONS = 50000;
+/** Per-call options of the async spatial math. */
+export interface SpatialMathCallOptions {
+    /** Abandon the call: it rejects with an `AbortError` and its result is dropped. */
+    signal?: AbortSignal;
+    /** Override {@link SPATIAL_MATH_WORKER_MIN_OBSERVATIONS} for this call (0 forces the worker). */
+    minObservations?: number;
+}
+/** Makes the worker; may be async, as the default one is (it imports the factory on demand). */
+export type SpatialMathWorkerFactory = () => Worker | Promise<Worker>;
+/**
+ * Owns one spatial-math worker and the calls in flight on it. The module-level functions
+ * share one instance; a test, or a caller that wants its own worker, makes another.
+ */
+export declare class SpatialMathClient {
+    private readonly factory?;
+    private worker;
+    private starting;
+    /** Set once the worker failed to start or crashed: every later call runs here. */
+    private unavailable;
+    private nextId;
+    private readonly pending;
+    /**
+     * `factory` is optional: without one the real worker module is imported on demand —
+     * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile
+     * rejects, so a static import would break every spec that reaches this file.
+     */
+    constructor(factory?: SpatialMathWorkerFactory | undefined);
+    /** Run `request`, in the worker when `size` reaches the threshold and a worker can run. */
+    run<R extends SpatialMathRequest>(request: R, size: number, options?: SpatialMathCallOptions): Promise<SpatialMathResults[R['op']]>;
+    /** Terminate the worker; calls still in flight reject with an `AbortError`. */
+    dispose(): void;
+    private post;
+    private ensureWorker;
+    private startWorker;
+    private onReply;
+    /** The worker died (failed to load, or threw outside a request): answer every call here. */
+    private onCrash;
+    private stopWorker;
+}
+/** {@link expressionField}, off the main thread when it is big enough to matter. */
+export declare function computeExpressionFieldAsync(obs: SpatialObservations, opts: ExpressionFieldOptions, options?: SpatialMathCallOptions): Promise<ExpressionField | null>;
+/** {@link expressionVolume}, off the main thread when it is big enough to matter. */
+export declare function computeExpressionVolumeAsync(obs: SpatialObservations, grid: DensityGrid, opts: ExpressionVolumeOptions, options?: SpatialMathCallOptions): Promise<ExpressionVolumeField | null>;
+/** {@link rasterizeDensity}, off the main thread when it is big enough to matter. */
+export declare function rasterizeDensityAsync(obs: SpatialObservations, grid: DensityGrid, opts: DensityOptions, options?: SpatialMathCallOptions): Promise<Uint8Array | null>;
+/** {@link heatmapMatrix}, off the main thread when it is big enough to matter. */
+export declare function computeHeatmapMatrixAsync(genes: readonly HeatmapGene[], groups: HeatmapGroups, opts?: HeatmapMatrixOptions, options?: SpatialMathCallOptions): Promise<HeatmapMatrix | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jax-data-science/sci-image-visualizer",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -37,10 +37,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@jax-js/jax": "^0.1.24",
     "cellpose-js": "^0.6.0",
     "fast-png": "^6.4.0",
-    "napari-js": "^0.14.0",
+    "napari-js": "^0.15.0",
     "openseadragon": "^6.0.2",
     "plotly.js-dist-min": "^3.0.1",
     "tslib": "^2.3.0"
@@ -55,9 +54,19 @@
     "file-saver": "^2.0.5",
     "image-js": "^0.35.6",
     "onnxruntime-web": "~1.26.0",
+    "primeflex": "^3.3.0 || ^4.0.0",
+    "primeicons": "^7.0.0",
     "primeng": "^17.18.0",
     "rxjs": "^7.8.0"
   },
+  "peerDependenciesMeta": {
+    "primeflex": {
+      "optional": true
+    },
+    "primeicons": {
+      "optional": true
+    }
+  },
   "overrides": {
     "@ngtools/webpack": "17.3.17"
   },

package/src/lib/styles/_viz-icons-rules.scss

@@ -0,0 +1,73 @@
+@use 'sass:list';
+
+// The visualizer's toolbar / context-menu icon classes, as a mixin so the same rules can
+// be emitted from two places with the right asset path for each:
+//  - `viz-icons.scss`, the stylesheet the package ships for hosts (global styles);
+//  - the visualizer component, inside `::ng-deep`, so nothing changes for a host that
+//    does not include the shipped stylesheet.
+// They must be global either way: the context menu and the toolbar overlays are appended
+// to <body>, outside the component's view.
+
+$icons: (
+  'zoom-box-off-icon': 'zoom-box',
+  'wand-icon': 'wand',
+  'brush-icon': 'paintbrush',
+  'polyline-icon': 'polyline',
+  'polygon-vertices-icon': 'polygon-vertices',
+  'vertex-add-icon': 'vertex-add',
+  'vertex-delete-icon': 'vertex-delete',
+  'region-move-icon': 'region-move',
+  'to-bezier-icon': 'to-bezier',
+  'to-polygon-icon': 'to-polygon',
+);
+
+// Icons inverted to white on the highlighted (active) context-menu entry.
+$context-menu-icons: (
+  'zoom-box-off-icon',
+  'wand-icon',
+  'polyline-icon',
+  'polygon-vertices-icon',
+  'vertex-add-icon',
+  'vertex-delete-icon',
+  'region-move-icon',
+  'to-bezier-icon',
+  'to-polygon-icon'
+);
+
+/// Emit the icon and active-context-menu rules. `$assets` is the path, relative to the
+/// stylesheet being compiled, of the package's `src/lib/assets` folder.
+@mixin rules($assets) {
+  .context-menu-active > .p-menuitem-content {
+    background-color: var(--primary-color) !important;
+  }
+
+  .context-menu-active > .p-menuitem-content .p-menuitem-icon,
+  .context-menu-active > .p-menuitem-content .p-menuitem-text {
+    color: #ffffff !important;
+  }
+
+  $active: ();
+  @each $class in $context-menu-icons {
+    $active: list.append($active, '.context-menu-active > .p-menuitem-content .#{$class}', $separator: comma);
+  }
+  #{$active} {
+    filter: brightness(0) invert(1);
+  }
+
+  @each $class, $file in $icons {
+    .#{$class} {
+      background: url('#{$assets}/#{$file}.svg') no-repeat center center;
+      background-size: contain;
+      width: 1.25rem;
+      height: 1.25rem;
+      display: inline-block;
+      filter: brightness(0)
+        invert(47%)
+        sepia(98%)
+        saturate(567%)
+        hue-rotate(181deg)
+        brightness(103%)
+        contrast(98%);
+    }
+  }
+}

package/src/lib/styles/viz-icons.scss

@@ -0,0 +1,14 @@
+// Global icon rules of the visualizer's toolbar and context menu, shipped for hosts.
+//
+// The visualizer component also emits these when it loads, so including this file is
+// optional. Include it to have the classes defined before any visualizer has loaded (a
+// host toolbar or menu that reuses them), and independent of stylesheet load order. In
+// angular.json:
+//
+//   "styles": ["node_modules/@jax-data-science/sci-image-visualizer/src/lib/styles/viz-icons.scss"]
+//
+// The icon URLs are relative to this file (`../assets/*.svg`, the package's assets folder),
+// which the Angular CLI resolves and bundles.
+@use 'viz-icons-rules';
+
+@include viz-icons-rules.rules('../assets');

package/esm2022/lib/implementations/napari-js/napari-axes-labels.mjs

@@ -1,97 +0,0 @@
-/**
- * DOM text labels for the napari-js 3D axes gizmo (jit-ui#102). The {@link AxesLayer} draws the
- * axis lines/ticks/box in WebGPU; this overlay adds the crisp X/Y/Z + scale text on top, projected
- * with the 3D camera's view-projection so each label tracks its anchor as the volume orbits.
- * Mirrors the {@link NapariScaleBar} overlay pattern (absolute-positioned over the host, updated on
- * every `camera3d.changed`). Falls back to pixel/slice counts when no physical µm/pixel is known.
- */
-/**
- * Re-exported from napari-js, which owns the projection now.
- *
- * This used to be a local copy: the same column-major multiply, perspective divide and y-flip
- * that {@link NapariVisualizerService.getSpatialScreenProjection} ALSO carried, written twice
- * with two different behind-the-eye conventions. The renderer owns the camera and the clip
- * convention, so it owns the projection; kept as a named export here only so the overlays that
- * import it from this module do not all have to change.
- */
-import { projectPoint } from 'napari-js';
-export { projectPoint };
-export class NapariAxesLabels {
-    constructor(host, camera3d, labels) {
-        this.host = host;
-        this.camera3d = camera3d;
-        this.labels = labels;
-        this.els = [];
-        this.visible = true;
-        if (getComputedStyle(host).position === 'static')
-            host.style.position = 'relative';
-        for (const spec of labels) {
-            const el = document.createElement('span');
-            Object.assign(el.style, {
-                position: 'absolute',
-                zIndex: '30',
-                pointerEvents: 'none',
-                font: '11px sans-serif',
-                fontWeight: '600',
-                color: spec.color,
-                textShadow: '0 0 3px #000, 0 0 3px #000',
-                whiteSpace: 'nowrap',
-                transform: 'translate(-50%, -50%)',
-                userSelect: 'none',
-            });
-            el.textContent = spec.text;
-            this.host.appendChild(el);
-            this.els.push(el);
-        }
-        this.disconnectCamera = this.camera3d.changed.connect(() => this.update());
-        if (typeof ResizeObserver !== 'undefined') {
-            this.resizeObserver = new ResizeObserver(() => this.update());
-            this.resizeObserver.observe(this.host);
-        }
-        this.update();
-    }
-    setVisible(visible) {
-        this.visible = visible;
-        this.update();
-    }
-    /** Replace the label anchors/text in place (same count) and reproject — lets a host move the
-     *  labels when the box geometry changes live (e.g. a Z-height gizmo restretching the volume)
-     *  without tearing down and recreating the DOM elements (which would flicker). */
-    updateAnchors(labels) {
-        for (let i = 0; i < this.labels.length && i < labels.length; i++) {
-            this.labels[i] = labels[i];
-            if (labels[i].text !== this.els[i].textContent)
-                this.els[i].textContent = labels[i].text;
-        }
-        this.update();
-    }
-    update() {
-        const vw = this.host.clientWidth;
-        const vh = this.host.clientHeight;
-        if (!this.visible || vw <= 0 || vh <= 0) {
-            for (const el of this.els)
-                el.style.display = 'none';
-            return;
-        }
-        const mvp = this.camera3d.viewProjection(vw, vh);
-        this.labels.forEach((spec, i) => {
-            const el = this.els[i];
-            const s = projectPoint(mvp, spec.anchor, vw, vh);
-            if (!s.visible) {
-                el.style.display = 'none';
-                return;
-            }
-            el.style.display = '';
-            el.style.left = `${s.x}px`;
-            el.style.top = `${s.y}px`;
-        });
-    }
-    destroy() {
-        this.disconnectCamera();
-        this.resizeObserver?.disconnect();
-        for (const el of this.els)
-            el.parentNode?.removeChild(el);
-        this.els.length = 0;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-axes-labels.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-axes-labels.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgBH;;;;;;;;GAQG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB,MAAM,OAAO,gBAAgB;IAM3B,YACmB,IAAiB,EACjB,QAA2B,EAC3B,MAAuB;QAFvB,SAAI,GAAJ,IAAI,CAAa;QACjB,aAAQ,GAAR,QAAQ,CAAmB;QAC3B,WAAM,GAAN,MAAM,CAAiB;QARzB,QAAG,GAAsB,EAAE,CAAC;QAGrC,YAAO,GAAG,IAAI,CAAC;QAOrB,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ;YAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC;QACnF,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;YAC1B,MAAM,EAAE,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC1C,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE;gBACtB,QAAQ,EAAE,UAAU;gBACpB,MAAM,EAAE,IAAI;gBACZ,aAAa,EAAE,MAAM;gBACrB,IAAI,EAAE,iBAAiB;gBACvB,UAAU,EAAE,KAAK;gBACjB,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,UAAU,EAAE,4BAA4B;gBACxC,UAAU,EAAE,QAAQ;gBACpB,SAAS,EAAE,uBAAuB;gBAClC,UAAU,EAAE,MAAM;aACa,CAAC,CAAC;YACnC,EAAE,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;YAC1B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACpB,CAAC;QACD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAC3E,IAAI,OAAO,cAAc,KAAK,WAAW,EAAE,CAAC;YAC1C,IAAI,CAAC,cAAc,GAAG,IAAI,cAAc,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC9D,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED,UAAU,CAAC,OAAgB;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED;;sFAEkF;IAClF,aAAa,CAAC,MAAuB;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACjE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YAC3B,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW;gBAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3F,CAAC;QACD,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAEO,MAAM;QACZ,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;QACjC,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YACxC,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,GAAG;gBAAE,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YACrD,OAAO;QACT,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;YAC9B,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACvB,MAAM,CAAC,GAAG,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;YACjD,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;gBACf,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;gBAC1B,OAAO;YACT,CAAC;YACD,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;YACtB,EAAE,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;YAC3B,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO;QACL,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,cAAc,EAAE,UAAU,EAAE,CAAC;QAClC,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,GAAG;YAAE,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;QAC1D,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;IACtB,CAAC;CACF","sourcesContent":["/**\n * DOM text labels for the napari-js 3D axes gizmo (jit-ui#102). The {@link AxesLayer} draws the\n * axis lines/ticks/box in WebGPU; this overlay adds the crisp X/Y/Z + scale text on top, projected\n * with the 3D camera's view-projection so each label tracks its anchor as the volume orbits.\n * Mirrors the {@link NapariScaleBar} overlay pattern (absolute-positioned over the host, updated on\n * every `camera3d.changed`). Falls back to pixel/slice counts when no physical µm/pixel is known.\n */\n\n/** One axis label: a world-space anchor (the axis end, in the volume's centred box), the text to\n *  show, and its colour (matching the WebGPU axis colour). */\nexport interface AxisLabelSpec {\n  anchor: [number, number, number];\n  text: string;\n  color: string;\n}\n\n/** The slice of napari's Camera3D this overlay reads. `viewProjection` is column-major (gl-matrix). */\nexport interface AxesLabelCamera3D {\n  viewProjection(vw: number, vh: number): ArrayLike<number>;\n  readonly changed: { connect(listener: () => void): () => void };\n}\n\n/**\n * Re-exported from napari-js, which owns the projection now.\n *\n * This used to be a local copy: the same column-major multiply, perspective divide and y-flip\n * that {@link NapariVisualizerService.getSpatialScreenProjection} ALSO carried, written twice\n * with two different behind-the-eye conventions. The renderer owns the camera and the clip\n * convention, so it owns the projection; kept as a named export here only so the overlays that\n * import it from this module do not all have to change.\n */\nimport { projectPoint } from 'napari-js';\n\nexport { projectPoint };\n\nexport class NapariAxesLabels {\n  private readonly els: HTMLSpanElement[] = [];\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  private visible = true;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera3d: AxesLabelCamera3D,\n    private readonly labels: AxisLabelSpec[],\n  ) {\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n    for (const spec of labels) {\n      const el = document.createElement('span');\n      Object.assign(el.style, {\n        position: 'absolute',\n        zIndex: '30',\n        pointerEvents: 'none',\n        font: '11px sans-serif',\n        fontWeight: '600',\n        color: spec.color,\n        textShadow: '0 0 3px #000, 0 0 3px #000',\n        whiteSpace: 'nowrap',\n        transform: 'translate(-50%, -50%)',\n        userSelect: 'none',\n      } as Partial<CSSStyleDeclaration>);\n      el.textContent = spec.text;\n      this.host.appendChild(el);\n      this.els.push(el);\n    }\n    this.disconnectCamera = this.camera3d.changed.connect(() => this.update());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.update());\n      this.resizeObserver.observe(this.host);\n    }\n    this.update();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.update();\n  }\n\n  /** Replace the label anchors/text in place (same count) and reproject — lets a host move the\n   *  labels when the box geometry changes live (e.g. a Z-height gizmo restretching the volume)\n   *  without tearing down and recreating the DOM elements (which would flicker). */\n  updateAnchors(labels: AxisLabelSpec[]): void {\n    for (let i = 0; i < this.labels.length && i < labels.length; i++) {\n      this.labels[i] = labels[i];\n      if (labels[i].text !== this.els[i].textContent) this.els[i].textContent = labels[i].text;\n    }\n    this.update();\n  }\n\n  private update(): void {\n    const vw = this.host.clientWidth;\n    const vh = this.host.clientHeight;\n    if (!this.visible || vw <= 0 || vh <= 0) {\n      for (const el of this.els) el.style.display = 'none';\n      return;\n    }\n    const mvp = this.camera3d.viewProjection(vw, vh);\n    this.labels.forEach((spec, i) => {\n      const el = this.els[i];\n      const s = projectPoint(mvp, spec.anchor, vw, vh);\n      if (!s.visible) {\n        el.style.display = 'none';\n        return;\n      }\n      el.style.display = '';\n      el.style.left = `${s.x}px`;\n      el.style.top = `${s.y}px`;\n    });\n  }\n\n  destroy(): void {\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    for (const el of this.els) el.parentNode?.removeChild(el);\n    this.els.length = 0;\n  }\n}\n"]}

package/esm2022/lib/implementations/napari-js/napari-navigator.mjs

@@ -1,195 +0,0 @@
-/**
- * Overview navigator (minimap) for the napari-js 2D views, mirroring the OSD backend's
- * built-in navigator: a thumbnail of the whole image in the bottom-right corner with the
- * current viewport drawn on it. Clicking re-centres the main view on that point at the
- * same zoom; dragging pans continuously — exactly OSD's behaviour.
- *
- * napari keeps layers at full-resolution pixel scale, so the camera's world units ARE
- * image pixels and the thumbnail maps onto `[0, width) × [0, height)` directly.
- */
-/** Fraction of the host's width the navigator takes — OSD's `navigatorSizeRatio`. */
-export const NAVIGATOR_SIZE_RATIO = 0.16;
-const NAVIGATOR_MIN_PX = 110;
-const NAVIGATOR_MAX_PX = 300;
-/** Box size and scale for a `worldW × worldH` image in a host `hostW` wide. */
-export function navigatorLayout(hostW, worldW, worldH, ratio = NAVIGATOR_SIZE_RATIO) {
-    if (!(worldW > 0) || !(worldH > 0) || !(hostW > 0))
-        return null;
-    const longest = Math.min(NAVIGATOR_MAX_PX, Math.max(NAVIGATOR_MIN_PX, hostW * ratio));
-    const scale = longest / Math.max(worldW, worldH);
-    return { width: worldW * scale, height: worldH * scale, scale };
-}
-/** The part of the world the camera shows, as `[x0, y0, x1, y1]`. */
-export function viewportWorldRect(center, zoom, hostW, hostH) {
-    const hw = hostW / zoom / 2;
-    const hh = hostH / zoom / 2;
-    return [center[0] - hw, center[1] - hh, center[0] + hw, center[1] + hh];
-}
-/** A point in the navigator box → world coordinates, clamped to the image. */
-export function navigatorToWorld(px, py, layout, worldW, worldH) {
-    const x = Math.min(worldW, Math.max(0, px / layout.scale));
-    const y = Math.min(worldH, Math.max(0, py / layout.scale));
-    return [x, y];
-}
-export class NapariNavigator {
-    constructor(host, camera, worldW, worldH, 
-    /** Called when the pointer enters the navigator — e.g. to hide a hover tooltip that
-     *  was describing the canvas underneath. */
-    onEnter) {
-        this.host = host;
-        this.camera = camera;
-        this.worldW = worldW;
-        this.worldH = worldH;
-        this.onEnter = onEnter;
-        /** Aborted by destroy() to remove every DOM listener the box holds. */
-        this.listeners = new AbortController();
-        this.layout = null;
-        this.image = null;
-        this.dragging = false;
-        this.visible = true;
-        this.onDown = (e) => {
-            stop(e);
-            if (e.button !== 0)
-                return;
-            this.dragging = true;
-            this.box.setPointerCapture?.(e.pointerId);
-            this.panTo(e);
-        };
-        this.onMove = (e) => {
-            // Always consumed: a hover over the navigator is not a hover over the canvas.
-            stop(e);
-            if (this.dragging)
-                this.panTo(e);
-        };
-        this.onUp = (e) => {
-            if (!this.dragging)
-                return;
-            stop(e);
-            this.dragging = false;
-            this.box.releasePointerCapture?.(e.pointerId);
-        };
-        if (getComputedStyle(host).position === 'static')
-            host.style.position = 'relative';
-        this.box = document.createElement('div');
-        this.box.className = 'napari-navigator';
-        Object.assign(this.box.style, {
-            position: 'absolute',
-            right: '12px',
-            bottom: '12px',
-            background: 'rgba(0,0,0,0.5)',
-            border: '1px solid rgba(255,255,255,0.35)',
-            overflow: 'hidden',
-            cursor: 'pointer',
-            zIndex: '5',
-            touchAction: 'none',
-        });
-        this.canvas = document.createElement('canvas');
-        Object.assign(this.canvas.style, { display: 'block', width: '100%', height: '100%' });
-        // OSD's default display-region style.
-        this.region = document.createElement('div');
-        Object.assign(this.region.style, {
-            position: 'absolute',
-            border: '2px solid #900',
-            boxSizing: 'border-box',
-            pointerEvents: 'none',
-        });
-        this.box.append(this.canvas, this.region);
-        host.appendChild(this.box);
-        // The navigator's own gestures must not also reach the canvas underneath (pan/zoom,
-        // region drawing), so every pointer/wheel event is consumed here.
-        // One signal for all of them, so destroy() releases every listener at once.
-        const signal = this.listeners.signal;
-        this.box.addEventListener('pointerdown', this.onDown, { signal });
-        this.box.addEventListener('pointermove', this.onMove, { signal });
-        this.box.addEventListener('pointerup', this.onUp, { signal });
-        this.box.addEventListener('pointercancel', this.onUp, { signal });
-        this.box.addEventListener('pointerenter', () => this.onEnter?.(), { signal });
-        for (const type of ['wheel', 'click', 'dblclick', 'contextmenu', 'mousedown']) {
-            this.box.addEventListener(type, stop, { passive: false, signal });
-        }
-        this.disconnectCamera = camera.changed.connect(() => this.updateRegion());
-        if (typeof ResizeObserver !== 'undefined') {
-            this.resizeObserver = new ResizeObserver(() => this.relayout());
-            this.resizeObserver.observe(host);
-        }
-        this.relayout();
-    }
-    /** The thumbnail to draw: any image of the whole world (a coarse pyramid level). */
-    setImage(image) {
-        this.image = image;
-        this.drawImage();
-    }
-    /** The image's world size changed (another image was loaded). */
-    setWorld(width, height) {
-        this.worldW = width;
-        this.worldH = height;
-        this.relayout();
-    }
-    setVisible(visible) {
-        this.visible = visible;
-        this.box.style.display = visible && this.layout ? 'block' : 'none';
-    }
-    destroy() {
-        this.listeners.abort();
-        this.disconnectCamera();
-        this.resizeObserver?.disconnect();
-        this.box.remove();
-    }
-    relayout() {
-        this.layout = navigatorLayout(this.host.clientWidth, this.worldW, this.worldH);
-        if (!this.layout) {
-            this.box.style.display = 'none';
-            return;
-        }
-        this.box.style.display = this.visible ? 'block' : 'none';
-        this.box.style.width = `${this.layout.width}px`;
-        this.box.style.height = `${this.layout.height}px`;
-        const dpr = typeof devicePixelRatio === 'number' ? devicePixelRatio : 1;
-        this.canvas.width = Math.max(1, Math.round(this.layout.width * dpr));
-        this.canvas.height = Math.max(1, Math.round(this.layout.height * dpr));
-        this.drawImage();
-        this.updateRegion();
-    }
-    drawImage() {
-        const ctx = this.canvas.getContext('2d');
-        if (!ctx)
-            return;
-        ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
-        if (this.image) {
-            ctx.imageSmoothingEnabled = true;
-            ctx.drawImage(this.image, 0, 0, this.canvas.width, this.canvas.height);
-        }
-    }
-    /** Draw the viewport rectangle, clipped to the box (as OSD does when zoomed out). */
-    updateRegion() {
-        const l = this.layout;
-        if (!l)
-            return;
-        const [x0, y0, x1, y1] = viewportWorldRect(this.camera.center, this.camera.zoom, this.host.clientWidth, this.host.clientHeight);
-        const left = Math.max(0, x0 * l.scale);
-        const top = Math.max(0, y0 * l.scale);
-        const right = Math.min(l.width, x1 * l.scale);
-        const bottom = Math.min(l.height, y1 * l.scale);
-        Object.assign(this.region.style, {
-            left: `${left}px`,
-            top: `${top}px`,
-            width: `${Math.max(2, right - left)}px`,
-            height: `${Math.max(2, bottom - top)}px`,
-            display: right > left && bottom > top ? 'block' : 'none',
-        });
-    }
-    /** Re-centre the main view on the navigator point under the pointer, keeping the zoom. */
-    panTo(e) {
-        const l = this.layout;
-        if (!l)
-            return;
-        const rect = this.box.getBoundingClientRect();
-        this.camera.center = navigatorToWorld(e.clientX - rect.left, e.clientY - rect.top, l, this.worldW, this.worldH);
-    }
-}
-function stop(e) {
-    e.stopPropagation();
-    if (e.cancelable)
-        e.preventDefault();
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-navigator.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-navigator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Overview navigator (minimap) for the napari-js 2D views, mirroring the OSD backend's\n * built-in navigator: a thumbnail of the whole image in the bottom-right corner with the\n * current viewport drawn on it. Clicking re-centres the main view on that point at the\n * same zoom; dragging pans continuously — exactly OSD's behaviour.\n *\n * napari keeps layers at full-resolution pixel scale, so the camera's world units ARE\n * image pixels and the thumbnail maps onto `[0, width) × [0, height)` directly.\n */\n\n/** The slice of the napari 2D camera the navigator reads and drives. */\nexport interface NavigatorCamera {\n  center: readonly [number, number];\n  readonly zoom: number;\n  readonly changed: { connect(listener: () => void): () => void };\n}\n\n/** Where the thumbnail sits inside the navigator box, in CSS px. */\nexport interface NavigatorLayout {\n  /** Box size. */\n  width: number;\n  height: number;\n  /** CSS px per world unit (image pixel). */\n  scale: number;\n}\n\n/** Fraction of the host's width the navigator takes — OSD's `navigatorSizeRatio`. */\nexport const NAVIGATOR_SIZE_RATIO = 0.16;\nconst NAVIGATOR_MIN_PX = 110;\nconst NAVIGATOR_MAX_PX = 300;\n\n/** Box size and scale for a `worldW × worldH` image in a host `hostW` wide. */\nexport function navigatorLayout(\n  hostW: number, worldW: number, worldH: number, ratio = NAVIGATOR_SIZE_RATIO,\n): NavigatorLayout | null {\n  if (!(worldW > 0) || !(worldH > 0) || !(hostW > 0)) return null;\n  const longest = Math.min(NAVIGATOR_MAX_PX, Math.max(NAVIGATOR_MIN_PX, hostW * ratio));\n  const scale = longest / Math.max(worldW, worldH);\n  return { width: worldW * scale, height: worldH * scale, scale };\n}\n\n/** The part of the world the camera shows, as `[x0, y0, x1, y1]`. */\nexport function viewportWorldRect(\n  center: readonly [number, number], zoom: number, hostW: number, hostH: number,\n): [number, number, number, number] {\n  const hw = hostW / zoom / 2;\n  const hh = hostH / zoom / 2;\n  return [center[0] - hw, center[1] - hh, center[0] + hw, center[1] + hh];\n}\n\n/** A point in the navigator box → world coordinates, clamped to the image. */\nexport function navigatorToWorld(\n  px: number, py: number, layout: NavigatorLayout, worldW: number, worldH: number,\n): [number, number] {\n  const x = Math.min(worldW, Math.max(0, px / layout.scale));\n  const y = Math.min(worldH, Math.max(0, py / layout.scale));\n  return [x, y];\n}\n\nexport class NapariNavigator {\n  private readonly box: HTMLDivElement;\n  private readonly canvas: HTMLCanvasElement;\n  private readonly region: HTMLDivElement;\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  /** Aborted by destroy() to remove every DOM listener the box holds. */\n  private readonly listeners = new AbortController();\n  private layout: NavigatorLayout | null = null;\n  private image: CanvasImageSource | null = null;\n  private dragging = false;\n  private visible = true;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera: NavigatorCamera,\n    private worldW: number,\n    private worldH: number,\n    /** Called when the pointer enters the navigator — e.g. to hide a hover tooltip that\n     *  was describing the canvas underneath. */\n    private readonly onEnter?: () => void,\n  ) {\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n\n    this.box = document.createElement('div');\n    this.box.className = 'napari-navigator';\n    Object.assign(this.box.style, {\n      position: 'absolute',\n      right: '12px',\n      bottom: '12px',\n      background: 'rgba(0,0,0,0.5)',\n      border: '1px solid rgba(255,255,255,0.35)',\n      overflow: 'hidden',\n      cursor: 'pointer',\n      zIndex: '5',\n      touchAction: 'none',\n    } satisfies Partial<CSSStyleDeclaration>);\n\n    this.canvas = document.createElement('canvas');\n    Object.assign(this.canvas.style, { display: 'block', width: '100%', height: '100%' });\n\n    // OSD's default display-region style.\n    this.region = document.createElement('div');\n    Object.assign(this.region.style, {\n      position: 'absolute',\n      border: '2px solid #900',\n      boxSizing: 'border-box',\n      pointerEvents: 'none',\n    } satisfies Partial<CSSStyleDeclaration>);\n\n    this.box.append(this.canvas, this.region);\n    host.appendChild(this.box);\n\n    // The navigator's own gestures must not also reach the canvas underneath (pan/zoom,\n    // region drawing), so every pointer/wheel event is consumed here.\n    // One signal for all of them, so destroy() releases every listener at once.\n    const signal = this.listeners.signal;\n    this.box.addEventListener('pointerdown', this.onDown, { signal });\n    this.box.addEventListener('pointermove', this.onMove, { signal });\n    this.box.addEventListener('pointerup', this.onUp, { signal });\n    this.box.addEventListener('pointercancel', this.onUp, { signal });\n    this.box.addEventListener('pointerenter', () => this.onEnter?.(), { signal });\n    for (const type of ['wheel', 'click', 'dblclick', 'contextmenu', 'mousedown'] as const) {\n      this.box.addEventListener(type, stop, { passive: false, signal });\n    }\n\n    this.disconnectCamera = camera.changed.connect(() => this.updateRegion());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.relayout());\n      this.resizeObserver.observe(host);\n    }\n    this.relayout();\n  }\n\n  /** The thumbnail to draw: any image of the whole world (a coarse pyramid level). */\n  setImage(image: CanvasImageSource | null): void {\n    this.image = image;\n    this.drawImage();\n  }\n\n  /** The image's world size changed (another image was loaded). */\n  setWorld(width: number, height: number): void {\n    this.worldW = width;\n    this.worldH = height;\n    this.relayout();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.box.style.display = visible && this.layout ? 'block' : 'none';\n  }\n\n  destroy(): void {\n    this.listeners.abort();\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    this.box.remove();\n  }\n\n  private relayout(): void {\n    this.layout = navigatorLayout(this.host.clientWidth, this.worldW, this.worldH);\n    if (!this.layout) {\n      this.box.style.display = 'none';\n      return;\n    }\n    this.box.style.display = this.visible ? 'block' : 'none';\n    this.box.style.width = `${this.layout.width}px`;\n    this.box.style.height = `${this.layout.height}px`;\n    const dpr = typeof devicePixelRatio === 'number' ? devicePixelRatio : 1;\n    this.canvas.width = Math.max(1, Math.round(this.layout.width * dpr));\n    this.canvas.height = Math.max(1, Math.round(this.layout.height * dpr));\n    this.drawImage();\n    this.updateRegion();\n  }\n\n  private drawImage(): void {\n    const ctx = this.canvas.getContext('2d');\n    if (!ctx) return;\n    ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);\n    if (this.image) {\n      ctx.imageSmoothingEnabled = true;\n      ctx.drawImage(this.image, 0, 0, this.canvas.width, this.canvas.height);\n    }\n  }\n\n  /** Draw the viewport rectangle, clipped to the box (as OSD does when zoomed out). */\n  private updateRegion(): void {\n    const l = this.layout;\n    if (!l) return;\n    const [x0, y0, x1, y1] = viewportWorldRect(\n      this.camera.center, this.camera.zoom, this.host.clientWidth, this.host.clientHeight,\n    );\n    const left = Math.max(0, x0 * l.scale);\n    const top = Math.max(0, y0 * l.scale);\n    const right = Math.min(l.width, x1 * l.scale);\n    const bottom = Math.min(l.height, y1 * l.scale);\n    Object.assign(this.region.style, {\n      left: `${left}px`,\n      top: `${top}px`,\n      width: `${Math.max(2, right - left)}px`,\n      height: `${Math.max(2, bottom - top)}px`,\n      display: right > left && bottom > top ? 'block' : 'none',\n    });\n  }\n\n  /** Re-centre the main view on the navigator point under the pointer, keeping the zoom. */\n  private panTo(e: PointerEvent): void {\n    const l = this.layout;\n    if (!l) return;\n    const rect = this.box.getBoundingClientRect();\n    this.camera.center = navigatorToWorld(\n      e.clientX - rect.left, e.clientY - rect.top, l, this.worldW, this.worldH,\n    );\n  }\n\n  private readonly onDown = (e: PointerEvent): void => {\n    stop(e);\n    if (e.button !== 0) return;\n    this.dragging = true;\n    this.box.setPointerCapture?.(e.pointerId);\n    this.panTo(e);\n  };\n\n  private readonly onMove = (e: PointerEvent): void => {\n    // Always consumed: a hover over the navigator is not a hover over the canvas.\n    stop(e);\n    if (this.dragging) this.panTo(e);\n  };\n\n  private readonly onUp = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    stop(e);\n    this.dragging = false;\n    this.box.releasePointerCapture?.(e.pointerId);\n  };\n}\n\nfunction stop(e: Event): void {\n  e.stopPropagation();\n  if (e.cancelable) e.preventDefault();\n}\n"]}