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

package/esm2022/lib/implementations/osd/osd-scale-bar.mjs

@@ -1,58 +1,18 @@
-import { OSD } from './osd-lib';
-/** Round up to a "nice" 1/2/5 × 10ⁿ value for scale-bar lengths. */
-function niceLength(x) {
-    if (x <= 0)
-        return 1;
-    const base = Math.pow(10, Math.floor(Math.log10(x)));
-    const f = x / base;
-    const nice = f < 1.5 ? 1 : f < 3.5 ? 2 : f < 7.5 ? 5 : 10;
-    return nice * base;
-}
-/**
- * Format a length given in micrometres, picking the unit that suits its
- * magnitude. The value is always µm internally (jit-service normalises whatever
- * unit Bio-Formats reports — nm/µm/mm/cm/inch — to µm), so this adapts the
- * displayed unit to the image's actual scale rather than assuming microns.
- */
-function formatUm(um) {
-    const trim = (n) => (n % 1 === 0 ? `${n}` : n.toFixed(1));
-    if (um >= 1e6)
-        return `${trim(um / 1e6)} m`;
-    if (um >= 1e4)
-        return `${trim(um / 1e4)} cm`;
-    if (um >= 1e3)
-        return `${trim(um / 1e3)} mm`;
-    if (um >= 1)
-        return `${trim(um)} µm`;
-    return `${trim(um * 1000)} nm`;
-}
+import { formatLength, scaleBarFor } from 'napari-js/overlays';
+import { imageToElement } from './osd-coords';
 /**
- * A physical scale bar drawn over an OpenSeadragon viewer. Recomputes on every
- * pan/zoom from the viewport's image→screen scale and the image's µm/pixel
- * (`mppX`, from Bio-Formats). Hidden when the image has no physical pixel size.
+ * A physical scale bar drawn over an OpenSeadragon viewer. The length maths (the nice 1/2/5 × 10ⁿ
+ * length nearest the target, and its unit) are napari-js's `scaleBarFor` / `formatLength`, which
+ * also size the napari backend's `ScaleBarOverlay`, so the two bars agree; the DOM is the same
+ * label-over-a-bracketed-line. Recomputes on every pan/zoom from the image→screen scale and the
+ * image's µm/pixel (`mppX`, from Bio-Formats). Hidden when the image has no physical pixel size.
  */
 export class OsdScaleBar {
     constructor(viewer, mppX) {
         this.viewer = viewer;
         this.mppX = mppX;
-        this.osd = OSD;
         this.redrawHandler = () => this.update();
-        this.bar = document.createElement('div');
-        Object.assign(this.bar.style, {
-            position: 'absolute', left: '12px', bottom: '12px', zIndex: '30',
-            pointerEvents: 'none', color: '#fff', font: '11px sans-serif',
-            textShadow: '0 0 3px #000', textAlign: 'center', userSelect: 'none',
-        });
-        this.label = document.createElement('span');
-        this.line = document.createElement('div');
-        Object.assign(this.line.style, {
-            height: '4px', marginTop: '2px', background: 'rgba(255,255,255,0.9)',
-            borderLeft: '1px solid #fff', borderRight: '1px solid #fff',
-            boxShadow: '0 0 3px #000',
-        });
-        this.bar.appendChild(this.label);
-        this.bar.appendChild(this.line);
-        this.viewer.canvas.appendChild(this.bar);
+        [this.bar, this.label, this.line] = createScaleBarElement(this.viewer.canvas);
         this.viewer.addHandler('update-viewport', this.redrawHandler);
         this.viewer.addHandler('animation', this.redrawHandler);
         this.viewer.addHandler('resize', this.redrawHandler);
@@ -63,26 +23,58 @@ export class OsdScaleBar {
             this.bar.style.display = 'none';
             return;
         }
-        const vp = this.viewer.viewport;
-        const a = vp.imageToViewerElementCoordinates(new this.osd.Point(0, 0));
-        const b = vp.imageToViewerElementCoordinates(new this.osd.Point(1, 0));
-        const pxPerImagePx = Math.abs(b.x - a.x); // screen px per image px
-        if (!(pxPerImagePx > 0)) {
+        // Through osd-coords (world item 0), which stays accurate while the world
+        // holds several slices — the viewport's own image conversion does not.
+        const a = imageToElement(this.viewer, 0, 0);
+        const b = imageToElement(this.viewer, 1, 0);
+        const spec = scaleBarFor(Math.abs(b.x - a.x), this.mppX);
+        if (!spec) {
             this.bar.style.display = 'none';
             return;
         }
-        const umPerScreenPx = this.mppX / pxPerImagePx;
-        const niceUm = niceLength(120 * umPerScreenPx); // target ~120px bar
         this.bar.style.display = '';
-        this.line.style.width = `${Math.round(niceUm / umPerScreenPx)}px`;
-        this.label.textContent = formatUm(niceUm);
+        this.line.style.width = `${Math.round(spec.widthPx)}px`;
+        this.label.textContent = formatLength(spec.length, 'µm');
     }
     destroy() {
         this.viewer.removeHandler('update-viewport', this.redrawHandler);
         this.viewer.removeHandler('animation', this.redrawHandler);
         this.viewer.removeHandler('resize', this.redrawHandler);
-        if (this.bar.parentNode)
-            this.bar.parentNode.removeChild(this.bar);
+        this.bar.remove();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osd-scale-bar.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/osd-scale-bar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAEhC,oEAAoE;AACpE,SAAS,UAAU,CAAC,CAAS;IAC3B,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACrB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACrD,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACnB,MAAM,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1D,OAAO,IAAI,GAAG,IAAI,CAAC;AACrB,CAAC;AAED;;;;;GAKG;AACH,SAAS,QAAQ,CAAC,EAAU;IAC1B,MAAM,IAAI,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IAClE,IAAI,EAAE,IAAI,GAAG;QAAE,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC;IAC5C,IAAI,EAAE,IAAI,GAAG;QAAE,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC;IAC7C,IAAI,EAAE,IAAI,GAAG;QAAE,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC;IAC7C,IAAI,EAAE,IAAI,CAAC;QAAE,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;IACrC,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,MAAM,OAAO,WAAW;IAOtB,YAAoB,MAAW,EAAU,IAAY;QAAjC,WAAM,GAAN,MAAM,CAAK;QAAU,SAAI,GAAJ,IAAI,CAAQ;QANpC,QAAG,GAAQ,GAAG,CAAC;QAIf,kBAAa,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;QAGnD,IAAI,CAAC,GAAG,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACzC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE;YAC5B,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI;YAChE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB;YAC7D,UAAU,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM;SAC7C,CAAC,CAAC;QAC1B,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YAC7B,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,uBAAuB;YACpE,UAAU,EAAE,gBAAgB,EAAE,WAAW,EAAE,gBAAgB;YAC3D,SAAS,EAAE,cAAc;SACH,CAAC,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEzC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC9D,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAEO,MAAM;QACZ,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;YACzF,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YAChC,OAAO;QACT,CAAC;QACD,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;QAChC,MAAM,CAAC,GAAG,EAAE,CAAC,+BAA+B,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACvE,MAAM,CAAC,GAAG,EAAE,CAAC,+BAA+B,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACvE,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,yBAAyB;QACnE,IAAI,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC,EAAE,CAAC;YAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YAAC,OAAO;QAAC,CAAC;QAErE,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QAC/C,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,GAAG,aAAa,CAAC,CAAC,CAAC,oBAAoB;QACpE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC;QAClE,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO;QACL,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACxD,IAAI,IAAI,CAAC,GAAG,CAAC,UAAU;YAAE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrE,CAAC;CACF","sourcesContent":["import { OSD } from './osd-lib';\n\n/** Round up to a \"nice\" 1/2/5 × 10ⁿ value for scale-bar lengths. */\nfunction niceLength(x: number): number {\n  if (x <= 0) return 1;\n  const base = Math.pow(10, Math.floor(Math.log10(x)));\n  const f = x / base;\n  const nice = f < 1.5 ? 1 : f < 3.5 ? 2 : f < 7.5 ? 5 : 10;\n  return nice * base;\n}\n\n/**\n * Format a length given in micrometres, picking the unit that suits its\n * magnitude. The value is always µm internally (jit-service normalises whatever\n * unit Bio-Formats reports — nm/µm/mm/cm/inch — to µm), so this adapts the\n * displayed unit to the image's actual scale rather than assuming microns.\n */\nfunction formatUm(um: number): string {\n  const trim = (n: number) => (n % 1 === 0 ? `${n}` : n.toFixed(1));\n  if (um >= 1e6) return `${trim(um / 1e6)} m`;\n  if (um >= 1e4) return `${trim(um / 1e4)} cm`;\n  if (um >= 1e3) return `${trim(um / 1e3)} mm`;\n  if (um >= 1) return `${trim(um)} µm`;\n  return `${trim(um * 1000)} nm`;\n}\n\n/**\n * A physical scale bar drawn over an OpenSeadragon viewer. Recomputes on every\n * pan/zoom from the viewport's image→screen scale and the image's µm/pixel\n * (`mppX`, from Bio-Formats). Hidden when the image has no physical pixel size.\n */\nexport class OsdScaleBar {\n  private readonly osd: any = OSD;\n  private readonly bar: HTMLDivElement;\n  private readonly line: HTMLDivElement;\n  private readonly label: HTMLSpanElement;\n  private readonly redrawHandler = () => this.update();\n\n  constructor(private viewer: any, private mppX: number) {\n    this.bar = document.createElement('div');\n    Object.assign(this.bar.style, {\n      position: 'absolute', left: '12px', bottom: '12px', zIndex: '30',\n      pointerEvents: 'none', color: '#fff', font: '11px sans-serif',\n      textShadow: '0 0 3px #000', textAlign: 'center', userSelect: 'none',\n    } as CSSStyleDeclaration);\n    this.label = document.createElement('span');\n    this.line = document.createElement('div');\n    Object.assign(this.line.style, {\n      height: '4px', marginTop: '2px', background: 'rgba(255,255,255,0.9)',\n      borderLeft: '1px solid #fff', borderRight: '1px solid #fff',\n      boxShadow: '0 0 3px #000',\n    } as CSSStyleDeclaration);\n    this.bar.appendChild(this.label);\n    this.bar.appendChild(this.line);\n    this.viewer.canvas.appendChild(this.bar);\n\n    this.viewer.addHandler('update-viewport', this.redrawHandler);\n    this.viewer.addHandler('animation', this.redrawHandler);\n    this.viewer.addHandler('resize', this.redrawHandler);\n    this.update();\n  }\n\n  private update(): void {\n    if (!(this.mppX > 0) || !this.viewer.viewport || this.viewer.world?.getItemCount() === 0) {\n      this.bar.style.display = 'none';\n      return;\n    }\n    const vp = this.viewer.viewport;\n    const a = vp.imageToViewerElementCoordinates(new this.osd.Point(0, 0));\n    const b = vp.imageToViewerElementCoordinates(new this.osd.Point(1, 0));\n    const pxPerImagePx = Math.abs(b.x - a.x); // screen px per image px\n    if (!(pxPerImagePx > 0)) { this.bar.style.display = 'none'; return; }\n\n    const umPerScreenPx = this.mppX / pxPerImagePx;\n    const niceUm = niceLength(120 * umPerScreenPx); // target ~120px bar\n    this.bar.style.display = '';\n    this.line.style.width = `${Math.round(niceUm / umPerScreenPx)}px`;\n    this.label.textContent = formatUm(niceUm);\n  }\n\n  destroy(): void {\n    this.viewer.removeHandler('update-viewport', this.redrawHandler);\n    this.viewer.removeHandler('animation', this.redrawHandler);\n    this.viewer.removeHandler('resize', this.redrawHandler);\n    if (this.bar.parentNode) this.bar.parentNode.removeChild(this.bar);\n  }\n}\n"]}
+/**
+ * The bar's DOM (a label over a bracketed line, bottom-left, above the canvas), styled as
+ * napari-js's `ScaleBarOverlay`, inside `host`, which must establish a containing block.
+ * Starts hidden until the first update.
+ */
+function createScaleBarElement(host) {
+    const bar = document.createElement('div');
+    Object.assign(bar.style, {
+        position: 'absolute',
+        left: '12px',
+        bottom: '12px',
+        zIndex: '30',
+        pointerEvents: 'none',
+        color: '#fff',
+        font: '11px sans-serif',
+        textShadow: '0 0 3px #000',
+        textAlign: 'center',
+        userSelect: 'none',
+        display: 'none',
+    });
+    const label = document.createElement('span');
+    const line = document.createElement('div');
+    Object.assign(line.style, {
+        height: '4px',
+        marginTop: '2px',
+        background: 'rgba(255,255,255,0.9)',
+        borderLeft: '1px solid #fff',
+        borderRight: '1px solid #fff',
+        boxShadow: '0 0 3px #000',
+    });
+    bar.append(label, line);
+    host.appendChild(bar);
+    return [bar, label, line];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osd-scale-bar.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/osd-scale-bar.ts"],"names":[],"mappings":"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","sourcesContent":["import { formatLength, scaleBarFor } from 'napari-js/overlays';\n\nimport { imageToElement } from './osd-coords';\nimport { OsdViewerLike } from './osd-viewer-like';\n\n/**\n * A physical scale bar drawn over an OpenSeadragon viewer. The length maths (the nice 1/2/5 × 10ⁿ\n * length nearest the target, and its unit) are napari-js's `scaleBarFor` / `formatLength`, which\n * also size the napari backend's `ScaleBarOverlay`, so the two bars agree; the DOM is the same\n * label-over-a-bracketed-line. Recomputes on every pan/zoom from the image→screen scale and the\n * image's µm/pixel (`mppX`, from Bio-Formats). Hidden when the image has no physical pixel size.\n */\nexport class OsdScaleBar {\n  private readonly bar: HTMLDivElement;\n  private readonly label: HTMLSpanElement;\n  private readonly line: HTMLDivElement;\n  private readonly redrawHandler = () => this.update();\n\n  constructor(\n    private viewer: OsdViewerLike,\n    private mppX: number,\n  ) {\n    [this.bar, this.label, this.line] = createScaleBarElement(this.viewer.canvas);\n    this.viewer.addHandler('update-viewport', this.redrawHandler);\n    this.viewer.addHandler('animation', this.redrawHandler);\n    this.viewer.addHandler('resize', this.redrawHandler);\n    this.update();\n  }\n\n  private update(): void {\n    if (!(this.mppX > 0) || !this.viewer.viewport || this.viewer.world?.getItemCount() === 0) {\n      this.bar.style.display = 'none';\n      return;\n    }\n    // Through osd-coords (world item 0), which stays accurate while the world\n    // holds several slices — the viewport's own image conversion does not.\n    const a = imageToElement(this.viewer, 0, 0);\n    const b = imageToElement(this.viewer, 1, 0);\n    const spec = scaleBarFor(Math.abs(b.x - a.x), this.mppX);\n    if (!spec) {\n      this.bar.style.display = 'none';\n      return;\n    }\n    this.bar.style.display = '';\n    this.line.style.width = `${Math.round(spec.widthPx)}px`;\n    this.label.textContent = formatLength(spec.length, 'µm');\n  }\n\n  destroy(): void {\n    this.viewer.removeHandler('update-viewport', this.redrawHandler);\n    this.viewer.removeHandler('animation', this.redrawHandler);\n    this.viewer.removeHandler('resize', this.redrawHandler);\n    this.bar.remove();\n  }\n}\n\n/**\n * The bar's DOM (a label over a bracketed line, bottom-left, above the canvas), styled as\n * napari-js's `ScaleBarOverlay`, inside `host`, which must establish a containing block.\n * Starts hidden until the first update.\n */\nfunction createScaleBarElement(host: HTMLElement): [HTMLDivElement, HTMLSpanElement, HTMLDivElement] {\n  const bar = document.createElement('div');\n  Object.assign(bar.style, {\n    position: 'absolute',\n    left: '12px',\n    bottom: '12px',\n    zIndex: '30',\n    pointerEvents: 'none',\n    color: '#fff',\n    font: '11px sans-serif',\n    textShadow: '0 0 3px #000',\n    textAlign: 'center',\n    userSelect: 'none',\n    display: 'none',\n  } as Partial<CSSStyleDeclaration>);\n  const label = document.createElement('span');\n  const line = document.createElement('div');\n  Object.assign(line.style, {\n    height: '4px',\n    marginTop: '2px',\n    background: 'rgba(255,255,255,0.9)',\n    borderLeft: '1px solid #fff',\n    borderRight: '1px solid #fff',\n    boxShadow: '0 0 3px #000',\n  } as Partial<CSSStyleDeclaration>);\n  bar.append(label, line);\n  host.appendChild(bar);\n  return [bar, label, line];\n}\n"]}

package/esm2022/lib/implementations/osd/osd-tile-source.mjs

@@ -0,0 +1,105 @@
+import { OSD } from './osd-lib';
+import { buildTileUrl } from './tile-client';
+/**
+ * Per-channel fit-view tile budget (tiles at the coarsest real level × channels).
+ * Above it, a multichannel image renders server-composited instead of per-channel
+ * — its full-res reads (it has no overview pyramid) would be too many × N channels.
+ * 64 (e.g. a 4x4 single-FOV z-stack × 4ch) stays per-channel; a whole-slide
+ * (hundreds–thousands) falls back.
+ */
+export const MAX_MULTICHANNEL_FIT_TILES = 256;
+/**
+ * Decide how to draw a tiled image. Multichannel fluorescence (indexed/LUT-bearing
+ * stacks) composite client-side from per-channel tiles. Trust the server's explicit
+ * `multichannel` flag — the old `channels>1 && grayscale` heuristic also matched RGB
+ * photos Bio-Formats reads as separated planes (channels>1, rgbChannels==1),
+ * splitting them into N per-channel TiledImages that flooded the tile endpoint and
+ * hung on load.
+ */
+export function planTiledMount(d, maxFitTiles = MAX_MULTICHANNEL_FIT_TILES) {
+    const realLevels = d.realLevels ?? d.levels.length;
+    // Tiles to cover the whole image at the coarsest REAL Bio-Formats level (the
+    // smallest level that has real, per-channel-fetchable tiles — synthetic overview
+    // levels are server-composited only). A pyramidal image's coarsest real level is
+    // tiny (few tiles); a flat/no-pyramid image's is the full-res grid (many tiles).
+    const coarse = d.levels[realLevels - 1] ?? d.levels[d.levels.length - 1];
+    const coarseW = coarse ? Math.ceil(coarse.width / d.tileSize) : 1;
+    const coarseH = coarse ? Math.ceil(coarse.height / d.tileSize) : 1;
+    const coarseTiles = coarseW * coarseH;
+    let multiChannel = !!d.multichannel;
+    if (multiChannel) {
+        // Per-channel rendering can only use the REAL levels, so OSD requests the
+        // coarsest real level's whole tile grid × N channels at fit. When that's large
+        // (a whole-slide), it's too many (often slow, pyramid-less) full-res reads —
+        // fall back to the single server-composited source (which keeps the fast
+        // synthetic overviews). A small single-FOV z-stack stays per-channel. Size in
+        // BYTES isn't the signal — tile count is.
+        const fitTiles = coarseTiles * Math.max(1, d.channels ?? 1);
+        if (fitTiles > maxFitTiles) {
+            multiChannel = false;
+            console.warn('[OSD] multichannel composite too large for per-channel rendering: ' +
+                `${coarseW}x${coarseH} tiles x ${d.channels} channels = ${fitTiles} at the coarsest ` +
+                `real level (> ${maxFitTiles}); rendering server-composited for speed.`);
+        }
+    }
+    return { realLevels, multiChannel, coarseTiles };
+}
+/**
+ * Custom tile source built from the descriptor. OSD numbers levels
+ * coarsest-first; the backend numbers resolutions full-res-first, so
+ * `res = (levels-1) - osdLevel`. Overriding getLevelScale/getNumTiles lets us
+ * honour Bio-Formats' actual per-level dimensions (not assume power-of-two).
+ *
+ * Multichannel images composite from per-channel tiles, which only exist at
+ * real Bio-Formats resolutions — so `realLevelsOnly` drives OSD off the real
+ * levels alone and skips the synthetic (server-composited) overviews. Every
+ * displayed tile is then per-channel-fetchable at any zoom.
+ */
+export function buildOsdTileSource(d, spec) {
+    const levels = spec.realLevelsOnly != null ? d.levels.slice(0, spec.realLevelsOnly) : d.levels;
+    const n = levels.length;
+    const t = d.tileSize;
+    // OSD level i (0 = coarsest) <-> backend resolution (n-1-i) (res 0 = full).
+    // The backend pyramid is NOT necessarily power-of-two, so we drive OSD off
+    // the backend's real per-level dimensions. We override ONLY getLevelScale:
+    // OSD derives getNumTiles, getTileBounds AND its per-zoom level selection
+    // from getLevelScale, so they all stay consistent — requesting exactly the
+    // tiles each resolution actually has (no out-of-range 400s, no flood).
+    const resForLevel = (level) => n - 1 - level;
+    const osd = OSD;
+    const ts = new osd.TileSource({
+        width: d.width,
+        height: d.height,
+        tileSize: t,
+        tileOverlap: 0,
+        minLevel: 0,
+        maxLevel: n - 1,
+    });
+    ts['getLevelScale'] = (level) => {
+        const lvl = levels[resForLevel(level)];
+        return lvl ? lvl.width / d.width : 1;
+    };
+    // Drive the tile COUNT off each level's own (independently-rounded) dimensions,
+    // not OSD's default `ceil(scale * fullDimension / tileSize)`. Synthetic AND real
+    // Bio-Formats levels aren't exact proportional scales of the full image, so
+    // `scale * fullHeight` can round up to one more row (or column) than the level
+    // actually has — OSD then requests an out-of-range tile that the server 400s
+    // ("Tile (col,row) out of range"). Using the level's real w/h matches the
+    // server's own bounds check exactly.
+    ts['getNumTiles'] = (level) => {
+        const lvl = levels[resForLevel(level)];
+        if (!lvl)
+            return new osd.Point(0, 0);
+        return new osd.Point(Math.ceil(lvl.width / t), Math.ceil(lvl.height / t));
+    };
+    ts['getTileUrl'] = (level, x, y) => buildTileUrl(spec.api, spec.infoB64, {
+        res: resForLevel(level),
+        col: x,
+        row: y,
+        z: spec.z,
+        tileSize: t,
+        channel: spec.channel,
+    });
+    return ts;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osd-tile-source.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/osd-tile-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { OSD } from './osd-lib';\nimport { buildTileUrl } from './tile-client';\nimport { TileDescriptor } from '../tile-server';\n\n/**\n * Per-channel fit-view tile budget (tiles at the coarsest real level × channels).\n * Above it, a multichannel image renders server-composited instead of per-channel\n * — its full-res reads (it has no overview pyramid) would be too many × N channels.\n * 64 (e.g. a 4x4 single-FOV z-stack × 4ch) stays per-channel; a whole-slide\n * (hundreds–thousands) falls back.\n */\nexport const MAX_MULTICHANNEL_FIT_TILES = 256;\n\n/** How a tiled image is drawn, decided once per mount by {@link planTiledMount}. */\nexport interface TiledMountPlan {\n  /** Real Bio-Formats resolution levels (per-channel tiles exist only here). */\n  realLevels: number;\n  /** Composite client-side from one TiledImage per channel. */\n  multiChannel: boolean;\n  /** Tiles covering the whole image at the coarsest real level. */\n  coarseTiles: number;\n}\n\n/**\n * Decide how to draw a tiled image. Multichannel fluorescence (indexed/LUT-bearing\n * stacks) composite client-side from per-channel tiles. Trust the server's explicit\n * `multichannel` flag — the old `channels>1 && grayscale` heuristic also matched RGB\n * photos Bio-Formats reads as separated planes (channels>1, rgbChannels==1),\n * splitting them into N per-channel TiledImages that flooded the tile endpoint and\n * hung on load.\n */\nexport function planTiledMount(d: TileDescriptor, maxFitTiles = MAX_MULTICHANNEL_FIT_TILES): TiledMountPlan {\n  const realLevels = d.realLevels ?? d.levels.length;\n  // Tiles to cover the whole image at the coarsest REAL Bio-Formats level (the\n  // smallest level that has real, per-channel-fetchable tiles — synthetic overview\n  // levels are server-composited only). A pyramidal image's coarsest real level is\n  // tiny (few tiles); a flat/no-pyramid image's is the full-res grid (many tiles).\n  const coarse = d.levels[realLevels - 1] ?? d.levels[d.levels.length - 1];\n  const coarseW = coarse ? Math.ceil(coarse.width / d.tileSize) : 1;\n  const coarseH = coarse ? Math.ceil(coarse.height / d.tileSize) : 1;\n  const coarseTiles = coarseW * coarseH;\n  let multiChannel = !!d.multichannel;\n  if (multiChannel) {\n    // Per-channel rendering can only use the REAL levels, so OSD requests the\n    // coarsest real level's whole tile grid × N channels at fit. When that's large\n    // (a whole-slide), it's too many (often slow, pyramid-less) full-res reads —\n    // fall back to the single server-composited source (which keeps the fast\n    // synthetic overviews). A small single-FOV z-stack stays per-channel. Size in\n    // BYTES isn't the signal — tile count is.\n    const fitTiles = coarseTiles * Math.max(1, d.channels ?? 1);\n    if (fitTiles > maxFitTiles) {\n      multiChannel = false;\n      console.warn(\n        '[OSD] multichannel composite too large for per-channel rendering: ' +\n          `${coarseW}x${coarseH} tiles x ${d.channels} channels = ${fitTiles} at the coarsest ` +\n          `real level (> ${maxFitTiles}); rendering server-composited for speed.`,\n      );\n    }\n  }\n  return { realLevels, multiChannel, coarseTiles };\n}\n\n/** Where the tiles of one slice (and optionally one channel) come from. */\nexport interface TileSourceSpec {\n  api: string;\n  infoB64: string;\n  z: number;\n  /** Fetch this channel's single-band tiles (per-channel multichannel rendering). */\n  channel?: number;\n  /** Drive OSD off the first N (real) levels only — see {@link buildOsdTileSource}. */\n  realLevelsOnly?: number;\n}\n\n/**\n * Custom tile source built from the descriptor. OSD numbers levels\n * coarsest-first; the backend numbers resolutions full-res-first, so\n * `res = (levels-1) - osdLevel`. Overriding getLevelScale/getNumTiles lets us\n * honour Bio-Formats' actual per-level dimensions (not assume power-of-two).\n *\n * Multichannel images composite from per-channel tiles, which only exist at\n * real Bio-Formats resolutions — so `realLevelsOnly` drives OSD off the real\n * levels alone and skips the synthetic (server-composited) overviews. Every\n * displayed tile is then per-channel-fetchable at any zoom.\n */\nexport function buildOsdTileSource(d: TileDescriptor, spec: TileSourceSpec): Record<string, unknown> {\n  const levels = spec.realLevelsOnly != null ? d.levels.slice(0, spec.realLevelsOnly) : d.levels;\n  const n = levels.length;\n  const t = d.tileSize;\n\n  // OSD level i (0 = coarsest) <-> backend resolution (n-1-i) (res 0 = full).\n  // The backend pyramid is NOT necessarily power-of-two, so we drive OSD off\n  // the backend's real per-level dimensions. We override ONLY getLevelScale:\n  // OSD derives getNumTiles, getTileBounds AND its per-zoom level selection\n  // from getLevelScale, so they all stay consistent — requesting exactly the\n  // tiles each resolution actually has (no out-of-range 400s, no flood).\n  const resForLevel = (level: number) => n - 1 - level;\n  const osd = OSD as unknown as {\n    TileSource: new (o: object) => Record<string, unknown>;\n    Point: new (x: number, y: number) => unknown;\n  };\n  const ts = new osd.TileSource({\n    width: d.width,\n    height: d.height,\n    tileSize: t,\n    tileOverlap: 0,\n    minLevel: 0,\n    maxLevel: n - 1,\n  });\n  ts['getLevelScale'] = (level: number) => {\n    const lvl = levels[resForLevel(level)];\n    return lvl ? lvl.width / d.width : 1;\n  };\n  // Drive the tile COUNT off each level's own (independently-rounded) dimensions,\n  // not OSD's default `ceil(scale * fullDimension / tileSize)`. Synthetic AND real\n  // Bio-Formats levels aren't exact proportional scales of the full image, so\n  // `scale * fullHeight` can round up to one more row (or column) than the level\n  // actually has — OSD then requests an out-of-range tile that the server 400s\n  // (\"Tile (col,row) out of range\"). Using the level's real w/h matches the\n  // server's own bounds check exactly.\n  ts['getNumTiles'] = (level: number) => {\n    const lvl = levels[resForLevel(level)];\n    if (!lvl) return new osd.Point(0, 0);\n    return new osd.Point(Math.ceil(lvl.width / t), Math.ceil(lvl.height / t));\n  };\n  ts['getTileUrl'] = (level: number, x: number, y: number) =>\n    buildTileUrl(spec.api, spec.infoB64, {\n      res: resForLevel(level),\n      col: x,\n      row: y,\n      z: spec.z,\n      tileSize: t,\n      channel: spec.channel,\n    });\n  return ts;\n}\n"]}

package/esm2022/lib/implementations/osd/osd-viewer-like.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/osd/osd-viewer-mount.mjs

@@ -0,0 +1,44 @@
+import { OSD } from './osd-lib';
+import { silenceOsdMultiImageAdvisory } from './openseadragon-viewer-options';
+/** How long a mount waits for OSD's `open`/`open-failed` before giving up. */
+export const OSD_OPEN_TIMEOUT_MS = 8000;
+/** Create an OpenSeadragon viewer (synchronously: a throwing factory throws here). */
+export function createViewer(options) {
+    silenceOsdMultiImageAdvisory();
+    return OSD(options);
+}
+/**
+ * Open `tileSource` in `viewer`. `onOpen` wires the freshly opened viewer
+ * (overlays, handlers); the promise resolves true once it ran, false on
+ * `open-failed` — and ALWAYS settles: if OSD never emits either (a bad tile
+ * source, a viewer torn down mid-open), the render pipeline must not hang, since
+ * a hang leaves imageLoading=true, sticking the spinner and the 500ms
+ * cache-progress poll forever (NS_BINDING_ABORTED storm).
+ */
+export function openViewer(viewer, tileSource, onOpen) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (ok) => {
+            if (!settled) {
+                settled = true;
+                resolve(ok);
+            }
+        };
+        viewer.addOnceHandler('open', () => {
+            onOpen(viewer);
+            done(true);
+        });
+        viewer.addOnceHandler('open-failed', (e) => {
+            const err = e;
+            console.warn('[OSD] open-failed', err?.message ?? e);
+            done(false);
+        });
+        setTimeout(() => {
+            if (!settled)
+                console.warn('[OSD] viewer open timed out');
+            done(false);
+        }, OSD_OPEN_TIMEOUT_MS);
+        viewer.open(tileSource);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/osd/osd-viewport.mjs

@@ -0,0 +1,184 @@
+import { Subject, defer } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { quiet } from './osd-lib';
+import { ZOOM_BUTTON_STEP } from './osd-zoom';
+import { imageRectToViewport, viewportRectToImage } from './osd-coords';
+/**
+ * The OpenSeadragon viewport as the rest of the library sees it: the visible
+ * image rect (settled, and per animation frame), the {@link PlotModeViewport} a
+ * contributed plot mode draws over, and the zoom/fit commands.
+ *
+ * Every member reads the CURRENT viewer through the host, so one instance lives
+ * as long as the service and stays valid across viewer rebuilds.
+ */
+export class OsdViewportAdapter {
+    constructor(host) {
+        this.host = host;
+        /** Visible image region (full-image pixel coords) emitted when the view
+         *  settles, so the intensity inset can re-sample at the current zoom level. */
+        this.viewportChange$ = new Subject();
+        /** The visible rect on every redraw, coalesced to one emission per animation
+         *  frame. Feeds {@link PlotModeViewport.frame$}. */
+        this.frame$ = new Subject();
+        this.frameRaf = null;
+        this.plotModeViewport = null;
+    }
+    /** Compute the current viewport's image-pixel rectangle (clamped to the image)
+     *  and broadcast it. */
+    emitViewportChange() {
+        const rect = this.visibleImageRect();
+        if (rect)
+            this.viewportChange$.next(rect);
+    }
+    /** The current viewport's image-pixel rectangle, clamped to the image, or
+     *  null when there is no laid-out viewport. */
+    visibleImageRect() {
+        const viewer = this.host.viewer();
+        const d = this.host.descriptor();
+        const vp = viewer?.viewport;
+        if (!vp || !d)
+            return null;
+        try {
+            // Route through world item 0 (osd-coords): vp.viewportToImageRectangle is
+            // inaccurate and warns when the world holds multiple images (per-channel
+            // multichannel layers), which fed the intensity inset a wrong ROI.
+            const r = viewportRectToImage(viewer, vp.getBounds(true));
+            const iw = d.width, ih = d.height;
+            const x = Math.max(0, Math.min(iw, r.x));
+            const y = Math.max(0, Math.min(ih, r.y));
+            const width = Math.max(1, Math.min(iw - x, r.width));
+            const height = Math.max(1, Math.min(ih - y, r.height));
+            return { x, y, width, height };
+        }
+        catch {
+            return null; /* viewport not ready */
+        }
+    }
+    /**
+     * Image-pixel rectangle the drawer canvas currently covers. Unlike
+     * {@link visibleImageRect}, this is NOT clamped to the image bounds: the canvas
+     * maps 1:1 to the viewport rectangle, so leaving it unclamped keeps
+     * `canvasPx -> imagePx` an exact affine map (clamping would skew coordinates
+     * near the image edges). Routed through world item 0 (see
+     * {@link viewportRectToImage}) for multi-layer accuracy.
+     */
+    displayedSourceRect() {
+        const viewer = this.host.viewer();
+        const vp = viewer?.viewport;
+        if (!vp || !this.host.descriptor())
+            return null;
+        try {
+            const r = viewportRectToImage(viewer, vp.getBounds(true));
+            return { x: r.x, y: r.y, width: r.width, height: r.height };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Coalesce redraws into one {@link frame$} emission per animation frame.
+     *  Skipped entirely while nothing listens. */
+    scheduleFrame() {
+        if (this.frameRaf !== null || !this.frame$.observed)
+            return;
+        this.frameRaf = requestAnimationFrame(() => {
+            this.frameRaf = null;
+            const rect = this.visibleImageRect();
+            if (rect)
+                this.frame$.next(rect);
+        });
+    }
+    /** Drop a pending {@link scheduleFrame} (the viewer is going away). */
+    cancelFrame() {
+        if (this.frameRaf !== null) {
+            cancelAnimationFrame(this.frameRaf);
+            this.frameRaf = null;
+        }
+    }
+    /**
+     * The viewport a contributed plot mode draws over. One stable object per
+     * service: every method reads the CURRENT viewer, so it stays valid across a
+     * viewer rebuild and reports `isReady() === false` while none is mounted
+     * (conversions then return NaN rather than throwing).
+     */
+    plotModeViewportFor() {
+        if (this.plotModeViewport)
+            return this.plotModeViewport;
+        const nan = { x: NaN, y: NaN };
+        const ct = () => this.host.coordTransform();
+        const ready = () => !!ct()?.isReady();
+        this.plotModeViewport = {
+            getOverlayContainer: () => this.host.overlayContainer(),
+            dataToClient: (x, y) => (ready() ? ct().dataToClient(x, y) : nan),
+            clientToData: (cx, cy) => (ready() ? ct().clientToData(cx, cy) : nan),
+            dataLengthToScreen: (len) => (ready() ? ct().dataLengthToScreen(len) : NaN),
+            isReady: ready,
+            // Both start with the current visible rect when the viewport is ready: a mode
+            // activates after the base render has gone idle, so without it an overlay
+            // following `frame$.subscribe(redraw)` would stay blank until the next pan/zoom.
+            frame$: this.withCurrentRect(this.frame$, ready),
+            settled$: this.withCurrentRect(this.viewportChange$, ready),
+            fitBounds: (rect, options) => {
+                const viewer = this.host.viewer();
+                if (!viewer || !ready() || !(rect.width > 0) || !(rect.height > 0))
+                    return;
+                const vpRect = imageRectToViewport(viewer, rect.x, rect.y, rect.width, rect.height);
+                viewer.viewport.fitBoundsWithConstraints(vpRect, !!options?.immediately);
+            },
+        };
+        return this.plotModeViewport;
+    }
+    /** `source`, preceded by the current visible rect for each subscriber (when ready). */
+    withCurrentRect(source, ready) {
+        return defer(() => {
+            const rect = ready() ? this.visibleImageRect() : null;
+            return rect ? source.pipe(startWith(rect)) : source.asObservable();
+        });
+    }
+    /**
+     * Keep the user's current view across a container/split resize instead of
+     * snapping home. Viewport bounds are image-relative (image width = 1), so
+     * they're independent of the container's pixel size — capture the visible
+     * region now and re-fit it once the new size has settled. OSD's autoResize
+     * fires asynchronously and the angular-split transition animates the width
+     * over a few hundred ms, so restore on the next frame and again after the
+     * transition completes.
+     */
+    keepViewAcrossResize() {
+        const vp = this.host.viewer()?.viewport;
+        if (!vp)
+            return;
+        const bounds = vp.getBounds(true);
+        const restore = () => quiet(() => {
+            this.host.viewer()?.viewport.fitBounds(bounds, true);
+            this.host.viewer()?.viewport.applyConstraints(true);
+        });
+        requestAnimationFrame(restore);
+        setTimeout(restore, 350);
+    }
+    goHome() {
+        this.host.viewer()?.viewport.goHome();
+    }
+    /** Zoom by one button step about the centre (`factor` > 1 zooms in). */
+    zoomBy(direction) {
+        const vp = this.host.viewer()?.viewport;
+        vp?.zoomBy(direction > 0 ? ZOOM_BUTTON_STEP : 1 / ZOOM_BUTTON_STEP);
+        vp?.applyConstraints();
+    }
+    /** Fit the OSD viewport to an image-space rectangle (coords ordered
+     *  [xMin, xMax, yMax, yMin]). */
+    applyZoomToBox(coordinates) {
+        const viewer = this.host.viewer();
+        if (!viewer || coordinates.length < 4)
+            return;
+        const [a, b, c, d] = coordinates;
+        const x = Math.min(a, b);
+        const w = Math.abs(b - a);
+        const y = Math.min(c, d);
+        const h = Math.abs(c - d);
+        if (w <= 0 || h <= 0)
+            return;
+        const rect = imageRectToViewport(viewer, x, y, w, h);
+        viewer.viewport.fitBounds(rect, false);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osd-viewport.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/osd-viewport.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject, defer } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport type * as OpenSeadragon from 'openseadragon';\n\nimport { quiet } from './osd-lib';\nimport { ZOOM_BUTTON_STEP } from './osd-zoom';\nimport { imageRectToViewport, viewportRectToImage } from './osd-coords';\nimport { OsdCoordinateTransform } from './osd-coordinate-transform';\nimport { PlotModeRect, PlotModeViewport } from '../../contracts/plot-type-contribution.contract';\nimport { TileDescriptor } from '../tile-server';\n\n/** The service state the viewport adapter reads — live, so it follows a viewer rebuild. */\nexport interface OsdViewportHost {\n  viewer(): OpenSeadragon.Viewer | null;\n  descriptor(): TileDescriptor | null;\n  coordTransform(): OsdCoordinateTransform | null;\n  overlayContainer(): HTMLElement | null;\n}\n\n/**\n * The OpenSeadragon viewport as the rest of the library sees it: the visible\n * image rect (settled, and per animation frame), the {@link PlotModeViewport} a\n * contributed plot mode draws over, and the zoom/fit commands.\n *\n * Every member reads the CURRENT viewer through the host, so one instance lives\n * as long as the service and stays valid across viewer rebuilds.\n */\nexport class OsdViewportAdapter {\n  /** Visible image region (full-image pixel coords) emitted when the view\n   *  settles, so the intensity inset can re-sample at the current zoom level. */\n  readonly viewportChange$ = new Subject<PlotModeRect>();\n  /** The visible rect on every redraw, coalesced to one emission per animation\n   *  frame. Feeds {@link PlotModeViewport.frame$}. */\n  private readonly frame$ = new Subject<PlotModeRect>();\n  private frameRaf: number | null = null;\n  private plotModeViewport: PlotModeViewport | null = null;\n\n  constructor(private readonly host: OsdViewportHost) {}\n\n  /** Compute the current viewport's image-pixel rectangle (clamped to the image)\n   *  and broadcast it. */\n  emitViewportChange(): void {\n    const rect = this.visibleImageRect();\n    if (rect) this.viewportChange$.next(rect);\n  }\n\n  /** The current viewport's image-pixel rectangle, clamped to the image, or\n   *  null when there is no laid-out viewport. */\n  visibleImageRect(): PlotModeRect | null {\n    const viewer = this.host.viewer();\n    const d = this.host.descriptor();\n    const vp = viewer?.viewport;\n    if (!vp || !d) return null;\n    try {\n      // Route through world item 0 (osd-coords): vp.viewportToImageRectangle is\n      // inaccurate and warns when the world holds multiple images (per-channel\n      // multichannel layers), which fed the intensity inset a wrong ROI.\n      const r = viewportRectToImage(viewer, vp.getBounds(true));\n      const iw = d.width,\n        ih = d.height;\n      const x = Math.max(0, Math.min(iw, r.x));\n      const y = Math.max(0, Math.min(ih, r.y));\n      const width = Math.max(1, Math.min(iw - x, r.width));\n      const height = Math.max(1, Math.min(ih - y, r.height));\n      return { x, y, width, height };\n    } catch {\n      return null; /* viewport not ready */\n    }\n  }\n\n  /**\n   * Image-pixel rectangle the drawer canvas currently covers. Unlike\n   * {@link visibleImageRect}, this is NOT clamped to the image bounds: the canvas\n   * maps 1:1 to the viewport rectangle, so leaving it unclamped keeps\n   * `canvasPx -> imagePx` an exact affine map (clamping would skew coordinates\n   * near the image edges). Routed through world item 0 (see\n   * {@link viewportRectToImage}) for multi-layer accuracy.\n   */\n  displayedSourceRect(): PlotModeRect | null {\n    const viewer = this.host.viewer();\n    const vp = viewer?.viewport;\n    if (!vp || !this.host.descriptor()) return null;\n    try {\n      const r = viewportRectToImage(viewer, vp.getBounds(true));\n      return { x: r.x, y: r.y, width: r.width, height: r.height };\n    } catch {\n      return null;\n    }\n  }\n\n  /** Coalesce redraws into one {@link frame$} emission per animation frame.\n   *  Skipped entirely while nothing listens. */\n  scheduleFrame(): void {\n    if (this.frameRaf !== null || !this.frame$.observed) return;\n    this.frameRaf = requestAnimationFrame(() => {\n      this.frameRaf = null;\n      const rect = this.visibleImageRect();\n      if (rect) this.frame$.next(rect);\n    });\n  }\n\n  /** Drop a pending {@link scheduleFrame} (the viewer is going away). */\n  cancelFrame(): void {\n    if (this.frameRaf !== null) {\n      cancelAnimationFrame(this.frameRaf);\n      this.frameRaf = null;\n    }\n  }\n\n  /**\n   * The viewport a contributed plot mode draws over. One stable object per\n   * service: every method reads the CURRENT viewer, so it stays valid across a\n   * viewer rebuild and reports `isReady() === false` while none is mounted\n   * (conversions then return NaN rather than throwing).\n   */\n  plotModeViewportFor(): PlotModeViewport {\n    if (this.plotModeViewport) return this.plotModeViewport;\n    const nan = { x: NaN, y: NaN };\n    const ct = () => this.host.coordTransform();\n    const ready = () => !!ct()?.isReady();\n    this.plotModeViewport = {\n      getOverlayContainer: () => this.host.overlayContainer(),\n      dataToClient: (x, y) => (ready() ? ct()!.dataToClient(x, y) : nan),\n      clientToData: (cx, cy) => (ready() ? ct()!.clientToData(cx, cy) : nan),\n      dataLengthToScreen: (len) => (ready() ? ct()!.dataLengthToScreen(len) : NaN),\n      isReady: ready,\n      // Both start with the current visible rect when the viewport is ready: a mode\n      // activates after the base render has gone idle, so without it an overlay\n      // following `frame$.subscribe(redraw)` would stay blank until the next pan/zoom.\n      frame$: this.withCurrentRect(this.frame$, ready),\n      settled$: this.withCurrentRect(this.viewportChange$, ready),\n      fitBounds: (rect, options) => {\n        const viewer = this.host.viewer();\n        if (!viewer || !ready() || !(rect.width > 0) || !(rect.height > 0)) return;\n        const vpRect = imageRectToViewport(viewer, rect.x, rect.y, rect.width, rect.height);\n        viewer.viewport.fitBoundsWithConstraints(vpRect, !!options?.immediately);\n      },\n    };\n    return this.plotModeViewport;\n  }\n\n  /** `source`, preceded by the current visible rect for each subscriber (when ready). */\n  private withCurrentRect(source: Subject<PlotModeRect>, ready: () => boolean): Observable<PlotModeRect> {\n    return defer(() => {\n      const rect = ready() ? this.visibleImageRect() : null;\n      return rect ? source.pipe(startWith(rect)) : source.asObservable();\n    });\n  }\n\n  /**\n   * Keep the user's current view across a container/split resize instead of\n   * snapping home. Viewport bounds are image-relative (image width = 1), so\n   * they're independent of the container's pixel size — capture the visible\n   * region now and re-fit it once the new size has settled. OSD's autoResize\n   * fires asynchronously and the angular-split transition animates the width\n   * over a few hundred ms, so restore on the next frame and again after the\n   * transition completes.\n   */\n  keepViewAcrossResize(): void {\n    const vp = this.host.viewer()?.viewport;\n    if (!vp) return;\n    const bounds = vp.getBounds(true);\n    const restore = () =>\n      quiet(() => {\n        this.host.viewer()?.viewport.fitBounds(bounds, true);\n        this.host.viewer()?.viewport.applyConstraints(true);\n      });\n    requestAnimationFrame(restore);\n    setTimeout(restore, 350);\n  }\n\n  goHome(): void {\n    this.host.viewer()?.viewport.goHome();\n  }\n\n  /** Zoom by one button step about the centre (`factor` > 1 zooms in). */\n  zoomBy(direction: 1 | -1): void {\n    const vp = this.host.viewer()?.viewport;\n    vp?.zoomBy(direction > 0 ? ZOOM_BUTTON_STEP : 1 / ZOOM_BUTTON_STEP);\n    vp?.applyConstraints();\n  }\n\n  /** Fit the OSD viewport to an image-space rectangle (coords ordered\n   *  [xMin, xMax, yMax, yMin]). */\n  applyZoomToBox(coordinates: number[]): void {\n    const viewer = this.host.viewer();\n    if (!viewer || coordinates.length < 4) return;\n    const [a, b, c, d] = coordinates;\n    const x = Math.min(a, b);\n    const w = Math.abs(b - a);\n    const y = Math.min(c, d);\n    const h = Math.abs(c - d);\n    if (w <= 0 || h <= 0) return;\n    const rect = imageRectToViewport(viewer, x, y, w, h);\n    viewer.viewport.fitBounds(rect, false);\n  }\n}\n"]}

package/esm2022/lib/implementations/osd/osd-zoom.mjs

@@ -17,4 +17,10 @@
  * zoom visibly changing pace when a tool is picked up is the bug this constant prevents.
  */
 export const OSD_ZOOM_PER_SCROLL = 1.03;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3NkLXpvb20uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2ltcGxlbWVudGF0aW9ucy9vc2Qvb3NkLXpvb20udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBXaGVlbC16b29tIHN0ZXAgZm9yIHRoZSBPcGVuU2VhZHJhZ29uIGJhY2tlbmQuXG4gKlxuICogQXBwbGllZCBwZXIgc2Nyb2xsIEVWRU5ULCBub3QgcGVyIHVuaXQgb2YgZGVsdGEg4oCUIHdoaWNoIGlzIHdoYXQgT3BlblNlYWRyYWdvbidzIG93blxuICogYHpvb21QZXJTY3JvbGxgIGRvZXMsIGFuZCB3aGF0IHRoZSByZWdpb24gb3ZlcmxheSBkb2VzIHdoZW4gYW4gYWN0aXZlIHRvb2wgaGFzIHRha2VuIHRoZSB3aGVlbFxuICogb3Zlci4gVGhhdCBtYWtlcyB0aGUgc3RlcCBjb21wb3VuZCB3aXRoIHRoZSBudW1iZXIgb2YgZXZlbnRzIGEgZGV2aWNlIHNlbmRzOiBhIG1vdXNlIG5vdGNoIGlzXG4gKiBvbmUgZXZlbnQsIGJ1dCBhIHRyYWNrcGFkIHN3aXBlIGlzIGEgYnVyc3Qgb2YgdGhlbSwgc28gYSBzdGVwIHRoYXQgZmVlbHMgcmlnaHQgZm9yIGEgbW91c2UgcnVuc1xuICogYXdheSB1bmRlciBhIHRyYWNrcGFkLlxuICpcbiAqIEF0IHRoZSBwcmV2aW91cyAxLjEgKE9wZW5TZWFkcmFnb24ncyBkZWZhdWx0IGlzIDEuMikgYW4gaW1hZ2UgZG91YmxlZCBpbiA3IG5vdGNoZXMsIGFnYWluc3QgdGhlXG4gKiB+MjQgdGhlIG5hcGFyaS1qcyBiYWNrZW5kIHRvb2sgZm9yIHRoZSBzYW1lIHBpY3R1cmUg4oCUIHRoZSBzYW1lIGdlc3R1cmUgem9vbWVkIHNldmVyYWwgdGltZXNcbiAqIGZ1cnRoZXIgZGVwZW5kaW5nIG9ubHkgb24gd2hpY2ggcmVuZGVyZXIgd2FzIGFjdGl2ZS4gMS4wMyBwdXRzIHRoZSB0d28gd2l0aGluIGEgd2hpc2tlciBvZiBlYWNoXG4gKiBvdGhlciwgc28gdGhlIHdoZWVsIGZlZWxzIHRoZSBzYW1lIHdoaWNoZXZlciBiYWNrZW5kIGlzIGRyYXdpbmcuXG4gKlxuICogU2hhcmVkIGJlY2F1c2UgdGhlIHZpZXdlciBvcHRpb24gYW5kIHRoZSBvdmVybGF5J3MgaGFuZGxlciBNVVNUIGFncmVlOiB3aGV0aGVyIHRoZSB3aGVlbCBpc1xuICogaGFuZGxlZCBieSBPcGVuU2VhZHJhZ29uIG9yIGJ5IHRoZSBvdmVybGF5IGRlcGVuZHMgb24gd2hldGhlciBhIHJlZ2lvbiB0b29sIGlzIGFjdGl2ZSwgYW5kIHRoZVxuICogem9vbSB2aXNpYmx5IGNoYW5naW5nIHBhY2Ugd2hlbiBhIHRvb2wgaXMgcGlja2VkIHVwIGlzIHRoZSBidWcgdGhpcyBjb25zdGFudCBwcmV2ZW50cy5cbiAqL1xuZXhwb3J0IGNvbnN0IE9TRF9aT09NX1BFUl9TQ1JPTEwgPSAxLjAzO1xuIl19
+/**
+ * Zoom factor per zoom-button press / +/- key, shared by every backend (OpenSeadragon, napari-js
+ * and Plotly's axis-range zoom) so a button press zooms the same amount whichever renderer is
+ * drawing. Unlike {@link OSD_ZOOM_PER_SCROLL} it is one deliberate step per press, not per event.
+ */
+export const ZOOM_BUTTON_STEP = 1.3;
+//# sourceMappingURL=data:application/json;base64,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