@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/implementations/napari-js/napari-loading-badge.mjs

@@ -1,6 +1,7 @@
 /**
  * "Transcripts reloading…" at the bottom of the canvas while a layer's data is in flight: one
  * line naming every layer still loading, on a semi-opaque backing so it reads over any tissue.
+ * Longer work names itself ("Building HPF in 3D…") and joins the line.
  *
  * Shown only once something has been loading for {@link SHOW_AFTER_MS}, so a redraw served from
  * cache does not flash it.
@@ -8,8 +9,8 @@
 export const SHOW_AFTER_MS = 150;
 export class NapariLoadingBadge {
     constructor(host) {
-        this.host = host;
         this.names = [];
+        this.tasks = [];
         this.timer = null;
         if (getComputedStyle(host).position === 'static')
             host.style.position = 'relative';
@@ -34,28 +35,30 @@ export class NapariLoadingBadge {
         });
         host.appendChild(this.el);
     }
-    /** The layers loading now; empty hides the badge. */
-    set(names) {
+    /** The layers loading now, and the tasks running (their messages); both empty hides the badge. */
+    set(names, tasks = []) {
         this.names = [...new Set(names)];
-        if (!this.names.length) {
+        this.tasks = [...new Set(tasks)];
+        if (!this.names.length && !this.tasks.length) {
             if (this.timer)
                 clearTimeout(this.timer);
             this.timer = null;
             this.el.style.display = 'none';
             return;
         }
-        this.el.textContent = `${listOf(this.names)} reloading…`;
+        const parts = this.names.length ? [`${listOf(this.names)} reloading…`, ...this.tasks] : this.tasks;
+        this.el.textContent = parts.join(' · ');
         if (this.el.style.display === 'block' || this.timer)
             return;
         this.timer = setTimeout(() => {
             this.timer = null;
-            if (this.names.length)
+            if (this.names.length || this.tasks.length)
                 this.el.style.display = 'block';
         }, SHOW_AFTER_MS);
     }
     /** The text currently set (shown or about to be). */
     get text() {
-        return this.names.length ? this.el.textContent ?? '' : '';
+        return this.names.length || this.tasks.length ? (this.el.textContent ?? '') : '';
     }
     destroy() {
         if (this.timer)
@@ -63,11 +66,11 @@ export class NapariLoadingBadge {
         this.el.remove();
     }
 }
-/** "A", "A and B", "A, B and C" — the first capitalised, the rest as they are. */
+/** "A", "A and b", "A, b and c": the first as given, the rest with a lower-cased initial. */
 function listOf(names) {
     const [first, ...rest] = names;
     const lower = rest.map((n) => n.charAt(0).toLowerCase() + n.slice(1));
     const all = [first, ...lower];
     return all.length === 1 ? all[0] : `${all.slice(0, -1).join(', ')} and ${all[all.length - 1]}`;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/napari-js/napari-loading-state.mjs

@@ -0,0 +1,83 @@
+import { NapariLoadingBadge } from './napari-loading-badge';
+/**
+ * "x reloading…" at the bottom of the canvas, aggregated over everything that loads into one
+ * scene: image tiles (the tile client), observation colourings (the spatial scenes) and the
+ * spatial tile layers' own loads (which report a list of layer names).
+ *
+ * Each load is a {@link begin} that hands back its own `end`. {@link reset} starts a new scene:
+ * the counts are dropped, and an `end` from a load that began before it is a no-op, so a load
+ * that settles after a re-plot can neither un-count the new scene's work nor drive a count below
+ * zero (which hid the next scene's "Observations reloading…" until a second load overlapped it).
+ *
+ * A {@link beginTask} is work that outlives a scene (a region's 3D reconstruction, built for
+ * whichever volume is on screen when it is done): its message stays across a reset.
+ */
+export class LoadingBadgeState {
+    constructor() {
+        this.host = null;
+        this.badge = null;
+        this.counts = new Map();
+        this.tileLayers = [];
+        this.generation = 0;
+        this.tasks = new Map();
+    }
+    /** The element the badge is drawn into (the plot host); set per plot. */
+    attach(host) {
+        this.host = host;
+        if (this.tasks.size)
+            this.show();
+    }
+    /** One load of `source` started; call the returned function once it settles. */
+    begin(source) {
+        const generation = this.generation;
+        this.counts.set(source, (this.counts.get(source) ?? 0) + 1);
+        this.show();
+        let ended = false;
+        return () => {
+            if (ended || generation !== this.generation)
+                return;
+            ended = true;
+            this.counts.set(source, (this.counts.get(source) ?? 0) - 1);
+            this.show();
+        };
+    }
+    /** A task started, shown by its `message` ("Building HPF in 3D…"); call the returned function
+     *  once it settles. */
+    beginTask(message) {
+        const id = Symbol(message);
+        this.tasks.set(id, message);
+        this.show();
+        return () => {
+            if (this.tasks.delete(id))
+                this.show();
+        };
+    }
+    /** The spatial tile layers still loading (their own names, in their order). */
+    setTileLayers(layers) {
+        this.tileLayers = layers;
+        this.show();
+    }
+    /** The text the badge has set (shown, or about to be once the show delay passes). */
+    get text() {
+        return this.badge?.text ?? '';
+    }
+    /** A new scene: forget every count and remove the badge (tasks show again on the next attach). */
+    reset() {
+        this.generation++;
+        this.counts.clear();
+        this.tileLayers = [];
+        this.badge?.destroy();
+        this.badge = null;
+    }
+    show() {
+        if (!this.host)
+            return;
+        this.badge ??= new NapariLoadingBadge(this.host);
+        this.badge.set([
+            ...((this.counts.get('Image') ?? 0) > 0 ? ['Image'] : []),
+            ...((this.counts.get('Observations') ?? 0) > 0 ? ['Observations'] : []),
+            ...this.tileLayers,
+        ], [...this.tasks.values()]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/napari-js/napari-region-mesh-pointer.mjs

@@ -0,0 +1,100 @@
+/** A press that moves farther than this (px) is an orbit drag, not a click. */
+const CLICK_SLOP_PX = 5;
+/** Hover picking waits for the pointer to rest this long (ms): a ray cast per move is wasted. */
+const HOVER_DELAY_MS = 60;
+/**
+ * Clicks and hover on the region surfaces of a volume view: a click (a press that does not orbit)
+ * picks the surface under it, or none; resting over a surface shows its name in a tooltip (and a
+ * pointer cursor when a click would pick it). Listens on the canvas without stopping events, so the
+ * camera still orbits.
+ */
+export class RegionMeshPointer {
+    constructor(canvas, host, opts) {
+        this.canvas = canvas;
+        this.opts = opts;
+        this.down = null;
+        this.hoverTimer = null;
+        this.onDown = (e) => {
+            this.down = e.button === 0 ? { x: e.clientX, y: e.clientY } : null;
+        };
+        this.onUp = (e) => {
+            const down = this.down;
+            this.down = null;
+            if (!down || e.button !== 0 || !this.opts.active())
+                return;
+            if (Math.hypot(e.clientX - down.x, e.clientY - down.y) > CLICK_SLOP_PX)
+                return;
+            const [x, y] = this.local(e);
+            const hit = this.opts.pickAt(x, y);
+            this.opts.onPick(hit?.key ?? null, e.shiftKey || e.ctrlKey || e.metaKey);
+        };
+        this.onMove = (e) => {
+            if (this.hoverTimer)
+                clearTimeout(this.hoverTimer);
+            this.hoverTimer = null;
+            // Dragging orbits the camera: no hover while a button is down.
+            if (e.buttons || !this.opts.hoverable()) {
+                this.hide();
+                return;
+            }
+            const [x, y] = this.local(e);
+            this.hoverTimer = setTimeout(() => {
+                this.hoverTimer = null;
+                const hit = this.opts.pickAt(x, y);
+                if (!hit) {
+                    this.hide();
+                    return;
+                }
+                this.canvas.style.cursor = this.opts.active() ? 'pointer' : '';
+                this.tip.textContent = hit.label ?? hit.key;
+                this.tip.style.left = `${x + 14}px`;
+                this.tip.style.top = `${y + 14}px`;
+                this.tip.style.display = 'block';
+            }, HOVER_DELAY_MS);
+        };
+        this.onLeave = () => {
+            if (this.hoverTimer)
+                clearTimeout(this.hoverTimer);
+            this.hoverTimer = null;
+            this.hide();
+        };
+        if (getComputedStyle(host).position === 'static')
+            host.style.position = 'relative';
+        this.tip = document.createElement('div');
+        this.tip.className = 'napari-region-mesh-tip';
+        Object.assign(this.tip.style, {
+            position: 'absolute',
+            padding: '2px 8px',
+            borderRadius: '4px',
+            background: 'rgba(0, 0, 0, 0.75)',
+            color: '#fff',
+            font: '12px/1.4 system-ui, sans-serif',
+            whiteSpace: 'nowrap',
+            pointerEvents: 'none',
+            zIndex: '6',
+            display: 'none',
+        });
+        host.appendChild(this.tip);
+        canvas.addEventListener('pointerdown', this.onDown);
+        canvas.addEventListener('pointerup', this.onUp);
+        canvas.addEventListener('pointermove', this.onMove);
+        canvas.addEventListener('pointerleave', this.onLeave);
+    }
+    destroy() {
+        this.canvas.removeEventListener('pointerdown', this.onDown);
+        this.canvas.removeEventListener('pointerup', this.onUp);
+        this.canvas.removeEventListener('pointermove', this.onMove);
+        this.canvas.removeEventListener('pointerleave', this.onLeave);
+        this.onLeave();
+        this.tip.remove();
+    }
+    local(e) {
+        const r = this.canvas.getBoundingClientRect();
+        return [e.clientX - r.left, e.clientY - r.top];
+    }
+    hide() {
+        this.tip.style.display = 'none';
+        this.canvas.style.cursor = '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-region-mesh-pointer.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-region-mesh-pointer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { RegionMesh3D } from './napari-volume-region-meshes';\n\nexport interface RegionMeshPointerOptions {\n  /** The surface under canvas point (`x`, `y`) (CSS px), or null. */\n  pickAt(x: number, y: number): RegionMesh3D | null;\n  /** Whether a click picks (the selection tool armed, surfaces shown); otherwise clicks are left alone. */\n  active(): boolean;\n  /** Whether hovering names the surface under the pointer (surfaces shown, whatever the tool). */\n  hoverable(): boolean;\n  /** A click on a surface (its key), or on none (null); `additive` with Shift / Ctrl / ⌘. */\n  onPick(key: string | null, additive: boolean): void;\n}\n\n/** A press that moves farther than this (px) is an orbit drag, not a click. */\nconst CLICK_SLOP_PX = 5;\n/** Hover picking waits for the pointer to rest this long (ms): a ray cast per move is wasted. */\nconst HOVER_DELAY_MS = 60;\n\n/**\n * Clicks and hover on the region surfaces of a volume view: a click (a press that does not orbit)\n * picks the surface under it, or none; resting over a surface shows its name in a tooltip (and a\n * pointer cursor when a click would pick it). Listens on the canvas without stopping events, so the\n * camera still orbits.\n */\nexport class RegionMeshPointer {\n  private readonly tip: HTMLDivElement;\n  private down: { x: number; y: number } | null = null;\n  private hoverTimer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor(\n    private readonly canvas: HTMLElement,\n    host: HTMLElement,\n    private readonly opts: RegionMeshPointerOptions,\n  ) {\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n    this.tip = document.createElement('div');\n    this.tip.className = 'napari-region-mesh-tip';\n    Object.assign(this.tip.style, {\n      position: 'absolute',\n      padding: '2px 8px',\n      borderRadius: '4px',\n      background: 'rgba(0, 0, 0, 0.75)',\n      color: '#fff',\n      font: '12px/1.4 system-ui, sans-serif',\n      whiteSpace: 'nowrap',\n      pointerEvents: 'none',\n      zIndex: '6',\n      display: 'none',\n    } satisfies Partial<CSSStyleDeclaration>);\n    host.appendChild(this.tip);\n    canvas.addEventListener('pointerdown', this.onDown);\n    canvas.addEventListener('pointerup', this.onUp);\n    canvas.addEventListener('pointermove', this.onMove);\n    canvas.addEventListener('pointerleave', this.onLeave);\n  }\n\n  destroy(): void {\n    this.canvas.removeEventListener('pointerdown', this.onDown);\n    this.canvas.removeEventListener('pointerup', this.onUp);\n    this.canvas.removeEventListener('pointermove', this.onMove);\n    this.canvas.removeEventListener('pointerleave', this.onLeave);\n    this.onLeave();\n    this.tip.remove();\n  }\n\n  private local(e: PointerEvent): [number, number] {\n    const r = this.canvas.getBoundingClientRect();\n    return [e.clientX - r.left, e.clientY - r.top];\n  }\n\n  private readonly onDown = (e: PointerEvent): void => {\n    this.down = e.button === 0 ? { x: e.clientX, y: e.clientY } : null;\n  };\n\n  private readonly onUp = (e: PointerEvent): void => {\n    const down = this.down;\n    this.down = null;\n    if (!down || e.button !== 0 || !this.opts.active()) return;\n    if (Math.hypot(e.clientX - down.x, e.clientY - down.y) > CLICK_SLOP_PX) return;\n    const [x, y] = this.local(e);\n    const hit = this.opts.pickAt(x, y);\n    this.opts.onPick(hit?.key ?? null, e.shiftKey || e.ctrlKey || e.metaKey);\n  };\n\n  private readonly onMove = (e: PointerEvent): void => {\n    if (this.hoverTimer) clearTimeout(this.hoverTimer);\n    this.hoverTimer = null;\n    // Dragging orbits the camera: no hover while a button is down.\n    if (e.buttons || !this.opts.hoverable()) {\n      this.hide();\n      return;\n    }\n    const [x, y] = this.local(e);\n    this.hoverTimer = setTimeout(() => {\n      this.hoverTimer = null;\n      const hit = this.opts.pickAt(x, y);\n      if (!hit) {\n        this.hide();\n        return;\n      }\n      this.canvas.style.cursor = this.opts.active() ? 'pointer' : '';\n      this.tip.textContent = hit.label ?? hit.key;\n      this.tip.style.left = `${x + 14}px`;\n      this.tip.style.top = `${y + 14}px`;\n      this.tip.style.display = 'block';\n    }, HOVER_DELAY_MS);\n  };\n\n  private readonly onLeave = (): void => {\n    if (this.hoverTimer) clearTimeout(this.hoverTimer);\n    this.hoverTimer = null;\n    this.hide();\n  };\n\n  private hide(): void {\n    this.tip.style.display = 'none';\n    this.canvas.style.cursor = '';\n  }\n}\n"]}