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

package/esm2022/lib/implementations/napari-js/spatial-tiles/layer-groups.mjs

@@ -0,0 +1,165 @@
+/**
+ * Bottom to top: cell fill, cell outline, nucleus outline, the transcript density, then the
+ * transcripts. The density goes OVER the service's observation markers on purpose: under 10^5
+ * dots it would only show in the gaps between cells.
+ */
+export const TILE_LAYER_ORDER = [
+    'cellFill',
+    'cellOutline',
+    'nucleusOutline',
+    'density',
+    'transcripts',
+];
+/**
+ * One napari-js layer per named group, kept in a fixed bottom-to-top order, plus what each
+ * group currently shows (its key), so an unchanged plan is a no-op.
+ *
+ * Order is kept with `LayerList.move`, which restacks a layer without disposing its GPU visual
+ * (a remove + re-add would re-upload its whole buffer, review NAPARI-BOUNDARY-11). A plan still
+ * restores the order once, after all its groups are in place, and moves only the layers that
+ * are out of place ({@link restoreOrder}).
+ */
+export class OrderedLayerGroups {
+    constructor(order) {
+        this.order = order;
+        this.current = null;
+        this.layers = new Map();
+        /** What each group currently shows, so an unchanged plan is a no-op. */
+        this.keys = new Map();
+    }
+    /** The viewer the groups are drawn into, while attached. */
+    get viewer() {
+        return this.current;
+    }
+    attach(viewer) {
+        this.current = viewer;
+    }
+    /** Remove every group's layer from the viewer and forget the layers, keys and viewer. */
+    detach() {
+        if (this.current) {
+            for (const layer of this.layers.values()) {
+                if (this.current.layers.items.includes(layer))
+                    this.current.layers.remove(layer);
+            }
+        }
+        this.layers.clear();
+        this.keys.clear();
+        this.current = null;
+    }
+    /** Whether `group` has a layer (on screen or not). */
+    has(group) {
+        return this.layers.has(group);
+    }
+    /** `group`'s layer (on screen or not), if it has one. */
+    layer(group) {
+        return this.layers.get(group);
+    }
+    /** Whether `group`'s layer is in the viewer now. */
+    shown(group) {
+        const layer = this.layers.get(group);
+        return !!layer && !!this.current?.layers.items.includes(layer);
+    }
+    /** What `group` currently shows, as its plan keyed it. */
+    key(group) {
+        return this.keys.get(group);
+    }
+    setKey(group, key) {
+        this.keys.set(group, key);
+    }
+    /** Forget what `group` shows, so the next plan redraws it. */
+    forgetKey(group) {
+        this.keys.delete(group);
+    }
+    /** Whether `layer` is one of the groups' layers. */
+    owns(layer) {
+        for (const l of this.layers.values())
+            if (l === layer)
+                return true;
+        return false;
+    }
+    /**
+     * Put a shapes layer in place for `group`: a geometry change builds a new layer, a
+     * colour-only change mutates the per-shape colours or values/colormap of the existing one.
+     */
+    upsertShapes(group, wanted, geometryChanged, rings, opts) {
+        if (!wanted) {
+            this.drop(group);
+            return;
+        }
+        const existing = this.layers.get(group);
+        if (existing && !geometryChanged && this.current.layers.items.includes(existing)) {
+            // Per-shape colours win over values; clearing them hands the layer back to values/colormap.
+            existing.faceColor = opts.faceColor ?? null;
+            // Flat colour has no values; clearing them is what switches the layer to `color`.
+            existing.values = opts.values ?? null;
+            if (opts.colormap)
+                existing.colormap = opts.colormap;
+            if (opts.contrastLimits)
+                existing.contrastLimits = opts.contrastLimits;
+            if (opts.color)
+                existing.color = opts.color;
+            if (opts.opacity !== undefined)
+                existing.opacity = opts.opacity;
+            this.current.requestRender();
+            return;
+        }
+        const layer = this.current.addShapes(rings.coords, rings.offsets, opts);
+        this.replace(group, layer);
+    }
+    /**
+     * Install `layer` as `group`'s layer. The layer was just added by the caller, so it is on
+     * top: the plan puts the groups that belong above it back in place once it is done
+     * ({@link restoreOrder}), rather than after every replaced group.
+     */
+    replace(group, layer) {
+        const v = this.current;
+        const old = this.layers.get(group);
+        if (old && old !== layer && v.layers.items.includes(old))
+            v.layers.remove(old);
+        this.layers.set(group, layer);
+        v.requestRender();
+    }
+    /**
+     * Put the groups' layers in order, moving to the top only from the first one out of place
+     * (and, with `aboveOthers`, the first one under a layer that is not ours — the service's
+     * markers). Everything before that is already where it belongs. A move keeps each layer
+     * mounted (no `removed`/`added`), so nothing is re-uploaded.
+     */
+    restoreOrder(aboveOthers) {
+        const v = this.current;
+        if (!v)
+            return;
+        const items = v.layers.items;
+        const wanted = this.order.map((g) => this.layers.get(g)).filter((l) => !!l && items.includes(l));
+        const ours = new Set(wanted);
+        let lastOther = -1;
+        if (aboveOthers)
+            items.forEach((l, i) => {
+                if (!ours.has(l))
+                    lastOther = i;
+            });
+        const current = items.filter((l) => ours.has(l));
+        let k = 0;
+        while (k < wanted.length && current[k] === wanted[k] && items.indexOf(wanted[k]) > lastOther)
+            k++;
+        if (k === wanted.length)
+            return;
+        for (const layer of wanted.slice(k))
+            v.layers.move(layer, items.length - 1);
+        v.requestRender();
+    }
+    /** Remove `group`'s layer and forget its key. */
+    drop(group) {
+        const layer = this.layers.get(group);
+        if (layer && this.current?.layers.items.includes(layer))
+            this.current.layers.remove(layer);
+        this.layers.delete(group);
+        this.keys.delete(group);
+    }
+    /** Drop every group. */
+    dropAll() {
+        for (const g of this.order)
+            this.drop(g);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layer-groups.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/spatial-tiles/layer-groups.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAyB;IACpD,UAAU;IACV,aAAa;IACb,gBAAgB;IAChB,SAAS;IACT,aAAa;CACd,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,OAAO,kBAAkB;IAM7B,YAA6B,KAAmB;QAAnB,UAAK,GAAL,KAAK,CAAc;QALxC,YAAO,GAAkB,IAAI,CAAC;QACrB,WAAM,GAAG,IAAI,GAAG,EAAY,CAAC;QAC9C,wEAAwE;QACvD,SAAI,GAAG,IAAI,GAAG,EAAa,CAAC;IAEM,CAAC;IAEpD,4DAA4D;IAC5D,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,MAAM,CAAC,MAAc;QACnB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,yFAAyF;IACzF,MAAM;QACJ,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;gBACzC,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;oBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACnF,CAAC;QACH,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QAClB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,sDAAsD;IACtD,GAAG,CAAC,KAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED,yDAAyD;IACzD,KAAK,CAAC,KAAQ;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED,oDAAoD;IACpD,KAAK,CAAC,KAAQ;QACZ,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrC,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACjE,CAAC;IAED,0DAA0D;IAC1D,GAAG,CAAC,KAAQ;QACV,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,CAAC,KAAQ,EAAE,GAAW;QAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC5B,CAAC;IAED,8DAA8D;IAC9D,SAAS,CAAC,KAAQ;QAChB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED,oDAAoD;IACpD,IAAI,CAAC,KAAY;QACf,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,CAAC,KAAK,KAAK;gBAAE,OAAO,IAAI,CAAC;QACnE,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACH,YAAY,CACV,KAAQ,EACR,MAAe,EACf,eAAwB,EACxB,KAAsB,EACtB,IAAiD;QAEjD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAA4B,CAAC;QACnE,IAAI,QAAQ,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,OAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClF,4FAA4F;YAC5F,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;YAC5C,kFAAkF;YAClF,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC;YACtC,IAAI,IAAI,CAAC,QAAQ;gBAAE,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;YACrD,IAAI,IAAI,CAAC,cAAc;gBAAE,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;YACvE,IAAI,IAAI,CAAC,KAAK;gBAAE,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YAC5C,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;gBAAE,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;YAChE,IAAI,CAAC,OAAQ,CAAC,aAAa,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACzE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,KAAQ,EAAE,KAAY;QAC5B,MAAM,CAAC,GAAG,IAAI,CAAC,OAAQ,CAAC;QACxB,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,GAAG,IAAI,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC/E,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9B,CAAC,CAAC,aAAa,EAAE,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,WAAoB;QAC/B,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QACvB,IAAI,CAAC,CAAC;YAAE,OAAO;QACf,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAc,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7G,MAAM,IAAI,GAAG,IAAI,GAAG,CAAQ,MAAM,CAAC,CAAC;QACpC,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC;QACnB,IAAI,WAAW;YACb,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;gBACrB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;oBAAE,SAAS,GAAG,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;QACL,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACjD,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;YAAE,CAAC,EAAE,CAAC;QAClG,IAAI,CAAC,KAAK,MAAM,CAAC,MAAM;YAAE,OAAO;QAChC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YAAE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC5E,CAAC,CAAC,aAAa,EAAE,CAAC;IACpB,CAAC;IAED,iDAAiD;IACjD,IAAI,CAAC,KAAQ;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3F,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED,wBAAwB;IACxB,OAAO;QACL,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK;YAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC3C,CAAC;CACF","sourcesContent":["import type { Layer, ShapesLayer, Viewer } from 'napari-js';\n\nimport type { SpatialPolygons } from '../../../contracts/spatial-dataset.contract';\n\n/** The layer groups of the 2D spatial tile view. */\nexport type TileGroup = 'density' | 'cellFill' | 'cellOutline' | 'nucleusOutline' | 'transcripts';\n\n/**\n * Bottom to top: cell fill, cell outline, nucleus outline, the transcript density, then the\n * transcripts. The density goes OVER the service's observation markers on purpose: under 10^5\n * dots it would only show in the gaps between cells.\n */\nexport const TILE_LAYER_ORDER: readonly TileGroup[] = [\n  'cellFill',\n  'cellOutline',\n  'nucleusOutline',\n  'density',\n  'transcripts',\n];\n\n/**\n * One napari-js layer per named group, kept in a fixed bottom-to-top order, plus what each\n * group currently shows (its key), so an unchanged plan is a no-op.\n *\n * Order is kept with `LayerList.move`, which restacks a layer without disposing its GPU visual\n * (a remove + re-add would re-upload its whole buffer, review NAPARI-BOUNDARY-11). A plan still\n * restores the order once, after all its groups are in place, and moves only the layers that\n * are out of place ({@link restoreOrder}).\n */\nexport class OrderedLayerGroups<G extends string> {\n  private current: Viewer | null = null;\n  private readonly layers = new Map<G, Layer>();\n  /** What each group currently shows, so an unchanged plan is a no-op. */\n  private readonly keys = new Map<G, string>();\n\n  constructor(private readonly order: readonly G[]) {}\n\n  /** The viewer the groups are drawn into, while attached. */\n  get viewer(): Viewer | null {\n    return this.current;\n  }\n\n  attach(viewer: Viewer): void {\n    this.current = viewer;\n  }\n\n  /** Remove every group's layer from the viewer and forget the layers, keys and viewer. */\n  detach(): void {\n    if (this.current) {\n      for (const layer of this.layers.values()) {\n        if (this.current.layers.items.includes(layer)) this.current.layers.remove(layer);\n      }\n    }\n    this.layers.clear();\n    this.keys.clear();\n    this.current = null;\n  }\n\n  /** Whether `group` has a layer (on screen or not). */\n  has(group: G): boolean {\n    return this.layers.has(group);\n  }\n\n  /** `group`'s layer (on screen or not), if it has one. */\n  layer(group: G): Layer | undefined {\n    return this.layers.get(group);\n  }\n\n  /** Whether `group`'s layer is in the viewer now. */\n  shown(group: G): boolean {\n    const layer = this.layers.get(group);\n    return !!layer && !!this.current?.layers.items.includes(layer);\n  }\n\n  /** What `group` currently shows, as its plan keyed it. */\n  key(group: G): string | undefined {\n    return this.keys.get(group);\n  }\n\n  setKey(group: G, key: string): void {\n    this.keys.set(group, key);\n  }\n\n  /** Forget what `group` shows, so the next plan redraws it. */\n  forgetKey(group: G): void {\n    this.keys.delete(group);\n  }\n\n  /** Whether `layer` is one of the groups' layers. */\n  owns(layer: Layer): boolean {\n    for (const l of this.layers.values()) if (l === layer) return true;\n    return false;\n  }\n\n  /**\n   * Put a shapes layer in place for `group`: a geometry change builds a new layer, a\n   * colour-only change mutates the per-shape colours or values/colormap of the existing one.\n   */\n  upsertShapes(\n    group: G,\n    wanted: boolean,\n    geometryChanged: boolean,\n    rings: SpatialPolygons,\n    opts: Parameters<Viewer['addShapes']>[2] & object,\n  ): void {\n    if (!wanted) {\n      this.drop(group);\n      return;\n    }\n    const existing = this.layers.get(group) as ShapesLayer | undefined;\n    if (existing && !geometryChanged && this.current!.layers.items.includes(existing)) {\n      // Per-shape colours win over values; clearing them hands the layer back to values/colormap.\n      existing.faceColor = opts.faceColor ?? null;\n      // Flat colour has no values; clearing them is what switches the layer to `color`.\n      existing.values = opts.values ?? null;\n      if (opts.colormap) existing.colormap = opts.colormap;\n      if (opts.contrastLimits) existing.contrastLimits = opts.contrastLimits;\n      if (opts.color) existing.color = opts.color;\n      if (opts.opacity !== undefined) existing.opacity = opts.opacity;\n      this.current!.requestRender();\n      return;\n    }\n    const layer = this.current!.addShapes(rings.coords, rings.offsets, opts);\n    this.replace(group, layer);\n  }\n\n  /**\n   * Install `layer` as `group`'s layer. The layer was just added by the caller, so it is on\n   * top: the plan puts the groups that belong above it back in place once it is done\n   * ({@link restoreOrder}), rather than after every replaced group.\n   */\n  replace(group: G, layer: Layer): void {\n    const v = this.current!;\n    const old = this.layers.get(group);\n    if (old && old !== layer && v.layers.items.includes(old)) v.layers.remove(old);\n    this.layers.set(group, layer);\n    v.requestRender();\n  }\n\n  /**\n   * Put the groups' layers in order, moving to the top only from the first one out of place\n   * (and, with `aboveOthers`, the first one under a layer that is not ours — the service's\n   * markers). Everything before that is already where it belongs. A move keeps each layer\n   * mounted (no `removed`/`added`), so nothing is re-uploaded.\n   */\n  restoreOrder(aboveOthers: boolean): void {\n    const v = this.current;\n    if (!v) return;\n    const items = v.layers.items;\n    const wanted = this.order.map((g) => this.layers.get(g)).filter((l): l is Layer => !!l && items.includes(l));\n    const ours = new Set<Layer>(wanted);\n    let lastOther = -1;\n    if (aboveOthers)\n      items.forEach((l, i) => {\n        if (!ours.has(l)) lastOther = i;\n      });\n    const current = items.filter((l) => ours.has(l));\n    let k = 0;\n    while (k < wanted.length && current[k] === wanted[k] && items.indexOf(wanted[k]) > lastOther) k++;\n    if (k === wanted.length) return;\n    for (const layer of wanted.slice(k)) v.layers.move(layer, items.length - 1);\n    v.requestRender();\n  }\n\n  /** Remove `group`'s layer and forget its key. */\n  drop(group: G): void {\n    const layer = this.layers.get(group);\n    if (layer && this.current?.layers.items.includes(layer)) this.current.layers.remove(layer);\n    this.layers.delete(group);\n    this.keys.delete(group);\n  }\n\n  /** Drop every group. */\n  dropAll(): void {\n    for (const g of this.order) this.drop(g);\n  }\n}\n"]}

package/esm2022/lib/implementations/napari-js/spatial-tiles/plan-context.mjs

@@ -0,0 +1,78 @@
+/**
+ * Loads in flight, per layer label ("Transcripts", "Cells"…), for the canvas loading badge.
+ * Shared by every plan: a label stays reported while any plan still loads it.
+ */
+export class LoadTracker {
+    constructor(changed) {
+        this.changed = changed;
+        this.loading = new Map();
+    }
+    /** Report `label` loading while `work` is in flight. */
+    async track(label, work) {
+        this.loading.set(label, (this.loading.get(label) ?? 0) + 1);
+        this.changed([...this.loading.keys()]);
+        try {
+            return await work;
+        }
+        finally {
+            const n = (this.loading.get(label) ?? 1) - 1;
+            if (n > 0)
+                this.loading.set(label, n);
+            else
+                this.loading.delete(label);
+            this.changed([...this.loading.keys()]);
+        }
+    }
+    /** Forget every load (the viewer went away) and report none. */
+    clear() {
+        this.loading.clear();
+        this.changed([]);
+    }
+}
+/**
+ * One run of `NapariSpatialTileLayers.plan()`. Completeness belongs to the run that did the
+ * fetching: on the instance, a superseded run's failed tile marked the CURRENT run incomplete,
+ * which then skipped caching its keys and retried for nothing (review NAPARI-BOUNDARY-9).
+ */
+export class PlanContext {
+    /** `isStale` turns true once a newer plan started or the viewer changed. */
+    constructor(isStale, loads) {
+        this.isStale = isStale;
+        this.loads = loads;
+        this.failed = false;
+    }
+    /** True once a newer plan started or the viewer changed. */
+    stale() {
+        return this.isStale();
+    }
+    /** Set when a fetch of this run failed (see fetchAll): don't cache it as done; retry. */
+    get incomplete() {
+        return this.failed;
+    }
+    /** A request of this run failed: what it drew must not be cached as done. */
+    markIncomplete() {
+        this.failed = true;
+    }
+    /** Report `label` loading while `work` is in flight. */
+    track(label, work) {
+        return this.loads.track(label, work);
+    }
+    /**
+     * Fetch every tile, drawing what arrived. A failure does not fail the view, but it marks this
+     * run incomplete: the caller must not cache it as done, and `plan()` retries it.
+     */
+    async fetchAll(keys, load) {
+        const settled = await Promise.allSettled(keys.map(load));
+        const out = [];
+        for (const s of settled) {
+            if (s.status === 'fulfilled')
+                out.push(s.value);
+            else
+                console.warn('[napari-js] spatial tile failed', s.reason);
+        }
+        if (out.length < keys.length)
+            this.markIncomplete();
+        return out;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/napari-js/spatial-tiles/transcript-hover.mjs

@@ -0,0 +1,182 @@
+import { NO_CATEGORY, NO_OBSERVATION, } from '../../../contracts/spatial-dataset.contract';
+/**
+ * Tooltips for the transcript markers of the 2D spatial view.
+ *
+ * Reads only what the transcript layer last drew — handed over one way through
+ * {@link setDrawn} / {@link setTypes} — and asks the server for the slower details (distinct
+ * genes in a group, its top genes and cells, the cell's display id) once the pointer has
+ * rested on a marker, caching them until the next draw.
+ */
+export class TranscriptHover {
+    /** `layerShown` says whether the transcript layer is on screen now (it may have been dropped). */
+    constructor(port, layerShown) {
+        this.port = port;
+        this.layerShown = layerShown;
+        /** What the transcript layer currently shows (written by drawing, read by hover). */
+        this.drawn = null;
+        /** The cell-type column, to name the cell a marker is in. */
+        this.types = null;
+        /** µm per observation unit of the drawn dataset, for describing a grouped marker's area. */
+        this.micronsPerUnit = null;
+        /** Details already fetched, by hovered entry. */
+        this.cache = new Map();
+        this.key = null;
+        this.timer = null;
+    }
+    /** The transcript layer was redrawn: hover names these entries now (cached details are dropped). */
+    setDrawn(drawn, micronsPerUnit) {
+        this.drawn = drawn;
+        this.cache.clear();
+        this.micronsPerUnit = micronsPerUnit;
+    }
+    /** The cell-type column the drawn entries' cells are named by, or null. */
+    setTypes(types) {
+        this.types = types;
+    }
+    /** Nothing is drawn any more. */
+    clear() {
+        this.drawn = null;
+    }
+    /** Stop a pending details request and forget what was drawn. */
+    dispose() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.drawn = null;
+    }
+    /**
+     * Tooltip lines for the transcript marker under world point `(wx, wy)`, or null.
+     *
+     * The marker is napari-js's pick on the drawn layer: hit anywhere on it, or within
+     * `radiusWorld` of its centre when it is smaller than that, the NEAREST centre winning
+     * among several (an exact tie, such as two genes' groups on one bin centre, goes to the one
+     * drawn on top). Returns what is known at once (gene, count, cell type); anything that needs
+     * the server — distinct genes in a group, its top genes and cells, the cell's display id —
+     * arrives through `onDetails` once the pointer has rested on the marker briefly.
+     */
+    hoverAt(wx, wy, radiusWorld, onDetails) {
+        const d = this.drawn;
+        if (!d || !this.layerShown() || !d.merged.count) {
+            this.key = null;
+            return null;
+        }
+        const i = d.layer.pick(wx, wy, { tolerance: radiusWorld, tieBreak: 'nearest' });
+        if (i < 0) {
+            this.key = null;
+            return null;
+        }
+        const key = `${d.kind}|${d.merged.x[i]}|${d.merged.y[i]}|${d.merged.gene[i]}`;
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        if (key !== this.key) {
+            this.key = key;
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.timer = setTimeout(() => void this.fetchDetails(d, i, key, onDetails), 150);
+        }
+        return this.describe(d, i, null);
+    }
+    async fetchDetails(d, i, key, onDetails) {
+        if (!this.port.getTranscriptSummary || this.key !== key)
+            return;
+        const obs = d.merged.observation[i];
+        const cells = obs === NO_OBSERVATION ? [] : [obs];
+        let box;
+        if ((d.kind === 'bins' || d.kind === 'genes') && d.bin) {
+            const { size, origin } = d.bin;
+            const bx = Math.floor((d.merged.x[i] - origin[0]) / size);
+            const by = Math.floor((d.merged.y[i] - origin[1]) / size);
+            const x0 = origin[0] + bx * size;
+            const y0 = origin[1] + by * size;
+            box = [x0, y0, x0 + size, y0 + size];
+        }
+        else if (d.kind === 'individual') {
+            const e = 0.02;
+            box = [d.merged.x[i] - e, d.merged.y[i] - e, d.merged.x[i] + e, d.merged.y[i] + e];
+        }
+        const genes = d.groupGenes && d.entryGroup ? d.groupGenes[d.entryGroup[i]] : undefined;
+        try {
+            const summary = await this.port.getTranscriptSummary({ box, cells, ...(genes ? { genes } : {}) });
+            const lines = this.describe(d, i, summary);
+            this.cache.set(key, lines);
+            if (this.key === key)
+                onDetails(lines);
+        }
+        catch (err) {
+            console.warn('[napari-js] transcript details unavailable', err);
+        }
+    }
+    /** The tooltip text for entry `i`, with the server's details when they have arrived. */
+    describe(d, i, s) {
+        const t = d.merged;
+        const n = t.weight[i];
+        const obs = t.observation[i];
+        const fmt = (v) => v.toLocaleString();
+        const typeOf = (o) => {
+            const types = this.types;
+            if (!types || o === NO_OBSERVATION || types.meta.kind !== 'categorical')
+                return null;
+            const c = types.codes[o];
+            return c === NO_CATEGORY ? null : (types.meta.categories[c] ?? null);
+        };
+        const cellLine = (o, prefix) => {
+            if (o === NO_OBSERVATION)
+                return 'outside any cell';
+            const id = s?.cellIds?.[o] ?? `#${o}`;
+            const type = typeOf(o);
+            return `${prefix} ${id}${type ? ` · ${type}` : ''}`;
+        };
+        if (d.kind === 'bins') {
+            const lines = [`${fmt(n)} transcripts · all genes`];
+            if (d.bin)
+                lines.push(`${d.bin.size.toFixed(1)} × ${d.bin.size.toFixed(1)} µm area`);
+            if (s?.transcripts !== undefined) {
+                lines.push(`${fmt(s.genes ?? 0)} distinct genes · ${fmt(s.cells ?? 0)} cell${s.cells === 1 ? '' : 's'}` +
+                    (s.unassigned ? ` · ${fmt(s.unassigned)} outside cells` : ''));
+                if (s.topGenes?.length) {
+                    lines.push(`top genes: ${s.topGenes
+                        .slice(0, 5)
+                        .map((g) => `${g.name} ${fmt(g.count)}`)
+                        .join(', ')}`);
+                }
+            }
+            lines.push(cellLine(obs, 'mostly cell'));
+            if (!s && this.port.getTranscriptSummary)
+                lines.push('loading details…');
+            return lines;
+        }
+        if (d.kind === 'individual') {
+            const gene = s?.topGenes?.[0]?.name;
+            return [
+                gene ? `${gene} transcript` : 'Transcript',
+                cellLine(obs, 'in cell'),
+                ...(!s && this.port.getTranscriptSummary ? ['loading details…'] : []),
+            ];
+        }
+        const gene = d.genes[t.gene[i]] ?? 'transcript';
+        if (d.bin) {
+            const um = d.bin.size * (this.micronsPerUnit ?? 1);
+            const group = d.entryGroup && d.groupNames ? d.groupNames[d.entryGroup[i]] : gene;
+            const top = s?.topGenes?.length
+                ? [
+                    s.topGenes
+                        .slice(0, 6)
+                        .map((g) => `${g.name} ${fmt(g.count)}`)
+                        .join(', '),
+                ]
+                : [];
+            return [
+                `${group} · ${fmt(n)} transcript${n === 1 ? '' : 's'}`,
+                ...(d.groupGenes ? top : group !== gene ? [`mostly ${gene}`] : []),
+                `${um.toFixed(1)} × ${um.toFixed(1)} µm area · zoom in to split`,
+                ...(obs === NO_OBSERVATION && d.groupGenes ? [] : [cellLine(obs, 'mostly cell')]),
+                ...(!s && d.groupGenes && this.port.getTranscriptSummary ? ['loading details…'] : []),
+            ];
+        }
+        return n > 1
+            ? [`${gene} · ${fmt(n)} transcripts`, 'grouped: zoom in to split', cellLine(obs, 'near cell')]
+            : [`${gene} transcript`, cellLine(obs, 'in cell')];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transcript-hover.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/spatial-tiles/transcript-hover.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PointsLayer } from 'napari-js';\n\nimport type { SpatialDataPort } from '../../../contracts/ports/spatial-data.port';\nimport {\n  NO_CATEGORY,\n  NO_OBSERVATION,\n  SpatialTranscriptSummary,\n  SpatialTranscriptTile,\n} from '../../../contracts/spatial-dataset.contract';\nimport type { CategoricalCodes } from './categorical-lookup';\n\n/** What one transcript entry is — decides what hovering it says. */\nexport type TranscriptKind = 'genes' | 'individual' | 'bins';\n\n/** A bin grid: its size and origin, so a hovered bin's square can be recovered. */\nexport interface TranscriptBin {\n  size: number;\n  origin: [number, number];\n}\n\n/**\n * Tooltips for the transcript markers of the 2D spatial view.\n *\n * Reads only what the transcript layer last drew — handed over one way through\n * {@link setDrawn} / {@link setTypes} — and asks the server for the slower details (distinct\n * genes in a group, its top genes and cells, the cell's display id) once the pointer has\n * rested on a marker, caching them until the next draw.\n */\nexport class TranscriptHover {\n  /** What the transcript layer currently shows (written by drawing, read by hover). */\n  private drawn: DrawnTranscripts | null = null;\n  /** The cell-type column, to name the cell a marker is in. */\n  private types: CategoricalCodes | null = null;\n  /** µm per observation unit of the drawn dataset, for describing a grouped marker's area. */\n  private micronsPerUnit: number | null = null;\n  /** Details already fetched, by hovered entry. */\n  private readonly cache = new Map<string, string[]>();\n  private key: string | null = null;\n  private timer: ReturnType<typeof setTimeout> | null = null;\n\n  /** `layerShown` says whether the transcript layer is on screen now (it may have been dropped). */\n  constructor(\n    private readonly port: SpatialDataPort,\n    private readonly layerShown: () => boolean,\n  ) {}\n\n  /** The transcript layer was redrawn: hover names these entries now (cached details are dropped). */\n  setDrawn(drawn: DrawnTranscripts, micronsPerUnit: number | null): void {\n    this.drawn = drawn;\n    this.cache.clear();\n    this.micronsPerUnit = micronsPerUnit;\n  }\n\n  /** The cell-type column the drawn entries' cells are named by, or null. */\n  setTypes(types: CategoricalCodes | null): void {\n    this.types = types;\n  }\n\n  /** Nothing is drawn any more. */\n  clear(): void {\n    this.drawn = null;\n  }\n\n  /** Stop a pending details request and forget what was drawn. */\n  dispose(): void {\n    if (this.timer) clearTimeout(this.timer);\n    this.timer = null;\n    this.drawn = null;\n  }\n\n  /**\n   * Tooltip lines for the transcript marker under world point `(wx, wy)`, or null.\n   *\n   * The marker is napari-js's pick on the drawn layer: hit anywhere on it, or within\n   * `radiusWorld` of its centre when it is smaller than that, the NEAREST centre winning\n   * among several (an exact tie, such as two genes' groups on one bin centre, goes to the one\n   * drawn on top). Returns what is known at once (gene, count, cell type); anything that needs\n   * the server — distinct genes in a group, its top genes and cells, the cell's display id —\n   * arrives through `onDetails` once the pointer has rested on the marker briefly.\n   */\n  hoverAt(wx: number, wy: number, radiusWorld: number, onDetails: (lines: string[]) => void): string[] | null {\n    const d = this.drawn;\n    if (!d || !this.layerShown() || !d.merged.count) {\n      this.key = null;\n      return null;\n    }\n    const i = d.layer.pick(wx, wy, { tolerance: radiusWorld, tieBreak: 'nearest' });\n    if (i < 0) {\n      this.key = null;\n      return null;\n    }\n    const key = `${d.kind}|${d.merged.x[i]}|${d.merged.y[i]}|${d.merged.gene[i]}`;\n    const cached = this.cache.get(key);\n    if (cached) return cached;\n    if (key !== this.key) {\n      this.key = key;\n      if (this.timer) clearTimeout(this.timer);\n      this.timer = setTimeout(() => void this.fetchDetails(d, i, key, onDetails), 150);\n    }\n    return this.describe(d, i, null);\n  }\n\n  private async fetchDetails(\n    d: DrawnTranscripts,\n    i: number,\n    key: string,\n    onDetails: (lines: string[]) => void,\n  ): Promise<void> {\n    if (!this.port.getTranscriptSummary || this.key !== key) return;\n    const obs = d.merged.observation[i];\n    const cells = obs === NO_OBSERVATION ? [] : [obs];\n    let box: [number, number, number, number] | undefined;\n    if ((d.kind === 'bins' || d.kind === 'genes') && d.bin) {\n      const { size, origin } = d.bin;\n      const bx = Math.floor((d.merged.x[i] - origin[0]) / size);\n      const by = Math.floor((d.merged.y[i] - origin[1]) / size);\n      const x0 = origin[0] + bx * size;\n      const y0 = origin[1] + by * size;\n      box = [x0, y0, x0 + size, y0 + size];\n    } else if (d.kind === 'individual') {\n      const e = 0.02;\n      box = [d.merged.x[i] - e, d.merged.y[i] - e, d.merged.x[i] + e, d.merged.y[i] + e];\n    }\n    const genes = d.groupGenes && d.entryGroup ? d.groupGenes[d.entryGroup[i]] : undefined;\n    try {\n      const summary = await this.port.getTranscriptSummary({ box, cells, ...(genes ? { genes } : {}) });\n      const lines = this.describe(d, i, summary);\n      this.cache.set(key, lines);\n      if (this.key === key) onDetails(lines);\n    } catch (err) {\n      console.warn('[napari-js] transcript details unavailable', err);\n    }\n  }\n\n  /** The tooltip text for entry `i`, with the server's details when they have arrived. */\n  private describe(d: DrawnTranscripts, i: number, s: SpatialTranscriptSummary | null): string[] {\n    const t = d.merged;\n    const n = t.weight[i];\n    const obs = t.observation[i];\n    const fmt = (v: number) => v.toLocaleString();\n    const typeOf = (o: number) => {\n      const types = this.types;\n      if (!types || o === NO_OBSERVATION || types.meta.kind !== 'categorical') return null;\n      const c = types.codes[o];\n      return c === NO_CATEGORY ? null : (types.meta.categories[c] ?? null);\n    };\n    const cellLine = (o: number, prefix: string) => {\n      if (o === NO_OBSERVATION) return 'outside any cell';\n      const id = s?.cellIds?.[o] ?? `#${o}`;\n      const type = typeOf(o);\n      return `${prefix} ${id}${type ? ` · ${type}` : ''}`;\n    };\n\n    if (d.kind === 'bins') {\n      const lines = [`${fmt(n)} transcripts · all genes`];\n      if (d.bin) lines.push(`${d.bin.size.toFixed(1)} × ${d.bin.size.toFixed(1)} µm area`);\n      if (s?.transcripts !== undefined) {\n        lines.push(\n          `${fmt(s.genes ?? 0)} distinct genes · ${fmt(s.cells ?? 0)} cell${s.cells === 1 ? '' : 's'}` +\n            (s.unassigned ? ` · ${fmt(s.unassigned)} outside cells` : ''),\n        );\n        if (s.topGenes?.length) {\n          lines.push(\n            `top genes: ${s.topGenes\n              .slice(0, 5)\n              .map((g) => `${g.name} ${fmt(g.count)}`)\n              .join(', ')}`,\n          );\n        }\n      }\n      lines.push(cellLine(obs, 'mostly cell'));\n      if (!s && this.port.getTranscriptSummary) lines.push('loading details…');\n      return lines;\n    }\n    if (d.kind === 'individual') {\n      const gene = s?.topGenes?.[0]?.name;\n      return [\n        gene ? `${gene} transcript` : 'Transcript',\n        cellLine(obs, 'in cell'),\n        ...(!s && this.port.getTranscriptSummary ? ['loading details…'] : []),\n      ];\n    }\n    const gene = d.genes[t.gene[i]] ?? 'transcript';\n    if (d.bin) {\n      const um = d.bin.size * (this.micronsPerUnit ?? 1);\n      const group = d.entryGroup && d.groupNames ? d.groupNames[d.entryGroup[i]] : gene;\n      const top = s?.topGenes?.length\n        ? [\n            s.topGenes\n              .slice(0, 6)\n              .map((g) => `${g.name} ${fmt(g.count)}`)\n              .join(', '),\n          ]\n        : [];\n      return [\n        `${group} · ${fmt(n)} transcript${n === 1 ? '' : 's'}`,\n        ...(d.groupGenes ? top : group !== gene ? [`mostly ${gene}`] : []),\n        `${um.toFixed(1)} × ${um.toFixed(1)} µm area · zoom in to split`,\n        ...(obs === NO_OBSERVATION && d.groupGenes ? [] : [cellLine(obs, 'mostly cell')]),\n        ...(!s && d.groupGenes && this.port.getTranscriptSummary ? ['loading details…'] : []),\n      ];\n    }\n    return n > 1\n      ? [`${gene} · ${fmt(n)} transcripts`, 'grouped: zoom in to split', cellLine(obs, 'near cell')]\n      : [`${gene} transcript`, cellLine(obs, 'in cell')];\n  }\n}\n\n/** What the transcript layer currently shows — what hovering needs to name a marker. */\nexport interface DrawnTranscripts {\n  kind: TranscriptKind;\n  bin?: TranscriptBin;\n  merged: SpatialTranscriptTile;\n  /** The layer the entries are drawn in, one marker per entry in the same order. */\n  layer: PointsLayer;\n  genes: string[];\n  /** For a grouped gene selection: each entry's group, and the groups' names. */\n  entryGroup?: Int32Array;\n  groupNames?: string[];\n  /** Each group's genes, when the markers came from the density grids (for the hover). */\n  groupGenes?: string[][];\n}\n"]}