anyplotlib 0.9.0__tar.gz → 0.10.0__tar.gz

{anyplotlib-0.9.0 → anyplotlib-0.10.0}/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,407 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.0}/CHANGELOG.rst

@@ -10,6 +10,23 @@ Fragment files in ``upcoming_changes/`` are assembled into this file by
 
 .. towncrier release notes start
 
+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.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: anyplotlib
-Version: 0.9.0
+Version: 0.10.0
 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.0}/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,31 +50,31 @@ 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` / `drawMarkers1d` | 7331 / 7415 |
+| Marker hit-test `_markerHitTest2d` | 7682 |
 
 > **`raster` marker (1D/PlotXY)** — `drawMarkers1d` has a `type==='raster'`
 > branch that blits a single RGBA image across data-coord `extent` (the fast
@@ -83,22 +83,22 @@ Rule 5 – Text never clips.  Optional gutters earn real layout space:
 > 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 |
+| Panel event dispatch `_attachPanelEvents` | 7939 |
+| 2D events `_attachEvents2d` | 8025 |
+| 1D events `_attachEvents1d` | 8411 |
+| 2D widget drag `_ovHitTest2d` / `_doDrag2d` | 8686 / 8965 |
+| **Brush strokes**: `_brushLiveBegin` / `_brushCommit` / `_brushErase` / `_brushPaintAt` | 8878 / 8892 / 8921 / 8956 |
+| 1D widget drag `_canvasXToFrac1d` … / snapping `_snapVal` | 9090 / 9163 |
+| Shared-axis propagation `_getShareGroups` | 9234 |
+| Figure resize `_applyFigResizeDOM` | 9298 |
+| **Bar chart**: `_barGeom` / `drawBar` / `_attachEventsBar` | 9492 / 9555 / 9931 |
+| Generic redraw `_redrawPanel` | 10121 |
+| **PNG export**: `_compositeCanvas` / `exportCanvas` / `exportPNG` | 10284 / 10480 / 10539 |
+| Native-resolution render `_withNativeSize` | 10260 |
+| **Export UI**: `_toast` / `_downloadCanvas` / `_openMenu` | 10573 / 10682 / 10861 |
+| Export registry `registerExportAction` | 10738 |
+| **Embedding API**: `createLocalModel` / `mount` | 11252 / 11308 |
+| **Navigated embed**: `decodeBlocks` / `mountNavigated` | 11563 / 11950 |
 
 > **`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 +148,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 +282,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 +660,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` | 10156 | inverse of `_applyScale`'s `transform:scale()` |
+| `_panelBox` | 10167 | the element whose rect bounds one panel |
+| `_neutralizeView` / `_restoreView` | 10176 / 10201 | transient whole-extent view |
+| `_nativeGeom` / `_nativeGuard` | 10216 / 10235 | native size + why-not message |
+| `_withNativeSize` | 10260 | resize → redraw → run → restore |
+| `_compositeCanvas` | 10284 | the compositor (`_drawEl` / `_drawPanel` …) |
+| `exportCanvas` / `exportPNG` | 10480 / 10539 | 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 +762,13 @@ 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` | 10573 | transient bottom-centre message |
+| `_copyCanvas` | 10608 | clipboard write + feature detection |
+| `_showPngPreview` | 10632 | framed-document download fallback |
+| `_downloadCanvas` | 10682 | `<a download>` or the preview |
+| `registerExportAction` | 10738 | downstream extension point |
+| `_menuRows` / `_openMenu` | 10792 / 10861 | menu model / DOM |
+| `_panelAtPoint` | 10973 | 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
@@ -830,16 +852,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` | 11563 | one base64 `fetch` → one ArrayBuffer → a typed-array view per manifest entry |
+| `dense` | 11589 | `at` / `gather` / `reduce` over a block whose leading axes are the nav axes |
+| `ragged` | 11654 | the same three, over a row-pointer block (`offsets` + one array per column) |
+| `maskFromWidget` | 11737 | rectangle / circle / annulus widget dict → `Uint8Array` (carries `width`/`height`) |
+| `rasterDisks` | 11777 | splat `{x, y, intensity}` rows as filled disks — the base image of a vectors panel |
+| `robustLevels` / `toU8` | 11806 / 11847 | the percentile window and the 8-bit code map, one implementation |
+| `panelAxis` | 11925 | a 1-D panel's decoded x axis (`_1dXArr`, else `x_axis_b64`) |
+| `installTouchShim` / `reportEmbedHeight` | 11862 / 11881 | page chrome: touch → mouse, `postMessage({aplEmbedHeight})` |
+| `encodeBase64` / `typedArrayBytes` | 11901 / 11909 | a 3-D cloud's geometry channel is base64, not the binary side table |
+| `mountNavigated` | 11950 | 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.0}/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.0}/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