anyplotlib 0.9.0__tar.gz → 0.10.1__tar.gz

{anyplotlib-0.9.0 → anyplotlib-0.10.1}/AGENTS.md

@@ -115,7 +115,7 @@ grep -nE '^\s*(function|const|let) [A-Za-z_]' anyplotlib/figure_esm.js
 ```
 
 and reconcile against the two numbered tables (the section map near the top and
-the 2-D function table). Both were last verified at 12,211 lines.
+the 2-D function table). Both were last verified at 12,438 lines.
 
 Changelog entries: add a fragment file to `upcoming_changes/` (e.g.
 `123.new_feature.rst`) — towncrier assembles `CHANGELOG.rst` at release time.

{anyplotlib-0.9.0 → anyplotlib-0.10.1}/CHANGELOG.rst

@@ -10,6 +10,38 @@ Fragment files in ``upcoming_changes/`` are assembled into this file by
 
 .. towncrier release notes start
 
+0.10.1 (2026-09-17)
+===================
+
+New Features
+------------
+
+- A page embedding a figure in an iframe can post ``{type: 'anyplotlib_host', savesPng: true}`` to say it saves exported PNGs itself; the figure's "Save PNG…" then only sends the image to the host, without the in-figure "Save image as…" preview or the "Save as… (choose folder)" entry. (`#78 <https://github.com/CSSFrancis/anyplotlib/pull/78>`_)
+
+
+Bug Fixes
+---------
+
+- Zooming or panning a coordinate axis no longer blanks an :meth:`~anyplotlib.plotxy.PlotXY.add_raster` image, and every marker drawn after it, until the next update from Python. (`#76 <https://github.com/CSSFrancis/anyplotlib/pull/76>`_)
+
+
+0.10.0 (2026-09-14)
+===================
+
+API and Behaviour Changes
+-------------------------
+
+- 2-D pointer events (``pointer_down``, ``double_click``, ``pointer_settled``, ``key_down``) and the hover readout now report ``img_x``/``img_y`` in the pixel-centre convention that markers, widgets and :meth:`~anyplotlib.Plot2D.display_to_data` already used — they read half a pixel right and down before — so ``round(event.img_x)`` names the clicked pixel (``int()`` no longer does), brush strokes land under the cursor, and an ``imshow`` event's ``xdata``/``ydata`` is exactly the axis value of the pixel centre it hits (``pcolormesh`` values are unchanged). (`#73 <https://github.com/CSSFrancis/anyplotlib/pull/73>`_)
+- 2-D tick labels now sit on the pixels they name: ``imshow`` axis values are placed at pixel centres (the image extends half a pixel past the first and last value, as matplotlib's ``imshow`` extent does) through the same transform markers and pointer events use, so ticks also follow a letterboxed image instead of spanning the whole gutter, and an ``origin='lower'`` image gets y ticks at all; :meth:`~anyplotlib.Plot2D.set_view` / ``set_xlim`` / ``set_ylim`` read the axis the same way — ``set_xlim(-0.5, n - 0.5)`` is the whole image, ``set_xlim(0, n - 1)`` now crops the outer half pixels — and accept a descending ``origin='lower'`` y axis. (`#74 <https://github.com/CSSFrancis/anyplotlib/pull/74>`_)
+
+
+New Features
+------------
+
+- The 2-D colorbar now writes its display minimum and maximum beside the strip — both ends in one format, and the strip itself coloured through the display window (saturated beyond it, the way the image is) and spanning the image rather than the whole panel — so a labelled scale says how much and not only which way; the image gives up a value gutter budgeted for the numbers (fixed for ordinary values so a contrast drag never moves the image, wider for the rare long ones, dropped in a cell too narrow to keep 40 px of image, and mirrored in :meth:`plot_box`) so they never clip. (`#71 <https://github.com/CSSFrancis/anyplotlib/pull/71>`_)
+- Text markers (:meth:`~anyplotlib.Plot2D.add_texts`, :meth:`~anyplotlib.Plot1D.add_texts` and ``add_text``) gained ``fontweight`` for bold labels and ``outline_color`` / ``outline_width`` for a halo stroked under the text, which keeps a label legible over both light and dark parts of an image. (`#73 <https://github.com/CSSFrancis/anyplotlib/pull/73>`_)
+
+
 0.9.0 (2026-09-11)
 ==================
 

{anyplotlib-0.9.0 → anyplotlib-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: anyplotlib
-Version: 0.9.0
+Version: 0.10.1
 Summary: A plotting library using python, javascript and anywidget for performant in browser plotting.
 Project-URL: Homepage, https://cssfrancis.github.io/anyplotlib/
 Project-URL: Repository, https://github.com/CSSFrancis/anyplotlib

{anyplotlib-0.9.0 → anyplotlib-0.10.1}/anyplotlib/FIGURE_ESM.md

@@ -35,8 +35,8 @@ Rule 4 – Zoom is relative to the fit-rect.
          zoom=Z → a 1/Z portion of the image fills the fit-rect.
 
 Rule 5 – Text never clips.  Optional gutters earn real layout space:
-         the colorbar (strip + label, _cbWidth) is subtracted from the
-         image width; the 2D title strip (_padT) grows for large or TeX
+         the colorbar (strip + value gutter + label, _cbWidth) is
+         subtracted from the image width; the 2D title strip (_padT) grows for large or TeX
          titles; 1D/bar titles clamp their drawn size to the fixed strip
          (_titlePx); edge tick labels are nudged inward.
 ```
@@ -50,55 +50,57 @@ Rule 5 – Text never clips.  Optional gutters earn real layout space:
 | Shared plot-area padding (`PAD_*`) | 9 |
 | Theme (dark/light detection) | 26 |
 | Shared math helpers | 64 |
-| b64 array decode helpers | 109 |
-| **Rich-text (mini-TeX) engine**: `_texRuns` / `_texLayout` / `_drawTex` | 161 / 228 / 250 |
-| **2D gutter geometry**: `_cbWidth` / `_cbGap` / `_padT` / `_titlePx` | 301 / 313 / 323 / 333 |
-| **Layout engine** `applyLayout` | 824 |
-| `_buildCanvasStack` | 907 |
-| `_createPanelDOM` | 1049 |
-| `_createInsetDOM` / `_applyAllInsetStates` | 1190 / 1584 |
-| `_resizePanelDOM` | 2297 |
-| **2D drawing**: `_imgFitRect` | 2461 |
-| `draw2d` | 2790 |
-| `drawScaleBar2d` / `drawColorbar2d` | 2985 / 3265 |
-| **Floating keys**: `_keyEnsure` / `_keyRect` / `drawKeys` | 3084 / 3107 / 3120 |
-| `_drawAxes2d` (ticks, labels, title) | 3319 |
-| `drawOverlay2d` / `drawMarkers2d` | 3472 / 3636 |
-| **Image layers**: `_layerBytes` / `_layerBitmap` / `_drawLayers2d` | 2610 / 2634 / 2695 |
-| Binary-bytes splice: `_spliceBinaryBytes` / `_registerBinaryPixelListeners` | 780 / 811 |
-| **Hover readout**: `_pixelValue2d` / `_readoutInfo2d` | 4480 / 4562 |
-| `_notifyReadout` / `_updateStatus2d` / `_armValueProbe` | 4602 / 4617 / 4638 |
-| **3D drawing**: `draw3d` | 5614 |
-| Event emission `_emitEvent` | 6451 |
-| 3D event handlers `_attachEvents3d` | 6508 |
-| **1D drawing**: `draw1d` | 6732 |
-| `_drawLine` (1D series + markers) | 6885 |
-| `drawOverlay1d` / `drawMarkers1d` | 7178 / 7262 |
-| Marker hit-test `_markerHitTest2d` | 7530 |
+| b64 array decode helpers | 141 |
+| **Rich-text (mini-TeX) engine**: `_texRuns` / `_texLayout` / `_drawTex` | 193 / 260 / 282 |
+| **2D gutter geometry**: `_cbLabelW` / `_cbValueChars` / `_cbTickW` / `_cbWidth` / `_cbGap` / `_padT` / `_titlePx` | 331 / 342 / 360 / 372 / 382 / 392 / 402 |
+| **Layout engine** `applyLayout` | 893 |
+| `_buildCanvasStack` | 976 |
+| `_createPanelDOM` | 1118 |
+| `_createInsetDOM` / `_applyAllInsetStates` | 1259 / 1653 |
+| `_resizePanelDOM` | 2366 |
+| **2D drawing**: `_imgFitRect` | 2537 |
+| `draw2d` | 2881 |
+| `drawScaleBar2d` / `drawColorbar2d` | 3076 / 3356 |
+| **Floating keys**: `_keyEnsure` / `_keyRect` / `drawKeys` | 3175 / 3198 / 3211 |
+| `_drawAxes2d` (ticks, labels, title) | 3468 |
+| `drawOverlay2d` / `drawMarkers2d` | 3623 / 3787 |
+| **Image layers**: `_layerBytes` / `_layerBitmap` / `_drawLayers2d` | 2701 / 2725 / 2786 |
+| Binary-bytes splice: `_spliceBinaryBytes` / `_registerBinaryPixelListeners` | 849 / 880 |
+| **Hover readout**: `_pixelValue2d` / `_readoutInfo2d` | 4631 / 4716 |
+| `_notifyReadout` / `_updateStatus2d` / `_armValueProbe` | 4755 / 4770 / 4791 |
+| **3D drawing**: `draw3d` | 5767 |
+| Event emission `_emitEvent` | 6604 |
+| 3D event handlers `_attachEvents3d` | 6661 |
+| **1D drawing**: `draw1d` | 6885 |
+| `_drawLine` (1D series + markers) | 7038 |
+| `drawOverlay1d` / `_rasterBitmap` / `drawMarkers1d` | 7331 / 7419 / 7436 |
+| Marker hit-test `_markerHitTest2d` | 7700 |
 
 > **`raster` marker (1D/PlotXY)** — `drawMarkers1d` has a `type==='raster'`
 > branch that blits a single RGBA image across data-coord `extent` (the fast
 > path for dense `PlotXY.pcolormesh` heatmaps). The image bytes ride the geom
 > channel as `st.raster_geom[id]` (Python `Plot1D._GEOM_KEYS`), so view-only
-> redraws never re-transmit them; the decoded `OffscreenCanvas` is cached on
-> the marker set (`ms._rasterBmp`/`_rasterKey`). The shared `clip_path` block
-> clips it to a curved sector.
-| Panel event dispatch `_attachPanelEvents` | 7787 |
-| 2D events `_attachEvents2d` | 7829 |
-| 1D events `_attachEvents1d` | 8222 |
-| 2D widget drag `_ovHitTest2d` / `_doDrag2d` | 8497 / 8776 |
-| **Brush strokes**: `_brushLiveBegin` / `_brushCommit` / `_brushErase` / `_brushPaintAt` | 8689 / 8703 / 8732 / 8767 |
-| 1D widget drag `_canvasXToFrac1d` … / snapping `_snapVal` | 8901 / 8974 |
-| Shared-axis propagation `_getShareGroups` | 9045 |
-| Figure resize `_applyFigResizeDOM` | 9109 |
-| **Bar chart**: `_barGeom` / `drawBar` / `_attachEventsBar` | 9300 / 9363 / 9739 |
-| Generic redraw `_redrawPanel` | 9929 |
-| **PNG export**: `_compositeCanvas` / `exportCanvas` / `exportPNG` | 10088 / 10284 / 10343 |
-| Native-resolution render `_withNativeSize` | 10064 |
-| **Export UI**: `_toast` / `_downloadCanvas` / `_openMenu` | 10377 / 10486 / 10665 |
-| Export registry `registerExportAction` | 10542 |
-| **Embedding API**: `createLocalModel` / `mount` | 11056 / 11112 |
-| **Navigated embed**: `decodeBlocks` / `mountNavigated` | 11367 / 11754 |
+> redraws never re-transmit them. The decoded `OffscreenCanvas` is cached per
+> panel by `_rasterBitmap` (keyed by the marker set's id, re-decoded when the
+> bytes or the shape change) — never on the marker set, which is state the
+> wheel and pan handlers serialise back. The shared `clip_path` block clips it
+> to a curved sector.
+| Panel event dispatch `_attachPanelEvents` | 7957 |
+| 2D events `_attachEvents2d` | 8043 |
+| 1D events `_attachEvents1d` | 8429 |
+| 2D widget drag `_ovHitTest2d` / `_doDrag2d` | 8704 / 8983 |
+| **Brush strokes**: `_brushLiveBegin` / `_brushCommit` / `_brushErase` / `_brushPaintAt` | 8896 / 8910 / 8939 / 8974 |
+| 1D widget drag `_canvasXToFrac1d` … / snapping `_snapVal` | 9108 / 9181 |
+| Shared-axis propagation `_getShareGroups` | 9252 |
+| Figure resize `_applyFigResizeDOM` | 9316 |
+| **Bar chart**: `_barGeom` / `drawBar` / `_attachEventsBar` | 9510 / 9573 / 9949 |
+| Generic redraw `_redrawPanel` | 10139 |
+| **PNG export**: `_compositeCanvas` / `exportCanvas` / `exportPNG` | 10302 / 10498 / 10557 |
+| Native-resolution render `_withNativeSize` | 10278 |
+| **Export UI**: `_toast` / `_downloadCanvas` / `_openMenu` | 10591 / 10713 / 10892 |
+| Export registry `registerExportAction` | 10769 |
+| **Embedding API**: `createLocalModel` / `mount` | 11283 / 11339 |
+| **Navigated embed**: `decodeBlocks` / `mountNavigated` | 11594 / 11981 |
 
 > **`brush` widget (2-D)** — the one widget whose drag is *modal*, and the one
 > that must NOT write the model per tick. `_ovHitTest2d` takes an extra `mods`
@@ -148,7 +150,10 @@ with fallbacks to the historical defaults: `title_size||11`,
 
 | Function | Purpose |
 |----------|---------|
-| `_cbWidth(st)` | Width reserved for the colorbar: 0 when hidden, else `16 + (label ? label_size+8 : 0)`.  Subtracted from the image width in `_resizePanelDOM` / `_resizePanelCSS` so the strip + label always fit inside the panel. |
+| `_cbLabelW(st)` | The rotated-label gutter: `label_size + 8`, 0 without a label. |
+| `_cbValueChars(st)` | Characters budgeted for the `display_min` / `display_max` values: 7 (all of `fmtRange`'s ordinary output, so a contrast drag never moves the image), more only for longer strings such as a three-digit exponent.  `fmtRange` (next to `fmtVal`) formats BOTH ends alike — exponent notation when the larger magnitude is outside [1e-2, 1e4), else decimals from the span (three significant digits of it, so ±1.25 reads 1.25).  Mirrored by Python `_colorbar_value_chars` / `colorbar_texts`. |
+| `_cbTickW(st, availW)` | Width of the value gutter right of the strip: `round(chars * 0.6 * tick_size) + 3`.  With `availW` (image + colorbar width after the axis gutters) it is 0 when the values would leave less than `CB_MIN_IMAGE_W` (40 px) of image — a narrow grid cell keeps the strip and label and drops the numbers.  `_resizePanelDOM` stores the result on `p._cbTickW` for `drawColorbar2d`.  Mirrored in Python's `plot_box`. |
+| `_cbWidth(st, availW)` | Width reserved for the colorbar: 0 when hidden, else `16 + _cbTickW + _cbLabelW`.  Subtracted from the image width in `_resizePanelDOM` / `_resizePanelCSS` so the strip, its values and its label always fit inside the panel. |
 | `_padT(st)` | 2D title-strip height: `PAD_T` (12) for default-size plain titles (pixel-identical layouts); grows to `ceil(size*1.3)+2..4` for `title_size > 11` or TeX titles (superscript rise). Stored as `p._padT`. |
 | `_titlePx(st)` | Drawn title size for fixed-strip panels (1D/bar): clamps to 11 (10 for TeX titles) so nothing clips. |
 
@@ -279,17 +284,36 @@ st.colorbar_label_size            (label font sizes; optional)
 
 | Function | Line | Purpose |
 |----------|------|---------|
-| **`_imgFitRect(iw,ih,cw,ch)`** | **2384** | Largest rect of aspect `iw:ih` centred in `cw×ch`; all 2-D coordinate functions derive from this |
-| `draw2d(p)` | 2713 | Main render: `_resizePanelDOM` → decode → LUT → ImageBitmap → blit; then mask, axes, scale bar, colorbar, overlay, markers |
-| `drawScaleBar2d(p)` | 2908 | Physical scale bar |
-| `_rawBand(st)` / `_buildLut32(st)` | 2433 / 2440 | The quantisation band the u8 bytes were encoded over, then the 256-entry LUT built from it. `_rawBand` mirrors Python `_tile_quant_clim`: a DEGENERATE band (`raw_max <= raw_min`) is UNSET and falls back to `display_min/max`. Both render paths and the colorbar go through it — honouring a `(0, 0)` band paints solid black |
-| `drawColorbar2d(p)` | 3188 | Gradient strip + min/max marks (band-relative, via `_rawBand`) + rotated label centred in the `_cbWidth` gutter |
-| `_drawAxes2d(p)` | 3242 | Ticks (edge labels nudged inward both axes), axis labels + title via `_drawTex` |
-| `drawOverlay2d(p)` / `drawMarkers2d(p)` | 3395 / 3559 | Widgets / marker groups |
+| **`_imgFitRect(iw,ih,cw,ch)`** / `_cbFitRect(st,imgW,imgH)` | **2537 / 2546** | Largest rect of aspect `iw:ih` centred in `cw×ch`; all 2-D coordinate functions derive from this.  `_cbFitRect` is its vertical extent in whole px — the colorbar strip spans the letterboxed IMAGE, not the whole image area (`p._cbH`) |
+| `draw2d(p)` | 2881 | Main render: `_resizePanelDOM` → decode → LUT → ImageBitmap → blit; then mask, axes, scale bar, colorbar, overlay, markers |
+| `drawScaleBar2d(p)` | 3076 | Physical scale bar |
+| `_rawBand(st)` / `_displayFrac(st, val)` / `_buildLut32(st)` | 2596 / 2606 / 2614 | The quantisation band the u8 bytes were encoded over, the ONE rule mapping a value through the display window and scale mode to a colormap fraction (shared by the LUT and the colorbar strip, so the strip's colours are the image's), then the 256-entry LUT built from both. `_rawBand` mirrors Python `_tile_quant_clim`: a DEGENERATE band (`raw_max <= raw_min`) is UNSET and falls back to `display_min/max`. Both render paths and the colorbar go through it — honouring a `(0, 0)` band paints solid black |
+| `drawColorbar2d(p)` | 3356 | Gradient strip coloured through the display window (`_displayFrac` — saturated beyond it, like the image) + min/max marks (band-relative, via `_rawBand`) + the two values written beside them (`fmtRange`; kept inside the strip by the glyphs' measured extent, held apart on a tiny range, the maximum alone at its own place on a strip too short for both; omitted when the layout dropped the gutter, `p._cbTickW == 0`) + rotated label centred right after the values' measured width (never past the reserved gutter) |
+| `_drawAxes2d(p)` | 3468 | Ticks placed through `_imgToCanvas2d` (pixel-centre axes, letterbox-aware; edge labels nudged inward both axes), axis labels + title via `_drawTex` |
+| `drawOverlay2d(p)` / `drawMarkers2d(p)` | 3623 / 3787 | Widgets / marker groups |
 
 Zoom model: at `zoom=1` the whole image fills the fit-rect; at `zoom=Z>1` a
 `1/Z` region fills it.  `_imgToCanvas2d` / `_canvasToImg2d` must stay exact
-inverses of the blit geometry.
+inverses of the blit geometry — and of each other.  Both use the pixel-CENTRE
+convention (integer *i* is the centre of pixel *i*, which spans
+`[i − 0.5, i + 0.5)`), the same as marker offsets, widget positions and Python's
+`data_to_display` / `display_to_data`; `_imgPix2d` / `_inImgAxis2d` name the
+pixel under a coordinate and bound it.  Pointer events and the readout map a
+coordinate to `xdata`/`ydata` through `_imgToAxisVal2d` (imshow axes are
+per-pixel centres, pcolormesh axes cell edges).  Code that addresses texels or
+the detail region by pixel EDGE (`_pixelValue2d`) adds the `0.5` back itself.
+
+The tick gutters (`_drawAxes2d`) use the same chain in reverse: tick value →
+`_axisValToImg2d` (imshow; pcolormesh goes through `_axisValToFrac` × n − ½) →
+`_imgToCanvas2d`, so ticks honour the letterboxed fit rect, zoom < 1, pan
+clamping and descending (`origin='lower'`) axes for free.  The visible value
+range is the gutter's two ends through `_canvasToImg2d`, clamped to the outer
+pixel edges.  Python's `Plot2D._axis_extent_frac` (behind `set_view` /
+`set_xlim`) mirrors `_axisValToImg2d` — keep the two in step.
+
+`texts` markers (1-D and 2-D) set their font and optional outline through
+`_markerTextStyle(ctx, ms)` (`fontweight`, `outline_color`, `outline_width`)
+and draw via `_drawMarkerText`, which strokes the halo under the fill.
 
 ### Hover readout
 
@@ -638,13 +662,13 @@ exportCanvas(same opts) → {canvas, width, height}   // synchronous, throws
 
 | Function | Line | Purpose |
 |----------|------|---------|
-| `_cssScale` | 9964 | inverse of `_applyScale`'s `transform:scale()` |
-| `_panelBox` | 9975 | the element whose rect bounds one panel |
-| `_neutralizeView` / `_restoreView` | 9984 / 10009 | transient whole-extent view |
-| `_nativeGeom` / `_nativeGuard` | 10024 / 10039 | native size + why-not message |
-| `_withNativeSize` | 10064 | resize → redraw → run → restore |
-| `_compositeCanvas` | 10088 | the compositor (`_drawEl` / `_drawPanel` …) |
-| `exportCanvas` / `exportPNG` | 10284 / 10343 | orchestrator / data-URL wrapper |
+| `_cssScale` | 10174 | inverse of `_applyScale`'s `transform:scale()` |
+| `_panelBox` | 10185 | the element whose rect bounds one panel |
+| `_neutralizeView` / `_restoreView` | 10194 / 10219 | transient whole-extent view |
+| `_nativeGeom` / `_nativeGuard` | 10234 / 10253 | native size + why-not message |
+| `_withNativeSize` | 10278 | resize → redraw → run → restore |
+| `_compositeCanvas` | 10302 | the compositor (`_drawEl` / `_drawPanel` …) |
+| `exportCanvas` / `exportPNG` | 10498 / 10557 | orchestrator / data-URL wrapper |
 
 **The whole pipeline is ONE synchronous task** — theme swap, view reset, native
 resize, composite, restore — so the browser never paints an intermediate state
@@ -740,13 +764,14 @@ leaders that cross into the panel included. Pinned by
 
 | Function | Line | Purpose |
 |----------|------|---------|
-| `_toast` | 10377 | transient bottom-centre message |
-| `_copyCanvas` | 10412 | clipboard write + feature detection |
-| `_showPngPreview` | 10436 | framed-document download fallback |
-| `_downloadCanvas` | 10486 | `<a download>` or the preview |
-| `registerExportAction` | 10542 | downstream extension point |
-| `_menuRows` / `_openMenu` | 10596 / 10665 | menu model / DOM |
-| `_panelAtPoint` | 10777 | hit test (insets first — they sit on top) |
+| `_toast` | 10591 | transient bottom-centre message |
+| `_copyCanvas` | 10626 | clipboard write + feature detection |
+| `_showPngPreview` | 10650 | framed-document download fallback |
+| `_hostSavesPng` / `_canPickFile` | 10702 / 10708 | the parent saves PNGs itself / a system Save dialog exists |
+| `_downloadCanvas` | 10713 | `<a download>`, the preview, or the host |
+| `registerExportAction` | 10769 | downstream extension point |
+| `_menuRows` / `_openMenu` | 10823 / 10892 | menu model / DOM |
+| `_panelAtPoint` | 11004 | hit test (insets first — they sit on top) |
 
 - **An `exportBtn` badge (⤓, beside the help badge) opens the same menu on an
   ordinary left click.** It is a `role="button"` with `tabIndex=0` and
@@ -788,9 +813,15 @@ leaders that cross into the panel included. Pinned by
   `save_html` page opened directly is top-level) from the unreliable one (VS
   Code webviews, `_repr_html_` iframes, nbconvert output). When framed, the
   result is posted to the parent under the existing
-  `anyplotlib_export_png_result` message AND shown as an in-figure preview whose
-  caption points at the browser's own "Save image as…", which needs no
-  permission and is never blocked.
+  `anyplotlib_export_png_result` message (`requestId: null`, plus `filename`)
+  AND shown as an in-figure preview whose caption points at the browser's own
+  "Save image as…", which needs no permission and is never blocked.
+- **Host saves** (`_hostSavesPng`): a parent that posts
+  `{type:'anyplotlib_host', savesPng:true}` sets `globalThis.__aplHostSavesPng`
+  (the page template's listener, parent frame only). Framed saves then post the
+  image WITHOUT the preview, and `_canPickFile()` is false, so the *Save as…*
+  row disappears — the host's own Save dialog chooses the folder, and an app
+  webview may have no "Save image as…" menu for the preview to point at.
 - **Clipboard**: gated on `isSecureContext && navigator.clipboard &&
   ClipboardItem && clipboard.write`. The Blob is built SYNCHRONOUSLY from the
   data URL (not via the async `toBlob` callback) so the write stays inside the
@@ -807,6 +838,7 @@ Test hooks: `__apl_menuItems`, `__apl_toastText`, `__apl_menuTheme`,
 Tests: `tests/test_embed/test_export_png.py` (the pre-existing contract),
 `test_export_sources.py` (panelId / source / theme / CSS scale),
 `test_export_menu.py` (menu, clipboard, download, registry),
+`test_host_saves_png.py` (the host announcement and the framed save),
 `test_savefig.py` (the Python entry point + view reconciliation).
 
 The standalone HTML template (`_repr_utils.build_standalone_html`) captures
@@ -816,11 +848,14 @@ render()'s api into `_aplRenderApi`, **also assigns it to `window._aplRenderApi`
 `{type:'anyplotlib_export_png', requestId, opts}` → `exportPNG(opts)` → replies
 `{type:'anyplotlib_export_png_result', requestId, dataUrl, width, height}` (or
 `{…, error}`) to `event.source` (targetOrigin `'*'`). `opts` is forwarded
-verbatim, so the new fields work over that channel too.
+verbatim, so the new fields work over that channel too. A second listener takes
+`{type:'anyplotlib_host', savesPng}` from `window.parent` only and records it
+in `globalThis.__aplHostSavesPng` (read by `_hostSavesPng`). Both live in
+`PNG_HARVEST_LISTENER`, which the navigated embed installs too.
 
 ---
 
-## Navigated-embed runtime (line 11333 to the end of the file)
+## Navigated-embed runtime (line 11346 to the end of the file)
 
 Everything below `mount()` is module scope, outside `render()`'s closure: pure
 functions over decoded data plus one entry point that wires them to a mounted
@@ -830,16 +865,16 @@ bindings, let it dispatch", rather than a hand-written program per result kind.
 
 | Function | Line | Purpose |
 |----------|------|---------|
-| `decodeBlocks` | 11367 | one base64 `fetch` → one ArrayBuffer → a typed-array view per manifest entry |
-| `dense` | 11393 | `at` / `gather` / `reduce` over a block whose leading axes are the nav axes |
-| `ragged` | 11458 | the same three, over a row-pointer block (`offsets` + one array per column) |
-| `maskFromWidget` | 11541 | rectangle / circle / annulus widget dict → `Uint8Array` (carries `width`/`height`) |
-| `rasterDisks` | 11581 | splat `{x, y, intensity}` rows as filled disks — the base image of a vectors panel |
-| `robustLevels` / `toU8` | 11610 / 11651 | the percentile window and the 8-bit code map, one implementation |
-| `panelAxis` | 11729 | a 1-D panel's decoded x axis (`_1dXArr`, else `x_axis_b64`) |
-| `installTouchShim` / `reportEmbedHeight` | 11666 / 11685 | page chrome: touch → mouse, `postMessage({aplEmbedHeight})` |
-| `encodeBase64` / `typedArrayBytes` | 11705 / 11713 | a 3-D cloud's geometry channel is base64, not the binary side table |
-| `mountNavigated` | 11754 | mount + bind + dispatch; resolves to the mount handle plus `dispatch`/`index`/`blocks` |
+| `decodeBlocks` | 11594 | one base64 `fetch` → one ArrayBuffer → a typed-array view per manifest entry |
+| `dense` | 11620 | `at` / `gather` / `reduce` over a block whose leading axes are the nav axes |
+| `ragged` | 11685 | the same three, over a row-pointer block (`offsets` + one array per column) |
+| `maskFromWidget` | 11768 | rectangle / circle / annulus widget dict → `Uint8Array` (carries `width`/`height`) |
+| `rasterDisks` | 11808 | splat `{x, y, intensity}` rows as filled disks — the base image of a vectors panel |
+| `robustLevels` / `toU8` | 11837 / 11878 | the percentile window and the 8-bit code map, one implementation |
+| `panelAxis` | 11956 | a 1-D panel's decoded x axis (`_1dXArr`, else `x_axis_b64`) |
+| `installTouchShim` / `reportEmbedHeight` | 11893 / 11912 | page chrome: touch → mouse, `postMessage({aplEmbedHeight})` |
+| `encodeBase64` / `typedArrayBytes` | 11932 / 11940 | a 3-D cloud's geometry channel is base64, not the binary side table |
+| `mountNavigated` | 11981 | mount + bind + dispatch; resolves to the mount handle plus `dispatch`/`index`/`blocks` |
 
 `mountNavigated(el, page, opts)` is **async** — the blob decode is a `fetch` of
 a `data:` URL — so a host `await`s it.  `page` is `{state, blocks, bindings,

{anyplotlib-0.9.0 → anyplotlib-0.10.1}/anyplotlib/_base_plot.py

@@ -6,11 +6,99 @@ Shared base classes and mixins for all plot panel types.
 
 from __future__ import annotations
 
+import decimal
+import math
+
 from contextlib import contextmanager
 
 from anyplotlib.callbacks import _EventMixin
 
 
+#: Below this many px of image the colorbar's value gutter is dropped
+#: (mirrors ``CB_MIN_IMAGE_W`` in the JS).
+COLORBAR_MIN_IMAGE_WIDTH = 40
+
+
+def _js_round(x: float) -> int:
+    """JavaScript's ``Math.round`` — half away from zero for positive values —
+    where Python's ``round`` would tie to even and put the two sides of the
+    layout mirror a pixel apart."""
+    return int(math.floor(float(x) + 0.5))
+
+
+def _js_exponential(value: float, digits: int) -> str:
+    """JavaScript's ``Number.toExponential(digits)``: a signed mantissa with
+    *digits* decimals, rounded half away from zero on the exact binary value
+    (``12500`` → ``1.3e+4``, where ``f"{:e}"`` would tie to even), and an
+    exponent without leading zeros (``1.2e+4``, ``-1.5e-10``)."""
+    number = decimal.Decimal(value)
+    if number == 0:
+        return f"{0:.{digits}f}e+0"
+    sign = "-" if number < 0 else ""
+    number = abs(number)
+    exponent = number.adjusted()
+    quantum = decimal.Decimal(1).scaleb(-digits)
+    mantissa = number.scaleb(-exponent).quantize(quantum, rounding=decimal.ROUND_HALF_UP)
+    if mantissa >= 10:
+        mantissa = (mantissa / 10).quantize(quantum, rounding=decimal.ROUND_HALF_UP)
+        exponent += 1
+    return f"{sign}{mantissa}e{exponent:+d}"
+
+
+def _js_fixed(value: float, digits: int) -> str:
+    """JavaScript's ``Number.toFixed(digits)``, which rounds half away from
+    zero on the exact binary value."""
+    quantum = decimal.Decimal(1).scaleb(-digits)
+    rounded = decimal.Decimal(value).quantize(quantum, rounding=decimal.ROUND_HALF_UP)
+    return f"{rounded:f}"
+
+
+def _strip_zeros(text: str) -> str:
+    return text.rstrip("0").rstrip(".") if "." in text else text
+
+
+def colorbar_texts(low: float, high: float) -> tuple[str, str]:
+    """The two values the renderer writes beside the colorbar (``fmtRange``),
+    mirrored so Python can budget the same width.
+
+    One format for both ends, so ``0.02`` never sits beside ``-5.0e-3``:
+    exponent notation when the larger magnitude is outside ``[1e-2, 1e4)``,
+    else fixed with enough decimals to show the ends exactly — three
+    significant digits of the span, so ±1.25 reads ``1.25`` and not ``1.3``;
+    at most four decimals.  Non-finite ends give ``""`` (the renderer draws
+    nothing)."""
+    low, high = float(low), float(high)
+    if not (math.isfinite(low) and math.isfinite(high)):
+        return "", ""
+    big = max(abs(low), abs(high))
+    if big == 0:
+        return "0", "0"
+    if big >= 1e4 or big < 1e-2:
+        return _js_exponential(low, 1), _js_exponential(high, 1)
+    span = abs(high - low) or big
+    decimals = min(4, max(0, math.ceil(-math.log10(span)) + 2))
+    return (_strip_zeros(_js_fixed(low, decimals)),
+            _strip_zeros(_js_fixed(high, decimals)))
+
+
+def _colorbar_value_chars(state: dict) -> int:
+    """Characters budgeted for the colorbar's min/max values: 7 in ordinary
+    use, so the layout is stable under a contrast drag, more only for the rare
+    longer strings.  Mirrors ``_cbValueChars`` in the JS."""
+    chars = 7
+    lo, hi = state.get("display_min"), state.get("display_max")
+    if lo is not None and hi is not None:
+        chars = max(chars, *(len(t) for t in colorbar_texts(lo, hi)))
+    return chars
+
+
+def _colorbar_value_width(state: dict) -> int:
+    """The value gutter in px — mirrors ``_cbTickW`` in the JS before its
+    narrow-cell rule."""
+    tick = state.get("tick_size") or 10
+    return _js_round(_colorbar_value_chars(state) * 0.6 * tick) + 3
+
+
 class _BasePlot(_EventMixin):
     """Universal base for Plot1D, Plot2D, PlotBar, and Plot3D.
 
@@ -376,14 +464,20 @@ class _PanelMixin:
         width = max((pw - left - right) if has_axes else pw, 1.0)
         height = max(ph - pad_t - (bottom if has_axes else 0.0), 1.0)
 
-        # The colorbar strip and its gap come out of the image width.
+        # The colorbar strip, its value gutter, its label and its gap come out
+        # of the image width.  Mirrors `_cbWidth` / `_cbTickW` in the JS,
+        # including the rule that drops the values in a cell too narrow for
+        # them (`width` here is the JS `availW`).
         if self._state.get("show_colorbar") and not self._state.get("is_rgb"):
             label = self._state.get("colorbar_label")
-            label_w = round((self._state.get("colorbar_label_size") or 10) + 8) \
+            label_w = _js_round((self._state.get("colorbar_label_size") or 10) + 8) \
                 if label else 0
+            tick_w = _colorbar_value_width(self._state)
             pad = self._state.get("colorbar_pad")
             gap = 6.0 if pad is None else max(0.0, float(pad))
-            width = max(width - (16 + label_w) - gap, 1.0)
+            if width - gap - 16 - label_w - tick_w < COLORBAR_MIN_IMAGE_WIDTH:
+                tick_w = 0
+            width = max(width - (16 + tick_w + label_w) - gap, 1.0)
 
         if is_image:
             # Images are drawn "contain" — see _imgFitRect.
@@ -625,7 +719,8 @@ class _MarkerMixin:
         transform : str, optional
             Coordinate system for ``(x, y)``.  Default ``"data"``.
         **kwargs : dict
-            Forwarded to :meth:`add_texts` (e.g. ``clip_display``).
+            Forwarded to :meth:`add_texts` (e.g. ``clip_display``,
+            ``fontweight``, ``outline_color``).
 
         Returns
         -------

{anyplotlib-0.9.0 → anyplotlib-0.10.1}/anyplotlib/_repr_utils.py

@@ -330,9 +330,10 @@ window.addEventListener('message', (e) => {{
 
 
 # A host page (or the SpyDE report harvester) asks an embedded figure for a
-# composite PNG over postMessage.  Both the standalone page and the navigated
-# embed install this listener; each assigns ``globalThis.__aplExportPNG`` once
-# its figure is mounted, which is also what makes "not ready yet" answerable.
+# composite PNG over postMessage, and can announce that it saves exported PNGs
+# itself.  Both the standalone page and the navigated embed install these
+# listeners; each assigns ``globalThis.__aplExportPNG`` once its figure is
+# mounted, which is also what makes "not ready yet" answerable.
 PNG_HARVEST_LISTENER = '''\
 // ── PNG export protocol ──────────────────────────────────────────────────────
 // A parent page (or the SpyDE report harvester) asks this frame over
@@ -370,6 +371,20 @@ window.addEventListener('message', (e) => {
     reply({ error: String(err && err.message || err) });
   }
 });
+
+// A host that saves exported PNGs itself (a desktop app with its own Save
+// dialog) announces it once:
+//   → { type: 'anyplotlib_host', savesPng: true }
+// after which the export menu's "Save PNG…" only posts the image to it
+//   ← { type: 'anyplotlib_export_png_result', requestId: null,
+//       dataUrl, width, height, filename }
+// instead of also showing the in-figure "Save image as…" preview. Only the
+// parent frame may say so.
+window.addEventListener('message', (e) => {
+  if (!e.data || e.data.type !== 'anyplotlib_host') return;
+  if (e.source !== window.parent || window.parent === window) return;
+  globalThis.__aplHostSavesPng = e.data.savesPng === true;
+});
 '''
 
 

{anyplotlib-0.9.0 → anyplotlib-0.10.1}/anyplotlib/callbacks.py

@@ -43,7 +43,7 @@ class Event:
         button         — 0=left 1=middle 2=right; None on move/enter/leave/settled
         buttons        — bitmask of currently held buttons
         xdata, ydata   — data-space coordinates (None for Plot3D)
-        img_x, img_y   — Plot2D/PlotMesh: position in IMAGE PIXELS (column, row; row 0 at the top, origin already applied), so a handler can index the source array directly. None on other plot types.
+        img_x, img_y   — Plot2D/PlotMesh: position in IMAGE PIXELS (column, row; row 0 at the top, origin already applied), so a handler can index the source array directly. Integer i is the CENTRE of pixel i (as for markers and widgets), so round() names the pixel. None on other plot types.
         ray            — Plot3D only: {"origin": [...], "direction": [...]}
         line_id        — Plot1D only: set when pointer is over a line
         dwell_ms       — pointer_settled only: actual dwell time